私有成员
- 在Java中有
public，private，protected这些访问修饰符，可控制类class成员的访问权限，在Dart中没有这些访问修饰符，属性成员可通过下划线_，表明该属性是类class的私有成员，外界不能直接访问，只能通过方法访问，注意这里涉及到两个单独文件之间的访问； - person类文件，代码如下：
class Person {
String name;
int age;
//私有成员
double _weight;
//其中age为可选参数
Person.init(this.name, this.age, this._weight);
//使用set,get关键字的setter，getter方法
set setName(String name) {
this.name = name;
}
String get getName {
return this.name;
}
double get getWeight {
return this._weight;
}
}
- main函数文件，代码如下：
import 'person.dart';
void main(List<String> args) {
Person person1 = Person.init("cccc", 26, 125.5);
//_weight 是私有成员 不能直接访问
print(person1.getWeight);
}
静态成员
- 使用
static关键字来定义静态成员，包括静态属性和静态函数方法； - 静态成员 通过
类名来调用；
void main(List<String> args) {
Car car = new Car("bsj", 12500.0);
//静态属性
Car.speed = 125.6;
//实例方法 调用者为实例对象
car.run();
//静态方法 调用者为类名
Car.walk();
}
class Car {
String name;
static double speed;
double weight;
Car(this.name, this.weight);
void run() {
print("run");
}
static void walk() {
print("walk");
}
}
类的继承
- Dart中继承使用
extends关键字，子类中使用super访问父类，不支持多继承； - 父类中的所有成员变量和方法都会被继承，但是
构造方法除外； - 重写方法最好加上 @override 注解；
- 子类的构造方法在执行前，会
隐式调用父类的无参数默认构造函数(没有参数且与类同名的构造方法)； - 如果父类没有
无参数默认构造函数，则子类的构造函数必须在初始化列表中通过super显式调用父类的某个构造函数，完成父类中属性的初始化；
main(List<String> args) {}
class Animal {
int age;
Animal(this.age);
}
class Person extends Animal {
String name;
//必须完成父类属性age的初始化 在初始化列表中完成
Person(this.name, int age) : super(age);
}
抽象类
- 用
abstract关键字修饰的类，称之为抽象类； - 在Dart中没有具体实现的方法，称之为
抽象方法； - 抽象方法必须存在于抽象类中，抽象方法没有
abstract关键字进行修饰，但是Java中可以，Java中的抽象类与抽象方法均可使用abstract关键字进行修饰，这是两者之间的区别；
void main(List<String> args) {
Circle circle = new Circle();
circle.draw();
circle.show();
}
abstract class Shap {
void draw();
void show() {
print("show");
}
}
//Circle必须实现draw 抽象方法 否则会报错
class Circle extends Shap {
@override
void draw() {
print("绘制圆形");
}
}
- 抽象类
不能实例化； - 继承抽象类的子类
必须实现抽象类中定义的抽象方法，否则会报错；
main(List<String> args) {
//抽象类不能实例化
final s = Shape();
//Map是系统的一个抽象类
//Map能实例化 是因为Map内部实现了一个工厂构造函数 external factory Map()
final map = Map();
print(map.runtimeType);
}
//Shape是一个抽象类
abstract class Shape {
//getArea是抽象方法 没有实现体的 由子类去实现
void getArea();
}
//继承抽象类的子类 必须实现抽象类中定义的抽象方法
class Rectanle extends Shape {
@override
void getArea() {
print("画矩形");
}
}
- Map是系统的一个抽象类，其能实例化 是因为Map内部实现了一个工厂构造函数
external factory Map()；
隐式接口
- 在Dart中接口比较特殊，没有一个专门的关键字来声明接口；
- 默认情况下，
定义的每个类都相当于默认也声明了一个接口，可称之为隐式接口，可以由其他类来实现，因为Dart不支持多继承； - 类可通过
implements关键字，将其他类当成接口，来实现其他类中定义的方法； - 在开发中，我们通常将用于给别人实现的类 声明为抽象类；
main(List<String> args) {
}
class Animal {
void eat() {
print("eat");
}
}
class Runnner {
void run() {
print("run");
}
}
class Flyer {
void fly() {
print("fly");
}
}
//当将一个类当作接口使用时，那么实现这个接口的类，必须实现这个接口中的所有方法
class Superman extends Animal implements Runnner, Flyer {
@override
void eat() {
// TODO: implement eat
super.eat();
}
@override
void run() {
// TODO: implement run
}
@override
void fly() {
// TODO: implement fly
}
}
-
Superman类继承自Animal，并实现Runnner和Flyer这两个接口，这里Runnner和Flyer本质是类class，可当作接口进行使用； - 当将一个
类当作接口使用时，那么实现这个接口的类，必须实现这个接口中的所有方法；
混入mixin
- 当
当前类实现(implements) 隐式接口类，默认必须实现 隐士接口类中 的所有方法； - 现在需要 实现
当前类不想再 实现隐式接口类中的 所有方法，可使用混入mixin语法； - 定义可混入的类时，不能用
class关键字，而是使用mixin关键字； - 当前类使用
with进行混入，使用混入时可以使用super关键字； - 当前类实现接口类 -- 案例代码：
void main(List<String> args) {
}
abstract class Runner {
void run();
}
abstract class Flyer {
void fly();
}
class Animal {
void eat() {
print("Animal eat");
}
}
//SuperMan实现接口类Runner与Flyer
//必须实现Runner与Flyer中所有方法，否则会报错
class SuperMan extends Animal implements Runner, Flyer {
@override
void run() {
// TODO: implement run
}
@override
void fly() {
// TODO: implement fly
}
}
SuperMan实现接口类Runner与Flyer；
必须实现Runner与Flyer中所有方法，否则会报错；
当前类with 混入类 -- 案例代码：
void main(List<String> args) {}
mixin Runner {
void run() {}
}
mixin Flyer {
void fly() {}
}
class Animal {
void eat() {
print("Animal eat");
}
}
//SuperMan with 混入类Runner与Flyer
//可有选择的实现Runner与Flyer中的方法
class SuperMan extends Animal with Runner, Flyer {
@override
void run() {
// TODO: implement run
super.run();
}
}
- SuperMan with 混入类Runner与Flyer；
- 可有选择的实现Runner与Flyer中的方法；
- 使用混入时，Superman实现时可以使用
super关键字，调用Runner中的实现；
