Dart语言基础学习

原创已于 2023-08-28 12:11:47 修改 · 987 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#fullter语言基础 #dart

于 2019-11-05 11:16:12 首次发布

Fullter 专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍了Dart语言的基础知识，包括常量、变量、数据类型如num、String、bool、List、Map，以及运算符、控制语句、函数、面向对象特性如类与对象、继承、抽象类、接口、Mixins等，同时涵盖了枚举和泛型等内容，适合初学者入门。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、常量、变量

1、变量

Dart语言中Object是所有的基类，所有未初始化的对象都是Object，不同于java的八大基本数据类型。

//声明变量时初始化，那么该变量可以是任何类型
var  a;     
a=1;        
a="123";      

//Object是基类，Object变量可以是任何类型
Object a=1;
a="as";

//显示类型声明
int  a;                  
a=100；

//当定义变量时指定了类型，那么就不能赋值给其他类型数据
int a=1;
a="123";                  error

//dynamic  和Object差不多，只是在运行时确定数据类型

2、常量

final和coast定义的常量在申明时就得初始化，且不能改变

//final运行时常量
final a=30;
a=10;                   //error
         
//const编译时常量    
const  a=1；

final a=1;
const b=a+1;           //error，final是运行时常量，而const是编译时常量

二、数据类型

Dart语言支持的数据类型num，string，boolean，list，map，runes，symbols等数据类型

1、num表示数值型，子类只有：int(整型)，double(浮点型)

（1）使用num声明的类型既可以接收整型，也可以接收浮点型

num a=10;    //int
a=12.5;      //double

（2）使用int声明整型

int a=10;

a=10.0;      //报错error

（3）使用double声明浮点型

double  f=10.0;

(4)常用属性和方法

int  a=20;
a.isEven;   //是否偶数
a.isOdd;    //是否奇数
a.abs();    //绝对值
a.toDouble();  //转换为浮点型
...

int b = 10.5;
b.toInt();//转换为整型
b.round(); //四舍五入，11
b.floor(); //不大于b的最大整数，10
b.ceil(); //不小于b的最小整数，11
...

2、字符串String

（1）使用单引号或双引号创建字符串

String  str='123'
String  str1="hello"

（2）使用三个单引号或三个双引号创建多行字符创

string str1='''hello  
               world'''               //三个双引号会换行
String str2='hello  \n  world'       //"\n"会转义，实现换行

（3）使用r（raw）创建原始字符串，"\"不会被转义

string str=r'hell0 \n world'        /"\n"不会被转义

（4）插值表达式 ,使用${ }表示插值表达式，单个变量可省略{ }

int  a=1；
int b=2;
print("a+b=${a+b}");

（5）字符串的操作（+，*，==，[]）

string  str1='hello'
string  str2='world'

print(str1+str2)     //helloworld   
print(str1*2)        //hellohello   *h后面是int类型，表示几倍的意思
print(str1==str2)    //false
print(str1[0])       //h,取下标元素

（6）常用属性和方法

str.length;//字符串长度
str.isEmpty;//是否为空
...

str.contains('xxx');//是否包含xxx
str.substring(0,3);//截取前三个字符
str.startsWith('xxx‘);//是否以xxx开头
str.split(",");//以,分隔字符串，返回数组
...

3、布尔类型，使用bool表示布尔型，值为：true和false

bool isTrue=true;
bool isFalse=false;

4、列表，使用List表示列表，它和数组式同一概念

（1）创建List，可变和不可变

//可变数据类型不一样的集合
var  list=[1,2,3,'dart',false]    //数据类型可以不一样，可改变元素
list[0]='hello'
print(list)                       //1,2,3,'hello',false

//使用类创建List
var list2=new List();
list2.add(1);
list2.add('dart');

//使用const关键字修饰对象   创建不可变的List
var  list2=const [1,2,3,"dart"];   //const修饰的对象不可变，但是变量可以执行其他对象
list2.add(1234);                   //error
list2=[1,2,3,4];                   //可以


const list3=[1,2,3];               //变量和对象都不可变
list3.add(1234);                   //error
list3=[1,2,3,4];                   //error

（2）常用属性和方法

var  list=new List();

list.length;   //获取元素个数
list.isEmpty; 
list.isNotEmpty; //判断是否为空
list[index];     //获取元素，index是下标
list.add("");    //添加元素
list.insert(index,"");   在下标位置添加元素
list.remove("")  //删除元素
list.clear();    //清空list
list.indexOf('xxx');//查询元素xxx,返回下标，不存在返回-1
list.sort(); //排序
list.subList(start,end);//获取从子列表
list.forEach(); //遍历list
...

5、键值对Map

(1)map的创建

//不同类型，可变map
var  map1= {'first':'dart',1:true,true:false}      //键值可以是不同的类型，值可以改变
map1['first']=1          //通过键修改
map1[1]='change'

//使用类创建
var map2=new Map();
map2.put('first','data');
map2.put(1,false);

//不可变Map
var  map2=const  {’first‘:‘dart’ ,'second':'java'}  //不可变map

（2）常用属性和方法

var  map=new Map();

map.length;          //获取元素个数
map.isEmpty;         
map.isNotEmpty;      //判断是否为空
map['third'] = 'JavaScript'; //添加key为thrid,value为JavaScript的元素
map.remove('third'); //删除key为third的元素
map.clear(); //清空map
map['first'] = 'C++'; //修改key为first的value为C++
map['first'];//获取key为first的value
map.keys; //获取map所有的key
map.values; //获取map所有的value
map.containsKey('first'); //map是否包含key为first的元素
map.containsValue('Java'); //map是否包含value为Java的元素
map.forEach(); //遍历map
...

6、动态类型 dynamic

dynamic  b=20;
b="javaScript"
var list=new List<dynamic>();   //类似泛型

7、Runes和Symbols

三、运算符

1、计算运算符（+，-，*，/(除，结果为浮点型),~/(除取整)，%（求余）， a++,++a，a--,--a）

num  a=3；
num  b=10；

print(b/a)        //3.3333
print(b~/a)       //3
print(b%a)        //1
print(a++)        //3  先使用a的值进行打印，再加1  这时候a为3
print(++a)        //4  先对a进行加1，再打印

2、关系运算符（==（只是判断内容是否相同，类似java的equals），!=,>,<,>=,<=）

int a=10
int b=10
string  str1='hello'
string  str2='world'
stirng  str3='hello'

print(a==b)           //false   比较的是值大小
print(str1==str2)    //false
print(str1==str3)    //true

3、逻辑运算符（!，&&，||）

bool  isTrue=true;
bool isFalse=false;
print(!isTrue);             //false
print(isTrue && isFalse)    //false
print(isTrue || isFalse)    //true

String  str="";
print(!str.isEmpty);        //false

4、赋值运算符（=,??=(表示左侧变量为空时进行复赋值，否则不赋值),+=,-=,*=,/=,%=,~/=）

int a=10;
int b;
 
b??=10;               //如果b为null则用右边的值，否则用自己的值
print(b);             //10
a+=2;
print(a);             //12

5、条件运算符

三目运算符:condition ? expr1 : exppr2

？？运算符: expr1 ?? expr2 如果expr1位null，则使用expr2的结果，否则使用expr1

int a=10;
str str=gender==0 ? "male=$a" : "Female=$a"；
print(str)；    //feFemale=10

string a;
stirng b="java"
string c=a ?? b;  
print(c);     //java    先判断a是否为空，不为空，把a赋值给c，如果为空，则把b赋值给c

6、安全操作符(?.)

？.操作符，左边对象为null，则返回null，不再进行下面的操作

String sb;

print(sb.length);        //空指针
print(sb?.length);       //null

7、级联操作符（..）

类似java中的建造者模式，可以链式调用

var sb = new StringBuffer();
sb..write('foo')..write('bar');

四、控制语句

1、if语句

if(condition1){
	//...
	if(condition2){
		//...
	}
} else if(condition3){
	//...
} else {
	//...
}

2、for语句

for循环

for...in

var list=[1,2,3,4,5];

for(int index=0;i<list.length;index++){
  print(list[index]);
}

for(var item in list){
  print(item);
}

3、while语句

while

do....while

int count=0;
while(count<5){
  print(count++);      //0,1,2,3,4
}

do{
  print(count--)
}while(count > 0)

4、break,continue

break，终止当前循环

continue 跳出当前循环，继续下一次循环

5、 switch语句

switch语句支持num，string，编译器常量，对象和枚举

String str="dart";
switch(str){
  case "Dart"
      print("aa");
      break;
 case "dart"
      print("bb");
      break;
  default:
     print("cc");
}

支持使用continue跳转标签

String str="dart";
switch(str){
  Test:
  case "Dart"
      print("aa");
      break;
 case "dart"
      print("bb");
      continue Test;
  default:
     print("cc");
}
// bb    aa

6、assert语句

assert条件表达式为false时会抛出异常

assert(str!=null);

五、函数

1、方法声明

Function fun=返回类型函数名称（参数）{

函数体

return 返回值 //如果没有指定返回类型，可以不写return 默认返回null

}

void  add(int a,int b){
   print(a+b);
}

2、参数

参数	必须参数（不可以有默认值）
	可选参数（可以有默认值）	位置可选参数. [int age,String name="张三"]
		命名可选参数 {int age=19, String name="李四"}

//可选命名参数
printText(String  name,{int age,String gender}){
  print("name=$name,age=$age,gender=$gender")
}
//调用
printText("张");               //name=张,age=null,gender=null
printtext("网",age:20,gender:"male")
printtext("网",gender:"male")


//可选位置参数
printStr(String  name,[int age,String gender]){
  print("name=$name,age=$age,gender=$gender")
}
//调用
printStr("张");               //name=张,age=null,gender=null
printStr("网",20);
printStr("网",20,"方");

3、方法对象

Dart中一切都是对象

方法可作为对象赋值给其他变量

方法可作为参数传递给其他方法

//方法赋值给其他变量
void  printText(){
  print("hello")
}
var func=printText;
func();h
或
Function  func=printText；
func();


//方法作为参数
String times(str){
  return str*3;
}

List listTimes(List list,String times(str)){
  for(var index=0;i<list.length;index++){
   list[index]=times(list[index]);
  }
  return list;
}

var list=[1,2,3,4];
print(listTimes(list2,times));

4、匿名方法

匿名方法没有具体的名称，和方法有相同的特性，也是对象，也可作为变量赋值和参数传递。

1、匿名方法申明

（参数）{

函数体...

return 返回值

}

//匿名方法赋值
var func=（str）{
    print("hello————$str")
}
func("aaa");

//匿名方法作为参数
List listTimes(List list,String times(str)){
  for(var index=0;i<list.length;index++){
   list[index]=times(list[index]);
  }
  return list;
}

var list=[1,2,3,4];
listTimes(list2,(str){return str*3});

5、闭包

闭包是一个方法

闭包定义在其他方法(假设为A)内部，A方法要返回闭包

闭包能够访问外部方法内的局部变量，并持有其状态（可以通过闭包的方法将其暴露出去，提供给外部访问）

//该方法返回一个闭包
makeAge(int initAge){
  return (int age){
     return age+initAge;     
  };
}

//闭包的访问可以访问局部变量
var func=makeAge(3);
func(12);

六、面向对象

1、类与对象

使用关键字class声明一个类

使用关键字new创建一个对象，new可省略

所有类都继承Object类

void  main(){
    var person=new person();
     
    person.name="time";
    person.work();
}

//定义类
class person{
     String  name;
     int age;
     
     void work(){
      print("我是方法");
    }
}

2、属性与方法

属性默认会生成getter和setter方法,final声明的属性只有getter方法

可见属性和方法通过点.访问

方法不能被重载

//定义类
class person{
     String  name;
     int _age;    //私有属性
     
     void work(){
      print("我是方法");
    }
}

3、类及成员可见性

Dart中的可见性以library(库)为单位

默认情况下，每一个Dart文件就是一个库

使用下划线表示库的私有性

使用import导入库

4、计算属性

计算属性的值是通过计算而来，本身不存储值，使用get，set关键字

void main(){
   var rect=new Rectangle();
   rect.height=20;
   rect.width=10;
   print(rect.area);    //200
}


class  Rectangle{
  num  width,height;
  num  get area=>width*height;
       set area(value){
        width=value/2;
       }
}

5、构造方法

构造函数不能重载	无返回值无return，可以使用this	默认构造函数	不定义构造函数。系统默认构造函数
		常规构造函数	Person（this.age，this.name）；
		命名构造函数	Person.name（this.name）；
		常量构造函数	const Person（this.age，this.name）;
		重定向构造函数	Person(String name):Person.name(this.name);
	return 返回值无this	工厂构造函数	factory Person.age(int)

class  Person{
  String name;
  int age;
  
  Person(String name,int age){
     this.name=name;
     this.age=age;             =====>  Person(this.name,this.age);
   }

 
  Person.withName(String name){
       this.name=name;         ======> Person.withName(this.name);
  }
}

6、常量构造方法

如果类是不可变状态，可以把对象定义为编译时常量

使用const声明构造方法，并且所有变量都为final

使用const声明对象，可以省略

void main(){
 const person=const Person("tom",12)
}

class Person{
   final String name;
   final int age

  const Person(String name,int age){
     this.name=name;
     this.age=age;
   }
}

7、工厂构造方法

工厂构造方法类似于设计模式中的工厂模式

在构造方法前添加关键字factory实现一个工厂构造方法

在工厂构造方法中可返回对象

class  Person{

 String name;
 Person.withName(this.name);
 factory  Person(String name){
    return Person.withName("ceshi");
   }
}

8、初始化列表

初始化列表会在构造方法体执行之前执行

使用逗号分隔初始化表达式

初始化列表常用于设置final变量的值

9、静态成员static

使用static关键字来实现类级别的变量和函数

静态成员不能访问非静态成员，非静态成员可以访问静态成员

类中常量需要使用static const声明

10、对象操作符（？.条件成员访问，类型转换as，是否制定类型is,is!,级联操作..）

Person person;
person?.work();   //条件运算符，如果person为空，怎不往后面运行了

var person;
person="";
person=new Person();
if(person is Person){
  (person as Person).work();
}

//有点类似build
var person=new Person();
person..name="time"
      ..age=20
      ..work();

11、对象call方法

如果类实现了call()方法，则该类的对象可以作为方法使用

class  Person{
  String name;
  void call(){
    print("Name is $name");
  }

}

void  main(){
  var perspn=new Person();
  person();  // 对象直接当成方法来执行
 
}

12、继承

使用关键字extends继承一个类

子类会继承父类可见的属性和方法，不会继承构造方法

子类能够复写父类的方法，getter和setter

单继承，多态

class  Person{
   String name;
   int _age;   //私有的属性，子类不能使用
}

class Student extends Person{

}

13、继承中的构造方法

子类的构造方法默认会调用父类的无名无参构造方法

如果父类没有无名无参构造方法，则需要显示调用父类构造方法

在构造方法参数后使用：显示调用父类构造方法

class   Person{
   String name;

   Person(this.name);
   Person.withName(this.name);
}


class Student extends Person{

  Student(String name) :super(name);
  Student(String name):super.withName(name);

}

14、构造方法的执行顺序

父类的构造方法在子类构造方法体开始执行的位置调用

如果有初始化列表，初始化列表会在父类构造方法之前执行

class Student extends  Person{
   int age;
   final String gender;

    Student(String name,String g)：gender=g,super.withName(name,gender);
}

15、抽象类

抽象类使用abstract表示，不能实例化

抽象方法不用abstract修饰，只要无实现就行

abstract  calss  Person{

   void  run();//抽象方法
}

抽象类可以没有抽象方法

有抽象方法的类一定得声明为抽象类

16、接口

类和接口是统一的，类就是接口

每个类都隐式的定义了一个包含所有实例成员的接口

class  Person{

   String name;
   
}

class Student implements Person{

}

17、Mixins

MIxins类似于多继承，是在多继承中重用一个类代码的方式

class  A{
}
class B{
}
class C{
}

class D extends A with B,C{

}

作为Mixin的类不能有显示声明构造方法

作为mixin的类只能继承于Object

使用关键字with，连接多个mixin类，永用逗号分隔

18、操作符覆写

覆写操作符需要在类中定义

返回类型 operator 操作符（参数1，操作2...）{

实现体...

return 返回值

}

19、枚举

枚举是一种又穷序列集的数据类型

使用关机子enum定义一个枚举

常用于代替常量，控制语句

enum Season{
   spring,
   summer,
   autumn,
   winter
}

//使用
var currentSeason=Season.spring;

枚举属性，有下标，从0开始

不能指定原始值

不能添加方法

20、泛型