概述
Dart 從 2.0 開始變爲強類型語言，靜態類型。這點和 Java、C# 等比較相似。也就是說在編譯時就已經知道變量的類型，就是靜態類型語言。開發人員在開發的時候需要指定變量的類型。這有什麽優點呢？就是所有類型檢查都可以通過編譯器來完成。可以提前預報一些瑣碎的錯誤。同時 Dart 還是面向對象的編程語言。像 python、Java、Koltin、PHP 等等都是面向對象的語言。
Dart 的特性
JIT: 即時編譯，開發期間做到更快的編譯和更快的代碼重載。但也有劣勢就是在運行時需要將代碼編譯爲機械碼，那麽直觀感受就是慢，所以我們在開發期間有時候會發現卡頓，但是打 release 包之後效果會變好。
AOT: 事前編譯，release 期間已經編譯爲二進制代碼，所以加載會更快更流暢。
常用數據類
任何語言的基礎都是數據類型，dart 也一樣。dart 中主要有數字、字符串、布爾、集合和 var 類型
num 類型
num 是 dart 中的數字類型的父類，它有兩個子類: int 和 double。當類型指定爲 num 的時候可以賦值爲小數也可以賦值爲整數，但是一旦指定了某一個具體的類型，就只能賦值這一類型的值。
void _boolType() { bool success = true; //定義bool值爲true bool failure = false; //定義bool值爲false print(success || failure); //或運算 輸出 true print(success && failure); //且運算 輸出 false }
其中這些類型之間是可以相互轉換的，如:
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 中常用的遍曆集合方式有:
1, 2, 3, “list”,”hello”,1, 2, 3, 4, 5
上面三種遍曆方式輸出結果都爲:
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。
class Logger { static Logger _logger; factory Logger() { if (_logger == null) { _logger = Logger._initInstance(); } return _logger; } //通過命名構造函數初始化 Logger._initInstance();}
方法定義
方法是由返回值類型+方法名+參數構成。其中返回值類型可缺省，也可爲 void 或者具體的類型。正常情況下都是有方法名的，但有一種特殊就是匿名方法。參數分爲參數類型和參數名，其中參數類型可缺省。參數又分爲可選參數和默認參數，他們都使用 {} 來定義。
class FunClass { //city爲可選參數，town爲默認參數 String fromWhere(country, {String city, String town = “小紅帽村”}) { if (city != null) { return “我來自 $country $city $town”; } else { return “我來自 $country $town”; } }}
我們來調用打印下看看:
class Worker extends Person { …… factory Worker.workHard(Worker work) { return Worker.begin(work, “”); }}
匿名方法有時候也被稱爲 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}’; }}
總結
本文主要是講解了在 Flutter 中常用到的 dart 的基礎知識，當然還有其他很多的知識點沒有涉及到。這裏推薦幾個 dart 學習網站給大家使用。