----大结局第一版

//面向对象扩展
// 继承，继承中的构造方法
//抽象类
//接口
//Mixins,操作符的覆写
//----------------------------------------------------
// 使用关键字 extends 继承一个类
// 子类会继承父类的属性和方法，不会继承构造方法
// 子类能够复写父类的方法、getter 和setter
// 单继承，多态性
//import 'higthObj.dart';
//void main(){
////var student= new Student();
////student.age=20;
////student.name='tom';
////student.isAdult;
////student.run();
////student.study();
////默认父类是object
//Person person=new Student();//多态
//person.name="zhangsan";
//if(person is Student){
//  person.study();
//}
//print(person);
//}
//class Student extends Person{
//  void study(){
//    print("Student study ...");
//  }
//  @override
//  bool get isAdult => age>15;//复写父类的方法 get set
//}
//----------------------------------------------------
//继承中的构造方法
//子类的构造方法默认会调用父类的无名无惨构造方法 Person(){}
//如果父类没有无名无参构造方法，则需要显示调用父类构造方法
//在构造方法参数后使用： 显示调用父类构造方法
// 构造方法的执行顺序
// 父类的构造方法在子类构造方法体开始执行的位置调用
//如果有初始化列表，初始化列表会在父类构造方法前执行
//void main(){
//var student=new Student("zhangsan","男");
//print(student.name);
//print(student.gender);
//}
//class Person{
//  String name;
//  Person(this.name);
//  Person.withName(this.name);
//}
//class Student extends Person{
//  int age;
//final String gender;
////  Student(String name) : super(name);//显示调用
////  gen 初始化参数
//  Student(String name,String gen):gender=gen, super.withName(name);//显示调用
////  Student.withName(String name) : super.withName(name);//显示调用
//}
//----------------------------------------------------
//抽象类
// 抽象类使用abstract 表示，不能被实例化
// 抽象方法不用abstract 修饰，无实现
// 抽象类可以没有抽象方法
// 有抽象方法的类一定得声明为抽象类
//void main(){
//var person= new Student();
//person.run();
//}
//abstract class Person{
//   void run();//抽象方法
//}
//class Student extends Person{
//  @override
//  void run() {
//print("run ...");  }
//
//}
//----------------------------------------------------
//接口
//类和接口是统一的，类就是接口
//每个类都隐式定义了一个包含所有实例成员的接口
// 如果是复用已有类的实现，使用继承 extends
// 如果只是使用已有类的外在行为，使用接口 implements
//void main (){
//var student= new Student();
//}
//class Person{
//  String name;
//  int  get age => 18;
//  void run (){
//    print("Person run ...");
//  }
//}
//class Student extends Person{ // 继承
//
//}

//class Student implements Person{//接口
//  @override
//  String name;
//
//  @override
//  // TODO: implement age
//  int get age => null;
//
//  @override
//  void run() {
//    // TODO: implement run
//  }
//
//}
//void main(){
//  var student=new Student();
//  student.run();
//}
//abstract class Person{
//  void run();
//}
//class Student implements Person{
//  @override
//  void run() {
//   print("student run ...");
//  }
//
//}
//----------------------------------------------------
// Mixins
// Mixin 类似于多继承，是在多继承中重用一个类代码的方式
// 作为Mixin 类不能有显示声明构造方法
// 作为 Mixin的类只能继承自 object
// 使用关键字with 连接一个或多个mixin
//void main(){
//var d=new D();
//d.a();
//}
//class A{
//  void a(){
//    print("A.a()...");
//  }
//}
//class B{
//  void a(){
//    print("B.a()...");
//  }
//  void b(){
//    print("B.b()...");
//  }
//}
//class C{
//  void a(){
//    print("C.a()...");
//  }
//  void c(){
//    print("C.c()...");
//  }
//}
////class D extends A with B,C{
////  //多继承 如果三个 类有同样的a方法，会调用C 中的a方法
////}
//class D =A with B,C;// 简化写法

//----------------------------------------------------
//操作符覆写
//覆写操作符需要在类中定义
//返回类型 operator 操作符（参数1，参数2，...）{
//  实现体..
//  return 返回值
//}
//如果覆写 == ，还需要覆写 对象的hashCode getter 方法
//参照官方 操作符
//void main(){
// var person1=new Person(18);
// var person2=new Person(20);
// print(person1>person2); //实现操作符
//  person1.age;
//  print(person1['age']);
//}
//class Person{
//  int age;
//  Person(this.age);
//  bool operator >(Person person){
//    return this.age > person.age;
//  }
//  int operator [] (String str){
//    if("age" == str){
//      return age;
//    }
//    return 0;
//  }
//}

//----------------------------------------------------
// 枚举
// 枚举是一种有穷序列集的数据类型
// 使用关键字 enum 定义一个枚举
// 常用于代替常量，控制语句等
//const spring=0;
//const summer=1;
//const autumn=2;
//const winter=3;
//void main(){
//  var currentSeason=Season.spring;
//  print(currentSeason.index);
//  switch ( currentSeason ){
//    case Season.spring:
//      print("1-3月");
//      break;
//    case Season.summer:
//      print("4-6月");
//      break;
//    case Season.autumn:
//      print("7-9月");
//      break;
//    case Season.winter:
//      print("10-12月");
//      break;
//  }
//}
//
//enum Season{
//  // dart 枚举特性
//// index 从0开始，依次累加
////  不能指定原始值
////  不能添加方法
// spring,
// summer,
// autumn,
// winter,
//}
//----------------------------------------------------
//泛型
// dart中类型是可选的，可使用泛型限定类型
// 使用泛型能够有效的减少代码重复
void main(){
  var list= new List<String>();// 设定类型只能一种，默认为动态
//  list.add(1);
  list.add("1");
//  var utils= new Utils(); //类级别的泛型
//  utils.put("sss");
//  utils.put(5);

//  var utils= new Utils<String>(); //类级别的泛型
//  utils.put("sss");

//  var utils= new Utils<int>(); //类级别的泛型
//  utils.put(5);

// var utils =new Utils(); //方法级别的泛型
// utils.put<String>("123");

//  var utils =new Utils(); //方法级别的泛型
//  utils.put<int>(1);
}
// 泛型的使用
// 类的泛型
// 方法的泛型
//class Utils{
//  int element;
//  String elementStr;
//  void putInt(int element){
//    this.element =element;
//  }
//  void putString(String element){
//    this.elementStr =element;
//  }
//}

//class Utils <T>{  //类级别的泛型
//  T element;
//  void put(T element){
//    this.element =element;
//  }
//}

class Utils {  //方法级别的泛型
 void put <T> (T element){
   print(element);
}}