Dart是一種“結構化的web編程”語言，Dart編程語言在所有現代瀏覽器和環境中提供高性能。Dart是谷歌開發的計算機編程語言，后來被ECMA認定為標準。

Dart重要的概念：

1、所有的東西都是對象。無論是變量、數字、函數等都是對象。所有的對象都是實例。所有的對象都繼承自內置的Object類。這點類似于JAVA語言的“一切皆為對象”。

2、程序中指定數據類型使得程序合理地分配內存空間，并幫助編譯器進行語法檢查。但是，指定類型不是必須的。Dart語言是弱數據類型。

3、Dart代碼在運行前解析。指定數據類型和編譯時的長列，可以提高運行速度。

4、Dart程序有統一的程序入口：main()。這一點與JAVA、C/C++語言相像。

5、Dart沒有public、protected和private的概念。私有特性通過變量或函數加下下劃線來表示。

6、Dart的工具可以檢查出警告信息(warning)和錯誤信息(errors)。警告信息只是表明代碼可能不工作，但是不會妨礙程序運行。錯誤信息可以是編譯時的錯誤，也可能是運行時的錯誤。編譯時的錯誤將阻止程序運行，運行時的錯誤將會以異常(execption)的方式呈現。

7、Dart支持anync/await異步處理。

8、關鍵字

abstract 2	dynamic 2	implements 2	show 1
as 2	else	import 2	static 2
assert	enum	in	super
async 1	export 2	interface 2	switch
await 3	extends	is	sync 1
break	external 2	library 2	this
case	factory 2	mixin 2	throw
catch	false	new	true
class	final	null	try
const	finally	on 1	typedef 2
continue	for	operator 2	var
covariant 2	Function 2	part 2	void
default	get 2	rethrow	while
deferred 2	hide 1	return	with
do	if	set 2	yield 3

避免使用這些單詞作為標識符。但是，如有必要，標有上標的關鍵字可以是標識符：

帶有上標1的單詞是上下文關鍵字，僅在特定位置有意義。它們在任何地方都是有效的標識符。

帶有上標2的單詞是內置標識符。為了簡化將JavaScript代碼移植到Dart，這些關鍵字在大多數地方都是有效的標識符，但它們不能用作類或類型名稱，也不能用作導入前綴。

帶有上標3的單詞是與Dart 1.0發布后添加的異步支持相關的有限保留字。不能在任何被標記async，async*或sync*標記的函數體中使用await或yield作為標識符。

表中的所有其他單詞都是保留字，不能是標識符。

Dart語言的常用庫

包名	概述
dart:async	異步編程支持，提供Future和Stream類
dart:collection	對dart:core提供更多的集合支持
dart:convert	不同類型(JSON、UTF-8)間的字符編碼、解碼支持
dart:core	Dart語言內建的類型、對象以及dart語言核心的功能
darr:html	網頁開發用到的庫
dart:io	文件讀寫I/O相關操作的庫
dart:math	數字常量及函數，提供隨機數算法
dart:svg	事件和動畫的矢量圖像支持

其中三個開發庫的使用頻率最高：

dart:core 核心庫，包含strings、numbers、collections、errors、dates、URIs等。

dart:html 網頁開發里DOM相關的一些庫。

dart:io I/O命令行使用的I/O庫。

dart:core庫時Dart語言初始已經包含的庫，其他的任何庫在使用前都需要加上import語句。

變量與基本數據類型：

在Dart里，變量聲明使用var關鍵字。在Dart語言里一切且為對象，所以如果沒有將變量初始化，那么它的默認值為null。

全局變量特點：全局變量常駐內存、全局變量污染全局
局部變量特點：不常駐內存會被垃圾機制回收、不會污染全局

1、常量和固定值

常量及固定值在開發中很常見。如果定義的變量不會變化，可以使用final或const來指明。const是一個編譯時的常量；final的值只能被設定一次。

例如：第一行代碼設置了一個常量，如果第二行進行重新賦值，那么將引發異常。

final username = "張三";  //定義了一個常量
//username = "李四";  //會引發一個錯誤

通過對const類型做四則運行將自動得到一個const類型的值。下面代碼會得到一個常量，計算圓的面積：

const pi = 3.1415926;
const area = pi * 100 * 100;

可以通過const來創建常量的值，就是說const[]本身是構造函數，示例代碼如下：

final stars = const [];
const buttons = const [];

2、基本數據類型

Dart語言常用的基本數據類型包括：Number、String、Boolean、List、Map。

(1)Number類型：包括int整型，double浮點型

int和double類型都是num類型的子類。int類型不能包含小數點。

int必須是整型；double即可以是整型，也可以是浮點型。

num類型包括的操作有：+，-，*，/，% 以及位移操作>>。num類型包括的常用方法有：abs、ceil和floor。

(2)String類型：字符串類型

String str = "This is flutter";

可以使用三個單引號或雙引號來定義多行的String類型，在Flutter中我們專門用來表示大文本塊。

var s1 = ''' '''
var s2 = """ """
//請注意這是一個用三個引號包裹起來的字符串，可以用來添加多行數據

字符串類型拼接：

String str1 = "Hello";
String str2 = "World"
print(str1 + str2); //Hello World
print(str1 + " " + str2); //Hello World

(3)Boolean類型

Dart是強bool類型檢查，只有bool類型的值是true才被認為是true。有的語言里0是false，大于0是true。在Dart語言里則不是，值必須為true或者false。

var sex = "男";
if(sex){
  print("你的性別是！" + sex);  
}

上面的示例代碼編譯不能正常通過，因為sex變量是一個字符串，不是使用條件判斷語句，必須用bool類型才可以。

(4)List類型

在Dart語言中，具有一系列相同類型的數據稱為List對象。Dart里的List對象類似于JavaScript語言的數組Array對象。

//第一種定義List方式
var list1 = [1, 2, 3];

//第二種定義List方式
var list2 = new List();
list2.add("a");
list2.add(123);
list2.add("c");

//定義List指定類型
var list3 = new List<String>();
list3.add("a");
list3.add("b");

List常用屬性：

length 長度
reversed 翻轉
isEmpty 是否為空
isNotEmpty 是否不為空

var arr = ["香蕉","蘋果","橘子"];
print(arr.length); //3
print(arr.reversed); //(橘子, 蘋果, 香蕉)
print(arr.isEmpty); //false
print(arr.isNotEmpty); //true

var newArr = arr.reversed.toList();
print(newArr); //[橘子, 蘋果, 香蕉]

List常用方法：

add 增加
addAll 拼接數據
indexOf 查找 傳入具體值
remove 刪除 傳入具體值
removeAt 刪除 傳入索引值
fillRange 修改
insert(index,value); 指定位置插入
insertAll(index,list); 指定位置插入List
toList() 其他類型轉換成List
join() List轉換成字符串
split() 字符串轉換成List
forEach()
map
where
any
every

var arr = ["香蕉","蘋果","橘子"];
arr.add("桃子");
print(arr); //[香蕉, 蘋果, 橘子, 桃子]
arr.addAll(["西瓜","草莓"]);
print(arr); //[香蕉, 蘋果, 橘子, 桃子, 西瓜, 草莓]
print(arr.indexOf("蘋果"));  //1  
//indexOf查找不到的話，返回-1；查找到的話，返回索引值
arr.remove("西瓜");
print(arr); //[香蕉, 蘋果, 橘子, 桃子, 草莓]
arr.removeAt(3);
print(arr); //[香蕉, 蘋果, 橘子, 草莓]
arr.fillRange(1, 2, "aaa"); //修改
print(arr); //[香蕉, aaa, 橘子, 草莓]  
arr.insert(2, "bbb"); //插入
print(arr); //[香蕉, aaa, bbb, 橘子, 草莓] 
arr.insertAll(1, ["123","456"]); //插入多個
print(arr); //[香蕉, 123, 456, aaa, bbb, 橘子, 草莓]

var arr = ["香蕉","蘋果","橘子"];
var str = arr.join("-"); //List轉換成字符串
print(str); //香蕉-蘋果-橘子
var newArr = str.split("-"); //字符串轉換成List
print(newArr); //[香蕉, 蘋果, 橘子] 

forEach：循環遍歷

List arr = ["香蕉","蘋果","橘子"];
arr.forEach((value){
     print(value);
});

map：常用于修改集合里的數據

//循環遍歷修改List
List myNum = [1,3,5];
List newNum = new List();
for(var i = 0; i < myNum.length; i++){
   newNum.add(myNum[i]*2);
}
print(newNum); //[2, 6, 10]
//可以用map來實現
List myNum = [1,3,5];
var newNum = myNum.map((value){
    return value*2;
});
print(newNum.toList()); //[2, 6, 10]

where：把滿足條件的返回一個新的集合

List myNum = [1,3,4,5,7,8,9];
var newNum = myNum.where((value){
    return value > 5;
});
print(newNum.toList()); //[7, 8, 9]

any和every：判斷List里有沒有滿足條件的，有的話返回true或false

//any
List myNum = [1,3,4,5,7,8,9];
var f = myNum.any((value){ //只要集合里有滿足條件的就返回true
    return value >5; 
});
print(f); //true
//every
List myNum = [1,3,4,5,7,8,9];
var f = myNum.every((value){ //集合里面每一個都要滿足條件返回true，否則返回false
    return value >5; 
});
print(f); //false

(5)Map類型

Map常用屬性：

keys 獲取所有的key值
values 獲取所有的value值
isEmpty 是否為空
isNotEmpty 是否不為空

var person = {
      "name":"張三",
      "age":20,
      "sex":"男",
};
print(person.keys.toList()); //[name, age, sex]
print(person.values.toList()); //[張三, 20, 男]
print(person.isEmpty); //fales
print(person.isNotEmpty); //true

Map常用方法：

remove(key) 刪除指定key的數據
addAll({...}) 合并映射 給映射增加屬性
containsValue 查看映射內的值 返回true/false
forEach
map
where
any
every

var person = {
      "name":"張三",
      "age":20,
      "sex":"男",
    };
person.addAll({"work":["程序員","外賣員"],"height":170});
print(person); //{name: 張三, age: 20, sex: 男, work: [程序員, 外賣員], height: 170}
person.remove("sex");
print(person); //{name: 張三, age: 20, work: [程序員, 外賣員], height: 170}
print(person.containsValue("張三")); //true

forEach()：

var person = {
    "name":"張三",
    "age":20,
    "sex":"男",
};
person.forEach((key,vlaue){
    print("$key--$vlaue");
});
//如果是一行代碼也可以用=>
person.forEach((key,vlaue)=>print("$key--$vlaue"));

Map類型將key和value關聯在一起，也就是鍵值對。像其他支持Map的編程語言一樣，key必須是唯一的。

var week = {
   "Monday" : "星期一",
   "Tuesday" : "星期二",
   "Wednesday" : "星期三",
   "Thursday" : "星期四",
   "Friday" : "星期五",
   "Saturday" : "星期六",
   "Sunday" : "星期日",      
};
print(week["Monday"]); 

//也可以使用Map對象的構造函數Map()來創建Map對象

var week = new Map();
   week["Monday"] = "星期一";
   week["Tuesday"] = "星期二";
   week["Wednesday"] = "星期三";
   week["Thursday"] = "星期四";
   week["Friday"] = "星期五";
   week["Saturday"] = "星期六";
   week["Sunday"] = "星期日"; 

添加新的key-value對，再給week添加一個值，注意，其中0為鍵不是數組的下標索引：week['0'] = '星期一';

檢查key是否在Map對象中：assert(week['Monday'] == null);

使用length來獲取key-value對的數量，現在我們調用length輸出長度為8，原因是剛才后面又添加了一個數據（0），代碼如下：

    var week = new Map();
    week['Monday'] = "星期一";
    week['Tuesday'] = "星期二";
    week['Wednesday'] = "星期三";
    week['Thursday'] = "星期四";
    week['Friday'] = "星期五";
    week['Saturday'] = "星期六";
    week['Sunday'] = "星期日";
    week['0'] = '星期一';
    print(week);  //{Monday: 星期一, Tuesday: 星期二, Wednesday: 星期三, Thursday: 星期四, Friday: 星期五, Saturday: 星期六, Sunday: 星期日, 0: 星期一}
    print(week.length); //8

(6)Set：表示對象的集合，其中每個對象只能出現一次。

Set：用它最主要的功能就是去除數組重復內容
Set是沒有順序且不能重復的集合，所以不能通過索引去獲取值

var ss = new Set();
ss.add("香蕉");
ss.add("蘋果");
ss.add("香蕉");
print(ss); //{香蕉, 蘋果}
print(ss.toList()); //[香蕉, 蘋果]

var arr = new List();
arr.add("香蕉");
arr.add("蘋果");
arr.add("香蕉");
print(arr); //[香蕉, 蘋果, 香蕉] 

var arr = ["香蕉","蘋果","橘子","香蕉","蘋果","香蕉","蘋果"];
var ss = new Set();
ss.addAll(arr);
print(ss.toList()); //[香蕉, 蘋果, 橘子]

Set也可以用forEach()循環遍歷:

var ss = new Set();
ss.addAll([11,22,333]);
ss.forEach((value){
    print(value);
});

//如果只有一行代碼可以用=>
ss.forEach((value)=>print(value));

is關鍵詞來判斷類型：

//加入str是后臺返回的數據，不知道是什么類型，可以用is來判斷
var str = '1234';
    if(str is String){
      print('是string類型');
    }else if(str is int){
      print('是int類型');
    }else{
      print('是其他類型');
    }
//是string類型

Dart類型轉換：

(1)Number類型轉換為String類型：toString()

var myNum = 123;
var str = myNum.toString();
print(str is String);  //true

(2)String類型轉換為Number類型：parse()

String str = "123";
var myNum = double.parse(str); //String類型轉換Number類型的時候建議用double，用int的話，如果有小數會報錯
print(myNum is double);  //true

(3)其他類型轉換成Boolean類型

isEmpty：判斷字符串是否為空

var str = 'xxx';
if(str.isEmpty){
    print('str為空');
}else{
    print('str不為空');
} 
//str不為空

var myNum1 = 0/0;
if(myNum1.isNaN){
    print('NaN');
}else{
    print(myNum1);
}
//NaN 

var myNum2 = 1;
if(myNum2.isNaN){
    print('NaN');
}else{
    print(myNum2);
}
//1

3、函數

Dart是一個面向對象的語言，所以函數也是對象，函數屬于Function對象。

函數可以像參數一樣傳遞給其他函數，這樣便于做回調處理。

//判斷兩個字符串是否相等
bool equal(String str1, String str2) {
    retrue str1 == str2;
}

(1)可選參數

將參數使用中括號[]括起來，用來表明是可選位置參數。

例如：總共傳入了三個參數，其中name和sex是必須傳入的參數，from參數可以不傳，代碼如下：

//獲取用戶信息
String getUserInfo(String name, String sex, [String from]) {
  var info = '$name 的性別是 $sex';
  if(from != null){
      info = ‘$info來自$from’;    
  }    
  return info;    
}

void test(){
  pring(getUserInfo(‘小王’, '男'));  
}

(2)參數默認值

如果參數指定了默認值，當不傳入值時，函數里會使用這個默認值。如果傳入了值，則用傳入的值取代默認值。通常參數的默認值為null。

改造上面獲取用戶信息的例子，給from參數賦上默認值，代碼如下：

//獲取用戶信息 使用等號= 來設置默認位置參數
String getUserInfo(String name, String sex, [String from = '中國']) {
  var info = '$name 的性別是 $sex';
  if(from != null){
      info = ‘$info來自$from’;    
  }
  return info;    
}

void test(){
  pring(getUserInfo(‘小王’, '男'));  
}

調用上面的test()方法可以輸出“小王的性別是男來自中國”。

(3)main函數

Flutter應用程序必須要有一個main函數，和其他語言一樣作為程序的入口函數。

如下代碼表示應用要啟動MyApp類：void main() => runApp(MyApp());

(4)函數返回值

在Dart語言中，函數的返回值有如下特點：

所有的函數都有返回值
如果沒有指定函數返回值，則默認的返回值是null
沒有返回值的函數，系統會在最后添加隱式的return語句

(5)箭頭函數

只有一條語句的時候可以用箭頭函數：

List arr = ["香蕉","蘋果","橘子"];
arr.forEach((value){
    print(value);
});
//箭頭函數
arr.forEach((value)=>print(value));

例子1：修改數組里的數據，大于2的值乘以2

List myNum = [1,2,3,4,5];
var newNum = myNum.map((value){
    if(value > 2){
        return value*2;
    }
    return value;
});
print(newNum.toList());
//用箭頭函數實現
List myNum = [1,2,3,4,5];
var newNum2 = myNum.map((value) => value>2 ? value*2 : value);
print(newNum2.toList());

例子2：定義一個方法isEvenNumber來判斷一個數是否是偶數，定義一個方法打印1到n之間的偶數。

//定義一個方法isEvenNumber來判斷一個數是否是偶數
bool isEvenNumber(int n){
    if(n%2 == 0){
        return true;
    }
    return false;
}
//打印1到n之間的偶數
printNum(int n){
    for(var i = 1; i <= n; i++){
        if(isEvenNumber(i)){
          print(i);
        }
    }
}
printNum(10); //2 4 6 8 10

4、運算符

Dart支持各種類型的運算符，并且其中的一些操作符還能進行重載。完整的操作符如下表

描述	運算符
一元后綴	expr++ expr-- () [] . ?.
一元前綴	-expr ！expr ~expr ++expr --expr
乘法類型	* / % ~/
加法類型	+ -
移動位運算	<< >>
與位運算	&
異或位運算	^
或位運算	|
關系和類型測試	>= <= > < as is is!
等式	== !=
邏輯與	&&
邏輯或	||
條件	expr1 ? expr2 : expr3
級聯	..
賦值	= *= /= ~/= %= += -= <<= >>= &= ^= |= ??=

使用運算符時可以創建表達式，以下是運算符表達式的一些示例：

a++
a--
a + b
a = b
a == b
expr ? a : b
a is T

注意使用運算符時的順序。在運算符表中，操作符的優先級由上到下逐個減小，上面行內的操作符優先級大于下面行內的操作符。例如，“乘法類型”操作符%的優先級比"等階"操作符==要高，而==操作符的優先級又比"邏輯與"操作符&&要高。

//使用括號來提高可讀性
if((n % i == 0) && (d & i == 0));
//難以閱讀，但是和上面等階
if(n % i == 0 && d & i == 0);

提示：對于二元運算符，其左邊的操作數將會決定使用的操作符的種類。例如：當你使用一個Vector對象以及一個Point對象時，aVector + aPoint使用的+是由Vector所定義的。

(1)算術運算符

Dart支持常用的算術運算符：

操作符	含義
+	加
-	減
-expr	一元減號，也命名為負號(使后面表達式的值反過來)
*	乘
/	除
~/	返回一個整數值的除法
%	取余，除法剩下的余數
++var	var=var+1表達式的值為var+1
var++	var=var+1表達式的值為var
--var	var=var-1表達式的值為var-1
var--	var=var-1表達式的值為var

示例代碼如下：

assert(3 + 6 == 9);
assert(3 - 6 == -3);
assert(3 * 6 == 18);
assert(7 / 2 == 3.5); //結果是浮點型
assert(5 ~/2 == 2); //結果是整形
assert(5 % 2 == 1); //求余數

var a, b;
a = 0;
b = ++a; //在b獲得其值之前自增a
assert(a == b); //1 == 1

a = 0;
b = a++; //在b獲得值后自增a
assert(a != b); //1 != 0

a = 0;
b = --a; //在b獲得其值之前自減a
assert(a == b); //-1 == -1

a = 0;
b = a--; //在b獲得值后自減a
assert(a != b); //-1 != 0

var a = 10;
var b = a++; //先把a的值賦值給b，然后在自增，所以b=10，a=11
print(a); //11
print(b); //10

var a = 10;
var b = ++a; //先進行自增，然后再賦值給b，所以都是11
print(a); //11
print(b); //11

注意：在賦值運算里，如果++或--寫在前面，這時先運算，再賦值；如果++或--寫在后面的時候，先賦值再進行運算。

(2)關系運算符

操作符	含義
==	等于
!=	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于

有時候需要判斷兩個對象是否相等，請使用==運算符。

    int a = 5;
    int b = 3;
    print(a==b); //false
    print(a!=b); //true
    print(a>b); //true
    print(a<b); //false
    print(a>=b); //true
    print(a<=b); //false

(3)類型測試操作符

as、is和is!操作符在運行時用于檢查類型非常方便，含義如下：

操作符	含義
as	類型轉換
is	當對象時相應類型時返回true
is!	當對象不是相應類型時返回true

如果obj實現了T所定義的接口，那么objis T將返回true。

使用as操作符可以把一個對象轉換為制定類型，前提是能夠轉換。轉換之前用is判斷一下更保險。如下代碼：

if(user is User){
  //類型檢測
  user.name = 'Flutter';  
}

//如果能確定user時User的實例，則可以通過as直接簡化代碼：
(user as User).name = ‘Flutter’；

注意：上面兩段代碼并不相等，如果user的值為null或者不是一個User對象，則第一段代碼不會做出任何事情，第二段代碼會報錯。

is 類型判斷：

class User{
  String name;
  num age;
  User(this.name,this.age);
  void printInfo(){
    print("${this.name}----${this.age}");
  }
}
void main(){
  User user = new User("張三",20);
  if(user is User){ //判斷user這個對象是否屬于User這個類
    user.name = "李四";
  }
  user.printInfo(); //李四----20
}

as 類型轉換：

class User{
  String name;
  num age;
  User(this.name,this.age);
  void printInfo(){
    print("${this.name}----${this.age}");
  }
}
void main(){
  var user = '';
  user = new User("張三",20);
  //老版本 user.printInfo(); 不會執行，因為不知道user屬于什么類型
  //所以user用as強制轉換為User類型
  (user as User).printInfo(); //張三----20
}

? 條件運算符：

class User{
  String name;
  num age;
  User(this.name,this.age);
  void printInfo(){
    print("${this.name}----${this.age}");
  }
}
void main(){
  User user1 ;
  user1?.printInfo(); //?表示如果對象是空的話不會調用這個方法

  User user2 = new User("張三",20);
  user2?.printInfo(); //張三----20  //?判斷非空調用方法
}

(4)賦值操作符

可以使用 = 運算符賦值。要僅在變量為null時賦值，請使用 ??= 運算符。如下代碼所示：

//賦值給a
a = value;
c = a + e;
//如果b為空，則將值分配給b；否則b保持不變
b??= value;
//例如
int b = 10;
b??= 20;
print(b); //10 因為b不為空，所以b的值還是10
//例如
int b;
b??= 20;
print(b); //20

復合賦值運算符:

諸如+=之類的復合賦值運算符將操作符與賦值相結合。以下是復合賦值運算符的工作方式：

復合賦值符	等式表達式
a op b	a = a op b
a += b	a = a + b
a -= b	a = a - b

var a = 3;
a += 5;
print(a); //8

(5)邏輯運算符

可以使用邏輯運算符反轉或組合布爾表達式。邏輯運算符如下所示：

操作符	含義
!expr	反轉以下表達式(將false更改為true，反之亦然)
||	邏輯或
&&	邏輯與

示例代碼如下：

if(!expr && (test == 1 || test == 8)) {
  ......  
}

(6)位運算符

通常我們指位運算為<<或 >>移動位運算，通過操作位的移動來達到運算的目的，而&、|、^、~expr也是操作位來達到運算的目的。

操作符	含義
&	與
|	或
^	異或
~expr	一元位補碼(0s變為1s；1s變為0s)
<<	左移
>>	右移

示例代碼如下：

final value = 0x22;
final bitmask = 0x0f;
assert((value & bitmask) == 0x02); //與
assert((value & -bitmask) == 0x20); //與非
assert((value | bitmask) == 0x2f); //或
assert((value ^ bitmask) == 0x2d); //異或
assert((value << 4) == 0x220); //左移
assert((value >> 4) == 0x02); //右移

(7)條件表達式

Dart由兩個運算符，可用來簡明地評估可能需要if-else語句的表達式。如下代碼即為一種條件表達式，也可以稱為三元表達式，如果條件為真，返回expr1，否則返回expr2.

condition ? expr1 : expr2;

//例如
var a = true ? 123 : 456;

第二種如下表示，如果expr1為非空，則返回其值；否則，計算并返回expr2的值。

expr1 ?? expr2;

//例如
var a;
var b = a ?? 10;
print(b); //a為空，計算并返回expr2的值10賦給b

//例如
var a = 22;
var b = a ?? 10;
print(b); //a不為空，返回a的值22賦給b

(8)級聯操作（連綴）

級聯操作用兩個點(..)表示，可對同一對象執行一系列操作。類似于Java語言里點點點處理或JavaScript里的Promise的then處理。級聯操作主要的目的是為了簡化代碼。

querySelector('#btnOK') { //獲取一個id為btnOK的按鈕對象
    ..text = '確定'  //使用它的成員
    ..classes.add('ButtonOKStyle');
    ..onClick.listen((e) => window.alert('確定'));      
}

//相當于

var button = querySelector('#btnOK');
button.text = '確定';
button.classes.add(' ' ButtonOKStyle ' ');
button.onClick.listen((e) => window.alert('確定')); 

第一個方法調用querySelector，返回一個按鈕對象，然后再設置它的文本為“確定”，再給這個按鈕添加一個樣式叫“ButtonOKStyle”，最后在監聽單擊事件，事件彈出一個顯示“確定”的Alert。

還用前面的例子：

class User{
  String name;
  num age;
  User(this.name,this.age);
  void printInfo(){
    print("${this.name}----${this.age}");
  }
}
void main(){
  User user = new User("張三",20);
  uesr.printInfo(); //張三----20
  user.name = "李四";
  user.age = 30;
  user.printInfo(); //李四----30
  //上面的三行代碼可以簡寫為
  user..name = "李四"
       ..age = 30
       ..printInfo(); //李四----30
}

注意：嚴格來說，級聯的“雙點”符號不是運算符。這只是Dart語法的一部分。

5、流程控制語句

Dart語言的流程控制語句如下：if和else、for(循環)、while和do-while(循環)、break和continue、switch和case、assert(斷言)、try-catch和throw。

(1)if和else

Dart支持if及else的多種組合。

String today = 'Monday';
if(today == 'Monday') {
  print('今天是星期一');  
}else if(today == 'Tuesday') {
  print('今天是星期二');
}else {
  print('今天是個好日子');  
}
//輸出'今天是星期一'，條件語句走到第一條判斷就停止了。

(2)for(循環)

//打印出0-50的偶數
for(var i = 0; i <= 50; i++){
      if(i%2 == 0){
        print(i);
      }
}

//求1到100的和
var sum = 0;
for(var i = 0; i <= 100; i++){
      sum += i;
}
print(sum); //5050

//計算5的階乘 1*2*3*4*5
var sum = 1;
for(var i = 1; i <= 5; i++){
      sum *= i;
}
print(sum); //120

//打印List里的內容
List arr = ['張三','李四','王五'];
for(var i = 0; i < arr.length; i++){
    print(arr[i]);
}

//也可以用for-in實現
List arr = ['張三','李四','王五'];
for(var item in arr){
    print(item);
}

//打印List里的內容
List arr = [
   {"title":"新聞1"},{"title":"新聞2"},{"title":"新聞3"},
];
for(var i = 0; i < arr.length; i++){
    print(arr[i]["title"]);
}

//打印List里的內容
List arr = [
      {
        "card":"國內",
        "news":[
          {"title":"國內新聞1"},{"title":"國內新聞2"},{"title":"國內新聞3"}
        ]
      },
      {
        "card":"國際",
        "news":[
          {"title":"國際新聞1"},{"title":"國際新聞2"},{"title":"國際新聞3"}
        ]
      },
    ];

    for(var i = 0; i < arr.length; i++){
       print(arr[i]["card"]);
       for(var j = 0; j < arr[i]["news"].length; j++){
          print(arr[i]["news"][j]["title"]);
       }
    }

下面舉例說明，首先定義了一個字符串“Hello Dart”，然后使用for循環向message變量里寫入5個同樣的字符“！”。

var message = new StringBuffer('Hello Dart');
for(var i = 0; i < 5; i ++) {
    message.write(i);
}
print(message);
//輸出“Hello Dart!!!!!”，注意值是字符串向尾部添加的。

//除了常規的for循環外，針對可以序列化的操作數，可以使用forEach()方法，當不關心操作數的當前下標時，forEach()方法師很簡便的。
var arr = [0, 1, 2, 3, 4, 5, 6];
for(var v in arr){
  print(v);
}
//按序列輸出 0 1 2 3 4 5 6

(3)while和do-while(循環)

下面舉例說明while循環，其中定義了一個變量temp，temp在循環體內自動加1，當條件(temp<5)不滿足時會推出循環，代碼如下：

var _temp = 0;
while(_temp < 5) {
  print('這是一個循環：' + (_temp).toString());
  _temp ++;
}


var _temp = 0;
do{
  print(‘這是一個循環：’ + (_temp).toString());
  _temp ++;  
}while(_temp < 5);

//都輸出
//flutter：這是一個循環：0
//flutter：這是一個循環：1
//flutter：這是一個循環：2
//flutter：這是一個循環：3
//flutter：這是一個循環：4

//打印0到10
var i = 0;
while(i <= 10){
    print(i);
    i++;
}

//打印1到100的和
var sum = 0;
var i = 1;
while(i <= 100){
    sum += i;
    i++;
}
print(sum); //5050
//do-while實現
var sum = 0;
var i = 1;
do{
    sum += i;
    i++;
}while(i <= 100);
print(sum); //5050

while和do-while的區別：

while：先判斷第一次循環條件，不成立的情況下，不執行語句；

do-while：先執行一次語句，再判斷第一次循環條件。

注意：死循環的問題。

(4)break和continue：

break可以用在switch case中，也可以用在for循環和while循環中。

break語句功能：
①、在switch語句中使流程跳出
②、在循環語句中使流程跳出當前循環，遇到break循環終止，后面代碼也不會再執行；在多層循環中，一個break語句只能向外跳一層

continue可以用在for循環以及while循環中，但是不建議用在while循環里，不小心容易造成死循環。

continue語句的功能：
只能在循環語句中使用，使本次循環結束，即跳過循環體，從下面尚未執行的語句，接著進行下去

break用來跳出循環，改造前面的循環例子：

var arr = [0, 1, 2, 3, 4, 5, 6];
for(var v in arr){
  if(v == 2){
     break;
  }  
  print(v);
}
//當v等于2的時候跳出循環，所以輸出“0，1”。現在把break改為continue

var arr = [0, 1, 2, 3, 4, 5, 6];
for(var v in arr){
  if(v == 2){
     //break;
     continue;
  }  
  print(v);
}
//改為continue后，當v等于2的時候只是跳出本次循環，代碼還會繼續往下執行，所以輸出結果是“0,1,3,4,5,6”

//continue例子
for(var i = 0; i <=10; i++){
    if( i == 4){
        continue; //跳出本次循環體，繼續下面的循環
    }
    print(i);
}
//0 1 2 3 5 6 7 8 9 10

//如果i等于4跳出循環
for(var i = 0; i <=10; i++){
   if( i == 4){
        break;
      }
   print(i);
}
//0 1 2 3 

//break跳出一層循環
for(var i = 0; i < 3; i++){
    print("外層---$i");
    for(var j = 0; j < 3; j++){
        if(j == 1){
          break;
        }
        print("里層$j");
    }
}
//外層---0
//里層0
//外層---1
//里層0
//外層---2
//里層0

(5)switch和case

Dart中switch/case語句使用==操作來比較整數、字符串或其他編譯過程中的常量，從而實現分支的作用。switch/case語句的前后操作數必須是相同類型的對象實例。每一個非空的case子句最后都必須跟上break語句。

String today = 'Monday';
switch(today) {
  case 'Monday' : 
    print('星期一');
    break;
  case 'Tuesday' :
    print('星期二');
    break;
}

(6)assert(斷言)

Dart語言通過使用assert語句來中斷正常的執行流程，當assert判斷的條件為false時發生中斷。assert判斷的條件是任何可以轉化為boolean類型的對象，即使是函數也可以。如果assert的判斷為true，則繼續執行下面的語句；反之則會拋出一個斷言錯誤異常AssertionError。

//確定變量的值不為null
assert(text != null);

6、方法

(1)自定義方法

自定義方法基本格式：

返回類型  方法名稱(參數1,參數2...){
  方法體
  return 返回值;
}

//定義方法
void printInfo(){ //void 是沒有返回值的
    print("我是一個自定義方法");
}
//運行方法
printInfo(); 

int getNum(){ //int是方法的返回值類型
    var myNum = 123;
    return myNum;
}
var n = getNum(); //調用方法，并發返回值賦給n
print(n); //123

String printInfo(){
    return 'This is string';
} 
var str = printInfo();
print(str); //This is string

List getList(){
    return ["aa","bb","cc"];
}
print(getList()); //[aa, bb, cc]

調用方法傳參：

例子1：定義一個方法，求1到這個數的所有的和

int sumNum(n){
    var sum = 0;
    for(var i = 0; i <= n; i++){
        sum += i;
    }
    return sum;
}
print(sumNum(10)); //55
print(sumNum(100)); //5050

例子2：定義一個打印用戶信息的方法

String printUserInfo(String name, int age){ //形參
    return "姓名：$name--年齡：$age";
}     
print(printUserInfo("張三",20)); //實參

例子3：定義一個帶可選參數的方法

String printUserInfo(String name, [int age]){ //[]可選參數
    if(age != null){
        return "姓名：$name--年齡：$age";
    }
    return "姓名：$name--年齡：保密";
}  
print(printUserInfo("張三"));    
print(printUserInfo("李四",20)); 

例子4：定義一個帶默認參數的方法

String printUserInfo(String name, [int age, String sex = "男"]){ 
    if(age != null){
        return "姓名：$name--年齡：$age--性別：$sex";
    }
    return "姓名：$name--年齡保密--性別：$sex";
    }  
print(printUserInfo("張三")); //姓名：張三--年齡保密--性別：男   
print(printUserInfo("李四",20)); //姓名：李四--年齡：20--性別：男
print(printUserInfo("王五",20,"女")); //姓名：王五--年齡：20--性別：女
//有個問題，如果實現只寫名字和性別會報錯，不能中間空一項，必須三項都寫

例子5：定義一個命名參數的方法

//用命名參數{}不會出現上面問題，不過實參要寫上key
String printUserInfo(String name, {int age, String sex = "男"}){ 
    if(age != null){
        return "姓名：$name--年齡：$age--性別：$sex";
    }
    return "姓名：$name--年齡保密--性別：$sex";
}  
print(printUserInfo("張三")); //姓名：張三--年齡保密--性別：男   
print(printUserInfo("李四",age:20)); //姓名：李四--年齡：20--性別：男
print(printUserInfo("王五",sex:"女")); //姓名：王五--年齡保密--性別：女

例子6：實現一個把方法當做參數的方法

//把fn1賦值給了fn，然后調用fn2執行里面的fn，打印出里面的“String” 
fn1(){
      print("String");
}
fn2(fn){
      fn();
}
//調用fn2方法，把fn1方法當做參數傳入
fn2(fn1); //fn1

//更好理解
var fn = (){
    print("我是一個匿名方法");
};
fn();

(2)匿名方法

var printNum = (int n){
    print(n+2);
};
printNum(3); //5

(3)自執行方法

格式：

((){
   ...  
})();
//或者
(){
   ...
}();

例子：

((n){
    print(n);
})(12); //12

(4)方法的遞歸

例子1：通過方法的遞歸求5的階乘

var sum = 1;
fn(n){
    sum *= n;
    if(n == 1){
        return;
    }
    fn(n-1);
}
fn(5);
print(sum); //120

例子2：通過方法的遞歸求1到100的和

var sum = 0;
fn(n){
    if(n == 0){
        return;
    }
    sum += n;
    fn(n-1);
}
fn(100);
print(sum); //5050

(5)閉包

閉包的寫法：函數嵌套函數，并return里的函數，這樣就形成了閉包

想實現的功能：常駐內存、不污染全局

fn(){
    var a = 123; //不會污染全局，常駐內存
    return(){
        a++;
        print(a);
    };
}
var b = fn();
b(); //124
b(); //125
b(); //126

7、異常處理

異常是表示發生了意外的錯誤，如果沒有捕獲異常，引發異常的隔離程序將被掛起。并且程序將終止。

Dart代碼可以拋出并捕獲異常，但與Java相反，Dart的所有異常都是未檢查的異常。方法不聲明它們可能拋出那些異常，也不需要捕獲任何異常。

Dart提供了異常和錯誤類型以及許多預定義的子類型。當然，也可以定義自己的異常。然后，Dart程序可以拋出任何非空對象。

(1)拋出異常

下面是一個拋出或引發異常的例子：

throw FormatException('拋出一個FormatException異常');

你也可以拋出任意對象：

throw '數據非法！';

提示：穩定健壯的程序一定是做了大量異常處理的，所以建議你在編寫程序時盡量考慮到可能發生異常的情況。

(2)捕獲異常

你可以指定一個或兩個參數來捕獲異常(catch)，第一個是拋出的異常，第二個是堆棧跟蹤(StackTrace對象)。如下代碼所示：

try {
         //...
      }on Exception catch (e) {
         print('Exception details:
 $e');
      }catch (e, s) {
         pring('Exception details:
 $e');
         pring('Stack trace:
 $s');
      } 
//上面的代碼第一個catch用來捕獲異常詳細信息，第二個catch是堆棧跟蹤信息

//例如 
String str = "";
    try{
      var myNum = double.parse(str); 
      print(myNum is double);
    }catch(e){
      print(0);
    }
//str為空，所以轉換Number類型失敗，打印0

(3)Finally

要確保某些代碼能夠運行，無論是否拋出異常，請使用finally子句。如果沒有catch子句匹配異常，則異常在finally子句運行后傳播。如下面代碼所示，在最下面加上了finally語句：

try {
         //...
      }on Exception catch (e) {
         print('Exception details:
 $e');
      }catch (e, s) {
         pring('Exception details:
 $e');
         pring('Stack trace:
 $s');
      }finally {
         print('Do some thing:
');
      }

8、面向對象 （面向對象的三大特性：封裝、繼承、多態）

Dart作為高級語言支持面向對象的很多特性，并且支持基于mixin的繼承方式。基于mixin的繼承方式是指：一個類可以繼承自多個父類，相當于其他語言里的多繼承。所有的類都有同一個基類Object，這個特性類似于Java語言，Java所有的類也都是繼承自Object，也就是說一切皆為對象。所有的對象都是類的實例，并且所有的類都是Object的子類。

使用new語句實例化一個類，如下所示：

//實例化了一個User類的對象user
var user = new User('張三', 20);

(1)實例化成員變量

定義一個User類，在里面添加兩個成員變量name和age，代碼如下：

class User{
  String name; //name成員變量
  String age; //age成員變量
}    

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

class User{
  String name; //name成員變量
  Int age; //age成員變量
}
main() {
  var user = new User();
  user.name = '張三'; //相當于使用了name的setter方法
  user.age = 20;
}

class User{
    String name = "張三";
    int age = 20;
    void getInfo(){
        //print("$name----$age");
        print("${this.name}----${this.age}");
    }
    void setInfo(int age){
        this.age = age;
    }
}

void main(){
    //實例化
    var user = new User();
    //也可以指定類型  User user = new User();
    print(user.name); //張三
    user.getInfo(); //張三----20
    user.setInfo(25);
    user.getInfo(); //張三----25
}

私有屬性、私有方法：

私有屬性：私有屬性需要單獨一個文件才可以使用

例子：新建Animal.dart文件

Animal{
    String _name; //私有屬性
    int age;
    Animal(this._name, this.age);
}

在main.dart文件里引入Animal.dart文件

import '../test/Animal.dart';
void main(){
   Animal a = new Animal("小狗", 3);
   print(a._name); //因為_name是私有屬性，所以會報錯
   print(a.age); //3
}

利用公有方法訪問私有屬性

還是上面的例子：

Animal{
    String _name; //私有屬性
    int age;
    Animal(this._name, this.age);
    //公有方法
    String getName(){ 
        return this._name;
    }
}    

import '../test/Animal.dart';
void main(){
   Animal a = new Animal("小狗", 3);
   print(a._name); //因為_name是私有屬性，所以會報錯
   print(a.age); //3
   print(a.getName()); //小狗
}

私有方法也是同理，可以通過公有方法間接的訪問私有方法：

Animal{
    String _name; //私有屬性
    int age;
    Animal(this._name, this.age);
    //私有方法
    void _run(){ 
        print("這是個私有方法");
    }
    getRun(){
        this._run(); //類里面方法的相互調用
    }
}

import '../test/Animal.dart';
void main(){
   Animal a = new Animal("小狗", 3);
   print(a._name); //因為_name是私有屬性，所以會報錯
   print(a.age); //3
   print(a.getName()); //小狗
   //間接的調用私有方法
   a.getRun(); //這是一個私有方法
}

靜態屬性、靜態方法：靜態方法不能訪問非靜態成員，非靜態方法可以訪問靜態成員以及非靜態成員

例子：

class User{
    static String name = "張三";
    int age = 20;
    static void show(){ //靜態方法
        print(name);
        print(this.age); //報錯，靜態方法不可以訪問非靜態成員
    }
    void printInfo(){ //非靜態方法可以訪問靜態成員以及非靜態成員
        print(name); //訪問靜態屬性
        print(this.age); //訪問非靜態屬性
        show(); //調用靜態方法
    }
}
void main(){
    //靜態屬性和方法不用實例化，可以直接調用
    print(User.name); //張三
    User.show(); //張三
    User user = new User(); //非靜態屬性和方法需要實例化
    user.printInfo(); //張三 //20 //張三
}

(2)構造函數

①默認構造函數

class User{
    String name = "張三";
    int age = 20;
    //默認構造函數
    User(){
       print("這是構造函數里面的內容，這個方法在實例化的時候觸發");
    }
}

main(){
    //實例化
    User user = new User();
    //運行，自動打印出：這是構造函數里面的內容，這個方法在實例化的時候觸發
}

②常規構造函數

構造函數是用來構造當前類的函數，是一個特殊的函數，函數名稱必須要和類名相同才行。如下代碼為User類添加了一個構造函數，函數里給User類的兩個成員變量初始化了值：

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

//this關鍵詞指向了當前類的實例，上面的代碼可以簡化為：

class User{
  String name;
  int age;
  User(this.name, this.age);
}

例子：

class User{
    String name;
    int age;
    User(this.name, this.age);
    void printInfo(){
        print("${this.name}----${this.age}");
    }
}

void main(){
   User user1 = new User("張三", 20);
   user1.printInfo(); //張三----20   
   User user2 = new User("李四", 25);
   user2.printInfo(); //李四----25 
}

③命名的構造函數

使用命名構造函數從另一類或現有的數據中快速實現構造函數，代碼如下：

class User {
  String name;
  int age;
 
  User(this.name, this.age);
  
  //命名構造函數
  User.fromJson(Map json) {
     name = json['nage'];
     age = json['age'];
  }
}

例子：

class User {
    String name;
    int age;
    User(this.name, this.age);
    //命名構造函數，可以多個
    User.now(){
        print("我是命名構造函數");
    }
    User.setInfo(String name, int age){
        this.name = name;
        this.age = age;
    }
    void printInfo(){
        print("${this.name}----${this.age}");
    }
}

void main(){
    //調用命名構造函數
    User user1 = new User.now(); //我是命名構造函數
    User user2 = new User.setInfo("李四",30);
    user2.printInfo(); //李四----30
}

一般把類單獨離成一個模塊（一個dart文件），使用的時候引入這個dart文件就可以了。

④構造函數初始化列表（先賦值再執行構造函數）

除了調用父類的構造函數，也可以通過初始化列表在子類的構造函數運行前來初始化實例的成員變量值。代碼如下：

class User {
  final String name;
  final int age;
  
  User(name, age)
         : name = name,
           age = age;
}

main() {
  var p = new User('張三', 20);
}

例子：

class Rect{
    num height;
    num width;
    Rect():height=2, width=10{
        print("${this.height}----${this.width}");
     }
    getArea(){
        return this.height * this.width;
    }
}
void main(){
    Rect r = new Rect();
    print(r.getArea()); 
}
//2----10
//20

(3)讀取和寫入對象

get()和set()方法是專門用于讀取和寫入對象的屬性方法，每一個類的實例，系統都隱式地包含有get()和set()方法。這和很多語言里的VO類相似。

get例子：

class Rect{
    num height;
    num width;
    Rect(this.height,this.width);
    area(){
        return this.height * this.width;
    }
}
void main(){
    Rect r = new Rect(10, 4);
    print("面積：${r.area()}"); //面積：40
}
//使用get
class Rect{
    num height;
    num width;
    Rect(this.height,this.width);
    get area{
        return this.height * this.width;
    }
}
void main(){
    Rect r = new Rect(10, 4);
    print("面積：${r.area}"); //面積：40  //注意調用直接通過訪問屬性的方式訪問area
}

set例子：

class Rect{
    num height;
    num width;
    Rect(this.height,this.width);
    get area{
        return this.height * this.width;
    }
    set areaHeight(value){
        this.height = value;
    }
}
void main(){
    Rect r = new Rect(10, 4);
    r.areaHeight = 6;
    print("面積：${r.area}"); //面積：24
}

例如，定義一個矩形的類，有上、下、左、右四個成員變量：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);

  //獲取right值
  num get right  => left + width;

  //設置right值 同時left也發生變化
  set right(num value)  => left = value - width;
  
  //獲取bottom值
  num get bottom => top + height;

  //設置bottom值 同時top也發生變化
  set bottom(num value)  => value - height;
}

main(){
  var rect = new Rectangle(3, 4, 20, 15);

  print('left:' + rect.left.toString());
  print('right:' + rect.right.toString());
  rect.right = 30;
  print('更改right值為30');
  print(‘left:’ + rect.left.toString());
  print('right:' + rect.right.toString());

  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());
}
//對應的輸出為：
//flutter: left:3
//flutter: right:23
//flutter: 更改right值為30
//flutter: left:10  //30-20
//flutter: right:30
//flutter: top:4
//flutter: bottom:19
//flutter: 更改bottom值為50
//flutter: top:35  //50-15
//flutter: bottom:50

(4)重載操作

編寫一個例子，定義一個Vector向量類，編寫兩個方法分別用于重載加號以及減號，那么兩個向量相加，就表示它們的x值及y值相加，當兩個向量相減，就表示它們的x值及y值相減。

//定義一個向量類
class Vector {
  final int x;
  final int y;
  const Vector(this.x, this.y);

  //重載加號 + (a + b)
  Vector operator +(Vector v) {
     retrun new Vector(x + v.x, y + v.y);
  }

  //重載減號 - (a - b)
  Vector operator -(Vector v) {
     retrun new Vector(x - v.x, y - v.y);
  }
}

main() {
  //實例化兩個向量
  final v = new Vector(2, 3);
  final w = new Vector(2, 2);
  final r1 = v + w;
  print('r1.x=' + r1.x.toString() + ' r1.y=' + r1.y.toString());
  final r2 = v - w;
  print('r2.x=' + r2.x.toString() + ' r2.y=' + r2.y.toString());
}

//上面輸出結果為：
//flutter: r1.x=4  r1.y=5   //2+2  2+3
//flutter: r2.x=0  r1.y=1   //2-2  3-2

(5)繼承類

繼承是面向對象編程技術的一塊基石，因為它允許創建分等級層次的類。繼承就是子類繼承父類的特征和行為，使得子類對象(實例)具有父類的實例域和方法；或子類從父類繼承方法，使得子類具有父類相同的行為。Dart里使用extends關鍵字來創建一個子類，super關鍵字來制定父類。

Dart中的類的繼承：
①子類使用extends關鍵詞來繼承父類
②子類會繼承父類里面可見的屬性和方法，但是不會繼承構造函數
③子類能復寫父類的方法 getter 和 setter

例子1：子類繼承父類

class User{
  String name = "張三";
  num age = 20;
  User(this.name,this.age);
  void printInfo(){
    print("${this.name}----${this.age}");
  }
}
class Web extends User{ //Web類繼承User類里面可見的屬性和方法

}

void main(){
  Web w = new Web();
  print(w.name); //張三
  w.printInfo(); //張三----20
}

例子2：實例化子類的時候給父類傳參，通過super來實現

class User{
  String name;
  num age;
  User(this.name,this.age);
  void printInfo(){
    print("${this.name}----${this.age}");
  }
}
class Web extends User{ 
  //Web類的構造函數:初始化列表
  Web(String name, num age) : super(name, age){ //執行子類的構造函數之前，把子類里面的傳過來的參數賦值給父類

  }
}

void main(){
  Web w new Web("張三",12);
  w.printInfo(); //張三----12
}

例子3：子類里可以定義自己的屬性和方法

class User{
  String name;
  num age;
  User(this.name,this.age);
  void printInfo(){
    print("${this.name}----${this.age}");
  }
}
class Web extends User{ 
  String sex;
  //Web類的構造函數:初始化列表
  Web(String name, num age, String sex) : super(name, age){ 
    this.sex = sex; 
  }
  run(){
    print(("${this.name}----${this.age}----${this.sex}");
  }
}

void main(){
  Web w = new Web("張三",12,"男");
  w.printInfo(); //張三----12
  w.run(); //張三----12----男
}

例子4：給父類的命名構造函數傳參

class User{
  String name;
  num age;
  User(this.name,this.age);
  User.xxx(this.name,this.age); //命名構造函數
  void printInfo(){
    print("${this.name}----${this.age}");
  }
}
class Web extends User{ 
  String sex;
  //Web類的構造函數:初始化列表
  Web(String name, num age, String sex) : super.xxx(name, age){ //給命名的構造函數傳參
    this.sex = sex; 
  }
  run(){
    print(("${this.name}----${this.age}----${this.sex}");
  }
}

void main(){
  Web w = new Web("張三",12,"男");
  w.printInfo(); //張三----12
  w.run(); //張三----12----男
}

例子5：子類里直接調用父類方法

class User{
  String name;
  num age;
  User(this.name,this.age);
  void printInfo(){
    print("${this.name}----${this.age}");
  }
  work(){
    print("${this.name}在公作...");
  }
}
class Web extends User{ 
  Web(String name, num age) : super(name, age){ 
    
  }
  run(){
    print(("run");
    super.work(); //子類直接調用父類的方法  也可以通過this
  }
}

void main(){
  Web w = new Web("李四",20);
  w.run(); //run //李四在公作...
}

例子6：子類里復寫父類的方法

class User{
  String name;
  num age;
  User(this.name,this.age);
  void printInfo(){
    print("${this.name}----${this.age}");
  }
  work(){
    print("${this.name}在公作...");
  }
}
class Web extends User{ 
  Web(String name, num age) : super(name, age){ 
    
  }
  run(){
    print(("run");
  }
  //復寫父類的方法 和父類的方法名字一樣
  @override //復寫父類方法的時候建議寫上
  void printInfo(){
    print("姓名:${this.name}----年齡:${this.age}");
  }
  @override
  work(){
    print("${this.name}的工作是寫代碼");
  }

}

void main(){
  Web w = new Web("李四",20);
  w.printInfo(); //姓名:李四----年齡:20
  w.work(); //李四的工作是寫代碼
}

例子：定義一個動物類，動物具有吃和跑兩種能力。再定義一個人類，人類是屬于動物類的，人類不僅會吃和會跑，還會說、會學習。所以人類相當于動物類的一個擴展。具體代碼：

//動物類
class Animal {
  //動物會吃
  void eat() {
    print('動物會吃');  
  }
  //動物會跑
  void run() {
    print('動物會跑');  
  }
}  

//人類
class Person extends Animal{
  //人類會說
  void say() {
    print('人類會說');
  }
  //人類會學習
  void study() {
    print('人類會學習');
  }
}  

main() {
  print('實例化一個動物類');
  var animal = new Animal();
  animal.eat();
  animal.run();

  print('實例化一個人類');
  var person = new Person();
  person.eat();
  person.run();
  person.say();
  person.study();
}
//輸出結果：
//flutter:實例化一個動物類
//flutter:動物會吃
//flutter:動物會跑
//flutter:實例化一個人類
//flutter:動物會吃
//flutter:動物會跑
//flutter:人類會說
//flutter:人類會學習

(6)抽象類

抽象類類似于Java語言中的接口。抽象類里不具體實現方法，只是寫好定義接口，具體實現留著調用的人去實現。

Dart中的抽象類：Dart抽象類主要用于定義標準，子類可以繼承抽象類，也可以實現抽象類接口。

①.抽象類通過abstract關鍵字來定義
②.Dart中的抽象方法不能用abstract聲明，Dart中沒有方法體的方法我們稱為抽象方法。
③.如果子類繼承抽象類，必須實現里面的抽象方法
④.如果把抽象類當做接口實現的話，必須得實現抽象類里面定義的所有屬性和方法。
⑤.抽象類不能被實例化，只有繼承它的子類可以

例子：定義一個Animal類，要求它的子類必須包含eat方法

abstract class Animal{ //abstract定義抽象類
  eat(); //抽象方法 沒有方法體的方法我們稱為抽象方法
  run(); //抽象方法
  printInfo(){ //非抽象方法 普通方法
    print("我是一個抽象類里面的普通方法");
  }
}
class Dog extends Animal{ //如果子類繼承抽象類，必須實現里面的抽象方法
  @override
  eat(){
   print("小狗在吃骨頭");
  }
  @override
  run(){
   print("小狗在跑");
  }
}
class Cat extends Animal{ //如果子類繼承抽象類，必須實現里面的抽象方法
  @override
  eat(){
    print("小貓在吃魚");
  }
  @override
  run(){
   print("小貓在跑");
  }
}

void main(){
  Dog dog = new Dog();
  dog.eat(); //小狗在吃骨頭
  Cat cat = new Cat();
  cat.eat(); //小貓在吃魚
  var a = new Animal(); //報錯，Animal是抽象類沒法直接被實例化
  //抽象類不能被實例化，只有繼承它的子類可以
  cat.printInfo(); //我是一個抽象類里面的普通方法
}

例子：定義一個抽象類叫DateBaseOperate，里面定義4個數據庫常用的操作方法“增刪改查”。再定義一個類命名為DateBaseOperateImpl繼承自DateBaseOperate用來實現抽象類里的方法。代碼如下：

//數據庫操作抽象類
abstract class DateBaseOperate {
  void insert();  //定義插入的方法
  void delect();  //定義刪除的方法
  void update();  //定義更新的方法
  void query();   //定義查詢的方法
}

//數據庫操作實現類
class DateBaseOperateImpl extends DateBaseOperate {
  //實現了插入的方法
  void insert() {
    print('實現了插入的方法');
  }
  //實現了刪除的方法
  void delect() {
    print('實現了刪除的方法');
  }
  //實現了更新的方法
  void update() {
    print('實現了更新的方法');
  }
  //實現了查詢的方法
  void query() {
    print('實現了查詢的方法');
  }  
}    

main(){
  var db = new  DateBaseOperateImpl();
  db.insert();
  db.select();
  db.update();
  db.query();
}
//輸出結果為：
//flutter:實現了插入的方法
//flutter:實現了刪除的方法
//flutter:實現了更新的方法
//flutter:實現了查詢的方法

(7)接口：

首先，dart的接口沒有interface關鍵字定義接口，而是普通類或抽象類都可以作為接口被實現。
同樣使用implements關鍵字進行實現接口。
但是dart的接口有點奇怪，如果實現的類是普通類，會將普通類和抽象類中的屬性的方法全部需要復寫一遍。
而因為抽象類可以定義抽象方法，普通類不可以，所以一般如果要實現像Java接口那樣的方式，一般會使用抽象類。
建議使用抽象類定義接口。

例子：定義一個DB庫，支持mysql、mssql、mongodb，這三個類里面都有同樣的方法。

abstract class Db{ //abstract定義抽象類 當做接口 接口就是約定、規范
  String url; //數據庫的鏈接地址
  add(String data);
  edit();
  delete();
}
class Mysql implements Db{ //implements來實現接口Db
  @override
  String url;
  Mysql(this.url);

  @override
  add(String data){
    print("這是mysql的add方法" + data);
  }
  @override
  edit(){
    
  }
  @override
  delete(){
    
  }
} 
class Mssql implements Db{ //implements來實現接口Db
  @override
  String url;
  @override
  add(String data){
    print("這是mssql的add方法" + data);
  }
  @override
  edit(){
    
  }
  @override
  delete(){
    
  }
}

void main(){
  Mysql mysql = new Mysql("http://xxx");
  mysql.add("12345"); //這是mysql的add方法12345
}

可以把以上代碼分離成3個dart文件，方便想用誰就可以引用誰。

Db.dart

abstract class Db{ //abstract定義抽象類 當做接口 接口就是約定、規范
  String url; //數據庫的鏈接地址
  add(String data);
  edit();
  delete();
}

Mysql.dart

impor "Db.dart";
class Mysql implements Db{ //implements來實現接口Db
  @override
  String url;
  Mysql(this.url);

  @override
  add(String data){
    print("這是mysql的add方法" + data);
  }
  @override
  edit(){
    
  }
  @override
  delete(){
    
  }
} 

Mssql.dart

import "Db.dart";
class Mssql implements Db{ //implements來實現接口Db
  @override
  String url;
  Mssql(this.url);
  @override
  add(String data){
    print("這是mssql的add方法" + data);
  }
  @override
  edit(){
    
  }
  @override
  delete(){
    
  }
}

使用那個就引用：

import "Mysql.dart";
import "Mssql.dart";

void main(){
  Mysql mysql = new Mysql("http://xxx");
  mysql.add("12345"); //這是mysql的add方法12345
  Mssql mssql = new Mssql();
  mssql.url = "http://xxx"; 
  mssql.add("增加的數據"); //這是這是mssql的add方法增加的數據
}

extends抽象類和implements的區別：
①.如果要復用抽象類里面的方法，并且要用抽象方法約束子類的話，我們就用extends繼承抽象類
②.如果只是把抽象類當做標準的話，我們就用implements實現抽象類。

例子：Dart中一個類實現多個接口：

abstract class A{ //abstract定義抽象類A 當做接口
      String name;
      printA(); //抽象方法
}
abstract class B{ //abstract定義抽象類B 當做接口
      printB(); //抽象方法
}
class C implements A,B{ //implements來實現接口A,B,實現所有屬性和方法
      @override
      String name;
      @override
      printA(){
        print("printA");
      }
      @override
      printB(){

      }
}

void main(){
      C c = new C(); //實例化C
      c.printA(); //printA
}

(8)Dart中的多態：

允許將子類類型的指針賦值給父類類型的指針，同一個函數調用會有不同的執行效果。
子類的實例賦值給父類的引用。
多態就是父類定義一個方法不去實現，讓繼承它的子類去實現，每個子類有不同的表現。

例子：這個就是多態

abstract class Animal{ //abstract定義抽象類
  eat(); //抽象方法  父類定義一個方法不去實現，讓繼承它的子類去實現，每個子類有不同的表現。
}
class Dog extends Animal{ //如果子類繼承抽象類，必須實現里面的抽象方法
  @override
  eat(){
   print("小狗在吃骨頭");
  }
}
class Cat extends Animal{ //如果子類繼承抽象類，必須實現里面的抽象方法
  @override
  eat(){
    print("小貓在吃魚");
  }
}

void main(){
  Dog dog = new Dog();
  dog.eat(); //小狗在吃骨頭
  Cat cat = new Cat();
  cat.eat(); //小貓在吃魚
}

例子：也是多態，如果子類只能運行父類里定義的方法

abstract class Animal{ //abstract定義抽象類
  eat(); //抽象方法  父類定義一個方法不去實現，讓繼承它的子類去實現，每個子類有不同的表現。
}
class Dog extends Animal{ //如果子類繼承抽象類，必須實現里面的抽象方法
  @override
  eat(){
   print("小狗在吃骨頭");
  }
  run(){
    print("run");
  }
}
class Cat extends Animal{ //如果子類繼承抽象類，必須實現里面的抽象方法
  @override
  eat(){
    print("小貓在吃魚");
  }
  run(){
    print("run");
  }
}

void main(){
  Animal dog = new Dog(); //表示把子類的實例賦值給了父類的一個引用，不能在調用run方法，只能調用父類定義的方法
  dog.eat(); //小狗在吃骨頭
  Animal cat = new Cat();
  cat.eat(); //小貓在吃魚
}

(9)枚舉類型

枚舉類型是一種特殊的類，通常用來表示相同類型的一組常量值。每個枚舉類型都用于一個index的getter，用來標記元素的元素位置。第一個枚舉元素的索引是0.

enum Color {
  red,
  green,
  blue
}

獲取枚舉類中所有的值，使用value常用：

List<Color> colors = Color.values;

因為枚舉類型里面的每個元素都是相同類型，可以使用switch語句來針對不同的值做不同的處理，示例代碼如下：

enum Color {
  red,
  green,
  blue
}
//定義一個顏色變量 默認值為藍色
Color aColor = Color.blue;
switch (aColor) {
  case Color.red:
    print('紅色');
    break;
  case Color.green:
    print('綠色');
    break;
  default: //默認顏色
    pring(aColor); //Color.blue
}

(10)Mixins：中文意思是混入，就是在類中混入其他功能，實現類似多繼承的功能。

Mixins(混入功能)相當于多繼承，也就是說可以繼承多個類。使用with關鍵字來實現Mixins的功能。

因為mixins使用的條件，隨著Dart版本一直在變，這里講的是Dart2.x中使用mixins的條件：
①.作為mixins的類只能繼承自Object，不能繼承其他的
②.作為mixins的類不能有構造函數
③.一個類可以mixins多個mixins類
④.mixins絕不是繼承，也不是接口，而是一種全新的特性

例子1：

class A{
    String info = "this is A";
    void printA(){
        print("A");
    }
}
class B{
    void printB(){
        print("B");
    }
}
class C with A,B { //混入 C類繼承A類和B類的屬性和方法
      
}

void main(){
    var c = new C();
    c.printA(); //A
    c.printB(); //B
    print(c.info); //this is A
}

例子2：

class User{
      String name;
      num age;
      User(this.name,this.age);//構造函數
      printInfo(){
        print("${this.name}----${this.age}");
      }
      void run(){
        print("User run");
      }
}
class A{ 
      String info = "this is A";
      void printA(){
        print("A");
      }
      void run(){
        print("A run");
      }
}
class B{
      void printB(){
        print("B");
      }
      void run(){
        print("B run");
      }
}
class C extends User with A,B { //即繼承User又混入A,B
      C(String name, num age):super(name,age); //父類里有構造函數并傳參的話，子類也要寫構造函數
    }

void main(){
      var c = new C("張三",20);
      c.printInfo(); //張三----20
      c.run(); //B run  //同樣的run方法，后面的把前面的覆蓋了
}

示例代碼如下：

class S {
  a() {print('S.a');}
}
class A {
  a() {print('A.a');}
  b() {print('A.b');}
}

class T = A with S;

main(List<String> args) {
  T t = new T();
  t.a();
  t.b();
}
//上面代碼從結果來看T具有了S及A兩個類的方法
//S.a
//A.b

Mixins的實例類型是其超類的子類型：

class A{ 
    String info = "this is A";
    void printA(){
        print("A");
    }
}
class B{
    void printB(){
        print("B");
    }
}
class C with A,B { 
}

void main(){
    var c = new C();
    print(c is A); //true A和B就是C的超類
    print(c is B); //true
}

9、泛型：就是解決類、接口、方法的復用性，以及對不特定數據類型的支持（類型校驗）

泛型通常是為了類型安全而設計的，適當地指定泛型類型會生成更好的代碼，可以使用泛型來減少代碼重復。Dart中使用<T>的方式來定義泛型。

例子：傳入什么類型，返回什么類型的數據

T getData<T>(T value){ //T代表泛型，可以是任意字母
    return value;
}
//也可以這樣寫，對傳入參數進行校驗，不對返回參數校驗
getData<T>(T value){ 
    return value;
}
    
void main(){
    print(getData<int>(12)); //12
}

例如，如果想要List只包含字符串，可以將其聲明為list<String>。如下所示：

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

(1)用于集合類型

泛型用于List和Map類型參數化：List:<type> Map:<keyType, valueType>

例子：

List list = new List<String>();
list.add('你好');
list.add('大家好');
print(list); //[你好, 大家好]
    
List list2 = new List<int>();
list2.add(11);
list2.add(22);
print(list2); //[11, 22]

例子：

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

例子：把下面類轉換成泛型類，要求List里面可以增加int類型的數據，也可以增加String類型的數據。

class PrintClasee<T>{
    List list = new List<T>();
    void add(T value){
        this.list.add(value);
    }
    void printInfo(){
        for(var i = 0; i < this.list.length; i++){
          print(this.list[i]);
        }
    }
}

void main(){
    PrintClasee p = new PrintClasee<String>();
    p.add("你好");
    p.add("大家好");
    p.printInfo(); //你好 //大家好

    PrintClasee p2 = new PrintClasee<int>();
    p2.add(12);
    p2.add(33);
    p2.printInfo(); //12 //33
}

(2)在構造函數中參數化

Map類型的例子如下：

var users = new Map<String, String>();

(3)泛型接口

實現數據緩存的功能：有文件緩存和內存緩存，文件緩存和內存緩存按照接口約束實現
①.定義一個泛型接口，約束實現它的子類必須由getByKey(key)和setByKey(key,value)
②.要求setByKey時候的value的類型和實例化子類時候指定的類型一致

abstract class Cache<T>{
      getByKey(String key);
      void setByKey(String key, T value);
    }
class FileCache<T> implements Cache<T>{ //文件緩存
      @override
      getByKey(String key){
        return null
      }
      @override
      void setByKey(String key, T value){
        print("我是文件緩存 把key=${key}  vlaue=${value} -寫入文件中");
      }
    }
class MemoryCache<T> implements Cache<T>{ //內存緩存
      @override
      getByKey(String key){
        return null
      }
      @override
      void setByKey(String key, T value){
        print("我是內存緩存 把key=${key}  vlaue=${value} -寫入內存中");
      }
} 
    
void main(){
      MemoryCache m = new MemoryCache<String>();
      m.setByKey("index","首頁數據"); //我是內存緩存 把key=index  vlaue=首頁數據 -寫入內存中

      MemoryCache map = new MemoryCache<Map>();
      map.setByKey("index",{"name":"張三","age":20}); //我是內存緩存 把key=index  vlaue={"name":"張三","age":20} -寫入內存中
}

10、庫的使用

Dart中的庫主要有三種：
①.我們自定義的庫，比如import "lib/xx.dart";
②.系統內置庫，比如import "dart:io";
③.Pub包管理系統中的庫，比如import "package:dio/dio.dart"; （需要在pubspec.yaml文件里添加依賴）

(1)引用庫

通過import語句在一個庫中引用另一個庫的文件。需要注意以下事項：

在import語句后面需要接上庫文件的路徑。
對Dart語言提供的庫文件使用dart:xx格式。
第三方的庫文件使用package:xx格式。

import例子：

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

(2)指定一個庫的前綴

當引用的庫擁有相互沖突的名字，可以為其中一個或幾個指定不一樣的前綴。這與命名空間的概念比較接近。示例代碼如下：

import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;
//...
Element element1 = new Element();  //使用lib1中的Element
lib2.Element element2 = new lib2.Element();  //使用lib2中的Element

lib1/lib1.dart及lib2/lib2.dart里都有Element類，如果直接引用就不知道具體引用那個Element類，所以代碼中把lib2/lib2.dart指定成lib2，這樣使用lib.Element就不會發生沖突。

(3)引用庫的一部分

如果只需要使用庫的一部分內容，可以有選擇的引用，有如下關鍵字：

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

示例代碼如下：

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

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

11、異步支持

Dart語言是目前少數幾個支持異步操作的語言。一般使用async函數和await表達式實現異步操作。

Dart庫提供asynchronous功能，該功能提供接口來進行耗費時間的操作，比如文件讀寫、網絡請求。該功能返回Future或Stream對象。

可以通過如下的方式來獲取asynchronous功能返回的Future對象的值：

使用async函數和await表達式。
使用Future功能提供的API。

可以通過如下的方式來獲取asynchronous功能返回的Stream對象的值：

使用async和一個異步的循環(awaitfor)。
使用Stream的相關API。

下面的例子代碼使用了async或await異步處理，雖然代碼看起來像是同步處理的：await readFile()

必須在一個使用了async關鍵字標記后的函數中使用await表達式：

fileOperate () async {
  //讀取文件
  var file = await readFile();
  //其他處理
}

12、元數據

使用元數據給代碼添加更多的信息。元數據是以@開始的修飾符，在@后面接著編譯時的常量或調用一個常量構造函數。目前Dart語言提供三個@修飾符：

(1)@deprecated被棄用的

(2)@override重寫

(3)@proxy代理

使用@voerride修飾符可以重寫父類方法。改造之前寫的例子，人類重寫eat方法，代碼如下：

//動物類
class Animal {
  //動物會吃
  void eat(){
    print('動物會吃');
  }
  //動物會跑
  void run(){
    print('動物會跑');
  }
}

//人類
class Person extends Animal {
  //人類會說
  void say(){
    print('人類會說');
  }  
  //人類會學習
  void study(){
    print('人類會學習);
  }

  @override
  //人類也會吃
  void eat(){
    print('人類也會吃');
  }
}

main() {
  print('實例化一個動物類');
  var animal = new Animal();
  animal.eat();
  animal.run();
  print('實例化一個人類');
  var person = new Person();
  person.eat();
  person.run();
  person.say();
  person.study();
}
//輸出結果是
//flutter:實例化一個動物類
//flutter:動物會吃
//flutter:動物會跑
//flutter:實例化一個人類
//flutter:人類也會吃
//flutter:動物會跑
//flutter:人類會說
//flutter:人類會學習

元數據可以修飾library(庫)、class(類)、typedef(類型定義)、typeparameter(類型參數)、constructor(構造函數)、factory(工廠函數)、function(函數)、field(作用域)、parameter(參數)、variabledeclaration(變量聲明)。

13、注釋

Dart支持三種注釋類型：單行注釋、多行注釋、文檔注釋。

(1)單行注釋：以//開頭。從//開始到一行結束的所有內容都會被Dart編譯器忽略。

(2)多行注釋：以/*開頭，以*/結束，之間的所有內容都會被Dart編譯器忽略。

(3)文檔注釋：以/**或///開頭。

總結

以上是生活随笔為你收集整理的Dart 语言简述的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。