Flutter学习之Dart语法(三)

时间  2020-03-31
标签 flutter 学习 dart 语法 繁體版
原文   原文链接

本文首发于我的博客html

类和对象

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

类的定义

在Dart中，定义类用class关键字。 类一般有两部分组成：成员（member）和方法（method）。 定义类的伪代码以下：github

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

编写一个简单的Person类：bash

  • 这里有一个注意点: 咱们在方法中使用属性(成员/实例变量)时，并无加this；
  • Dart的开发风格中，在方法中一般使用属性时，会省略this，可是有命名冲突时，this不能省略；
class Person {
  String name;

  eat() {
    print('$name在吃东西');
  }
}
复制代码

咱们来使用这个类，建立对应的对象：ide

  • 注意：从Dart2开始，new关键字能够省略。
main(List<String> args) {
  // 1.建立类的对象
  var p = new Person(); // 直接使用Person()也能够建立

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

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

复制代码

构造方法

普通构造方法

咱们知道, 当经过类建立一个对象时，会调用这个类的构造方法。函数

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

咱们也能够根据本身的需求，定义本身的构造方法:学习

**注意一：**当有了本身的构造方法时，默认的构造方法将会失效，不能使用优化

  • 固然，你可能但愿明确的写一个默认的构造方法，可是会和咱们自定义的构造方法冲突；
  • 这是由于Dart自己不支持函数的重载（名称相同, 参数不一样的方式）。

**注意二：**这里我还实现了toString方法ui

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提供了一种更加简洁的语法糖形式. 上面的构造方法能够优化成下面的写法：this

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

复制代码

命名构造方法

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

由于不支持方法（函数）的重载，因此咱们没办法建立相同名称的构造方法。

咱们须要使用命名构造方法:

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('eagle', 18);
print(p2);

复制代码

在以后的开发中, 咱们也能够利用命名构造方法，提供更加便捷的建立对象方式:

好比开发中，咱们须要常常将一个Map转成对象，能够提供以下的构造方法

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

	// 经过上面的构造方法建立对象
  var p3 = new Person.fromMap({'name': 'kobe', 'age': 30});
  print(p3);

复制代码

初始化列表

咱们来从新定义一个类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);
}

复制代码

上面这种初始化变量的方法, 咱们称之为初始化列表(Initializer list)

重定向构造方法

在某些状况下, 咱们但愿在一个构造方法中去调用另一个构造方法, 这个时候可使用重定向构造方法：

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

class Person {
  String name;
  int age;

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

复制代码

常量构造方法

在某些状况下，传入相同值时，咱们但愿返回同一个对象，这个时候，可使用常量构造方法. 默认状况下，建立对象时，即便传入相同的参数，建立出来的也不是同一个对象，看下面代码:

这里咱们使用identical(对象1, 对象2)函数来判断两个对象是不是同一个对象:

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

class Person {
  String name;

  Person(this.name);
}

复制代码

可是, 若是将构造方法前加const进行修饰，那么能够保证同一个参数，建立出来的对象是相同的

这样的构造方法就称之为常量构造方法。

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

class Person {
  final String name;

  const Person(this.name);
}

复制代码

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

  • 注意一：拥有常量构造方法的类中，全部的成员变量必须是final修饰的.
  • 注意二: 为了能够经过常量构造方法，建立出相同的对象，再也不使用 new关键字，而是使用const关键字

若是是将结果赋值给const修饰的标识符时，const能够省略.

工厂构造方法

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

main(List<String> args) {
  var p1 = Person('eagle');
  var p2 = Person('eagle');
  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);
}

复制代码

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);
}

复制代码

类的继承

面向对象的其中一大特性就是继承，继承不只仅能够减小咱们的代码量，也是多态的使用前提。 Dart中的继承使用extends关键字，子类中使用super来访问父类。 父类中的全部成员变量和方法都会被继承,，可是构造方法除外。

main(List<String> args) {
  var p = new Person();
  p.age = 18;
  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';
  }
}

复制代码

抽象类

咱们知道，继承是多态使用的前提。 因此在定义不少通用的调用接口时, 咱们一般会让调用者传入父类，经过多态来实现更加灵活的调用方式。 可是，父类自己可能并不须要对某些方法进行具体的实现，因此父类中定义的方法,，咱们能够定义为抽象方法。 什么是 抽象方法? 在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;
  }
}

复制代码

注意事项:

**注意一：**抽象类不能实例化. **注意二：**抽象类中的抽象方法必须被子类实现, 抽象类中的已经被实现方法, 能够不被子类重写.

隐式接口

Dart中的接口比较特殊, 没有一个专门的关键字来声明接口. 默认状况下，定义的每一个类都至关于默认也声明了一个接口，能够由其余的类来实现(由于Dart不支持多继承) 在开发中，咱们一般将用于给别人实现的类声明为抽象类:

abstract class Runner {
  run();
}

abstract class Flyer {
  fly();
}

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

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

复制代码

Mixin混入

在经过implements实现某个类时，类中全部的方法都必须被从新实现(不管这个类原来是否已经实现过该方法)。 可是某些状况下，一个类可能但愿直接复用以前类的原有实现方案，怎么作呢?

使用继承吗？可是Dart只支持单继承，那么意味着你只能复用一个类的实现。

Dart提供了另一种方案: Mixin混入的方式

除了能够经过class定义类以外，也能够经过mixin关键字来定义一个类。 只是经过mixin定义的类用于被其余类混入使用，经过with关键字来进行混入。

main(List<String> args) {
  var superMan = SuperMain();
  superMan.run();
  superMan.fly();
}

mixin Runner {
  run() {
    print('在奔跑');
  }
}

mixin Flyer {
  fly() {
    print('在飞翔');
  }
}

// implements的方式要求必须对其中的方法进行从新实现
// class SuperMan implements Runner, Flyer {}

class SuperMain with Runner, Flyer {

}

复制代码

类成员和方法

前面咱们在类中定义的成员和方法都属于对象级别的, 在开发中, 咱们有时候也须要定义类级别的成员和方法 在Dart中咱们使用static关键字来定义:

main(List<String> args) {
  var stu = Student();
  stu.name = 'eagle';
  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('去上课');
  }
}

复制代码

枚举类型

枚举在开发中也很是常见, 枚举也是一种特殊的类, 一般用于表示固定数量的常量值。

枚举的定义

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

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

enum Colors {
  red,
  green,
  blue
}

复制代码

枚举的属性

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

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

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

  print(Colors.values);
}

enum Colors {
  red,
  green,
  blue
}

复制代码

枚举类型的注意事项:

  • 注意一: 您不能子类化、混合或实现枚举。
  • 注意二: 不能显式实例化一个枚举

参考 ke.qq.com/course/4697…

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程