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
}