Flutter 之 Dart（二）

一. 運算符

這裡，我只列出來相對其他語言比較特殊的運算符，因為某些運算符太簡單了，不浪費時間，比如+、-、+=、==。

你可能會疑惑，Dart為什麼要搞出這麼多特殊的運算符呢？

你要堅信一點：所有這些特殊的運算符都是為了讓我們在開發中可以更加方便的操作，而不是讓我們的編碼變得更加複雜。

1.1. 除法、整除、取模運算

我們來看一下除法、整除、取模運算

<code>var num = 7;
print(num / 3); // 除法操作, 結果2.3333..
print(num ~/ 3); // 整除操作, 結果2;
print(num % 3); // 取模操作, 結果1;/<code>

1.2. ??=賦值操作

dart有一個很多語言都不具備的賦值運算符：

• 當變量為null時，使用後面的內容進行賦值。
• 當變量有值時，使用自己原來的值。

<code>main(List<string> args) {
  var name1 = 'coderwhy';
  print(name1);
  // var name2 = 'kobe';
  var name2 = null;
  name2 ??= 'james'; 
  print(name2); // 當name2初始化為kobe時，結果為kobe，當初始化為null時，賦值了james
}/<string>/<code>

1.3. 條件運算符：

Dart中包含一直比較特殊的條件運算符：expr1 ?? expr2

• 如果expr1是null，則返回expr2的結果;
• 如果expr1不是null，直接使用expr1的結果。

<code>var temp = 'why';
var temp = null;
var name = temp ?? 'kobe';
print(name);/<code>

1.4. 級聯語法：..

• 某些時候，我們希望對一個對象進行連續的操作，這個時候可以使用級聯語法

<code>class Person {
  String name;

  void run() {
    print("${name} is running");
  }

  void eat() {
    print("${name} is eating");
  }

  void swim() {
    print("${name} is swimming");
  }
}

main(List<string> args) {
  final p1 = Person();
  p1.name = 'why';
  p1.run();
  p1.eat();
  p1.swim();

  final p2 = Person()
              ..name = "why"
              ..run()
              ..eat() 

              ..swim();
}/<string>/<code>

二. 流程控制

和大部分語言的特性比較相似，這裡就不再詳細贅述，看一下即可。

2.1. if和else

和其他語言用法一樣

這裡有一個注意點：不支持非空即真或者非0即真，必須有明確的bool類型

• 我們來看下面name為null的判斷

2.2. 循環操作

基本的for循環

<code>\tfor (var i = 0; i < 5; i++) {
      print(i);
    }/<code>

for in遍歷List和Set類型

<code>var names = ['why', 'kobe', 'curry'];
for (var name in names) {
  print(name);
}/<code>

while和do-while和其他語言一致

break和continue用法也是一致

2.3. switch-case

普通的switch使用

• 注意：每一個case語句，默認情況下必須以一個break結尾

<code>main(List<string> args) {
  var direction = 'east';
  switch (direction) {
    case 'east':
      print('東面');
      break;
    case 'south':
      print('南面');
      break;
    case 'west':
      print('西面');
      break;
    case 'north':
      print('北面');
      break; 

    default:
      print('其他方向');
  }
}/<string>/<code>

三. 類和對象

Dart是一個面向對象的語言，面向對象中非常重要的概念就是類，類產生了對象。

這一節，我們就具體來學習類和對象，但是Dart對類進行了很多其他語言沒有的特性，所以，這裡我會花比較長的篇幅來講解。

3.1. 類的定義

在Dart中，定義類用class關鍵字。

類通常有兩部分組成：成員（member）和方法（method）。

定義類的偽代碼如下：

<code>class 類名 {
  類型 成員名;
  返回值類型 方法名(參數列表) {
    方法體
  }
}/<code>

編寫一個簡單的Person類：

• 這裡有一個注意點: 我們在方法中使用屬性(成員/實例變量)時，並沒有加this；
• Dart的開發風格中，在方法中通常使用屬性時，會省略this，但是在命名衝突時，this不能省略；

<code>\tclass Person {
        String name;

        eat() {
          print('$name在吃東西');
        }
      }/<code>

我們來使用這個類，創建對應的對象：

• 注意：從Dart2開始，new關鍵字可以省略。

<code>main(List<string> args) {
  // 1.創建類的對象
  var p = new Person(); // 直接使用Person()也可以創建

  // 2.給對象的屬性賦值
  p.name = 'why';

  // 3.調用對象的方法
  p.eat();
}/<string>/<code>

3.2. 構造方法

3.2.1. 普通構造方法

我們知道, 當通過類創建一個對象時，會調用這個類的構造方法。

• 當類中沒有明確指定構造方法時，將默認擁有一個無參的構造方法。
• 前面的Person中我們就是在調用這個構造方法.

我們也可以根據自己的需求，定義自己的構造方法:

• **注意一：**當有了自己的構造方法時，默認的構造方法將會失效，不能使用
• 當然，你可能希望明確的寫一個默認的構造方法，但是會和我們自定義的構造方法衝突；
• 這是因為Dart本身不支持函數的重載（名稱相同, 參數不同的方式）。
• **注意二：**這裡我還實現了toString方法

<code>class Person {
  String name;
  int age;

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

  @override
  String toString() {
    return 'name=$name age=$age';
  } 

}/<code>

另外，在實現構造方法時，通常做的事情就是通過**參數給屬性**賦值

為了簡化這一過程, Dart提供了一種更加簡潔的語法糖形式.

上面的構造方法可以優化成下面的寫法：

<code>Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  // 等同於
  Person(this.name, this.age);/<code>

3.2.2. 命名構造方法

但是在開發中, 我們確實希望實現更多的構造方法，怎麼辦呢？

• 因為不支持方法（函數）的重載，所以我們沒辦法創建相同名稱的構造方法。

我們需要使用命名構造方法:

<code>class Person {
  String name;
  int age;

  Person() {
    name = ''; 

    age = 0;
  }
\t// 命名構造方法
  Person.withArgments(String name, int age) {
    this.name = name;
    this.age = age;
  }

  @override
  String toString() {
    return 'name=$name age=$age';
  }
}

// 創建對象
var p1 = new Person();
print(p1);
var p2 = new Person.withArgments('why', 18);
print(p2);/<code>

在之後的開發中, 我們也可以利用命名構造方法，提供更加便捷的創建對象方式:

• 比如開發中，我們需要經常將一個Map轉成對象，可以提供如下的構造方法

<code>// 新的構造方法
\tPerson.fromMap(Map<string> map) {
    this.name = map['name'];
    this.age = map['age'];
  }

\t// 通過上面的構造方法創建對象
  var p3 = new Person.fromMap({'name': 'kobe', 'age': 30});
  print(p3);/<string>/<code>

3.2.3. 初始化列表

我們來重新定義一個類Point, 傳入x/y，可以得到它們的距離distance:

<code>
class Point {
  final num x;
  final num y;
  final num distance;

  // 錯誤寫法
  // Point(this.x, this.y) {
  //   distance = sqrt(x * x + y * y);
  // }

  // 正確的寫法
  Point(this.x, this.y) : distance = sqrt(x * x + y * y);
}/<code>

上面這種初始化變量的方法, 我們稱之為初始化列表(Initializer list)

3.2.4. 重定向構造方法

在某些情況下, 我們希望在一個構造方法中去調用另外一個構造方法, 這個時候可以使用重定向構造方法：

• 在一個構造函數中，去調用另外一個構造函數（注意：是在冒號後面使用this調用）

<code>class Person {
  String name;
  int age;

  Person(this.name, this.age);
  Person.fromName(String name) : this(name, 0);
}/<code>

3.2.5. 常量構造方法

在某些情況下，傳入相同值時，我們希望返回同一個對象，這個時候，可以使用常量構造方法.

默認情況下，創建對象時，即使傳入相同的參數，創建出來的也不是同一個對象，看下面代碼:

• 這裡我們使用identical(對象1, 對象2)函數來判斷兩個對象是否是同一個對象:

<code>main(List<string> args) {
  var p1 = Person('why');
  var p2 = Person('why');
  print(identical(p1, p2)); // false
}

class Person {
  String name;

  Person(this.name);
}/<string>/<code>

但是, 如果將構造方法前加const進行修飾，那麼可以保證同一個參數，創建出來的對象是相同的

• 這樣的構造方法就稱之為 常量構造方法。

<code>main(List<string> args) {
  var p1 = const Person('why');
  var p2 = const Person('why');
  print(identical(p1, p2)); // true
} 


class Person {
  final String name;

  const Person(this.name);
}/<string>/<code>

常量構造方法有一些注意點:

• 注意一：擁有常量構造方法的類中，所有的成員變量必須是final修飾的.
• 注意二: 為了可以通過常量構造方法，創建出相同的對象，不再使用 new關鍵字，而是使用const關鍵字
• 如果是將結果賦值給const修飾的標識符時，const可以省略.

3.2.6. 工廠構造方法

Dart提供了factory關鍵字, 用於通過工廠去獲取對象

<code>main(List<string> args) {
  var p1 = Person('why');
  var p2 = Person('why');
  print(identical(p1, p2)); // true
}

class Person {
  String name;
 

  static final Map<string> _cache = <string>{};

  factory Person(String name) {
    if (_cache.containsKey(name)) {
      return _cache[name];
    } else {
      final p = Person._internal(name);
      _cache[name] = p;
      return p;
    }
  }

  Person._internal(this.name);
}/<string>/<string>/<string>/<code>

3.3. setter和getter

默認情況下，Dart中類定義的屬性是可以直接被外界訪問的。

但是某些情況下，我們希望監控這個類的屬性被訪問的過程，這個時候就可以使用setter和getter了

<code>main(List<string> args) {
  final d = Dog("黃色");
  d.setColor = "黑色";
  print(d.getColor);
}

class Dog {
  String color;

  String get getColor {
    return color;
  }
  set setColor(String color) {
    this.color = color;
  }

  Dog(this.color);
}/<string>/<code>

3.4. 類的繼承

面向對象的其中一大特性就是繼承，繼承不僅僅可以減少我們的代碼量，也是多態的使用前提。

Dart中的繼承使用extends關鍵字，子類中使用super來訪問父類。

父類中的所有成員變量和方法都會被繼承,，但是構造方法除外。

<code>main(List<string> args) {
  var p = new Person();
  p.age = 18;
  p.run();
  print(p.age);
}

class Animal {
  int age;

  run() {
    print('在奔跑ing');
  }
}

class Person extends Animal {

}/<string>/<code>

子類可以 擁有自己的成員變量, 並且可以 對父類的方法進行重寫：

<code>class Person extends Animal {
  String name;

  @override
  run() {
    print('$name在奔跑ing');
  } 

}/<code>

子類中可以調用父類的構造方法，對某些屬性進行初始化：

• 子類的構造方法在執行前，將隱含調用父類的無參默認構造方法（沒有參數且與類同名的構造方法）。
• 如果父類沒有無參默認構造方法，則子類的構造方法必須在初始化列表中通過super顯式調用父類的某個構造方法。

<code>class Animal {
  int age;

  Animal(this.age);

  run() {
    print('在奔跑ing');
  }
}

class Person extends Animal {
  String name;

  Person(String name, int age) : name=name, super(age);

  @override
  run() {
    print('$name在奔跑ing');
  }

  @override
  String toString() { 

    return 'name=$name, age=$age';
  }
}/<code>

3.5. 抽象類

我們知道，繼承是多態使用的前提。

所以在定義很多通用的**調用接口**時, 我們通常會讓調用者傳入父類，通過多態來實現更加靈活的調用方式。

但是，父類本身可能並不需要對某些方法進行具體的實現，所以父類中定義的方法,，我們可以定義為抽象方法。

什麼是 抽象方法? 在Dart中沒有具體實現的方法(沒有方法體)，就是抽象方法。

• 抽象方法，必須存在於抽象類中。
• 抽象類是使用abstract聲明的類。

下面的代碼中, Shape類就是一個抽象類, 其中包含一個抽象方法.

<code>abstract class Shape { 

  getArea();
}

class Circle extends Shape {
  double r;

  Circle(this.r);

  @override
  getArea() {
    return r * r * 3.14;
  }
}

class Reactangle extends Shape {
  double w;
  double h;

  Reactangle(this.w, this.h);

  @override
  getArea() {
    return w * h;
  }
}/<code>

注意事項:

• **注意一：**抽象類不能實例化.
• **注意二：**抽象類中的抽象方法必須被子類實現, 抽象類中的已經被實現方法, 可以不被子類重寫.

3.6. 隱式接口

Dart中的接口比較特殊, 沒有一個專門的關鍵字來聲明接口.

默認情況下，定義的每個類都相當於默認也聲明瞭一個接口，可以由其他的類來實現(因為Dart不支持多繼承)

在開發中，我們通常將用於給別人實現的類聲明為抽象類:

<code>abstract class Runner {
  run();
}

abstract class Flyer {
  fly();
}

class SuperMan implements Runner, Flyer {
  @override
  run() {
    print('超人在奔跑');
  }

  @override
  fly() {
    print('超人在飛');
  }
}/<code>

3.7. Mixin混入

在通過implements實現某個類時，類中所有的方法都必須 被重新實現(無論這個類原來是否已經實現過該方法)。

但是某些情況下，一個類可能希望直接複用之前類的原有實現方案，怎麼做呢?

• 使用繼承嗎？但是Dart只支持單繼承，那麼意味著你只能複用一個類的實現。

Dart提供了另外一種方案:

• 除了可以通過class定義類之外，也可以通過mixin關鍵字來定義一個類。
• 只是通過mixin定義的類用於被其他類混入使用，通過with關鍵字來進行混入。

<code>main(List<string> args) {
  var superMan = SuperMain();
  superMan.run();
  superMan.fly();
}

mixin Runner {
  run() {
    print('在奔跑');
  }
}

mixin Flyer {
  fly() {
    print('在飛翔');
  }
}

// implements的方式要求必須對其中的方法進行重新實現
// class SuperMan implements Runner, Flyer {}

class SuperMain with Runner, Flyer {

}/<string>/<code>

3.8. 類成員和方法

前面我們在類中定義的成員和方法都屬於對象級別的, 在開發中, 我們有時候也需要定義類級別的成員和方法

在Dart中我們使用static關鍵字來定義:

<code>main(List<string> args) {
  var stu = Student();
  stu.name = 'why';
  stu.sno = 110;
  stu.study();

  Student.time = '早上8點';
  // stu.time = '早上9點'; 錯誤做法, 實例對象不能訪問類成員  
 ‍‍‍Student.attendClass();  // stu.attendClass(); 錯誤做法, 實現對象不能‍訪問類方法
}

class Student {
  String name;
  int sno;

  static String time;

  study() {
    print('$name在學習');
  }

  static attendClass() {
    print('去上課');
  }
}/<string>/<code>

3.9. 枚舉類型

枚舉在開發中也非常常見, 枚舉也是一種特殊的類, 通常用於表示固定數量的常量值。

3.9.1. 枚舉的定義

枚舉使用enum關鍵字來進行定義:

<code>main(List<string> args) {
  print(Colors.red);
}

enum Colors {
  red,
  green,
  blue
}/<string>/<code>

3.9.2. 枚舉的屬性

枚舉類型中有兩個比較常見的屬性:

• index: 用於表示每個枚舉常量的索引, 從0開始.
• values: 包含每個枚舉值的List.

<code>main(List<string> args) {
  print(Colors.red.index);
  print(Colors.green.index);
  print(Colors.blue.index);

  print(Colors.values);
}

enum Colors {
  red,
  green,
  blue
}/<string>/<code>

枚舉類型的注意事項:

• 注意一: 您不能子類化、混合或實現枚舉。
• 注意二: 不能顯式實例化一個枚舉

四. 泛型

4.1. 為什麼使用泛型?

對於有基礎的同學, 這部分不再解釋

4.2. List和Map的泛型

List使用時的泛型寫法:

<code> // 創建List的方式
  var names1 = ['why', 'kobe', 'james', 111];
  print(names1.runtimeType); // List<object>

  // 限制類型
  var names2 = <string>['why', 'kobe', 'james', 111]; // 最後一個報錯
  List<string> names3 = ['why', 'kobe', 'james', 111]; // 最後一個報錯/<string>/<string>/<object>/<code>

Map使用時的泛型寫法:

<code>// 創建Map的方式
  var infos1 = {1: 'one', 'name': 'why', 'age': 18}; 
  print(infos1.runtimeType); // _InternalLinkedHashMap<object>

  // 對類型進行顯示
  Map<string> infos2 = {'name': 'why', 'age': 18}; // 18不能放在value中
  var infos3 = <string>{'name': 'why', 'age': 18}; // 18不能放在value中/<string>/<string>/<object>/<code>

4.3. 類定義的泛型

如果我們需要定義一個類, 用於存儲位置信息Location, 但是並不確定使用者希望使用的是int類型,還是double類型, 甚至是一個字符串, 這個時候如何定義呢?

• 一種方案是使用Object類型, 但是在之後使用時, 非常不方便
• 另一種方案就是使用泛型.

Location類的定義: Object方式

<code>main(List<string> args) {
  Location l1 = Location(10, 20);
  print(l1.x.runtimeType); // Object
}

class Location {
  Object x;
  Object y;

  Location(this.x, this.y);
}/<string>/<code>

Location類的定義: 泛型方式

<code>main(List<string> args) {
  Location l2 = Location(10, 20);
  print(l2.x.runtimeType); // int 

  Location l3 = Location<string>('aaa', 'bbb');
  print(l3.x.runtimeType); // String
}
}

class Location {
  T x;
  T y;

  Location(this.x, this.y);
}/<string>/<string>/<code>

如果我們希望類型只能是num類型, 怎麼做呢?

<code>main(List<string> args) {
  Location l2 = Location(10, 20);
  print(l2.x.runtimeType); 

\t
  // 錯誤的寫法, 類型必須繼承自num
  Location l3 = Location<string>('aaa', 'bbb');
  print(l3.x.runtimeType);
}

class Location {
  T x;
  T y;

  Location(this.x, this.y);
}/<string>/<string>/<code>

4.4. 泛型方法的定義

最初，Dart僅僅在類中支持泛型。後來一種稱為泛型方法的新語法允許在方法和函數中使用類型參數。

<code>main(List<string> args) {
  var names = ['why', 'kobe'];
  var first = getFirst(names);
  print('$first ${first.runtimeType}'); // why String
}

T getFirst(List ts) {
  return ts[0];
}/<string>/<code>

五. 庫的使用

在Dart中，你可以導入一個庫來使用它所提供的功能。

庫的使用可以使代碼的重用性得到提高，並且可以更好的組合代碼。

Dart中任何一個dart文件都是一個庫，即使你沒有用關鍵字library聲明

5.1. 庫的導入

import語句用來導入一個庫，後面跟一個字符串形式的Uri來指定表示要引用的庫，語法如下：

<code>import '庫所在的uri';/<code>

常見的庫URI有三種不同的形式

• 來自dart標準版，比如dart:io、dart:html、dart:math、dart:core(但是這個可以省略)

<code>//dart:前綴表示Dart的標準庫，如dart:io、dart:html、dart:math
import 'dart:io';/<code>

使用相對路徑導入的庫，通常指自己項目中定義的其他dart文件

<code>//當然，你也可以用相對路徑或絕對路徑的dart文件來引用
import 'lib/student/student.dart';/<code>

Pub包管理工具管理的一些庫，包括自己的配置以及一些第三方的庫，通常使用前綴package

<code>//Pub包管理系統中有很多功能強大、實用的庫，可以使用前綴 package: 

import 'package:flutter/material.dart';/<code>

庫文件中內容的顯示和隱藏

如果希望只導入庫中某些內容，或者刻意隱藏庫裡面某些內容，可以使用show和hide關鍵字

• **show關鍵字：**可以顯示某個成員（屏蔽其他）
• **hide關鍵字：**可以隱藏某個成員（顯示其他）

<code>import 'lib/student/student.dart' show Student, Person;

import 'lib/student/student.dart' hide Person;/<code>

庫中內容和當前文件中的名字衝突

當各個庫有命名衝突的時候，可以使用as關鍵字來使用命名空間

<code>import 'lib/student/student.dart' as Stu;

Stu.Student s = new Stu.Student();/<code>

5.2. 庫的定義

library關鍵字

通常在定義庫時，我們可以使用library關鍵字給庫起一個名字。

但目前我發現，庫的名字並不影響導入，因為import語句用的是字符串URI

<code>library math;/<code>

part關鍵字

在之前我們使用student.dart作為演練的時候，只是將該文件作為一個庫。

在開發中，如果一個庫文件太大，將所有內容保存到一個文件夾是不太合理的，我們有可能希望將這個庫進行拆分，這個時候就可以使用part關鍵字了

不過官方已經不建議使用這種方式了：

• https://dart.dev/guides/libraries/create-library-packages

mathUtils.dart文件

<code>part of "utils.dart";

int sum(int num1, int num2) {
  return num1 + num2;
}/<code>

dateUtils.dart文件

<code>part of "utils.dart";

String dateFormat(DateTime date) {
  return "2020-12-12";
}/<code>

utils.dart文件

<code>part "mathUtils.dart";
part "dateUtils.dart";/<code>

test_libary.dart文件

<code>import "lib/utils.dart";

main(List<string> args) {
  print(sum(10, 20));
  print(dateFormat(DateTime.now()));
}/<string>/<code>

export關鍵字

官方不推薦使用part關鍵字，那如果庫非常大，如何進行管理呢？

• 將每一個dart文件作為庫文件，使用export關鍵字在某個庫文件中單獨導入

mathUtils.dart文件

<code>int sum(int num1, int num2) {
  return num1 + num2;
}/<code>

dateUtils.dart文件

<code>String dateFormat(DateTime date) {
  return "2020-12-12";
}/<code>

utils.dart文件

<code>library utils;

export "mathUtils.dart";
export "dateUtils.dart";/<code>

test_libary.dart文件

<code>import "lib/utils.dart";

main(List<string> args) {
  print(sum(10, 20));
  print(dateFormat(DateTime.now()));
}/<string>/<code>

最後，也可以通過Pub管理自己的庫自己的庫，在項目開發中個人覺得不是非常有必要，所以暫時不講解這種方式。

原文出處：https://mp.weixin.qq.com/s/xdSYvqSYOXTOCeb89C1uvg（侵權刪除）

閱讀更多 凌雲壯志549 的文章

關鍵字: 自己 暫時 講解