Dart 语法学习（三）

继承

(1)使用关键字extends 继承一个类
(2) 子类会继承父类可见的属性和方法，不会继承父类的命名构造函数
(3)子类能够复写父类的方法，getter 和setter
(4) 单继承，多态性
例子：
（1）使用关键字extends 继承一个类

//1、使用关键字extends 继承一个类
class Student extends Person {
  Student(){
    print("Student constructor");
  }
  void study() {
    print("Student study");
  }

(2) 子类会继承父类可见的属性和方法，不会继承父类的命名构造函数

class Person{
  Person(){
    print("Person constructor");
  }
  Person.withName(this.name);
  String name;
  int age;
  String _gender;
  bool get isAdult =>age>18;
  void run(){
    print("Person can run.");
  }
}

import 'package:flutter_app/dart/class_and_object/Person.dart';

void main() {
  var student = new Student();
  student.study();
  //2、可以访问Person中可见的属性、计算属性与方法
  student.name = "学生1";
  student.age = 16;
  student.isAdult;
  student.run();
  print("student is Adult ${student.isAdult}");
  //不能访问不可见属性
//  student._gender="";
}

(3)子类能够复写父类的方法，getter 和setter

//1、使用关键字extends 继承一个类
class Student extends Person {
  Student() {
    print("Student constructor");
  }

  void study() {
    print("Student study");
  }

  //3、子类能够复写父类的方法，getter 和setter
  @override
  int get age => super.age+1;

  @override
  void set age(int _age) {
    super.age = _age + 1;
  }

  @override
  bool get isAdult => age > 16;

  @override
  void run() {
    print("Studdent can run.");
  }
}

(4) 单继承，多态性

抽象类

（1）抽象类使用abstract表示，不能直接被实例化
（2）抽象方法不用abstract 修饰，无实现
（3）抽象类可以没有抽象方法

void main(){
 // 抽象类使用abstract表示，不能直接被实例化
//  var person=new Person();
    var student=new Student();
    student.work();
}
//抽象类使用abstract表示，不能直接被实例化
abstract class Person {
 // 抽象类可以没有抽象方法
  //抽象方法不用abstract 修饰，无实现
 void work();
}

class Student extends Person{
  @override
  void work() {
   print("Study");
  }
}

接口

(1)Dart中类与接口是统一的，类就是接口
(2)每个类都隐式的定义了一个包含所有实例成员的接口
类与接口的使用区别：
如果是复用用已有类的实现，使用继承
如果是使用已有类的行为，使用接口

void main(){
    Student student =new Student();
}
//接口必须实现类里面的所有方法
class Student implements Person{
  @override
  int age;

  @override
  String name;

  @override
  // TODO: implement isAdult
  bool get isAdult => null;

  @override
  void run() {
    // TODO: implement run
  }

}

Mixins

(1)使用with 连接一个或多个mixin
(2)MIxins类似于多继承，是在类多继承中重用一个类代码的方式
(3)使用Mixins时当2个类中有相同的方法，具体方法的调用跟2个类的先后顺序相关
(4)作为MixIns的类不能有显示声明的构造方法
(5)作为MixIns的类只能继承自Object

void main() {
  SomeAnimal someAnimal = new SomeAnimal();
  someAnimal.eat();
  //使用Mixins时当2个类中有相同的方法，具体方法的调用跟2个类的先后顺序相关
  someAnimal.bark();
}

class Animal {
  void eat() {
    print("eat someThings");
  }
}

class Dog {
  void bark() {
    print("wang wang wang");
  }
}

class Cat {
//  Cat() {} //(3)作为MixIn的类不能有显示声明的构造方法

  void feature() {
    print("very cute");
  }

  void bark() {
    print("miao miao miao ");
  }
}

class SomeAnimal extends Animal with Cat, Dog {}

操作符覆写

(1)覆写操作符需要在类中定义，格式如下：
返回类型 operator 操作符 （参数，参数）{
实现体
return 返回值
}
(2)如果覆写== 还需要覆写对象的hashcode getter方法
可以覆写的操作符

<	|	+	[]
>	/	^	[]=
<=	~/	&	~
>=	*	<<	==
>	%	>>

void main() {
  var person1 = new Person(10);
  var person2 = new Person(20);

  print(person1 > person2);
  print( person1["35"]);
}

class Person {
  int age;

  Person(this.age);

  bool operator >(Person person) {
    return this.age > person.age;
  }

  int operator [](String age){
    this.age=int.parse(age);
    return this.age;
  }
}

枚举

（1）枚举是一种有穷序列集的数据类型
（2）使用关键字enum定义一个枚举
（3）常用于代替常量、控制语句中
与java区别：
Dart中枚举具有index属性
不能设置初始值
不能添加方法

void main() {
  var currentLesson = Lesson.Java;
  switch (currentLesson) {
    case Lesson.Java:
      print("你在学习的是Java课程");
      break;
    case Lesson.PHP:
      print("你在学习的是PHP课程");
      break;
    case Lesson.HTML:
      print("你在学习的是HTML课程");
      break;
    case Lesson.PYTHON:
      print("你在学习的是PYTHON课程");
      break;
  }
  print(currentLesson.index);//Dart中枚举具有index属性
}
//不能设置初始值
//不能添加方法
enum Lesson { Java, PHP, HTML, PYTHON }

泛型

泛型使用在类上
泛型使用在方法上

void main(){
  var utils=Utils<String>();
  utils.putElement("element");
  var utils2=Utils2();
  utils2.putElement(1);
  utils2.putElement<String>("2");
}
//泛型使用在类上
class  Utils<T>{
  T element;
  void putElement(T element){
    this.element=element;
    print(element);
  }
}
//泛型使用在方法上
class Utils2{
  void putElement<T>(T element){
    print(element);
  }
}

异步

通过async await 方式进行异步操作

Future checkVersion() async {
  var version = await lookUpVersion();
  // Do something with version
}