Dart基础语法

变量类型

1.var

//类型推导，声明一个整形变量，其值可变
var age = 21;
1
2

2.const

//类型推导，声明一个字符串常量，其值不可变
const name = 'abc';
1
2

3.final

//类型推导，声明一个bool常量，其值不可变
const name = false;
1
2

4.const和final的相同点和不同点

相同点
1、final、const必须初始化
2、 final、const只能赋值一次
1
2
3

不同点
1、 final可修饰实例变量、const不可以修饰实例变量
2、访问类中const修饰的变量需要static修饰
3、const修饰的List集合任意索引不可修改，final修饰的可以修改
4、const 用来修饰变量 只能被赋值一次，在编译时赋值
5、final 用来修饰变量 只能被赋值一次，在运行时赋值
6、final 只可用来修饰变量， const 关键字即可修饰变量也可用来修饰 常量构造函数
1
2
3
4
5
6
7

赋值操作

普通赋值

类型自动推到机制，定义了一个String类型变量name

var name = 'liszt';
1

??=运算符

??=运算符的含义：如果变量name已经有了初始值，不为空，则不执行??=，反之，将后续值赋值给变量，此处输出liszt，类似>=运算符

var name = 'liszt';
name ??= 'franz';
1
2

??运算符

??运算符的含义：如果变量name不为空，则将name的值赋值给变量temp，反之将franz赋值给temp;类似三目运算符

var name = 'liszt';
var temp = name ?? 'franz';
1
2

类

普通类声明

class person{
int age;
person(this.age);
}
1
2
3
4

命名构造函数

Class person{
String name;
int age;
double height;

person(this.name,this.age);
//命名构造函数，名字自定义
person.addHeight(this.name,this.age,this.height);
}
1
2
3
4
5
6
7
8
9

var man = person.addHeight('liszt',22,173.0);
1

类的初始化列表

class person{
 final String name;
 final int age;
 person(this.name{int age}):this.age = age ?? 22{
 
 }
}
1
2
3
4
5
6
7

构造函数的重定向

class person {
 String name;
 int age;
 person(String name):this.inner(name,0);
 person.inner(this.name,this.age);
}
1
2
3
4
5
6

类的set和get

class person{
 String name;
 int age;
 
 set setName(String name){
 this.name = name;
 }
 
 String get getName{
 return this.name;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12

类的继承

class shape{
 double width;
 double height;
 shape(this.width,this.height);
}


class ring extends shape{
 String name;
 ring(this.name,double width,double height):super(width,height);
}
1
2
3
4
5
6
7
8
9
10
11

类的混入

void main(){
  var man = superMan();
  man.fly();
  man.run();
}

mixin flyAct{
  void fly(){
    print('fly');
  }
}

mixin runAct{
  void run(){
    print('run');
  }
}

class superMan with flyAct,runAct{

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

集合类型

1.列表List

var names = ['abc','def','aaa'];
1

2.集合Set

元素不可重复

var names = {'aaa','bbb','ccc'};
1

3.映射Map

var info = {
"name" = "liszt",
"age" = 22
};
1
2
3
4

函数

必传参数

void printName(String name){
printf(name);
}
1
2
3

位置可选参数

其中name参数必须传，后面俩个参数可传可不传，但是如果要传的话，实参和形参对应位置必须一致

void printInfo(String name,[int age,String sex]){

}
1
2
3

命名可选参数

其中name参数必须传，后面俩个参数可传可不传，如果要传，位置不一定要和形参一致，但是必须加形参名称，如下所示：

printInfo('liszt',age : 10);
1

void printInfo(String name,{int age,String sex}){

}
1
2
3

参数默认值

可选参数可以拥有默认值

void printInfo(String name,{int age = 10,String sex = ‘male’}){

}
1
2
3

函数做为一等公民+匿名函数

main() {
  printResult((result){
    print(result);
  });
}

int sum(int a,int b)=> a+b;

void printResult(Function(int) func){
  func(sum(10, 20));
}
1
2
3
4
5
6
7
8
9
10
11

箭头函数

当函数体只有一行代码的时候可以使用箭头

int sum(int a,int b) => a+b;
1

typedef用法

void printInfo(int fun(String name,int age)){

}
1
2
3

typedef infos = int Function(String name,int age);

void printInfo(infos info){
 info('liszt',22);
}
1
2
3
4
5

级联运算符

类似责任链设计模式

//quote
var man = person()
          ..name = 'liszt'
          ..age = 22
          ..eat();
          
Class person{
String name;
int age;
void eat(){
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13

Object和dynamic的区别

1.object调用方法时，编译器会报错

2.dynamic调用方法时，编译器不会报错，但是会存在安全隐患
1
2
3

库的导入

导入系统文件

import 'dart:math';
1

导入自定义文件

document A:
int sum(int a,int b) => a+b;
double div(int a,int b) =>  a/b;

suppose document B want to use methon in document A:

import 'test_two.dart';

main(){
  print(sum(10, 20));
}
1
2
3
4
5
6
7
8
9
10
11

3.导入文件中的函数与当前文件函数重名

可以使用as取一个别名

import 'test_two.dart' as diyMath;

main(){
  print(diyMath.sum(10, 20));
}

void sum(int a,int b){
  
}
1
2
3
4
5
6
7
8
9

4.当只想引用部分函数时

import 'test_two.dart' as diyMath show sum;

main(){
  print(diyMath.sum(10, 20));
}

void sum(int a,int b){

}
1
2
3
4
5
6
7
8
9

5.当想被引用文件的函数不需要时

//则文件中的sum函数不能被调用
import 'test_two.dart' as diyMath hide sum;
1
2

导入第三方库

以导入Dio库为例，打开pubspec.yaml文件，并在dependencies下添加如下语句

//添加依赖
dio: ^4.0.0
1
2

随后只需在需要引用的文件添加如下语句

import 'package:dio/dio.dart';
1