Dart 中的类 抽象类 多态 继承 接口 以及 Mixins

时间  2019-11-24
标签 dart 抽象 继承 接口 以及 mixins 栏目 软件设计 繁體版
原文   原文链接

09 Dart中的对象 类

09-1 对象 类

  • 面向对象编程(OOP)的三个基本特征是：封装、继承、多态sql

    • 封装：封装是对象和类概念的主要特性。封装，把客观事物封装成抽象的类，而且把本身的部分属性和方法提供给其余对象调用, 而一部分属性和方法则隐藏。
    • 继承：面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可使用现有类的功能，并在无需从新编写原来的类的状况下对这些功能进行扩展。
    • 多态：容许将子类类型的指针赋值给父类类型的指针, 同一个函数调用会有不一样的执行效果 。

  • Dart全部的东西都是对象，全部的对象都继承自Object类。数据库

  • Dart是一门使用类和单继承的面向对象语言，全部的对象都是类的实例，而且全部的类都是Object的子类编程

  • 一个类一般由属性和方法组成。ide

class Person {
    // String name = '张三';
    // int age = 32;
    String name;
    int age;

    // 构造函数在实例化的时候触发
    // Person() {
      // print('构造函数在实例化的时候触发');
    // }

    // Person(String name, int age) {
      // this.name = name;
      // this.age = age;
    // }

    Person(this.name, this.age);

    // 命名构造函数
    Person.setInfo(String name, int age) {
      this.name = name;
      this.age = age;
    }

    void getInfo() {
      print('${this.name}---${this.age}');
    }

    void setInfo(int age) {
      this.age = age;
    }
  }

  void main() {
    Person p2 = new Person('Hiraku', 29);
    p2.setInfo(28);
    p2.getInfo();

    Person p3 = new Person.setInfo('Hiraku', 29);
    p3.getInfo();
  }
复制代码

09-2 私有属性

  • dart 中没有私有属性和私有方法，不像其余面向对象的语言有 public private protected 等修饰符
  • 将类单独抽离到一个文件夹，而后加上 _ 表示私有属性

09-3 类中的 setter 和 getter

  • setter
class Reac {
  num height;
  num width;

  Reac(this.height, this.width);

  get area {
    return this.height * this.width;
  }
}

void main() {
  Reac r = new Reac(8, 16);

  print('面积：${r.area}');
}
复制代码
  • getter
class Reac {
  num height;
  num width;

  Reac(this.height, this.width);

  set reacHeight(num val) {
    this.height = val;
  }

  get area {
    return this.height * this.width;
  }
}

void main() {
  Reac r = new Reac(8, 16);
  r.reacHeight = 1;

  print('面积：${r.area}');
}
复制代码

09-4 类里面的初始化列表

class Reac {
  num height;
  num width;

  Reac():height = 20, width = 30{
    print('${this.height}===${this.width}');
  }

  set reacHeight(num val) {
    this.height = val;
  }

  get area {
    return this.height * this.width;
  }
}

void main() {
  Reac r = new Reac();

  print('面积：${r.area}');
}
复制代码

10 Dart中的类 静态成员 操做符 类的继承

10-1 Dart中的静态成员:

  • 一、使用static 关键字来实现类级别的变量和函数
  • 二、静态方法不能访问非静态成员，非静态方法能够访问静态成员
class Person {
  static String name = '张三';
  static void show() {
    print(name);
  }
}

void main() {
  print(Person.name);
  Person.show();  
}
复制代码
class Person {
  static String name = '张三';
  int age=20;
  
  static void show() {
    print(name);
  }
  void printInfo() {  /*非静态方法能够访问静态成员以及非静态成员*/
    // print(name); // 访问静态属性
    // print(this.age); // 访问非静态属性

    show();   // 调用静态方法
  }
  static void printUserInfo() {// 静态方法
    print(name);   // 静态属性
    show();        // 静态方法

    // print(this.age); // 静态方法无法访问非静态的属性
    // this.printInfo(); // 静态方法无法访问非静态的方法
    // printInfo();
  }
}

void main() {
  // print(Person.name);
  // Person.show(); 

  // Person p = new Person();
  // p.printInfo(); 

  Person.printUserInfo();
}
复制代码

10-2 Dart中的对象操做符

  • ? 条件运算符 （了解）
  • as 类型转换
  • is 类型判断
  • .. 级联操做 （连缀） (记住)
class Person {
    String name;
    int age;
    Person(this.name, this.age);

    printInfo() {
      print('${this.name}--${this.age}');
    }
  }

  void main() {
    Person p;
    p.printInfo(); // 报错

    p?.printInfo();

    print(p is Person); // true
    print(p is Object); // true
  }

  void main() {
    var p1;
    p1 = '';
    p1 = new Person();
    (p1 as Person).printInfo();
  }

  void main() {
    Person p1 = new Person('Hiraku', 29);
    p1.printInfo(); // Hiraku--29

    p1.name = '马红琴';
    p1.age = 18;
    pi.printInfo(); // 马红琴--18

    p1..name = '马红琴'
      ..age = 18
      ..pringInfo(); // 马红琴--18
  }
复制代码

10-3 面向对象的三大特性：封装 、继承、多态

  • Dart中的类的继承：
    • 一、子类使用 extends 关键词来继承父类
    • 二、子类会继承父类里面可见的属性和方法 可是不会继承构造函数
    • 三、子类能复写父类的方法 getter 和 setter
class Person {
  String name;
  int age;

  Person(this.name, this.age);
  Person.work(this.name) { // 命名构造函数
    print('${this.name} is working');
  };

  void printInfo() {
    print('${this.name}--${this.age}');
  }

  void isJoking() {
    print('${this.name}---is joking');
  }
}

class Web extends Person {
  String sex;

  Web(String name, int age, String sex) : super(name, age) {
    this.sex = sex;
  }

  void printFun() {
    print('${this.name}--${this.age}--${this.sex}');
  }
}

class Design extends Person {
  String sex;

  Design(String name, int age, String sex) : super.work(name) {
    this.age = age;
    this.sex = sex;
  }

  void printFun() {
    super.isJoking(); // 子类调用父类的方法
    print('${this.name}--${this.age}--${this.sex}');
  }

  @overage
  void printInfo() { // 复写父类方法
    print('姓名：${this.name}');
  }
}

void main() {
  Web w = new Web('Hiraku', 29, '女');
  Design d = new Design('Hiraku', 29, '女');

  w.printFun();
  d.printFun();
}
复制代码

11 Dart中的抽象类 多态 以及接口

11-1 Dart 中的抽象类

  • Dart中抽象类: Dart 抽象类主要用于定义标准，子类能够继承抽象类，也能够实现抽象类接口。函数

    • 一、抽象类经过 abstract 关键字来定义
    • 二、Dart 中的抽象方法不能用 abstract 声明，Dart 中没有方法体的方法咱们称为抽象方法。
    • 三、若是子类继承抽象类必须得实现里面的抽象方法
    • 四、若是把抽象类当作接口实现的话必须得实现抽象类里面定义的全部属性和方法。
    • 五、抽象类不能被实例化，只有继承它的子类能够

  • extends 抽象类和 implements 的区别：ui

    • 一、若是要复用抽象类里面的方法，而且要用抽象方法约束自类的话咱们就用 extends 继承抽象类
    • 二、若是只是把抽象类当作标准的话咱们就用 implements 实现抽象类

11-2 Dart 中的多态

  • 容许将子类类型的指针赋值给父类类型的指针, 同一个函数调用会有不一样的执行效果
  • 子类的实例赋值给父类的引用
  • 多态就是父类定义一个方法不去实现，让继承他的子类去实现，每一个子类有不一样的表现
abstract class Animal { // 抽象类用 abstract 定义
  Animal();
  eat(); // 抽象方法，主要用来约束子类，不能使用 abstract 定义，而是没有方法体的方式定义抽象方法
  run();

  printCommonFunc() {
    print('我是抽象类的抽象方法');
  }
}

class Dog extends Animal {
  @override
  eat() { // 必须得实现抽象方法
    print('小狗在吃骨头');
  }

  @override
  run() {
    print('小狗在遛弯');
  }

  printInfo() {
    print('我是小狗');
  }
}

class Cat extends Animal {
  @override
  eat() {
    print('小猫在吃猫食');
  }

  @override
  run() {
    print('小猫在散步');
  }

  printInfo() {
    print('我是小猫咪');
  }
}

void main() {
  Dog d = new Dog();
  d.eat();
  d.run();

  Cat c = new Cat();
  c.eat();
  c.run();

  Animal animalDog = new Dog();
  animalDog.eat();
  animalDog.printCommonFunc();
  // animalDog.printInfo(); // 报错，由于子类的实例赋值给父类的引用

  Animal animalCat = new Cat();
  animalCat.eat();
}
复制代码

11-4 dart 中的接口

  • 和Java同样，dart也有接口，可是和Java仍是有区别的
    • 首先，dart 的接口没有 interface 关键字定义接口，而是普通类或抽象类均可以做为接口被实现
    • 一样使用 implements 关键字进行实现
    • 可是 dart 的接口有点奇怪，若是实现的类是普通类，会将普通类和抽象中的属性的方法所有须要覆写一遍
    • 而由于抽象类能够定义抽象方法，普通类不能够，因此通常若是要实现像Java接口那样的方式，通常会使用抽象类
    • 建议使用抽象类定义接口
abstract class Db {  // 看成接口：规范 规定
  String uri;  // 数据库链接地址
  add();
  save();
  delete();
}

class Mysql implements Db {
  @override
  String uri;

  @override
  add() {
    // TODO: implement add
    return null;
  }

  @override
  delete() {
    // TODO: implement delete
    return null;
  }

  @override
  save() {
    // TODO: implement save
    return null;
  }
  
}

class MongoDb implements Db {
  @override
  String uri;

  @override
  add() {
    // TODO: implement add
    return null;
  }

  @override
  delete() {
    // TODO: implement delete
    return null;
  }

  @override
  save() {
    // TODO: implement save
    return null;
  }
  
}
复制代码

12 Dart中一个类实现多个接口以及 Dart 中的 Mixins

12-1 实现多个接口

abstract class A {
  String name;
  printA();
}

abstract class B {
  printB();
}

class C implements A,B {  
  @override
  String name;  
  @override
  printA() {
    print('printA');
  }
  @override
  printB() {
    // TODO: implement printB
    return null;
  }
  
}

void main(){
  C c=new C();
  c.printA();

}
复制代码

12-2 实现多个接口

  • mixins 的中文意思是混入，就是在类中混入其余功能
  • 在 Dart 中可使用 mixins 实现相似多继承的功能
  • 由于 mixins 使用的条件，随着 Dart 版本一直在变，这里讲的是D art2.x 中使用 mixins 的条件：
    • 一、做为 mixins 的类只能继承自 Object，不能继承其余类
    • 二、做为 mixins 的类不能有构造函数
    • 三、一个类能够 mixins 多个 mixins 类
    • 四、mixins 毫不是继承，也不是接口，而是一种全新的特性
class Animal {
  String name;
  int age;
  Animal(this.name, this.age);

  funcAnimal() {
    print('${this.name}--${this.age}');
  }
}
class A {
  String info = 'This is a attribute in A';

  funcA() {
    print('我是 A');
  }
}

class B {
  funcB() {
    print('我是 B');
  }
}

class C extends Animal with A, B {
  C(String name, int age) : super(name, age);
  funcC() {
    print('我是 C 的方法');
  }
}

void main() {
  C c = new C('小猫', 3);
  c.funcA();
  c.funcB();
  c.funcC();
  c.funcAnimal();
  print(c.info);

  print(c is A); // true
  print(c is Animal); // true
}
复制代码
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程