Dart的语法详解系列篇（二）-- 类与函数

版权声明：本文为博主原创文章，未经博主允许不得转载。https://www.jianshu.com/p/44ae73a58ebc

转载请标明出处：
https://www.jianshu.com/p/44ae73a58ebc
本文出自 AWeiLoveAndroid的博客

---

Flutter系列博文链接 ↓：

工具安装：

• Flutter从配置安装到填坑指南详解

Flutter基础篇：

• Flutter基础篇（1）-- 跨平台开发框架和工具集锦
• Flutter基础篇（2）-- 老司机用一篇博客带你快速熟悉Dart语法
• Flutter基础篇（3）-- Flutter基础全面详解
• Flutter基础篇（4）-- Flutter填坑全面总结
• Flutter基础篇（5）-- Flutter代码模板，解放双手，提高开发效率必备
• Flutter基础篇（6）-- 水平和垂直布局详解
• Flutter基础篇（7）-- Flutter更新错误全面解决方案(图文+视频讲解)

Flutter进阶篇：

• Flutter进阶篇（1）-- 手把手带你快速上手调试Flutter项目
• Flutter进阶篇（2）-- Flutter路由详解
• Flutter进阶篇（3）-- Flutter 的手势（GestureDetector）分析详解
• Flutter进阶篇（4）-- Flutter的Future异步详解

Dart语法系列博文链接 ↓：

• Flutter基础篇（2）-- 老司机用一篇博客带你快速熟悉Dart语法(这是Dart语法系列的第一篇)
• Dart的语法详解系列篇（二）-- 类与函数
• Dart的语法详解系列篇（三）-- mixin入门
• Dart的语法详解系列篇（四）-- 泛型、异步、库等有关详解

---

本文代码同步发布在Github: https://github.com/AweiLoveAndroid/Flutter-learning/tree/master/projects/dart_demo

上一篇主要讲了数据类型、运算符、流程语句等，由于文字太多，我就把剩下的内容分开写一篇文章。
这一篇我们讲Dart的类与函数，内容较多，希望大家可以耐心看完。我也是花了很长时间研究的。喜欢的就点个赞，打个赏吧。感谢大家支持。

---

八、Dart的类与函数

Dart是一种面向对象的语言，具有类和基于mixin的继承。每个对象都是一个类的实例，所有类都来自Object。 基于Mixin的继承意味着虽然每个类（除了Object）只有一个超类，但是类体可以在多个类层次结构中重用。

（一）类的分类

（1）普通类

1).Dart使用class关键字表示一个类，对象具有由函数和数据（分别为方法和实例变量）组成的成员。

我们通过new关键字来创建一个类对象，然后使用（.）调用类里面的变量或者普通（实例，非静态）函数（注：函数和方法意思是一样的。），以便访问该对象的函数和数据。例如类Test里面有一个普通函数tests()，我们可以使用new Test().tests();来调用这个tests()函数，在Dart2里面创建对象时可以省略new关键字。

例如：

class Test{
  void tests(){}
}
void main(){
  new Test().tests();
}

2).要在运行时获取对象的类型，可以使用Object类的runtimeType属性，该属性返回一个Type对象。

如果没有指明具体类型，Dart具有类型推断机制，会自动推断变量类型。

示例如下：

  var a = 10;
  var b = 10.0;
  var c = '10';
  var d = true;
  var e = [12.5,13.1];
  var f = {3:'5',5:'11'};
  var t = new Test();// 这里就直接使用上面那个Test类 不再去重复写这个类了
  print('a 的类型是： ${a.runtimeType}'); // a 的类型是： int
  print('b 的类型是： ${b.runtimeType}'); // b 的类型是： double
  print('c 的类型是： ${c.runtimeType}'); // c 的类型是： String
  print('d 的类型是： ${d.runtimeType}'); // d 的类型是： bool
  print('e 的类型是： ${e.runtimeType}'); // e 的类型是： List
  print('f 的类型是： ${f.runtimeType}'); // f 的类型是： _InternalLinkedHashMap
  print('t 的类型是： ${t.runtimeType}'); // t 的类型是： Test
class Test{}

3). Dart和Java一样，使用extends关键字，表示一个类继承另一个类。

使用@override注解声明你要重写的函数，在这个函数内部可以使用super调用重写的这个父类的函数。

实例如下：

  class Test {
    void test() {/*这里省略方法内部的逻辑操作*/}
  // 其他逻辑
}

class TestChild extends Test {
  @override  //@override标注在test()函数上面 表示test()函数是重写父类的。
    void test() {
      super.test();// 调用父类的test()函数
      /*这里省略方法内部的逻辑操作*/
    }
    // 其他逻辑
}

@override是元数据。元数据注解以字符开头@，后跟对编译时常量（如deprecated）的引用或对常量构造函数的调用。元数据可以出现在库，类，typedef，类型参数，构造函数，工厂，函数，字段，参数或变量声明之前以及导入或导出指令之前。您可以使用反射在运行时检索元数据。
所有Dart代码都有两个注解：@deprecated和 @override。
以下是使用@deprecated 注解的示例：

class Television {
  /// _Deprecated: Use [turnOn] instead._
  @deprecated
  void activate() {
    turnOn();
  }

  // Turns the TV's power on.
  void turnOn() {
    //...
  }
}

您可以定义自己的元数据注释。

这是一个定义带有两个参数的@todo注释的示例：

library todo;

class Todo {
  final String who;
  final String what;
  const Todo(this.who, this.what);
}

// 以下是使用@todo注释的示例：
import 'todo.dart';
@Todo('seth', 'make this do something')
void doSomething() {
  print('do something');
}

4).静态变量

使用static关键字修饰的类范围的变量。
静态变量（类变量）对于类范围的状态和常量很有用。静态变量在使用之前不会初始化。

class Test {
  static const num = 16;
  // ···
}

void main() {
  print(Test. num); // 16
}

5).重写操作符

您可以重写下表中显示的运算符。

操作符名称
<	+	|	[]
>	/	^	[]=
<=	~/	&	~
>=	*	<<	==
-	%	>>

注意：!=不是可重写的运算符。表达式e1 != e2 是!(e1==e2)的语法糖。
以下是一个重写+和-运算符的类的示例：

void main(){
  final a = Testoperator(2, 3);
  final b = Testoperator(2, 2);
  var num1 = Testoperator(4, 5);
  var num2= Testoperator(0,1);
  print(a + b == num1); // true
  print(a - b == num2); // true
}

class Testoperator {
  final int x, y;

  Testoperator(this.x, this.y);

  Testoperator operator +(Testoperator o) => Testoperator(x + o.x, y + o.y);
  Testoperator operator -(Testoperator o) => Testoperator(x - o.x, y - o.y);

  // Override hashCode using strategy from Effective Java, Chapter 11.
  @override
  int get hashCode {
    int result = 17;
    result = 37 * result + x.hashCode;
    result = 37 * result + y.hashCode;
    return result;
  }

  // 如果重写了 hashCode，应该重写==操作符。
  @override
  bool operator ==(dynamic other) {
    if (other is! Testoperator) return false;
    Testoperator person = other;
    return (person.x == x &&
        person.y == y);
  }
}

6).noSuchMethod()

要在代码尝试使用不存在的方法或实例变量时检测或做出反应，您可以重写noSuchMethod()

void main() {
  TestMethod test = new TestMethod();
  dynamic f = test.foo;
  // Invokes `Object.noSuchMethod`, not `TestMethod.noSuchMethod`, so it throws.
  f(42);
}

class TestMethod {
// 除非你重写noSuchMethod，否则使用不存在的成员会导致NoSuchMethodError
  // Unless you override noSuchMethod, using a
  // non-existent member results in a NoSuchMethodError.
  @override
  void noSuchMethod(Invocation invocation) {
    print('You tried to use a non-existent member: ' +
        '${invocation.memberName}');
  }
dynamic foo();
}

你不能调用未实现的方法，除非以下的某一条是true：

• 1.接收处有静态类型dynamic
• 2.接收处定义了一个未实现的方法（abstract也是OK的）的静态类型dynamic，接收器的动态类型的实现与类noSuchMethod() 中的实现不同Object。
  有关更多信息，请参阅非正式 noSuchMethod转发规范

（2）抽象类

1).使用abstract修饰符定义抽象类（无法实例化的类）。抽象类对于定义接口非常有用，通常还有一些实现。如果希望抽象类看起来是可实例化的，请定义工厂构造函数。

抽象类通常有抽象方法。这是一个声明具有抽象方法的抽象类的示例：

// 此类声明为abstract，因此无法实例化
abstract class Test {
  //定义构造函数，字段，方法...
    
  // 抽象方法
  void test();
}

2).隐式接口

每个类都隐式定义一个接口，该接口包含该类的所有实例成员及其实现的任何接口。如果要在不继承B实现的情况下创建支持B类API的A类，则A类应实现B接口。
一个类通过在implements子句中声明它们然后提供接口所需的API来实现一个或多个接口。
例如：

void main() {
  print(sayHello(Person('李四'))); // 你好 张三. 我是 李四.
  print(sayHello(PersonImpl())); // 你好 张三  你知道我是谁吗？
}

// Person类 隐式接口包含hello()
class Person {
  // 在接口中，但是仅在此库中可见。
  final _name;

  // 不在接口中,因为这是一个构造函数
  Person(this._name);

  // 在接口中
  String hello(String who) => '你好 $who. 我是 $_name.';
}

// Person接口的实现
class PersonImpl implements Person {
  get _name => '';

  String hello(String name) => '你好 $name  你知道我是谁吗？';
}

String sayHello(Person person) => person.hello('张三'); 

一个类也可以实现多个接口，例如：
class ZhangSan implements Run,Life {
  //...
}
class Run {}
class Life {}

（3）可调用的类（Callable Class）

更多详情可以查看Dart官网： 在Dart中模拟函数
要允许像函数一样调用Dart类，请实现该call()方法。
在下面的示例中，Test类定义了一个call()方法，它接受三个字符串并连接它们，用空格分隔每个字符串，并附加一个感叹号。

void main() {
    var test = new Test();
    var result = test(166.6665,"Flutter真好玩",672);
print("$result");// 666.666 Flutter真好玩 666
}
class Test {
    // 必须是call函数
    call(double a, String b, int c) => '${a*4} ${b} ${c-6}';
}

（4）枚举类型

1.使用enum关键字声明枚举类型：

例如：enum Color { red, green, blue }

2). 枚举中的每个值都有一个index getter，它返回枚举声明中值的从零开始的位置。例如，第一个值具有索引0，第二个值具有索引1。

assert(Color.red.index == 0);
assert(Color.green.index == 1);
assert(Color.blue.index == 2);

3).要获取枚举中所有值的列表，请使用枚举values常量。

List colors = Color.values;
assert(colors[2] == Color.blue);

4).您可以在switch语句中使用枚举，如果您不处理所有枚举值，您将收到警告。

var aColor = Color.blue;
switch (aColor) {
  case Color.red:
    print('Red');
    break;
  case Color.green:
    print('Green');
    break;
  default: // 你没有这个 你会看到一个警告
    print(aColor); // 'Color.blue'
}

5).枚举类型的限制条件：

• 1.你不能在子类，mixin 或者实现枚举。
• 2.你不能显式实例化枚举。

（5）mixin

更多关于mixin的资料，可以查看 Dart2.1 mixin规范

Mixins是一种在多个类层次结构中重用类代码的方法。

1).要实现 mixin，请创建一个扩展Object的类，并且不声明构造函数。除非您希望mixin可用作常规类，否则请使用mixin关键字而不是class。

例如：

// 声明mixin
// 专家
mixin Expert {
  // 发现和解决难题
  bool solveProblems = false;
  // 精通数据结构和算法
  bool dataStructureAndAlgorithms = false;
  // 会架构设计
  bool architectureDesign = false;
  // 性能优化
  bool performanceOptimization = false;
  // 熟练掌握计算机系统
  bool computerSystem = false;

  void develop() {
    // 娱乐节目
    if (solveProblems) {
      print('发现和解决难题');
    }
    if (dataStructureAndAlgorithms) {
      print('精通数据结构和算法');
    }
    if (architectureDesign) {
      print('会架构设计');
    }
    if (performanceOptimization) {
      print('熟练掌握性能优化');
    }
    if (computerSystem) {
      print('熟练掌握计算机系统');
    }
  }
}

// 特性

// 有效率的
mixin Efficient {
  void getEfficientAttrs() {
    print('有效率的');
  }
}

// 和蔼的
mixin Kind {
  void getKindAttrs() {
    print('和蔼的');
  }
}

// 软件架构师
class SoftwareArchitect {
  SoftwareArchitect() {
    print('软件架构师');
  }
}

2).要使用 mixin，请使用with关键字后跟一个或多个mixin名称。以下示例显示了两个使用mixins的类。

void main() {
  // 姓名：张三
  // 发现和解决难题
  // 精通数据结构和算法
  // 会架构设计
  ACompanySoftwareArchitect architect1 = new ACompanySoftwareArchitect('张三');
  architect1.develop();
  print('====');
  // 姓名：李四
  // 发现和解决难题
  // 精通数据结构和算法
  // 会架构设计
  // 熟练掌握性能优化
  // 熟练掌握计算机系统
  // 有效率的
  // 和蔼的
  BCompanySoftwareArchitect architect2 = new BCompanySoftwareArchitect('李四');
  architect2.develop();
  architect2.getEfficientAttrs();
  architect2.getKindAttrs();
}

// 使用mixin
// A公司的软件架构师，继承自软件架构师，拥有专家的特性。
class ACompanySoftwareArchitect extends SoftwareArchitect with Expert {
  String name;
  ACompanySoftwareArchitect(String name) {
    this.name = name;
    print('姓名：' + name);
    solveProblems = true;
    dataStructureAndAlgorithms = true;
    architectureDesign = true;
  }

  @override
  void develop() {
    super.develop();
  }
}

//  B公司的软件架构师，继承自软件架构师，
class BCompanySoftwareArchitect extends SoftwareArchitect
    with Expert, Efficient, Kind {
  String name;

  BCompanySoftwareArchitect(String name) {
    this.name = name;
    print('姓名：' + name);
    solveProblems = true;
    dataStructureAndAlgorithms = true;
    architectureDesign = true;
    performanceOptimization = true;
    computerSystem = true;
  }
}

3).要指定只有某些类型可以使用mixin。例如，所以你的mixin可以调用它没有定义的方法， 用于on指定所需的超类。

mixin SoftwareDeveloper on ACompanySoftwareArchitect{}

---

（二）泛型

如果您查看基本数组类型的API文档 List，您会看到该类型实际上是List。<...>表示法将List标记为 泛型（或参数化）类型 - 具有正式类型参数的类型。按照惯例，大多数类型变量都有单字母名称，例如E，T，S，K和V`.

（1）为什么使用泛型？

类型安全通常需要泛型，但它们比仅允许代码运行有更多好处：

1).正确指定泛型类型可以生成更好的代码。

如果您希望列表只包含字符串，则可以将其声明为List（将其读作“字符串列表”）。这样一来，工具可以检测到将非字符串分配给列表可能是一个错误。
例子：

var names = List();
names.addAll(['Seth', 'Kathy', 'Lars']);
// 报错 The argument type 'int' can't be assigned to the parameter type 'String'.
names.add(42); 

2).您可以使用泛型来减少代码重复。

泛型允许您在多种类型之间共享单个接口和实现，同时仍然利用静态分析。
例如：创建了一个用于缓存对象的接口：

abstract class ObjectCache {
  Object getByKey(String key);
  void setByKey(String key, Object value);
}

您发现需要此接口针对字符串的做一个缓存，因此您需要创建另一个接口：

abstract class StringCache {
  String getByKey(String key);
  void setByKey(String key, String value);
}

如果还有其他更改，就要写很多接口。

class Test1 extends ObjectCache {
  @override
  Object getByKey(String key) {
    return 'object cache';
  }

  @override
  void setByKey(String key, Object value) {
    return null;
  }
}

class Test2 extends StringCache {
  @override
  String getByKey(String key) {
    return 'String cache';
  }

  @override
  void setByKey(String key, String value) {
    return null;
  }
}

泛型可以省去创建所有这些接口的麻烦。你可以创建一个带有类型参数的接口。
示例如下：T是一个占位符，您可以将其视为开发人员稍后定义的类型。

abstract class Cache {
  T getByKey(String key);
}

使用泛型以前的调用方式

print(new Test1().getByKey('123'));
print(new Test2().getByKey('456'));

（2）使用集合文字

list和map文字可以参数化。参数化文字就像你已经看到的文字一样，除了你在开始括号之前添加 （对于list）或 （对于map）。
以下是使用类型文字(typed literals)的示例：

var numbers = ['11', '22', '33'];
var pages = {
  'index.html': 'Homepage',
  'store.html': 'Store',
  'mine.html': 'Mine'
};

（3）使用带有构造函数的参数化类型

要在使用构造函数时指定一个或多个类型，请将类型放在类名称后面的尖括号<...>中。

例如：

var names = List();
names.addAll(['Seth', 'Kathy', 'Lars']);
var nameSet = Set.from(names);

以下代码创建一个具有整数的key和View类型的value的map：

var views = Map();

（4）泛型集合及其包含的类型

Dart的泛型类型是具体的。也就说，它们在运行时会会携带类型信息。

var names = List();
names.addAll(['Seth', 'Kathy', 'Lars']);
print(names is List); // true
print(names.runtimeType); // List

注意：相反，Java中的泛型使用擦除，这意味着在运行时删除泛型类型参数。在Java中，您可以测试对象是否为List，但您无法测试它是否是List。

（5）限制参数类型

实现泛型类型时，您可能希望限制其参数的类型。你可以在<>里面使用extends。
例如：

abstract class SomeBaseClass {
    // 其他操作
}

class Foo {
  String toString() {
      return "Instance of Foo<$T>";
  }
}

class Extender extends SomeBaseClass {
     //其他操作
}

现在可以使用SomeBaseClass或它的任何子类作为泛型参数。

例如：

void main() {
    var someBaseClassFoo = Foo();
    var extenderFoo = Foo();
    print(someBaseClassFoo.toString());// Instance of Foo
    print(extenderFoo.toString());// Instance of Foo
}

也可以不指定泛型参数。
例如：

var foo = Foo();

//等同于print(foo.toString());

print(foo);// Instance of Foo

如果指定任何非SomeBaseClass类型会导致错误。
例如：var foo = Foo