1.类的基本使用

void main(List<String> args) {
  // Dart所有的东西都是对象，所有的对象都继承自Object类。
  // Dart中的类都是单继承的
  Person person = new Person();

  // 调用方法
  person.show();

  // 修改属性
  person.name = "jack";
  person.age = 18;

  // 访问属性
  print(person.name + ', ${person.age}');

  person.show();
}

// 定义类
class Person {
  String name = "";
  int age = 0;

  void show() => print("$name, $age");
}

2.构造函数

void main(List<String> args) {
  // 构造函数的功能主要用于在类的对象创建时定义`初始化`的状态
  // Dart语言中的构造函数分为`默认构造函数`和命名构造函数
  // 构造函数的命名必须和类名`完全相同`, 没有返回值

  // 1. 如果不显式写构造函数，默认提供一个无参构造

  // 默认的缺省构造
  // Person p = Person(); // new 关键字可以不写
  // print(p);

  // 2. 一旦显式提供构造函数，默认的缺省构造将不再提供，
  // 构造函数有且只能有一个
  // 构造函数可以简写
  Person p = Person('jack', 18);
  print(p);

  // 3. 命名构造可以有一堆 类名.xxx
  Person p2 = Person.init();
  print(p2);

  p2 = Person.setupInfo('rose', 22);
  print(p2);

  // 4.常量构造
  // 要使用常量构造方法，创建出相同的对象，使用const关键字
  // 如果是将结果赋值给const修饰的标识符时，const可以省略.
  Point point3 = const Point(10, 20);
  const point4 = Point(10, 20);
  print(identical(point3, point4));
}

// ========

class Person {
  var name;
  int age = 0;

  // 构造函数可以简写
  Person(this.name, this.age);

  // Person(var name, int age) {
  //   print('有参构造');
  //   this.name = name;
  //   this.age = age;
  // }

  // Person(); // 构造函数只能有一个，因为不能重载

  // 命名构造
  Person.setupInfo(var name, int age) {
    this.name = name;
    this.age = age;
  }

  Person.init({var name, int age = 0}) {
    this.name = name;
    this.age = age;
  }
}

class Point {
  final int x;
  final int y;

  // 在构造函数前加上 const 变成常量构造
  const Point(this.x, this.y);
}

3.初始化列表

void main(List<String> args) {
  // 初始化列表，在C++中有类似的语法
  // Dart中我们也可以在构造函数体运行之前初始化实例变量
  // 所有的成员变量都是final, C++是有包含有const的成员

  Rect r = Rect(10, 20);
  print(r.circle);
}

class Rect {
  final int width;
  final int height;

  final int circle; // 周长

  // Rect(this.width, this.height) {
  //   this.circle = width * height; // 'circle' can't be used as a setter because it's final.
  // }

  // 上面的方法不行，除非三个值全部用构造，除了这个方法，我们还可以使用初始化列表
  Rect(this.width, this.height) : circle = ((width + height) * 2) {
    print("初始化列表");
  }
}

4. 重定向构造与工厂构造

void main(List<String> args) {
  // 1.重写向构造：在一个构造函数中去调用另一个构造函数
  Person p = Person.setupInto('jack', 20);

  // 2.工厂构造
  // Dart提供了factory关键字, 用于通过工厂去获取对象,  如果对象存在直接返回，否则创建

  Person p1 = Person.map({'name': 'rose', 'age': 18});
  Person p2 = Person.map({'name': 'jack', 'age': 22});
  print(identical(p1, p2)); // true, 因为是直接获取对象

  // 3.利用工厂构造来实现单例
  Singleton s1 = Singleton();
  Singleton s2 = Singleton();
  print(identical(s1, s2));
}

class Person {
  String name;
  int age;
  static var _cache;

  Person(this.name, this.age) {
    print("我被调用了");
    this.name = name;
    this.age = age;
  }
  Person.setupInto(String name, int age) : this(name, age);

  // 工厂构造
  factory Person.map(Map map) {
    if (Person._cache == null) {
      Person._cache = Person.setupInto(map['name'], map['age']);
      print("创建对象");
    }

    return Person._cache;
  }
}

class Singleton {
  static final Singleton _singleton = Singleton.internal();

  factory Singleton() {
    print('Singleton 工厂构造被调用');
    return _singleton;
  }

  Singleton.internal() {
    print('internal 被调用了');
  }
}

5.setter && getter

void main(List<String> args) {
  // getter的定义方式 get+方法名
  // setter的定义方式 set+方法名(参数)
  // 注意：getter方法是没有( )的。返回值类型可以不用声明。
  // setter方法有且只能接收一个参数

  // 注意调用方式，是以属性修改的方式，不是以函数调用的方式。
  Person p = Person();
  p.name = 'jack'; // 这样是不会调用 setter和getter的
  print(p.name);

  // 调用 setter getter的正确姿势
  p.setName = 'rose';
  print(p.getName);
}

class Person {
  var name;

  // set方法
  set setName(String name) {
    print('设置');
    this.name = name;
  }

  // get 方法
  get getName {
    print('获取');
    return this.name;
  }
}

6. 对象运算符

void main(List<String> args) {
  // is 是父类或当前类
  // is! 不是
  // as 转换
  // ?
  // .. 级联运算
  int data = 100;
  print(data is num); // true
  print(data is int); // true

  num n = 100;
  print(n is int); // true
  print(n is Object); // true

  print((n as int).runtimeType); // int
  // print((n as double)); // 转换失败

  var p;
  p?.show(); // 如果 p 为 null, 不执行 show()方法，这和Swfit相同的

  Person p2 = Person(name: 'jack', age: 20);
  p2
    ..name = 'rose'
    ..age = 18
    ..show();
}

class Person {
  String name = "";
  int age = 0;

  Person({this.name = "", this.age = 0});

  void show() => print("$name, $age");
}

7. static关键字

void main(List<String> args) {
  // static的用法与其它语言几乎是一样的
  // 使用 static 关键字来实现类级别的变量和函数
  // 静态方法不能访问非静态成员，非静态方法可以访问静态成员
  // 这些和其它语言几乎是一样的

  Person.printInfo();
  Person.country = "美国";

  Person p = Person();
  p.show();
  // p.country = "ABC"; // 不允许在界面，通过对象来访问静态成员
  // p.printInfo(); // 同上
}

class Person {
  String name = "";
  static String country = "中国";

  static printInfo() {
    // print(name); // 错误，不能访问非静态成员
    print(country);
  }

  void show() {
    country = "abc"; // 在类内，非静态成员可以访问静态成员
    print("$name, $country");
  }
}

8.类的分离与私有属性

• Peron文件

class Person {
  String _name = "";

  set setName(String name) {
    _name = name;
  }

  get name => _name;
}

• main文件

import './person.dart';

void main(List<String> args) {
  // Dart 中没有 public private protected这些访问修饰符
  // Dart中使用 _ (下划线) 把一个属性或者方法定义成私有
  // 私有属性在同一文件，都是可以访问的
  Student stu = Student();
  stu._name = 'jack';

  Person p = Person();
  // p._name = 'jack'; // 不能访问

  // 通过 getter和setter来访问
  p.setName = "rose";
  print(p.name);
}

class Student {
  String _name = "";
}