【Flutter入门到进阶】Dart基础篇---面向对象_dart面向对象

1 类

1.1 构造

//java中写法
class P {
  double x;
  double y;
 
  P(int x, int y) {
    this.x = x;
    this.y = y;
  }
}
 
//dart建议写法
class P {
  num x;
  num y;
  Point(this.x, this.y);
}

1.2 重定向构造

class P { 
  num x; 
  num y; 
 
  Point(this.x, this.y); 
 
  //重定向构造函数，使用冒号调用其他构造函数
  P.alongXAxis(num x) : this(x, 0);
}

1.3 命名构造函数

class Rect{
  int _height;//定义成私有成员(前面加下划线),私有成员不能被外部直接访问
  int _width;
 
  Rect(this._height,this._width);//Dart默认构造函数 只能声明一次,Java可以声明多个
  Rect.heigthSet(this._height);//命名构造函数 可以声明多个
  Rect.widthSet(this._width);//命名构造函数 可以声明多个
  Rect.allSet(this._width,this._height);//命名构造函数 可以声明多个
  Rect.allSet2():_height=5,_width=5;//带默认参数的构造方法
  
  //set get属性方法,外部通过访问属性的形式调用该方法
  set setHeight(int value){
    this._height=value;
  }
 
  //getter属性方法,不用括号，外部通过访问属性的形式调用该方法
  get getHeight{
    return _height;
  }
 
  //getter属性方法,不用括号，外部通过访问属性的形式调用该方法
  get Area{
    return _height*_width;
  }
 
  //定义私有方法
  int _area(){
    return _height*_width;
  }
 
  int getArea(){
    return _area();
  }
 
  String getMessage(){
    return('获取传入的高，宽值：$_height $_width 面积计算为：');
  }
}

1.4 类的Get和Set方法

class Rectangle {   
    num left;   
    num top;   
    num width;   
    num height;   
    Rectangle(this.left, this.top, this.width, this.height);   
    num get right => left + width; 
    set right(num value) => left = value - width;   
    num get bottom => top + height;   
    set bottom(num value) => top = value - height; 
}

2 抽象 和 继承

实例

// 定义父类
abstract class Person{
  String name;
  int age;
 
  Person(this.name, this.age);
 
  Person.second(this.name, this.age);
 
  void show() {
    print('$name $age');
  }
 
  //抽象方法定义规则，要求子类必须继承
  void marry();
}
 
// 子类继承，必须实现抽象方法
class Boy extends Person{
  double height;
  Boy(String name, int age,double height):super(name,age){
    this.height=height;
  }
 
  //方法重写
  @override
  void show(){
    // super.show();
    print('$name $age $height');
  }
 
  void playBoy(){
    print('男生喜欢打王者荣耀');
  }
 
  @override
  void marry() {
    print('我是一个男生，要找一个女朋友结婚');
  }
 
}

3 封装 和 多态

3.1 说明

        1、Dart中的多态体现在方法重写，向上转型

        2、比如上面Boy子类中的方法重写，我们也可以再定义一个Girl子类重写；

        3、向上转型，向下转型这里做一个简单的介绍，具体代码可在我的资源中下载去看

        4、向上转型可以提取公共方法，向下转型可以转化到子类，调用子类方法，向上转型也是一种封装

3.2 实例

        A is B 判断A是否是B类型

        A as B 把A类型转换为B类型

if(p is Boy){
    Boy boy=p as Boy;
    boy.playBoy();
}

4 接口

dart中类就是接口，和声明抽象类一样，一般是用abstract修饰

代码

abstract class Person {
  void run();
}
class Student implements Person {
  @override
  void run() {
    print("run 执行了。。。")
  }
}

5 Mixins

5.1 说明

        实际上就是多继承

                通过mixins实现类似多继承，但是mixins不属于继承，也不属于接口，就是一种新的特性

                作为mixins的类只能继承于最终父类Object，不可以继承别的类

                mixins类不能有构造函数

                一个类可以继承于多个mixins

        Mixins是Dart里面的一个全新概念，简单来说，用来复用多个类之间的代码，减少耦合，换句话来说，可以从中扩展方法（或变量）而不扩展类

5.2 示例

5.2.1 场景

        工程师 = 软件工程师 + 建筑工程师

        教师 = 美术教师 + IT教师

        工作者 = 教师 + 工程师

5.2.2 图例

5.2.3 java实现

//工作者
abstract class Worker {
    public abstract void doWork();//工作者需要工作
}
 
//工程师
class Engineer extends Worker {
    @Override
    public void doWork() {
        System.out.println("工程师在工作");
    }
}
 
//教师
class Teacher extends Worker {
    @Override
    public void doWork() {
        System.out.println("教师在教学");
    }
}
 
//软件工程师
class SoftwareEngineer extends Engineer {}
 
//建筑工程师
class BuildingEngineer extends Engineer {}
 
//美术教师
class ArtTeacher extends Teacher {}
 
//IT教师
class ITTeacher extends Teacher {}

5.3.4 Dart实现

//工作者
abstract class Worker {
  void doWork();//工作者需要工作
}
 
//工程师
class Engineer extends Worker {
  void doWork() {
    print('工程师在工作');
  }
}
 
//教师
class Teacher extends Worker {
  void doWork() {
    print('教师在教学');
  }
}
 
//软件工程师
class SoftwareEngineer extends Engineer {}
 
//建筑工程师
class BuildingEngineer extends Engineer {}
 
//美术教师
class ArtTeacher extends Teacher {}
 
//IT教师
class ITTeacher extends Teacher {}

5.4 扩展功能

5.4.1 图例

5.5 如果使用Java，那么我们自然就想到了使用interface。

5.5.1 代码示例

interface CanFixComputer {
    void fixComputer();
}
 
interface CanDesignSoftware {
    void designSoftware();
}
 
//软件工程师
class SoftwareEngineer extends Engineer implements CanFixComputer, CanDesignSoftware {
 
    @Override
    public void fixComputer() {
        System.out.println("修电脑");
    }
    
    @Override
    public void designSoftware() {
        System.out.println("设计软件");
    }
 
}
 
//IT教师
class ITTeacher extends Teacher implements CanFixComputer {
 
    @Override
    public void fixComputer() {
        System.out.println("修电脑");
    }
 
}

5.5.2 说明

        但是，我们知道Dart当中没有interface的概念，但并不意味着这门语言没有接口，事实上，Dart任何一个类都是接口，你可以实现任何一个类，只需要重写那个类里面的所有具体方法。

        如果要用Dart来实现的话，只需要将interface修改成abstract class。

        但是我们发现，fixComputer这个接口被继承了两次，并且两次的实现都是一样的，这里就出现了代码重复和冗余的问题。怎么办呢？在java中我们有接口的default实现来解决这个问题(这是一个java8出现的不得已的方案。)

        但是，有了mixins之后，这件事就变得不那么难了。

5.6 Dart的处理

abstract class CanFixComputer {
  void fixComputer() {
    print('修电脑');
  }
}
 
abstract class CanDesignSoftware {
  void designSoftware() {
    print('设计软件');
  }
}
 
//软件工程师
class SoftwareEngineer extends Engineer
    with CanFixComputer, CanDesignSoftware {}
 
//IT教师
class ITTeacher extends Teacher with CanFixComputer {}
 
main() {
  ITTeacher itTeacher = new ITTeacher();
  itTeacher.doWork();
  itTeacher.fixComputer();
  SoftwareEngineer softwareEngineer = new SoftwareEngineer();
  softwareEngineer.doWork();
  softwareEngineer.fixComputer();
  softwareEngineer.designSoftware();
}

通过以上代码，我们可以看到这里不用implements，更不是extends，而是with。

        每个具有某项特性的类不再需要具体去实现同样的功能，接口是没法实现功能的，而通过继承的方式虽然能实现功能，但已经有父类，同时不是一个父类，又不能多继承，所以这个时候，Dart的Mixin机制就比Java的接口会高效，开发上层的只需要关心当前需要什么特性，而开发功能模块的关心具体要实现什么功能。

5.7 无论是extends、implements还是mixin，优先级最高的是在具体类中的方法。

class First {   
    void doPrint() {     
        print('First');   
    } 
} 
 
class Second {   
    void doPrint() {     
        print('Second');   
    } 
} 
 
class Father {   
    void doPrint() {     
        print('Father');   
    } 
} 
 
class Son1 extends Father with First,Second { } 
 
class Son2 extends Father with First implements Second { 
     main() { 
        Son1 son1 = new Son1();   
        son1.doPrint(); // Second   
        Son2 son2 = new Son2();   
        son2.doPrint(); // First 
    }
}

其实在Son2中implements只是说要实现他的doPrint()方法，这个时候其实具体实现是First中Mixin的具体实现。

而Mixin的具体顺序也是可以从代码倒过来看的，最后mixin的优先级是最高的。

优先级 with>extends>implements

6 泛型

6.1 说明

        在Dart当中，有很多容器对象，在创建对象时都可以定义泛型类型，这一点和Java是一样。

        Java中的泛型信息是编译时的，泛型信息在运行时是不存在的。

        Dart的泛型类型是固化的，在运行时也有可以判断的具体类型。

6.2 示例

var list = List<String>();   
list.add('aaa');   
list.add('bbb');   
list.add('ccc');   
print(list);   
var map = Map<int, String>();   
map[1] = 'aaaa';   
map[2] = 'bbbb';  
map[3] = 'cccc';   
print(map);