Dart学习笔记-面向对象编程（二）
一、继承、继承中的构造函数
- 键字extends继承一个类
- 子类会继承父类可见的属性和方法，不会继承构造方法
- 子类能够复写父类的方法、getter和setter
- 单继承
class Person {
String name;
int age;
String _birthday;
bool get isAdult => age > 18;
void run(){
print("Person run...");
}
}
class Student extends Person{
@override
bool get isAdult => age > 15;
@override
void run(){
print("Student run...");
}
@override
String toString(){
return("Student toString");
}
void study(){
print("Student study...");
}
}
- 继承中的构造方法
- 子类的构造方法默认会调用父类无名无参的构造方法
- 如果父类没有无名午餐的构造方法，则需要显示调用父类构造方法
- 在构造方法参数后使用：显示调用父类构造方法
class Person {
String name;
int age;
String _birthday;
bool get isAdult => age > 18;
Person(this.name);
Person.withName(this.name);
void run(){
print("Person run...");
}
}
class Student extends Person{
Student(String name) : super(name);
}
- 构造方法执行顺序
- 父类的构造方法在子类构造方法体开始执行的位置调用
- 如果有初始化列表，初始化列表会在父类构造方法之前执行
class Person {
String name;
int age;
bool get isAdult => age > 18;
Person(this.name);
Person.withName(this.name);
void run(){
print("Person run...");
}
}
class Student extends Person{
final String gender;
Student(String name,String g) : gender = g,super(name);
}
二、抽象类
- 抽象类使用abstract标识，不能直接被实例化
- 抽象方法不用abstract修饰，无实现
- 抽象类可以没有抽象方法
- 有抽象方法的类一定得声明为抽象类
abstract class Person{
void run();
}
class Student extends Person{
@override
void run(){
print("run...");
}
}
三、接口
- 类和接口是统一的，类就是接口
- 每个类都隐式定义了一个包含所有实例成员的接口
- 如果是复用已有类的实现，使用继承（extends）
- 如果只是使用已有类的外在行为，使用接口（implements）
class Person {
String name;
int age;
void run(){
print("Person run...");
}
}
class Student implements Person{
@override
String name;
@override
int age;
@override
void run(){
print("run...");
}
}
建议使用抽象类作为接口
abstract class Person{
void run();
}
class Student implements Person{
@override
void run(){
print("run...");
}
}
四、Mixins，操作符的覆写
1、Mixins
- Mixins类似于多继承，是在多类继承中重用一个类代码的方式，Mixin不能直接使用，必须配合继承
- 作为Mixin的类不能有显示声明构造函数
- 作为Mixin的类智能继承自Object
- 使用关键字with连接一个或多个mixin
顺序问题
- 如果2个或多个超类拥有相同签名的A方法，那么子类会以继承的最后一个超类中的A方法为准。
- 若子类也重写了改方法也已子类为准
- 优先级顺序是：子类自己实现>Mixin>继承，如果有多个Mixin，则已最后的Mixin为主
class A {
String getMessage() => 'A';
}
class B {
String getMessage() => 'B';
}
class P {
String getMessage() => 'P';
}
class AB extends P with A, B {}
class BA extends P with B, A {}
class C extends P with B, A {
String getMessage() => 'C'; //优先级最高的是在具体类中的方法。
}
//关系连接：implements实现、extends继承、with混入
class CC extends P with B implements A {
}
var cc = CC();
print(cc.getMessage());//=>B
使用mixin进行类组合
abstract class Person{
String name;
int age;
void run();
}
class Animal{
void eat(){
print("eat...");
}
}
//mixin on的使用，使用这个mixin的class必须继承自Animal
mixin Boy on Animal implements Person{
@override
String name;
@override
int age;
@override
void run(){
print("Person run...");
}
void playBall(){
print("playBall...");
}
}
mixin Girle implements Person {
@override
String name;
@override
int age;
@override
void run(){
print("Person run...");
}
void dance(){
print("dance...");
}
}
class Cat{
void eat(){
print("eat...");
}
}
此时我们可以使用快捷方式组合class
class A = Cat with Girle;
var a = A();
a.run();
2、操作符的覆写
- 操作符覆写
- 覆写需要在类中定义
返回类型 operator操作符（参数1、参数2.....）{
实现体
return 返回值
}
class Person {
int age;
bool operator > (Person person){
return this.age > person.age;
}
}
var p1= Person();
p1.age = 18;
var p2= Person();
p2.age = 13;
print(p1>p2);//ture