Flutter 类和对象的继承、混入、实现常用关键字

一、 总结

关键字	描述	示例
extends	继承，表示子类继承父类，子类可以访问父类的所有实例成员	class Dog extends Animal {}
with	混入（mixin），将一个或多个类的功能混入当前类	class Dog with Swimmer {}
implements	实现接口，表示类必须实现接口中定义的所有方法	class Dog implements Animal {}
abstract	抽象类，表示不能实例化的类，可以包含抽象方法（没有实现的方法）和已实现的方法	abstract class Animal {}
covariant	协变，用于改变方法参数的协变性，允许子类类型代替父类类型	void handle(covariant Animal animal)
super	调用父类的构造函数、方法或属性	super.speak()
this	当前类的实例引用，用于访问当前对象的属性或方法	this.name

二、案例

1. extends - 继承

• 用途：extends 关键字用于表示一个类继承自另一个类。子类可以继承父类的所有实例成员（方法和属性），但不能继承父类的构造函数。

• 例子：

  class Animal {
    void speak() {
      print("Animal speaks");
    }
  }
  
  class Dog extends Animal {
    void speak() {
      print("Dog barks");
    }
  }
  
  void main() {
    Dog dog = Dog();
    dog.speak(); // 输出: Dog barks
  }
  

2. with - 混入（Mixin）

• 用途：with 关键字用于将多个类的功能混入到一个类中，通常用于添加额外的功能。with 适用于类之间不需要继承，但希望复用代码的场景。它不会继承类的构造函数。

• 注意：Dart 支持多个混入。

• 例子：

  class Animal {
    void speak() {
      print("Animal speaks");
    }
  }
  
  class Swimmer {
    void swim() {
      print("Swimming");
    }
  }
  
  class Dog extends Animal with Swimmer {
    void bark() {
      print("Dog barks");
    }
  }
  
  void main() {
    Dog dog = Dog();
    dog.speak(); // 输出: Animal speaks
    dog.swim();  // 输出: Swimming
  }
  

3. implements - 实现接口

• 用途：implements 用于实现一个接口（类）。类必须实现接口中声明的所有方法。如果接口有某些方法没有实现，编译器会提示错误。

• 例子：

  class Animal {
    void speak();
  }
  
  class Dog implements Animal {
    @override
    void speak() {
      print("Dog barks");
    }
  }
  
  void main() {
    Dog dog = Dog();
    dog.speak(); // 输出: Dog barks
  }
  

4. abstract - 抽象类

• 用途：abstract 关键字用于声明一个抽象类，抽象类不能被实例化。它可以包含抽象方法（没有实现的方法）和已实现的方法。

• 例子：

  abstract class Animal {
    void speak(); // 抽象方法
    void breathe() {
      print("Breathing"); // 实现的方法
    }
  }
  
  class Dog extends Animal {
    @override
    void speak() {
      print("Dog barks");
    }
  }
  
  void main() {
    Dog dog = Dog();
    dog.speak();    // 输出: Dog barks
    dog.breathe();  // 输出: Breathing
  }
  

5. covariant - 协变

• 用途：covariant 关键字用于改变方法参数类型的协变性（用于允许某些类型的父类参数接受子类的参数类型）。这是 Dart 中的一个较高级的特性，通常用于泛型。

• 例子：

  class Animal {
    void speak() {
      print("Animal speaks");
    }
  }
  
  class Dog extends Animal {
    @override
    void speak() {
      print("Dog barks");
    }
  }
  
  class Handler {
    void handle(covariant Animal animal) {
      animal.speak();
    }
  }
  
  void main() {
    Handler handler = Handler();
    handler.handle(Dog());  // 输出: Dog barks
  }
  

6. super - 父类调用

• 用途：super 关键字用于访问父类的方法、构造函数或属性。它通常在子类中使用，用于调用父类的构造函数或方法。

• 例子：

  class Animal {
    String name;
  
    Animal(this.name);
  
    void speak() {
      print("$name speaks");
    }
  }
  
  class Dog extends Animal {
    Dog(String name) : super(name);
  
    @override
    void speak() {
      super.speak(); // 调用父类的 speak 方法
      print("Dog barks");
    }
  }
  
  void main() {
    Dog dog = Dog("Buddy");
    dog.speak();  // 输出: Buddy speaks
                  // 输出: Dog barks
  }
  

7. this - 当前类的实例

• 用途：this 关键字引用当前类的实例。它通常用于区分成员变量和构造函数参数，特别是在构造函数中。

• 例子：

  class Animal {
    String name;
  
    Animal(this.name); // 使用 this 来表示构造函数参数
  
    void speak() {
      print("$name speaks");
    }
  }
  
  void main() {
    Animal animal = Animal("Lion");
    animal.speak();  // 输出: Lion speaks
  }