Dart学习笔记-面向对象编程

Posted 2022-12-03 追到梦的魔术师

一、继承、继承中的构造函数

• 键字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