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;

  }
}