Abstract
Abstract被用于定义一个抽象类，用Abstract修饰的class是无法被实例化的，可以当做抽象类来 extends 也可以当做接口来 implements，dart 中没有 interface 这个关键字，接口也是抽象类实现的
abstract的类中的方法可以有方法体，也可以没有
用作抽象类 继承
abstract class Animal {
speak(); // 抽象方法 必须实现
printInfo() { // 不需要实现
print('not abstract method');
}
}
class Dog extends Animal {
@override
speak() {
print('wang!');
}
}
class Cat extends Animal {
@override
speak() {
print('miao');
}
}
void main() {
print('---------抽象类------------');
Dog d = new Dog();
Cat c = new Cat();
d.speak();
d.printInfo();
c.speak();
c.printInfo();
}
用作抽象类 接口 实现
@override 可不写，用作接口 implements，Test类的方法在Mysql类里要全部实现，要不会报错，
包括DB的实例变量也要重写，因为实例变量会自动生成setter getter 方法
abstract class Test {
String host;
String port;
String user;
String pass;
test1(String data);
test2(String data);
test3(String data);
test4(String data);
}
class Mysql implements DB {
@override
String host;
@override
String pass;
@override
String port;
@override
String user;
Mysql(this.host, this.user, this.pass, [this.port = '3306']) {
print(
'[ok] connect to ${this.host}:${this.port}, use ${this.user}:${this.pass}');
}
@override
test4(String data) {
print('delete ${data}');
}
@override
test3(String data) {
print('insert ${data}');
}
@override
test2(String data) {
print('query ${data}');
}
@override
test1(String data) {
print('update ${data}');
}
}
void main() {
print('---------接口------------');
Mysql my = new Mysql('127.0.0.1', 'root', '123456', '3307');
my.test1('121');
my.test2('121');
my.test3('121');
my.test4('121');
}
继承 extends
Flutter中的继承是单继承
- 子类使用extends关键词来继承父类
- 子类会继承父类里面可见的属性和方法 但是不会继承构造函数
- 子类能复写父类的方法 getter和setter
- 子类重写超类的方法，要用@override ,也可不用
- 子类调用超类的方法，要用super
- 子类可以继承父类的非私有变量
class Person {
//公有变量
String name;
num age;
//私有变量
String _gender;
//类名构造函数
Person(this.name,this.age);
//公有的方法
void printInfo() {
print("${this.name}---${this.age}");
}
work(){
print("${this.name}在工作...");
}
}
class Web extends Person{
Web(String name, num age) : super(name, age);
run(){
print('run');
super.work(); //自类调用父类的方法
}
//覆写父类的方法
@override //可以写也可以不写 建议在覆写父类方法的时候加上 @override
void printInfo(){
print("姓名：${this.name}---年龄：${this.age}");
}
}
main(){
Web w=new Web('李四',20);
// w.printInfo();
w.run();
}
接口实现(implements)
Flutter是没有interface的，但是Flutter中的每个类都是一个隐式的接口，这个接口包含类里的所有成员变量，以及定义的方法。如果有一个类 A,你想让类B拥有A的API，但又不想拥有A里的实现，那么你就应该把A当做接口，类B implements 类A
如果你被实现的类不是用abstract 修饰，那么被修饰的类的方法也要写实现，要不然会报错
所以在Flutter中:class 就是 interface
当class被当做interface用时，class中的方法就是接口的方法，必须需要在子类里重新实现，在子类实现的时候要加@override(也可不加)
当class被当做interface用时，class中的成员变量也需要在子类里重新实现。在成员变量前加@override
如果一个类既有继承又有实现，那么extends要写在 implements前面，要不然会报错
混合 mixins (with)
mixin用于修饰类，和abstract类似，该类可以拥有成员变量、普通方法、抽象方法，但是不可以实例化。mixin一般用于描述一种具有某种功能的组块，而某一对象可以拥有多个不同功能的组块
举个例子，我们有一种能力是 '绘画'，而拥有这种能力的是 ‘教师’，那么实现如下：
mixin DrawFunc {
String content = '..';
String what();
void draw() {
print('I can draw ${what()}');
}
}
class Teacher with DrawFunc {
String what() => "car";
}
void main() {
Teacher().draw();
}
我们限定了 '绘画' 这种能力只能够用在 '人类' 上面，示例如下
class Person {}
mixin DrawFunc on Person {
String content = '..';
String what();
void draw() {
print('I can draw ${what()}');
}
}
class Teacher extends Person with DrawFunc {
String what() => "car";
}
void main() {
Teacher().draw();
}
当我们在mixin上使用了on关键字，那么mixin只能在那个类的子类上使用，而mixin可以调用那个类的方法
mixin是将一些有共同特性的类抽出来共用，把具体的特性封装成一个mixin供其他类使用。本质上是为了减少代码冗余。而implement也能实现这种功能，但是继承自implement的子类需要完全重写父类的所有属性与方法，这就造成了很多不必要的代码冗余
mixin在定义时可以使用on关键字指定使用范围
当多个mixin函数一样时，后一个mixin会覆盖前面一个（线性特征）
with关键字能够实现mixin,可以想象成多继承，而且是以类似于栈的形式实现，同一方法调用最外边的
mixin可以实现蕾丝多重继承的功能，但是多重继承中相同函数执行并不会存在父子关系
mixin实现了一条继承链，声明的顺序代表了继承的顺序，声明在后面的mixin会最先执行
如果with后面跟多个，且有同名方法，则以最后一个为准，如class AB extends P with A, B {}如果A、B有同名方法，则AB使用的是B的方法。如果mixin和extends中有同名方法，最终使用的是mixin中的
class AB extends P with A, B {}
class BA extends P with B, A {}
等价于
class PA = P with A;
class PAB = PA with B;
class AB extends PAB {}
class PB = P with B;
class PBA = PB with A;
class BA extends PBA {}
如果三个一起用
class Extends {
void log() {
print('extends');
}
}
mixin Mixins {
void log() {
print('mixin');
}
}
mixin Mixins2 {
void log() {
print('mixin2');
}
}
class Implements {
void log() {
print('implements');
}
}
class Log extends Extends with Mixins, Mixins2 implements Implements {}
void main() {
Log().log();
}
输出结果
mixin2
这里我们发现了一个奇怪的现象：虽然我们加上了implements，但是Dart居然没让我们实现Implements.log()方法也不报错，
这是因为在这种情况下，它识别到我们从with和extends中获得了log()方法的能力，因此调用的是Mixins2.log()。
假如我们对Implements#log方法进行实现：
class Log extends Extends with Mixins, Mixins2 implements Implements {
void log() {
print("implements log");
}
}
输出的结果为
implements log
这三种关系可以同时存在，但是有着前后顺序：extends > mixins >implements,必须是extends在最前面 mixins在中间 implements在后面
