Mr.Zhang
Articles
10
Tags
10
Categories
3
首页
历程
标签
分类
友链
关于我
Dart and Flutter学习之旅
|前端
Word count: 3.5k|Reading time: 13 min|Post View:

sss

sss

好长时间没有写博客了，一直处于学习状态吧。最近的Google 大会后，Flutter再次升级。在国内吵的大火，可以一套代码适配IOS端和Android 端，它还出了 Flutter-for-web ， 可以一段代码3个端，目前这个阶段还不成熟吧，坑特别多。身为前端的我，也好奇的投入其中。由于Flutter的语言是基于Dart开发，而Flutter是构建UI 视图的，Dart是实现逻辑，它的开发方式和原生Android 开发很相似， 原生安卓的开发方式是：XML 写UI 布局，Java是写逻辑。 但是经过这几天折腾，简单的了解了Flutter 开发，它写UI 的方式还是适应不了，没有前端HTML+CSS 写的爽。Flutter 写UI 的方式 都是通过一个对象，然后往这个对象添加所需要的属性，最后 放到一个Weiget的body中。如果Weight组件多的话，它就需要单独成立一个模块，最后在主文件中，导入即可，然后放到 runApp( 组件中) ， 这个 组件中 里包括了刚刚 import 导入的Weiget， 从而就形成了一个App。

现在先放弃学Flutter吧。目前，我觉得应更好的掌握Vue 结合UI 框架的开发 能达到处理基本业务的条件，英语一直推，一直想学，总有很多事，英语很重要。

最近几天，不知道怎么了，特别的焦虑，其实你已经很努力了，已经在同龄人中算强的了。不要老是觉得自己不行，不要一遇到你没遇到问题而感觉自卑，你应该 了解的其原理 ，也不一定要会，不要常常待在自己的圈子，多交流，问题就不是问题了。 我是很少做梦的，这几天一直做梦而且做的编程的梦，我是怎么了？

最近也学习了很多知识，Github的使用，写完一个小项目 ， 你没必要慌，你更应该的沉淀下来分析自己的不足，也不要给自己的太大的压力。

前几天，看视频听到 姬诚老师的一些指点：

  • 人性面对压力，很难产生动力，多了解自己，别给自己留太多压力，人生没有压力，才会发挥出更好的创造力。
  • 注意身体，保持运动
  • 读书是一种认知的拓展，视野更大

就到此为止吧，继续学习，只有学习才不会被社会抛弃吧！

Function 优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#优化前：
eat(){
  return '吃炸薯条';
}
# 优化后
eat() => '吃炸薯条';


----------------------------------------------------------------------------------
# 优化前
play(){
  print('我正在玩游戏');
}

#优化后
play() => print('我正在玩游戏');

Function可填参数[ ]，判断显示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void main() {
  var name = "员工";
  sayPersonal('张', '三');
}
sayPersonal(String firstName, String lastName, [ String adress]) {
  if(adress == null){
    print('$firstName$lastName不想告诉我家的地址');
  }else{
    print('$firstName$lastName家的地址是$adress');
  }
}



# 如果有多个可选参数的话， 放在一个 [] 里
  sayPersonal(String firstName, String lastName, [ String adress， ine phone]) {}

Function 命名参数 { }, 在使用要明确参数名

1
2
3
4
5
6
7
8
sayPhone(String name,{int phone}){
  print('$name的手机号是$phone');
}

void main() {
 
  sayPhone('张三',phone: 1325190062);
}

List 使用创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
1.创建
    List list1 = new List();
    List list1 = [];
2.常用方法
    add			增加
    addall		拼接数组
    indexOf		传入指定索引值
    remove		传入指定索引值
    removeAt     传入指定索引值
    fillRange    修改
    insert(index,value)
    insertAll(index,list)   
    join    List转化成字符串
   	split   字符串转化成List

Set 集合去重，不能添加重复数据

1
2
3
4
5
6
void main() {
  List list1 = ['张三', '李四', '张三', '李四', '张三', '李四'];
  var dd = new Set();
  dd.addAll(list1);
  print(dd.toList());
}

Map映射无序键值对 使用创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1.创建
   Map first = {
    "name": '张三', "age": 22
  };

  var  second = new Map();
  second['name'] = '李四';  添加数据


 2.常用属性：
      keys			获取keys值
      values		获取所有的value值
      isEmpty		是否为空
      isNotEmpty	是否不为空
      
3. 常用方法
      remove		移除key
      containsValue  判断是否有该键的值

Map Set List循环的使用

1
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
 List arr = ['张1', '张2', '张3', '张4'];
1.第一种 for
  for (var i = 0; i < arr.length; i++) {
    print(arr[i]);
  }
  Map newArr = {
    "name":"张三"
  }；
2.第二种 for in
  for (var item in arr) {
      print(item);
  
3.第三种  list或map .forEach
  newArr.forEach((key,value){
    print(key+value);
  });
      
4.第四种   List 或Map. map 
  List four = [1,2,3];
  var newFour = four.map((value){
    return value*2;
  });
  print(newFour);
      
5.第五种   where 循环，返回满足条件的 
  List five = [1,3,55,44,22,66,777];
  var newFive = five.where((value){
    return value>55;
  });
  print(newFive);
      
6.第六种  any 判断集合种有满足条件的吗，只要有一项满足就返回 true 则false
 List six = [22,11,33,44,55,566];
  var boo = six.any((value){
    return value>33;
  });
  print(boo);
      
7. 第七种  every 判断集合种有满足条件的吗，只要有一项不满足就返回 false 则true
 List seven = [22,11,33,44,55,566];
  var boo = seven.every((value){
    return value>33;
  });
  print(boo);

闭包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1.全局变量特点：
    全局变量常驻内存，全局变量污染全局
2.局部变量特点：
    不常驻内存，会被垃圾机制回收，不会污染全局
    
3.闭包主要解决：
    不污染全局,常驻内存
    
4.代码：
void main(){
  text(){
    var num = 11;  //不会污染全局, 常驻内存
    jia(){
      num++;
      print(num);
    }
    return jia();
  }
  text();
}

类的创建 构造函数 命名构造函数

1
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
###需要注意：
    1.默认构造函数只能有一个，命名构造函数可以有多个；
    2.命名构造函数使用  类 实例化名 = 类.命名构造函数命名
    
    
    
class Animal{
  String name;
  String eat;
  // 默认构造函数 实例化会调用默认构造函数
  Animal(this.name,this.eat){
     print("输出$name    最喜欢吃的事物$eat");
  }

  Animal.sayMessage(name,eat){
    print("输出$name    最喜欢吃的事物$eat");
  }
  Animal.saySkill(name){
    print('$name的技能是拆家');
  }
}

void main(){
  // Animal dog = new Animal.sayMessage('哈士奇', '喜欢吃骨头');
  // Animal dog = new Animal('哈士奇', '喜欢吃骨头');
  Animal dog = new Animal.saySkill('哈士奇');
}

将类抽离成一个模块，在需要文件内通过 import 导入

例如将这个单独抽离成一个文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Animal.dart

class Animal{
  String name;
  String eat;
  // 默认构造函数 实例化会调用默认构造函数
  Animal(this.name,this.eat){
     print("输出$name    最喜欢吃的事物$eat");
  }

  Animal.sayMessage(name,eat){
    print("输出$name    最喜欢吃的事物$eat");
  }
  Animal.saySkill(name){
    print('$name的技能是拆家');
  }
}
导入该文件
1
2
3
4
5
6
7
8
9
main.dart
	import '文件路径'
    // 在dart中开始路径不需要 ./ ，直接文件路径
 
void main(){
  // Animal dog = new Animal.sayMessage('哈士奇', '喜欢吃骨头');
  // Animal dog = new Animal('哈士奇', '喜欢吃骨头');
  Animal dog = new Animal.saySkill('哈士奇');
}

私有属性创建 访问

1
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
## 定义属性通过 _ 这个符号加在属性或方法前，就成为私有属性或私有方法
    
    
 Animal.dart
    
class Animal{
  String name;
  String eat;
  // 私有属性
  int _age;
  // 默认构造函数 实例化会调用默认构造函数
  Animal(this.name,this.eat,this._age){
     print("输出$name    最喜欢吃的事物$eat");
  }
  // 间接的通过this实例 获取私有属性
  getAge(){
    print(this._age);
  }
  // 私有方法
  void _sayKind(){
    print('我是私有方法');
  }
  // 通过this 实例获取私有属性方法
  getKind(){
    this._sayKind();
  }
    
    
    
    
Cat.dart
   
   //导入该文件
  import 'Animal.dart';

    void main() {
      Animal cat = new Animal('小菜', '🐟',22);
      // 访问私有属性和私有方法
      cat.getAge();
      cat.getKind();
    }

setter getter 使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class People{
  String name;
  int age;
  // set 只能传递一个参数
  set stName(value){
    this.name = value;
  }
  // get 定义时不需要加（）
  get personal{
    print('你的姓名是'+this.name);
  }
}

void main(){
People xiaoMing = new People();
//调用的时候，相当于调属性
xiaoMing.stName = '小明';
xiaoMing.personal;
}

类初始化列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 在实例化之前做的事情---------相当于一些属性的默认值
class Cat{
  String name;
//  使用方法  类():传递属性的默认值
  Cat():name = '咖啡猫'{
    print("猫的姓名是$name");
  }
  
}


void main(List<String> args) {
  Cat samll = new Cat();
}

类的静态成员

  • 非静态方法可以访问非静态成员也可以访问静态成员
  • 静态方法可以访问静态成员，但不可以访问非静态成员
  • 静态方法还可以通过类直接调用，但是不能通过实例调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Book{
  static String name = '张三';
  int age;
  getMsg(){
    print(name);
  }
  static getNews(){
    //print(this.age)   在静态方法中，不可以访问非静态成员
  }
  static getName(){
    //在静态方法中可以，可以访问静态成员
    print(name);      
    getNews();
  }
  void getAge(){
    //在静态方法中，可以访问静态成员和非静态成员
    // 非静态属性
    print(this.age); 
    // 静态属性和方法
    print(name);
    getNews();
  }
}

常用操作符

  • ? 条件运算符
  • as 强制类型转换———————-用于继承 多态
  • is 类型判断
  • .. 级联操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Dog{
  String name;
  int strong;
  Dog(this.name,this.strong);
}

class Cat{
  String name;
  int strong;
  Cat(this.name,this.strong);
}

void main() {

  Dog erha = new Dog('二哈', 200);
  print(erha is Dog);
  // 级联操作  可以给对象同时赋值多个属性和方法
  erha..name = '虎虎'
      ..strong = 222;
  print("名字为${erha.name}体重为${erha.strong}");
}

类中的继承

  • 子类通过extends实现继承父类
  • 子类继承父类的属性和方法，但不会继承构造函数
  • 子类可以重写父类的方法 setter 和 getter
  • 子类继承父类，必须实现继承构造函数 或 命名的构造函数
  • 子类调用父类的方法 super.父类的方法名
  • 子类覆写父类的方法时， 方法上方加上 @override 标志
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    例如
    class A{
       	String name;
        String sex;
        //普通的构造函数
        A(this.name);
        //命名的构造函数
        A.sayMsg(this.sex)
    }
    class B extends A{
        num age;
        //实现普通的构造函数继承
        B(String name,num age): super(name){
            this.age = age;
        }
        //实现命名的构造函数继承
        B(String sex,num age): super.sayMsg(sex){
            this.age = age;
        }
    }

抽象类

  • 抽象类不可以被实例化
  • 抽象类的定义的方法，子类必须实现抽象方法，
  • 抽象类中也可以定义非抽象方法
  • 抽象类的主要作用： 定义标准
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    abstract class Animal{
      String name;
       eat(){}  // 抽象方法
        // 公共的方法
       sayMsg(){
         print('我是抽象类中的普通方法');
       }
    }
    class Dog extends Animal{
      // 必须实现抽象方法 eat
      @override
        eat() {
          print('小狗在吃骨头');
        }
    }

    void main(){
      Dog erha = new Dog();
      erha.eat();
      erha.sayMsg();
      // Animal ss = new  Animal();  抽象类不可实例化
    }

多态

  • 通过 父类 实例名 = new 子类 ， 可以达到多态效果
  • 多态是 父类定义好方法不去实现， 子类继承父类，每个子类都有不同的效果
    1
    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
    class Animal{
      String name;
      int age;
      Animal(this.name,this.age);
      eat(){}
    }
    class Dog extends Animal{
      Dog(String name,int age): super(name,age);
      eat(){
        print('${this.name}吃骨头');
      }
      run(){
        print('${this.name}跑的快');
      }
    }
    class Cat extends Animal{
      Cat(String name,int age): super(name,age);
      eat(){
        print('${this.name}吃🐟');
      }
    }

    void main(){
      Animal d = new Dog('哈士奇',22);
      Animal s = new Cat('咖啡猫2', 11);
      d.eat();
       // 应为改变了指针的引用，子类不能使用自己的属性和方法
      s.eat();
      

    }

接口

  • 子类通过 implements 抽象类定义的接口规定
1
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
abstract class Db{
  kill(){}
}
class Mysql implements Db{
  String name;
  Mysql(String name){
    this.name = name;
  }
  @override
    kill() {
      print('我是${this.name}数据库');
    }
}
class Mongodb implements Db{
  String name;
  Mongodb(String name);
  @override
    kill() {
      print('我是${this.name}数据库');
    }
}


void main(){
  Mysql ddd = new Mysql('mysql');
  ddd.kill();
}

extends 和 implements 区别

  • 如果要覆用 抽象类的方法， 并且用抽象类来约束该类的话就 选用 extends 。 简化 子类覆用父类内容，就选用 extends
  • 如果只是把抽象类当作标准的话，就选用implements

一个类可以实现多个接口

1
2
class A implements B,C,D
// 那么它必须实现 B C D 中的 所有 抽象方法 和 抽象属性

mixins 类的使用

  • mixins 是在类中混入其他的功能， 类似于 多继承
  • 使用 mixins 的条件
    • 1.mixins 的类只能继承自 Object类,不能继承其他类。
    • 2.mixins 类不能有构造函数
    • 3.一个类可以有多个 mixins类 width A,B,C….
    • 4.mixins 类不是继承，也不是接口，是一种新特性
1
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
class A{
  void say(){
    print('我是A');
  }
}
class B{
  void say(){
    print('我是A');
  }
  play(){
    print('我能跑');
  }
}
class People{
  String name;
  People(String name){
    this.name = name;
  }
}
class C extends People with A,B{
  C(String name): super(name);
}



void main(){
  C s = new C('张三');
  // 实例化对象调用的方法或属性，mixins类都有的话,会按with先后走，后面覆盖前面的
  s.say(); 
  print(s.name);
}

第三方库的使用

  • 第三方下载库网址 https://pub.dev/packages
  • 如何使用第三方库呢
    • 1.创建一个 pubspec.yaml 文件
    • 2.内容为，内容都为英文，中文的话会报错
      • name: some
      • description: miaoshu
      • dependencies: 依赖
    • 3。在需要文件内引入该模块

自定义库的按须引入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
'引入内容.dart'

void send(){
  print('我是发送内容');
}
void play(){
  print('我会完游戏');
}


'库的按须引入.dart' 
 '在导入的模块后，使用show的作用是只能使用模块的具体的功能'
 '在导入的模块后，使用hide的作用是不能使用模块的具体的功能'
 import '引入内容.dart' show play;
void main(){
  play();
  // send()      它就不能使用，应为 只引用了 play
}
 import '引入内容.dart' hide play;
void main(){
  //play();它就不能使用，应为 隐藏了 play
  send()；     
}
Author: Small Xin
Link: http://yoursite.com/2019/05/26/Dart/
Copyright Notice: All articles in this blog are licensed under CC BY-NC-SA 4.0 unless stating additionally.
Dart ,Flutter
Donate
  • 微信
  • 支付寶
繁
Catalog
  1. 1. Function 优化
  2. 2. Function可填参数[ ]，判断显示
  3. 3. Function 命名参数 { }, 在使用要明确参数名
  4. 4. List 使用创建
  5. 5. Set 集合去重，不能添加重复数据
  6. 6. Map映射无序键值对 使用创建
  7. 7. Map Set List循环的使用
  8. 8. 闭包
  9. 9. 类的创建 构造函数 命名构造函数
  10. 10. 将类抽离成一个模块，在需要文件内通过 import 导入
    1. 10.1. 例如将这个单独抽离成一个文件
    2. 10.2. 导入该文件
  11. 11. 私有属性创建 访问
  12. 12. setter getter 使用
  13. 13. 类初始化列表
  14. 14. 类的静态成员
    1. 14.1. 非静态方法可以访问非静态成员也可以访问静态成员
    2. 14.2. 静态方法可以访问静态成员，但不可以访问非静态成员
    3. 14.3. 静态方法还可以通过类直接调用，但是不能通过实例调用
  15. 15. 常用操作符
    1. 15.1. ? 条件运算符
    2. 15.2. as 强制类型转换———————-用于继承 多态
    3. 15.3. is 类型判断
    4. 15.4. .. 级联操作
  16. 16. 类中的继承
    1. 16.1. 子类通过extends实现继承父类
    2. 16.2. 子类继承父类的属性和方法，但不会继承构造函数
    3. 16.3. 子类可以重写父类的方法 setter 和 getter
    4. 16.4. 子类继承父类，必须实现继承构造函数 或 命名的构造函数
    5. 16.5. 子类调用父类的方法 super.父类的方法名
    6. 16.6. 子类覆写父类的方法时， 方法上方加上 @override 标志
  17. 17. 抽象类
    1. 17.1. 抽象类不可以被实例化
    2. 17.2. 抽象类的定义的方法，子类必须实现抽象方法，
    3. 17.3. 抽象类中也可以定义非抽象方法
    4. 17.4. 抽象类的主要作用： 定义标准
  18. 18. 多态
    1. 18.1. 通过 父类 实例名 = new 子类 ， 可以达到多态效果
    2. 18.2. 多态是 父类定义好方法不去实现， 子类继承父类，每个子类都有不同的效果
  19. 19. 接口
    1. 19.1. 子类通过 implements 抽象类定义的接口规定
  20. 20. extends 和 implements 区别
    1. 20.1. 如果要覆用 抽象类的方法， 并且用抽象类来约束该类的话就 选用 extends 。 简化 子类覆用父类内容，就选用 extends
    2. 20.2. 如果只是把抽象类当作标准的话，就选用implements
  21. 21. 一个类可以实现多个接口
  22. 22. mixins 类的使用
    1. 22.1. mixins 是在类中混入其他的功能， 类似于 多继承
    2. 22.2. 使用 mixins 的条件
  23. 23. 第三方库的使用
    1. 23.1. 第三方下载库网址 https://pub.dev/packages
    2. 23.2. 如何使用第三方库呢
      1. 23.2.1. 1.创建一个 pubspec.yaml 文件
      2. 23.2.2. 2.内容为，内容都为英文，中文的话会报错
      3. 23.2.3. 3。在需要文件内引入该模块
  24. 24. 自定义库的按须引入