Dart学习笔录 继承，多态，接口，混入

1.继承

Animal.dart:

class Animal{
  String name;
  Animal(this.name);
  Animal.name(String name){
    this.name="animal命名构造函数${name}";
  } 
  void printInfo(){
    print("Animal:${this.name}");
  } 
}

class Dog extends Animal{
  int age; //自己的属性
  Dog(String name, int age) : super(name){
    this.age=age;  //子类定义自己的属性
  }
  // 命名构造函数
  Dog.name(String name) : super.name(name){
    this.age=age;  //子类定义自己的属性
  }

  @override
  String printInfo(){
    super.printInfo();  //子类方法里面调用父类的方法
    return "子类的重写方法";
  }
  
  // 子类自己的方法
  void childPrint(){
    print("${this.name} ---- ${this.age}");
  }

}


index.dart:

import "Animal.dart";

main(List<String> args) {
  
  Dog d=new Dog("二狗子", 100);
  print(d.printInfo()); // 子类的重写方法
  d.childPrint(); // 二狗子 ---- 100

}

2.抽象类和多态

   抽象类里面的抽象方法是不实现的，由子类进行实现，一般用于来约束子类，制定标准。

   同样抽象类不能实例化，里面的属性和实现的方法，只能通过子类去访问，但是可以通过子类的实例赋值给父类的引用实现

   继承抽象类是用来约束子类，接口实现抽象类是用来制定标准

Animal.dart 文件:

// abstract表示抽象类
abstract class Animal{
  String name;
  eat();  // 不实现的方法才是抽象方法
  printInfo(){
    print("Animal abstract");
  }
}

class Dog extends Animal{
  @override
  eat() {
    print("小狗吃东西");
  } // eat方法其实就是个多态

  // 多态就是父类方法不实现，子类去实现，每个子类有不同的表现
}

class Cat extends Animal{
  @override
  eat() {
    print("小猫吃东西");
  }  // eat方法其实就是个多态
}

index.dart 文件1:

import "abstract.dart";

main(List<String> args) {

  Dog d=new Dog();
  d.eat();  // 小狗吃东西
  Cat c=new Cat();
  c.eat(); // 小猫吃东西

}

index.dart 文件2:

import "abstract.dart";

main(List<String> args) {
  
  Animal a=new Dog();  //子类的实例赋值给父类的引用
  // 这种子类的自己的人方法就没法调用，只能用父类里面的
  a.eat();
  a.printInfo();

  Animal b=new Cat();  //子类的实例赋值给父类的引用
  // 这种子类的自己的人方法就没法调用，只能用父类里面的
  b.eat();

}

3.接口   

实现接口，不仅要实现抽象类的属性还要实现抽象类的方法

abstract class Animal{
  String name;
  eat();
}

abstract class InnerAnimal{
  String age;
  go();
}


class Dog implements Animal{
  @override
  String name;

  @override
  eat() {
    print("小狗正在吃东西");
  }
}

// 实现多个接口
class Cat implements Animal,InnerAnimal{
  @override
  String age;

  @override
  String name;

  @override
  eat() {
    // TODO: implement eat
    return null;
  }

  @override
  go() {
    // TODO: implement go
    return null;
  }
 

}

4. 混入 （mixin）  使用关键词 with

with.dart 文件：

//minin类只能继承Object，不能是其他类

// 作为mixin类 不能有构造函数
class A{
  String name='aa';
  void printInfo(){
    print("A");
  }
}

// 作为mixin类 不能有构造函数
class B{
  int age;
  String name='bb';
  void printInfo(){
    print("B");
  }
}

class D extends B{}  //继承B

class C with A,B{}  // mixin的后面的优先级比前面的高，就是B的属性和方法优先级比A高

class E with A,D{}  //会报错，因为D不是Object类

index.dart 文件:

import "with.dart";

main(List<String> args) {

  C c=new C();
  c.printInfo();  // B
  print(c.name);  // bb

}