变量类型

1.var

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

2.const

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

3.final

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

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

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

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

赋值操作

普通赋值

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

var name = 'liszt';

??=运算符

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

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

??运算符

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

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

类

普通类声明

class person{
int age;
person(this.age);
}

命名构造函数

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

person(this.name,this.age);
//命名构造函数，名字自定义
person.addHeight(this.name,this.age,this.height);
}

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

类的初始化列表

class person{
 final String name;
 final int age;
 person(this.name{int age}):this.age = age ?? 22{
 
 }
}

构造函数的重定向

class person {
 String name;
 int age;
 person(String name):this.inner(name,0);
 person.inner(this.name,this.age);
}

类的set和get

class person{
 String name;
 int age;
 
 set setName(String name){
 this.name = name;
 }
 
 String get getName{
 return this.name;
 }
}

类的继承

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);
}

类的混入

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.列表List

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

2.集合Set

元素不可重复

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

3.映射Map

var info = {
"name" = "liszt",
"age" = 22
};

函数

必传参数

void printName(String name){
printf(name);
}

位置可选参数

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

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

}

命名可选参数

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

printInfo('liszt',age : 10);

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

}

参数默认值

可选参数可以拥有默认值

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

}

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

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

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

void printResult(Function(int) func){
  func(sum(10, 20));
}

箭头函数

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

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

typedef用法

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

}

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

void printInfo(infos info){
 info('liszt',22);
}

级联运算符

类似责任链设计模式

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

}

Object和dynamic的区别

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

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

库的导入

导入系统文件

import 'dart:math';

导入自定义文件

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));
}

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

可以使用as取一个别名

import 'test_two.dart' as diyMath;

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

void sum(int a,int b){
  
}

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

import 'test_two.dart' as diyMath show sum;

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

void sum(int a,int b){

}

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

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

导入第三方库

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

//添加依赖
dio: ^4.0.0

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

import 'package:dio/dio.dart';

Dart基础语法

Dart语法