【初见Dart】第六章: Dart面向对象编程1

1. 本章概述

◆ 类与对象，声明、创建及基本特性
◆ 构造方法及初始化列表
◆ 静态成员及对象操作符的使用

2. 类与对象

2.1 类与对象

◆ 使用关键字class声明一个类
◆ 使用关键字new创建一个对象, new可省略
◆ 所有对象都继承于Object类

2.2 类及成员可见性

◆ Dart 中的可见性以library(库)为单位
◆ 默认情况下,每一个Dart文件就是-一个库
◆ 使用_表示库的私有性
◆ 使用import导入库

2.3 属性与方法

◆ 属性默认会生成getter和setter方法
◆ 使用final声明的属性只有getter方法
◆ 属性和方法通过.访问
◆ 方法不能被重载

2.4 举个栗子

void main() {
  var person = new Person();
  person.name = "Tom";
  person.age = 20;

  print(person.name);//Tom
  print(person.address);//ShangHai

  person.work();//Name is Tom, Age is 20, He is working. . .
}

class Person {
  //_Person 使用_表示库的私有性,其他文件无法访问
  late String name;//late 新特性,延迟初始化,和Kotlin 的 lateinit 很像
  late int age;
  late final String address = "ShangHai";

  void work() {
    print("Name is $name, Age is $age, He is working. . .");
  }
}

3. 计算属性

◆ 顾名思义,计算属性的值是通过计算而来,本身不存储值
◆ 计算属性赋值,其实是通过计算转换到其它实例变量

3.1 举个栗子

void main() {
  var rect = new Rectangle();
  rect.height = 20;

  rect.width = 10;
  print(rect.area);//200

  rect.area = 200;
  print(rect.width);//10.0
}

class Rectangle {
  num width = 20, height = 20;
  num get area => width * height;

  set area(value) {
    width = value / 20;
  }
}

4. 构造方法

◆ 如果没有自定义构造方法,则会有个默认构造方法
◆ 如果存在自定义构造方法,则默认构造方法无效
◆ 构造方法不能重载

4.1 举个栗子

void main() {
  var person1 = new Person1("Tom", 20);
  var person2 = new Person2("Tom", 20, "Male");
  var person3 = new Person3("Tom", 20, "Male");
  new Person3.withName("John", "Male");
  new Person3.withAge(20, "Male");
}

class Person1 {
  late String name;
  late int age;
  final String gender = "Male";

  Person1(String name, int age) {
    this.name = name;
    this.age = age;
  }

  void work() {
    print("Work. . .");
  }
}

class Person2 {
  String name;
  int age;
  final String gender;

  Person2(this.name, this.age, this.gender);

  void work() {
    print("Work. . .");
  }
}

class Person3 {
  String name = "Tom";
  int age = 10;
  final String gender;

  Person3(this.name, this.age, this.gender);

  Person3.withName(String name, this.gender) {
    this.name = name;
  }

  Person3.withAge(this.age, this.gender);

  void work() {
    print("Work. . .");
  }
}

5. 常量构造方法

◆ 如果类是不可变状态,可以把对象定义为编译时常量
◆ 使用const声明构造方法,并且所有变量都为final
◆ 使用const声明对象,可以省略

5.1 举个栗子

void main() {
  const person4 = const Person4("Tom", 20, "Male");
}

class Person4 {
  final String name;
  final int age;
  final String gender;

  const Person4(this.name, this.age, this.gender);

  void work() {
    print("Work. . .");
  }
}

6. 工厂构造方法

◆ 工厂构造方法类似于设计模式中的工厂模式
◆ 在构造方法前添加关键字factory实现一个工厂构造方法
◆ 在工厂构造方法中可返回对象

6.1 举个栗子

class Logger {
  final String name;

  static final Map<String, Logger> eache = <String, Logger>{};

  factory Logger (String name) {
    return Logger._internal("Dart");
  }

  Logger._internal(this.name);

  void log(String msg) {
    print(msg);
  }
}

7. 初始化列表

◆ 初始化列表会在构造方法体执行之前执行
◆ 使用逗号分隔初始化表达式
◆ 初始化列表常用于设置final变量的值

7.1 举个栗子

void main() {
  var person5 = new Person5("Tom", 20, "Male");
}

class Person5 {
  String name;
  int age;
  final String gender;

  Person5(this.name, this.age, this.gender);

  Person5.withMap(Map map)
      : name = map["name"],
        gender = map["gender"],
        age = map["age"];

  void work() {
    print("Work. . .");
  }
}

8. 静态成员

◆ 使用static关键字来实现类级别的变量和函数
◆ 静态成员不能访问非静态成员,非静态成员可以访问静态成员
◆ 类中的常量需要使用static const声明

8.1 举个栗子

void main() {
  var page = new Page();
  Page.scrollDown();//ScrollDown. . .
}

class Page {
  static const int maxPage = 10;
  static int currentPage = 1;

  //下滑
  static void scrollDown() {
    currentPage = 1;
    print("ScrollDown. . .");
  }

  //上滑
  void scrollUp() {
    currentPage++;
    print("scrollUp. . .");
  }
}

9. 对象操作符

◆ 条件成员访问: ?.
◆ 类型转换: as
◆ 是否指定类型: is, is!
◆ 级联操作: …

9.1 举个栗子

void main() {
  Person6 person = new Person6();
  print(person.name ?? "123");//??很像Kotlin的?:,是判空机制

  var person1;
  person1 = "";
  person1 = new Person6();
  (person1 as Person6).work();
  if (person1 is! Person6) {
    person1.work();
  }

  var person2 = new Person6();
  person2//很像kotlin的apply{}语法糖
    ..name = "Tome"
    ..age = 20
    ..work();
}

class Person6 {
  String? name;//这里在String?,是可空类型,也和Kotlin一样
  int? age;

  void work() {
    print("Work...$name,$age");
  }
}

10. 对象Call方法

◆ 如果类实现了call()方法,则该类的对象可以作为方法使用

10.1 举个栗子

void main() {
  var person = new Person7();
  print(person("Test", 30));//Name is Test,Age is 30
}

class Person7 {
  String? name;
  int? age;

  String call(String name, int age) {
    return "Name is $name,Age is $age";
  }
}

11. 本章小结

◆ 类声明，对象创建，属性，方法，可见性，计算属性
◆ 构造方法，命名构造方法，常量构造方法，工厂构造方法
◆ 初始化列表，静态成员，操作符，call方法 .