类与对象
/*
* 类和对象
* 使用class关键字声明一个类
* 可以使用new构造函数
* 所有的对象都继承Object类
* */
void main(List<String> arguments) {
LGPerson p = LGPerson();
p.name = 'shark';
p.age = 18;
p.run(); /// name: shark age: 18
test(); ///name: shark age: 10 name: shark age: 10
}
/*Dart中默认会生成getter和setter方法
* 属性和方法都通过 .访问
* final修饰的属性必须定义初始值
* */
class LGPerson {
String? name;
int? age;
int? _year; // 加上下划线，就是私有的属性, 但同一个文件内还是可以访问的
void run() {
print('name: $name age: $age');
}
void _printP() { // 加上下划线，就是私有的方法
print('name: $name age: $age');
}
}
/// 但同一个文件内还是可以访问的, 而且很神奇，这个test方法是全局的
void test() {
LGPerson p = LGPerson();
p.name = 'shark';
p.age = 10;
p._year = 123;
p.run();
p._printP();
}
构造方法
- Dart中默认会生成getter和setter方法
- 属性和方法都通过 .访问
final修饰的属性必须定义初始值- 当一个对象所有的成员属性都是
final的时候，那么这个对象可以被创建为常量对象 - 使用
const修饰构造函数
/*Dart中默认会生成getter和setter方法
* 属性和方法都通过 .访问
* final修饰的属性必须定义初始值
* 当一个对象所有的成员属性都是final的时候，那么这个对象可以被创建为常量对象
* 使用const修饰构造函数
* */
class LGPerson {
String? name;
int? age;
int? _year; // 加上下划线，就是私有的属性, 但同一个文件内还是可以访问的
// LGPerson(int age, String name) {
// this.name = name;
// this.age = age;
// }
//
LGPerson(this.age, this.name);
/// 命名构造函数
LGPerson.whitName(this.name, this.age);
void run() {
print('name: $name age: $age');
}
void _printP() { // 加上下划线，就是私有的方法
print('name: $name age: $age');
}
}
单利方法
class FactoryCalss {
/// 需要一个单利对象
static FactoryCalss? _instance;
factory FactoryCalss() => _instance ??= FactoryCalss._init(); /// 简化版本
// factory FactoryCalss() {
// if(_instance == null) {
// _instance = FactoryCalss._init();
// }
// return _instance ??= FactoryCalss._init();
// }
/// 私有的命名构造函数。这样的话外部就无法调用FactoryCalss()初始化对象了，会报错了
FactoryCalss._init();
}
初始化列表方法-可检验参数
/// 初始化列表，目的：1 给final变量赋值
/// 校验传递的值
class Person {
String name;
int age;
final height;
Person(this.name, this.age, int h):
height = h, assert(h >= 0) {
print('name: $name age:$age, height:$height');
}
}
静态方法
class StaticClass {
//静态属性
static int count = 1;
int currentCount = 0;
//静态方法
static int sum(int a) {
return a + count;
}
//实例方法
int sum2(int a) {
return currentCount + a + count;
}
}
/// 静态方法使用
StaticClass.count = 10;
StaticClass.sum(9);
链式编程
..语言，链式编程
var s1 = StaticClass();
print(s1..currentCount = 15..sum2(20)); /// 链式编程，返回的是对象本身
继承
- Dart中的继承
- 使用extends继承一个类
- 子类会继承除了构造方法以外的属性和方法
- Dart是单继承的
/// 初始化列表，目的：1 给final变量赋值
/// 校验传递的值
class Person {
String? name;
int? age;
int? _height;
bool get isFree => _height! < 110;
Person(this.name, this.age){
print('name: $name age:$age');
}
void run() {
print('run');
}
}
class Student extends Person {
Student(super.name, super.age);
study() {
print('认真学习');
}
}
抽象类
- 类似于协议
/* 抽象类
* 不能被实例化的类，使用abstract修饰
* */
abstractDemo() {
SubClass as = SubClass();
as.sum(1, 10);
as.sum1(1, 10);
as.sum2(1, 10);
}
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 SubClass implements AbstractClass,AbstractClass1,AbstractClass2 {
@override
int sum(int a, int b) {
print('a + b = ${a + b}');
return a + b;
}
@override
int sum1(int a, int b) {
print('sum1: a + b = ${a + b}');
return a + b;
}
@override
int sum2(int a, int b) {
print('sum2: a + b = ${a + b}');
return a + b;
}
}
重载符>, <, =等
- bool operator
>(OperatorClass other) => this.age > other.age;
operatorDemo() {
OperatorClass op1 = OperatorClass(10);
OperatorClass op2 = OperatorClass(20);
print(op1 > op2);
}
class OperatorClass {
int age;
OperatorClass(this.age);
bool operator > (OperatorClass other) => this.age > other.age;
}
混入
- 说白了就是多继承, 如果多个类有同名方法会怎样呢，如run方法， 会运行最后一个类的方法，如C的run
- 作为混入类，是不能实现构造方法的
/* 混入
* 说白了就是多继承, 如果多个类有同名方法会怎样呢，如run方法， 会运行最后一个类的方法，如C的run
* 作为混入类，是不能实现构造方法的
* */
mixinDemo() {
D d = D();
d.runA();
d.runB();
d.runC();
d.run();
/*
*
a ...
b ...
c ...
run c
* ...*/
}
class D extends A with B, C {}
class A {
runA() => print("a ...");
run() => print("run a ...");
}
class B {
runB() => print("b ...");
run() => print("run b ...");
}
class C {
runC() => print("c ...");
run() => print("run c ...");
}
