Flutter開發必備Dart基礎：Dart快速入門

時間 2019-11-15

標籤 flutter 開發必備 dart 基礎快速入門简体版

原文原文鏈接

本文首發於微信公衆號「Android開發之旅」，歡迎關注，獲取更多技術乾貨

概述

Dart從2.0開始變爲強類型語言，靜態類型。這點和Java、C#等比較類似。也就是說在編譯時就已經知道變量的類型那麼就是靜態類型語言。開發人員在開發的時候須要指定變量的類型。這有什麼優勢呢？就是全部類型檢查均可以經過編譯器來完成。能夠提早預報一些瑣碎的錯誤。
同時Dart仍是面向對象的編程語言。像python、Java、Koltin、PHP等等都是面向對象的語言。python

dart的特性：
JIT：即時編譯，開發期間作到更快的編譯和更快的代碼重載。但也有劣勢就是在運行時須要將代碼編譯爲機械碼，那麼直觀感覺就是慢，因此咱們在開發期間有時候會發現卡頓，可是打release包以後效果會變好的緣由。
AOT：事前編譯，release期間已經編譯爲二進制代碼，因此加載會更快更流暢。編程

經常使用數據類型

任何語言的基礎都是數據類型，dart也同樣。dart中主要有數字、字符串、布爾、集合和var類型。json

num類型

num是dart中的數字類型的父類，它有兩個子類：int和double。當類型指定爲num的時候能夠賦值爲小數也能夠賦值爲整數，可是一旦指定了某一個具體的類型，就只能賦值這一類型的值。segmentfault

void _numType() {
    num num1 = -2.0; //定義爲小數
    num num2 = 4; //定義num爲你太
    int num3 = 5; //只能是整數
    double num4 = 6.0; //只能是雙精度
  }

其中這些類型之間是能夠相互轉換的，如：緩存

print(num1.abs()); // 取絕對值 輸出 2.0
    print(num2.toDouble()); // 轉爲小數 輸出4.0
    print(num3.toString()); // 轉爲字符串 輸出"5"
    print(num4.toInt()); // 轉爲整數 輸出 6

String類型

String的定義也比較簡單，它可使用單引號也可使用雙引號定義，定義一個String類型後面能夠經過逗號隔開定義多個變量。在dart中拼接字符串能夠是 + 號連接，還可使用 $ 符號進行拼接，若是是變量則直接使用$xx，若是是表達式則使用${xxx}將其包裹起來。微信

void _stringType() {
    String str1 = 'str1', str2 = "str2"; //定義字符串str1和str2
    String str3 = "字符串數據類型"; //定義字符串str3
    String str4 = 'str1=$str1;str2=$str2'; //經過$符拼接字符串
    String str5 = "str1=" + str1 + " str3=" + str3; //經過+號拼接字符串
  }

字符串還有一些經常使用的API，好比字符串截取，獲取指定字符串位置，匹配字符串開頭等等。網絡

print(str3.substring(1, 5)); //符串數據 輸出 符串數據
    print(str3.indexOf("數據")); // 獲取位置 輸出 3
    print(str3.startsWith("字")); //匹配起始字符串 true
    print(str3.replaceAll("字符串", "dart的String")); //替換 輸出dart的String數據類型
    print(str3.split("數")); //切夠字符串 輸出[字符串，據類型]

布爾類型

dart中布爾類型是強bool類型，只有bool類型的值爲true，才被認爲是true。bool還有一些經常使用的運算符好比 ||（或）或者 &&（且），在運算的時候，教你們一個口訣就是，且同真爲真，或同假爲假。閉包

void _boolType() {
    bool success = true; //定義bool值爲true
    bool failure = false; //定義bool值爲false

    print(success || failure); //或運算 輸出 true
    print(success && failure); //且運算 輸出 false
  }

集合類型

dart中定義集合直接使用List list=[]，若是沒有指定泛型，默認類型爲dynamic類型，集合中能夠添加任何數據類型的數據，一旦指定了泛型，那麼就只能添加約束的類型數據。除了初始化的時候添加元素另外還能夠經過API的方式像集合中添加數據，add添加單一數據，addAll添加集合。還有另一種方式是經過List.generate來生成集合，它的第一個參數表示集合的大小，第二個參數表示集合的元素。編程語言

void _listType() {
    List list = [1, 2, 3, "list"]; //泛型爲dynamic
    //報 type 'List<dynamic>' is not a subtype of type 'List<int>' 異常
    //由於指定了intList的泛型爲int 可是list的泛型爲dynamic，隨意賦值失敗
    //List<int> intList = list;
    List<int> intList2 = [1, 2, 3, 4, 5]; //定義int集合
    list.add("hello"); //添加單一元素
    list.addAll(intList2); //添加集合
    print(list); //輸出 [1, 2, 3, "list","hello",1, 2, 3, 4, 5]

    List<String> strList = List.generate(2, (index)=> "我是第$index個元素"); //經過generate定義一個String集合
    print(strList); //輸出 [我是第0個元素, 我是第1個元素]
  }

有了集合那麼咱們就須要遍歷它，dart中經常使用的遍歷集合方式有：ide

for (int i = 0; i < list.length; i++) {
      print(list[i]);
    }

    for (var data in list) {
      print(data);
    }

    list.forEach((it) {
      print(it);
    });

上面三種遍歷方式輸出結果都爲：

1, 2, 3, "list","hello",1, 2, 3, 4, 5

Map類型

Map類型是將key和value相關聯的對象，key和value能夠是任意類型的數據，而且key是惟一的，若是key重複那麼後添加的會覆蓋以前添加的數據。定義map類型直接看代碼：

void _mapList() {
    Map map = {"lisi": 20, "zhangsan": 24}; //直接經過 {key:value} 方式定義
    Map map2 = {};
    map2[11] = 20;
    map2["zhangsan"] = "24";
    //上面兩個效果是同樣的且都沒有指定泛型。

    Map<int, int> intMap = {1: 2, 3: 4}; //指定map的泛型
  }

下面咱們看下Map的遍歷：

map.forEach((key, value) {
      print(
          "key:$key,value:$value"); //輸出 key:lisi,value:20 和 key:zhangsan,value:24
    });

    map.map((key, value) {
      return MapEntry(value, key); //返回一個新的map對象，咱們將key value值進行顛倒後返回
    }).forEach((key, value) {
      print("key:$key,value:$value"); //輸出 key:20,value:lisi 和 key:24,value:zhangsan
    });

    for(var key in map.keys){ //遍歷map的key元素 同理還能夠遍歷map.values
      print(key); //輸出 lisi 和 zhangsan
    }

dynamic、var、Object的區別

dynamic：動態數據類型，是全部Dart對象的基礎類型，在大多數狀況下，一般不直接使用它，經過它定義的變量會關閉類型檢查，這意味着 dynamic x = 'hello world'; 調用x.foo()方法時靜態類型檢查不會報錯，可是運行時會crash，由於x並無foo()方法，因此建議你們在編程時不要直接使用dynamic。

var：是一個關鍵字，意思是「我不關心這裏的類型是什麼。」，系統會自動推斷類型runtimeType；並且一旦指定了類型，就不能夠修改。

Object：是Dart對象的基類，當你定義：Object obj=xxx 時這時候系統會認爲obj是個對象，你能夠調用obj的toString()和hashCode()方法，由於Object提供了這些方法，可是若是你嘗試調用obj.foo()時，靜態類型檢查會進行報錯。

綜上不難看出dynamic與Object的最大的區別是在靜態類型檢查上。

面向對象

類的定義和構造

定義一個dart類，使用class關鍵字加上類名，構造方法和類名相同，默認全部的類都是繼承Object的。其中能夠定義一些方法和變量，如:

class Person {
  String name;
  int age;

  //標準構造方法
  Person(this.name, this.age);
  
  //重載父類的toString方法 也是多態的重要體現
  @override
  String toString() {
    return "name=$name,age=$age";
  }
}

一個類繼承另外一個類使用關鍵字extends，若是父類沒有默認無參構造函數，那麼子類須要使用super對父類進行初始化，子類的變量使用this.xxx來指定初始化，如：

class Worker extends Person {
  
  String workType;
  String workAddress;
  //經過this來初始化子類字段，將其餘字段交由父類初始化
  Worker(this.workType,this.workAddress,String name, int age) : super(name, age);
}

上面代碼中的：super(name,age) 被稱做爲初始化列表，除了調用父類構造器，還能夠初始化實例變量，不一樣的初始化變量之間用逗號隔開。

class Worker extends Person {

  String workType;
  String workAddress;
  String companyName;

  //經過this來初始化子類字段，將其餘字段交由父類初始化,這裏指定了companyName的初始化。
  //若是要初始化變量，那麼其不能夠在構造方法中定義
  Worker(this.workType, this.workAddress, String name, int age)
      : companyName = "world",
        super(name, age);
}

咱們還能夠經過命名構造函數的方式初始化實例類。使用就是類名.xx() 便可，主要注意的是當有變量的類型是final的時候，命名構造方法就要求其在構造方法中指定初始化。

class Worker extends Person {

  ......

  //命名構造函數
  Worker.begin(Worker work) : super(work.name, work.age) {
    print("命名構造函數");
  }
  
  //假若有變量final String workAddress，那麼就須要在構造方法中指定：
  //Worker.begin(Worker work,this. workAddress) : super(work.name, work.age) {
  //  print("命名構造函數");
  //}
  
}

工廠構造函數就是都只返回同一個實例類，能夠理解爲Java中的單例模式。

class Logger {
  static Logger _logger;

  factory Logger() {
    if (_logger == null) {
      _logger = Logger._initInstance();
    }
    return _logger;
  }

  //經過命名構造函數初始化
  Logger._initInstance();
}

還有一種構造方法是命名構造和工廠構造的結合體，一般在網絡請求的時候將json映射爲object的時候使用，它有一個好處就是不須要將類的final變量做爲參數傳遞給構造方法。提供了一種靈活獲取類對象的方式。定義格式：factory 類名.方法名。

class Worker extends Person {
 
  ......
 
  factory Worker.workHard(Worker work) {
    return Worker.begin(work, "");
  }
}

dart默認都會隱式的定義setter方法，對非空的變量還會增長getter方法。可是加了私有後，外界就沒法訪問變量了，須要咱們手動的添加set和get方法。

class Worker extends Person {

  ......

  double _salary;

  set salary(double value) => _salary = value;

  get salary => _salary;

  ......

}

抽象類和方法

使用 abstract 修飾符來定義一個抽象類，該類不能被實例化。抽象類在定義接口的時候很是有用，實際上抽象類中也包含一些實現。若是一個類繼承了抽象類要麼實現它的抽象方法，要麼也將本身定義成抽象類。一個抽象類中不必定要有抽象方法，可是有抽象方法的類必定是抽象類。

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

//實現抽象類
class Dog extends Animal {
  //實現eat方法
  @override
  void eat() {
    print("啃骨頭");
  }
}

mixins

mixins 是在多個類層次結構中重用代碼的一種方式。要使用 mixins ，在 with 關鍵字後面跟一個或多個 mixin 的名字(用逗號分開)，而且with要用在extends關鍵字以後。

mixins的特徵：實現 mixin ，就建立一個繼承 Object 類的子類(不能繼承其餘類)，不聲明任何構造方法，不調用 super。

//聲明mixins類
class Pig {
  void action() {
    print("吃完就睡");
  }
}

//使用mixins類，能夠複用它的action方法
class Cat extends Animal with Pig {
  @override
  void action() {
    print("抓老鼠");
  }

  @override
  void eat() {
    print("吃貓糧");
  }
}

方法定義

方法是由返回值類型+方法名+參數構成。其中返回值類型可缺省，也可爲void或者具體的類型。正常狀況下都是由方法名的，但有一種特殊就是匿名方法。參數分爲參數類型和參數名，其中參數類型可缺省。參數又分爲可選參數和默認參數,他們都使用 {} 來定義。

class FunClass {
  //city爲可選參數，town爲默認參數
  String fromWhere(country, {String city, String town = "小紅帽村"}) {
    if (city != null) {
      return "我來自 $country $city $town";
    } else {
      return "我來自 $country $town";
    }
  }
}

咱們來調用打印下看看：

FunClass funClass = FunClass();
print(funClass.fromWhere("格林國")); //輸出 我來自 格林國 哈哈村
print(funClass.fromWhere("格林國", city: "童話鎮"));//輸出 我來自 格林國 童話鎮 哈哈村

匿名方法有時候也被稱爲 lambda 或者 closure 閉包，能夠把匿名方法賦值給一個變量，直接調用變量名便可。

var printI = (i) => print(i);

使用：

FunClass funClass = FunClass();
funClass.printI(999);

泛型

泛型主要是解決類、接口、方法的複用性、以及對不特定數據類型的支持。

class Cache<T> {
  static final Map<String, Object> _cached = Map();

  void setItem(String key, T value) {
    _cached[key] = value;
  }

  ///泛型方法
  T getItem(String key) {
    return _cached[key];
  }
}

這裏咱們定義了一個緩存類，存儲的類型被定義爲泛型，提升代碼的複用度。

有時候咱們在實現相似通用接口的泛型中，指望的類型是某些特定類型時，這時可使用類型約束。

class Member<T extends Person> {
  T _person;

  ///泛型做用：約束參數類型
  Member(this._person);

  String fixedName() {
    return 'fixed:${_person.name}';
  }
}