四、大话Flutter——Dart的类和对象

Haha_bj
195 阅读5分钟

一、类的定义

在Dart中，定义类用class关键字。 类通常由两部分组成：成员（member）和方法（method）。

 class 类名 {
      类型 成员名;
      返回值类型 方法名(参数列表) {
        方法体
      }
    }
  • 这里有一个注意点:  我们在方法中使用属性(成员/实例变量)时，并没有加this；
  • Dart的开发风格中，在方法中通常使用属性时，会省略this，但是有命名冲突时，this不能省略；
 main(List<String> args) {
      var p = Persion();
      p.name = '哈哈';
      p.run();
    }

    class Persion {
      // late 表示推迟赋值
      late String name;
      run() {
        print('$name在跑');
      }
    }

二、类的构造方法

一、普通构造方法

我们知道, 当通过类创建一个对象时，会调用这个类的构造方法。

  • 当类中没有明确指定构造方法时，将默认拥有一个无参的构造方法。
  • 前面的Person中我们就是在调用这个构造方法。

我们也可以根据自己的需求，定义自己的构造方法:

  • 注意当有了自己的构造方法时，默认的构造方法将会失效，不能使用
    • 当然，你可能希望明确的写一个默认的构造方法，但是会和我们自定义的构造方法冲突；
    • 这是因为Dart本身不支持函数的重载（名称相同, 参数不同的方式）。
    class Persion {
      // late 表示推迟赋值
      late String name;
      late int age;
       Persion(String name, int age) {
        this.name = name;
        this.age = age;
      }

      run() {
        print('$name在跑');
      }
      
    }

另外，在实现构造方法时，通常做的事情就是通过参数给属性赋值

为了简化这一过程, Dart提供了一种更加简洁的语法糖形式。

     Persion(String name, int age) {
             this.name = name;
             this.age = age;
           }
     // 与上面是等价的      
    Persion(this.name,this.age)

二、命名构造方法

但是在开发中, 我们确实希望实现更多的构造方法，怎么办呢？

  • 因为不支持方法（函数）的重载，所以我们没办法创建相同名称的构造方法。 可以使用命名构造方法:
    //命名构造方法
      Persion.argments(String name, int age) {
        this.name = name;
        this.age = age;
      }
      Persion.fromMap(Map<String, Object> map) {
        this.name = map['name'].toString();
        this.age = int.parse(map['age'].toString());
      }

三、初始化列表

我们来重新定义一个类Point, 传入x/y，可以得到它们的距离distance:

    import 'dart:math';
    class Point {
      final num x;
      final num y;
      final num distance;
      Point(this.x, this.y) : distance = sqrt(x * x + y * y);
    }

上面这种初始化变量的方法, 我们称之为初始化列表(Initializer list)

四、重定向构造方法

在某些情况下, 我们希望在一个构造方法中去调用另外一个构造方法, 这个时候可以使用重定向构造方法：

  • 在一个构造函数中，去调用另外一个构造函数（注意：是在冒号后面使用this调用）
class Persion {
      late String name;
      late int age;
      Persion(this.name, this.age);
      // 调用另一个初始化器
      Persion.actionName(String name) : this(name, 0);

    }

五、常量构造方法

在某种情况下，传入相同值时，我们希望返回同一个对象，这个时候，可以使用常量构造方法.

默认情况下，创建对象时，即使传入相同的参数，创建出来的也不是同一个对象，例:

  • 这里我们使用identical(对象1, 对象2)函数来判断两个对象是否是同一个对象:
    main(List<String> args) {
      var p1 = Persion("哈哈");
      var p2 = Persion("哈哈");
      print(identical(p1, p2)); // false  不是同一个对象
    }

    class Persion {
      late String name;
      Persion(this.name);
    }

将构造方法前加const进行修饰，那么可以保证同一个参数，创建出来的对象是相同的。 这样的构造方法就称之为常量构造方法

    main(List<String> args) {
      var p1 = const Persion("哈哈");
      var p2 = const Persion("哈哈");
      print(identical(p1, p2)); // true  是同一个对象
    }

    class Persion {
      final String name;
      const Persion(this.name);
    }

常量构造方法有一些注意点:

  • 注意一：拥有常量构造方法的类中，所有的成员变量必须是final修饰的.
  • 注意二:  为了可以通过常量构造方法，创建出相同的对象，不再使用 new关键字，而是使用const关键字
    • 如果是将结果赋值给const修饰的标识符时，const可以省略.

六、工厂构造方法

Dart提供了factory关键字, 用于通过工厂去获取对象

 main(List<String> args) {
      var p1 = Persion('哈哈');
      var p2 = Persion('哈哈');
      print(identical(p1, p2)); // true
    }

    class Persion {
      late String name;
      static final Map<String, Persion> _cache = <String, Persion>{};
      Persion._internal(this.name);
      factory Persion(String name) {
        if (_cache.containsKey(name)) {
          return _cache[name]!;
        } else {
          final p = Persion._internal(name);
          _cache[name] = p;
          return p;
        }
      }
    }

三、setter和getter

默认情况下，Dart中类定义的属性是可以直接被外界访问的。

但是某些情况下，我们希望监控这个类的属性被访问的过程，这个时候就可以使用setter和getter了

通过_定义的变量和方法是私有变量和私有方法，作用域是当前文件。

void main(){
  Dog g = Dog("Red");
  print(g.color);
  g.color = "Whrte";
  print(g.color);
}
// 通过_定义的变量和方法是私有变量和私有方法，作用域是当前文件。
class Dog{
  String _color;
  set color(String color){
    _color = color;
  }
  String get color{
    return _color;
  }
  Dog(this._color);

  _run(){
    print("跑方法");
  }
}

四、类的继承

面向对象的其中一大特性就是继承，继承不仅仅可以减少我们的代码量，也是多态的使用前提。

Dart中的继承使用extends关键字，子类中使用super来访问父类。

父类中的所有成员变量和方法都会被继承,，但是构造方法除外。

    class Animal {
      late int age;
      run() {
        print("在跑步");
      }
    }

    //Persion 继承自  Animal
    class Persion extends Animal {}

    main(List<String> args) {
      var p = Persion();
      p.age = 20;
      p.run();
    }
```Dart 
子类可以`拥有自己的成员变量,` 并且可以`对父类的方法进行重写`：

```Dart
 class Animal {
      late int age;
      run() {
        print("在跑步");
      }
    }

    //Persion 继承自  Animal
    class Persion extends Animal {
      late String name;
      @override
      run() {
        print("人在跑步");
        //调用父类的方法
        super.run();
      }
    }

    main(List<String> args) {
      var p = Persion();
      p.age = 20;
      p.name = "哈哈";
      p.run();
    }

子类中可以调用父类的构造方法，对某些属性进行初始化：

  • 子类的构造方法在执行前，将隐含调用父类的无参默认构造方法（没有参数且与类同名的构造方法）。
  • 如果父类没有无参默认构造方法，则子类的构造方法必须在初始化列表中通过super显式调用父类的某个构造方法。
    class Animal {
      int age;
      Animal(this.age);
      run() {
        print('在奔跑ing');
      }
    }

    class Person extends Animal {
      String name;
      Person(String name, int age) : name=name, super(age);
      @override
      run() {
        print('$name在奔跑ing');
      }

      @override
      String toString() {
        return 'name=$name, age=$age';
      }
    }

五、抽象类

继承是多态使用的前提。 所以在定义很多通用的调用接口时, 我们通常会让调用者传入父类，通过多态来实现更加灵活的调用方式。

但是，父类本身可能并不需要对某些方法进行具体的实现，所以父类中定义的方法,，我们可以定义为抽象方法。

什么是 抽象方法? 在Dart中没有具体实现的方法(没有方法体)，就是抽象方法。

  • 抽象方法，必须存在于抽象类中。
  • 抽象类是使用abstract声明的类。

下面的代码中, Shape类就是一个抽象类, 其中包含一个抽象方法.

void main(){
  Square s = Square();
  s.getArea();
  s.getPerimeter();
}

// 抽象类是可以被继承的
// 继承抽象类要实现它的抽象方法(没有方法体的方法)，否则也需要将自己定义成抽象类
class Square extends Shape{
  @override
  getArea() {
    print("面积");
  }
}
/// 一个类也可以 implements 关键字来实现一个抽象类，但要实现所有方法，不然编译报错。
class Circle implements Shape{
  @override
  getArea() {
  }
  @override
  getPerimeter() {
  }
}

/// 抽象类
abstract class Shape{
  /// 抽象方法
  getArea();

  /// 默认实现的抽象方法
  getPerimeter(){
    print("周长");
  }
}

注意事项:

  • 注意一：抽象类不能实例化.
  • 注意二：抽象类中的抽象方法必须被子类实现, 抽象类中的已经被实现方法, 可以不被子类重写.
  • 注意三：extends、implements 继承与实现的区别，extends没有方法体的抽象方法，必须实现，有方法体的可以不用实现， implements抽象方法有没有方法体都的实现

六、隐式接口

Dart中的接口比较特殊, 没有一个专门的关键字来声明接口.

默认情况下，定义的每个类都相当于默认也声明了一个接口，可以由其他的类来实现(因为Dart不支持多继承)

在开发中，我们通常将用于给别人实现的类声明为抽象类:

    abstract class Runner {
      run();
    }

    abstract class Flyer {
      fly();
    }

    // implements
    class Persion implements Runner, Flyer {
      @override
      run() {
        // TODO: implement run
        print("在跑");
      }

      @override
      fly() {
        print("在飞");
      }
    }

七、Mixin混入

在通过implements实现某个类时，类中所有的方法都必须被重新实现(无论这个类原来是否已经实现过该方法)。

但是某些情况下，一个类可能希望直接复用之前类的原有实现方案，怎么做呢?

  • 使用继承吗？但是Dart只支持单继承，那么意味着你只能复用一个类的实现。

Dart提供了另外一种方案: Mixin混入的方式

  • 除了可以通过class定义类之外，也可以通过mixin关键字来定义一个类。
  • 只是通过mixin定义的类用于被其他类混入使用，通过with关键字来进行混入。
    mixin Runner {
      run() {
        print('在奔跑');
      }
    }

    mixin Flyer {
      fly() {
        print('在飞翔');
      }
    }

    // implements的方式要求必须对其中的方法进行重新实现
    // class SuperMan implements Runner, Flyer {}

    class SuperMain with Runner, Flyer {

    }
    
    main(List<String> args) {
      var superMan = SuperMain();
      superMan.run();
      superMan.fly();
    }

八、类成员和方法

前面我们在类中定义的成员和方法都属于对象级别的, 在开发中, 我们有时候也需要定义类级别的成员和方法

在Dart中我们使用static关键字来定义

    class Student {
      String name;
      int sno;

      static String time;

      study() {
        print('$name在学习');
      }

      static attendClass() {
        print('去上课');
      }
    }

九、泛型(Generics)

泛型的主要作用1、提高代码的复用度 2、约束参数类型

void main(){
  
  /// 例 1 
  Cache<String> cache = Cache();
  cache.setItem("name", "哈哈");
  String? name = cache.getItem("name");
  print(name);

  ///  例 2
  ///  约束参数类型 必须继承  Zoon
  Member<Cat> m = Member(Cat());

}

// 泛型类
// 泛型类主要作用：提高代码的复用度
class Cache<T>{
  final Map<String,T> _cached = {};
  void setItem(String key, T value){
    _cached[key] = value;
  }
  T? getItem(String key){
    return _cached[key];
  }
}

class Zoon{
}
class Cat extends Zoon{

}
/// 泛型的另一个作用：约束参数类型
class Member<T extends Zoon>{
  final T _zoon;
  Member(this._zoon);

}
avatar
文章
阅读
粉丝