flutter-dart编程语言

前言

若想开始开发 flutter，那么谷歌推出的 dart 编程语言是必备的， dart基本上就是为学习java 的人量身订做的，在一些语法上有比较像 swift，可以说谷歌为了推出跨平台flutter，是花了不少心思的，毕竟一个是土生土长的java，另一个也是ios端目前最新最流行的swift

从语言上来说，java和swift只要会一个，上手就和喝水一样简单，下面跟着我学习一遍吧，学完剩下的就是实战了

dart_demo案例 -- 此案例可以在vscode下载code runer插件，进入代码后右键运行(注意：从文件的main函数运行)

学习参考地址

ps：可能有人会说，你这不就是照着参考地址，学完一遍后，自己举个例子简单翻译就结束了么？我想说，这就是我学习理解与记忆的一部分呀，另外也可以看出 dart 语言上手就是这么简单

dart 编程语言

导入一个库

导入库的时候使用 import，后面一般是 [dart:库名]，一般系统会自动导入

另外对于引入自己的文件，则是根据当前路径定位文件的相对位置

./： 返回当前文件所在目录

../： 返回上一个目录

//使用库,必须要写到最上面
import 'dart:async';
import 'dart:html';
//导入数学库
import 'dart:math';
//导入内置的文件,导入某个项目文件，使用相对路径
import './4class.dart'; 

//导入一个库，由于其调用方式和c类似，因此可能会和我们项目中有重名的情况
//为了避免调用错误或者冲突报错问题，可以使用 import * as + 名字 的方式导入，即模块化导入
//默认导入方式
import 'dart:convert'
//模块化导入方式
import 'dart:convert' as convert;
//以这种模块化方式导入，相当于将里面暴露出来的方法给放到了自己命名的类中
//import + 库名 + as + 命名，调用方式: 类名.函数名即可调用
原本调用: jsonEncode()  ---  模块化调用: convert.jsonEncode()

常量和变量

变量都是 var修饰，很多语言常量用 let 修饰常量，这里的 final 就相当于 let，可以给变量赋值一次， const表示只读，一般在编辑阶段使用，定义时就要给值，也可以像c一样使用指定类型声明

dart在声明对象时，无需指明变量类型，系统会自动根据创建时的类型，推断出实际类型，即类型推断(作为参数传递时，则需要指明)；在需要时，可以将 let之类的修饰符换成指定类型，以声明变量类型，也算是保留一些其他端的用户习惯

ps：和 js不同，js的 var具备变量提升效果，let 相当于声明普通的局部变量，这里的 var 声明的就是一个普通变量

//赋予一个字符串属性
const readonlyName = "我是只读的常量"; //编辑期间使用，  也和 swift 中 let 类似

// final finalName = "我只能被赋值一次";//只能被赋值椅子，之后不能赋值
final finalName; //只能被赋值一次，之后不能赋值，宛如swift中的let
finalName = "我只能被赋值一次";

// static const sreadonlyName = "我是只读的类属性，只能在类中使用";
var name = "我是可更改的变量"; //变量
name = "我的内容更新了";

//也可以使用声明指定类型方式接收变量，平时用的比较少
String a = "我是直接使用类型的方式声明";

数字number

这里的数字其实也是对象，和 js 类似，数字有自己的一些对象方法，能进行一些数学操作

ps: 数字的类型都是小写哈，和其他的不同，感觉可能是另外一个人写的😂

//数字，可以使用常见的Math函数
var num1 = 10; //类型推断，实际是int类型
var num2 = 10.2; //类型推断，实际是double 类型

//数字可以使用abs()、ceil()、floor()等，也支持常见的四则运算、移位、与、或、非、异或等操作
//也可以使用math数学库 import 'dart:math';
var num3 = num1 | num1 & num1 & num1;
var numa = num2.abs();
var numc = num2.ceil();
var numf = num2.floor();
var nump = pow(num2, num1); //数学库的方法

//bool类型
var boolNum = true;
boolNum = false;

字符串String

字符串的类也是一个对象，可以像其他语言一样通过 + 或者${} 拼接字符串，连一些字符串的操作名字都一样，如下所示，列出一部分

var str = '我是一个普通的字符串';
var str1 = "我是一个没区别的双引号字符串";

var str2 = str + str1; //拼接字符串

//几可以使用三个单引号或者三个双引号，将一片多行字符串拼接起来
var str3 = ''' 
'sfasdf' 
'123123'
''';
str3 = """ 
sfasdf
123123
""";

//字符串前面加上r内部字符串不会被转义
var rstr = r'1212313 \n 123123';

//字符串中拼接其他变量，通过 ${} 包裹变量内容
var spitStr = "str的总长度是:${str.length}, str1的内容是:${str1}";

//获取子串 1-2，从1开始共 3-1=2个字符串
str.substring(1, 3);

//分割字符串为数组，其他语言中也很常见
str.split('一');

//是否包含某一个子串
final result = str.contains(str1);

//查找子串的位置
str.indexOf(str1);

//转化为大小写
str.toLowerCase();
str.toUpperCase();

字符串数字相互转化

字符串，数字中比较常见转化了，如下所示

其中 toString是各个对象中基本都存在的方法，可以转化字符串，在一些网络数据中，为了安全基本基本必调的

保留小数点也是比较常见的，有指定的方法也能避免自己写逻辑

var num1 = 10;
var num11 = 10.21312893192783;
var str1 = "10.2";

//数字转化字符串
var num2 = int.parse(str1);
var num3 = double.parse(str1);

//字符串转化成数字
var str2 = num1.toString();
var str3 = num1.toStringAsFixed(2); //保留小数点后两位

数组 List

数组在这里类型名字为 List（不是Array）, 不得不说，使用中最常见的集合就是数组了，其为有序的线性集合

//创建一个空数组,默认为任何类型,构造方法的形式，系统不推荐
var list = [];
var list1 = <int>[]; //创建只有int类型的数组

//添加元素
list.add(1);
list.add("asfsdf");
list.add("123");
list.addAll(list1); //添加数组内所有元素

//删除指定元素，或者指定索引的元素
list.remove('123');
list.removeAt(0);

//插入的元素
list.insert(1, "插入的元素");

//获取数量
list.length;

//内部排序
list.sort((a, b) => a > b);

//将数组元素使用分隔符拼接成字符串
var str = list.join(';');

list.reversed; //置反数组

//forin遍历数组(推荐)
for (var item in list) {
}
//内部使用的也是forin
list.forEach((element) {
});
var newList = list.map((e) => {
  e = e + "啦啦啦"
});

哈希表 Set

Set是一个哈希表，为一个无序集合，其根据内容生成哈希值，使用哈希值作为索引获取数据信息，内部具体表现是哈希表、树表、哈希表树表结合还是其他，就不知道了(据说一些在使用哈希表同时，采用二分法的方式修改查询，放弃了红黑树等树表)

特点:写入速度稍慢，读取速度快，不会存放重复数据

//创建一个 set
var sets = {};
//使用Set的构造方法创建
var sets1 = Set();
var sets2 = Set<String>();

//创建一个有值的set
var set = {1, 2, 3, '哈哈', '啦啦'};
var set1 = <int>{1, 2, 3}; //创建一个指定类型的Set集合

set.add(3);
set.add('哈哈');

//移除某一个元素
set.remove(3);

//是否包含某一个元素,此时取出已经没必要了
set.contains(3);

set.length; //获取数量

//遍历集合(推荐)
for (var item in set) {
}
//内部使用的也是forin
set.forEach((element) {
});

key-value哈希表 Map

Map也是一个哈希表，只不过是以key生成哈希值，存放value等信息，即 key-value形式的哈希表，实现与Set相似，内部具体表现是哈希表、树表、哈希表树表结合还是其他，就不知道了(据说一些在使用哈希表同时，采用二分法的方式查询，放弃了红黑树等树表)

//创建一个空Map，注意{}代表空Set
var map = <String, String>{};
//使用Map的构造方法创建
var map1 = Map<int, String>();

//快捷创建一个Map集合
var map2 = {
"key1": '哈哈',
"key2": "啦啦"
};

//赋值和获取
map["123"] = "啦啦";
var content = map["123"];

//获取另一个类型的数组，注意下标是key，而不是数组的顺序索引
map1[1] = "哈哈";
var content2 = map1[10];

//是否包含某一个元素key
map.containsKey("key");

//遍历集合(推荐)
for (var item in map.keys) {
}
//内部使用的也是forin
map.forEach((key, value) {
});

任意类型 dynamic、Object

dynamic表示任意类型，可以作为一个通用类型(实际使用中，建议能不使用就不适用，容易出现隐性bug)，就像typescript 中的 any 类型，java 中的 Object 类型

Object 和 dynamic类似，可以表示所有的对象类型，就目前所知道的，String、number等都是对象类型（还没有碰到其他非对象类型）

tips：ios中的 id 和 NSObject类型就不一样了，那里的 int，char等都是非对象类型的，因此不能代替

基本流程语句

基本流程语句包括常见的 if else、for循环、while循环、do while循环、switch控制语句

var a = 10;
var b = 20;
var c = "a";
var d = "b";

if (c == d ) {
//满足条件
}else {
//不满足条件
}

//for 循环遍历
for(var i = 0; i < 10; i++) {
print("哈哈哈");
}

//for in快速遍历集合
var list = [];
for(final item in list ) {
print(item);
}
//内部是for in
list.forEach((element) {
print(element);
});

//先走控制语句
while (a++ > b) {
print("a不大于b");
};

//先走内部语句，再走控制
do {
print("a不大于b");
} while(a++ > b);


var command = 'open'; // on、open、off、close、other
switch(command) {
case 'on':
case 'open': 
  print('门开着的');
  break;
case 'off':
case 'close': 
  print('门关着的');
  break;
default: 
  print('门可能被打破了，不知道算开，还是关');
  break;
}

异常捕获try catch

编写代码时难免会碰到不可抗拒因素，例如：一些老的api在使用中会 throw 一个异常，或者网络请求的失败可能也会抛出一个失败异常，此时都可以使用 try-catch解决，如果想捕获指定异常，可以使用 on 关键字来解决

void test9(int num) {
  if (num > 10) throw FormatException("num不能大于10");
}
void test10() {
  try {
    test9(12);
  }catch(e) {
    print('出现异常了:${e.toString()}');
  }

  try {
    test9(12);
  }on FormatException {
    print("根据抛出的异常类型,只捕获某一类");
  }catch(e) {
    print("捕获剩余的类型");
  }finally {
    //无论是否异常都执行
  }
}

定时器

定时器在平常开发中使用在常见不过了，这里就直接先介绍了

下面就是使用Timer写的一个延迟定时器和间隔性定时器

注意：间隔定时器使用完后要合适时机释放，否则会一直执行（合适时机可以是，某一个功能执行完毕了、此模块推出了等等）

//只会回调一次的定时器
Timer(Duration(seconds: 5), () {
//执行一个5s的定时器
});

//会回调多次的定时器
var num = 0;
Timer.periodic(Duration(seconds: 5), (timer) { 
  if (num++ > 10) {
    timer.cancel(); //取消定时器
  }
  print(num);
});

函数

函数的定义

函数的定义和 java 很像，如下所示

//无参无返回值函数
void getUserInfo() {
}
//无参的可简化返回值效果
//注意下面返回值实际默认是 dynamic
//getUserInfo1() {
getUserInfo1() {
}

//带参的函数
getUserInfoByToken(String token) {
}

//参数带?的函数,可以理解为可选参数,除了指定类型，可以传null
getUserInfoByToken1(String? token) {
}

//带参带返回值
List getUserInfiByToken1(String token) {
  return [];
}
//设置返回类型
List<String> getUserInfiByToken2(String token) {
  return ["啦啦啦"];
}

闭包(匿名函数)

在开发中，不是只会用到平常的函数，有时候使用闭包函数，将会减少工作量，且使用起来更加方便，无论是传参还是调用

//无参无返回值闭包函数
var block = () {
print(123);
};
block();

//带参有返回值的
var block1 = (num) {
return num + 1;
};
var result = block1(10);
print(result);


//带箭头的，简化操作，有点兼容js箭头函数的意思
var block2 = (num) => pow(num, 2);
var result2 = block2(14);
print(result2);

var block3 = (str) => {
print("哈哈哈:${str}")
};
block3("哎呀");

闭包、函数作为参数(两者一样)

闭包函数作为参数时，和正常函数一样，只要是一眼类型的都可以，传入的都是函数指针，或者闭包指针

如下所示，演示了无参函数，带参函数、闭包、普通函数之间的传递方式，其中也用 ? 表示了可选类型的声明传入

?: 为可选类型，代表指定类型或者null,例如 double? 代表的是一个浮点数 或者 null

//无参普通函数
getUserInfo() {
}

//传入无参闭包或者普通函数
requestUser(void completed()) {
  Timer(Duration(seconds: 2), () {
    completed();
  });
}
//传递闭包参数，加上？表示可选，(闭包的参数名在中间，因此？写到最后)
requestUserTokenByCompleted(void completed(String? userToken)?) {
  Timer(Duration(seconds: 2), () {
    if (completed != null) {
      completed(DateTime.now().microsecondsSinceEpoch % 5 > 2 ? 'abc' : null );
    }
  });
}

//flutter中标准写法改进
requestUser(Function() completed) {
  Timer(Duration(seconds: 2), () {
    completed();
  });
}
//可选带参类型案例
requestUserTokenByCompleted(Function(String? userToken)? completed) {
  Timer(Duration(seconds: 2), () {
    if (completed != null) {
      completed(DateTime.now().microsecondsSinceEpoch % 5 > 2 ? 'abc' : null );
    }
  });
}

//闭包函数
void main() {
    //调用无参闭包函数
    requestUser(() {
      print("调用了一个无参闭包函数");
    });
    //此时requestUser的回调在 getUserInfo 普通函数中
    requestUser(getUserInfo);
    
    //调用带参闭包函数
    requestUserTokenByCompleted((token) {
      print("获取用户信息成功了,token:${token}");
    });

    requestUserTokenByCompleted((token) {
      print("获取用户信息成功了,token:${token}");
    });

    requestUserTokenByCompleted(null);
}

重名函数类型：在传递函数或者闭包函数的过程，有时候会显得类型非常繁琐，可以采用重命名的方式来简化参数类型，简化都的参数和普通类型一样，例如：double

//重命名,或者声明一个闭包类型，与平常的不一样名字就在返回值和参数中间，作为参数也一样
typedef void blockType(int num);

//像普通变量一样调用
test(blockType block) {
    block(2);
}

运算符

赋值运算符

赋值运算符，在很多语言中都比较通用，例如 ??= *= /= += -= %= &= |= ~= <<= >>= >>>=

&=: (按位与赋值) |=: (安按位赋值) !=: (按位取反赋值) <<=: (按位左移赋值) >>=: (按位算术右移，最前面位置补零) >>>=: (按位逻辑右移,最前面位置补符号位)

这里主要介绍不常见的的一些

//??
var a = b ?? c //当 b存在时返回b，否则返回c

//??=
b ??= value  //如果b存在，b保持不变，相反，b为空，则将value的值给b

关系运算符

关系运算符，比较常见的就是 as、is、is!，==判断就不多说了，是否相同

as: 类型转换，可以用来转化类型，例如：将声明父类的转化声明成子类类型(实际如果不是这个类型使用可能会报错)

is: 判断一个类是不是某一个类或者其子类，是则返回true，否则返回false；如果一个类实现了某一个接口 T，那么 is T 也是true

//as、is、is!
//有这么两个类学生Student继承人类Person

//如下，Student继承自Person，虽然强转指定类型，编译阶段不一定报错，实际运行没有该方法还是会报错
var p = new Person();
var a1 = p as Student; //
a1.getName(); //如果 p实际上没有 Student的 getName方法，那么就会报错

//as
// 只是 强转了编译期的声明类型，编译期间不会报错了
//实际调用时，如果不是实际类仍然可能会报错
//使用时，一般通过多态或者通用类型声明一个对象，可以使用as转化为实际类型使用

//is 
//判断一个类是不是某一个类或者其子类，是则返回true，否则返回false
//如果一个类实现了某一个接口 T，那么 is T 也是 true

级联运算符

..、？.. 为级联运算符的两个关键字，前者是默认调动，后者是可选调用，为空则不调用

//.. 或者 ?.. 可以省略调用，简化多次调用方法或者变量
//对于对象存在的情况，使用..
var paint = Paint()
    ..color = Colors.black
    ..strokeCap = StrokeCap.round
    ..strokeWidth = 5.0;

//相当于

var paint = Paint();
paint.color = Colors.black;
paint.strokeCap = StrokeCap.round;
paint.strokeWidth = 5.0;


//队友有些对象可能不存在的情况，使用?.. + ..
querySelector('#confirm') // Get an object.
    ?..text = 'Confirm' // Use its members.
    ..classes.add('important')
    ..onClick.listen((e) => window.alert('Confirmed!'));

//相当于

var button = querySelector('#confirm');
button?.text = 'Confirm';
button?.classes.add('important');
button?.onClick.listen((e) => window.alert('Confirmed!'));

异步支持 async await

这里的异步支持就是比较常见的 async、await了

其中 async 则是让一个函数开始支持异步操作，此时可以理解为并没有开启异步线程，当异步方法碰到await时，此异步方法开始被阻塞，并保存到Future对象中，放到队列中延迟执行，然后切出此函数，继续往后执行(注意：不是跳过await继续执行该函数，而是返回上一级继续执行)，然后继续执行，碰到await修饰的继续阻塞保存放入队列，直到其他方法执行完毕之后，然后开始制定Future延迟队列中阻塞的内容，就这样模拟出了异步效果(由于flutter是单线程，又根据效果猜想，大致原理应该相似，不影响使用)

ps： 阻塞执行这一步实际有没有开出多线程可以自己查看一下，可能仅仅是模拟异步逻辑，类似操作系统切换cpu执行任务片段时间等，以让任务获得响应

另外，Future和js的Promise类似,只不过没有resolve、reject，默认返回 Future参数，通过await或者 then都可以获取参数，只不过使用 await 的前提是，当前函数得异步支持（async），而 then 不需要（另外可以结合 Completer做出类似 Promise的效果，后面会有文章介绍）

具体为什么这么说，等看完测试结果就能猜出一些了

//声明一个异步方法
Future<bool> simulateOperate() async {
  //假设这一有一些非常耗时的操作逻辑，例如对本地数据整理
  var num = 0;
  for(var i = 0; i < 10000000; i++) {
    num++;
  }
  print('我的异步任务执行完毕了--${num}');
  return true;
}

//执行一个同步方法调用，会发现，此异步任务执行正常
void test() {
  print('开启test同步方法');
  //通过打印可以看到这里返回的是函数指针，异步任务结果这里已经忽略了
  //没有 await，实际阻塞了后续任务的执行，可以理解我同步执行
  var res = simulateOperate();
  print('我是test同步方法,执行完毕了:${res}');
}

//必须在有async的函数下使用 await,能够等待异步任务执行结果，另外没有返回值时可以省略 Future
testAwait2() async {
  print('开启testAwait2异步方法');
  var res = await simulateOperate(); //之而立返回的是true
  print('我是testAwait2异步方法方法,执行完毕了：${res}');
}

//和上面的一样，只不过时使用 then
testAwait2() {
    print('开启testAwait2异步方法');
    simulateOperate().then((res) {
        print('我是testAwait2异步方法方法,执行完毕了：${res}');
    })
}

void main() {
  print("总体任务开始");
  test();
  print("第一个测试完毕");
  testAwait2();
  print("第二个测试完毕");
}

执行结果如下所示

//打印结果
// I/flutter ( 5664): 总体任务开始
// I/flutter ( 5664): 开启test同步方法
// I/flutter ( 5664): 我的异步任务执行完毕了--1000000000
// I/flutter ( 5664): 我是test同步方法,执行完毕了:Instance of 'Future<bool>'
// I/flutter ( 5664): 第一个测试完毕
// I/flutter ( 5664): 开启testAwait2异步方法
// I/flutter ( 5664): 我的异步任务执行完毕了--1000000000
// I/flutter ( 5664): 第二个测试完毕
// I/flutter ( 5664): 我是testAwait2异步方法方法,执行完毕了：true

看了这个结果应该知道怎么回事了吧，需要 await 的时候在声明 async函数，否则不但没有效果，还徒增代码

tips: 如果需要同时 await 多个函数或者网络请求，那么可以使用 Future.await(Future1, Future2, ...)

Future.wait([fun1(), fun2(), fun3()]).then((List resList) {
    print(resList); 
}).catchError((error) {
    print(error);
})

枚举

一般用在类型判断是使用，其能更好数字number类型，能友好的判断出类型的意义，提高代码可读性，且配合 switch 使用更方便，还能更好给出提示

//枚举
//调用，可以使用前面介绍的switch来实现不同情况，当然if else也可以
enum Level {
  firstLevel,
  secondLevel,
  thirdLevel,
  maxLevel
}

//枚举的使用
Level.firstLevel

类和对象

类是对象的抽象，对象是类的载体，可以理解为对象的模板规范，可以通过这个模板规范生产出相似的对象(不多解释，抽象的事情需要案例才能更好理解)

类的声明

声明一个类用 Class 关键字

//通过 class 关键字声明一个类，叫Person，为对人的部分抽象
class Person {
   String name = '';
   int age = 0;
   
   Person(this.name, this.age);
}
//通过 Person 定义出 张三和李四 两个人，这两个人(personA、personB)就是对象
var personA = Person("张三", 20);
var personB = Person("李四", 21);

属性

属性声明时，需要默认赋予初值，否则就设置为可选类型?，可选类型默认为 null

class Point {
  double x = 0;
  double y = 0;
  // double? x, y; //可以连续声明多个，也可以赋值
  // double x = 0, y = 0;
  final double z; //属性只能被赋值一次
}

构造函数

构造方法有多种创建方式，下面就一一介绍（注意构造方法只能有一个，命名式除外），而析构函数却没看到😂

注意： 如果不写构造方法，会有默认的无参构造方法(所以系统才要求所有参数必须有默认值，如果重写构造方法，那初值就一定必要了)

class Point {
  double x = 0;
  double y = 0;
  final double z; //属性只能被赋值一次

  一般构造方法这么写
  Point(double? x, doubel, y) {
    this.x = x;
    this.y = y;
  }

  //系统给了语法糖就可以这么简化了, 注意，构造方法不可以被重写，只能写自己的
  Point(this.x, this.y, this.z); //构造方法

  //赋值的时候，以这种方式可以给剩下的赋值
  Point(this.x, this.y): z = 20;

  //命名式构造方法
  //方式： [类名].[方法名]
  //如果构造方法不传参数，或者漏传，需要在后面加上:对剩下参数赋值，如下所示
  Point.origin(): x = 0, y = 0, z = 0;
  //相当于下面的
  Point.origin(this.x, this.y, this.z);

  //factory 工厂模式
  //先使用命名式构造方法，定义一个构造函数，用来赋值
  Point.internal(this.x, this.y): z = 0;
  //在使用默认的属性，来给默认的构造方法开启构造工厂
  factory Point(String key) {
    var pointList = pointMap[key];
    if (pointList == null) {
      return new Point.internal(0, 0);
    }
    return Point.internal(pointList[0], pointList[1]);
  }
}

各种类的的调用如下所示

void main() {
  var point0 = Point(0, 0, 0); //正常使用构造方法
  var point1 = Point.internal(10, 10); //命名式构造方法
  
  var point = Point("1010"); //调用工厂构造方法初始化
  point.printPoint(); //调用对象方法
  Point.sPrintPoint();//调用对象方法
}

静态方法

在一个类中声明静态方法，需要使用 static 关键字，这样该方法就可以通过类名调用了

注意: static 的方法中，this 不是指向类，因此static的不能使用this了

class Point {
  //声明一个函数，这里不多介绍
  printPoint() {
    print("point");
  }

  //可以理解为类方法，需要通过类名调用，但是也不像其他语言一样，其不能与对象方法同名
  static sPrintPoint() {
    //注意static方法不想像其他语言一样使用this调用同类型方法
    print("point");
    Point.sPrintPoint2(); //不能使用this.sPrintPoint2()
  }
  static sPrintPoint2() {}
}

重写运算符

通过重写运算符，可以让一个类具备和数字一样的运算

声明方式： Point operator 运算符符号 + 参数 + 实现

class Point {
  double x = 0;
  double y = 0;
  
  //重写运算符，可以传入操作符右侧变量
  Point operator +(Point value) => Point.origin(x + value.x, y + value.y);
  Point operator -(Point value) => Point.origin(x - value.x, y - value.y);
}

Setter和Getter

这里的 Setter、Getter与ios中的就大有不同了，ios是真的重写属性的Setter和Getter方法，这里的Setter 和 Getter 只是能像属性一样调用罢了

其一般用来根据当前属性，虚拟出新的属性，平时使用不是必要的（也可以搞出类似属性的单例）

定义通过 get set 关键字实现，如下所示

其只能以 set 和 get 修饰方法名，其能像方法属性一样赋值和获取，但不是重写已经声明的属性字段，也不能同名
var instance = Rectangle(1, 2, 3, 4);
class Rectangle {
  double left, top, width, height;

  //可以通过static静态方法，搞一个单例
  static Rectangle get shared => instance;

  //普通使用set 和 get，重写后调用方便 看情况使用
  //下面设置一个居右侧属性
  double get right => width + left;
  set right(double value) => left = value - width;
}

抽象方法(接口与实现)

抽象方法通过 abstract关键字修饰，其就是接口，通常作为接口实现成多个相似的类

一个类实现一个接口，通过 implements 关键字即可，实现多个接口通过,隔开

//抽象方法 abstract
//其无法创建实例,且内部定义的方法一定是抽象方法
abstract class AbstractClass {
  speak(); 
}
abstract class AbstractClass1 {
  talk();
}
//实现接口
//通过实现接口，可以给让不同的类实现统一调度功能，就像多态一样
class Children implements AbstractClass {
  @override
  speak() {
    print("嘤嘤嘤");
  }
}
class Person implements AbstractClass {
  @override
  speak() {
    print("我不止嘤嘤嘤，我还哈哈哈");
  }
}

通过将变量类型声明成接口类型，可以被遵循接口的类统一调度，如下所示

speakForAll(AbstractClass p) {
  p.speak();
}
testSpeak() {
  var chi = Children();
  var per = Person();
  speakForAll(chi);
  speakForAll(per);
}

继承

通过 extends 关键字，可以继承一个类，被继承的类被称为 父类、超类，继承者被称为子类、派生类

//class 内部也可以定义接口，只不过是通过继承重写的方式来实现
//因此通过继承定义的接口也被称为隐式接口
class ParentClass {
  ParentClass();

  void sayHello() {
    print("hello");
  }
}
//继承，采用 extends
class SubClass extends ParentClass {
  SubClass();

  @override
  void sayHello() {
    // super.sayHello(); //可以通过super调用父类方法
    print("我不会sayHello");
  }
}

父类型可以用来声明子类变量，这就是多态的一种

一个父类(超类)被继承后，生成多个种类，这也是多态，例如：定义一个动物类为父类，子类为牛、马、蛇、羊，这也是多态

//这就是多态的使用之一
test(ParentClass p) {
    p.sayHello();
}
var sub = SubClass();
test(sub)

//这也是多态，子类也被成为派生类
class Animal {
    speak() {
        print("我会说话");
    }
}
class Dog extends Animal {
    @override
    speak() {
        print("汪汪汪");
    }
}
class sheep extends Animal {
    @override
    speak() {
        print("咩咩咩");
    }
}

继承并实现抽象接口

继承和实现接口并不冲突，且接口能同时实现多个，通过,隔开，如下所示

//继承并实现抽象接口，可以同时实现多个抽象接口
class B extends A implements AbstractClass, AbstractClass1 {
  @override
  speak() {
    print("我不止嘤嘤嘤，我还哈哈哈");
  }
  
  @override
  talk() {
    print('我已经不只是会嘤嘤嘤，还会正常聊天了');
  }
}

类扩展 extension

能在原有类的基础上扩展出新的属性或者方法，扩展的父类，子类仍然能用，反之不能

使用方式： extension + 扩展名 + on + 被扩展类名

ps：可能有人觉得扩展名没有存在必要，实际扩展名可以作为标记名，将不同功能的扩展更好区分开，更利于阅读

extension Employee on SubClass {
  void work() {
    print("我能工作了");
  }
}
extension Sleep on ParentClass {
  void sleep() {
    print("我休息了");
  }
}

多继承 maxin

使用maxin修饰的父类，可以让继承者们同时继承实现多继承的效果

一般类只能extends一个父类，通过 with + maxin声明类，可以实现多继承，且 maxin 修饰的类只能使用with关键字继承

被多继承父类声明方式: maxin + 类名

继承时使用方式： class ... + with + maxin类(多个,隔开)

多继承的好处不少，可以多个小功能类拼接成一个大类使用，使用非常灵活(比起扩展来说)，缺陷也非常明显，太灵活了，代码不好控制，可读性下降

注意：其他的语言通过接口、协议、扩展等代替它(C++除外)，扩展与其类似，而扩展却是针对固定类的

//定义一个打游戏的类
mixin Player {
  bool canPlayWangzhe = false;
  bool canPlaychiji = false;

  playGames() {
    print('在这里,我是一名游戏玩家');
  }

//继承 A 的同时，继承了 Player，通过with可以继承多个,隔开
class maxinTestClass extends A with Player {
}

多继承类型约束

类型约束，即:maxin修饰的类被多继承时，只有继承了指定类，才能多继承他

声明被多继承父类方式: maxin + 类名 + on + 被约束到类名

//定义一个打游戏的类
mixin Player {
  bool canPlayWangzhe = false;
  bool canPlaychiji = false;

  playGames() {
    print('在这里,我是一名游戏玩家');
  }
}

//定义一个类，只能被继承B的类，多继承
mixin stu on B {
  study() {
    print('我是学生,要学习');
  }
}

//继承 A 的同时，继承了 Player，通过with可以继承多个
//继承了A，此时不能继承Stu
class maxinTestClass extends A with Player {
}

//继承多个，继承B的同时继承Stu，player
class maxinConstraintTest extends B with Player, stu {
}

泛型

泛型可以通过一个类型 name (一般用T，也可以根据指定场景起名)，可以泛指某一个设定的类型(用户传入的泛型类型)

示例：List集合，其可以设定一个指定类型，设定后，添加所有元素都只能是这个类型（这就使用泛型改装一个类）

var list = <int>[];//这个<int>，括号里面的就是泛型，也可以点进去查看,int就是用户传入的泛型类型

使用泛型改装类

在类名后面加上一个<T>的形式，可以指定一个泛型，通过该泛型，可以用来统一参数类型

//下面定义一个栈，定义泛型(命名为T)，用来代替里面存放节点的类型
class Stack<T> {
  List<T> container = [];
  //传入 T 类型的参数
  push(T element) {
    container.add(element);
  }
}

调用如下，一个传入了String 类型，即 T 为 String，另一个传入了 int， 即 T 为 int

var stack = Stack<String>();
stack.push("哈哈");
var stack2 = Stack<int>();
stack2.push(2);

使用泛型改装函数

在开发中，可能会封装一个支持多种类型的处理方法，例如：往一个集合塞东西，交换两个参数内容等等

//可能会封装一个，支持多个类型的处理方法
//单纯的使用一个泛型方法,其类型约束也是extends
class handlerClass {
  static pushByList<T>(List<T> list, T object) {
    list.add(object);
    //debug可以打印了运行时的实际类型字符串
    // print(object.runtimeType.toString());
  }
}

泛型约束

通过 extends 来约束一个泛型，因此也可以理解为，此泛型继承某个类、接口

//如果想 像多继承一样限制泛型可以使用的类型怎么办
//如下所示，使用 extends 来限制类型为 int 或者为其子类
class StrStack<T extends String> {
  List<T> container = [];
  //传入 T 类型的参数
  push(T element) {
    container.add(element);
  }
}

//泛型约束定义一个函数
class handlerClass {
  static pushByList<T extends String>(List<T> list, T str) {
    list.add(str);
  }
}

调用方法如下所示

var stack = StrStack<String>();
stack.push("哈哈");
// var stack2 = StrStack<int>();这个就报错了，函数也是一个样子

var list = <String>[];
handlerClass.pushByList(list, "哈哈哈");

最后

跟着这篇文章，自己又学习扩展了一次，收益匪浅，也算是一份常用内容记录，如果又看到了，跟着走一遍，相信也会有所收获，至少对 dart 不在陌生不是 😂