一、变量和常量

1.变量 var

dart语言的变量定义与JavaScript定义变量一样的，使用var 关键字。变量没有赋值，默认值为null。

void main(){
 var name = 'amy';
  print(name)
}

1.常量 const final

使用const ,final定义常量时，必须要初始化，否则会报错。定义完之后，不能再重新赋值。

void main(){
  const name = 'amy';
  print(name)
  final age = 18;
  print(age)
}

二、数值型

数值型有int（整型），double（浮点型），dart的数值型的方式和属性与javascript差不多，不过，dart的数值型多了一个‘~/’，相除求整的运算符

1.运算符

+，-，*，/，%，~/
void main(){
  int a = 10;
  double b = 12.3;
  print(a+b);
  print(a-b);
  print(a*b);
  print(a/b);
  print(a~/b);    // 除求整
  print(a%b);
  print(0.0/0.0); //nan
}

2.方法和属性

void main(){
  int a = 10;
  double b = 12.3;
 
  print(a.isEven);
  print(a.isFinite);
  print(a.isInfinite);
  print(a.isNaN);
  print(a.isOdd);

  print(a.abs());
  print(a.ceil());

}

三.字符串

1.字符串定义

字符串定义可以使用单引号，双引号，三引号来定义

void main(){
  var str = 'hello dart';
  var str1 = """hello
                world""";
  var str2 = 'hello \n amy';
  var str3 = r'hello \n amy';

  print(str);
  print(str1);
  print(str2);
  print(str3);
}

注意：
1.三引号定义用于多行字符串的显示，连换行和空格也会打印出来；
2.字符串使用普通方式定义，且中间有转译符，会识别转义符；
3.字符串定义前面加‘r’会把字符串的内容原本输出

2.字符串的运算符

+,* ,==,[]
void main(){
  String str = 'hello dart';
  print(str+'hahha');
  print(str*5);   // 遍历5次连接起来
  print(str[0]);
}

3.字符串插值表达式

+,* ,==,[]
void main(){
  var a =1;
  var b =2;
  print('a+b = ${a+b}');  // 字符串占位符
  print('a = $a');
}

如果有表达式，使用大括号括起来，如果只是一个变量，就直接写$,

4.字符串的属性和方法

void main(){
  String str = 'hello dart';

  print(str.trim());
  print(str.padLeft(20,'a'));// 在字符串的左边补指定字符串（默认为空格）

  print(str.length);
  print(str.isEmpty);
}

属性，方法有很多，可以到官网或源码看看，这里就不一一列举了。

5.布尔型

布尔型就两种，false和true

void main(){
  bool isFalse = false;
  bool isTrue = true;
  print(isFalse);
  print(isTrue);
}

6.List型（Array）

1.List的定义

void main(){
  var list = [1,2,3,'22'];        
  var list1 = const [4,5,6];
  var list2 = new List();
}

使用const定义的list，不可修改

2.LIST的方法属性

属性：主要有[],length等
方法：add(),insert(),remove(),clear()等
方法太多了，不想写了

7.Map型

8.dynamic型

与JavaScript不同的地方
1.算术运算符??

void main(){
  var aa;
  var bb = 'js';
  print(aa??bb);
}
如果aa没有值，值就为bb，如果aa有值，结果就为aa

2.switch--case 的continue 跳转标签

void main(){
  var aa = 'dart';
  switch(aa){
    D:
    case 'dart':
      print('dart');
      break;
    case 'js':
      print('js');
      continue D;
    case 'python':
      print('python');
      break;
  }
}
打印出来:
js
dart

8.函数

（1）可选参数为对象

void main(List argc){
print(printPeople('amy',age:18));
  print(printPeople('amy',age:18));
}
printPeople(String name,{int age,String genger}){
  return 'I am $name,$age,$genger';
}

函数的可选参数为对象时，如果函数调用使用可选参数，必选填写参数名

（2）可选参数为数组

printPeople1(String name,[int age,String genger]){
  return 'I am $name,$age,$genger';
}
void main(List argc){
 print(printPeople1('amy'));
  print(printPeople1('amy',16,'女'));
}

可选参数为数组时，调用函数使用可选函数，直接写入对应下标的值就可以。
（3）可选参数设置默认值

printPeople2(String name,{int age = 30,String genger = 'male'}){
  return 'I am $name,$age,$genger';
}
void main(List argc){
  print(printPeople2('amy'));
  print(printPeople2('amy',genger:'famale'));
}

重新赋值会把默认值覆盖，没有赋值就为默认数据。

9.类

void main(List argc){

  var person = new Person();
  person.name='amy';
  person.age=18;
  print(person.name);
  person.say();
}

class Person{
  String name;
  int age;
  final String father = 'bab'; // final 定义的变量没有setter方法，只能getter
  void say(){
    print('hi,我可以说话');
  }
  // void say(int age){           // 方法不能重载
  //   print('hi,我可以说话');
  // }
}

（1）类的声明使用class
（2）类的创建使用new ,new 可省
（3）类中定义的实例变量都有getter和setter属性，但是final声明的变量只有getter.，没有setter.
(4) 方法不能重构

10 .类的计算属性

void main(){
  var rect = new Rectangle();
  rect.width=10;
  rect.height=20;
  print(rect.getRect());
  print(rect.area);
  rect.area = 200;
  print(rect.width);
  
}
class Rectangle{
  num width,height;
  num getRect(){
    return width*height;
  }
  num get area=> width*height;
      set area(value){
        width = value/2;
      }
}

计算属性首先声明类型 ，然后一个get/set 再定义计算属性的名称，ok，看上面代码

11.构造函数

1.默认构造函数

定义类对象的时候，如果不写构造函数，默认会有一个构造函数

void main(){
  print('hello world');
  var people = new People();
  people.name='amy';
  people.age=18;
  print(people.name);
}

class People {
  String name;
  int age;
  People(){}
  final String gender = '男';
}

2.重写构造函数

void main(){
  print('hello world');
  var people = new People('amy',18);
  print(people.name);
}

class People {
  String name;
  int age;
  final String gender = '男';
  People(String name,int age){
    this.name = name;
    this.age = age;
  }
}

3.构造函数的语法糖

void main(){
  print('hello world');
  var people = new People('amy',18);
  print(people.name);
}

class People {
  String name;
  int age;
  final String gender = '男';
  People(this.name,this.age);
}

4.具名构造函数（重构）

void main(){
  print('hello world');
  var people = new People('amy',18);
  new People.withName('ye');
  var age = new People.withAge(18);
  print(people.name);
  print(age.age);
}

class People {
  String name;
  int age;
  final String gender = '男';
  People(this.name,this.age);
  People.withName(this.name);
  People.withAge(this.age);
}

12.常量构造函数

void main(){
  var people = [new] [const] People('amy',18);
  print(people.age);
}

class People {
  final String name;
  final int age;
  const People(this.name,this.age);
}

常量构造函数：
（1）类的定义必须使用final；
（2）类的构造函数使用const 声明；
（3）new 类对象时const可以省略

13.工厂构造函数

void main(){
  var people = new People('amy',18);
  print(people.name);
}

class People {
  String name;
  int age;
  factory People(String name,int age){
    if(name!=null){
      return People._withName(name);
    }else{
      return People._withAge(age);
    }
      
  }
  People._withName(this.name);
  People._withAge(this.age);
}

普通的构造函数是不能有返回值的，但是使用factor来定义的工厂构造函数是可以有返回值；

14.初始化列表

void main(){
  var people = new People('amy',18);
  Map map = {'name':'胖金妹','age':1,'gender':'女'};
  
  var pp = new People.withMap(map);
  print(pp.name);
  print(people.name);
}

class People {
  String name;
  int age;
  String gender = 'nv';
  People(this.name,this.age);
  People.withMap(Map map):name = map['name'],age=map['age']{
    this.gender = map['gender'];
  }
}

15.静态成员

void main(){
  var people = new People();
  People.scrollDown();
  people.scrollUp();
 
}

class People {
  // 类中的常量必须使用static定义
  static  const int maxPage = 10;
  // 静态变量，
  static int currentPage = 0;
  // 静态方法，实例不能直接调用，使用类调用
  static void scrollDown(){
    currentPage ++;
    print('scrolldown');
  }
  void scrollUp(){
    currentPage--;
    print('scrollUp');
  }
}

（1）定义类中的静态变量和静态方法，使用static关键字
（2）静态成员不能访问非静态成员，非静态成员可以访问静态成员
（3）类中的常量需要使用static const 声明

16 对象操作符

1、.?条件成员访问

void main(){
  People people = new People();
  people?.work(); // 条件成员访问
}

class People {
 String name;
 int age;
 void work(){
   print('work');
 }
}

当不确定返回对象是否为空时，使用条件成员访问来判断

2、.as类型的转换

void main(){
  var people;
  people ='';
  people = new People();
  (people as People).work(); // 类型的转换
  
}

class People {
 String name;
 int age;
 void work(){
   print('work');
 }
}

3、?,?!判断符

void main(){
  var people;
  people ='';
  people = new People();
  if(people is People){
    print('true');
    people.work();
  }
  if(people is! People){
    print('false');

  }
}

class People {
 String name;
 int age;
 void work(){
   print('work');
 }
}

使用?判断左边的实例是否是右边的类型。

4、..级联运算符

void main(){
 var people = new People();
  people..name='amy'..age=18;
  print(people.name);
}

class People {
 String name;
 int age;
 void work(){
   print('work');
 }
}

17call方法的使用

void main(){
 var people = new People();
  people..name='amy'..age=18;
  print(people.name);
  people(); //对象作为方法来使用
}

class People {
 String name;
 int age;

  void call(){
    print('name:$name,age:$age');
  }
}

call 方法定义，可以使实例对象作为一个方法来使用

void main(){
 var people = new People();
  people..name='amy'..age=18;
  print(people.name);
  people('tom',1); //对象作为方法来使用
}

class People {
 String name;
 int age;

 void call(String name,int age){
   print('name:$name,age:$age');
 }
}

如果call方法声明了形参，调用实例对象时，也要传入对应的参数

18.类的继承

// people.dart
void main(){
 var people = new People();
}

class People {
 String name;
 int age;
 String _address;
 bool get isAdult=> age>18;
 void run (){
   print('people run');
 } 
}



// student.dart
import 'people.dart';
void main() {
  var student = new Student();
  student.study();
  student.name='amy';
  student.age=12;
  // student._address = 'ddd';// 不能继承父类的私有属性
  print(student.isAdult);
  student.run();
}
class Student extends People{
  void study(){
    print('student study');
  }
  void run(){  // 重写父类的方法
    print('student run');
  }
  @override  // 重写父类的计算属性
  // TODO: implement isAdult
  bool get isAdult => this.age>16;
}

dart的继承与其他语言的差不多，
（1）使用extends关键字实现继承
（2）子类可以继承父类的可见属性和方法
（3）子类可以重写父类的方法，getter，setter方法。

19.继承中的构造方法

1.子类的构造方法会调用父类的无名无参的构造方法

void main(){
 var stu = new Student();
}

class People {
 String name;
 int age;
 People(){
   print('People');
 }
 void run (){
   print('people run');
 } 
}

class Student extends People{
  void study(){
    print('student study');
  }
}

//编译结果：People

子类的构造方法调用父类的无名有参的构造方法

void main(){
 var stu = new Student('amy');
 print(stu.name);
}

class People {
 String name;
 int age;
 People(this.name);
}

class Student extends People{
  Student(String name) : super(name);
  void study(){
    print('student study');
  }
}

2.子类的构造方法调用父类有参有名的构造方法

void main(){
 var stu = new Student(16);
 print(stu.age);
}

class People {
 String name;
 int age;
 People(this.name);
 People.withAge(this.age);
 
}

class Student extends People{
  Student(int age) : super.withAge(age); // 初始化列表

  void study(){
    print('student study');
  }
}

如果父类的构造方法中不仅有无名构造方法，也有具有构造方法，在子类实现继承的时候，可以通过选择

20.抽象类

void main(){
  var stu = new Student();
  stu.run();
}

abstract class People {
 void run(){}
}

class Student extends People{
    void run(){
      print('重写抽象类的方法');
    }
}

（1）抽象类通过abstract 关键字来创建
（2）抽象类不能通过new表达式实现实例化；
（3）通过子类继承抽象类来实现抽象类的方法和属性；
（4）抽象类的方法前面不需要abstract修饰，抽象类的方法可以为空；

21.接口

void main(){
  var stu = new Student();
  stu.run();
}

abstract class People {
 void run(){}
}

class Student implements People{
    void run(){
      print('重写抽象类的方法');
    }
}

（1）接口会重新类的所有属性和方法，可以是任意的类

22.Mixins 实现多继承

void main(){
  var d = new D();
  d.a();
  d.b();
  d.c();
  d.d();
}

class A{
  void a(){
    print('A --a');
  }
}

class B{
  void b(){
    print('B--b');
  }
}

class C{
  void c(){
    print('C--c');
  }
}
//  mixins 实现类似多继承的效果
class D extends A with B,C{
  void d(){
    print('d--d');
  }
}

void main(){
  var d = new D();
  d.a();    // B--a
}

class A{
  void a(){
    print('A --a');
  }
}

class B{
  void a(){
    print('B --a');
  }
  void b(){
    print('B--b');
  }
}

class C{
  void a(){
    print('C --a');
  }
  void b(){
    print('C--b');
  }
  void c(){
    print('C--c');
  }
}
//  mixins 实现类似多继承的效果
class D extends A with C,B{
   
  void d(){
    print('D--d');
  }
}


如果多个类中有相同的方法，调用的是最后一个类方法

注意：
（1）Mixins类似于多继承，是在多继承中重用一个类代码的方法‘
（2）作为Mixins的类不能有显性声明构造方法
（3）作为Mixins的类只能继承自Object
（4）使用关键字with连接一个或多个Mixins

综合的案例：

void main(){
  var car = new Car();
  var bus = new Bus();
  car.work();
  bus.work();
}

abstract class Engine{
  void work();
}
class OilEngine implements Engine{
  void work(){
    print('烧油引擎');
  }
}
class ElectricEngine implements Engine{
  void work(){
    print('烧电引擎');
  }
}

class Tyre{
  String name;
  void run(){
    print('跑起来啦');
  }
}

class Car = Tyre with ElectricEngine;
class Bus = Tyre with OilEngine;
// 不同的写法
[class Car extends Tyre with OilEngine{}]

23.dart的枚举

void main(){
  var currentSeason = Season.autumn;
  switch(currentSeason){
    case Season.spring:
      print('1-3月');
      break;
    case Season.summer:
      print('4-6月');
      break;
    case Season.autumn:
      print('7-9月');
      break;
    case Season.winter:
      print('10-12月');
      break;
  }
}

enum Season{
  spring,
  summer,
  autumn,
  winter
}

（1）index从0开始，依次累加
（2）不能指定原始值
（3）不能添加方法

24.泛型

dart中类型是可选的，可使用泛型限定类型

void main(){
  var list = new List<int>();
  list.add(1);
  print(list);  
}

类的泛型

void main(){
  var utilsInt = new Units<int>();
  utilsInt.put(1);
  var utilsStr = new Units<String>();
  utilsStr.put('amy');
}
class Units<T>{
  T element;
  void put(T element){
    this.element = element;
  }
}

方法的泛型

void main(){
  var units = new Units();
  units.put<int>(2);
  
}
class Units{
  
  void put<T>(T element){
    print(element);
  }
}