Dart语言详解-7 类

1 类-构造函数

//java中写法
class Point {
  double x;
  double y;

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

//dart建议写法
class Point {
  num x;
  num y;
  Point(this.x, this.y);
}

main() {
  //普通构造函数
  var p = new Point(1, 1); //new 可省略 var point = Point(1, 2);
  print(p);
}

打印：

Point(x = 1, y = 1)

2 类-命名构造函数

class Point { 
  num x; 
  num y; 

  Point(this.x, this.y); 

  //命名构造函数
  Point.fromJson(Map json) { 
    x = json['x']; 
    y = json['y']; 
  } 
}

void main(){
	//命名构造函数
	p = Point.fromJson({'x': 2, 'y': 2});
	print(p);
}

打印：

Point(x = 2, y = 2)

3 类-重定向构造函数

class Point { 
  num x; 
  num y; 

  Point(this.x, this.y); 

  //重定向构造函数，使用冒号调用其他构造函数
  Point.alongXAxis(num x) : this(x, 0);
}

  //重定向构造函数
  p = Point.alongXAxis(0);
  print(p);

打印：

Point(x = 0, y = 0)

4 类-初始化列表

import 'dart:math';

class Point {
  //final变量不能被修改，必须被构造函数初始化
  final num x;
  final num y;
  final num distanceFromOrigin;

  //初始化列表
  Point(x, y)
      : x = x,
        y = y,
        distanceFromOrigin = sqrt(x * x + y * y);
}

5 类-调用超类构造函数

class Parent {
  int x;
  int y;

  //父类命名构造函数不会传递  
  Parent.fromJson(x, y)
      : x = x,
        y = y {
    print('父类命名构造函数');
  }
}

class Child extends Parent {
  int x;
  int y;
  //若超类没有默认构造函数， 需要手动调用超类其他构造函数
  Child(x, y) : super.fromJson(x, y) {
    //调用父类构造函数的参数无法访问 this
    print('子类构造函数');
  }

  //在构造函数的初始化列表中使用super()，需要把它放到最后
  Child.fromJson(x, y) 
	 : x = x,
	   y = y,
	   super.fromJson(x, y) {
    print('子类命名构造函数');
  }
}

main() {
  //调用超类构造函数
  var child = Child.fromJson(1, 2);
  var child1 = Child(3, 4);
}

打印：

超类命名构造函数
子类命名构造函数
超类命名构造函数
子类构造函数

6 类-常量构造函数

class Point2 {
  //定义const构造函数要确保所有实例变量都是final
  final num x;
  final num y;
  static final Point2 origin = const Point2(0, 0);

  //const关键字放在构造函数名称之前，且不能有函数体
  const Point2(this.x, this.y);
}

void main(){
	//常量构造函数
  var p2 = const Point2(4, 4);
  print(p2);
  var p21 = Point2(4, 4); //创建的是非 常量对象
  var p22 = const Point2(4, 4);
  print(identical(p2, p21));
  print(identical(p2, p22));
}

打印：

Point2(x = 4, y = 4)
false
true

7 类-工厂构造函数

class Singleton {
  String name;
  //工厂构造函数无法访问this，所以这里要用static
  static Singleton _cache; 

  //工厂方法构造函数，关键字factory
  factory Singleton([String name = 'singleton']) =>
      Singleton._cache ??= Singleton._newObject(name);

  //定义一个命名构造函数用来生产实例
  Singleton._newObject(this.name);
}

打印：true

8 类-Setter和Getter

main() {
  //set get
  var rect = new Rectangle(1, 1, 10, 10);
  print(rect.left);
  rect.right = 15;
  print(rect.left);
}

//setter getter
//每个实例变量都隐含的具有一个 getter， 如果变量不是 final 的则还有一个 setter
//可以通过实行 getter 和 setter 来创建新的属性， 使用 get 和 set 关键字定义 getter 和 setter
class Rectangle {
  num left;
  num top;
  num width;
  num height;

  Rectangle(this.left, this.top, this.width, this.height);

  // getter 和 setter 的好处是，可以开始使用实例变量，后面可以把实例变量用函数包裹起来，而调用你代码的地方不需要修改。
  //获取right值
  num get right => left + width;
  //设置right值，同时left也发生变化
  set right(num value) => left = value - width;
  //获取bottom值
  num get bottom => top + height;
  //设置bottom值，同时top也发生变化
  set bottom(num value) => top = value - height;
}

打印：

1
5

9 类-抽象类

• abstract关键字修饰class
• 继承的方式使用
• 接口的方式使用

工厂模式两种方式：

1 创建工厂构造函数

main() {
  //创建工厂构造函数
  var footMassage = new Massage('foot');
  footMassage.doMassage();
  var bodyMassage = new Massage('body');
  bodyMassage.doMassage();
  var specialMassage = new Massage('%#@##@##');
  specialMassage.doMassage();
}
//工厂模式
abstract class Massage {
  factory Massage(String type) {
    switch (type) {
      case 'foot':
        return new FootMassage();
      case 'body':
        return new BodyMassage();
      default:
        return new SpecialMassage();
    }
  }
  void doMassage();
}

class FootMassage implements Massage {
  @override
  doMassage() {
    print('脚底');
  }
}
class BodyMassage implements Massage {
  @override
  void doMassage() {
    print('全身');
  }
}
class SpecialMassage implements Massage {
  @override
  void doMassage() {
    print('特殊');
  }
}

打印：

脚底
全身
特殊

---

2 创建顶级函数

main() {
  //创建顶级函数
  var footMassage = massageFactory('foot');
  footMassage.doMassage();
  var bodyMassage = massageFactory('body');
  bodyMassage.doMassage();
  var specialMassage = massageFactory('xxx');
  specialMassage.doMassage();
}
//工厂函数
class Massage {
  void doMassage(){
    print('按摩');
  }
}
class FootMassage extends Massage {
  @override
  doMassage() {
    print('脚底');
  }
}

class BodyMassage extends Massage {
  @override
  void doMassage() {
    print('全身');
  }
}

class SpecialMassage extends Massage {
  @override
  void doMassage() {
    print('特殊');
  }
}
Massage massageFactory(String type){
  switch (type) {
    case 'foot':
      return new FootMassage();
    case 'body':
      return new BodyMassage();
    default:
      return new SpecialMassage();
  }
}

打印：

脚底
全身
特殊

10 类-可调用类

main() {
  //可调用类
  var cf = new ClassFunction();
  var out = cf("hongxue","flutter,","xiaoming");
  print('$out'); // Hi there, gang!
  print(cf.runtimeType); // WannabeFunction
  print(out.runtimeType); // String
  print(cf is Function); // true
}
//可调用类
class ClassFunction {
  call(String a, String b, String c) => '$a $b $c!';
}

打印：

hongxue flutter, xiaoming!
ClassFunction
String
false