一、抽象類的使用
Dart 抽象類可以只宣告方法，也可以有具體的方法實現，但是不能直接用抽象類來建立例項，只能被繼承使用或者充當介面。
定義一個抽象類 Animal
abstract class Animal {
// 僅宣告eat方法
void eat();
// 宣告方法，且有具體實現
void sleep() {
print("睡覺");
}
}
複製程式碼繼承使用
class Cat extends Animal {
@override
void eat() {
print("喵喵吃");
sleep();
}
// 可以不實現 sleep 方法
}
複製程式碼充當介面
class Cat implements Animal {
void eat() {
print("吃");
}
// 必須實現 sleep 方法
void sleep() {
print('睡');
}
}
複製程式碼例項化
final animal = Animal();
// 抽象類例項化會報錯
// Error: The class 'Test' is abstract and can't be instantiated.
複製程式碼
- 抽象類不能例項化。
- 繼承: 子類比較實現抽象方法，子類可以不重寫抽象類中已實現的方法。
- 介面: 必須實現抽象類中宣告的所有方法
二、抽象類的例項化
上面提到了抽象類不能用於建立例項，但是有沒有發現，Dart 提供的 Map 和 List 就是抽象類，卻可以直接使用它們建立出一個例項物件
final list = List();
final dict = Map<String, dynamic>();
複製程式碼我們來看一下 Map 的原始碼：
Map 的確是抽象類，不過此時我們也注意到了，在 Map 這個抽象類中，定義了一個工廠構造方法，這就是使抽象類可例項化的關鍵所在，因為工廠方法可以返回一個例項物件，但這個物件的型別不一定就是當前類!
在這個地方，Map 的工廠方法並沒有具體的實現，而只是在工廠構造方法前加了一個關鍵字 external。
external 關鍵字可以讓方法的宣告與實現分離，即 可以由外部來幫我們完成具體的方法實現，那外部如何才能關聯到該宣告的方法呢？這裡就需要用到註解 @patch，使外部的方法實現與該宣告的方法繫結
external可以分離方法的宣告與實現@patch關聯某個類中用external修飾的方法的實現
根據如下路徑可以找到 Map 的具體實現原始碼
// flutter/bin/cache/dart-sdk/lib/_internal/vm/lib/map_patch.dart
@patch
factory Map() => new LinkedHashMap<K, V>();
複製程式碼可以看到，這裡使用了 LinkedHashMap 來實現 Map 。
我們再去看一下 LinkedHashMap 的實現原始碼，路徑如下：
// flutter/bin/cache/dart-sdk/lib/collection/linked_hash_map.dart
external factory LinkedHashMap(
{bool Function(K, K)? equals,
int Function(K)? hashCode,
bool Function(dynamic)? isValidKey});
複製程式碼這裡我們又發現 LinkedHashMap 也僅僅只是宣告，找到具體實現
// flutter/bin/cache/dart-sdk/lib/_internal/vm/lib/collection_patch.dart
@patch
class LinkedHashMap<K, V> {
@patch
factory LinkedHashMap(
{bool equals(K key1, K key2)?,
int hashCode(K key)?,
bool isValidKey(potentialKey)?}) {
if (isValidKey == null) {
if (hashCode == null) {
if (equals == null) {
return new _InternalLinkedHashMap<K, V>();
}
hashCode = _defaultHashCode;
} else {
if (identical(identityHashCode, hashCode) &&
identical(identical, equals)) {
return new _CompactLinkedIdentityHashMap<K, V>();
}
equals ??= _defaultEquals;
}
} else {
hashCode ??= _defaultHashCode;
equals ??= _defaultEquals;
}
return new _CompactLinkedCustomHashMap<K, V>(equals, hashCode, isValidKey);
}
...
}
複製程式碼可以看到，LinkedHashMap的工廠構造方法返回的例項型別是 _InternalLinkedHashMap 或 _CompactLinkedCustomHashMap ，這裡我們再看一下這兩個類的實現原始碼
// flutter/bin/cache/dart-sdk/lib/_internal/vm/lib/compact_hash.dart
@pragma("vm:entry-point")
class _InternalLinkedHashMap<K, V> extends _HashVMBase
with
MapMixin<K, V>,
_LinkedHashMapMixin<K, V>,
_HashBase,
_OperatorEqualsAndHashCode
implements LinkedHashMap<K, V> {
_InternalLinkedHashMap() {
_index = new Uint32List(_HashBase._INITIAL_INDEX_SIZE);
_hashMask = _HashBase._indexSizeToHashMask(_HashBase._INITIAL_INDEX_SIZE);
_data = new List.filled(_HashBase._INITIAL_INDEX_SIZE, null);
_usedData = 0;
_deletedKeys = 0;
}
}
......
class _CompactLinkedIdentityHashMap<K, V> extends _HashFieldBase
with
MapMixin<K, V>,
_LinkedHashMapMixin<K, V>,
_HashBase,
_IdenticalAndIdentityHashCode
implements LinkedHashMap<K, V> {
_CompactLinkedIdentityHashMap() : super(_HashBase._INITIAL_INDEX_SIZE);
}
class _CompactLinkedCustomHashMap<K, V> extends _HashFieldBase
with MapMixin<K, V>, _LinkedHashMapMixin<K, V>, _HashBase
implements LinkedHashMap<K, V> {
final _equality;
final _hasher;
final _validKey;
// TODO(koda): Ask gbracha why I cannot have fields _equals/_hashCode.
int _hashCode(e) => _hasher(e);
bool _equals(e1, e2) => _equality(e1, e2);
bool containsKey(Object? o) => _validKey(o) ? super.containsKey(o) : false;
V? operator [](Object? o) => _validKey(o) ? super[o] : null;
V? remove(Object? o) => _validKey(o) ? super.remove(o) : null;
_CompactLinkedCustomHashMap(this._equality, this._hasher, validKey)
: _validKey = (validKey != null) ? validKey : new _TypeTest<K>().test,
super(_HashBase._INITIAL_INDEX_SIZE);
}
複製程式碼它們都是一個普通的類，沒有工廠構造方法，也就是說 Map 中的 external factory Map(); 最終返回的最終例項型別為 _InternalLinkedHashMap 或 _CompactLinkedCustomHashMap
我們可以做一個簡單的驗證
final map = Map();
print(map.runtimeType);
// 列印結果
// _InternalLinkedHashMap<dynamic, dynamic>
複製程式碼我們來試著例項化一個抽象類吧
abstract class Animal {
void eat();
void sleep() {
print("睡覺");
}
factory Animal() {
return Cat();
}
}
class Cat implements Animal {
void eat() {
print("吃");
}
void sleep() {
print('睡');
}
}
複製程式碼final animal = Animal();
print(animal.runtimeType);
// 列印結果: Cat
複製程式碼可能會有同學要問了，這裡用的是介面的方式，可以用繼承的方式嗎？ 很遺憾不行，因為在抽象類中定義了工廠構造方法後，在子類中不能定義除工廠構造方法外的其它構造方法了，會報錯~
總結一下：
抽象類無法直接建立例項，但是可以通過實現工廠構造方法來間接實現抽象類的例項化！
三、補充
那饒了這麼一大圈，為什麼不直接在宣告的時候就給它實現了呢？? 這樣做的好處就是：
- 複用同一套API的宣告
- 可以針對不同的平臺做不同的實現
而 針對不同的平臺做不同的實現 這一點在下方給出的原始碼中可以看出
// flutter/bin/cache/dart-sdk/lib/io/file_system_entity.dart
abstract class _FileSystemWatcher {
external static Stream<FileSystemEvent> _watch(
String path, int events, bool recursive);
external static bool get isSupported;
}
複製程式碼// flutter/bin/cache/dart-sdk/lib/_internal/vm/bin/file_patch.dart
@patch
static Stream<FileSystemEvent> _watch(
String path, int events, bool recursive) {
if (Platform.isLinux) {
return new _InotifyFileSystemWatcher(path, events, recursive)._stream;
}
if (Platform.isWindows) {
return new _Win32FileSystemWatcher(path, events, recursive)._stream;
}
if (Platform.isMacOS) {
return new _FSEventStreamFileSystemWatcher(path, events, recursive)
._stream;
}
throw new FileSystemException(
"File system watching is not supported on this platform");
}
複製程式碼