image

Dart我們有不得不學(xué)的理由，因?yàn)橛?code>Flutter這尊大神在啊，但是像有的大神這樣瀟灑，現(xiàn)階段我還做不到

如果您熟悉面向?qū)ο蠛突揪幊谈拍睿ㄈ缱兞?、循環(huán)和條件控制），則可以完成本教程，您無需要了解Dart或擁有移動(dòng)開發(fā)的經(jīng)驗(yàn)

膜拜大神...... 初上Dart有種似曾相識(shí)的感覺，那是因?yàn)楝F(xiàn)在高階語(yǔ)言基本趨同，Dart又是融合強(qiáng)類型語(yǔ)言和弱類型語(yǔ)言，所以還是不能直接跳過，要不然很多代碼其實(shí)也是不怎么清楚的。再者對(duì)我自己來說，若是不把Dart系統(tǒng)的走一遍，還是會(huì)有朦朧感的，這樣很不舒服的

本文重在給初次接觸Dart的朋友提供幫助，內(nèi)容涵蓋基礎(chǔ)語(yǔ)法，但是Dart的多線程、異步不在本文之列，那是下一篇的內(nèi)容。同時(shí)呢自己上手操作下、再寫一遍筆記，這樣記得清楚，更是為以后著想，人過留名，雁過留聲，我們學(xué)完了不寫博客怎么證明我們學(xué)過了，以后忘了怎么辦，那就是白學(xué)了嘛，希望大家都自己做筆記寫博客、寫文章

我寫的很隨自己的意思，大家看不慣的話請(qǐng)看下面寫的很標(biāo)準(zhǔn)的：

• Flutter(三)之搞定Dart（一）
• Flutter(四)之搞定Dart（二）

Dart 特性

網(wǎng)上很多文章都說 Dart 在java 的基礎(chǔ)上融會(huì)了高級(jí)語(yǔ)言的特性，但是我想說 java 最新版本就沒有嗎？所以這樣說等于沒說

要我說 Dart = java + kotlin，要是您接觸過 python，那么 Dart = java + python 才是最恰當(dāng)?shù)?，?Dart 中您即可以編寫傳統(tǒng) java 風(fēng)格的代碼，也可以編寫類似 python 風(fēng)格的代碼，下面我盡量給大家展示出來 Dart 在那些方面像 python

1. 像 python 的地方

• 1.1 Dart 支持庫(kù)形式開發(fā)
  用過python的同學(xué)都知道是怎么回事，在java里我們創(chuàng)建一個(gè)class文件必須要在該文件內(nèi)創(chuàng)建一個(gè)和該文件同名的類

public class Name {
    ......
}

但是Dart允許我們?cè)?code>Dart文件種不創(chuàng)建類，直接寫屬性、寫方法，然后以庫(kù)的方式給別人使用

image

DartLib 代碼：

var name = "NAME";

void function1() {
  print(name);
}

void function2() {
  print("BBB");
}

以庫(kù)的形式導(dǎo)入使用

import 'package:flutter_app4/DartLib.dart' as Lib;

void test(){
  Lib.name = "FUN";
  Lib.function1();
}

• 1.2 Dart 允許大家像 python 那樣聲明變量

var book = Book("AA", 18);

• 1.3 Dart 可以像 python 一樣，方法聲明時(shí)返回值可寫可不寫，編譯器會(huì)自動(dòng)判斷返回類型的

  sum( var num1){
    return num1 + 10;
  }

• 1.4 Dart 和 python 最大的區(qū)別：就是 Dart 不能像 python 那樣可以處處省略參數(shù)類型，Dart 必須得寫參數(shù)類型，{}、；也必須寫，要不然 Dart 就真的和 python 差不多了

2. Dart 支持 var 動(dòng)態(tài)類型

Dart 靜動(dòng)態(tài)類型都支持，再加上高級(jí)語(yǔ)言特性，這樣就可以像怎么寫就怎么寫了，即可以寫成傳統(tǒng)的java面向?qū)ο蟆⑻幪幗詫?duì)象的代碼風(fēng)格，也可以像kotlin一樣，還可以像python一樣，現(xiàn)在語(yǔ)言的差異越來越小了，Dart和python的差異很小了，說實(shí)話，我是比較喜歡python的，極簡(jiǎn)是有種魔力的，粘上就忘不了了

3. Dart 有性能優(yōu)勢(shì)

Dart可以在沒有鎖的情況下進(jìn)行對(duì)象分配和垃圾回收。就像JavaScript一樣，Dart避免了搶占式調(diào)度和共享內(nèi)存（因而也不需要鎖），所以Dart可以更輕松地創(chuàng)建以60fps運(yùn)行的流暢動(dòng)畫和轉(zhuǎn)場(chǎng)。這個(gè)在你使用Dart開發(fā)出App之后必定會(huì)深有感觸

基本數(shù)據(jù)類型

Dart 基本數(shù)據(jù)類型：

• 動(dòng)態(tài)類型 - var、dynamic
• 數(shù)值型 - Num、int、double、bool(布爾值)
• 集合型 - List、Map，Dart 沒有數(shù)組的概念，數(shù)組就等于集合
• 文本型 - String
• 方法類 - Function

下面仔細(xì)說下：

1. var和dynamic是動(dòng)態(tài)類型

2. 新的數(shù)學(xué)類型 Num

int、double大家知道是什么，那這個(gè)Num是僅限于數(shù)字的動(dòng)態(tài)類型，數(shù)值可以是int也可以是double

  num name = 10;

  void test() {
    name = 11;
    name = 11.2;
  }

3. Dart 沒有 kotlin 這么變態(tài)的非 null 要求，聲明的變量初始值可以給 null

var name ;

4. var 的特性

var 聲明的變量，初始值要是 null 的話，后面給什么值都可以，但只要 var 的變量給初始值明確類型了，那么后面就只能是這個(gè)類型的數(shù)據(jù)了

  // 這樣 OK
  var name ;
  void test() {
    name = 11;
    name = "AA";
  }
  
  // 這樣報(bào)錯(cuò)
  var name = 10;
  void test() {
    name = 11;
    name = "AA";
  }

5. dynamic

dynamic 是不確定類型和var是一樣的，但是var是給開發(fā)人員用的，dynamic是Dart 內(nèi)部用的，我們也可以寫dynamic，但是一般有dynamic的地方都自動(dòng)隱藏了，dynamic這個(gè)關(guān)鍵字自動(dòng)提示是沒有的，就是說Dart不建議我們使用dynamic，我們知道dynamic什么意思就行了:dynamic修飾的變量，可以賦給任何類型的值

運(yùn)算符

常用的就不說了，說些有變化的

1. /

在java中取整，5/3=1；但是在Dart中就不是取整了，而是帶小數(shù)點(diǎn)了，5/3=1.6666...

2. ~/ -

在Dart中是取整的意思，5/3=1

3. ==

Dart 的==判斷的就不是引用一樣不一樣了，而是判斷的等號(hào)2邊內(nèi)容一樣不一樣

4. identical(name1, name2)

identical在Dart中才是判斷應(yīng)用一樣不一樣的

5. ??=

給null賦值，若這個(gè)參數(shù)==null，那么就=后面的這個(gè)數(shù)，當(dāng)然大家使用??也是可以的，??兩邊可以接表達(dá)式的

var name;
print(name ??= 10);
~~~~~~~~log~~~~~~~~~~~
I/flutter: 10

6. =>

單行時(shí)可以省略{}

Function test1 = (var name, var age) => print(name + age);

7. ..

進(jìn)行鏈?zhǔn)秸{(diào)用，非常簡(jiǎn)便

    var book = Book("AA", 12)
      ..name = "BB"
      ..age = 15;

8. ?.

null的話不報(bào)錯(cuò)

  var book = Book("AA", 12, "CC");
  book?.name = "BB";

9. is、is!、as

類型判斷，轉(zhuǎn)換類型，詳細(xì)不展開了，大家都知道

  if (book1 is Book) {
    book1.name = "AA";
  }

  (book2 as Book).name = "DD";

switch

Dart 中的 switch case 支持基本數(shù)據(jù)類型和對(duì)象類型，另外還可以給每個(gè) case 加上別名，用于指定跳轉(zhuǎn)到某個(gè) case 執(zhí)行代碼

    var name = "BB";
    switch (name) {
      as:
      case "AA":
        print("AA");
        break;
      case "BB":
        print("BB");
        continue as;
        break;
      case "CC":
        print("CC");
        break;
    }
    
~~~~~~~~~log~~~~~~~~~
I/flutter: BB
I/flutter: AA

比如上面我們給AA這個(gè)case加上as這個(gè)標(biāo)記之后，在BB中我們就可以使用continue這個(gè)關(guān)鍵字跳到AA這個(gè)case去執(zhí)行代碼，不管AA符不符合判斷，后會(huì)執(zhí)行AA這個(gè)case 的代碼

方法上的變化

1. Dart 中方法都是有返回值的，即便我們寫void其實(shí)也是返回的null，這點(diǎn)大家知道一下就行

2. 參數(shù)花樣

Dart 用{}表示可選參數(shù)，用[]表示位置參數(shù)，沒 python 好使

  // 可選參數(shù)，用 xx:xx 傳值
  void test1(var name1, {var name2 = 10, var name3 = 20}) {
    print("result = $name1,$name2,$name3");
  }
  
  // 位置參數(shù)，位置是固定的，你要是想給 name3賦值，必須先給name2賦值
  void test2(var name1, [var name2, var name3]) {
    print("result = $name1,$name2,$name3");
  }
  
  test1("AA", name2: 55);
  test2("BB",18,19);

3. 方法皆對(duì)象

Dart 秉承高級(jí)語(yǔ)言的特性，一切解釋對(duì)象，方法本身也不例外，熟悉 koltin、python 的朋友一定不會(huì)謀生

  void man(){
    print("man");
  }
  
  var f = man;
  f();

比如上面，我們可以聲明一個(gè)屬性對(duì)象，用別的方法賦值給該對(duì)象，然后加()的方式運(yùn)行該方法

4. 參數(shù)方法

我們來看下 Dart 中方法作為參數(shù)的使用

  // 聲明方法
  void textView(void click(var name)) => click("AA");
  // 使用方法
  textView((var name) => print(name));

5. 匿名方法

其實(shí)在上面4中就展示了匿名方法，這里再?gòu)?qiáng)調(diào)一下，Dart 中匿名方法語(yǔ)法：返回值 (參數(shù)類型 參數(shù)名，xxx){}，沒有返回值的可以不寫，實(shí)現(xiàn)單行可以用=>代替{}

舉個(gè)例子：

void textView(String click(var name)) => click("AA");
  
textView((var name) {
  print(name);
  return "AA";
});

6. 閉包

Dart 的閉包和 JS、python 一個(gè)意思，是定義在方法里面的方法，其特性：

• 閉包是一個(gè)對(duì)象
• 閉包定義在其他方法內(nèi)部
• 閉包可以訪問外部方法的布局變量，并持有其狀態(tài)。這是閉包的最大用途，通過閉包的方式把一個(gè)方法內(nèi)部的屬性暴露出去，因?yàn)榉椒ㄊ强梢苑祷胤椒ǖ?，Dart 中方法也是對(duì)象一樣可以當(dāng)做返回值處理

很多人說閉包學(xué)不會(huì)，看了很多資料還是不明白，其實(shí)吧這樣跟大家說：大家把閉包看成對(duì)象就行了

比如下面這個(gè)例子，我們拿到閉包，操作外層方法的數(shù)據(jù)不停的自增，我們對(duì)調(diào)用幾次閉包，大家會(huì)發(fā)現(xiàn)Z合格數(shù)據(jù)是不停增加的

// 閉包
sum(){
  var num = 0;
  sum2(){
    num++;
    print(num);
  }
  return sum2;
  
  // 也可以這么寫，匿名的方式用的最多
  return (){
    num++;
    print(num);
  };
}

// 多調(diào)用閉包幾次
void main(){
  Function a = sum();
  a();
  a();
  a();
  a();
  a();
  a();
}

~~~~~~~~~~log~~~~~~~~~~
1
2
3
4
5
6

結(jié)果是不會(huì)騙人的，大家就把閉包看成是一個(gè)包含外層數(shù)據(jù)的匿名實(shí)現(xiàn)類，當(dāng)成對(duì)象看就好理解了，這是最經(jīng)典的一個(gè)例子

面向?qū)ο笊系淖兓?/h3>

1. 可以省略 new

上文說過 Dart 創(chuàng)建對(duì)象可以省略new，很棒的設(shè)計(jì)，體驗(yàn)上像 python 極簡(jiǎn)主義靠攏

var book = Book("AA", 12);

2. Dart 默認(rèn)自帶get/set方法

3. Dart 中方法是不能重載的

image

4. Dart 沒有public，private

Dart 的可見范圍是以library庫(kù)為單位的，每一個(gè) Dart 文件就是一個(gè)庫(kù)，Dart 中_表示庫(kù)級(jí)別私有，_即可以修飾變量，也可以修飾對(duì)象，還可以修飾方法，這點(diǎn)又是和 python 一樣

// 這樣的對(duì)象，除了這個(gè)庫(kù)文件，哪也別想用，變量我就舉例了
class _Book {
  var name, age;

  _Book(this.name, this.age);

  speak(){

  }
}

5. 計(jì)算屬性

Dart 屬性默認(rèn)自動(dòng)生成get、set方法，但是大家也可以自己寫，但是自己寫的get、set就有區(qū)別了，看下面：

class RectTest {
  var width, height;

  RectTest(this.width, this.height);

  get area => width * height;

  set area(value) => width = value;
}

void main() {
  var rect = RectTest(20, 12);
  print(rect.area);
  rect.area = 30;
  print(rect.area);
  print(rect.width);
}

~~~~~~~~~~~~~log~~~~~~~~~~~~~~~
240
360
30

• 要自己寫get、set的話，該屬性就不能聲明，寫了get、set方法的話就當(dāng)是生命了一個(gè)變量，該變量set方法中不能給自己賦值(會(huì)陷入無限遞歸的狀態(tài))，只能給別的屬性賦值，大家看例子中的結(jié)果也能看出來，可以自己試下

6. 構(gòu)造方法

Dart 中構(gòu)造方法變化較大

• 6.1 首先 Dart 像 java 一樣提供一個(gè)默認(rèn)的空的構(gòu)造方法，但是一旦我們自己實(shí)現(xiàn)構(gòu)造方法的話，這個(gè)默認(rèn)的構(gòu)造方法就會(huì)失效，我們自己的寫的構(gòu)造方法會(huì)替代默認(rèn)的構(gòu)造方法，另外 Dart 也提供了便利的語(yǔ)法糖在里面

class Book {
  var name, age;
    
  // 標(biāo)準(zhǔn)寫法
  Book(var name, var age){
    this.name = name;
    this.age = age;
   }
  
  // 語(yǔ)法糖1
  Book(this.name, this.age){
   }
  
   // 語(yǔ)法糖2
   Book(this.name, this.age);
}

有一點(diǎn)要明確，這樣的構(gòu)造方法里，this的賦值是在構(gòu)造方法方法體之前執(zhí)行的

• 6.2 Dart 蛋疼的不支持重載，所以 Dart 提供了命名構(gòu)造方法，就是類名+方法名的方式實(shí)現(xiàn)多構(gòu)造方法

class Book {
  var name, age;

  Book(this.name, this.age);
  Book.withName(this.name);
  Book.withAge(this.age);
}

然后自動(dòng)提示就可以顯示有多個(gè)構(gòu)造方法了

image

• 6.3 常量構(gòu)造方法，若是有一個(gè)對(duì)象他的值都不需要變化的話我們就可以使用常量構(gòu)造函數(shù)構(gòu)造一個(gè)常量，這樣的話對(duì)象的值在編譯期就能知道，運(yùn)行速度上有優(yōu)勢(shì)，這個(gè)需要結(jié)合 const 使用，具體場(chǎng)景估計(jì)也就是枚舉了吧

// const 的對(duì)象要求屬性都是不可變的，也就是 final 的
class Book {
  final name, age;

  const Book(this.name, this.age);
}

void main() {
  const book = const Book(12,112);
}

• 6.4 工廠構(gòu)造方法，在普通構(gòu)造方法前加factory關(guān)鍵字，這個(gè)是配和私有構(gòu)造方法使用的，看下面的例子

class Book {
  var name, age;

  factory Book(var name){
    return Book._withName(name);
  }

  // 私有構(gòu)造方法
  Book._withName(this.name);

  Book._withAge(this.age);

}

• 6.5 給 final 賦值，final 描述的一般都是不可變的值，Dart 允許我們聲明 final 時(shí)給個(gè)null，但是在代碼運(yùn)行前必須初始化，這個(gè)地方就是構(gòu)造方法，方式有2種：

方式1：在構(gòu)造方法后面跟:給 final 賦值

class Book {
  var name, age;

  final title;

  Book(this.name, this.age, var title) : this.title = title {}

}

方式2：直接在構(gòu)造方法中賦值，利用this.xxx在方法體之前執(zhí)行的特性

class Book {
  var name, age;

  final title;

  Book(this.name, this.age, this.title);
}

• 6.6 對(duì)象call方法，高級(jí)語(yǔ)言中允許把方法當(dāng)做對(duì)象使用，Dart 中允許大家把對(duì)象當(dāng)方法使用book1()，本質(zhì)是調(diào)用book1里面的指定方法call

class Book {
  var name, age;

  final title;

  Book(this.name, this.age, this.title);

  call( var value ){
    print("$name同學(xué)請(qǐng)$value同學(xué)上臺(tái)演講");
  }
}

void main() {
  var book1 = Book("AA", 12, "CC");
  var book2 = Book("AA", 12, "CC");

  book1("PP");
}

~~~~~~~~~~~~~~~log~~~~~~~~~~~~~~~~~~
AA同學(xué)請(qǐng)PP同學(xué)上臺(tái)演講

其實(shí)什么++,--之類的都是運(yùn)用的這個(gè)思路，不過不推薦這個(gè)搞，這樣會(huì)模糊對(duì)象和方法的邊界，那代碼就不好閱讀理解了

7 繼承

Dart 是單繼承關(guān)系，子類不能繼承父類的私有(屬性、方法)和構(gòu)造函數(shù)

Dart 最蛋疼的是就是繼承關(guān)系中的構(gòu)造函數(shù)了，Dart 的子類默認(rèn)使用父類的默認(rèn)構(gòu)造函數(shù)，若是父類沒有默認(rèn)的構(gòu)造函數(shù)了，而是用戶自定義的，那么子類必須顯示的繼承父類的一個(gè)構(gòu)造函數(shù)，看下面的例子：

class Animal {
  var name, sex;

  Animal(this.name);

  Animal.withSex(this.sex);
}

class Dog extends Animal {
  Dog(name) : super(name);

  Dog.withSex(sex) : super.withSex(sex);
}

情況再?gòu)?fù)雜一點(diǎn)的是加上 final 賦值，中間用，相聯(lián)

class Dog extends Animal {
  final price;

  Dog.withSex(var sex, var price)
      : this.price = price,
        super.withSex(sex);
}

8. 多繼承

Dart 中多繼承專門有個(gè)詞：Mixins，Dart 允許我們使用with關(guān)鍵字實(shí)現(xiàn)多繼承，但是多繼承本身非常危險(xiǎn)，很容易出現(xiàn)各種問題的

標(biāo)準(zhǔn)寫法：

class Animal {
  var age, sex;
}

class Cat {
  var name;

  speak() {
    print("CAT");
  }
}

class Dog {
  var name;

  speak() {
    print("DOG");
  }
}

class Bear {
  var name;

  speak() {
    print("BEAR");
  }
}

class MyPet extends Animal with Dog, Cat, Bear {
  var n;

  MyPet(this.n);
}

然后我們調(diào)用下 pet.speak() 方法看看

  var pet = MyPet();
  pet.speak();
  
  ~~~~~~~~log~~~~~~~~
  BEAR

這說明對(duì)于多繼承來說，多個(gè)父類同名的屬性和方法是以最后一個(gè)繼承的父類的數(shù)據(jù)為準(zhǔn)

并且多繼承對(duì)父類要求很嚴(yán)格，要求父類不能有自己的構(gòu)造方法，默認(rèn)的除外...蛋疼不，并且多繼承很容易出問題的，使用時(shí)要格外注意

多繼承進(jìn)一步就是組合了，用于模塊間和架構(gòu)內(nèi)的功能組合，看下面的代碼，這塊我也沒有什么體驗(yàn)，也是道聽途說

class MyPet1 = Animal with Dog;
class MyPet2 = Animal with Cat;
class MyPet3 = Animal with Bear;

我有3種不同功能的寵物，注意這樣寫的話要求 MyPet1 這樣的子類不能有自己的屬性和方法，純粹是為了功能組合而存在，大家要清楚

9. 抽象類

Dart 的抽象類中的抽象方法不用寫abstract關(guān)鍵字，一般認(rèn)為 Dart 的抽象類更像是接口，一般都是當(dāng)接口用的

abstract class Cat{
  void speak();
}

10. 接口

Dart 的接口實(shí)在是怪，Dart 中其實(shí)是沒有接口這個(gè)概念的，在 Dart 里接口就是對(duì)象，我們用implements關(guān)鍵字可以直接繼承一個(gè)對(duì)象，但是該對(duì)象中的所有屬性和方法都需要我們重寫

class Animal {
  var name, sex;

  Animal(this.name);

  Animal.withSex(this.sex);
}

class Dog implements Animal {
  @override
  var name;

  @override
  var sex;
}

所以這里就體現(xiàn)出上面說的抽象類的重要性了，Dart 里我們一般把接口寫成抽象類

abstract class Cat{
  void speak();
}

class Dog implements Cat {
  @override
  void speak() {
    // TODO: implement speak
  }
}

11. Mixin 混入

Dart 的 implements 限制不小，比如你繼承一個(gè) dart 中的 接口，你必須重寫這個(gè)接口里面所有的屬性和方法，不管這個(gè)方法是不是抽象的

abstract class A {
  runA();

  speakA() {}
}

abstract class B {
  runB();
}

class AA implements A, B {
  @override
  runA() {
    // TODO: implement runA
    return null;
  }

  @override
  runB() {
    // TODO: implement runB
    return null;
  }

  @override
  speakA() {
    // TODO: implement speakA
    return null;
  }
}

這樣明顯限制太大，很多時(shí)候用著并不舒服，所以 Dart 提供一種新的接口類型：Mixin,你實(shí)現(xiàn) Mixin 類型的接口后，這樣你就可以像 java 那樣去實(shí)現(xiàn)接口了，注意實(shí)現(xiàn)接口時(shí)要用：with

mixin A {
  runA();

  speakA() {}
}

mixin B {
  runB();
}

class AA with A, B {
  @override
  runA() {
    // TODO: implement runA
    return null;
  }

  @override
  runB() {
    // TODO: implement runB
    return null;
  }
}

12. 重寫操作符

這是個(gè)騷操作，會(huì)讓我們的代碼看著非常高大上，什么是操作符：+,-,++,>這些就是，我們?cè)赾lass內(nèi)部使用operator關(guān)鍵字+操作符號(hào)就可以給我們的對(duì)象添加諸如+,-,++,>這樣的操作了

class Book{
  var price;
  var _name = "AA";

  Book(this.price);

  operator >( Book otherBook ){
    return this.price > otherBook.price;
  }

  operator [](String attribute){
    switch(attribute){
      case "price":{return price;}break;
      case "name":{return _name;}break;
      default: {return null;}
    }
  }
}

void main() {

  var book1 = Book(20);
  var book2 = Book(30);

  print( book1 > book2 );
  print( book1["price"] );
  print( book1["name"] );
}

book1["price"]這可以讓我們換個(gè)方式調(diào)用對(duì)象的屬性，裝逼用的，大家看上面的寫法就成，用這個(gè)方法可以在外面拿到對(duì)象的私有屬性

泛型

Dart 中的泛型和 JAVA 語(yǔ)法差不多

1. 類中使用泛型

class Location {
  Object x;
  Object y;

  Location(this.x, this.y);
}

2. 方法中使用泛型

class Location<T> {
  T x;
  T y;

  Location(this.x, this.y);
}

3. 集合中使用泛型

• 3.1 list

// 不使用泛型限制數(shù)據(jù)類型
var names = ['aa', 'bb', 'cc', 111];

// 使用泛型之后
var names = <String>['aa', 'bb', 'cc'];

• 3.2 map

// 不使用泛型限制數(shù)據(jù)類型
var infos = {1: 'one', 'name': 'why', 'age': 18}; 

// 使用泛型之后
Map<String, String> infos = {'name': 'why', 'age': '18'};

庫(kù)的導(dǎo)入

前面簡(jiǎn)單的說了下導(dǎo)庫(kù)，這里咱們?cè)敿?xì)來說說

1. Dart 導(dǎo)庫(kù)的3種方式：

• Dart 標(biāo)準(zhǔn)庫(kù) - 這里庫(kù)都是 Dart 內(nèi)部自帶的，比如：dart:io、dart:html、dart:math

import 'dart:io';

• Pub 包管理器 - 使用前綴：package:，像 Flutter 提供的包就是用 Pub 管理器導(dǎo)入

import 'package:flutter/material.dart';

• 指定路徑 - 可以是相對(duì)路徑或絕對(duì)路徑

import 'lib/student/student.dart';

2. show、hide、as 關(guān)鍵字

• show - 只導(dǎo)入指定的文件
• hide - 隱藏指定文件，其他都導(dǎo)入
• as - 起別名

import 'lib/student/student.dart' show Student, Person;
import 'lib/student/student.dart' hide Person;
import 'lib/student/student.dart' as Stu;

// 使用的使用要加上別名
Stu.Student s = new Stu.Student();

這點(diǎn)其實(shí)和 python 是一模一樣的

3. library、part 定義庫(kù)

我們可以用 library 給庫(kù)起個(gè)名字，沒名字的庫(kù)你也沒法用不是，然后當(dāng)庫(kù)很大時(shí)，一個(gè)文件裝不下時(shí) part 就起作用了， 使用 part 可以把子文件關(guān)聯(lián)進(jìn)庫(kù)主文件中，庫(kù)打包的時(shí)候一起都打進(jìn)去，不會(huì)造成文件缺失

使用思路：

• 子文件使用 part of "庫(kù)名" 的方式關(guān)聯(lián)庫(kù)主文件
• 庫(kù)主文件使用 子文件名.dart 的方式把子文件綁定進(jìn)庫(kù)里

主文件 AB.dart

library AB
part "mathUtils.dart";
part "dateUtils.dart";

子文件 mathUtils.dart

part of "AB.dart";

int sum(int num1, int num2) {
  return num1 + num2;
}

恩，有些麻煩，需要子文件和主文件都相互聲明，有點(diǎn)繞，初上手會(huì)很困惑的，好在一切不合理的都會(huì)被消滅，這東西現(xiàn)在過時(shí)啦

4. export 定義庫(kù)

export 就是用來代替 path 的，在 export 的時(shí)代，我們只需要在庫(kù)主文件聲明一下需要的子文件就行啦，不用再折騰子文件了

主文件 AB.dart

library AB;

export "mathUtils.dart";
export "dateUtils.dart";

子文件 mathUtils.dart

int sum(int num1, int num2) {
  return num1 + num2;
}