06 Dart 基础 类和对象

一 对象的基本概念

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

封装：封装是对象和类概念的主要特性。封装，把客观事物封装成抽象的类，并且把自己的部分属性和方法提供给其他对象调用, 而一部分属性和方法则隐藏。

继承：面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

多态：允许将子类类型的指针赋值给父类类型的指针, 同一个函数调用会有不同的执行效果 。

Dart所有的东西都是对象，所有的对象都继承自Object类。

Dart是一门使用类和单继承的面向对象语言，所有的对象都是类的实例，并且所有的类都是Object的子类

一个类通常由属性和方法组成。

// 1 创建一个类
class Person {
  // 定义属性
  String name = "leonardo";
  // late 声明不为空的成员变量,如果不初始化的话需要在属性前面加上late
  late int age;
  // 默认的构造函数
  Person(this.name, this.age);
  // 定义方法
  void getInfo() {
    print("$name ---- $age");
  }
}

void main() {
  runApp(const MyApp());
  // 实例化一个类
  Person p = Person("Leonardo", 88);

  p.getInfo();
  // print(p.name);
}

二 静态方法和属性 Static 和 操作符

// 1 创建一个类
class Person {
  // 定义属性
  static String name = "leonardo from static";
  String nickName = "apple";
  // late 声明不为空的成员变量,如果不初始化的话需要在属性前面加上late
  late int age;
  late int sex;
  // 静态方法
  static getStaticInfo() {
    print(name);
    // print(nickName);访问报错
  }

  // 非静态方法
  void getInfo() {
    // 访问静态的方法
    getStaticInfo();
  }
}

void main() {
  runApp(const MyApp());
  // Person().getStaticInfo();

  Person p = Person();
  p.getInfo();

  //  类型判断
  if (p is Person) {
    print("is person correct");
  }

  // 级联操作服 ..
  // 可以让你在同一个对象上连续调用多个对象的变量或方法。
  p
    ..nickName = "apple"
    ..age = 1
    ..sex = 1;
}

三 类的继承

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

Dart中的类的继承：

1、子类使用extends关键词来继承父类

2、子类会继承父类里面可见的属性和方法 但是不会继承构造函数

3、子类能复写父类的方法 getter和setter

// 1 创建一个类
class Person {
  // 定义属性
  late String name = "leonardo from static";
  // late 声明不为空的成员变量,如果不初始化的话需要在属性前面加上late
  late int age;
  // 定义一个构造函数
  Person(this.name, this.age);
  void printInfo() {
    print("$name --- $age");
  }
}

// 类的继承
class Worker extends Person {
  String partment = "Human resource";
  // 父类实现构造函数 子类必须必须把参数传递给父类
  Worker(super.name, super.age);
  // 重写父类的方法
  @override
  void printInfo() {
    // TODO: implement printInfo
    print("worker --- $name --- $age");
  }
}

void main() {
  runApp(const MyApp());
  // Person().getStaticInfo();

  Worker w = Worker("LeonardoFibonacci", 32);
  w.printInfo();
}

四 抽象类

// 1 创建一个抽象类
abstract class Animal {
  // 定义抽象方法
  eat();
  run();
}

// 继承自抽象类的子类 必须实现抽象类中抽象方法
class Dog extends Animal {
  @override
  eat() {
    // TODO: implement eat
    print(" dog eat");
  }

  @override
  run() {
    // TODO: implement run
    print("dog run");
  }
}

class Cat extends Animal {
  @override
  eat() {
    // TODO: implement eat
    print(" cat eat");
  }

  @override
  run() {
    // TODO: implement run
    print(" cat run");
  }
}

void main() {
  runApp(const MyApp());
  // Person().getStaticInfo();

  // Animal 抽象类是没有办法直接被实例化的
  Dog d = new Dog();
  d.eat();
  d.run();
}

五 多态

允许将子类类型的指针赋值给父类类型的指针, 同一个函数调用会有不同的执行效果 。

子类的实例赋值给父类的引用。 多态就是父类定义一个方法不去实现，让继承他的子类去实现，每个子类有不同的表现。

六 implements实现多个接口

// 1 创建一个抽象类
abstract class A {
  // 定义抽象方法
  printA();
}

abstract class B {
  printB();
}

// 定义一个类实现A和B的接口
class C implements A, B {
  @override
  printA() {
    // TODO: implement printA
    print("AAAAAA");
  }

  @override
  printB() {
    // TODO: implement printB
    print("BBBBBB");
  }
}

void main() {
  runApp(const MyApp());
  // Person().getStaticInfo();

  // Animal 抽象类是没有办法直接被实例化的
  C c = new C();
  c.printA();
  c.printB();
}

七 mixins 类似实现多继承

mixins的中文意思是混入，就是在类中混入其他功能。

在Dart中可以使用mixins实现类似多继承的功能

因为mixins使用的条件，随着Dart版本一直在变，这里讲的是Dart2.x中使用mixins的条件：

1、作为mixins的类只能继承自Object，不能继承其他类

2、作为mixins的类不能有构造函数

3、一个类可以mixins多个mixins类

4、mixins绝不是继承，也不是接口，而是一种全新的特性

// 特性1 就是 如果A 类 extends其他类，那么定义C类就会报错，不能mixins 其他类
class A {
  printA() {
    print("AAAAAA");
  }

  run() {
    print("A Run");
  }
}

class B {
  printB() {
    print("BBBBBB");
  }

  run() {
    print("B Run");
  }
}

// 使用with 关键字 mixins
class C with A, B {}

void main() {
  runApp(const MyApp());
  // Person().getStaticInfo();

  // Animal 抽象类是没有办法直接被实例化的
  C c = new C();
  c.printA();
  c.printB();
  // 打印结果B run，两个类中都有相同的方法时候 后面覆盖前面的
  c.run();
  // 以下打印结果全是true mixins的实例类型是什么？很简单，mixins的类型就是其超类的子类型。
  print(c is A);
  print(c is B);
  print(c is C);
}