//1.抽象类必须通过abstract关键字声明
//2.抽象类中，可以有抽象方法，也可以没有抽象方法，一般来说，抽象类都有抽象方法
import 'package:my_flutter_app/15_metadata.dart';
abstract class Phone {
//声明抽象方法。标记为手机处理器
void processor();
void camera(); //手机摄像头
void info() {
print('我是抽象类中的普通方法');
}
}
class Huawei extends Phone {
@override
void camera() {
print('莱卡888');
}
@override
void processor() {
print('888');
}
}
class Xiaomi extends Phone {
//普通类继承了抽象类，必须实现抽象类中的所有抽象方法
@override
void camera() {
print('骁龙888');
}
@override
void processor() {
print('骁龙888');
}
//普通类里面不能有抽象方法
// void aaa();
}
void main() {
//抽象类不能被实例化
// var p1 =new Phone();
var p = new Xiaomi();
p.camera();
p.processor();
p.info();
var h = new Huawei();
h.info();
h.processor();
}
接口
- 接口在Dart中就是一个类（只是用法不同）
- 与java不同，java中的接口需要interface关键字声明；Dart中不需要
- 接口可以是任意类，但一般使用抽象类做接口
- 一个类可以实现（implements）多个接口，多个接口用逗号分隔
- class MyClass implements Interface1,Interface2{...}
- 接口可以看成是一个个小零件，类实现接口相当于组装零件
- 普通类实现接口，必须重写接口中所有的属性和方法
//手机的处理器
import 'package:my_flutter_app/15_metadata.dart';
abstract class Processor {
late String cores; //内核数 2核 4核
arch(String name); //芯片制程 7nm 5nm
}
abstract class Camera {
late String resolution; //分辨率 100万，3000万
brand(String name); //品牌：三星，莱卡
}
//通过普通类是实现接口
class Phone implements Processor, Camera {
@override
String cores;
@override
String resolution;
Phone(this.cores, this.resolution);
@override
arch(String name) {
print('芯片制程：$name');
}
@override
brand(String name) {
print('相机品牌：$name');
}
}
void main() {
Phone p = new Phone('4核', '300万');
p.arch('5nm');
p.brand('莱卡');
}
``
### 混入
+ 混入（Mixin）是一段公共代码，混入有两种声明方式：
+ 将类当作混入`class MixinA{...}`
+ 作为Mixin的类只能继承来自Object，不能继承其他类
+ 作为Mixin的类不能有构造函数
+ 使用mixin关键字声明`mixin MixinB{...}`
+ 混入（Mixin）可以提高代码复用率，普通类可以通过`with`来使用混入
``` class MyClass with MixinA , MixinB{...} ```
+ 使用多个混入时，后引入的混入会覆盖之前混入中的重复内容
+ MixinA 和 MixinB 中都有hello()方法，MyClass 会使用 MixinB中的
import 'package:my_flutter_app/Father.dart';
// class MixinA extends Object{
// class MixinA extends Father{
class MixinA {
String name = 'MixinA';
//用作混入的类不能拥有构造函数
MixinA();
void printA() {
print('A $name');
}
void run() {
print('A is runing');
}
}
class MixinB {
String name = 'MixinB';
void printB() {
print('B $name');
}
void run() {
print('B is runing');
}
}
class MyClass with MixinA, MixinB {}
void main() {
var c = new MyClass();
//后引入的混入，会覆盖之前引入的混入中的重复的内容
c.printA();
c.printB();
c.run();
}
### 泛型
### 泛型函数
// String getData(String value) {
// return value;
// }
// int getData(int value) {
// return value;
// }
//不指定数据类型的函数，
// getData(value) {
// return value;
// }
// T getData<T>(T value) {
// return value;
// }
//只约定参数类型，不约定函数返回值的类型
getData<T>(T value) {
return value;
}
void main() {
// getData('');
print(getData<String>('hello'));
print(getData<int>(111));
}
### 泛型类
class CommonClass {
Set s = new Set<int>();
void add(int value) {
this.s.add(value);
}
void info() {
print(this.s);
}
}
class GenericsClass<T> {
Set s = new Set<T>();
void add(T value) {
this.s.add(value);
}
void info() {
print(this.s);
}
}
void main() {
CommonClass c = new CommonClass();
c.add(1);
// c.add('2');
c.info();
GenericsClass g = new GenericsClass<String>();
g.add('hello');
g.info();
GenericsClass g1 = new GenericsClass<int>();
g1.add(123);
g1.info();
// Set s=new Set();
// s.add(123);
// s.add('value');
// print(s);
Set s = new Set<int>();
s.add(123);
// s.add('value');
print(s);
//字面量形式的泛型
Set set = <int>{};
set.add(1);
}
### 泛型接口
## 使用泛型限制参数类型
class SomeBaseClass {}
class AnotherClass {}
class Extender extends SomeBaseClass {}
class Foo<T extends SomeBaseClass> {
String toString() => "Instance of 'Foo<$T>'";
}
void main() {
var someBaseClassFoo = Foo<SomeBaseClass>();
print(someBaseClassFoo.toString());
// var anotherClass = Foo<AnotherClass>();//报错
// print(anotherClass.toString());
var extenderFoo = Foo<Extender>(); //子类也可
print(extenderFoo.toString());
var no = Foo(); //不写默认
print(no.toString());
}
> 下一节`枚举`
`