Flutter开发之Dart中的类和对象

原文博客地址: Flutter和Dart系列文章
上次学习Flutter已是整整一年前的事情了,以后由于工做重心主要放在了React Native开发形式上
如今从新捡起Flutter, 也是计划系统性的从头开始从新学习Dart和Flutter
这篇Dart笔记主要就是记录Dart语言中的类和对象

类及其构造方法

Dart也是一门面向对象的开发语言，面向对象中很是重要的概念就是类，经过类的初始化建立一个对象html

类的定义

在Dart中，定义类用class关键字
当未指明其父类的时候, 默认是继承自Object的, 格式以下:

class 类名 {
  类型 成员名;
  返回值类型 方法名(参数列表) {
    方法体
  }
}
复制代码

在Dart语言中, 在类中使用属性(成员/实例变量)时, 有必要时是经过this获取的
可是下面在getsize方法中并无加this
这里须要注意的是: Dart的开发风格中，在方法中一般使用属性时，会省略this，可是有命名冲突时，this不能省略

// 建立类
class Point {
  // 定义变量
  int x;

  void getsize() {
    print('x = $x');
  }
}

// 类的初始化
main(List<String> args) {
    // 从Dart2开始，new关键字能够省略
    var point = new Point();
    point.x = 1;
    point.getsize();
}
复制代码

构造方法

当经过类建立一个对象时，会调用这个类的构造方法
- 在Dart语言中,若是类中没有明确指定构造方法时，将默认拥有一个无参的构造方法()
- 上面获得的point对象调用的就是默认的无参构造方法
也能够根据本身的需求自定义构造方法
- 当咱们建立了本身的构造方法时，默认的无参的构造方法将会失效，不能使用,不然会报错
- 由于Dart自己不支持函数的重载, 因此若是咱们明确的写一个默认的构造方法，就会和咱们自定义的构造方法冲突

class Student {
  String name;
  int age;

  Student(String name, int age) {
    this.name = name;
    this.age = age;
  }
}
复制代码

在上面构造方法中主要实现的就是经过构造函数的参数给类的户型赋值
为了简化这一过程, Dart提供了一种更加简洁的语法糖形式

class Student1 {
  String name;
  int age;

  // 这里和上面的Studeng的构造方法等价
  Student1(this.name, this.age);
}
复制代码

命名构造方法

在实际开发中, 很明显一个构造方法的确是不够咱们使用的
并且Dart又不支持函数的重载, 不能建立爱你相同名称不一样参数的构造方法
这就衍生出了另一中构造方法:命名构造方法

class Model {
  String name;
  int age;

  Model(this.name, this.age);

  // 命名构造方法
  Model.withNameAndAge(String name, int age) {
    this.name = name;
    this.age = age;
  }
  // 命名构造方法
  Model.initJson(Map<String, Object> map) {
    this.name = map['name'];
    this.age = map['age'];
  }
}


// 初始化对象
main() {
  // 普通构造方法
  var model0 = Model('name', 12);
  // 命名构造方法
  var model1 = Model.withNameAndAge('titan', 12);
  var model2 = Model.initJson({'name': 'jun', 'age': 18});
}
复制代码

初始化列表

几种方式定义的属性都是可变的, 若是定义的属性是final不可从新赋值的又该如何实现api

class Teacher {
  final String name;
  final int age;

  // 1. 这里会有一个错误提示: All final variables must be initialized, but 'age' and 'name' are not
  Teacher(String name, int age) {
    //2. 这里也会有一个错误提示: 'name' can't be used as a setter because it's final
    this.name = name;
    this.age = age;
  }
}
复制代码

上面第一处错误主要是由于: 在Dart中在执行下面{ }中的代码的时候, 表示Teacher对象已经初始化完毕了
因此在执行{ }以前, 必须保证name和age被初始化了
并且final修饰的属性是不可被从新赋值的, 因此才会报错
或者也可使用函数中的命名可选参数处理

class Size {
  final double width;
  final double height;
  final double area;

  // 命名可选参数
  Size(this.width, this.height, { this.area = 10 }); 
}
复制代码

上面经过命名可选参数的形式, 给参数设置默认值也是能够的, 可是不一样的是area只能设置具体的数值, 不能设置表达式
初始化列表的形式不但能够设置具体的数值, 也能够设置默认值为表达式的形式

class Size {
  final double width;
  final double height;
  final double area;

  // 多个属性使用逗号分隔
  Size(double width, double height): 
    this.width = width,
    this.height = height,
    this.area = width * height;
}
复制代码

重定向构造方法

下面的构造函数中, 咱们只能经过传入两个参数来获取一个对象
若是在某些状况下, 但愿只经过一个name变量来获取一个对象
这种状况下, 就能够经过在构造方法中去调用另一个构造方法, 这个时候可使用重定向构造方法
须要注意的是: 在一个构造函数中，去调用另一个构造函数, 是在冒号后面使用this调用

class Point {
  String name;
  int age;

  Point(this.name, this.age);

  // 重定向的构造方法
  Point.fromName(String name): this(name, 0);
}

// 使用方法
var point = Point.fromName("name");
print(point.age);  // 输出: 0
复制代码

常量构造函数

在某些状况下, 咱们但愿经过构造函数, 只要传入相同的参数, 那么获得的对象就是同一个
在Dart中判断两个对象是不是同一个的方法是经过函数identical判断, 返回值是一个布尔值

// 普通构造函数
class Person {
  String name;
  int age;

  Person(this.name, this.age);
}

// 初始化列表
class Size {
  final double width;
  final double height;
  final double area;

  // 多个属性使用逗号分隔
  Size(double width, double height): 
    this.width = width,
    this.height = height,
    this.area = width * height;
}

main(List<String> args) {
  var p1 = Person("name", 10);
  var p2 = Person("name", 10);
  // 判断两个对象是否是同一个
  print(identical(p1, p2));    /// false


  var s1 = Size(10, 20);
  var s2 = Size(10, 20);
  // 判断两个对象是否是同一个
  print(identical(s1, s2));    /// false
}
复制代码

很明显上面两种方式初始化的对象都不是同一个
其实在Dart中若是将构造方法前加const进行修饰，那么能够保证相同的参数，建立出来的对象是相同的
这样的构造方法就称之为常量构造方法

// 常量构造方法
class Teacher {
  final String name;

  const Teacher(this.name);
}

main(List<String> args) {
  // 常量构造方法
  // 这里的const不能够省略
  var t1 = const Teacher("name");
  var t2 = const Teacher("name");
  print(identical(t1, t2));    /// true
  
  // 这里的const能够省略
  const t3 = Teacher("name");
  const t4 = Teacher("name");
  print(identical(t3, t4));    /// true
  print(identical(t1, t4));    /// true
}
复制代码

常量构造方法有一些注意点:缓存

拥有常量构造方法的类中，全部的成员变量必须是final修饰的.
为了能够经过常量构造方法，建立出相同的对象，再也不使用new关键字，而是使用const关键字
若是是将结果赋值给const修饰的标识符时，const能够省略.

工厂构造方法

在Dart提供了factory关键字, 用于经过工厂去获取对象
普通的构造函数, 会默认返回建立出来的对象, 不须要咱们手动return
工厂构造方法, 须要手动返回一个对象
一样和上面同样的目的, 只要传入相同的参数, 那么获得的对象就是同一个, 下面经过工厂构造函数的方式实现

main(List<String> args) {
  
  var p1 = Person.fromName("titan");
  var p2 = Person.fromName("titan");
  print(identical(p1, p2)); // true
}

class Person {
  String name;

  // 用于缓存建立的对象, 避免大量的建立和销毁对象
  static final Map<String, Person> _cache = <String, Person>{};

  factory Person.fromName(String name) {
    if (_cache.containsKey(name)) {
      return _cache[name];
    } else {
      final p = Person(name);
      _cache[name] = p;
      return p;
    }
  }

  Person(this.name);
}
复制代码

类的继承

setter和getter

Dart中类定义的属性默认是能够直接被外界访问的
Dart中也存在setter和getter方法, 用于监听累的属性被访问的过程

main() {
  var people = People('top');
  people.setName = 'top';
  print(people.getName);
  print(people.name);

  var person = Person('titan');
  person.setName = 'jun';
  print(person.getName);
}


class People {
  String name;

  // setter
  set setName(String value) {
    this.name = value;
  }
  // getter
  String get getName {
    return 'titanjun';
  }

  People(this.name);
}
复制代码

上面setName和getName是自定义的, 你也能够命名为setterName和getterName等
还有就是上述两个方法不是系统自动生成的, 是须要咱们手动添加的
简单的方式也可使用箭头函数

class Person {
  String name;

  // setter
  set setName(String value) => this.name = value;
  // getter
  String get getName => 'titanjun';

  Person(this.name);
}
复制代码

类的继承

在Dart中一样支持类的继承, 继承使用extends关键字，子类中使用super来访问父类
父类中除了构造方法外, 全部的成员变量和方法都会被继承
子类能够拥有本身的成员变量, 而且能够对父类的方法进行重写
子类中能够调用父类的构造方法，对某些属性进行初始化：
- 子类的构造方法在执行前，将隐含调用父类的无参默认构造方法（没有参数且与类同名的构造方法）
- 若是父类没有无参默认构造方法，则子类的构造方法必须在初始化列表中经过super显式调用父类的某个构造方法

class People {
  String name;

  People(this.name);

  void eat() {
    print('people -- eat');
  }
}

class Person extends People {
  int age;

  Person(String name, int age): this.age = age, super(name);

  @override
  void eat() {
    // 这里的super, 看我的需求是否调用
    super.eat();
    print('Person -- eat');
  }
}

main(List<String> args) {
  var people = People('name');
  people.eat();

  var person = Person("top", 10);
  person.eat();
}
复制代码

抽象类

在Dart中抽象类是使用abstract声明的类
在Dart中没有具体实现的方法(没有方法体)，就是抽象方法
抽象方法，必须存在于抽象类中, 抽象类不能实例化
抽象类中的抽象方法必须被子类实现, 抽象类中的已经被实现方法, 能够不被子类重写

abstract class Size {
  int width;
  int height;

  Size(this.width, this.height);

  void getSize();

  int getArea() {
    return this.width * this.height;
  }
}

class Area extends Size {
  @override
  void getSize() {
    print('width = $width, height = $height');
  }

  Area(int width, int height): super(width, height);
}

main(List<String> args) {
  // 实例化Size会报错: Abstract classes can't be instantiated
  // var size = Size(20, 2);
  var area = Area(10, 2);
  area.getArea();
  print(area.getArea());
}
复制代码

类成员和方法

在Dart中咱们使用static关键字来定义类成员和类方法微信

main() {
 var person = Person();
 print(person.firstName);
 person.hide();

 print(Person.lastName);
 Person.show();
}


class Person {

  String firstName = 'top';
  // 不能使用this调用静态属性
  static String lastName = 'titanjun';


  void hide() {
    print('titanjun');
  }

  // 静态方法
  static void show() {
    print('https://www.$lastName.top');
  }
}
复制代码

多继承

在Dart中只有单继承, 是不支持多继承的, 可是咱们却能够经过其余方式间接实现多继承问题markdown

隐式接口

Dart中的接口比较特殊, 没有一个专门的关键字来声明接口, 默认状况下全部的类都是隐式接口
默认状况下，定义的每一个类都至关于默认也声明了一个接口，能够由其余的类来实现
在Dart开发中，咱们一般将用于给别人实现的类声明为抽象类
当将一个类可以作接口使用时, 那么实现这个接口的类, 必须实现这个接口中的全部方法
在Dart中经过implements来实现多继承问题, 可是必须实现这个接口中的全部方法, 并且在方法的实现中不能调用super方法

abstract class Woman {
  void eat();

  void student() {
    print("student");
  }
}

class Man {
  void run() {
    print("runner");
  }
}


class Student implements Woman, Man {
  @override
  void eat() {
    print("eat");
  }

  @override
  void student() {
    print("student--student");
  }

  @override
  void run() {
    // 这里不能调用super方法
    // super.run(); 
    print("run");
  }
}

main(List<String> args) {
  var stu = Student();
  stu.eat();
  stu.run();
  stu.student();
}
复制代码

Mixin混入

在经过implements实现某个类时，类中全部的方法都必须被从新实现(不管这个类原来是否已经实现过该方法)
可是某些状况下，一个类可能但愿直接复用以前类的原有实现方案
Dart提供了另一种方案: Mixin混入的方式
- 除了能够经过class定义类以外，也能够经过mixin关键字来定义一个类。
- 只是经过mixin定义的类用于被其余类混入使用，经过with关键字来进行混入

mixin Runner {
  run() {
    print('在奔跑');
  }
}

mixin Flyer {
  fly() {
    print('在飞翔');
  }
}

// 这里能够对原方法不作任何实现
class Bird with Runner, Flyer {  }

main(List<String> args) {
  var bird = Bird();
  bird.run();
  bird.fly();
}
复制代码

参考资料

欢迎您扫一扫下面的微信公众号，订阅个人博客！ide