Dark 面向对象

1 继承

• 使用extends继承一个类
• 子类会继承父类可见的属性和方法，不包含构造方法
• 可以复写父类的方法
• 单继承,多态性

构造方法

• 子类的构造方法会默认调用父类的无名无参构造方法
• 如果父类没有无名无参，则需要显示调用父类构造方法

class Student extends Person{
  Student(int salary, int month) : super(salary, month);
}

class Person {
  int salary;
  int month;
  Person(this.salary, this.month); //构造方法并赋值
  Person.withSalary(this.salary); //命名构造方法
  num get yearSalary => (salary * month); //计算属性
  work() {
    print("work...");
  }
}

2 抽象类

• 使用abstract定义
• 抽象类可以没有抽象方法
• 抽象方法无须abstract，无实现
• 有抽象方法的类必须定义成抽象类
• 抽象类不能实例化，需要子类继承覆写抽象方法

//abstract定义抽象类
abstract class Person {
  //可以没有抽象方法
  //抽象方法 不用abstract修饰,无实现
  void run();
}

3 接口

• 类和接口是统一的，类就是接口
• 每个类都隐式的定义了一个包含所有实例成员的接口
• 如果是复用已有类的实现，使用继承extends
• 如果是使用父类的行为，使用implements接口 （结合抽象类实现）

//abstract定义抽象类( 类即接口）
abstract class Person {
  //可以没有抽象方法
  //抽象方法 不用abstract修饰,无实现
  void run();
}

class Student implements Person{
  @override
  void run() {
    // TODO: implement run
  }
}

4 Mixins （非常强大，需要在实际运用中领会）

• 类似于多继承，是在多继承中重用一个类代码的方式。（在一个类中使用多个类的属性和方法）
• 作为Minxins的类不能有显示的构造方法
• 作为Minxins的类只能继承（extends)Object ，可以implements 接口
• 使用with连接一个或多个mixins

void main() {
  C().a();//由于B是最后with的，这里调用的是B的a方法
  C().b();//这里调用的是B的b方法
}

class C extends A with B {}//C拥有A、B的属性和方法啦

class A {
  a() {
    print("a.a");
  }
}

class B {
  a() {
    print("b.a");
  }

  b() {
    print("b.b");
  }
}

5 操作符覆写

void main() {
  print(Person.withAge(18) > Person.withAge(20));
}

class Person {
  int age;
  Person.withAge(this.age);

  bool operator >(Person p) {
    return this.age > p.age;
  }
}

6 枚举

使用与java类似。不同在于可以获取枚举的索引，默认从0开始。

 

7 泛型

使用与java类似。

• 类的泛型：定义在类级别上
• 方法的泛型：定义在方法上

void main() {
  var utils = new Utils<String>();
  utils.put("Hello!";)
}

class Utils<T> {
  T element;
  void put(T element) {
    this.element = element;
  }
}