Dart的基本语法之类

类构造方法

命名构造和继承父类构造方法

void main(){
	print(Child(3,2)); /输出a=3 b=2,已经赋值给了父类里面的两个变量。
}
class Child extends Parent {
  int c;
  int d;

  Child(num a, num b)
      : c = a,
        d = b,
        super(a, b) {
    print('子类构造函数');
  }
  
  Child.fromMap(Map map) : super.fromMap(map) {
    print('子类命名构造函数');
  }
  
  Child.redirect(num a) : super.redirect(a) {}
}

//父类
class Parent {
  int a;
  int b;

  Parent(this.a, this.b);
  
	/命名构造函数
  Parent.fromMap(Map map) {
    this.a = map['a'];
    b = map['b'];
  }
  
	/重定向构造函数，通过冒号来调用其它构造函数
  Parent.redirect(int a) : this(a, 0);

  @override
  String toString() {
    return 'a=' + a.toString() + '  b=' + b.toString();
  }
}

常量构造函数

变量用final修饰，构造方法用const修饰

class Point2 {
  final int q;
  final int w;

  const Point2(this.q, this.w);
}

需要注意的一点：如果用const修饰new出来的对象，里面变量赋值一样，则共用一块内存地址。

/因为Point2的构造方法用const修饰的，所以这里在new的时候可以用const修饰
Point2 p1=const Point2(3,4);
Point2 p2=const Point2(3,4);

/上面构造方法都传入的3和4，下面输出结果为true
print(identical(p1,p2));

工厂构造函数，工厂模式

class AA {
  String name;
  static AA aa;

  /工厂构造函数无法访问this
  /工厂构造函数不能自动生成实例，通过代码返回你想返回的实例对象
  /*factory AA([String name = 'AA']) {
    if (AA.aa == null) {
      AA.aa = AA._newObject(name);
    }
    return AA.aa ;
  }*/
	/上面的方法可以简写成下面的格式
  factory AA([String name = 'AA'])=> AA.aa ??= AA._newObject(name);

  AA._newObject(this.name);
}

可调用类

void main(){
  var cf=ClassFunc();
  var out =cf('tt','uu');
  print(out.runtimeType); /输出String
  print(out);    /输出tt uu
  print(out is Function); /输出false
}

/这个类可以当方法调用
class ClassFunc{
  /函数名必须是call
  call(String a,String b)=>'$a  $b';
}

继承和Mixin

with的优先级比extends高，同时使用with和extends时，默认会继承with后面最后一个类里面的方法。
只使用implements时必须重写父类里面的所有方法。

void main() {
  print(AB().getMessage());/输出B
  print(BA().getMessage());/输出A
  print(C().getMessage()); /输出C
  print(CC().getMessage()); /输出B
}

/顺序问题
/如果2个或多个超类拥有相同签名的A方法，那么子类会以继承的最后一个超类中的A方法为准。
/当然这是子类没有重写A方法的前提下，如果子类自己重写了A方法则以本身的A方法为准
class A {
  String getMessage() => 'A';
}

class B {
  String getMessage() => 'B';
}

class P {
  String getMessage() => 'P';
}

class AB extends P with A, B {}

class BA extends P with B, A {}

class C extends P with B, A {
  String getMessage() => 'C'; /优先级最高的是在具体类中的方法。
}

class CC extends P with B implements A {
} /这里的implement只是表明要实现A的方法，这个时候具体实现是再B中mixin了具体实现

/实现A必须重写A里面所有的方法
class D implements A {
  @override
  String getMessage() {
    return 'D';
  }
}

泛型

Dart中泛型使用基本上和Java是一样的，也有一些不一样的地方。
Java中的泛型信息是编译时的，泛型信息在运行时是不存在的。
Dart的泛型类型是固化的，在运行时也有可以判断的具体类型。

var names = List<String>();
print(names is List<String>); /输出true
print(names.runtimeType); 	/输出List<String>

泛型限制

main() {
  var footMassage = FootMassage();
  var m = Massage<FootMassage>(footMassage);
  m.massage.doMassage();
}

class Massage<T extends FootMassage > {
  final T massage;
  Massage(this.massage);
}

class FootMassage {
  void doMassage() {
    print('脚底按摩');
  }
}