前序

Google为Flutter选择了Dart就已经是既定的事实，无论你多么想用你熟悉的语言，比如JavaScript、Java、Swift、C++等来开发Flutter，至少目前都是不可以的。

相信大家中有很多人已经从事研发很多年了，可能也学习过很多种语言，其实如果你对编程语言有足够的自信，完全可以忽略Dart的基本内容：

因为你学过N种编程语言之后，你会发现他们的差异是并不大；
无非就是语法上的差异+某些语言有某些特性，而某些语言没有某些特性而已；
在初次接触Flutter的时候，并没有专门去看Dart的语法，而是对于某些语法不太熟练的时候回头去了解而已；

本篇将讲述Flutter的初体验--Dart的基本内容，通过本篇的学习大家对Flutter的基本语法Dart有个清晰的认识，也完全不需要去看相关视频和博客啦！本篇博客直接跳过Dart的安装与配置【网上资料较多】

一、Hello Dart

学习任何一门语言都是从“Hello World”开始，那我们也从这开始吧

1.1 Hello Dart

在Andriod Studio中新建一个helloWorld.dart 文件，添加如下代码

main(List<String> args) {
  print('Hello World');
}

然后在终端执行dart helloWorld.dart，就能看到Hello World的结果啦

1.2 程序的分析

针对上面的开篇打印Hello World讲述，总结如下：

Dart语言的入口也是main()函数，并且必须显示的进行定义；
Dart的入口函数main()是没有返回值的；
传递给main的命令行参数，是通过List完成的，其中List是Dart的集合类型；
定义字符串的时候，可以使用单引号或者双引号；
每行语句必须要使用分号作为结尾

二、定义变量及常量

2.1 明确声明【Explicit】

明确声明变量的方式，格式如下：

变量类型 变量名称 = 赋值;

示例代码如下

String name = "A Flutter Programmer";
int age = 27;
double height = 183;
print('${name}, ${age}, ${height}');

注意事项：定义的变量可以修改值，但是不能赋值其它类型【拼接方式下面会讲到】

String content = 'A Flutter Programmer;
content = 'Hello World'; // 正确的
content = 111; // 错误的, 将一个int值赋值给一个String变量

2.2 类型推导【Type Interface】

类型推导声明变量的方式, 格式如下:

var/dynamic/const/final 变量名称 = 赋值;

2.2.1 var的使用

var的使用示例：runtimeType用于获取变量当前的类型

var name = 'zhangxiaoyang';
name = "A Flutter Programmer";
print(name.runtimeType);// String

2.2.2 dynamic的使用

如果确实希望这样做,可以使用dynamic来声明变量,但是在开发中, 通常情况下不使用dynamic, 因为类型的变量会带来潜在的危险

dynamic name = 'zhangxiaoyang';
print(name.runtimeType); // String
name = 18;
print(name.runtimeType); // int

2.2.3 final & const的使用

final和const都是用于定义常量的, 也就是定义之后值都不可以修改

final name = 'zhangxiaoyang'
name = 'Flutter Dart'// 错误做法
const age = 18
age = 20// 错误做法

final和const有什么区别呢?

const在赋值时, 赋值的内容必须是在编译期间就确定下来的
final在赋值时, 可以动态获取, 比如赋值一个函数

String getName() { return 'zhangxiaoyang' }

main(List args) { const name = getName(); // 错误的做法, 因为要执行函数才能获取到值 final name = getName(); // 正确的做法 }

final和const小案例:

首先, const是不可以赋值为DateTime.now()
其次, final一旦被赋值后就有确定的结果, 不会再次赋值

// const time = DateTime.now(); // 错误的赋值方式 final time = DateTime.now(); print(time); // 2020-12-14 14:02:54.052626

sleep(Duration(seconds: 2)); print(time); // 2020-12-14 14:02:56.052626

三、数据类型

3.1 数字类型

对于数值来说，也不用关心它是否有符号，以及数据的宽度和精度等问题。只要记着整数用int，浮点数用double就行了

不过，要说明一下的是Dart中的int和double可表示的范围并不是固定的，它取决于运行Dart的平台。

// 1.整数类型int
  int age = 27;
  int hexAge = 0x1B;
  print(age);
  print(hexAge);

// 2.浮点类型double
  double height = 1.83;
  print(height);

字符串和数字之间的转化:

// 字符串和数字转化
// 1.字符串转数字
  var one = int.parse('111');
  var two = double.parse('12.22');
  print('${one} ${one.runtimeType}'); // 111 int
  print('${two} ${two.runtimeType}'); // 12.22 double

// 2.数字转字符串
  var num1 = 123;
  var num2 = 123.456;
  var num1Str = num1.toString();
  var num2Str = num2.toString();
  var num2StrD = num2.toStringAsFixed(2); // 保留两位小数
  print('${num1Str} ${num1Str.runtimeType}'); // 123 String
  print('${num2Str} ${num2Str.runtimeType}'); // 123.456 String
  print('${num2StrD} ${num2StrD.runtimeType}'); // 123.46 String

3.2 布尔类型

布尔类型中,Dart提供了一个bool的类型, 取值为true和false

// 布尔类型
var isFlag = true;
print('$isFlag ${isFlag.runtimeType}');

注意: Dart中不能判断非0即真, 或者非空即真，Dart的类型安全性意味着您不能使用if(非booleanvalue)或assert(非booleanvalue)之类的代码。

var message = 'Hello Dart';
  // 错误的写法
  if (message) {
    print(message)
}

3.3 字符串类型

Dart字符串是UTF-16编码单元的序列。您可以使用单引号或双引号创建一个字符串:

// 1.定义字符串的方式
var s1 = 'Hello World';
var s2 = "Hello Dart";
var s3 = 'Hello\'Fullter';
var s4 = "Hello'Fullter";

可以使用三个单引号或者双引号表示多行字符串:

// 2.表示多行字符串的方式
var message1 = '''
哈哈哈
呵呵呵
嘿嘿嘿''';

字符串和其他变量或表达式拼接: 使用${expression}, 如果表达式是一个标识符, 那么{}可以省略

// 3.拼接其他变量
var name = 'coderwhy';
var age = 18;
var height = 1.88;
print('my name is ${name}, age is $age, height is $height');

3.4 字符串类型

3.4.1 集合类型的定义

对于集合类型，Dart内置了最常用的三种：List / Set / Map

其中List这样定义：

//List定义
// 1.使用类型推导定义
  var letters = ['a', 'b', 'c', 'd'];
  print('$letters ${letters.runtimeType}');

// 2.明确指定类型
  List<int> numbers = [1, 2, 3, 4];
  print('$numbers ${numbers.runtimeType}');

Set可以这样来定义：

其实，也就是把[]换成{}就好了。
Set和List最大的两个不同就是：Set是无序的，并且元素是不重复的。

// Set的定义 // 1.使用类型推导定义 var lettersSet = {'a', 'b', 'c'}; print(' $lettersSet$ {lettersSet.runtimeType}');

// 2.明确指定类型 Set numbersSet = {1, 2, 3, 4}; print(' $numbersSet$ {numbersSet.runtimeType}');

最后Map可以这样定义

// 1.使用类型推导定义 
  var map1 = {'name': 'zhangxiaoyang', 'age': 27};
  print('$map1 ${map1.runtimeType}');

  // 2.明确指定类型
  Map<String, object> map2 = {'height': 183, 'province': '深圳'};
  print('$map2 ${map2.runtimeType}');

3.4.2 集合的常见操作

第一类，是所有集合都支持的获取长度的属性**length**：

// 获取集合的长度
  print(letters.length);
  print(lettersSet.length);
  print(map1.length);

第二类, 是添加/删除/包含操作

并且，对List来说，由于元素是有序的，它还提供了一个删除指定索引位置上元素的方法

// 添加/删除/包含元素
  numbers.add(5);
  numbersSet.add(5);
  print('$numbers $numbersSet');

  numbers.remove(1);
  numbersSet.remove(1);
  print('$numbers $numbersSet');

  print(numbers.contains(2));
  print(numbersSet.contains(2));

// List根据index删除元素
  numbers.removeAt(3);
  print('$numbers');

第三类，是**Map**的操作

由于它有key和value，因此无论是读取值，还是操作，都要明确是基于key的，还是基于value的，或者是基于key/value对的。

// Map的操作  
  //1.根据key获取value
  print(map1['name']); //zhangxiaoyang

  // 2.获取所有的entries
  print('${map1.entries} ${map1.entries.runtimeType}'); // (MapEntry(name: zhangxiaoyang), MapEntry(age: 27)) MappedIterable<String, MapEntry<String, Object>>

  // 3.获取所有的keys
  print('${map1.keys} ${map1.keys.runtimeType}'); // (name, age) _CompactIterable<String>

  // 4.获取所有的values
  print('${map1.values} ${map1.values.runtimeType}'); // (zhangxiaoyang, 27) _CompactIterable<Object>

  // 5.判断是否包含某个key或者value
  print('${map1.containsKey('age')} ${map1.containsValue(27)}'); //true
  
  //6.根据key删除元素
  map1.remove('age');
  print('${map1}')// {name: zhangxiaoyang}

四、函数

4.1 函数的基本定义

Dart是一种真正的面向对象语言，所以即使函数也是对象，所有也有类型, 类型就是Function。这也就意味着函数可以作为变量定义或者作为其他函数的参数或者返回值.

函数的定义方式：

返回值 函数的名称(参数列表) {
  函数体
  return 返回值
}

按照上面的定义方式，定义一个完整的函数

int sum(num num1, num num2) {
  return num1 + num2;
}

Effective Dart建议对公共的API, 使用类型注解, 但是如果我们省略掉了类型, 依然是可以正常工作的

sum(num1, num2) {
  return num1 + num2;
}

另外, 如果函数中只有一个表达式, 那么可以使用箭头语法(arrow syntax)

sum(num1, num2) => num1 + num2;

4.2 函数的参数问题

**函数的参数可以分成两类: 必须参数和可选参数，**前面使用的参数都是必须参数.

4.2.1 可选参数

可选参数可以分为 命名可选参数【用{}表示】 和 位置可选参数【用[]表示】

定义方式：

命名可选参数: {param1, param2, ...}
位置可选参数: [param1, param2, ...]

命名可选参数的演示：

printInfo(String name, {int age, double height}) {
  print('name = $name age = $age height = $height');
}

// 调用printInfo1函数
printInfo1('zhangxiaoyang'); // name=zhangxiaoyang age=null height=null
printInfo1('zhangxiaoyang', age: 27); // name=zhangxiaoyang age=27 height=null
printInfo1('zhangxiaoyang', age: 27, height: 1.83); // name=zhangxiaoyang age=27 height=1.83
printInfo1('zhangxiaoyang', height: 1.88); // name=zhangxiaoyang age=null height=1.83

位置可选参数的演示:

// 定义位置可选参数
printInfo2(String name, [int age, double height]) {
  print('name=$name age=$age height=$height');
}

// 调用printInfo2函数
printInfo2('zhangxiaoyang'); // name=zhangxiaoyang age=null height=null
printInfo2('zhangxiaoyang', 27); // name=zhangxiaoyang age=27 height=null
printInfo2('zhangxiaoyang', 27, 1.83); // name=zhangxiaoyang age=27 height=1.83

命名可选参数, 可以指定某个参数是必传的(使用@required, 有问题)

// 命名可选参数的必须
printInfo3(String name, {int age, double height, @required String province}) {
  print('name=$name age=$age height=$height province=$province');
}

4.2.2 参数默认值

参数可以有默认值, 在不传入的情况下, 使用默认值**。**注意, 只有可选参数才可以有默认值, 必须参数不能有默认值

// 参数的默认值
printInfo4(String name, {int age = 27, double height=1.83}) {
  print('name=$name age=$age height=$height');
}

Dart中的main函数就是一个接受可选的列表参数作为参数的, 所以在使用main函数时, 我们可以传入参数, 也可以不传入。

4.3 函数是一等公民

在很多语言中, 函数并不能作为一等公民来使用, 比如Java/OC. 这种限制让编程不够灵活, 所以现代的编程语言基本都支持函数作为一等公民来使用, Dart也支持。

这就意味着你可以将函数赋值给一个变量, 也可以将函数作为另外一个函数的参数或者返回值来使用。

main(List<String> args) {
  // 1.将函数赋值给一个变量
  var bar = foo;
  print(bar);

  // 2.将函数作为另一个函数的参数
  test(foo);

  // 3.将函数作为另一个函数的返回值
  var func =getFunc();
  func('kobe');
}

// 1.定义一个函数
foo(String name) {
  print('传入的name:$name');
}

// 2.将函数作为另外一个函数的参数
test(Function func) {
  func('coderwhy');
}

// 3.将函数作为另一个函数的返回值
getFunc() {
  return foo;
}

4.4 匿名函数的使用

大部分我们定义的函数都会有自己的名字，比如前面定义的foo、test函数等等。

但是某些情况下，给函数命名太麻烦了，我们可以使用没有名字的函数，这种函数可以被称之为匿名函数( anonymous function)，也可以叫lambda或者closure。

main(List<String> args) {
  // 1.定义数组
  var movies = ['1','2','3','4'];

  // 2.使用forEach遍历: 有名字的函数
  printElement(item) {
    print(item);
  }
  movies.forEach(printElement);

  // 3.使用forEach遍历: 匿名函数
  movies.forEach((item) {
    print(item);
  });
  movies.forEach((item) => print(item));
}

4.5 词法作用域

dart中的词法有自己明确的作用域范围，它是根据代码的结构({})来决定作用域范围的，优先使用自己作用域中的变量，如果没有找到，则一层层向外查找。

var name = 'global';
main(List<String> args) {
  // var name = 'main';
  void foo() {
    // var name = 'foo';
    print(name);
  }

  foo();
}

4.6 词法闭包

闭包可以访问其词法范围内的变量，即使函数在其他地方被使用，也可以正常的访问。

main(List<String> args) {
  makeAdder(num addBy) {
    return (num i) {
      return i + addBy;
    };
  }

  var adder2 = makeAdder(2);
  print(adder2(10)); // 12
  print(adder2(6)); // 8

  var adder5 = makeAdder(5);
  print(adder5(10)); // 15
  print(adder5(6)); // 11
}

4.7 返回值问题

所有函数都返回一个值。如果没有指定返回值，则语句返回null;隐式附加到函数体。

main(List<String> args) {
  print(foo()); // null
}

foo() {
  print('foo function');
}

五、运算符

这里，我只列出来相对其他语言比较特殊的运算符，因为某些运算符太简单了，不浪费时间，比如+、-、+=、==。你可能会疑惑，Dart为什么要搞出这么多特殊的运算符呢？你要坚信一点：所有这些特殊的运算符都是为了让我们在开发中可以更加方便的操作，而不是让我们的编码变得更加复杂。

5.1 除法、整除、取模运算

var num = 7;
print(num / 3); // 除法操作, 结果2.3333..
print(num ~/ 3); // 整除操作, 结果2;
print(num % 3); // 取模操作, 结果1;

5.2 ??=赋值操作

dart有一个很多语言都不具备的赋值运算符：

当变量为null时，使用后面的内容进行赋值。
当变量有值时，使用自己原来的值。

main(List<String> args) {

  var name1 = 'zhangxiaoyang';
  print(name1);
  // var name2 = 'kobe';
  var name2 = null;
  name2 ??= 'james'; 
  print(name2); // 当name2初始化为kobe时，结果为kobe，当初始化为null时，赋值了james
}

5.3 条件运算符

Dart中包含一直比较特殊的条件运算符：

expr1 ?? expr2 如果expr1是null，则返回expr2的结果;
如果expr1不是null，直接使用expr1的结果。

var temp = 'zhangxiaoyang'; var temp = null; var name = temp ?? 'kobe'; print(name);

5.4 级联语法：..

某些时候，希望对一个对象进行连续的操作，这个时候可以使用级联语法

class Person {
  String name;

  void run() {
    print("${name} is running");
  }

  void eat() {
    print("${name} is eating");
  }

  void swim() {
    print("${name} is swimming");
  }
}

main(List<String> args) {
  final p1 = Person();
  p1.name = 'zhangxiaoyang';
  p1.run();
  p1.eat();
  p1.swim();

  final p2 = Person()
              ..name = "zhangxiaoyang"
              ..run()
              ..eat()
              ..swim();
}

六、流程控制

和大部分语言的特性比较相似，这里就不再详细赘述，看一下即可。

6.1 if 和 else

和其它语法用法一样。这里有一个注意点：不支持非空即真或者非0即真，必须有明确的bool类型

6.2 循环操作

基本的for循环

for (var i = 0; i < 5; i++) {
  print(i);
}

for in遍历List和Set类型

var names = ['Zhangxiaoyang','Flutter', 'Programmer'];
for (var name in names) {
    print(name);
}

6.3 switch-case

每一个case语句，默认情况下必须以一个break结尾。

main(List<String> args) {
  var direction = 'east';
  switch (direction) {
    case 'east':
      print('东面');
      break;
    case 'south':
      print('南面');
      break;
    case 'west':
      print('西面');
      break;
    case 'north':
      print('北面');
      break;
    default:
      print('其他方向');
  }
}

七、类和对象

Dart是一个面向对象的语言，面向对象中非常重要的概念就是类，类产生了对象。

7.1 类的定义

在Dart中，定义类用class关键字。类通常有两部分组成：成员（member）和方法（method）。

定义的伪代码：

class 类名 {
  类型 成员名;
  返回值类型 方法名(参数列表) {
    方法体
  }
}

编写一个简单的Person类：

这里有一个注意点: 我们在方法中使用属性(成员/实例变量)时，并没有加this；
Dart的开发风格中，在方法中通常使用属性时，会省略this，但是有命名冲突时，this不能省略；

class Person { String name;

eat() { print('$name在吃东西'); } }

来使用这个类，创建对应的对象：【从Dart2开始，new关键字可以省略】

main(List<String> args) {
  // 1.创建类的对象
  var p = new Person(); // 直接使用Person()也可以创建

  // 2.给对象的属性赋值
  p.name = 'zhangxiaoyang';

  // 3.调用对象的方法
  p.eat();
}

7.2 构造方法

7.2.1 普通构造方法

当通过类创建一个对象时，会调用这个类的构造方法。

当类中没有明确指定构造方法时，将默认拥有一个无参的构造方法
前面的Person中就是在调用这个构造方法

我们也可以根据自己的需求，定义属于自己的构造方法：

当有了自己的构造方法时，默认的构造方法会失效，不能使用**【当然，你可能希望明确的写一个默认的构造方法，但是会和我们自定义的构造方法冲突；这是因为Dart本身不支持函数的重载【名称相同，参数不同的方式】】**
实现了toString方法

class Person { String name; int age;

Person(String name, int age) { this.name = name; this.age = age; }

@override String toString() { return 'name= $name age=$ age'; } }

另外在实现构造方法时，通常做的事情就是通过参数给属性赋值，为了简化这个过程，Dart提供了一种更加简洁的语法糖形式

上面的方法简写成下面方式

Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  // 等同于
Person(this.name, this.age);

7.2.2 命名构造方法

但是在开发中, 我们确实希望实现更多的构造方法，怎么办呢？

因为不支持方法（函数）的重载，所以我们没办法创建相同名称的构造方法。

需要使用命名构造方法:

class Person {
  String name;
  int age;

  Person() {
    name = '';
    age = 0;
  }
  // 命名构造方法
  Person.withArgments(String name, int age) {
    this.name = name;
    this.age = age;
  }

  @override
  String toString() {
    return 'name=$name age=$age';
  }
}

// 创建对象
var p1 = new Person();
print(p1);
var p2 = new Person.withArgments('zhangxiaoyang', 27);
print(p2);

在之后的开发中, 我们也可以利用命名构造方法，提供更加便捷的创建对象方式:

比如开发中，我们需要经常将一个Map转成对象，可以提供如下的构造方法

// 新的构造方法
Person.fromMap(Map<String, Object> map) {
  this.name = map['name'];
  this.age = map['age'];
}

// 通过上面的构造方法创建对象
var p3 = new Person.fromMap({'name': 'zhangxiaoyang', 'age': 27});
print(p3);

7.2.3 初始化列表

定义一个类Point, 传入x/y，可以得到它们的距离distance:

class Point {
  final num x;
  final num y;
  final num distance;

  // 错误写法
  // Point(this.x, this.y) {
  //   distance = sqrt(x * x + y * y);
  // }

  // 正确的写法
  Point(this.x, this.y) : distance = sqrt(x * x + y * y);
}

7.2.4 重定向构造方法

在某些情况下, 我们希望在一个构造方法中去调用另外一个构造方法, 这个时候可以使用重定向构造方法

在一个构造函数中，去调用另外一个构造函数（注意：是在冒号后面使用this调用）

class Person {
  String name;
  int age;

  Person(this.name, this.age);
  Person.fromName(String name) : this(name, 0);
}

7.2.5 重定向构造方法

在某些情况下，传入相同值时，希望返同一个对象，这个时候可以使用常量构造方法。默认情况创建对象时，即使传入相同的参数，创建出来的也不是同一个对象，看下面代码：

我们使用**identical(对象1, 对象2)**函数来判断两个对象是否是同一个对象:

main(List<String> args) {
  var p1 = Person('why');
  var p2 = Person('why');
  print(identical(p1, p2)); // false
}

class Person {
  String name;

  Person(this.name);
}

但是, 如果将构造方法前加const进行修饰，那么可以保证同一个参数，创建出来的对象是相同的，这样的构造方法称之为常量构造方法。

main(List<String> args) {
  var p1 = const Person('zhangxiaoyang');
  var p2 = const Person('zhangxiaoyang');
  print(identical(p1, p2)); // true
}

class Person {
  final String name;

  const Person(this.name);
}

常量构造方法有一些注意点:

注意一：拥有常量构造方法的类中，所有的成员变量必须是final修饰的.
注意二: 为了可以通过常量构造方法，创建出相同的对象，不再使用 new关键字，而是使用const关键字【如果是将结果赋值给const修饰的标识符时，const可以省略。】

7.2.6 工厂构造方法

Dart提供了factory关键字, 用于通过工厂去获取对象

main(List<String> args) {
  var p1 = Person('why');
  var p2 = Person('why');
  print(identical(p1, p2)); // true
}

class Person {
  String name;

  static final Map<String, Person> _cache = <String, Person>{};

  factory Person(String name) {
    if (_cache.containsKey(name)) {
      return _cache[name];
    } else {
      final p = Person._internal(name);
      _cache[name] = p;
      return p;
    }
  }

  Person._internal(this.name);
}

7.3 setter和getter

默认情况下，Dart中类定义的属性是可以直接被外界访问的。但是某些情况下，我们希望监控这个类的属性被访问的过程，这个时候就可以使用setter和getter了。

main(List<String> args) {
  final d = Dog("黄色");
  d.setColor = "黑色";
  print(d.getColor);
}

class Dog {
  String color;

  String get getColor {
    return color;
  }
  set setColor(String color) {
    this.color = color;
  }

  Dog(this.color);
}

7.4 类的继承

面向对象的其中一大特性就是继承，继承不仅仅可以减少我们的代码量，也是多态的使用前提。

Dart中的继承使用extends关键字，子类中使用super来访问父类。父类中的所有成员变量和方法都会被继承,，但是构造方法除外。

main(List<String> args) {
  var p = new Person();
  p.age = 27;
  p.run();
  print(p.age);
}

class Animal {
  int age;

  run() {
    print('在奔跑ing');
  }
}

class Person extends Animal {

}

子类可以拥有自己的成员变量，并且可以对父类的方法进行重写

class Person extends Animal {
  String name;

  @override
  run() {
    print('$name在奔跑ing');
  }
}

子类中可以调用父类的构造方法，对某些属性进行初始化：

子类的构造方法在执行前，将隐含调用父类的无参默认构造方法（没有参数且与类同名的构造方法）。
如果父类没有无参默认构造方法，则子类的构造方法必须在初始化列表中通过super显式调用父类的某个构造方法。

class Animal { int age;

Animal(this.age);

run() { print('在奔跑ing'); } }

class Person extends Animal { String name;

Person(String name, int age) : name=name, super(age);

@override run() { print('$name在奔跑ing'); }

@override String toString() { return 'name= $name, age=$ age'; } }

7.5 抽象类

继承是多态使用的前提。

所以在定义很多通用的**调用接口**时, 我们通常会让调用者传入父类，通过多态来实现更加灵活的调用方式。但是，父类本身可能并不需要对某些方法进行具体的实现，所以父类中定义的方法,，我们可以定义为抽象方法。

什么是 抽象方法? 在Dart中没有具体实现的方法(没有方法体)，就是抽象方法。

抽象方法，必须存在于抽象类中。
抽象类是使用abstract声明的类。

下面的代码中, Shape类就是一个抽象类, 其中包含一个抽象方法。

abstract class Shape {
  getArea();
}

class Circle extends Shape {
  double r;

  Circle(this.r);

  @override
  getArea() {
    return r * r * 3.14;
  }
}

class Reactangle extends Shape {
  double w;
  double h;

  Reactangle(this.w, this.h);

  @override
  getArea() {
    return w * h;
  }
}

注意事项:

抽象类不能实例化.
抽象类中的抽象方法必须被子类实现, 抽象类中的已经被实现方法, 可以不被子类重写.

7.6 隐式接口

Dart中的接口比较特殊, 没有一个专门的关键字来声明接口。默认情况下，定义的每个类都相当于默认也声明了一个接口，可以由其他的类来实现(因为Dart不支持多继承)。在开发中，我们通常将用于给别人实现的类声明为抽象类:

abstract class Runner {
  run();
}

abstract class Flyer {
  fly();
}

class SuperMan implements Runner, Flyer {
  @override
  run() {
    print('超人在奔跑');
  }

  @override
  fly() {
    print('超人在飞');
  }
}

7.7 类成员和方法

类中定义的成员和方法都属于对象级别的, 在开发中, 我们有时候也需要定义类级别的成员和方法。

在Dart中我们使用static关键字来定义:

main(List<String> args) {
  var stu = Student();
  stu.name = 'zhangxiaoyang';
  stu.sno = 110;
  stu.study();

  Student.time = '早上8点';
  // stu.time = '早上9点'; 错误做法, 实例对象不能访问类成员  
 ‍‍‍Student.attendClass();  // stu.attendClass(); 错误做法, 实现对象不能‍访问类方法
}

class Student {
  String name;
  int sno;

  static String time;

  study() {
    print('$name在学习');
  }

  static attendClass() {
    print('去上课');
  }
}

7.8 枚举类型

7.8.1 枚举的定义

枚举使用enum关键字来进行定义：

main(List<String> args) {
  print(Colors.red);
}

enum Colors {
  red,
  green,
  blue
}

7.8.2 枚举属性

**枚举类型中有两个比较常见的属性:
**

index: 用于表示每个枚举常量的索引, 从0开始.
values: 包含每个枚举值的List.

main(List args) { print(Colors.red.index); print(Colors.green.index); print(Colors.blue.index);

print(Colors.values); }

enum Colors { red, green, blue }

枚举类型的注意事项:

不能子类化、混合或实现枚举。
不能显式实例化一个枚举

八、泛型

8.1 List和Map的泛型

List使用时的泛型写法:

// 创建List的方式
  var names1 = ['zhangxiaoyang', 'kobe', 'james', 111];
  print(names1.runtimeType); // List<Object>

  // 限制类型
  var names2 = <String>['zhangxiaoyang', 'kobe', 'james', 111]; // 最后一个报错
  List<String> names3 = ['zhangxiaoyang', 'kobe', 'james', 111]; // 最后一个报错

Map使用时的泛型写法:

  // 创建Map的方式
  var infos1 = {1: 'one', 'name': 'zhangxiaoyang', 'age': 27}; 
  print(infos1.runtimeType); // _InternalLinkedHashMap<Object, Object>

  // 对类型进行显示
  Map<String, String> infos2 = {'name': 'zhangxiaoyang', 'age': 27}; // 27不能放在value中
  var infos3 = <String, String>{'name': 'zhangxiaoyang', 'age': 27}; // 27不能放在value中

8.2 类定义的泛型

如果需要定义一个类, 用于存储位置信息Location, 但是并不确定使用者希望使用的是int类型,还是double类型, 甚至是一个字符串, 这个时候如何定义呢?

一种方案是使用Object类型, 但是在之后使用时, 非常不方便
另一种方案就是使用泛型.

Location类的定义: Object方式

main(List<String> args) {
  Location l1 = Location(10, 20);
  print(l1.x.runtimeType); // Object
}

class Location {
  Object x;
  Object y;

  Location(this.x, this.y);
}

Location类的定义: 泛型方式

main(List<String> args) {
  Location l2 = Location<int>(10, 20);
  print(l2.x.runtimeType); // int 

  Location l3 = Location<String>('aaa', 'bbb');
  print(l3.x.runtimeType); // String
}
}

class Location<T> {
  T x;
  T y;

  Location(this.x, this.y);
}

如果我们希望类型只能是num类型, 怎么做呢?

Location l2 = Location<int>(10, 20);
print(l2.x.runtimeType);

// 错误的写法, 类型必须继承自num
Location l3 = Location<String>('aaa', 'bbb');
print(l3.x.runtimeType);
}

class Location<T extends num> {
  T x;
  T y;

  Location(this.x, this.y);
}

8.3 泛型方法的定义

最初，Dart仅仅在类中支持泛型。后来一种称为泛型方法的新语法允许在方法和函数中使用类型参数。

main(List<String> args) {
  var names = ['why', 'kobe'];
  var first = getFirst(names);
  print('$first ${first.runtimeType}'); // why String
}

T getFirst<T>(List<T> ts) {
  return ts[0];
}

九、库的使用

在Dart中，你可以导入一个库来使用它所提供的功能。库的使用可以使代码的重用性得到提高，并且可以更好的组合代码。Dart中任何一个dart文件都是一个库，即使你没有用关键字library声明

9.1 库的导入

import语句用来导入一个库，后面跟一个字符串形式的Uri来指定表示要引用的库，语法如下：

import '库所在的uri';

常见的库URI有三种不同的形式

来自dart标准版，比如dart:io、dart:html、dart:math、dart:core(但是这个可以省略)
```
//dart:前缀表示Dart的标准库，如dart:io、dart:html、dart:math
import 'dart:io';
```

使用相对路径导入的库，通常指自己项目中定义的其他dart文件

//当然，你也可以用相对路径或绝对路径的dart文件来引用
import 'lib/student/student.dart';

Pub包管理工具管理的一些库，包括自己的配置以及一些第三方的库，通常使用前缀package

//Pub包管理系统中有很多功能强大、实用的库，可以使用前缀 package:
import 'package:flutter/material.dart';

库文件中内容的显示和隐藏

如果希望只导入库中某些内容，或者刻意隐藏库里面某些内容，可以使用show和hide关键字

**show关键字：**可以显示某个成员（屏蔽其他）
**hide关键字：**可以隐藏某个成员（显示其他）

import 'lib/student/student.dart' show Student, Person;

import 'lib/student/student.dart' hide Person;

库中内容和当前文件中的名字冲突

当各个库有命名冲突的时候，可以使用as关键字来使用命名空间

import 'lib/student/student.dart' as Stu;

Stu.Student s = new Stu.Student();

9.2 库的定义

library关键字

通常在定义库时，我们可以使用library关键字给库起一个名字。

但目前我发现，库的名字并不影响导入，因为import语句用的是字符串URI

library math;

part关键字

在开发中，如果一个库文件太大，将所有内容保存到一个文件夹是不太合理的，我们有可能希望将这个库进行拆分，这个时候就可以使用part关键字了

mathUtils.dart文件

part of "utils.dart";

int sum(int num1, int num2) {
  return num1 + num2;
}

export关键字

官方不推荐使用part关键字，那如果库非常大，如何进行管理呢？

将每一个dart文件作为库文件，使用export关键字在某个库文件中单独导入