-
Dart中的类与对象 -
Dart中的构造函数 -
Dart的工厂构造函数，单例，初始化列表 -
Dart类方法和对象操作符 -
Dart的继承 -
Dart的抽象类和接口 -
DartMixins混入
1.Dart 中的类于对象
void main() {
//构造函数与类同名
Person p = Person();
//当和Person类在同一文件里，Person所有属性和方法都能被访问
//属性和方法都通过`.`语法访问
p._study();
p.name = "MG";
p.age = 18;
}
class Person {
String? name;
int? age;
//final定义的属性必须定义初始值
final double height = 181.2;
void _study() {
print('$name age:$age, height:$height 学习');
}
void toScholl() {
print('去学校');
}
//方法是不能重载的(方法的名称是寻找方法的唯一标识)
// void toScholl(int a) {
// }
}
- 使用
class关键字声明一个类 - 创建对象可以使用
new加上构造函数 - 所有对象都继承
object类 - 每一个类会默认生成构造函数，就是类名本身
-
Dart中默认会生成getter和setter方法 - 属性和方法都通过
.语法访问 -
final定义的属性必须定义初始值 -
Dart中对象方法是不能重载的(方法的名称是寻找方法的唯一标识) - 在名称前加
_表示私有，在同一文件下私有是可以被访问的
2.Dart 中的构造函数
class Person {
final String name;
final int age;
//final定义的属性必须定义初始值
final double height = 181.2;
//构造函数，外界调用则需要传参数
// Person(String name, int age) {
// //当成员属性和参数名称一样，会导致值赋值不了
// // name = name;
// _age = age;
// }
//作为参数this语法只能在构造函数中使用
//当一个对象所有的成员属性都是`final`时，那么这个对象可以被创建为常量对象,使用const修饰构造函数
const Person(this.name, this.age);
//命名构造函数
// Person.withName();
void _study() {
print('$name age:$age, height:$height 学习');
}
}
-
Dart中自定义了构造函数后，默认构造函数就会失效 -
Dart中当一个对象所有的成员属性都是final时，那么这个对象可以被创建为常量对象，使用const修饰构造函数
3.Dart的工厂构造函数，单例，初始化列表
3.1工厂构造方法，单例
class FactoryClass {
//需要一个单例
static FactoryClass? _instances;
//Dart中构造函数没有返回值,如果需要返回可以添加 Factory 工厂构造方法
factory FactoryClass() => _instances ??= FactoryClass._init();
//私有命名构造函数
FactoryClass._init();
}
3.2初始化列表
初始化列表作用：
- 给
final变量赋值 - 校验传递的值
class Person {
String name;
int age;
final int height;
//用:标识赋值
Person(this.name, this.age, int h)
: height = h,
//校验在打印之前
assert(h >= 0),
assert(age >= 0) {
print('name:$name age:$age, height:$height');
}
}
4Dart类方法和对象操作符
4.1类方法
class StaticClass {
//静态属性，外部访问是用类名方法,方法也是同理
// StaticClass.count
// StaticClass.sum(10);
static int count = 1; //在内存中只有一份
int currentCount = 10;
//如果是常量也需要用static修饰
static const String name = "mg";
//静态方法,静态方法里可以访问静态成员,但是静态方法中不能访问非静态成员
static int sum(int a) {
//静态方法中不能访问非静态成员
// return count + a + currentCount;
return count + a;
}
//实例方法，则是两者都可以访问
int sum2(int b) {
return count + b + currentCount;
}
//解析：
//静态成员，静态方法是通过类名访问的，那么这时类的实例可能还没有出来，所以在静态方法中不能访问非静态成员
}
4.2对象操作符
-
?条件运算符 -
as类型转换 -
is类型判断 -
..级联操作(连缀)
void staticDemo() {
var s1;
s1 = StaticClass();
print(s1.sum2(2));
s1 = null;
//在这里执行就会报错，这里我们加上条件运算符号？，就能解决
// print(s1.sum2(3));
print(s1?.sum2(3));
var s2 = Object();
s2 = StaticClass();
//由于在声明时s2为Object类型，后又改变为StaticClass，编译器不知道会报错
//我们采用类型转符as解决，类型转换符只在当下有效
print((s2 as StaticClass).sum2(2));
//除此之外我们还能先判断类型is
if (s2 is StaticClass) {
// print(s2.sum2(3));
//级联操作..，采用级联操作返回的是调用者本身，那么我们就能继续再调用，函数式编程
s2
..currentCount = 15
..sum2(2);
}
}
5Dart的继承
-
Dart继承使用extends继承一个类 -
Dart是单继承 -
Dart子类会继承除了构造方法以外的属性和方法
void extendsDemo() {
Student st = Student.withName("MG");
//继承子类能访问父类的方法
st.run();
st.name = "MG";
st.age = 18;
//也不能访问私有属性
// st._heght = 180
print(st.isFree); //输出 true
}
class Person {
String? name;
int? age;
int? _height;
bool get isFree {
_height ??= 0;
return _height! < 180;
}
Person.withName(String? name);
void run() {
print("Person run...");
}
}
//
class Student extends Person {
final subName;
//当父类有自定义构造方法时，子类必须创建
//初始化列表必须放在super前面
Student.withName(String? name) : subName = name!, super.withName(name);
void study() {
print('认真学习');
}
//@override标识复写父类的
//也可以去掉。不过为了代码可读性建议保留
@override
bool get isFree => age! < 19;
}
6Dart的抽象类和接口
- 抽象类不能被实例化
- 抽象类使用
abstract修饰
//Dart抽象类
void abstractDemo() {
//抽象类的好处，直接使用父类的对象，调用子类的方法 --- 多态
abstractClass as = subClass();
print(as.sum(10, 20));
}
//抽象类
abstract class abstractClass {
//没有实现的方法---抽象方法
//抽象方法必须放在抽象类中
int sum(int a, int b);
}
//子类继承抽象类
class subClass extends abstractClass {
//必须实现抽象类中的方法
@override
int sum(int a, int b) {
print('a + b = ${a+b}');
return a + b;
}
}
如果想要实现多个抽象类的方法呢？
由于Dart是单继承，就不能使用继承extends了，我们可以采用implements实现,如果使用implements就必须实现类中的所有东西
//Dart抽象类
void abstractDemo() {
//抽象类的好处，直接使用父类的对象，调用子类的方法 --- 多态
subClass as = subClass();
as.sum(10, 20);
as.sum1(10, 20);
as.sum2(10, 20);
as.run();
}
//抽象类
abstract class abstractClass {
//没有实现的方法---抽象方法
//抽象方法必须放在抽象类中
int sum(int a, int b);
}
abstract class abstractClass1 {
//没有实现的方法---抽象方法
//抽象方法必须放在抽象类中
int sum1(int a, int b);
}
abstract class abstractClass2 {
//没有实现的方法---抽象方法
//抽象方法必须放在抽象类中
int sum2(int a, int b);
}
class a {
String name = '啊';
run() {
print('run...');
}
}
//implements类似于接口
class subClass implements abstractClass,abstractClass1,abstractClass2,a {
//必须实现抽象类中的方法
@override
int sum(int a, int b) {
print('a + b = ${a+b}');
return a + b;
}
@override
int sum1(int a, int b) {
print('a + b = ${a+b}');
return a + b;
}
@override
int sum2(int a, int b) {
print('a + b = ${a+b}');
return a + b;
}
@override
String name = 'a';
@override
run() {
print('run...');
}
}
7DartMixins混入
void mixinsDemo() {
//声明一个D的对象
D d = D();
//d可以调用a
d.a();
//d可以调用b
d.b();
//d可以调用c
d.c();
//如果A，B，C类中的方法都是同名方法，这里只打印C的方法
//C是最后一个，会覆盖掉前面的方法
}
class A {
a() => print('a....');
}
class B {
b() => print('b....');
}
class C {
c() => print('c....');
}
//加入with，将B，C二类称作D的混入
class D extends A with B,C {
}
-
Mixins用来实现多继承功能的 - 混入的类中有构造方法则不能使用
- 当混入的类继承其他类时，编译器会报错，不过可以运行。原因是怕继承的类有非默认的构造方法
