Dart 面向对象 类 方法

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

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

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

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

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

---

• 构造函数

// class Person{
//   String name='张三';
//   int age=20;
//   //默认构造函数
//   Person(){
//     print('这是构造函数里面的内容  这个方法在实例化的时候触发');
//   }
//   void printInfo(){
//     print("${this.name}----${this.age}");
//   }
// }

// class Person{
//   String name;
//   int age;
//   //默认构造函数
//   Person(String name,int age){
//       this.name=name;
//       this.age=age;
//   }
//   void printInfo(){
//     print("${this.name}----${this.age}");
//   }
// }

class Person{
  String name;
  int age;
  //默认构造函数的简写，通常这么用
  Person(this.name,this.age);
  void printInfo(){
    print("${this.name}----${this.age}");
  }
}

void main(){

  Person p1=new Person('张三',20);
  p1.printInfo();

  Person p2=new Person('李四',25);
  p2.printInfo();

}

区别1：与java的构造函数有点不同的是，dart里面构造函数可以写多个。

class Person{
  String name;
  int age;
  //默认构造函数的简写
  Person(this.name,this.age);

  Person.now(){
    print('我是命名构造函数');
  }

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

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

void main(){

  // var d=new DateTime.now();   //实例化DateTime调用它的命名构造函数
  // print(d);

  //Person p1=new Person('张三', 20);   //默认实例化类的时候调用的是 默认构造函数

  //Person p1=new Person.now();   //命名构造函数

  Person p1=new Person.setInfo('李四',30);
  p1.printInfo(); 
}

区别2：Dart中没有 public private protected这些访问修饰符，但是我们可以使用_把一个属性或者方法定义成私有。

区别3：getter与setter修饰符

class Rect{
  double height;
  double width;
  Rect(this.height,this.width);
  // getter修饰符
  get area{
    return this.height * this.width;
  }
  // setter修饰符
  set areaHeight(value){
    this.height = value;
  }
}

void main() {
  Rect r = Rect(10.0,5.0);
  print(r.area);
  r.areaHeight = 20.0;
  print(r.area);
}

 区别4：Dart可以在构造函数体运行之前初始化实例变量

class Rect{

  int height;
  int width;
  Rect():height=2,width=10{

    print("${this.height}---${this.width}");
  }
  getArea(){
    return this.height*this.width;
  }
}

void main(){
  Rect r=new Rect();
  print(r.getArea()); 

}

---

• Dart中的静态成员与静态方法

class Person {
  static String name = '张三';
  static void show() {
    print(name);
  }
}

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

与java语法基本一样。

静态方法不能访问非静态成员，只能访问静态成员。

非静态方法可以访问非静态成员，也可以访问静态成员。

---

• Dart中的对象操作符

条件运算符——？

class Person{
  String name;
  int age;
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");
  }
}

void main() {
  Person p;
  p.printInfo();  // NoSuchMethodError: The method 'printInfo' was called on null.
  p?.printInfo();  // 如果p不为null时，执行printInfo方法。否则跳过。
}

类型转换（类似Java中的强制转换）——as

 (p as Person).printInfo();

类型判断——is

if(p is Person){
  ...
}

级联操作——..

p..name = "李四"
 ..age = 30
 ..printInfo();

---

• Dart中的super（用于“继承”）

super关键字可以传递参数给父类

class Person {
  String name;
  num age;
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");
  }
}

class Web extends Person{
  String sex;
  Web(String name, num age,String sex) : super(name, age){  // super关键字可以把name和age的值传递给父类
    this.sex=sex;
  }
  run(){
   print("${this.name}---${this.age}--${this.sex}");
  }

}

void main(){ 

  Web w=new Web('张三', 12,"男");

  w.printInfo();

  w.run();

}

super关键字可以调用父类方法

class Person {
  String name;
  num age;
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");
  }
  work(){
    print("${this.name}在工作...");
  }
}

class Web extends Person{
  Web(String name, num age) : super(name, age);

  run(){
    print('run');
    super.work();  //子类调用父类的方法
  }
}

---

• Dart中的抽象类

Dart中抽象类: Dart抽象类主要用于定义标准，子类可以继承抽象类，也可以实现抽象类接口。

1、抽象类通过abstract 关键字来定义

2、Dart中的抽象方法不能用abstract声明，Dart中没有方法体的方法我们称为抽象方法。

3、如果子类继承抽象类必须得实现里面的抽象方法

4、如果把抽象类当做接口实现的话必须得实现抽象类里面定义的所有属性和方法。

5、抽象类不能被实例化，只有继承它的子类可以

extends抽象类 和 implements的区别：

1、如果要复用抽象类里面的方法，并且要用抽象方法约束子类的话我们就用extends继承抽象类

2、如果只是把抽象类当做标准的话我们就用implements实现抽象类

abstract class Animal{
  eat();   //抽象方法
  run();  //抽象方法
  printInfo(){
    print('我是一个抽象类里面的普通方法');
  }
}

class Dog extends Animal{
  @override
  eat() {
     print('小狗在吃骨头');
  }

  @override
  run() {
    print('小狗在跑');
  }
}
class Cat extends Animal{
  @override
  eat() {
    print('小猫在吃老鼠');
  }

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

}

main(){

  Dog d=new Dog();
  d.eat();
  d.printInfo();

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

  // Animal a=new Animal();   //抽象类没法直接被实例化

}

---

• Dart中的多态

Dart中的多态：

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

子类的实例赋值给父类的引用。

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

abstract class Animal{
  eat();   //抽象方法
}

class Dog extends Animal{
  @override
  eat() {
     print('小狗在吃骨头');
  }
}
class Cat extends Animal{
  @override
  eat() {
    print('小猫在吃老鼠');
  }
}

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

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

---

• Dart中的接口

和Java一样，dart也有接口，但是和Java还是有区别的。

首先，dart的接口没有interface关键字定义接口，而是普通类或抽象类都可以作为接口被实现。

同样使用implements关键字进行实现。

但是dart的接口有点奇怪，如果实现的类是普通类，会将普通类和抽象中的属性和方法全部需要覆写一遍。

而因为抽象类可以定义抽象方法，普通类不可以，所以一般如果要实现像Java接口那样的方式，一般会使用抽象类。

建议使用抽象类定义接口。

/*
定义一个DB库 支持 mysql  mssql  mongodb
mysql  mssql  mongodb三个类里面都有同样的方法
*/

abstract class Db{   //当做接口   接口：就是约定 、规范
    String uri;      //数据库的链接地址
    add(String data);
    save();
    delete();
}

class Mysql implements Db{

  @override
  String uri;

  Mysql(this.uri);

  @override
  add(data) {
    print('这是mysql的add方法'+data);
  }

  @override
  delete() {
    return null;
  }

  @override
  save() {
    return null;
  }

  remove(){
    return null;
  }
}

class MsSql implements Db{
  @override
  String uri;

  @override
  add(String data) {
    print('这是mssql的add方法'+data);
  }

  @override
  delete() {
    return null;
  }

  @override
  save() {
    return null;
  }
}

main() {

  Mysql mysql=new Mysql('xxxxxx');

  mysql.add('1243214');
}

---

• Dart中的mixins

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

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

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

1、作为mixins的类只能继承自Object，不能继承其他类
2、作为mixins的类不能有构造函数
3、一个类可以mixins多个mixins类
4、mixins绝不是继承，也不是接口，而是一种全新的特性

class Person{
  String name;
  num age;
  Person(this.name,this.age);
  printInfo(){
    print('${this.name}----${this.age}');
  }
  void run(){
    print("Person Run");
  }
}

class A {
  String info="this is A";
  void printA(){
    print("A");
  }
  void run(){
    print("A Run");
  }
}

class B {
  void printB(){
    print("B");
  }
  void run(){
    print("B Run");
  }
}

class C extends Person with B,A{
  C(String name, num age) : super(name, age);

}

void main(){
  var c=new C('张三',20);
  c.printInfo();  // 张三----20
  c.printB();  //B
  print(c.info);  // this is A
  c.run();  // A Run（如果有同样的方法，取最后的mixins类的方法）
}

---

• Dart中的泛型

泛型方法

void main() {

  T getData<T>(T value){
    return value;
  }

  String result = getData<String>("你好");
  print(result);
}

泛型类

class PrintClass<T> {
  List list = new List<T>();

  void add(T value){
    this.list.add(value);
  }

  void printInfo(){
    for(var i = 0; i < this.list.length; i++) {
      print(this.list[i]);
    }
  }
}

void main() {
  PrintClass p = new PrintClass<String>();
  p.add("你好");
  p.add("再见");
  p.printInfo();
}

泛型接口

abstract class Cache<T>{
  getByKey(String key);
  void setByKey(String key, T value);
}

class FlieCache<T> implements Cache<T>{
  @override
  getByKey(String key) {
    return null;
  }

  @override
  void setByKey(String key, T value) {
   print("我是文件缓存 把key=${key}  value=${value}的数据写入到了文件中");
  }
}

class MemoryCache<T> implements Cache<T>{
  @override
  getByKey(String key) {
    return null;
  }

  @override
  void setByKey(String key, T value) {
       print("我是内存缓存 把key=${key}  value=${value} 写入到了内存中");
  }
}

void main(){
  MemoryCache m1=new MemoryCache<String>();
  m1.setByKey('index', '首页数据');

  MemoryCache m2=new MemoryCache<Map>();
  m2.setByKey('index', {"name":"张三","age":20});
}