Flutter開發之Dart中的類和對象

• 原文博客地址: Flutter和Dart系列文章
• 上次學習Flutter已經是整整一年前的事情了,之後因爲工作重心主要放在了React Native開發形式上
• 現在重新撿起Flutter, 也是計劃系統性的從頭開始重新學習Dart和Flutter
• 這篇Dart筆記主要就是記錄Dart語言中的類和對象

類及其構造方法

Dart也是一門面向對象的開發語言，面向對象中非常重要的概念就是類，通過類的初始化創建一個對象

類的定義

• 在Dart中，定義類用class關鍵字
• 當未指明其父類的時候, 默認是繼承自Object的, 格式如下:

class 類名 {
  類型 成員名;
  返回值類型 方法名(參數列表) {
    方法體
  }
}

• 在Dart語言中, 在類中使用屬性(成員/實例變量)時, 有必要時是通過this獲取的
• 但是下面在getsize方法中並沒有加this
• 這裏需要注意的是: Dart的開發風格中，在方法中通常使用屬性時，會省略this，但是有命名衝突時，this不能省略

// 創建類
class Point {
  // 定義變量
  int x;

  void getsize() {
    print('x = $x');
  }
}

// 類的初始化
main(List<String> args) {
    // 從Dart2開始，new關鍵字可以省略
    var point = new Point();
    point.x = 1;
    point.getsize();
}

構造方法

• 當通過類創建一個對象時，會調用這個類的構造方法
  • 在Dart語言中,如果類中沒有明確指定構造方法時，將默認擁有一個無參的構造方法()
  • 上面得到的point對象調用的就是默認的無參構造方法
• 也可以根據自己的需求自定義構造方法
  • 當我們創建了自己的構造方法時，默認的無參的構造方法將會失效，不能使用,否則會報錯
  • 因爲Dart本身不支持函數的重載, 所以如果我們明確的寫一個默認的構造方法，就會和我們自定義的構造方法衝突

class Student {
  String name;
  int age;

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

• 在上面構造方法中主要實現的就是通過構造函數的參數給類的戶型賦值
• 爲了簡化這一過程, Dart提供了一種更加簡潔的語法糖形式

class Student1 {
  String name;
  int age;

  // 這裏和上面的Studeng的構造方法等價
  Student1(this.name, this.age);
}

命名構造方法

• 在實際開發中, 很明顯一個構造方法的確是不夠我們使用的
• 而且Dart又不支持函數的重載, 不能創建愛你相同名稱不同參數的構造方法
• 這就衍生出了另外一中構造方法:命名構造方法

class Model {
  String name;
  int age;

  Model(this.name, this.age);

  // 命名構造方法
  Model.withNameAndAge(String name, int age) {
    this.name = name;
    this.age = age;
  }
  // 命名構造方法
  Model.initJson(Map<String, Object> map) {
    this.name = map['name'];
    this.age = map['age'];
  }
}


// 初始化對象
main() {
  // 普通構造方法
  var model0 = Model('name', 12);
  // 命名構造方法
  var model1 = Model.withNameAndAge('titan', 12);
  var model2 = Model.initJson({'name': 'jun', 'age': 18});
}

初始化列表

幾種方式定義的屬性都是可變的, 如果定義的屬性是final不可重新賦值的又該如何實現

class Teacher {
  final String name;
  final int age;

  // 1. 這裏會有一個錯誤提示: All final variables must be initialized, but 'age' and 'name' are not
  Teacher(String name, int age) {
    //2. 這裏也會有一個錯誤提示: 'name' can't be used as a setter because it's final
    this.name = name;
    this.age = age;
  }
}

• 上面第一處錯誤主要是因爲: 在Dart中在執行下面{ }中的代碼的時候, 表示Teacher對象已經初始化完畢了
• 所以在執行{ }之前, 必須保證name和age被初始化了
• 而且final修飾的屬性是不可被重新賦值的, 所以纔會報錯
• 或者也可以使用函數中的命名可選參數處理

class Size {
  final double width;
  final double height;
  final double area;

  // 命名可選參數
  Size(this.width, this.height, { this.area = 10 }); 
}

• 上面通過命名可選參數的形式, 給參數設置默認值也是可以的, 但是不同的是area只能設置具體的數值, 不能設置表達式
• 初始化列表的形式不但可以設置具體的數值, 也可以設置默認值爲表達式的形式

class Size {
  final double width;
  final double height;
  final double area;

  // 多個屬性使用逗號分隔
  Size(double width, double height): 
    this.width = width,
    this.height = height,
    this.area = width * height;
}

重定向構造方法

• 下面的構造函數中, 我們只能通過傳入兩個參數來獲取一個對象
• 如果在某些情況下, 希望只通過一個name變量來獲取一個對象
• 這種情況下, 就可以通過在構造方法中去調用另外一個構造方法, 這個時候可以使用重定向構造方法
• 需要注意的是: 在一個構造函數中，去調用另外一個構造函數, 是在冒號後面使用this調用

class Point {
  String name;
  int age;

  Point(this.name, this.age);

  // 重定向的構造方法
  Point.fromName(String name): this(name, 0);
}

// 使用方法
var point = Point.fromName("name");
print(point.age);  // 輸出: 0

常量構造函數

• 在某些情況下, 我們希望通過構造函數, 只要傳入相同的參數, 那麼得到的對象就是同一個
• 在Dart中判斷兩個對象是否是同一個的方法是通過函數identical判斷, 返回值是一個布爾值

// 普通構造函數
class Person {
  String name;
  int age;

  Person(this.name, this.age);
}

// 初始化列表
class Size {
  final double width;
  final double height;
  final double area;

  // 多個屬性使用逗號分隔
  Size(double width, double height): 
    this.width = width,
    this.height = height,
    this.area = width * height;
}

main(List<String> args) {
  var p1 = Person("name", 10);
  var p2 = Person("name", 10);
  // 判斷兩個對象是不是同一個
  print(identical(p1, p2));    /// false


  var s1 = Size(10, 20);
  var s2 = Size(10, 20);
  // 判斷兩個對象是不是同一個
  print(identical(s1, s2));    /// false
}

• 很明顯上面兩種方式初始化的對象都不是同一個
• 其實在Dart中如果將構造方法前加const進行修飾，那麼可以保證相同的參數，創建出來的對象是相同的
• 這樣的構造方法就稱之爲常量構造方法

// 常量構造方法
class Teacher {
  final String name;

  const Teacher(this.name);
}

main(List<String> args) {
  // 常量構造方法
  // 這裏的const不可以省略
  var t1 = const Teacher("name");
  var t2 = const Teacher("name");
  print(identical(t1, t2));    /// true
  
  // 這裏的const可以省略
  const t3 = Teacher("name");
  const t4 = Teacher("name");
  print(identical(t3, t4));    /// true
  print(identical(t1, t4));    /// true
}

常量構造方法有一些注意點:

• 擁有常量構造方法的類中，所有的成員變量必須是final修飾的.
• 爲了可以通過常量構造方法，創建出相同的對象，不再使用new關鍵字，而是使用const關鍵字
• 如果是將結果賦值給const修飾的標識符時，const可以省略.

工廠構造方法

• 在Dart提供了factory關鍵字, 用於通過工廠去獲取對象
• 普通的構造函數, 會默認返回創建出來的對象, 不需要我們手動return
• 工廠構造方法, 需要手動返回一個對象
• 同樣和上面一樣的目的, 只要傳入相同的參數, 那麼得到的對象就是同一個, 下面通過工廠構造函數的方式實現

main(List<String> args) {
  
  var p1 = Person.fromName("titan");
  var p2 = Person.fromName("titan");
  print(identical(p1, p2)); // true
}

class Person {
  String name;

  // 用於緩存創建的對象, 避免大量的創建和銷燬對象
  static final Map<String, Person> _cache = <String, Person>{};

  factory Person.fromName(String name) {
    if (_cache.containsKey(name)) {
      return _cache[name];
    } else {
      final p = Person(name);
      _cache[name] = p;
      return p;
    }
  }

  Person(this.name);
}

類的繼承

setter和getter

• Dart中類定義的屬性默認是可以直接被外界訪問的
• Dart中也存在setter和getter方法, 用於監聽累的屬性被訪問的過程

main() {
  var people = People('top');
  people.setName = 'top';
  print(people.getName);
  print(people.name);

  var person = Person('titan');
  person.setName = 'jun';
  print(person.getName);
}


class People {
  String name;

  // setter
  set setName(String value) {
    this.name = value;
  }
  // getter
  String get getName {
    return 'titanjun';
  }

  People(this.name);
}

• 上面setName和getName是自定義的, 你也可以命名爲setterName和getterName等
• 還有就是上述兩個方法不是系統自動生成的, 是需要我們手動添加的
• 簡單的方式也可以使用箭頭函數

class Person {
  String name;

  // setter
  set setName(String value) => this.name = value;
  // getter
  String get getName => 'titanjun';

  Person(this.name);
}

類的繼承

• 在Dart中同樣支持類的繼承, 繼承使用extends關鍵字，子類中使用super來訪問父類
• 父類中除了構造方法外, 所有的成員變量和方法都會被繼承
• 子類可以擁有自己的成員變量, 並且可以對父類的方法進行重寫
• 子類中可以調用父類的構造方法，對某些屬性進行初始化：
  • 子類的構造方法在執行前，將隱含調用父類的無參默認構造方法（沒有參數且與類同名的構造方法）
  • 如果父類沒有無參默認構造方法，則子類的構造方法必須在初始化列表中通過super顯式調用父類的某個構造方法

class People {
  String name;

  People(this.name);

  void eat() {
    print('people -- eat');
  }
}

class Person extends People {
  int age;

  Person(String name, int age): this.age = age, super(name);

  @override
  void eat() {
    // 這裏的super, 看個人需求是否調用
    super.eat();
    print('Person -- eat');
  }
}

main(List<String> args) {
  var people = People('name');
  people.eat();

  var person = Person("top", 10);
  person.eat();
}

抽象類

• 在Dart中抽象類是使用abstract聲明的類
• 在Dart中沒有具體實現的方法(沒有方法體)，就是抽象方法
• 抽象方法，必須存在於抽象類中, 抽象類不能實例化
• 抽象類中的抽象方法必須被子類實現, 抽象類中的已經被實現方法, 可以不被子類重寫

abstract class Size {
  int width;
  int height;

  Size(this.width, this.height);

  void getSize();

  int getArea() {
    return this.width * this.height;
  }
}

class Area extends Size {
  @override
  void getSize() {
    print('width = $width, height = $height');
  }

  Area(int width, int height): super(width, height);
}

main(List<String> args) {
  // 實例化Size會報錯: Abstract classes can't be instantiated
  // var size = Size(20, 2);
  var area = Area(10, 2);
  area.getArea();
  print(area.getArea());
}

類成員和方法

在Dart中我們使用static關鍵字來定義類成員和類方法

main() {
 var person = Person();
 print(person.firstName);
 person.hide();

 print(Person.lastName);
 Person.show();
}


class Person {

  String firstName = 'top';
  // 不能使用this調用靜態屬性
  static String lastName = 'titanjun';


  void hide() {
    print('titanjun');
  }

  // 靜態方法
  static void show() {
    print('https://www.$lastName.top');
  }
}

多繼承

在Dart中只有單繼承, 是不支持多繼承的, 但是我們卻可以通過其他方式間接實現多繼承問題

隱式接口

• Dart中的接口比較特殊, 沒有一個專門的關鍵字來聲明接口, 默認情況下所有的類都是隱式接口
• 默認情況下，定義的每個類都相當於默認也聲明瞭一個接口，可以由其他的類來實現
• 在Dart開發中，我們通常將用於給別人實現的類聲明爲抽象類
• 當將一個類能夠做接口使用時, 那麼實現這個接口的類, 必須實現這個接口中的所有方法
• 在Dart中通過implements來實現多繼承問題, 但是必須實現這個接口中的所有方法, 而且在方法的實現中不能調用super方法

abstract class Woman {
  void eat();

  void student() {
    print("student");
  }
}

class Man {
  void run() {
    print("runner");
  }
}


class Student implements Woman, Man {
  @override
  void eat() {
    print("eat");
  }

  @override
  void student() {
    print("student--student");
  }

  @override
  void run() {
    // 這裏不能調用super方法
    // super.run(); 
    print("run");
  }
}

main(List<String> args) {
  var stu = Student();
  stu.eat();
  stu.run();
  stu.student();
}

Mixin混入

• 在通過implements實現某個類時，類中所有的方法都必須被重新實現(無論這個類原來是否已經實現過該方法)
• 但是某些情況下，一個類可能希望直接複用之前類的原有實現方案
• Dart提供了另外一種方案: Mixin混入的方式
  • 除了可以通過class定義類之外，也可以通過mixin關鍵字來定義一個類。
  • 只是通過mixin定義的類用於被其他類混入使用，通過with關鍵字來進行混入

mixin Runner {
  run() {
    print('在奔跑');
  }
}

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

// 這裏可以對原方法不做任何實現
class Bird with Runner, Flyer {  }

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

參考資料

• Flutter之搞定Dart二: coderwhy老師的公衆號知識
• Dart官網語法介紹-英文版
• Dart語言中文社區

---

歡迎您掃一掃下面的微信公衆號，訂閱我的博客！