释放双眼，带上耳机，听听看~！
1.标准构造函数,可选参数,默认参数,初始化列表,命名构造函数,工厂构造函数,命名工厂构造函数,get,set,静态方法,抽象方法,抽象类
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
2class Person {
3 String name;
4 int age;
5 Person(this.name, this.age); //标准构造方法
6
7 @override
8 String toString() {
9 // 重写了父级的toString的方法
10 return "name:$name,age:age";
11 }
12}
13
14class Student extends Person {
15 String _school; //_表示是私有变量
16 String city; //城市
17 String country; //国家
18 String name;
19
20 //如果继承的父类没有默认构造方法(无参数的)，就要调用父类的构造方法
21 //:后面的表示式就是初始化列表
22 //this._school初始化自由参数
23 //name,age交由父级初始化
24 //{}里面的就是可选参数，或者用[]
25 //=就是默认参数
26 //初始化列表多个表示式的时候，用,隔开
27 //构造方法有方法体的，用{}
28 //这个事标准构造方法
29 Student(this._school, name, int age, {this.city, this.country = '中国'})
30 : name = "$country-$city",
31 super(name, age) {
32 print("构造方法体不是必须的");
33 }
34
35 //命名构造方法 [类名+.+方法名]
36 //可以多个，但是标准构造方法只能一个
37 //也可以有方法体
38 Student.per(Student stu) : super(stu.name, stu.age);
39
40 //命名工厂构造方法: factory [类名+.+方法名]
41 //这种形式不需要把final的变量作为参数，比较灵活
42 //如果事上面的模式，有final的变量，必须要初始化
43 factory Student.fac(String school, String name, int age) {
44 return Student(school, name, age);
45 }
46
47 //_school是私有属性，外部访问要公有
48 //可以直接实例化的per.school访问
49 String get school=>_school;
50
51 //设置的时候，控制修改
52 //实例化per.school="123";赋值的时候会调用
53 set school(String val){
54 _school=val;
55 }
56
57 //静态方法 方法前加static
58 //调用的时候是用[类.方法名]
59 static doPrint(String str){
60 print("doPring$str");
61 }
62}
63
64//工厂构造方法
65//也可以理解为单例模式
66class Logger {
67 static Logger _logger;
68
69 Logger._create();
70
71 factory Logger() {
72 if (_logger == null) {
73 _logger = Logger._create(); //实例化一般用私有的命名构造方法实现
74 }
75 return _logger;
76 }
77}
78
79//抽象类和抽象方法(没有实现的方法)
80//抽象类里面不一定一定要有抽象方法，但是有抽象方法的类必须是抽象类
81//继承抽象类，必须实现抽象方法
82abstract class Study{
83 void flutterStydy();
84}
85
86class FlutterStudy extends Study{
87 @override
88 //实现抽象方法
89 void flutterStydy() {
90 print("flutterStydy");
91 }
92
93}
94
final变量没有初始化的错误：
2.mixins 用with连接词
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2//with 后面添加名字，多个用 ，分割
3//只能继承自Object字类，不能有构造函数，不能调用super
4//下面就是一个mixins,可以类，也可以抽象类
5abstract class Studys{
6 void flutterStydy();
7}
8
9class Member extends Person with Studys{
10
11 Member(String name, int age) : super(name, age); //这是继承实现父级构造函数
12
13 //这个是mixins的复用Studys的特性(必须实现抽象类的方法)
14 //mixins就是继承类的特性
15 @override
16 void flutterStydy() {
17 // TODO: implement flutterStydy
18 }
19
20}
21
3.泛型
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2//提高复用性
3//T可以实任意类型
4
5class Cache<T> {
6
7 static final Map<String, Object> _cache = Map();
8
9 T getItem(String key){
10 return _cache[key];
11 }
12
13 void setItem(String key, T value){
14 _cache[key]=value;
15 }
16}
17
18class TestCache{
19 void start(){
20 Cache<String> c1= Cache();
21 Cache<int> c2=Cache();
22 c1.setItem("name", "张三"); //值只能是String
23 c2.setItem("age", 18); //值只能是int
24 }
25}
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
2
3class GenericMember<T extends Person> {
4 T _person;
5
6 GenericMember(this._person);
7
8 String getName() {
9 return "Name is ${_person.name}";
10 }
11}
12
13class TestGenericMember {
14 void start() {
15 //Student是Person的子类，参考下面
16 GenericMember<Student> gm = GenericMember(Student("学校", "名字", 18));
17 print(gm.getName()); //Name is 名字
18 }
19}
20
21//参考：
22//所有的类都继承自Object
23class Person {
24 String name;
25 int age;
26 Person(this.name, this.age); //标准构造方法
27
28 @override
29 String toString() {
30 // 重写了父级的toString的方法
31 return "name:$name,age:age";
32 }
33}
34
35class Student extends Person {
36 String _school; //_表示是私有变量
37 String city; //城市
38 String country; //国家
39 String name;
40
41 //如果继承的父类没有默认构造方法(无参数的)，就要调用父类的构造方法
42 //:后面的表示式就是初始化列表
43 //this._school初始化自由参数
44 //name,age交由父级初始化
45 //{}里面的就是可选参数，或者用[]
46 //=就是默认参数
47 //初始化列表多个表示式的时候，用,隔开
48 //构造方法有方法体的，用{}
49 //这个事标准构造方法
50 Student(this._school, name, int age, {this.city, this.country = '中国'})
51 : name = "$country-$city",
52 super(name, age) {
53 print("构造方法体不是必须的");
54 }
55
56 //命名构造方法 [类名+.+方法名]
57 //可以多个，但是标准构造方法只能一个
58 //也可以有方法体
59 Student.per(Student stu) : super(stu.name, stu.age);
60
61 //命名工厂构造方法: factory [类名+.+方法名]
62 //这种形式不需要把final的变量作为参数，比较灵活
63 //如果事上面的模式，有final的变量，必须要初始化
64 factory Student.fac(String school, String name, int age) {
65 return Student(school, name, age);
66 }
67
68 //_school是私有属性，外部访问要公有
69 //可以直接实例化的per.school访问
70 String get school => _school;
71
72 //设置的时候，控制修改
73 //实例化per.school="123";赋值的时候会调用
74 set school(String val) {
75 _school = val;
76 }
77
78 //静态方法 方法前加static
79 //调用的时候是用[类.方法名]
80 static doPrint(String str) {
81 print("doPring$str");
82 }
83}
84
4.dart编程小技巧
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
2//封装要大到类型的封装，类的封装和抽象，小到方法的封装
3//封装目的在于提高复用性和可维护性
4//不要在一个方法体里面写太多代码，小于100行
5//点点点习惯，1.点看类有哪些属性和方法 2.点看源码 3.点看源码里面的其他的引用，看究竟
6void skill(){
7 // 1.安全的调用 ?.
8 List list; //这个list不确定是否存在，你直接调用list.length就会抛异常
9 print(list?.length); //这样就不会报错，存在才会访问length
10
11 // 2.设置默认值
12 print(list?.length??-1); //list不存在的时候，获取的是-1，存在就取list.length
13
14 //条件判断0,'',null
15 list.addAll([0,'',null]);
16
17 //这样固然可以，但是太冗余
18 if(list[0] == null || list[0] == 0 || list[0] == ''){
19 print('list[0] is empty ');
20 }
21
22 //这样就简洁多了，多个也方便添加
23 if([null,0,''].contains(list[0])){
24 print('list[0] is empty ');
25 }
26
27}
28
也可以参考dart的最佳实践 http://dart.goodev.org/guides/language/effective-dart/usage\#section
