【Flutter】Dart篇之三

我就是我 2024-04-26 02:04 9阅读 0赞

> 🔥 本文由 [程序喵正在路上][Link 1] 原创，CSDN首发！  
> 💖 系列专栏：[Flutter学习][Flutter]  
> 🌠 首发时间：2024年4月23日  
> 🦋 欢迎关注🖱点赞👍收藏🌟留言🐾

#### 目录 ####

*  类
 *   *  静态成员
     *  操作符
     *  类的继承
     *  抽象类
     *  多态
     *  接口
     *  多接口的实现
     *  mixins
 *  泛型
 *   *  泛型方法
     *  泛型类
     *  泛型接口

## 类 ##

*  面向对象编程 (OOP) 的三个基本特征是：封装、继承、多态
    
     *  封装：封装是对象和类概念的主要特性。封装，把客观事物封装成抽象的类，并且把自己的部分属性和方法提供给其他对象调用，而一部分属性和方法则隐藏
     *  继承：面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的功能，并在无需重新编写原来的类的情况下对这些功能进行扩展
     *  多态：允许将子类类型的指针赋值给父类类型的指针，同一个函数调用会有不同的执行效果
 *  Dart 中所有的东西都是对象，所有的对象都继承自 Object 类。
 *  Dart 是一门使用类和单继承的面向对象语言，所有的对象都是类的实例，并且所有的类都是 Object 的子类
 *  一个类通常由属性和方法组成
 *  Dart和其他面向对象语言不一样，Data中没有 public private protected这些访问修饰符合，但是我们可以在一个属性或方法前面加上 “`_`” 将其定义成私有

关于类的定义，没什么好讲的，主要注意以下几点：

*  将类定义在一个单独的文件中，私有属性和方法才会生效
 *  get 和 set 方法的书写
 *  类的初始化列表（不怎么用到，但要知道）

// 注意：最新版本的dart中需要初始化不可为null的实例字段，如果不初始化的话需要在属性前面加上late
    class Person {
        
      late String _name; //私有属性
      late int _age;
    
      //默认构造函数, 只能有一个
      // Person(String name,int age){
        
      //     this.name=name;
      //     this.age=age;
      // }
    
      //默认构造函数的简写
      Person(this._name, this._age);
    
      //命名构造函数, 可以有多个
      Person.now() {
        
        print('我是命名构造函数');
      }
    
      //命名构造函数
      Person.setInfo(String name, int age) {
        
        this._name = name;
        this._age = age;
      }
    
      //get方法
      get getName {
        
        return this._name;
      }
    
      get getAge {
        
        return this._age;
      }
    
      //set方法
      set setName(String name) {
        
        this._name = name;
      }
    
      set setAge(int age) {
        
        this._age = age;
      }
    
      //普通方法
      void printInfo() {
        
        print("${
          this._name}----${
          this._age}");
      }
    }

import 'lib/Person.dart'; //导入类
    
    void main() {
        
      Person p1 = new Person.setInfo('李四', 30);
      p1.printInfo();
      print("${
          p1.getName}==>${
          p1.getAge}");
      print("--------------");
    
      // p1._name; //无法访问私有属性
      p1.setName = '小明';
      p1.setAge = 18;
      print("${
          p1.getName}==>${
          p1.getAge}");
    }

![在这里插入图片描述][6c3da0eb8b3b472198238fa34c6c0364.png]

类的初始化列表：

// Dart中我们也可以在构造函数体运行之前初始化实例变量
    class Rect {
        
      int height;
      int width;
      Rect()
          : height = 2,
            width = 10 {
        
        print("${
          this.height}---${
          this.width}");
      }
      getArea() {
        
        return this.height * this.width;
      }
    }
    
    void main() {
        
      Rect r = new Rect();
      print(r.getArea());
    }

![在这里插入图片描述][ac907dcde0434522aead1af969facc2c.png]

### 静态成员 ###

Dart中的静态成员:

1.  使用 **static** 关键字来实现类级别的变量和函数
2.  静态方法不能访问非静态成员，非静态方法可以访问静态成员

class Person {
        
      static String name = '张三'; //静态属性
      int age = 20;
    
      //静态方法
      static void show() {
        
        print(name);
      }
    
      void printInfo() {
        
        /*非静态方法可以访问静态成员以及非静态成员*/
        print(name); //访问静态属性
        print(this.age); //访问非静态属性
        show(); //调用静态方法
      }
    
      //静态方法
      static void printUserInfo() {
        
        /*静态方法只能访问静态成员 */
        print(name); //静态属性
        show(); //静态方法
      }
    }
    
    main() {
        
      //静态成员可以直接直接访问
      print(Person.name);
      Person.show();
      print("-------------");
    
      //非静态成员必须创建对象才能访问
      Person p = new Person();
      p.printInfo();
    }

![在这里插入图片描述][f1f802dc8cc94240b604883d716fc062.png]

### 操作符 ###

Dart中的对象操作符:

*  `as`：用于类型转换（了解）
 *  `is`：用于类型判断（了解）
 *  `..`：用于级联操作 （连缀） (常用)

class Person {
        
      String name;
      num age;
      Person(this.name, this.age);
      void printInfo() {
        
        print("${
          this.name}---${
          this.age}");
      }
    }
    
    main() {
        
      //is
      Person p = new Person('张三', 20);
      if (p is Person) {
        
        p.name = "李四";
      }
      p.printInfo();
      print("-----------");
    
      //as
      var p1;
      p1 = '';
      p1 = new Person('张三1', 20);
      p1.printInfo(); //在最新版的dart可以直接访问
      (p1 as Person).printInfo(); //以前需要用as来类型转换
      print("-----------");
    
      //普通写法
      Person p2 = new Person('张三1', 20);
      p2.printInfo();
      p2.name = '张三222';
      p2.age = 40;
      p2.printInfo();
      print("-----------");
    
      //级联操作
      Person p3 = new Person('张三1', 20);
      p3.printInfo();
      p3
        ..name = "李四"
        ..age = 30
        ..printInfo();
    }

![在这里插入图片描述][4f4b133b848744448eed2fad3e6ac079.png]

### 类的继承 ###

Dart中的类的继承：

1.  子类使用 `extends` 关键词来继承父类
2.  子类会继承父类里面可见的属性和方法，但是不会继承构造函数
3.  子类能复写父类的方法，也可以有自己的方法
4.  子类能用 `super` 关键字调用父类中的方法

注意:最新版本的 dart 中需要初始化不可为 null 的实例字段，如果不初始化的话需要在属性前面加上 `late`

class Person {
        
      String name;
      num age;
    
      Person(this.name, this.age);
    
      void printInfo() {
        
        print("${
          this.name}---${
          this.age}");
      }
    
      work() {
        
        print("${
          this.name}在工作...");
      }
    }
    
    class Web extends Person {
        
      //super也可以调用父类的命名构造函数
      Web(String name, num age) : super(name, age);
    
      //子类自己的方法
      run() {
        
        print('run');
        super.work(); //子类调用父类的方法
      }
    
      //覆写父类的方法
      @override //可以写也可以不写  建议在覆写父类方法的时候加上 @override
      void printInfo() {
        
        print("姓名：${
          this.name}---年龄：${
          this.age}");
      }
    }
    
    main() {
        
      Web w = new Web('李四', 20);
      w.printInfo();
      w.run();
    }

![在这里插入图片描述][7fa618b8594d4901894c7c3714086068.png]

### 抽象类 ###

Dart中的抽象类主要用于定义标准，子类可以继承抽象类，也可以实现抽象类接口。

1.  抽象类通过 `abstract` 关键字来定义
2.  Dart中的抽象方法不能用 `abstract` 声明，Dart中没有方法体的方法我们称为抽象方法
3.  如果子类继承抽象类，必须得实现里面的抽象方法
4.  如果把抽象类当做接口实现的话，必须得实现抽象类里面定义的所有属性和方法
5.  抽象类不能被实例化，只有继承它的子类可以

`extends` 抽象类和 `implements` 的区别：

1.  如果要复用抽象类里面的方法，并且要用抽象方法约束自类的话我们就用 `extends` 继承抽象类
2.  如果只是把抽象类当做标准的话，我们就用 `implements` 实现抽象类

//案例：定义一个Animal 类要求它的子类必须包含eat方法
    abstract class Animal {
        
      eat(); //抽象方法
      run(); //抽象方法
      printInfo() {
        
        print('我是一个抽象类里面的普通方法');
      }
    }
    
    class Dog extends Animal {
        
      @override
      eat() {
        
        print('小狗在吃骨头');
      }
    
      @override
      run() {
        
        print('小狗在跑');
      }
    }
    
    class Cat extends Animal {
        
      @override
      eat() {
        
        print('小猫在吃老鼠');
      }
    
      @override
      run() {
        
        print('小猫在跑');
      }
    }
    
    main() {
        
      Dog d = new Dog();
      d.eat();
      d.printInfo();
    
      Cat c = new Cat();
      c.eat();
      c.printInfo();
    }

### 多态 ###

Dart中的多态：

1.  允许将子类类型的指针赋值给父类类型的指针，同一个函数调用会有不同的执行效果
2.  子类的实例赋值给父类的引用
3.  多态就是父类定义一个方法不去实现，让继承他的子类去实现，每个子类有不同的表现
4.  多态实现的对象只拥有父类中有的方法

abstract class Animal {
        
      eat(); //抽象方法
    }
    
    class Dog extends Animal {
        
      @override
      eat() {
        
        print('小狗在吃骨头');
      }
    
      run() {
        
        print('run');
      }
    }
    
    class Cat extends Animal {
        
      @override
      eat() {
        
        print('小猫在吃老鼠');
      }
    
      run() {
        
        print('run');
      }
    }
    
    main() {
        
      Animal d = new Dog();
      d.eat();
    
      Animal c = new Cat();
      c.eat();
    }

### 接口 ###

和 Java 一样，dart 也有接口，但是和 Java 还是有区别的。

*  首先，dart 的接口没有 `interface` 关键字定义接口，而是普通类或抽象类都可以作为接口被实现
 *  同样使用 `implements` 关键字进行实现
 *  但是 dart 的接口有点奇怪，如果实现的类是普通类，会将普通类和抽象中的属性的方法全部需要覆写一遍
 *  而因为抽象类可以定义抽象方法，普通类不可以，所以一般如果要实现像 Java 接口那样的方式，一般会使用抽象类
 *  建议使用抽象类定义接口

案例：定义一个DB库，支持 mysql、mssql，mysql、mssql 两个类里面都有同样的方法。

abstract class Db {
        
      //当做接口   接口：就是约定 、规范
      late String uri; //数据库的连接地址
      add(String data);
      save();
      delete();
    }

import 'Db.dart';
    
    class MsSql implements Db {
        
      @override
      late String uri;
      @override
      add(String data) {
        
        print('这是mssql的add方法' + data);
      }
    
      @override
      delete() {
        
        // TODO: implement delete
        return null;
      }
    
      @override
      save() {
        
        // TODO: implement save
        return null;
      }
    }

import 'Db.dart';
    
    class Mysql implements Db {
        
      @override
      String uri;
      Mysql(this.uri);
    
      @override
      add(data) {
        
        print('这是mysql的add方法' + data);
      }
    
      @override
      delete() {
        
        return null;
      }
    
      @override
      save() {
        
        return null;
      }
    }

### 多接口的实现 ###

abstract class A {
        
      late String name;
      printA();
    }
    
    abstract class B {
        
      printB();
    }
    
    class C implements A, B {
        
      @override
      late String name;
      @override
      printA() {
        
        print('printA');
      }
    
      @override
      printB() {
        
        return null;
      }
    }
    
    void main() {
        
      C c = new C();
      c.printA();
    }

### mixins ###

*  `mixins` 的中文意思是混入，就是在类中混入其他功能。
 *  在 **Dart** 中，我们可以使用 `mixins` 实现类似多继承的功能
 *  因为 `mixins` 使用的条件，随着 **Dart** 版本一直在变，在 **Dart 3.0** 版本及以上，可以使用 `mixin` 关键字来声明一个 **mixin** 类。**Mixin** 类是一种特殊的类，它可以包含方法和属性，但不能直接实例化。**Mixin** 类通常用于在其他类中重用代码，通过使用 `with` 关键字将 **mixin** 类混入到其他类中。
    
    1.  作为 `mixins` 的类只能继承自 Object，不能继承其他类
    2.  作为 `mixins` 的类不能有构造函数
    3.  一个类可以 **mixin** 多个 `mixins` 类
    4.  `mixins` 不是继承，也不是接口，而是一种全新的特性

//普通类
    class Person {
        
      String name;
      num age;
    
      Person(this.name, this.age);
      printInfo() {
        
        print('${
          this.name}----${
          this.age}');
      }
    
      void run() {
        
        print("Person Run");
      }
    }
    
    //mixin类： 不可继承其他类
    mixin class A {
        
      String info = "this is A";
      void printA() {
        
        print("A");
      }
    
      void run() {
        
        print("A Run");
      }
    }
    
    //mixin类
    mixin class B {
        
      void printB() {
        
        print("B");
      }
    
      void run() {
        
        print("B Run");
      }
    }
    
    //普通类
    class C extends Person with B, A {
        
      C(String name, num age) : super(name, age);
    }
    
    void main() {
        
      var c = new C('张三', 20);
      c.printInfo();
      c.run(); //同名方法, mixin类会覆盖继承的类, 后面mixin的类会覆盖前面mixin的类
    }

![在这里插入图片描述][4e63c15ce4a7454692e31d84c43ce327.png]

**mixins的类型**

**mixins** 的实例类型是什么？

很简单，**mixins** 的类型就是其超类的子类型。

mixin class A {
        
      String info = "this is A";
      void printA() {
        
        print("A");
      }
    }
    
    mixin class B {
        
      void printB() {
        
        print("B");
      }
    }
    
    class C with A, B {
        }
    
    void main() {
        
      var c = new C();
    
      print(c is C); //true
      print(c is A); //true
      print(c is B); //true
    }

## 泛型 ##

通俗理解：泛型就是解决类、接口、方法的复用性、以及对不特定数据类型的支持(类型校验)

### 泛型方法 ###

//实现一个方法：传入什么类型的值，就返回什么类型的值
    T getData<T>(T value) {
        
      return value;
    }
    
    //返回类型可以省略
    // getData<T>(T value) {
        
    //   return value;
    // }
    
    void main() {
        
      print(getData(21));
      print(getData('xxx'));
    
      //传参时可以指定类型
      print(getData<String>('你好'));
      print(getData<int>(12));
    }

### 泛型类 ###

/*
      案例：实现泛型类MyList, 要求MyList里面可以增加int类型的数据, 
      也可以增加String类型的数据, 但是每次调用增加的类型要统一
    */
    class MyList<T> {
        
      List list = <T>[];
    
      void add(T value) {
        
        this.list.add(value);
      }
    
      List getList() {
        
        return list;
      }
    }
    
    main() {
        
      //不指定类型
      MyList l = new MyList();
      l.add("张三");
      l.add(123);
      l.add(true);
      print(l.getList());
      print("----------------");
    
      //指定类型
      MyList l1 = new MyList<String>();
      l1.add("张三");
      print(l1.getList());
      print("----------------");
    
      MyList l2 = new MyList<int>();
      l2.add(11);
      l2.add(12);
      print(l2.getList());
    }

![在这里插入图片描述][129f89e8cc6849a39ead90fd60716b9c.png]

### 泛型接口 ###

案例：实现数据缓存的功能，有文件缓存、和内存缓存。内存缓存和文件缓存按照接口约束实现。

1.  定义一个泛型接口，约束实现它的子类必须有 `getByKey(key)` 和 `setByKey(key,value)`
2.  要求调用 `setByKey` 时的参数 `value` 的类型和实例化子类的时候指定的类型一致

//缓存接口
    abstract class Cache<T> {
        
      getByKey(String key);
      void setByKey(String key, T value);
    }
    
    //文件缓存
    class FileCache<T> implements Cache<T> {
        
      @override
      getByKey(String key) {
        
        return null;
      }
    
      @override
      void setByKey(String key, T value) {
        
        print("我是文件缓存, 把 key=${
          key}  value=${
          value} 写入到了文件中");
      }
    }
    
    //内存缓存
    class MemoryCache<T> implements Cache<T> {
        
      @override
      getByKey(String key) {
        
        return null;
      }
    
      @override
      void setByKey(String key, T value) {
        
        print("我是内存缓存, 把 key=${
          key}  value=${
          value} 写入到了内存中");
      }
    }
    
    void main() {
        
      //在实例化时指定类型
      MemoryCache m1 = new MemoryCache<String>();
      m1.setByKey('index', '首页数据');
    
      MemoryCache m2 = new MemoryCache<Map>();
      m2.setByKey('index', {
        "name": "张三", "age": 20});
    }

![在这里插入图片描述][682423085190436ebaaa1ade494829af.png]

[Link 1]: https://blog.csdn.net/weixin_62511863?spm=1011.2421.3001.5343
[Flutter]: https://blog.csdn.net/weixin_62511863/category_12649403.html?spm=1001.2014.3001.5482
[6c3da0eb8b3b472198238fa34c6c0364.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/91995d436267471d99380b0ad1a1286f.png
[ac907dcde0434522aead1af969facc2c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/8182cb3b1e124f7e88fae95cf164019f.png
[f1f802dc8cc94240b604883d716fc062.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/09435a982d314a31bb744149cfe1b7cb.png
[4f4b133b848744448eed2fad3e6ac079.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7ae0e97449d24fa0b6569a2d7c966584.png
[7fa618b8594d4901894c7c3714086068.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/ebb328bf1e844e85881c7a27acd7fdfb.png
[4e63c15ce4a7454692e31d84c43ce327.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/5dd5a78df59e42199ad203068922dc84.png
[129f89e8cc6849a39ead90fd60716b9c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/eb2d629f3a3c4aa495bee70f1ca60e48.png
[682423085190436ebaaa1ade494829af.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/edca987cc06f438497c56f206810e6c2.png