类

• 文件名一般以小写加下划线加小写的方式
• 类名一般用大写字母开头
• dart没有像java一样的private之类的关键词来限制类或者变量，但是可以加下划线代表私有
• 构造方法不需要方法体
• dart不允许方法重载，如果需要有多个不同参数的构造方法，可以使用命名构造方法的方式，取一个别名的构造方法，实现像java里构造方法的重载
• dart的构造方法允许可变参数，但是使用命名构造方法可以更直观表示方法作用和特性
• 参数初始化列表 初始化你类当中的属性 可以不写方法体

//包括类的定义 如果使用 _开头 意味着这个类是private
class  Point{
  //使用 _ 开始命名的变量 就是Java的 private
  int _x;
  int y;

    //构造方法不需要方法体
  Point(this._x,this.y);

    //dart的构造方法允许可变参数，但是使用命名构造方法可以更直观表示方法作用和特性
//  Point({int x,int y}){
//
//  }


  // 命名构造方法  命名更加直观的表示这个构造方法的作用与特性
  Point.Cool(int y){
    this. y = y;
    print("我好帅啊!");
  }
  Point.X(this._x);

  //参数初始化列表 初始化你类当中的属性 可以不写方法体
  Point.fromMap(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);
//  }
}

常量构造方法

• 使用 new 来创建 常量构造方法的 对象 就和普通的对象没有区别
• 使用const 来创建多个对象，传递参数一样 表示 这几个对象是同一个 编译期常量 对象 （必须定义常量构造函数
• 工厂构造方法
• 有了私有的命名构造方法就不能再new默认的构造方法
• 同一个文件下可以调用私有命名构造方法，不同文件下才不能调用这个私有构造方法

class ImmutabelPoint{
  final int x;
  final int y;
  // 常量构造方法
  const ImmutabelPoint(this.x,this.y);
}





class Manager{
  int i;
  static Manager _instance;
  // 工厂构造方法 必须返回一个 实例对象
  factory Manager.getInstance(){
    if(_instance == null){
      _instance = new Manager._newInstance();
    }
    return _instance;
  }

//  static Manager get2(){
//    return new Manager();
//  }

  //私有的 private的 有了这个私有的构造方法就不能再new Manager()了
  //同一个文件下可以调用这个_newInstance，不同文件下才不能调用这个私有构造方法
  Manager._newInstance();

}




void main(){
  //使用  new 来创建 常量构造方法的 对象 就和普通的对象没有区别
  //使用const 来创建多个对象，传递参数一样 表示 这几个对象是同一个 编译期常量 对象 （必须定义常量构造函数）
  var p1 = const ImmutabelPoint(1,1);
  var p2 = const ImmutabelPoint(1,1);
  print(p1.hashCode == p2.hashCode);
  print(p1 == p2);


  /**
   * 工厂构造方法
   */
  new Manager.getInstance();

}

set get方法

• 类中每一个实例属性 变量都会有一个隐式的 get，非final 还有 set
• 类中非私有的变量本身就有隐式非final的get和set方法，dart又不支持重载，所以就不能再自定义这个变量的set和get方法了。可以给私有变量自定义
• 运算符重载
• 抽象类，跟java类似。区别是抽象类的抽象函数可以不写abstract关键词
• 接口，dart中每个类都可以看成是一个接口
• 可调用的类，可以直接调用类中的call函数

class Point{
  //每一个实例属性 变量都会有一个隐式的 get，非final 还有 set
  int _x;
  int _y;

  //x 是方法名
  //这里可以写方法体，可以用=>写表达式，也可以写三元运算
  int get x => _x;

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

  //运算符重载， 定义+ 操作的行为
  Point operator +(Point othre){
    var point = new Point();
    point._x = _x + othre.x;
    return point;
  }

  String operator -(int x){
   return "hahahaha";
  }
}



class Test{
  void ass(){}

  void  fff(){}

  void call(int ){

  }
}


void main(){
//  var point = new Point();
//  //  get
//  print(point.xxxxx);
//  // set
//  point.bbbbbbb = 10;


  var p1 = Point();
  var p2 = Point();
  p1.x = 10;
  p2.x = 20;

  var p3= p1 + p2;
  p3 = p1 + p2 + p3;

  print(p3.x);

  //灵活......
  String str = p3 - 1;
  print(str);

    //可调用的类
  Test test = Test();
    //调用的是Test中的call函数
  test(1);
}

混合mixins

• 被mixin(混入)的类不能有构造函数
• 混合后有名称相同的函数时，自身是第一优先级，如果自身没有对应的方法，就从with最右边开始查找方法
• 内部可以用super关键词调用父类的函数

//被mixin(混入)的类不能有构造函数
class A  {
  void a(){
    print("A  的a方法!");
  }
}
class B{
  void b(){
    print("b方法");
  }
  void a(){
    print("B  的a方法!");
  }
}


// 满足了我们的多继承的需求
class C with  B,A{

  void c(){

  }
  // 重写了 混入类的a方法
  void a(){

  }
}

//C 就是A B的混合类
//class C = Object with A, B;


void main(){
  //1、自身是第一优先级
  //2、如果自身没有对应的方法，就从with最右边开始查找方法
  var c = new C();
  c.a();



}