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
}