面向对象之1

概述

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

1. 类

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

2. 属性与方法

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

3. 类及成员可见性

* Dart 中的可见性以 library(库) 为单位
* 默认情况下，每一个Dart文件就是一个库
* 使用 _ 表示库的私有性 （其它文件中是不能访问的）
* 使用 import 导入库

4. 计算属性

• 顾名思义，计算属性的值是通过计算而来的，本身不存在储存值

var rect = Rectangle();
rect.height = 20;
rect.width = 10;
print(rect.area);
             
class Rectangle {
    num width, height;
    num get area => width * height;
    // 或者可以写成
    num get area {
        return width * height;
    }            
}

• 计算属性赋值，其实是通过计算转换到其它实例变量

var rect = Rectangle();
rect.area = 200;
print(rect.width);
             
class Rectangle {
    num width, height;
    num get area => width * height;
    // 或者可以写成
    num get area {
        return width * height;
    }
    set area(value) {
        width = value / 20;
    }        
}

5. 构造方法

• 如果没有自定义构造方法，则会有个默认的构造方法

// 类 Person，默认构造方法为
Person() {}

• 如果存在自定义构造方法，则默认构造方法无效

var person = Person("Tow", 20);
var person1 = Person("Tow", 20, "One");
        
class Person {
    String name;
    int age;
            
    final String gender;
            
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 或者写成 语法糖
    Person(this.name, this.age);
            
    // 对 final 属性赋值
    // 错误赋值
    Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender; // 会报错
    }
    // 但可以使用语法糖来对 final 属性赋值, 因为他是执行构造方法前对 final 属性赋值
    Person(this.name, this.age, this.gender);
}

• 构造方法不能重载
• 命名构造方法
  • 使用命名构造方法，可以实现多个构造方法
  • 使用 类名.方法 的形式实现

var person = Person("Tow", 20);
var person1 = Person("Tow", 20, "One");
var person2 = Person.withName("Tow");
var person3 = Person.withAge(20);
        
class Person {
    String name;
    int age;        
    final String gender;
            
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 或者写成 语法糖
    Person(this.name, this.age);
            
    Person.withName(String name) {
        this.name = name;
    }
    // 或者写成 语法糖
    Person.withName(this.name);
            
    Person.withAge(this.age);
}

6. 常量构造方法

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

const person = const Person("Tow", 20);
// 或者可以写成
const person = Person("Tow", 20);

class Person {
    final String name;
    final int age;        
    final String gender;
            
    const Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 或者写成 语法糖
    const Person(this.name, this.age);
}

7. 工厂构造方法

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

class Logger {
    final String name;
    static final Map<String, Logger> _cache = <String, Logger>();
    
    factory Logger(String name) {
        if (_cache.containsKey(name)) {
            return _cache[name];
        } else {
            final logger = logger._interanl(name);
            _cache[name] = logger;
            return logger;
        }
    }

    Logger._internal(this.name);

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

8. 初始化列表

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

class Person {
    String name;
    int age;        
    final String gender;
    
    Person(this.name, this.age, this.gender);
    Person.withMap(Map map) : name = map["name"], gender = map["gender"] {
      this.age = map["age"];
    }
}

9. 静态成员

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

var page = Page();
Page.scrollDown();

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

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

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

10. 对象操作符

• 条件成员访问：?.
• 类型转换：as
• 是否指定类型：is ，is!
• 级联操作：..

// 条件成员访问
Person person = new Person();
person?.name = "Tow";
person?.work();

// 类型转换
var person1;
person1 = "";
person1 = new Person();
(person1 as Person).work();

var person2;
person2 = new Person();
// 是 Person 类
if (person2 is Person) {
    person2.work();
}

var person3;
person3 = new Person();
// 不是 Person 类
if (person3 is! Person) {
    person3.work();
}

// 级联操作
var person4 = new Person();
person4..name = "Tow"
       ..age = 20
       ..work();
// 或者写成
new Person()..name = "Tow"
       ..age = 20
       ..work();

class Person {
    String name;
    int age;
    
    void work() {
        print("work...$name,$age");
    }
}

11. 对象 call 方法

• 如果类实现了 call() 方法，则该类的对象可以作为方法使用
• call() 方法中的返回值、参数可以随意写

var person = new Person();
print(person("Test",30));
// 打印结果：Name is Test,Age is 30

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

小结

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