Dart类

 一、构造函数

1.默认构造函数

如果不声明构造函数，将为您提供默认构造函数。默认构造函数没有参数，并调用超类中的无参数构造函数

dart不支持重载构造函数，只能有一个构造函数，可以带参数也可以不带参数

2.非默认构造函数不继承

子类不会从其超类继承构造函数。声明没有构造函数的子类只有默认（没有参数，没有名称）构造函数。

3.this

main() {
 Point p= new Point(, );
 print(p.x);
}

class Point {
   num x;
   num y;
   //构造函数可以没有方法体，并且this可以直接在传参时直接对实例赋值
   Point(this.x, this.y);
}

或也可以写成大多数语言通用的方式

  Point(x, y) {
    this.x = x;
    this.y = y;
  }

4.命名构造函数

可以使用自定义的方式命名构造函数

main() {
 Point p= new Point.test(, );
 print(p.x);
}

class Point {
   num x;
   num y;
   Point.test(this.x, this.y);
   Point.test2(this.x, this.y);
}

5.调用非默认超类构造函数

如果父类是带参数的构造或者命名函数，子类需要手动调用父类的构造函数

main() {
  A p =  A(, );
  print(p.x);
}

class Point {
  num x;
  num y;
  Point(this.x){print('class:Point');}
}

class A extends Point {
  num x;
  num y;
  num z;
  A(this.x, this.y) : super(x) {print('class:A');}
}

执行时，会先调用父类的构造

命名构造函数同理

main() {
  A p = A(, , );
  print(p.x);
}

class Point {
  num x;
  num y;
  Point.test1(this.x) {
    print('class:Point1');
  }
  Point.test2(this.x, this.y) {
    print('class:Point2');
  }
}

class A extends Point {
  num x;
  num y;
  num z;
  A(this.x, this.y, this.z) : super.test2(x, y) {
    print('class:A');
  }
}

6.实例化可以省略new关键字

Point p =  Point(, );

7.初始化程序列表

main() {
  var list=[,];
  Point(list);
}

class Point {
  num x;
  num y;
  Point(List list)
      : x = list[],
        y = list[] {
          print(y);
        }
}

8.重定向构造函数

main() {
  Point(,);
}

class Point {
  num x, y;
  Point(this.x, this.y){print(x);}
  //重定向构造函数不能带花括号和内容，
  Point.alongXAxis(num x) : this(x, );
}

9.常量构造函数

如果类生成的对象不会改变，可以使这些对象成为编译时常量

main() {
  Point(, );
}

class Point {
  static final Point a = const Point(, );
  final num x, y;
  const Point(this.x, this.y);
}

10.工厂构造函数

xxx

二、方法和变量

1.get set

void main() {
  Point p = new Point();
  p.setX = ;
  print(p.getX);
}

class Point {
  num _x;
  set setX(num value) {
    _x = value;
  }
  String get getX {
    return 'x is ${_x}';
  }
}

2.简写

void main() {
  Point p = new Point();
  p.setX = ;
  print(p.getX);
}

class Point {
  num _x;
  set setX(num value)=>_x=value;
  String get getX=>'x is ${_x}';
}

3.私有属性和方法

在属性和方法名的开头使用下划线_ 来表示他是私有的。不能被该类以外访问

Dart中没有访问控制符，无论类还是方法默认都是public

4.静态方法

main() {
  A.Test();
}

class A{
 static Test(){
  }
}

5.静态变量

class A {
  //不能改变的值
  static const int i1 = ;
  //因为是静态所以没法在构造函数中赋值，所以和const效果一样？？
   final int i2=;
  //静态变量
  static var i3 = ;
}

5.扩展方法

dart2.7新增功能

main(){
  List list =new List();
  list.test();
}
//给list类添加一个test方法
extension list on List {
    test() {
      print("abc");
  }
}

三、接口

1.dart里没有interface关键字，所有的类默认都能被implement。

被implements 必须实现父类的非静态所有方法和所有属性。

class A {
  int j;
  m() {}
}

class B implements A {
  @override
  int j;
  @override
  m() {
    return null;
  }
}

2.静态属性和方法不需要实现

class A {
  static int j;
  static m() {}
}

class B implements A {}

3.和JAVA一样可以有多个实现

class B implements A1,A2 {}

四、继承

1.和java一样只能是单继承

class A {
  int i;
  m() {
    print('A');
  }
}

class B extends A {
  m() {
    super.m();
  }
}

2.重写

class A {
  int i;
  m() {
    print('A');
  }
}

class B extends A {
  //重写方法
  @override
  m() {
    print('B');
  }
}

五、抽象

抽象类无法被实例化。

 abstract class A {
  int i;
  m() {
    print('A');
  }
}

六、mixins&with&on

https://github.com/dart-lang/language/blob/master/accepted/2.1/super-mixins/feature-specification.md#dart-2-mixin-declarations

Mixins 是在多个类层次结构中重用类代码的一种方式

个人感觉是因为dart不能多继承，而又不想让父类能实力化，并且能直接不需要重写使用父类的方法的情况下出现的新类型

main() {
B b= B();
b.Sound();
}

mixin Extra1 {
  Sound() {
    print('Extra1');
  }
}

mixin Extra2 {
  Sound() {
    print('Extra2');
  }
}

class A {
  Sound() {
    print('A');
  }
}

class B extends A with Extra1, Extra2 {
  Sound() {
    print('B');
  }
}

如果其中方法有重名他的优先级顺序为

本类》mixin  Extra2》mixin  Extra1 》Class B

七、重写操作符

两个点对象相加

class Point {
  num x;
  num y;
  Point(this.x, this.y);
  Point operator +(Point p) {
    return Point(x + p.x, y + p.y);
  }
  print1(){
    print('x:$x,y:$y');
  }
}

void main() {
  Point p1 = new Point(, );
  Point p2 = new Point(, );
  (p1 + p2).print1();
}