定义一个类
class Person { String name; int age; Person(String name, int age) { this.name = name; this.age = age; } }
简化后可写成
class Person { String name; int age; // 在构造方法中初始化成员变量时，可使用如下写法简化 Person(this.name, this.age); }
如需处理其他变量时，也可单独对其操作
class Person { String name; int age;
// 如需处理其他变量时，也可单独对其操作 Person(this.name, this.age, String address){ print(address); } }
ps：另外还需要注意一点，Dart中没有构造方法的重载，不能写两个同名的构造方法。
Getters 和 Setters方法
所有类中都包含隐式的getter方法，对于非final修饰的成员，类中还包含隐式的setter方法。
很多时候我们调用setter和getter方法并不仅仅是为了赋值和访问，而是为了一些额外的处理
class Person { String userName; Person(this.userName); // 方法名前加get关键字 String get name{ return "user:" + this.userName; } // 方法名前加set关键字 set name(String name){ // do something this.userName = name; } }
构造方法
不支持构造方法重载，但有命名构造方法
class Person { String userName; int age; Person(this.userName, this.age); // 命名构造方法 Person.fromData(Map data) { this.userName = data[‘name‘]; this.age = data[‘age‘]; } } void main() { // 使用命名构造方法创建对象 var p = new Person.fromData({ "name":"Bob", "age":19 }); print(p.userName); }
常量构造方法
如果想提供一个状态永远不变的对像，在Dart中，我们可以创建一个编译时常量对象，节省开销。
class ConstPoint {
final num x;
final num y;
// 使用const修构造方法
const ConstPoint(this.x, this.y);
// 编译时常量对象，需使用const来创建对象
static final ConstPoint origin = const ConstPoint(0, 0);
}
void main() {
print(ConstPoint.origin.x);
print(ConstPoint.origin.y);
}
工厂构造方法
当我们需要创建一个新的对象或者从缓存中取一个对象时，工厂构造方法就派上了用场。
class Logger { final String name; // 创建一个静态Map做为缓存 static final Map<String, Logger> _cache = <String, Logger>{}; // 定义一个命名构造方法，用下划线"_"修饰，将构造方法私有化 Logger._internal(this.name); // 使用关键字factory修饰类同名构造方法 factory Logger(String name) { if (_cache.containsKey(name)) { return _cache[name]; } else { // 调用命名构造方法创建新对象 final logger= new Logger._internal(name); _cache[name] = logger; // 存入缓存 return logger; } } } void main() { var uiLog = new Logger(‘UI‘); var eventLog = new Logger(‘event‘); }
构造方法重定向
有时候一个构造方法会调动类中的其他构造方法来实例化，这时候可以使用构造方法重定向，
class Point { num x; num y; // 同名构造方法 Point(this.x, this.y); // 命名构造方法重定向到同名构造方法，中间使用一个冒号 Point.alongXAxis(num x) : this(x, 0); }
类的初始化列表
位于构造方法的小括号与大括号之间，在初始化列表之前需添加一个冒号
逗号分隔的一些赋值语句组成
适合用来初始化 final修饰的变量
调用是在构造方法之前
class Point { final num x; final num y; final num distance; Point(x, y) : x = x, y = y, distance = sqrt(x * x + y * y){ print("这是构造方法"); } } void main() { var p = new Point(2, 3); print(p.distance); }
运算符重载
class Point { int x; int y; Point(this.x, this.y); // 使用operator关键字，为该类重载"+"运算符 Point operator +(Point p) { return new Point(this.x + p.x, this.y + p.y); } // 为该类重载"-"运算符 Point operator -(Point p) { return new Point(this.x - p.x, this.y - p.y); } } void main(){ var p1 = new Point(1,5); var p2 = new Point(7,10); // 重载运算符后，类可以使用“+”、“-” 运算符操作 var p3 = p1 + p2; var p4 = p2 - p1; print("${p3.x}, ${p3.y}"); print("${p4.x}, ${p4.y}"); }
类的单继承
class Father { myFunction(){ // do something } } class Son extends Father { @override myFunction(){ super.myFunction(); // do something } }
实现多继承，需要使用with关键字
// 首先定义三个父类 class Father1 { a(){ print("this is a func"); } common(){ print("common Father1"); } } class Father2 { b(){ print("this is b func"); } common(){ print("common Father2"); } } class Father3 { c(){ print("this is c func"); } common(){ print("common Father3"); } } //定义子类 class Son extends Father1 with Father2,Father3{ } void main() { var obj = new Son(); obj.common(); obj.a(); obj.b(); obj.c(); }
打印结果
common Father3 this is a func this is b func this is c func
以上继承写法中，也可以直接使用with，等价于如下写法
class Son with Father1,Father2,Father3{ }
Dart语言没有提供interface关键字来定义接口，
但是Dart语言中保留了抽象类，同Java，使用abstract关键字来修饰抽象类。而Dart中的抽象类，实际上就相当于Java中的接口。
抽象类是不能被实例化的，子类继承抽象类时，必须实现全部抽象方法。
abstract class Base { // 省略函数体即可定义抽象方法，不需加关键字 func1(); func2(); }
实际上在Dart中，每个类都隐式的定义了一个包含所有实例成员的接口， 并且该类实现了这个接口
因此，如果我们想实现某个接口，但有又不想继承，则可以使用这种隐式接口机制。我们需要用到关键字implements
class People { void greet(){ print("Hello"); } } class Student implements People{ @override void greet(){ print("Hi,I‘m Alice."); } } greet(People p){ p.greet(); } void main() { greet(new Student()); }
var names = new List<String>(); names.add("zhangsan") var maps = new Map<int, String>(); maps[1]="value";
字面量写法
var infos = <String>[‘Seth‘, ‘Kathy‘, ‘Lars‘]; var pages = <String, String>{ ‘index.html‘: ‘Homepage‘, ‘robots.txt‘: ‘Hints for web robots‘ };
try { // 使除数为0 print(11~/0); } on IntegerDivisionByZeroException { print("除数为0"); }on Exception{ print("Exception"); }finally { print("finally"); }
不关心具体异常，只想捕获，避免异常继续传递
try { print(11~/0); } catch(e){ // 打印报错信息 print(e); }finally { print("finally"); }
如果想获取更多异常信息，可以使用两个参数的catch，第二个参数是异常的调用栈信息
try { print(11~/0); } catch(e,s){ print(s); }
如果你既想针对不同异常进行不同处理，还想打印调用栈信息，那就将两种结合起来使用
try { print(11~/0); } on IntegerDivisionByZeroException catch(e,s){ print(s); } on Exception catch(e,s){ print(s); }
原文：https://www.cnblogs.com/liyonghua/p/11910773.html