抽象类、函数、成员
abstract class Person {
static const String name = 'abc';
void printName(){
print(name);
}
}
不能直接 new 实例化
var p = Person();//错误
p.printName();
继承方式使用
抽象类中只定义抽象函数，实例化访问会报错
定义
class Teacher extends Person {
}
实例
var user = Teacher();
user.printName();
接口方式使用
定义
abstract class Person {
static const String name = '';
void printName();
}
class Student implements Person {
String name = 'this is student';
void printName() {
print(name);
}
}
实例
var user = Student();
user.printName();
实现多接口
Dart可以履行多接口，Dart中没有interface关键字
void main() {
var p = AndroidPhone();
p.startup();
p.shutdown();
}
class Phone {
void startup() {
print('开机');
}
void shutdown() {
print('关机');
}
}
class Mobile {
int signal;
}
class AndroidPhone implements Phone, Mobile {
int signal;
void startup() {
print('AndroidPhone 开机');
}
void shutdown() {
print('AndroidPhone 关机');
}
}
继承
实现集成
void main() {
var p = AndroidPhone();
p.startup();
p.shutdown();
}
class Phone {
void startup() {
print('开机');
}
void shutdown() {
print('关机');
}
}
class AndroidPhone extends Phone {
}
继承抽象类
抽象类中只定义抽象函数，实例化访问抽象函数会报错
void main() {
var p = AndroidPhone();
p.startup();
p.shutdown();
}
abstract class Phone {
void startup();
void shutdown();
}
class AndroidPhone extends Phone {
}
调用父类普通方法
super 对象可以访问父类，super.method();
void main() {
var p = AndroidPhone();
p.startup();
}
class Phone {
void startup() {
print('开机');
}
void shutdown() {
print('关机');
}
}
class AndroidPhone extends Phone {
void startup() {
super.startup();
print('AndroidPhone 开机');
}
}
调用父类构造方法
void main() {
var p = AndroidPhone(12345678);
p.showNumber();
}
class Mobile {
int number;
int signal;
Mobile(this.number);
void showNumber() {
print('010-${number}');
}
}
class AndroidPhone extends Mobile {
AndroidPhone(int number) : super(number);
}
class Parent{
int x;
int y;
//父类命名构造函数不会传递
Parent.aa(x,y)
:x=x,
y=y{
print('父类命名构造函数');
}
}
class Child extends Parent{
int x;
int y;
//若父类没有默认构造函数，需要手动调用父类其他构造函数
Child(x,y) :super.aa(x,y){
print('子类构造函数');
}
//在构造函数的初始化列表里使用super(),需要把它放到最后
Child.fromJson(x,y)
:x=x,
y=y,
super.aa(x,y){
print('子类命名构造函数');
}
}
重写父类方法
在重写的函数上加修饰符
@override
void main() {
dynamic p = AndroidPhone(12345);
p.showNumber();
}
class Mobile {
int number;
int signal;
Mobile(this.number);
void showNumber() {
print('010-${number}');
}
}
class AndroidPhone extends Mobile {
AndroidPhone(int number) : super(number);
@override
void showNumber() {
print('sssa');
}
}
多类继承mixin
'Dart中的Mixins通过创建一个新类来实现，该类将mixin的实现层叠在一个超类之上以创建一个新类 ，它不是“在超类中”，而是在超类的“顶部”，因此如何解决查找问题不会产生歧义。— Lasse R. H. Nielsen on StackOverflow.'
要使用mixin的话，你需要使用with关键字，后跟一个或多个mixin的名称：
class Phone {
void startup() {
print('开机');
}
void shutdown() {
print('关机');
}
}
class AndroidPhone extends Phone {
void startup() {
super.startup();
print('AndroidPhone 开机');
}
}
class AndroidSystem {
void call() {
print('android call');
}
}
class Weixin {
void sms() {
print('weixin sms');
}
}
class Xiaomi extends AndroidPhone with AndroidSystem, Weixin {
void startup() {
super.startup();
print('AndroidPhone 开机');
}
}
函数重名冲突
遇到相同功能的函数，最后载入的会覆盖之前的函数定义
void main() {
var xm = Xiaomi();
xm.sms(); // qq sms
}
class Phone {
}
class Weixin {
void sms() {
print('weixin sms');
}
}
class QQ {
void sms() {
print('qq sms');
}
}
class Xiaomi extends Phone with Weixin, QQ {
}
//顺序问题
//如果2个或多个超类拥有相同签名的A方法，那么子类会以继承的最后一个超类中的A方法为准。
//当然这是子类没有重写A方法的前提下，如果子类自己重写了A方法则以本身的A方法为准
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 C extends P with B, A {
String getMessage() => 'C'; //优先级最高的是在具体类中的方法。
}
class CC extends P with B implements A {
} //这里的implement只是表明要实现A的方法，这个时候具体实现是再B中mixin了具体实现
main(List<String> args) {
print(AB().getMessage()); //B
print(BA().getMessage()); //A
print(C().getMessage()); //C
print(CC().getMessage()); //B
}
