类
Dart作为一门面向对象的编程语言，类充当了一个非常重要的角色。
Dart中一切皆为对象，而每个对象都是一个类的实例，所有的类都继承于Object。
实例变量
以下是一个描述人的类，其中有name、sex、age三个实例变量，如下所示：
class People {
String name; //声明实例变量name，初始值为null
int sex =1; //声明实例变量name，初始值为1
int age = 0; //声明实例变量age，初始化为0
}
所有的实例变量都会自动生成一个getter方法，没有声明为final的实例变量还会生成一个setter方法。所以我们可以直接 调用 (示例.属性 )来访问 和 赋值变量
构造方法
默认构造方法
定义了一个类的时候就会自动生成一个无参的构造方法，如果需要别的参数的构造方法，可以自己定义，如下所示：
class People {
String name;
int sex =1;
int age = 0;
People() {
//默认会生成
}
}
main() {
People p1 = new People();
p1.name = "test";
p1.sex = 2;
p1.age = 3;
}
看到默认会生成一个构造方法，也许OC/java程序员就会想到一个问题，他是不是能重载？
事实上，Dart的方法时不支持重载的，如下所示，是错误的代码示范
class People {
String name;
int sex =1;
int age = 0;
People() {
//默认会生成
}
People(String name , int sex ,int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
}
那么，如果dart里面需要多个构造方法怎么办？
这就是下面的“命名构造方法”。
命名构造方法
class People {
String name;
int sex =1;
int age = 0;
People.formNSA(String name , int sex ,int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
}
dart提供了一个语法糖来进行一些构造方法简写：
People.formNSA(String name , int sex ,int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
}
可以写成：
People.formNSA(this.name ,this.sex ,this.age);
需要注意的是：子类不会继承父类的构造方法。子类如果没有定义构造方法，则只有一个默认的构造方法。
调用父类的构造方法
默认情况下，子类的构造方法会自动调用父类的默认构造方法。父类的构造方法在子类构造方法开始执行的位置调用。
如下是定义一个People的子类Adults的示例：
class People {
String name;
int sex =1;
int age = 0;
People(this.name ,this.sex ,this.age){
print("I am a human being");
}
}
class Adults extends People{
String work;
Adults(String name, int sex, int age,this.work) : super(name, sex, age){
print("I'm an adult");
}
}
main() {
var cp = new Adults("test", 2, 20, 'developer');
}
那么控制台将输出以下信息：
I am a human being
I'm an adult
初始化参数列表
如果提供了一个initializer list（初始化参数列表），则初始化参数列表会在父类构造方法执行之前执行，他们之间的执行顺序如下：
- 初始化参数列表
- 父类构造方法
- 主类构造方法
初始化列表非常适合用来设置final变量的值，下面是算出体质是什么类型(瘦,标准,胖)的例子：
import 'dart:math';
enum Constitution {
thin,
standard,
fat
}
class People {
String name;
int weight =1;
int height = 0;
Constitution Physique;
People(name ,weight ,height)
: name = name,
weight = weight,
height = height,
Physique = ( ( (height-80)*.7)-weight ) > 5? Constitution.thin : ( ( (height-80)*.7)-weight ) < 5? Constitution.fat : Constitution.standard;
}
main() {
var p = new People("test", 60, 174);
print(p.Physique);
}
重定向构造函数
有时候一个构造函数会调动类中的其他构造函数(在Java中就是 this(...))。 一个重定向构造函数是没有代码的，在构造函数声明后，使用 冒号调用其他构造函数。
class People {
String name;
int weight =1;
int height = 0;
People(this.weight, this.height);
People.wh(int weight,int height):this(weight,height); ///调用上面的构造函数
}
常量构造方法
如果你需要提供一个状态不变的对象，并在编译时将这些对象编译为常量。
做到这些，只需要定义一个const构造方法，并且把所有变量声明为final类型。
class Oldman {
final int age;
const Oldman(this.age);
}
void main(){
//编译器常量
var p1 = const Oldman(60);
var p2 = const Oldman(60);
print(p1 == p2); // true
}
工厂构造函数
当实现一个使用factory 关键词修饰的构造函数时，这个构造函数不必创建类的新实例。例如，一个工厂构造函数 可能从缓存中获取一个实例并返回，或者 返回一个子类型的实例。（工厂构造函数无法访问 this）
class Logger {
final String name;
//从缓存获取对象
static final Map _cache = {};
//工厂构造函数，无法使用this变量
factory Logger(String name) {
if (_cache.containsKey(name)) {
//工厂构造函数需要返回 Logger 实例对象
return _cache[name];
} else {
final logger = Logger._internal(name);
_cache[name] = logger;
return logger;
}
}
//以 _ 开头的函数、变量无法在库外使用
Logger._internal(this.name);
}
借助工厂构造函数能够实现单例:
/使用工厂构造实现单例
class Manager {
static Manager _instance;
//和static是一样的, 区别是factory毕竟是构造函数，需要返回一个实例，而static是静态方法。
factory Manager.getInstance() {
if (_instance == null) {
_instance = new Manager._internal();
}
return _instance;
}
Manager._internal();
}
可以看到上面示例代码中默认构造方法前面还有个factory，这个关键字代表着这是个工厂构造方法。
要注意的是工厂构造方法时没法访问this关键字的，所以上面就有了在类的内部这么调用构造方法的代码：final logger = new Logger._internal(name);，在上面工厂构造方法中，如果缓存中存在传入的name的key值，则取出缓存中的对应value返回。如果缓存中没找到，就会通过命名构造方法来新建一个对象，缓存起来后返回。
Getters 和 Setters
Dart中每个实例变量都隐含的具有一个 getter， 如果变量不是 final 的则还有一个 setter。可以通过实现 getter 和 setter 来创建新的属性， 使用 get 和 set 关键字定义 getter 和 setter：
class Rect {
num left;
num top;
num width;
num height;
Rect(this.left, this.top, this.width, this.height);
//使用 get定义了一个 right 属性
num get right => left + width;
set right(num value) => left = value - width;
}
void main() {
var rect = Rect(0, 0, 10, 10);
print(rect.right); //10
rect.right = 15;
print(rect.left); //5
}
需要注意的是，在get与set中使用自身会导致Stack Overflow
可覆写的操作符
把已经定义的、有一定功能的操作符进行重新定义。可以重新定义的操作符有：
| < | + | | | [] |
| ---- | ---- | ---- | ----- |
| > | / | ^ | []= |
| <= | ~/ | & | ~ |
| >= | * | << | == |
| – | % | >> | |
比如：List就重写了 []。
class Point {
int x;
int y;
//返回值 参数随你定义
Point operator +(Point point) {
return Point(x + point.x, y + point.y);
}
Point(this.x, this.y);
}
var p1 = Point(1, 1);
var p2 = p1 + Point(2, 2);
print(p2.x); ///3
print(p2.y); ///3
抽象类
抽象类使用abstract关键字定义，是不能被实例化的，通常用来定义接口以及部分实现。
但与其他语言不太一样的地方是，抽象方法也可以定义在非抽象类中，如下例子所示：
abstract class Bird {
void fly(); //抽象方法，不需要在方法前声明 abstract`
}
class Sparrow extends Bird {
void fly() {
}
void sleep();
}
接口
与Java不同，Dart中没有interface关键字，Dart中每个类都隐式的定义了一个包含所有实例成员的接口， 并且这个类实现了这个接口。如果你想 创建类 A 来支持 类 B 的 方法，而不想继承 B 的实现， 则类 A 应该实现 B 的接口。
class Listener{
void onComplete(){}
void onFailure(){}
}
class MyListsner implements Listener{
MyListsner(){
}
@override
void onComplete() {
}
@override
void onFailure() {
}
}
与继承的区别在于：
1、单继承，多实现。
2、继承可以有选择的重写父类方法并且可以使用super，实现强制重新定义接口所有成员。
可调用的类
如果 Dart 类实现了 call() 函数则 类的实例 可以当做方法来调用。
class Closure {
call(String a, String b) => '$a $b!';
}
main() {
var c = new Closure();
var out = c("Hello","Dart");
print(out);
}
混合mixins
Mixins 实现了多继承 是一种在多类继承中重用一个类代码的方法。 它的基本 形式如下
//被mixin(混入)的类不能有构造函数
class A {
void a(){}
}
class B{
void b(){}
}
class C with A,B{
void c(){}
}
with后面跟着需要混入的类，被mixin(混入)的类不能有构造函数。现在的 C拥有了三个方法（a、b与c）。假设A与B 存在相同的方法，以最右侧的混入类为主，比如：
class A {
String getMessage() => 'A';
}
class B {
String getMessage() => 'B';
}
//
class AB with A, B {}
class BA with B, A {}
void printMessage(obj) => print(obj.getMessage());
void main() {
printMessage(AB()); //输出 B
printMessage(BA()); //输出 A
}
继承与mixins是兼容的
class A {
String getMessage() => 'A';
}
class B {
String getMessage() => 'B';
}
class P{
String getMessage() => 'P';
}
class AB extends P with A, B {}
class BA extends P with B, A {}
//可以简写成：
//class AB = P with A, B;
//class BA = P with B, A;
void printMessage(obj) => print(obj.getMessage());
void main() {
printMessage(AB()); //输出 B
printMessage(BA()); //输出 A
}
mixins弥补了接口和继承的不足，继承只能单继承，而接口无法复用实现，mixins却可以多混入并且能利用到混入类的具体实现：
abstract class Swimming{
void swimming(){
print("游泳");
}
}
abstract class Jump{
void jump(){
print("跳跃");
}
}
//只能单继承，如果需要Jump，只能以implements的形式
class Test extends Swimming implements Jump{
//实现接口
void jump(){
print("跳跃");
}
}
//但是实际上，我们经常不需要重新实现Jump方法，复用Jump所实现的jump方法就可以了
//这时使用混合能够更加方便
class Test with Swimming, Jump {}
