image.png
1、方法
1.1 一等方法对象
在dart 中是面向对象的编程 , num、String、dynamic、这些类型都是一个对象,当然也包括方法(Function)
看下面的代码, 先定义了一个fun() 方法 ,然后将方法赋值给 Function 变量, 再通过 变量 f 调用
//这是一个方法
void fun() {
debugPrint("这是一个方法");
}
void main() {
//方法都是对象，可以赋值给Function变量
// Function 类，我们将 fun 方法赋值给Function 变量
Function f = fun;
//直接调用
f();
}
上面的方法 fun() 是没有传参数的,如果我们想传参数应该怎么调用呢
//这个 参数是一个 Function对象（也就是说可以传入另一个方法，但是这里并没有指定方法的参数与返回值）
void fun(Function function) {
debugPrint("这是 fun() 方法");
//1、注意这个地方调用里面的参数是可以随便填的,因为我们并没有定义都有什么参数和方法的返回值
function();
}
void main() {
//方法都是对象，可以赋值给Function变量
// Function 类，我们将 fun 方法赋值给Function 变量
Function f = fun;
//直接调用
//2、传入一个匿名函数,这个传入的匿名函数也是可以随便传入参数的
f((){
debugPrint("这是参数方法");
});
}
最后输出:
这是 fun() 方法
这是参数方法
注意这 1 和 2 的地方(匿名函数和被执行的函数),因为没有定义传入的方法参数和返回值,所以如果两边的参数不一致就会抛出异常(当然编译器是不会报错,只有在运行时才会报错)。 那么这个问题如何解决?
这就有了 typedef 关键字,它是用来定义一个类型的。看下面这行代码
typedef void F(String a,int b)
上面这段代码的意思是:定义了一个 F 的类型,这个F的类型其实就是一个方法, 参数 是(String,int) 返回值 是 void
//定义了一个F类型，F 类型其实就是一个方法，参数是（String，int） 返回值是 Void
typedef void F(String a, int b);
//定义一个方法，些方法的参数 是一个 F 类型
void fun2(F function) {
debugPrint("这是 fun2() 方法");
//因为它是一个F类型，所以在调用的时候要按照我们定义的方法去传参数，而不是和上面一样随便传参
function("abc", 2);
}
void main() {
Function f2 = fun2;
//调用 fun2() 方法,并且传入匿名函数(这里的参数必须要和上面定义的F类型一样)
f2((String a, int b) {
debugPrint("这是 Fun2 方法 $a $b");
});
}
当然除了上面这种还有其他的写法,这三种用哪个都行,个人喜欢上面那个
//直接定义在方法上也是可以的
void fun3(void Function(String str, int a) function) {
function("fun3", 123);
}
//这两个方法是一样的
void fun4(void function(String str, int a)) {
function("fun4", 123);
}
1.2 可选位置参数
在Dart中有一些参数是可选得,调用方法的时候即使不传也是可以的
注意可选位置参数是 有顺序的,如果你想给第二个参数传值,那么前面的必须也要传
//可选位置参数,可以设置默认参数
void fun([int? a, int? b = 2]) {
debugPrint("$a");
debugPrint("$b");
}
void main() {
//这是给第一个参数传值
fun(10);
//如果想给第二个参数传就必须保证前面的参数有值
fun(20,22);
}
1.3 可选命名参数
调用命名参数时必须要有形参的变量名,而且有了名字就不用在意位置了。不管是命名参数还是位置参数都是可以设置默认值的
//可选命名参数
void fun2({int i = 1, j = 2}) {
debugPrint("i=$i;j=$j");
}
//调用命名参数时必须要有形参的变量名,而且有了名字就不用在意位置了
fun2(j: 47);
fun2(i: 35, j: 28);
fun2(j: 98, i: 73);
2、类
所有的类都继承Object
2.1 变量
在Dart中是没有 private 关键字的, 如果想让一个变量是私有的使用 _ 开头的命名
class Point {
//私有变量
final String _a = "abc";
int b = 123;
}
2.2 构造方法
- 类的构造方法是可以没有方法体的
- 在Dart中是没有方法重载的,不管是构造方法还是普通的方法
- 构造方法分为 未命名构造 和 命名构造 ,
- 未命名构造 只能有一个, 命名构造 可以有多个(只要名字不同即可)
//类的定义
class Person {
// late 关键字表示 延迟初始化,和Kotlin中 lateinit 一个道理
late String name;
late int age;
//标准的构造函数
Person(this.name, this.age);
//在Dart中未命名的构造只能有一个，可以有无数个命名的构造
Person._() {
name = "";
age = 0;
}
//命名构造
Person.a();
}
2.3 初始化列表
主要功能就是初始化参数,当然也是可以在构造的方法体中进行初始化的
class Point {
String? _a = "abc";
int b = 123;
//命名构造
Point.Map(Map<String, String> map) : _a = map["a"];//初始化参数列表
void printA() {
debugPrint("_a:$_a");
}
}
void main() {
Map<String, String> map = {"a": "aah"};
var p1 = Point.Map(map);
p1.printA();
}
2.4 常量构造函数
在Dart中有两个常量的关键字 const 和 final
- const 编译时常量
- final 运行时常量
const 的性能要比final的要好
class MyPoint {
final int x;
final int y;
//常量构造函数
const MyPoint(this.x, this.y);
}
void main() {
var p1 = const MyPoint(1, 2);
var p2 = const MyPoint(1, 2);
var p3 = const MyPoint(1, 3);
debugPrint("${p1 == p2}"); // 输出结果为true,注意这两个的参数是一样的,如果不一样就为false
debugPrint("${p2 == p3}");//参数不一样为false
}
常量构造函数在其他语言中是没有的。在Dart中是很常见的,这是因为在Dart中控件都可以是一个类.比如我们在不同页面中有三个TextView 显示的内容是一样的,那如果使用常量构造函数创建出来的组件就是同一个对象,而不会产生三个对象
2.5 工厂构造函数 与 静态方法
工厂构造函数 的关键字是 factory. 必须要有一个构造函数
class Manager {
late int i;
//普通函数
Manager();
//工厂构造函数
factory Manager.get() {
//调用未命名的构造(但是这个构造必须也要有)
return Manager();
}
}
//继承
class Child extends Manager {}
在Dart中静态方法使用 static ,静态方法可以直接使用 类名.方法名() 调用
class C {
static print(obj) {
debugPrint("$obj");
}
}
//调用
void main() {
//通过类名直接调用
C.print(test);
}
2.6 Getter 与 Setter 方法
Dart 语言中的这两个方法都是有对应的 get 和 set 关键字。
get 方法是没有参数列表的,所以不需要 加括号
set 方法必须要声明一个参数
class Child extends Manager {
int _x = 0;
Child() : super();
int get getX {
return _x;
}
set setX(int a) {
_x = a;
}
}
这里当我们调用 set 方法时更像是给变量赋值
var child = Child();
child.setX = 1;
// child.setX(1); 这样写会报错
2.7 操作符重载
在Kotlin中也有这个功能, 这两个语言使用的关键字是一样的
class Child {
int _x = 0;
int get getX {
return _x;
}
set setX(int a) {
_x = a;
}
//返回值和参数可以定义成任何自己需要的类型
int operator +(Child c) {
var child = Child();
child.setX = _x + c.getX;
return child.getX;
}}
调用的时候需要注意前面的是调用者后面的是参数
var child = Child();
child.setX = 3;
var child2 = Child();
child2.setX = 4;
//这里 child 是调用者,child2 是参数,相当于 child.+(child2)
int c = child + child2;
debugPrint("${c}");
下面这个图片是可重载的操作符
可重载的操作符.png
3 、抽象类与接口
3.1 抽象类
- 使用
abstract表示 抽象类 - 抽象类中没有方法体的就是抽象方法
- 因为构造方法本身是可以省略方法体,所以他不是抽象方法
abstract class A {
//构造方法本身可以省略方法体
A();
//在抽象类中没有方法体的就是抽象方法
void test();
//有方法体的是实例方法
void test2() {
debugPrint("这是 实例方法 test2()");
}
}
class B extends A {
@override
void test() {
// TODO: implement test
}
}
3.2 接口
- Dart 中没有 interface 关键字
- 他的所有的类都可以看做是接口,除了抽象类除外
在Dart中每个类都隐式的定义了一个包含所有实例成员的接口
//创建一个普通的类 Test
class Test {
//变量
int x = 0;
//方法
void fun1() {}
}
//实现 Test 类
class MyTest implements Test {
@override
late int x = 1;
@override
void fun1() {
// TODO: implement fun1
}
}
4、可调用的类
如果一个类中有 call() 方法,可直接调用,代码如下
class MyTest {
// 可调用的类
void call() {
debugPrint("Call 方法");
}
}
void main() {
var test = MyTest();
//直接调用call
test();
//平时这样调用也是可以的
test.call();
}
5、混合 mixins
混合类似是多继承,可以把多个类中的方法混入到新的类中
如下代码,将A,B混入到C类中
class A{
void a(){
debugPrint("A类的 a() 方法");
}
void b(){
debugPrint("A类的 b() 方法");
}
}
class B{
void b(){
debugPrint("B类的 b() 方法");
}
}
//将A,B混入到C类中
//注意混入的顺序
class C with A,B{
@override
void a(){
debugPrint("C类的 a() 方法");
}
}
//如果C类中没有自己的方法的话还可以使用下面的语法糖
class C = Object with A, B;
注意:
- A和B 必须是 Object 的直接子类
- A类和B类不能有构造方法
- 如果存在重复的方法,会先从C类本身中找,如果找不到再去从最后混入的B 类中去找,然后再是A类
6、异常
上面记录了一些类相关的知识,接下来记录一下异常相关
在Dart中可以抛出任何类型的异常,包括但不限于 int String bool Function
对,你没有看错还可以抛出一个方法
//这里的index 动态的数据类型 dynamic
void _throwException(index){
if (index == 0) {
throw "字符串";
} else if (index == 1) {
throw 100;
} else if (index == "2") {
throw print;
}
}
void test(){
print("======");
try{
_throwException("2");
//使用 on 判断 是哪种异常
}on int catch(e,s){
print(e);
print(e.runtimeType);
}on String catch(e,s){
print(e);
print(e.runtimeType);
}on Function catch(e){
e("这是一个方法");
e(e.runtimeType);
}
}
网友评论