类
Dart 是一个面向对象编程语言。 每个对象都是一个类的实例，所有的类都继承于 Object。
//每个实例变量都会自动生成一个 getter 方法（隐含的）。 非final 实例变量还会自动生成一个 setter 方法。
class Point {
num x;
num y;
}
构造函数
由于把构造函数参数赋值给实例变量的场景太常见了， Dart 提供了一个语法糖来简化这个操作：
class Point {
num x;
num y;
Point(this.x, this.y);
}
命名构造函数
Dart 并不支持构造函数的重载，而采用了命名构造函数为一个类实现多个构造函数：
class Point {
num x;
num y;
Point(this.x, this.y);
Point(this.y);///错误，不允许重载
//命名构造函数
Point.y(this.y) {
x = 0;
}
}
//使用
var p = Point.y(0);
初始化列表
在构造函数函数体执行之前会首先执行初始化列表，非常适合用来设置 final 变量的值。
class Point {
num x;
num y;
Point(this.x, this.y);
//命名构造函数
Point.y(this.y) {
x = 0;
}
Point.fromMap(Map map)
: x = map['x'], // : 和c++一样，初始化列表
y = map['y'];
Point.x(int i)
: x = i,
y = 0;
}
重定向构造函数
有时候一个构造函数会调动类中的其他构造函数(在Java中就是 this(...))。 一个重定向构造函数是没有代码的，在构造函数声明后，使用 冒号调用其他构造函数。
class Point {
num x;
num y;
Point(this.x, this.y);
Point.xy(int x,int y):this(x,y); ///调用上面的构造函数
}
常量构造函数
如果你的类提供一个状态不变的对象，你可以把这些对象 定义为编译时常量。要实现这个功能，需要定义一个 const 构造函数， 并且声明所有类的变量为 final。
class ImmutablePoint {
final num x;
final num y;
//常量构造函数
const ImmutablePoint(this.x, this.y);
}
void main(){
//编译器常量
var p1 = const ImmutablePoint(0,0);
var p2 = const ImmutablePoint(0,0);
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;
}
// static Manager getInstance() {
// if (_instance == null) {
// _instance = new Manager._internal();
// }
// return _instance;
// }
Manager._internal();
}
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 Parent {
String name;
void printName(); //抽象方法，不需要在方法前声明 abstract
}
抽象类不能被实例化，除非定义工厂方法并返回子类。
abstract class Parent {
String name;
//默认构造方法
Parent(this.name);
//工厂方法返回Child实例
factory Parent.test(String name){
return new Child(name);
}
void printName();
}
// extends 继承抽象类
class Child extends Parent{
Child(String name) : super(name);
@override
void printName() {
print(name);
}
}
void main() {
var p = Parent.test("test");
print(p.runtimeType); //输出实际类型 Child
p.printName();
}
接口
与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 {}
