dart(四)--类、构造函数、方法

类

构造函数

构造函数 className 或 className.identifier, 关键字 new 可选.

构造函数语句执行顺序：初始化器，父类构造函数，子类构造函数。

class Point {
    num x, y, distance;
    
    /*
        1,匿名构造函数
        2,使用this.x 简化写法，原写法： Point(num x , num y)
        3,此处 : 后为初始化器，初始化的结果赋值给初始化器的对象，是最简洁的方式。
        4,此处的this可以理解为self。
    */
    Point(this.x , this.y) : distance = sqrt(x * x + y * y);
    
    /*
        1,在初始化器里可以使用断言做一些判断
    */
    Point.withAssert(this.x , this.y) : assert(x>=0), 
        distance = sqrt(x * x + y * y);
    
    /*
        1,命名构造函数,获得原点坐标。
        2,此处 : 后为委托构造函数。
        3，委托构造函数需要满足参数x>=0,否则构造失败。
    */
    Point.origin() : this.withAssert(0, 0);
    Point.fromJson(map<String, num> json) : this(json['x'], json['y']);
    
    /*
        1,使用@override 来重写父类方法
        2,dart所有的对象都默认继承object
    */
    @override
    String toString() => 'Point(x: $x,y: $y)';

    /*
        1，num是方法的返回值 ,x是方法名 
        2，set,(num value)方法参数,无反回值。
    */
    num get x => sqrt(distance * distance + y * y);
    set x(num value) => y = sqrt(distance * distance + value * value);
}

常值实例创建方法

class ImmtablePoint {
    /*
        如果调用参数一致，创建出的实例也是同一个（内存地址相同）。
       1,类似于swift中单例的初始化方法。
       2,static final修饰的shared是静态的地址不可修改的实例变量.
       3,const ImmtablePoint(0,0) 表示初始化一个为常值的实例。
       4,shared变量是一个地址不可修改且内容为常值的ImmtablePoint类的实例。
       5,由于需要构造一个内容不可修改的实例，所以构造函数也需要被const修饰。
       6,常量构造函数内容不可修改则实例变量也不可修改，则实例变量也需要final来修饰。
    */
    static final shared = const ImmtablePoint(0,0);
    
    final num a,b;
    
    const ImmtablePoint(this.a, this.b);
}

抽象类

abstract class Doer {
    /*
        抽象类，方法无需实现
    */
    void doSomething();
}

class EffDoer extends Doer {
    /*
        1，指定抽象类拓展。
        2，拓展后需实现抽象类中的方法。
    */
    void doSomething() {
        print('doSomething');
    }
}

方法

/*
    1,在方法中的x，y，就是实例变量。如果在方法中出现重名，则需要用:this.x,this.y来表示。
*/
 num distanceTo(Point other){
    var dx = x - other.x;
    var dy = y - other.y;
    return sqrt(dx* dx + dy * dy);
}

/*
    factory，工厂方法
*/
factory Logger(String name) {}

/*
    构造函数前加 _ ,这个方法、构造函数，是一个私有方法，只能在类中自己使用。
*/
Logger._internal(this.x);

操作符覆盖

class Vector {
    final int x,y;
    Vector(this.x,this.y);
    
    /*
        1,+，-操作覆盖
        2，operator关键词
    */
    Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
    Vector operator -(Vector v) => Vector(x - v.x, y - v.y);
    
    /*
        1,覆盖==符号，必须也好覆盖hashCode方法
    */
    @override
    int get hashCode {
        int res = 1;
        res = res + x.hashCode;
        res = res + y.hashCode;
        return res
    }
    
    @override
    bool operator ==(dynamic other){
        if (other is! Vector) return false;
        Vector newObj = other;
        return (newObj.x = x && newObj.y == y);
    }
}

方法类型定义

使用typedef来定义一个方法类型，包含：参数、返回值

typedef Compare = int Function(Object a, Object b);

// 同时支持泛型
typedef Compar<T> = int Function(T a, T b);

class soos{
    Compare compare;
    //自定义后依旧是Function的子类
    assert(compare is Function);
}