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();
utils.putElement("element");
var utils2=Utils2();
utils2.putElement(1);
utils2.putElement("2");
}
//泛型使用在类上
class Utils{
T element;
void putElement(T element){
this.element=element;
print(element);
}
}
//泛型使用在方法上
class Utils2{
void putElement(T element){
print(element);
}
}
异步
通过async await 方式进行异步操作
Future checkVersion() async {
var version = await lookUpVersion();
// Do something with version
}