本文主要是介绍Flutter基础 -- Dart 语言 -- 类抽象接口继承函数库，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
目录
1. 类 class
1.1 定义、使用类
1.2 构造函数
1.3 初始化列表
1.4 命名构造函数
1.5 重定向构造函数
1.6 callable
2. 类 get set
2.1 定义、使用 get set
2.2 简化 get set
2.3 业务场景
3. 静态 static
3.1 static 定义
3.2 函数内部访问
3.3 静态方法
3.4 PS
4. 抽象 abstract
4.1 abstract 类、函数、成员
4.2 不能直接 new 实例化
4.3 继承方式使用
4.3.1 extends 继承关键字
4.3.2 super
4.4 接口方式使用
5. 接口 interface
5.1 implements
5.2 接口方式使用
5.3 履行多接口
5.4 从一个普通类履行接口
6. 继承 extends
6.1 实现继承
6.2 父类调用
6.3 调用父类构造
6.4 重写超类函数
6.4.1 noSuchMethod 方法
6.4.2 Invocation 参数
6.5 继承抽象类的问题
7. 工厂函数 factory
7.1 调用子类
7.2 单例模式
7.2.1 解释 static final Phone _single = Phone._internal();
7.2.2 解释 私有构造函数Phone._internal();
7.2.3 工厂构造函数 factory Phone()
7.3 减少重复实例对象
8. 多继承 with
8.1 正常
8.2 函数重名冲突
8.3 mixin 不能构造函数
8.4 mixin on 限定条件
9. 库 lib
9.1 导入核心库
9.2 导入第三方库
异步操作的解释
9.3 导入自己的 git 仓库
9.4 导入类文件
9.5 前缀&别名
9.6 筛选包内容
9.7 延迟载入
1. 类 class
1.1 定义、使用类
class Point {num x, y;Point(this.x, this.y);@overrideString toString() {return "$x, $y";}
}定义
class Point {
}使用
var p = Point();1.2 构造函数
定义
class Point {num x, y;Point(this.x, this.y);@overrideString toString() {return "$x, $y";}
}Point的类里面有一个Point的构造函数，这个 this.x 就相当于引用，形参传过来直接就给了类的 x。@override就是修饰下面的toString，就是重写了Point类的toString的方法，这样让print(p)的时候就会调用这个方法而打印出我们想要的结果
使用
var p = Point(1, 2);
print(p);1, 21.3 初始化列表
定义
class Point {num x, y;Map origin1, origin2;Point(this.x, this.y): origin1 = {'x': x, 'y': y},origin2 = {'x': x + 10, 'y': y + 10};
}这个和cpp的初始化列表是一样的
使用
void main(List<String> args) {var p = Point(1, 2);print(p);1, 2, {1: 1, 2: 2}, {1: 2, 2: 4}1.4 命名构造函数
定义
class Point {num x, y;Map origin1, origin2;Point.fromJson(Map json): x = json['x'],y = json['y'],origin1 = {'x': json['x'], 'y': json['y']},origin2 = {'x': json['x'] + 10, 'y': json['y'] + 10};
}这个就是cpp没有的东西了
使用
var p = Point.fromJson({"x": 1, "y": 2});
print(p);10, 20, {x: 10, y: 20}, {x: 20, y: 30}1.5 重定向构造函数
定义
class Point {num x, y;Map origin1, origin2;Point(this.x, this.y): origin1 = {'x': x, 'y': y},origin2 = {'x': x + 10, 'y': y + 10};// 重定向构造函数Point.fromJson(Map json) : this(json['x'], json['y']);
}如果没有这个重定向函数，那么我们现在传入的参数和构造函数不一样，就需要内部重新在把内部的各种赋值再写一遍(就像是上面的命名构造函数一样)，就不能像现在这么简单，这个this指向的就是Point(this.x,this.y)
使用
var p = Point.fromJson({"x": 1, "y": 2});
print(p);10, 20, {x: 10, y: 20}, {x: 20, y: 30}1.6 callable
class IOSPhone {call(String num) {print('phone number is $num');}
}main(List<String> args) {var phone = IOSPhone();phone('911');
}phone number is 911这个call就是cpp的仿函数，可以对象+()直接调用
2. 类 get set
2.1 定义、使用 get set
定义
class People {String? _name;People();set name(String value) {_name = value;}String get name {return 'people is $_name';}
}String? _name 指的是 _name可以为null，并且和我们之前的命名方式一样，_开头就代表私有变量,这里是属于语法
使用
var p = People();
p.name = 'ducafecat';
print(p.name);people is ducafecat就是可以直接 .方法名 就可以了
2.2 简化 get set
class People {String? _name;People();set name(String value) => _name = value;String get name => 'people is $_name';
}=>：表示单行函数定义，它等同于 { _name = value; } 的简写形式。
这种简写形式仅适用于函数体只有单一返回表达式的情况。
2.3 业务场景
/// 商品数量int get lineItemsCount => lineItems.length;/// 运费double get shipping => 0;/// 折扣double get discount =>lineCoupons.fold<double>(0, (double previousValue, CouponsModel element) {return previousValue + (double.parse(element.amount ?? "0"));});/// 商品合计价格double get totalItemsPrice =>lineItems.fold<double>(0, (double previousValue, LineItem element) {return previousValue + double.parse(element.total ?? "0");});以前可能会写个方法 getXXX() 当然也适用于赋值操作，现在直接 .方法名 更方便
3. 静态 static
3.1 static 定义
声明
class People {static String name = 'ducafecat';void show() {print(name);}
}class People {static String name = 'ducafecat';
}调用
静态变量可以通过外部直接访问,不需要将类实例化
print(People.name);ducafecat3.2 函数内部访问
实例化后的类也可以访问该静态变量
声明
class People {static String name = 'ducafecat';void show() {print(name);}
}调用
People().show();ducafecatPeople().show(); 创建一个 People 类的匿名实例，并调用其 show 方法
3.3 静态方法
静态方法可以通过外部直接访问
声明
class People {static String name = 'ducafecat';static void printName() {print(name);}
}调用
People.printName();ducafecat3.4 PS
1. 注意类名后面是否有()，有就是匿名对象，没有就是类直接去调用！
2.
默认：Dart 中的所有类、成员和方法默认都是公开的
私有：通过在名称前加
_来定义私有成员和方法，它们只能在同一个库中访问访问控制：使用公共方法提供接口来与外部代码交互，同时隐藏内部实现细节
通过这种方式，你可以更好地控制代码的可访问性和行为，从而使代码更安全、可维护
4. 抽象 abstract
4.1 abstract 类、函数、成员
普通类前加 abstract
abstract class Person {String name = 'ducafecat';void printName() {print(name);}
}4.2 不能直接 new 实例化
var p = Person();
p.printName();Abstract classes can't be instantiated.
Try creating an instance of a concrete subtype.有两种可以使用的方式
4.3 继承方式使用
class Teacher extends Person {
}var p = Teacher();
p.printName();ducafecat4.3.1 extends 继承关键字
继承的关键点
重用代码: 继承允许你重用已有类的属性和方法，减少代码重复
扩展功能: 子类可以添加新的属性和方法，或者覆盖（override）父类的方法，以实现更具体的功能
class Person {String name;Person(this.name);void printName() {print('Name: $name');}
}class Teacher extends Person {Teacher(String name) : super(name);@overridevoid printName() {print('Teacher Name: $name');}
}void main() {var p = Teacher('Alice');p.printName(); // 输出: Teacher Name: Alice
}4.3.2 super
super 关键字在 Dart 中用于引用当前实例的父类（也称为基类或超类），它主要用于以下几种情况：
调用父类的构造函数：在子类的构造函数中调用父类的构造函数，以便正确初始化继承的成员变量
调用父类的方法：在子类中调用父类的实现方法，通常在覆盖（override）方法时使用
1. 调用父类的构造函数
class Person {String name;// 父类的构造函数Person(this.name);
}class Teacher extends Person {String subject;// 子类的构造函数，调用父类构造函数Teacher(String name, this.subject) : super(name);void display() {print('Name: $name, Subject: $subject');}
}void main() {var teacher = Teacher('Alice', 'Math');teacher.display(); // 输出: Name: Alice, Subject: Math
}2. 调用父类的方法
class Person {String name;Person(this.name);void printInfo() {print('Name: $name');}
}class Teacher extends Person {String subject;Teacher(String name, this.subject) : super(name);@overridevoid printInfo() {// 调用父类的方法实现super.printInfo();print('Subject: $subject');}
}void main() {var teacher = Teacher('Alice', 'Math');teacher.printInfo();// 输出:// Name: Alice// Subject: Math
}4.4 接口方式使用
定义
abstract class Person {String name = '';void printName();
}class Teacher implements Person {@overrideString name;Teacher(this.name);@overridevoid printName() {print('Teacher: $name');}
}实例
var p = Teacher("ducafecat");
p.printName();ducafecat5. 接口 interface
首先是 Dart 没有接口,所以我们是来模拟实现的
https://dart.dev/samples#interfaces-and-abstract-classes
5.1 implements
implements 关键字在 Dart 中用于表示一个类实现了一个或多个接口。接口是类的一个规范，规定了必须实现的方法和属性。使用 implements 关键字的类需要提供接口中所有方法和属性的具体实现。与 extends 不同，implements 只是强制实现接口的方法，而不会继承接口的实现。因此，所有通过 implements 实现的类必须重写（提供具体实现）接口中的所有方法和属性
5.2 接口方式使用
定义人抽象类
abstract class IPerson {String name;int age;IPerson(this.name, this.age);String info() {return 'Name: $name, Age: $age';}
}接口用途的抽象类 请用字母 I 开头 , 如 IPhone
定义老师
class Teacher implements IPerson {@overrideString name;@overrideint age;Teacher(this.name, this.age);@overrideString info() {return 'Teacher -> Name: $name, Age: $age';}
}定义学生
class Student implements IPerson {@overrideint age;@overrideString name;Student(this.name, this.age);@overrideString info() {return 'Student -> Name: $name, Age: $age';}
}打印信息
void makePersonInfo(IPerson user) => print(user.info());实例化
void main(List<String> args) {var t = Teacher('ducafecat', 99);makePersonInfo(t);var s = Student('hans', 66);makePersonInfo(s);
}Teacher -> Name: ducafecat, Age: 99
Student -> Name: hans, Age: 66细心的小伙伴就发现了，这不就是 cpp 的多态嘛
只不过这里是最好要求 父类 用 abstract 修饰为抽象类，虽然不修饰也可以，这就是dart太开放了而没有一个规范
5.3 履行多接口
定义学校抽象类
abstract class ISchool {int grade;ISchool(this.grade);String schoolInfo() {return 'Grade: $grade';}
}学生 多继承
class Student implements IPerson, ISchool {@overrideint age;@overrideString name;@overrideint grade;Student(this.name, this.age, this.grade);@overrideString info() {return 'Student -> Name: $name, Age: $age';}@overrideString schoolInfo() {return 'School -> Name: $name, Age: $age, Grade: $grade';}
}打印信息
void makePersonInfo(IPerson user) => print(user.info());
void makeSchoolInfo(ISchool user) => print(user.schoolInfo());实例化
void main(List<String> args) {var t = Teacher('ducafecat', 99);makePersonInfo(t);var s = Student('hans', 66, 5);makePersonInfo(s);makeSchoolInfo(s);
}Teacher -> Name: ducafecat, Age: 99
Student -> Name: hans, Age: 66
School -> Name: hans, Age: 66, Grade: 55.4 从一个普通类履行接口
class Phone {void startup() {print('开机');}void shutdown() {print('关机');}
}class AndroidPhone implements Phone {@overridevoid startup() {print('AndroidPhone 开机');}@overridevoid shutdown() {print('AndroidPhone 关机');}
}void main() {var p = AndroidPhone();p.startup();p.shutdown();
}Dart 可以从一个普通的类履行接口，这就是上面才提到的
6. 继承 extends
6.1 实现继承
class Phone {void startup() {print('开机');}void shutdown() {print('关机');}
}class AndroidPhone extends Phone {
}void main() {var p = AndroidPhone();p.startup();p.shutdown();
}开机
关机6.2 父类调用
class Phone {void startup() {print('开机');}void shutdown() {print('关机');}
}class AndroidPhone extends Phone {@overridevoid startup() {super.startup();print('AndroidPhone 开机');}
}void main() {var p = AndroidPhone();p.startup();
}开机
AndroidPhone 开机super 对象可以访问父类
6.3 调用父类构造
class Mobile {int number;Mobile(this.number);void showNumber() {print('010-$number');}
}class AndroidPhone extends Mobile {AndroidPhone(int number) : super(number);
}void main() {var p = AndroidPhone(12345678);p.showNumber();
}010-12345678可调用父类的 构造函数
6.4 重写超类函数
class Mobile {int number;Mobile(this.number);
}class AndroidPhone extends Mobile {AndroidPhone(int number) : super(number);@overridevoid noSuchMethod(Invocation mirror) {print('被重写 noSuchMethod');}
}void main() {dynamic p = AndroidPhone(12345678);p.showNumber111();
}被重写 noSuchMethod注意这里要用 dynamic p，因为我们并没有showNumber111方法，而var会有检查，但是dynamic没有
6.4.1 noSuchMethod 方法
作用：noSuchMethod 方法在一个对象上调用了不存在的方法或访问了不存在的属性时被调用。可以用它来处理这些未实现的行为，从而避免程序崩溃
6.4.2 Invocation 参数
Invocation 对象包含了被调用的方法或属性的信息，例如名称和参数。Invocation 是 Dart 中的一个类，用来封装一次方法调用或属性访问的相关信息。它在 noSuchMethod 中起到了至关重要的作用。当你试图调用一个不存在的方法或访问一个不存在的属性时，Dart 会将这个调用的信息（如方法名、参数等）打包成一个 Invocation 对象，并传递给 noSuchMethod 方法
Invocation 类提供了一些有用的属性，可以帮助你了解被调用的方法或属性的详细信息：
isMethod：表示这是一个方法调用
isGetter：表示这是一个getter访问（读取属性值）
isSetter：表示这是一个setter访问（设置属性值）
memberName：表示被调用的方法或属性的名称
positionalArguments：表示被调用方法的所有位置参数
namedArguments：表示被调用方法的所有命名参数
在重写的函数上加修饰符 @override
6.5 继承抽象类的问题
abstract class IPhone {void startup() {print('开机');}void shutdown();
}class AndroidPhone extends IPhone {@overridevoid startup() {super.startup();print('AndroidPhone 开机');}@overridevoid shutdown() {print('AndroidPhone 关机');}
}void main() {var p = AndroidPhone();p.startup();p.shutdown();
}开机
AndroidPhone 开机
AndroidPhone 关机抽象类中只定义抽象函数，实例化访问会报错
7. 工厂函数 factory
7.1 调用子类
abstract class Phone {void call();factory Phone(String type) {switch (type) {case "android":return Android();case "ios":return Ios();default:throw "The '$type' is not an recognized";}}
}class Android implements Phone {@overridevoid call() {print('Android Calling...');}
}class Ios implements Phone {@overridevoid call() {print('Ios Calling...');}
}void main() {var android = Phone('android');var ios = Phone('ios');android.call();ios.call();
}Android Calling...
Ios Calling...抽象类：定义了一个接口和一个工厂构造函数
实现类：实现了抽象类的接口方法
工厂构造函数：根据输入参数返回不同的具体实例，实现了对象创建的抽象化，符合工厂设计模式的原则
这使得代码更具可扩展性和灵活性，能够根据需要轻松添加新的类型
简单说就是可以用 抽象父类 去实例化子类（之前是方法/接口的多态，那么现在就是利用abstract和factory实现实例化子类的多态）
7.2 单例模式
class Phone {// 创建一个静态的、私有的实例static final Phone _single = Phone._internal();// 私有构造函数，用于初始化实例Phone._internal();// 工厂构造函数，返回唯一的实例factory Phone() {return _single;}// 示例方法void call() {print('Calling...');}
}void main() {var p1 = Phone(); // 获取单例实例var p2 = Phone(); // 获取同一个单例实例print(identical(p1, p2)); // 检查两个引用是否指向同一个实例Phone().call(); // 使用单例实例调用方法
}true
Calling...7.2.1 解释 static final Phone _single = Phone._internal();
static：表示这个变量是类级别的，而不是对象级别的。也就是说，不管有多少个 Phone 对象，这个变量只有一个实例
final：表示这个变量一旦赋值后就不能改变
Phone _single：这是单例模式的核心，定义了一个名为 _single 的私有静态变量，它将持有 Phone 类的唯一实例
= Phone._internal();：这里调用了私有的命名构造函数 _internal，创建并初始化了 Phone 类的唯一实例 _single
7.2.2 解释 私有构造函数Phone._internal();
这个构造函数被声明为私有的（前面有下划线 _），因此它只能在 Phone 类内部被访问，外部不能直接调用它
这个构造函数的作用是在类内部初始化单例对象
7.2.3 工厂构造函数 factory Phone()
factory：这是 Dart 中的一个关键字，用于定义一个工厂构造函数。工厂构造函数不直接创建新实例，而是可以返回一个现有的实例
Phone()：这里定义了一个默认的工厂构造函数
return _single：工厂构造函数中唯一的操作是返回先前创建的 _single 实例。因此，无论什么时候使用 new Phone()，总是返回同一个实例对象
简单说，获得单例的时候，先调用static final Phone _single = Phone._internal();，然后这个的后半部分会去调用Phone._internal();然后调用 factory Phone()返回单例
7.3 减少重复实例对象
class Phone {int _number;Phone(this._number);factory Phone.fromJson(Map<String, dynamic> json) =>Phone(json['number'] as int);void call() {print('Calling $_number...');}
}void main() {var p = Phone.fromJson({"number": 911});p.call();
}如果不用工厂构造函数，就要用类静态方法，就会有多余的内存占用(static 方法)，用工厂构造函数就比较干净
8. 多继承 with
8.1 正常
定义类
class Phone {void call() {print('Phone is calling...');}
}class Android {void playStore() {print('Google play store');}
}class Ios {void appleStore() {print('Apply store');}
}with 混入
class Xiaomi with Phone, Android, Ios {}采用 with ... , .... , ... 方式 mixin 入多个类功能
执行
void main(List<String> args) {var p = Xiaomi();p.call();p.playStore();p.appleStore();
}Phone is calling...
Google play store
Apply store8.2 函数重名冲突
Android Ios 加入 call 函数
class Android {void playStore() {print('Google play store');}void call() {print('Android phone is calling...');}
}class Ios {void appleStore() {print('Apply store');}void call() {print('Ios phone is calling...');}
}执行
void main(List<String> args) {var p = Xiaomi();p.call();p.playStore();p.appleStore();
}Ios phone is calling...
Google play store
Apply store可以发现后面的覆盖了前面的内容
8.3 mixin 不能构造函数
加入构造函数
class Android {Android();...
}The class 'Android' can't be used as a mixin because it declares a constructor.加入 mixin 关键字 限定
mixin Android {// mixin 中不能定义 constructor...
}mixin 的作用就是告诉编译器这个类的作用很单纯就是去混入的，所以编译器会进行检查是否有构造函数
8.4 mixin on 限定条件
关键字 on 限定 Phone
mixin Android on Phone {void playStore() {print('Google play store');}@overridevoid call() {super.call();print('Android phone is calling...');}
}with 混入时候，必须先 Phone 才行
错误
class Xiaomi with Android {}'Android' can't be mixed onto 'Object' because 'Object' doesn't implement 'Phone'.
Try extending the class 'Android'.正确
class Xiaomi with Phone,Android {}9. 库 lib
9.1 导入核心库
import 'dart:io';void main() {var f = new File('README.md');var content = f.readAsStringSync();print(content);
}9.2 导入第三方库
编写 pubspec.yaml
dependencies:dio: ^4.0.6执行拉取包命令
$ dart pub get程序调用
import 'package:dio/dio.dart';void main() async {Dio dio = Dio();Response<String> response =await dio.get("https://wpapi.ducafecat.tech/products/categories");print(response.data);
}[{"id":34,"name":"Bag","slug":"bag","parent":0,"description":" ......await 是 Dart 编程语言中的一个关键字，用于等待一个异步操作的完成。它只能在 async 函数中使用。在示例中，它用于等待来自 Dio 包的 HTTP 请求完成，并在请求完成之后继续执行代码
解释：Response<String> response = await dio.get("https://wpapi.ducafecat.tech/products/categories");:
- 使用
Dio实例发送一个GET请求并等待响应 await关键字告诉 Dart 等待dio.get函数完成并返回结果dio.get函数返回一个Future<Response<String>>，其中Response<String>是实际的响应对象。await将这个Future解包成Response对象
异步操作的解释
async关键字：用于标记函数是异步的。异步函数可以使用await关键字await关键字：用于等待异步操作完成。在等待期间不会阻塞事件循环，允许其他代码继续执行
9.3 导入自己的 git 仓库
编写 pubspec.yaml
dependencies:uuid:git:url: https://github.com/Daegalus/dart-uuidref: master执行拉取包命令
$ dart pub get从 master 分支拉取
9.4 导入类文件
phone.dart
class Phone {void call() {print('Phone is calling...');}
}class Android {void playStore() {print('Google play store');}void call() {print('Android phone is calling...');}
}class Ios {void appleStore() {print('Apply store');}void call() {print('Ios phone is calling...');}
}实例
import 'package:dart_learn/phone.dart';void main() {var p = Phone();p.call();
}Phone is calling...9.5 前缀&别名
import 'package:dart_learn/phone.dart' as pp;void main() {var p = pp.Android();p.call();p.playStore();
}Android phone is calling...
Google play store就是导入包后面的 as
9.6 筛选包内容
import 'package:dart_learn/phone.dart' show Ios;void main() {var p = Ios();p.call();p.appleStore();
}Ios phone is calling...
Apply storehide 筛掉某几个包 show 只使用某几个包
9.7 延迟载入
import 'package:dart_learn/phone.dart' deferred as pp;Future<void> main() async {await pp.loadLibrary();var p = pp.Android();p.call();p.playStore();
}Android phone is calling...
Google play storeloadLibrary() 方式在需要的时候载入包 可提高程序启动速度 用在不常使用的功能 用在载入时间过长的包
创作不易，希望读者三连支持 💖
赠人玫瑰，手有余香 💖
这篇关于Flutter基础 -- Dart 语言 -- 类抽象接口继承函数库的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
