Dart语法：Mixing、extends、abstract、operator、implements
Main
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter_oop_first/person_class.dart';
import 'package:flutter_oop_first/static_class.dart';
import 'package:flutter_oop_first/techer_class.dart';
import 'extends_class.dart';
import 'factory_class.dart';
/*
* 类和对象
* 使用Class关键字创建一个对象
* 可以说会用new构造函数
* 所有对象都是继承Object类
* Dart不支持重载（不能有相同的方法名）
* */
void main() {
//校验类
// Teacher t = Teacher('teacher',29,-100);
// staticDemo();
// extendsDemo();
// abstractDemo();
operatorDemo();
}
/*
* Mixins混入、多继承
* */
void mixinsDemo(){
DClass d = DClass();
d.e();//输出c，因为最后一个覆盖了前面的
}
/*
* Mixins混入、多继承
* */
class AClass {
a()=> print('a....');
e()=> print('a....');
}
class BClass {
b()=> print('b....');
e()=> print('b....');
}
class CClass extends MixinsBugClass{//
c()=> print('c....');
e()=> print('c....');
// CClass();使用Mixins，父类就不有构造方法，否则会报错
}
class MixinsBugClass{
// String name;
// MixinsBugClass(this.name);//重写构造方法加参数，子类继承后，使用Mixins会导致奔溃
}
class DClass extends AClass with BClass, CClass{//使用Mixins,父类不能继承非objcet类，防止有构造方法，但依旧可以运行
}
//class DClass = AClass with BClass, CClass;Mixins优化写法
//重载
operatorDemo(){
OperatorClass o1 = OperatorClass(20);
OperatorClass o2 = OperatorClass(18);
print('operator:${o1 > o2}');
}
class OperatorClass{
int age;
OperatorClass(this.age);
bool operator > (OperatorClass other) => this.age > other.age;
}
//抽象类，协议
void abstractDemo(){
SubClass sc = SubClass();
sc.sum1(10, 10);
sc.sum2(10, 10);
sc.sum3(10, 10);
}
//抽象类，协议
// 不能被实例化
// 使用abstract修饰
abstract class AbstractClass1{
//抽象方法，不能实现，在子类里实现
int sum1(int a, int b);
}
class NormalClass{//正常类
String? name;
run(){
print('normal');
}
}
// class SubClass extends AbstractClass{//extends只能单继承
class SubClass implements AbstractClass1,AbstractClass2,AbstractClass3,NormalClass{//implements执行，可以多继承抽象类或，正常类，但需要实现所有的方法和属性
@override
String? name;
@override
run() {
// TODO: implement run
print('override NormalClass run');
// throw UnimplementedError();
}
@override//继承抽象类，必须实现抽象类方法
int sum1(int a, int b) {
// TODO: implement sum
print('1 a + b = ${a + b}');
return a + b;
}
@override//继承抽象类，必须实现抽象类方法
int sum2(int a, int b) {
// TODO: implement sum
print('2 a + b = ${a + b}');
return a + b;
}
@override//继承抽象类，必须实现抽象类方法
int sum3(int a, int b) {
// TODO: implement sum
print('3 a + b = ${a + b}');
return a + b;
}
}
abstract class AbstractClass2{
//抽象方法，不能实现，在子类里实现
int sum2(int a, int b);
}
abstract class AbstractClass3{
//抽象方法，不能实现，在子类里实现
int sum3(int a, int b);
}
void extendsDemo(){
StudentClass st = StudentClass.withName('Fre');
st.name = 'Same';
st.age = 18;
st.run();//父类方法
st.study();//自有方法
print(st.isFree);
print(st);
polymorphicDemo();
}
void polymorphicDemo(){//多态
ExtendsClass st = StudentClass.withName('Tom');
if(st is StudentClass){
st.name = 'Sam';
st.age = 19;
st.run();//父类方法
st.study();//自有方法
print(st.isFree);
}
}
void staticDemo(){
StaticClass sc1 = StaticClass();
sc1.currentCount = 10;//默认值是0
StaticClass.count = 20;//默认值是0
print(sc1.sum2(20));//20 +count + currentCount = 50
StaticClass sc2 = StaticClass();
print(sc1.sum2(1));//输出是31，受到上面的影响，静态对象，内存里只有一份
//动态类型dynamic防止为空
var dynamic ;
dynamic = StaticClass();
print(dynamic.sum2(20));//40
dynamic = null;
print(dynamic?.sum2(20));//这里的?就是防止为空,输出null
//类型转换transition
var transition = Object();
transition = StaticClass();
print((transition as StaticClass).sum2(20));//输出40， as类型转换，只有一行有效
if(transition is StaticClass){//条件判断保护
print(transition.sum2(20));
transition.currentCount = 15;
transition.sum2(20);
//可以写作成下面。Dart特殊语法，".."执行完后返回对象本身
transition..currentCount = 15..sum2(20);
}
}
factoryTest() {
FactoryClass fact1 = FactoryClass();
FactoryClass fact2 = FactoryClass();
print( fact1 == fact2);
}
personTest(){
Person p = Person(18,'Tom',30);
// p.name = 'abc';
// p.age = 18;
// p.run();
p.height = 10;
p.printP();
p.changeAge(20);
p.printP();
test();
}
ExtendsClass
class ExtendsClass{
String? name;
int? age;
int? _height;
bool get isFree => _height! < 110;//!是强制解包，告诉系统已处理为空，不需要报错。<110是根据条件判断赋值
run(){
print('ExtendsClass run');
}
// ExtendsClass(){
// print('ExtendsClass create');
// }
ExtendsClass(this.name);//构造方法加属性
ExtendsClass.init();//有名字没参数的构造方法
ExtendsClass.withName(this.name);//有名字、有参数的构造方法.
}
class StudentClass extends ExtendsClass{
final String subName;
// StudentClass(String? name) : super(name);//父类重写了构造方法后，子类就自少要续写其中一个: super
// StudentClass.init() : super.init();
StudentClass.withName(String? name) :subName = name!, super.withName(name);
//
StudentClass() :subName = 'Dan', super.init();//父类重写了构造方法后，子类就自少要续写其中一个: super
//类似初始化列表，初始化列表主要用于给final属性赋值
//:subName = name!, 是初始化列表，!是强制解包。必须写在super前面
study(){
print('认真学习');
}
@override//重写父类属性
// TODO: implement isFree
bool get isFree => age! > 18;
@override//重写父类方法
run() {
// TODO: implement run
print('student run');
}
@override
String toString() {
// TODO: implement toString
return'override Student descrition';
}
}
FactoryClass
class FactoryClass{//创建类
//创建单利类
static FactoryClass? _instance;
//Dart语言中构造函数是没有返回对象的，如果需要返回对象加factory关键字修饰
// factory FactoryClass(){
// // if(_instance == null){
// // _instance = FactoryClass._init();
// // }
// // _instance ??= FactoryClass._init();//优化写法1，为空赋值
// // return _instance!;//这里的!是强制解包，告诉编译器，我已经做过为空处理，不需要报错了
// return _instance ??= FactoryClass._init();//优化写法2
// }
factory FactoryClass() => _instance ??= FactoryClass._init();//优化写法3
FactoryClass._init();
}PersonClass
/*
* Dart中默认会生成get和set方法
* 属性和方法都通过.访问
* final修饰的属性必须定义初始值
* */
class Person{//类
// String? name;//?可以为空
String? _name ;// _为私有属性,跨文件不能访问
int? _age;
int? height;
final int wight;//final 只能赋值一次
// Person (int age, String name){//重写构造函数，会覆盖系统的构造函数
// _age = age;
// _name = name;
// }
Person (this._age, this._name,this.wight);//重写构造函数，会覆盖系统的构造函数，final修饰的属性必须定义初始值，
//命名构造函数，重写构造函数方法
Person.withName(this._name,this.wight);
void changeAge(int age){
this._age = age;
}
final String? school = 'sz';
void _run(){//方法
print('name$_name age$_age');
}
void printP(){
_run();
print('height$height');
}
// void _run(){// _为私有方法
// print('name$name age$age');
// }
}
/*
* 当所有属性都为final时，可以用const修饰成常量类
* 一般用于传值
* */
class Student{//常量类，
final String name;
final int age;
final int height;
const Student(this.name,this.age,this.height);
}
void test(){
Person p = Person(20,'Jack',30);
p._name = 'abc';//同个页面可以访问私有属性
p._run();
p.printP();
}TeacherClass
class Teacher{
String name;
int age;
final height;
//初始化列表,目的：
//1给final赋值，
//2校验传递的值
Teacher(this.name,this.age,int h):height = h,
assert(h >= 0),
assert(age >= 0){
print('name:$name age:$age height:$height');
}
//执行顺序先校验 assert(h >= 0),assert(age >= 0)
//再执行this.name,this.age
//再执行{ print('name:$name age:$age height:$height'); }
}
StaticClass
class StaticClass{
//静态属性
static int count =0;
static const String name = 'Coco';//静态常量，只有一份
int currentCount = 0;
//静态方法是类调用，不是对象
static int sum(int a){
//静态方法访问不了，非static属性currentCount
return a +count;
}
//实例方法可以访问静态和非静态属性
int sum2(int a ){
return a +count + currentCount;
}
}