Flutter學習筆記（8）--Dart物件導向

CurtisWgh發表於2019-07-19
Flutter筆記Dart物件

如需轉載，請註明出處：Flutter學習筆記（8）--Dart物件導向

 

Dart作為高階語言，支援物件導向的很多特性，並且支援基於mixin的繼承方式，基於mixin的繼承方式是指：一個類可以繼承自多個父類，相當於其他語言裡的多繼承。所有的類都有同一個基類Object，這和特性類似於Java語言，Java所有的類也都是繼承自Object，也就是說一切皆物件。

//例項化了一個User類的物件user
var user = new User('張三',20);

  • 例項化成員變數

Class User{
    String name;//name 成員變數
    int age;//age 成員變數
}

類定義中所有的變數都會隱式的定義setter方法，針對非空的變數會額外增加getter方法。例項化成員變數請參考如下程式碼：

main(){
    var user = new User();
    user.name = '張三';//相當於使用了name的setter方法
    user.age = 25;
}

  • 建構函式

　　1.常規的建構函式

建構函式是用來構造當前類的函式，是一種特殊的函式，函式名稱必須要和類名相同才行，如下程式碼為User類新增了一個建構函式，函式裡給User類的兩個成員變數初始化了值：

Class User{
    String name;
    int age;
    User(String mName,int mAge){
        this.name = mAge;
        this.age = mAge;
    }
}

this關鍵字指向了當前類的例項，上面的程式碼可以簡化為：

Class User{
    String name;
    int age;

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

第一種沒有簡化的構造方法初始化成員變數是在方法體內進行初始化的，第二種簡化的構造方法初始化成員變數，是在例項化類的時候直接進行賦值初始化的。

　　2.命名的建構函式

使用命名建構函式從另一類或現有的資料中快速實現建構函式，程式碼如下所示：

Class User{
    String name;
    int age;
    //普通建構函式
    User(this.name,this.age);

    //命名建構函式
    User.fromJson(Map json){
        name = json['name'];
        age = json['age'];
    }
}

//在例項化類的時候，如果沒有傳參，會預設呼叫無引數的構造方法
//普通建構函式
var user = new User('張三',25);

//命名建構函式
var user = new User.fromJson(mMapJson);

我對命名建構函式的理解就是起了個名字，在Java裡面，相同引數個數的構造方法只能有一個，在Dart裡面也不例外，那麼如果我們想有多個相同引數個數的構造方法要怎麼做呢，這時候命名構造方法就顯現出他價值了，我們可以給相同引數個數的構造方法起不同的名字，這種就不會有錯誤了。

　　3.子類的建立

注1：子類在繼承父類的時候，如果在父類中有顯示的提供一個無名、無參的建構函式，不會繼承父類無名有參建構函式和命名建構函式，即：子類只會繼承父類無名無參的建構函式。（程式會給類隱式的生成一個無名、無參的建構函式）

注2：子類在繼承父類的時候，如果在父類中沒有有顯示的提供一個無名、無參的建構函式，子類必須手動呼叫父類的一個建構函式，在這種情況下，呼叫的父類的建構函式要放在子類建構函式之後，在子類建構函式體之前，用“：”分隔。

注3：父類的建構函式會在子類的建構函式前呼叫。

注4：預設情況下，子類只能呼叫父類無名、無引數的建構函式。

下面我會用程式碼給大家解釋上面的“注”（開始我也不會，也是上網查資料理解的！！！）

注1和注3：父類中有一個無名、無參的建構函式，子類繼承父類，會預設繼承父類無名、無參的建構函式（即使有其他無名、有參的建構函式或者命名建構函式，子類都不會呼叫），並且，父類的無名、無參的建構函式會在子類的建構函式之前被呼叫。

Class Futher {

    //無名、無參的建構函式
    Futher(){
        print('我是父類無名、無參的建構函式');
    }
}

Class Son extends Futher {
    //因為父類有顯式的宣告一個無名、無參的建構函式，所以不用手動呼叫父類的建構函式。
    Son.fromJson(Map mMapJson){
        print('我是子類的命名建構函式');
    }
}

var son = new Son.fromJson(mMapJson);
//列印結果
//我是父類無名、無參的建構函式
//我是子類的命名構造函

注2：下面程式碼裡，子類的命名構造方法寫了兩種方式，第一種是正確的，第二種是錯誤的，有詳細的註釋， 如果有疑問請留言。

Class Futher {

    //無名、無參的建構函式
    Futher.printSth(){
        print('我是父類無名、無參的建構函式');
    }
}

Class Son extends Futher {
    //因為父類沒有有顯式的宣告一個無名、無參的建構函式，所以需要手動的呼叫父類的建構函式。
    Son.fromJson(Map mMapJson) : super Futher.printSth{
        print('我是子類的命名建構函式');
    }

    //這種寫法會報錯，因為父類中沒有顯示的提供一個無名、無參的建構函式。所以需要像上面那樣，手動呼叫父類的一個建構函式
    Son.fromJson(Map mMapJson){
        print('我是子類的命名建構函式');
    }
}

　　4.建構函式初始化列表

上面在講解常規的建構函式和命名建構函式的時候，示例程式碼都有對類中的成員變數進行了初始化，特點是在建構函式的方法體內進行初始化，初始化成員變數還有另一種方式，就是在建構函式執行前來初始化成員變數。

Class User {
    String name;
    int age;

    User(mName,mAge)
        :name = mName,
        age = mAge{
            // Do Some Thing
        }
}

特點是在建構函式的方法體前（大括號前面）來初始化成員變數，變數間用“，”分隔。

  • 讀取和寫入物件

get()和set()方法是專門用於讀取和寫入物件的屬性的方法，每一個類的例項，系統都會隱式的包含有get()和set()方法。

例如，定義一個矩形的類，有上、下、左、右：top、bottom、left、right四個成員變數，使用get及set關鍵字分別對right、bottom進行獲取和設定值。程式碼如下所示：

Class Rectangle {
    num left;
    num top;
    num width;
    num height;

    Rectangle(this.left,this.top,this.width,this.height);

    num get right => left + width;//獲取righht的值（第一行）

    set right(num value) => left = value - width;//設定right的值，同時left也發生了變化（第二行）

    num get bottom => top + height;//獲取bottom的值（第三行）

    set bottom(num value) => top = value - height;//設定bottom值，同時top也發生了變化（第四行）
}

main(){
    var rect = new Rectangle(3,4,20,15);//例項化Rectangle，並給類中的4個變數進行初始化賦值

    print('left:'+rect.left.toString());//獲取left的值，並列印 left = 3
    print('right:'+rect.right.toString());//獲取right的值，並列印，這裡執行了Rectangle類中第一行程式碼，right = left + width，right = 3+20 = 23
    rect.right = 30;//重新給right進行賦值 right = 30，這裡執行了Rectabgke類中的第二行程式碼，將right的值設定為30，並且，將left的值改為30 - 20，left = 30-20 = 10
    print('right的值改為30');
    print('left:'+rect.left.toString());//獲取left的值，並列印，因為上面給right重新賦值的時候，也改變了left的值，所以，此時left = 10
    print('right:'+rect.right.toString());//rect.right = 30將right的值改為了30，所以，right = 30


    print('top:'+rect.top.toString());
    print('bottom:'+rect.bottom.toString());
    rect.bottom = 50;
    print('bottom的值改為50');
    print('top:'+rect.top.toString());
    print('bottom:'+rect.bottom.toString());
}

//列印結果
left:3
right:23
right的值改為30
left:10
right:30
top:4
bottom:19
bottom的值改為50
top:35
bottom:50

上面的示例註釋已經解釋的很清楚了，如果有任何疑問，請留言！！！

這裡我就解釋一下“=>”的作用，在Dart裡面，大家可以簡單的理解為接下來要繼續執行後面的操作。

  • 重運算子載操作

在講解過載運算子前需要先說明Dart裡面的一個關鍵字operator，operator和運算子一起使用，表示一個運算子過載函式，在理解時可以將operator和運算子（如operator+或operator-）視為一個函式名。編寫一個例子方便理解。

Class Vector {
    final int x;
    final int y;
    const Vector(this.x,this.y);

    //過載加號 + （a+b）
    Vector operator + (Vector v){
        return new Vector(x + v.x,y + v.y);
    }
}

main() {
    //例項化兩個變數
    final result1 = new Vector(10,20);
    final result2 = new Vector(30,40);

    final result = result1 + result2;

    print('result.x = '+result.x.toString()+''，+'result.y = '+result.y.toString());

    //列印結果
    result.x = 40,result.y = 60
}

 

講解一下上面的例子，如果有不對的地方，麻煩留言指出。

首先建立了一個Vector類，宣告兩個成員變數x和y還有一個構造方法，在Vector類裡面過載一個加法運算子，過載操作返回Vector物件，接下來在main函式裡面，例項化了兩個Vector變數，兩次操作分別給

x和y進行了賦值，x = 10；y = 20；x = 30；y = 40。然後讓result1和result2這兩個變數相加，看到這裡大家可能會有疑問，兩個物件變數怎麼相加呢？這裡我們的運算子過載就發揮出作用了，實際上，在執行final result = result1 + result2;這行程式碼的時候，其實是物件result1呼叫了"operator +"這個函式，並將result2這個物件當作一個引數傳遞給了這個函式，從而實現了物件result1中的x和物件result2中的x相加，物件result1中的y和物件result2中的y相加的操作，所以最終列印的結果result.x = 40,result.y = 60。

看到這裡，大家是否對運算子過載有了一定的理解了呢？如果有任何疑問，歡迎留言提問！！！

注：對於 Dart 提供的所有操作符，通常只支援對於基本資料型別和標準庫中提供的類的操作，而對於使用者自己定義的類，如果想要通過該操作符實現一些基本操作（比如比較大小，判斷是否相等），就需要使用者自己來定義關於這個操作符的具體實現了。

  •  繼承類

繼承是物件導向程式設計技術的一塊基石，因為它允許建立分等級層次的類。繼承就是子類繼承父類的特徵和行為，使得子類物件具有父類的例項域和方法；或子類從父類繼承方法，使得子類具有父類相同的行為。Dart裡面使用extends關鍵字來實現繼承，super關鍵字來指定父類。

Class Animal {
    void eat(){
        print('動物會吃');
    }

    void run(){
        print('動物會跑');
    }
}

Class Human extends Animal {
    void say(){
        print('人會說');
    }

    void study(){
        print('人會學習');
    }
}

main(){
    var animal = new Animal();
    animal.eat();
    animal.run();

    value human = new Human();
    human.eat();
    human.run();
    human.say();
    human.study();

    //列印結果
    動物會吃
    動物會跑

    動物會吃
    動物會跑
    人會說
    人會學習
}

 

  • 抽象類

抽象類類似於Java語言中的介面。抽象類裡不具體實現方法，只是寫好定義介面，具體實現留著呼叫的人去實現。抽象類可以使用abstract關鍵字定義類。

  1. 抽象類通過abstract關鍵字來定義。
  2. Dart中的抽象方法不能用abstract宣告，Dart中沒有方法體的方法我們成為抽象方法。
  3. 如果子類繼承了抽象類，就必須實現裡面的抽象方法。
  4. 如果把抽象類當作介面實現的話，就必須得實現抽象類裡面的所有屬性和方法。
  5. 抽象類不能例項化，只有繼承它的子類可以例項化。
abstract class Animal{
    eat();   //抽象方法
    run();  //抽象方法  
    printInfo(){
    print('我是一個抽象類裡面的普通方法');
  }
}

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

    @override
    run() {
        // TODO: implement run
        print('小狗在跑');
    }  
}
class Cat extends Animal{
    @override
    eat() {
        // TODO: implement eat
        print('小貓在吃老鼠');
    }

    @override
    run() {
        // TODO: implement run
        print('小貓在跑');
    }

}

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

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


    // Animal a=new Animal();   //抽象類沒法直接被例項化
}

  • 列舉型別

列舉型別是一種特殊的類，通常用來表示相同型別的一組常量值，用enum來定義，每個列舉型別都有一個index和getter，index用來標記元素的元素位置。第一個列舉元素的索引是0，列舉不能被繼承，不能建立例項。

//定義一個列舉類
enum Color {
    red,
    green,
    blue
}

//列印列舉類中green的索引
print(Color.green.index); // 1

//獲取列舉類中所有的值，使用value常數
List<Color> colorList = Color.values;

 

因為列舉類中的每個元素都是相同型別，所以可以使用switch語句來針對不同的值做不同的處理，示例程式碼如下：

//定義一個列舉類
enum Color {
    red,
    green,
    blue
}

main(){
    Color mColor = Color.blue;

    switch (mColor){
        case Color.red:
        print('紅色');
        break;
        
        case Color.green:
        print('綠色');
        break;
        
        case Color.blue:
        print('藍色');
        break;

        default:
        break;
    }

    //列印結果
    藍色
}

 

  • Mixins

Mixins（混入功能）相當於多繼承，也就是說可以繼承多個類，使用with關鍵字來實現Mixins的功能，示例程式碼如下：

Class First {
    void printSth(){
        print('im first printSth');
    };
}

Class Second {
    void printSth(){
        print('im Second printSth');
    };

    void secondPrint(){
        print('test');
    }
}

Class A = Second with First;

main (){
    A a = new A();
    a.printSth();
    a.secondPrint();

    //列印結果
    im first printSth
    test
}

 

這段示例程式碼，是將類First混入到了Second類中並給了類A，這塊我在學習的時候有個疑問，同樣的printSth方法，將First混入到Second後，列印的是First中的im first printSth，這是因為First中的printSth方法將Second中的printSth方法覆蓋了嘛？

  • 泛型

泛型通常是為了型別安全而設計的，適當的指定泛型型別會生成更好的程式碼，可以使用泛型來減少程式碼重複，Dart中使用<T>的方式來定義泛型。例如，如果想要List只包含字串，可以將其宣告為list<String>。如下所示：

var names = new List<String>();
names.addAll(['張三','李四','王五']);

泛型用於List和Map型別引數化：

List:<type>
Map:<keyType,valueType>

var names = new List<String>['張三','李四','王五'];
var weeks = new Map<String,String>{
    'Monday’' : '星期一',
    'Tuesday' : '星期二',
    'Wednesday' : '星期三',
    'Thursday' : '星期四',
    'Friday' : '星期五',
    'Saturday' : '星期六',  
};

 

  • 庫的使用

　　1.引用庫

通過import語句在一個庫中引用另一個庫的檔案，需要注意一下事項：

1.1在import語句後面需要接上庫檔案的路徑。
1.2對Dart語言提供的庫檔案使用dart:xx格式
1.3第三方的庫檔案使用package:xx格式

import的例子如下：

import 'dart:io';
import 'package:mylib/mylib.dart';

 

　　2.指定一個庫的字首

當引用的庫擁有相互衝突的名字，可以為其中一個或幾個指定不一樣的字首，這與名稱空間的概念比較接近，示例程式碼如下：

import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;

Element emelent1 = new Element();//預設使用lib1裡面的Element
lib2.Element emelent2 = new lib2.Element();//使用lib2裡面的Element

 

lib1/lib1.dart及lib2/lib2.dart裡面都有Element類，如果直接引用就不知道具體引用哪個Element類，所以程式碼中把lib2/lib2.dart指定成lib2，這樣使用lib2.Element就不會發生衝突。　　3.引用庫的一部分如果只需要使用庫的一部分內容，可以有選擇的進行引用，有如下關鍵字：

3.1show關鍵字：只引用一點
3.2hide：除此之外都引用

示例程式碼如下：

//匯入foo
import 'package:lib1/lib1.dart' show foo;

//除了foo匯入其他所有內容
import 'package:lib1/lib1.dart' hide foo;

 

  • 非同步支援

  • 後設資料

  • 註釋

下一章節：Flutter學習筆記（9）--常用元件

相關文章