定义一个类

-> 如果想定义一个私有属性，那么加上_ ,「dart里面没有重载函数」如果想用，那么 类名.xxx 的形式-> Point.Cool() 这里很想Kotlin的扩展函数.算是构造方法语法糖

-> 初始化列表构造方法 Point.fromMap(Map map): _x = map["x"],
y = map["y"];

class Point {
      int _x;
      int y;

  Point(this._x, this.y);

  // 命名构造方法
  Point.Cool() {
    this.y = y;
    print("Cool");
  }

  Point.X(this._x);

//初始化列表构造方法
  Point.fromMap(Map map)
      : _x = map["x"],
        y = map["y"];

  Point.fromMap2(Map map) {
    _x = map["x"];
    y = map["y"];
  }
}

-> 重定向构造方法

class View {
  // 重定向构造方法
  View(int context, int attr);

  View.a(int context) : this(context, 0);

// Java 写法
//  View(int context){
//    this(context,0);
//  }
}

-> 常量构造方法

class ImmutablePoint {
  final int x;
  final int y;

  const ImmutablePoint(this.x, this.y);
}

void main() {
  var a = ImmutablePoint(1, 1);
  var b = ImmutablePoint(1, 1);
  print(a == b);
  print(a.hashCode == b.hashCode);
  var c = const ImmutablePoint(1, 1);
  var d = const ImmutablePoint(1, 1);
  print(c == d);
  print(c.hashCode == d.hashCode);
  var e = const ImmutablePoint(1, 2);
  print(c == e);

}

-> 工厂构造方法

class Manager{

  static Manager _instance;

  factory Manager.getInstance(){
    if(_instance == null){
      _instance = new Manager._newInstance();
    }
    return _instance;
  }

//  static Manager get2(){
//    return new Manager();
//  }
  ->「私有的实例方法」
  Manager._newInstance();
}

void main(){
  Manager.getInstance();
   -> 其他文件中无法调用
  Manager._newInstance();
}

-> getter & setter & 操作符重载

class Point{
  -> 声明一个变量就会有默认的get/set 方法，类似Kotlin比如int x. 定义成私有_x,就可以声明自己的set get 

  int _x;
  int _y;

  int get x => _x;

  set x(int value) => _x = value;

  int get y => _y;

  set y(int value) => _y = value;


  Point operator + (Point other){
    var point = Point();
    point._x = _x + other._x;
    return point;
  }

  String operator >= (int x) {
    return "骚操作";
  }

}

void main(){
  var point = Point();
  point.x = 1;
  print(point.x);
  print(point.y);
  var point2 = Point();
  point2.x = 10;

  point2 = point2 + point;
  print(point2.x);

  String teststr = point2 >= 1;
  print(teststr);

继承 & 实现

每个类既可以看成接口，也可以重载

-> 注意call() 方法。类似Kotlin invoke()

abstract class Parent{
  String name;
  void printName();
  void printName2(){

  }
}


class IA{
  void a(){}
}
-> 「实现必须写重载」
class A implements IA{
  @override
  void a() {
    // TODO: implement a
  }

}

-> 「继承可以不写重载函数」
class B extends IA{

}

class Test{
//  void call(){
//    print("like groovy");
//  }
  void call2(){
    print("like groovy call2");

  }
  void call(int i){
    print("like groovy i");

  }
}

void main(){
  print("interface test like groovy");
  Test test = Test();
  test(1);
}

-> 混合 mixins------不支持多继承，不允许重载，但是他的的另类途径满足多需求

// a with b,c  自身没有从右向左顺序调用  a c b
class A{
  void a(){

  }
  void call(){
    print('a');
  }
  void all(){
    print('all a');
  }
}

class C with A,B{
  void c(){

  }

  void call(){
    print('c');
    super.call();
  }
}

class B{
  void b(){

  }
  void call(){
    print('b');
  }

  void all(){
    print('all b');
  }
}

class myC = Object with A,B;

void main(){
  var c = C();
  c.a();
  c.b();
  c.c();
  c();

  c.all();

}