首页手记 Dart的抽象类学习：从入门到上手

Dart的抽象类学习：从入门到上手

标签：

设计模式移动开发

概述

本文详细介绍了Dart的抽象类学习，包括抽象类的定义、成员实现以及应用场景。通过多个示例，解释了如何定义抽象方法、普通方法和抽象属性，并探讨了抽象类在继承层次结构中的作用。文章还讨论了抽象类和普通类的区别，并提供了常见问题解答和注意事项，帮助读者更好地理解和使用抽象类。Dart的抽象类学习是一个重要的主题，对于构建复杂和灵活的Dart应用程序至关重要。

Dart抽象类简介

Dart 是一种现代编程语言，旨在构建高效、简洁的代码。它广泛应用于Web、移动应用开发以及服务器端编程。抽象类是Dart语言中的一种特殊类，用于定义一组相关的行为和状态，但不允许直接实例化。抽象类的主要目的是提供一种设计模式，用于定义一组通用的方法和属性，而这些方法和属性的具体实现则由其子类提供。

抽象类在Dart中通过关键字 abstract 来定义。它们通常用于实现某些接口或提供一些通用的行为，但不允许直接创建对象实例。相反，抽象类必须由具体的子类来实例化，这些子类必须实现抽象类中声明的所有抽象成员。抽象类的这种特性使得它们非常适合用于定义通用的行为模板，帮助实现继承关系中的代码重用和扩展。

在Dart语言中，抽象类通过 abstract 关键字进行声明。它们可以包含抽象方法（即只有方法签名而没有实现的方法）、普通方法（具有完整实现的方法）、构造函数以及其他成员。抽象类不能被实例化，但它们的子类可以实例化，前提是子类实现了所有抽象方法。这使得抽象类成为一种强大的工具，能够定义通用的行为和结构，同时保证特定实现细节由具体的子类提供。

如何定义抽象类

在Dart中定义抽象类时，主要使用 abstract 关键字。抽象类可以包含抽象方法、普通方法、属性和构造函数。以下是如何定义一个抽象类的示例：

abstract class Animal {
  // 抽象方法
  void makeSound();

  // 普通方法
  void move() {
    print("Moving...");
  }

  // 抽象属性
  int age;
}

在这个例子中，Animal 是一个抽象类，它包含一个抽象方法 makeSound 和一个普通方法 move。此外，它还定义了一个抽象属性 age，这是一个没有初始化实现的属性。需要注意的是，抽象属性通常没有默认的实现，必须由具体的子类来实现。

抽象方法

抽象方法是仅定义了方法签名而没有实际实现的方法。所有继承自抽象类的子类都必须实现这些抽象方法。以下是定义抽象方法的语法：

abstract class Animal {
  void makeSound();
}

在这个例子中，makeSound 是一个抽象方法，它在 Animal 类中声明，但没有具体的实现。具体子类如 Dog 和 Cat 必须实现这个方法。

普通方法

普通方法是指在抽象类中已经完成实现的方法。子类可以调用这些方法，但也可以选择覆盖它们以提供不同的实现。以下是一个包含普通方法的抽象类示例：

abstract class Animal {
  void move() {
    print("Moving...");
  }
}

在这个例子中，move 是一个普通方法，它在 Animal 类中实现了具体的逻辑。子类可以继承这个方法，但也可以选择覆盖它以提供不同的行为。

抽象属性

抽象属性是指没有具体实现的属性。它们需要在具体的子类中实现。以下是如何定义抽象属性的示例：

abstract class Animal {
  int age;
}

在这个例子中，age 是一个抽象属性，它没有实现具体的初始化代码。具体子类如 Dog 和 Cat 必须实现这个属性。

通过以上的示例，可以看到抽象类在Dart语言中的定义及其不同成员的使用。接下来，将详细介绍抽象类成员的使用。

抽象类成员的理解与使用

在Dart中，抽象类成员包括抽象方法、普通方法和抽象属性，这些成员的定义和使用方式各有特点。理解和正确使用这些成员对于充分利用抽象类的功能至关重要。

抽象方法

抽象方法仅定义了方法签名，没有具体的实现。抽象方法在抽象类中声明，但必须由具体的子类提供实现。以下是一个定义抽象方法的示例：

abstract class Animal {
  void makeSound();
}

在这个例子中，makeSound 是一个抽象方法，它在 Animal 类中声明但没有具体实现。具体的子类如 Dog 和 Cat 必须实现这个方法：

class Dog extends Animal {
  @override
  void makeSound() {
    print("Woof!");
  }
}

class Cat extends Animal {
  @override
  void makeSound() {
    print("Meow!");
  }
}

通过上述代码可以看出，子类 Dog 和 Cat 必须实现抽象方法 makeSound。这样，每个子类都可以提供特定于自身的实现，从而实现多态行为。

普通方法

普通方法是在抽象类中已经完成实现的方法。这些方法可以在继承的子类中直接使用，也可以被子类覆盖以提供不同的实现。以下是一个包含普通方法的抽象类示例：

abstract class Animal {
  void move() {
    print("Moving...");
  }
}

在这个例子中，move 是一个普通方法，它在 Animal 类中实现了具体的逻辑。子类可以继承这个方法，并可以在需要时覆盖它以提供更多细节或不同的行为：

class Bird extends Animal {
  @override
  void move() {
    print("Flying...");
  }
}

在这个例子中，Bird 类继承了 Animal 类中的 move 方法，并覆盖了它，以实现更具体的飞行行为。

抽象属性

抽象属性是没有实现的具体属性。它们需要在具体的子类中实现。以下是如何定义抽象属性的示例：

abstract class Animal {
  int age;
}

在这个例子中，age 是一个抽象属性，它在 Animal 类中声明但没有实现。具体的子类如 Dog 和 Cat 必须实现这个属性：

class Dog extends Animal {
  @override
  int age = 5;
}

class Cat extends Animal {
  @override
  int age = 3;
}

通过上述代码可以看出，子类 Dog 和 Cat 分别实现了抽象属性 age，并提供了具体的值。

抽象类不能实例化

抽象类不能直接实例化。原因在于抽象类的目的在于提供一个行为模板，具体实现细节由子类提供，抽象类本身并不具备完整的实现。为了确保子类能够实现抽象成员，Dart 强制执行了这一规则。

分析实例化抽象类的尝试

考虑如下代码：

abstract class Animal {
  void makeSound();
}

void main() {
  Animal animal = Animal();  // 抛出异常：Animal is an abstract class and cannot be instantiated.
}

在这个例子中，尝试直接实例化抽象类 Animal 会导致编译错误。这是因为抽象类没有提供完整的实现，编译器要求必须通过具体的子类来实例化。

实例化具体的子类

为了实例化抽象类，必须通过具体的子类来完成。只有具体子类实现了所有抽象成员，它们才能被实例化。例如：

abstract class Animal {
  void makeSound();
}

class Dog extends Animal {
  @override
  void makeSound() {
    print("Woof!");
  }
}

void main() {
  Dog dog = Dog();
  dog.makeSound();  // 输出: Woof!
}

在这个例子中，Dog 类继承了 Animal 类，并实现了抽象方法 makeSound。因此，Dog 类实例可以被成功创建并正常使用。

抽象类的灵活性

由于抽象类不能直接实例化，它们可以灵活地提供通用的行为模板。例如，可以定义多个抽象方法，每个方法由不同的子类提供具体实现。这样，抽象类不仅定义了行为的结构，还确保了所有子类都遵循相同的接口。

抽象类与普通类的区别

抽象类和普通类在Dart中具有不同的特性和用途，理解它们的区别对于有效使用这些类来说至关重要。抽象类主要用于定义行为模板，而普通类则提供完整的实现。

抽象类

定义行为模板：抽象类通过定义抽象方法和属性来提供行为模板，具体实现留给子类。这使得抽象类非常适合构建继承层次结构，确保所有子类都遵循相同的接口。
不能实例化：抽象类不能直接实例化。它们的目的是提供一个行为模板，而具体实现则由具体的子类提供。任何尝试直接实例化抽象类的操作都会导致编译错误。
必须实现抽象方法：任何继承自抽象类的子类都必须实现所有抽象方法。这确保了抽象类定义的行为在所有子类中都能得到实现。
成员类型：抽象类可以包含抽象方法、普通方法、构造函数和属性，但至少要包含一个抽象方法或属性，否则它就失去了作为抽象类的意义。

普通类

提供完整实现：普通类提供完整的实现，包括所有方法和属性。它们可以被实例化，用于创建具体的对象。
可以实例化：普通类可以直接实例化，用于创建具体的对象。这种实例化操作不会导致任何编译错误。
实例化对象：普通类实例化后可以被直接使用，执行其中定义的方法和访问属性。而抽象类实例化需要通过具体的子类来完成。
成员类型：普通类可以包含普通方法、构造函数和属性，但不需要定义任何抽象成员。它们可以独立存在，没有强制要求实现特定行为。

示例对比

下面通过一个示例来展示抽象类和普通类的区别：

// 抽象类 Animal
abstract class Animal {
  void makeSound();  // 抽象方法
}

// 普通类 Dog
class Dog {
  void makeSound() {
    print("Woof!");
  }
}

// 实例化普通类 Dog
void main() {
  Dog dog = Dog();
  dog.makeSound();  // 输出: Woof!
}

在这个示例中，Dog 是一个普通类，它实现了 makeSound 方法。因此，可以直接实例化 Dog 类并调用 makeSound 方法。

如果尝试实例化抽象类 Animal：

void main() {
  Animal animal = Animal();  // 抛出异常：Animal is an abstract class and cannot be instantiated.
}

这段代码会导致编译错误，因为 Animal 是一个抽象类，不能直接实例化。

抽象类成员的实现

抽象类的成员包括抽象方法、普通方法和抽象属性。具体子类需要实现这些成员才能实例化。下面详细解释这些成员的实现方式：

抽象方法的实现

抽象方法是在抽象类中声明但没有实现的方法。具体子类必须实现这些方法。以下是一个示例，展示了如何在子类中实现抽象方法：

abstract class Animal {
  void makeSound();
}

class Dog extends Animal {
  @override
  void makeSound() {
    print("Woof!");
  }
}

class Cat extends Animal {
  @override
  void makeSound() {
    print("Meow!");
  }
}

void main() {
  Dog dog = Dog();
  dog.makeSound();  // 输出: Woof!

  Cat cat = Cat();
  cat.makeSound();  // 输出: Meow!
}

在这个例子中，Animal 是一个抽象类，它包含一个抽象方法 makeSound。Dog 和 Cat 类继承自 Animal 并分别实现了 makeSound 方法。通过这种方式，可以确保子类提供特定的行为实现。

普通方法的实现

普通方法是在抽象类中已经实现的方法。子类可以继承这些方法，也可以选择覆盖它们以提供不同的实现。以下是一个示例，展示了如何在子类中覆盖普通方法：

abstract class Animal {
  void move() {
    print("Moving...");
  }
}

class Bird extends Animal {
  @override
  void move() {
    print("Flying...");
  }
}

void main() {
  Bird bird = Bird();
  bird.move();  // 输出: Flying...
}

在这个例子中，Animal 类包含一个普通方法 move，而 Bird 类继承了 Animal 并覆盖了 move 方法。通过这种方式，子类可以为特定的行为提供更具体的实现。

抽象属性的实现

抽象属性是在抽象类中定义但没有具体实现的属性。具体子类必须实现这些属性以完成抽象类的实现。以下是一个示例，展示了如何在子类中实现抽象属性：

abstract class Animal {
  int age;
}

class Dog extends Animal {
  @override
  int get age => 5;
}

class Cat extends Animal {
  @override
  int get age => 3;
}

void main() {
  Dog dog = Dog();
  print(dog.age);  // 输出: 5

  Cat cat = Cat();
  print(cat.age);  // 输出: 3
}

在这个例子中，Animal 类包含一个抽象属性 age，而 Dog 和 Cat 类继承 Animal 并分别实现了 age 属性。通过这种方式，子类提供了具体的属性值。

抽象类的应用场景

抽象类在Dart编程中具有多种应用场景。它们主要用于定义行为模板，提供通用接口，以及确保子类遵循特定的行为规则。以下是一些常见的应用场景：

接口定义

抽象类可以用于定义通用接口，确保所有子类都遵循相同的行为规范。例如，考虑一个图形绘制系统，其中需要定义一个 Shape 抽象类来表示不同形状：

abstract class Shape {
  void draw();
}

class Circle extends Shape {
  @override
  void draw() {
    print("Drawing a circle...");
  }
}

class Rectangle extends Shape {
  @override
  void draw() {
    print("Drawing a rectangle...");
  }
}

void main() {
  Circle circle = Circle();
  circle.draw();  // 输出: Drawing a circle...

  Rectangle rectangle = Rectangle();
  rectangle.draw();  // 输出: Drawing a rectangle...
}

通过这种方式，抽象类 Shape 定义了一个通用的 draw 方法，所有具体的 Circle 和 Rectangle 类都必须实现这个方法。这样就能确保所有形状类都遵循相同的接口规范。

行为模板

抽象类还可以用于定义行为模板，提供通用行为的实现。例如，可以定义一个 Logger 抽象类，提供日志记录的基本行为，但具体实现可以由子类提供：

abstract class Logger {
  void log(String message);
}

class ConsoleLogger extends Logger {
  @override
  void log(String message) {
    print("Console: $message");
  }
}

class FileLogger extends Logger {
  @override
  void log(String message) {
    print("File: $message");
  }
}

void main() {
  Logger logger = ConsoleLogger();
  logger.log("This is a console log message.");

  logger = FileLogger();
  logger.log("This is a file log message.");
}

在这个例子中，Logger 抽象类定义了一个 log 方法，具体子类 ConsoleLogger 和 FileLogger 实现了这个方法，但提供了不同的日志记录方式。

行为扩展

抽象类还允许通过继承来扩展行为。例如，可以定义一个 Vehicle 抽象类，提供基本的移动行为，但具体的实现留给子类：

abstract class Vehicle {
  void move() {
    print("Moving...");
  }
}

class Car extends Vehicle {
  @override
  void move() {
    print("Car moving...");
  }
}

class Bike extends Vehicle {
  @override
  void move() {
    print("Bike moving...");
  }
}

void main() {
  Vehicle car = Car();
  car.move();  // 输出: Car moving...

  Vehicle bike = Bike();
  bike.move();  // 输出: Bike moving...
}

在这个例子中，Vehicle 抽象类提供了一个 move 方法，具体子类 Car 和 Bike 都继承了这个方法，但提供了不同的实现。这种设计方式使得代码更加模块化，易于扩展和维护。

常见问题解答与注意事项

在使用Dart中的抽象类时，经常会遇到一些常见问题和注意事项。这些问题和注意事项可以帮助开发者更好地理解和使用抽象类。

问题1：抽象类能否包含已经实现的方法？

解答：是的，抽象类可以包含已经实现的方法。这些方法在抽象类中提供了完整的实现，但子类仍可以选择覆盖这些方法以提供不同的实现。例如：

abstract class Animal {
  void move() {
    print("Moving...");
  }
}

class Bird extends Animal {
  @override
  void move() {
    print("Flying...");
  }
}

在这个例子中，Animal 抽象类包含了 move 方法，并提供了默认的实现。子类 Bird 继承了 Animal 并覆盖了 move 方法，提供了一个更具体的实现。这种设计使得抽象类可以提供默认行为，但允许子类根据需要扩展或修改这些行为。

问题2：抽象类能否包含构造函数？

解答：是的，抽象类可以包含构造函数。这些构造函数可以在抽象类中定义，但通常不会被实例化，因为抽象类本身不能直接实例化。构造函数在语法上与普通类中的构造函数相同。例如：

abstract class Animal {
  Animal(String name) {
    print("Animal $name created");
  }
}

class Dog extends Animal {
  Dog(String name) : super(name) {
    print("Dog $name created");
  }
}

在这个例子中，Animal 抽象类定义了一个构造函数，而 Dog 子类继承并调用了这个构造函数。构造函数在子类实例化时会被调用，并提供有关实例化对象的初始化信息。

问题3：抽象类是否可以包含普通属性？

解答：是的，抽象类可以包含普通属性。这些属性可以在抽象类中定义，默认情况下没有初始化实现。子类可以选择实现这些属性或提供具体的值。例如：

abstract class Animal {
  int age;
}

class Dog extends Animal {
  @override
  int age = 5;
}

class Cat extends Animal {
  @override
  int age = 3;
}

在这个例子中，Animal 抽象类定义了一个 age 属性，而具体的子类 Dog 和 Cat 实现了这个属性，并提供了具体的年龄值。这种设计使得抽象类可以定义通用的属性，但具体的实现细节由子类提供。

问题4：抽象类是否可以继承其他抽象类或普通类？

解答：是的，抽象类可以继承其他抽象类或普通类。这种继承关系可以实现更复杂的继承层次结构。例如：

abstract class Animal {
  void makeSound();
}

abstract class Mammal extends Animal {
  void feed();
}

class Dog extends Mammal {
  @override
  void makeSound() {
    print("Woof!");
  }

  @override
  void feed() {
    print("Dog is being fed...");
  }
}

在这个例子中，Mammal 抽象类继承了 Animal 抽象类，而 Dog 子类继承了 Mammal。这种层次结构使得抽象类可以定义更复杂的继承关系，提供更丰富的行为模板。

问题5：抽象类是否可以包含抽象属性？

解答：是的，抽象类可以包含抽象属性。这些属性在抽象类中定义，但没有具体的实现。具体的子类必须实现这些属性。例如：

abstract class Animal {
  int age;
}

class Dog extends Animal {
  @override
  int age = 5;
}

class Cat extends Animal {
  @override
  int age = 3;
}

在这个例子中，Animal 抽象类定义了一个抽象属性 age，而具体的子类 Dog 和 Cat 实现了这个属性，并提供了具体的年龄值。这种设计使得抽象类可以定义通用的属性，但具体的实现细节由子类提供。

注意事项1：抽象类必须包含至少一个抽象成员

抽象类必须至少包含一个抽象方法或属性，否则编译器会报错。例如：

abstract class Animal {
  // 没有抽象方法或属性，编译器会报错
}

这个例子中的 Animal 类没有定义任何抽象方法或属性，会导致编译错误。因此，抽象类不应是一个空壳。

注意事项2：子类必须实现抽象成员

任何继承自抽象类的子类都必须实现所有抽象成员。如果子类不实现所有抽象成员，也会导致编译错误。例如：

abstract class Animal {
  void makeSound();
}

class Dog extends Animal {
  // 没有实现 makeSound 方法，编译器会报错
}

在这个例子中，Dog 子类没有实现 Animal 抽象类中的 makeSound 方法，会导致编译错误。因此，确保子类实现所有抽象成员是必要的。

注意事项3：抽象类的构造函数不会被直接调用

抽象类本身不能被实例化，因此抽象类的构造函数不会被直接调用。构造函数通常在具体的子类实例化时被调用。例如：

abstract class Animal {
  Animal() {
    print("Animal created");
  }
}

class Dog extends Animal {
  Dog() : super() {
    print("Dog created");
  }
}

在这个例子中，Animal 抽象类的构造函数不会被直接调用，而是在具体的子类 Dog 实例化时被调用。这种设计使得抽象类可以提供特定的初始化逻辑，但具体的实例化由子类处理。

通过以上常见问题解答和注意事项，更好地理解和使用抽象类将有助于编写更健壮和灵活的Dart代码。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕标琳琳

手记
篇

粉丝

18

获赞与收藏

140

关注作者，订阅最新文章

阅读免费教程

设计模式入门教程

10个小节 21967 417

后端通用面试教程

41个小节 30936 346

网络编程入门教程

20个小节 12729 240

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Dart的抽象类学习：从入门到上手

Dart抽象类简介

如何定义抽象类

抽象方法

普通方法

抽象属性

抽象类成员的理解与使用

抽象方法

普通方法

抽象属性

抽象类不能实例化

分析实例化抽象类的尝试

实例化具体的子类

抽象类的灵活性

抽象类与普通类的区别

抽象类

普通类

示例对比

抽象类成员的实现

抽象方法的实现

普通方法的实现

抽象属性的实现

抽象类的应用场景

接口定义

行为模板

行为扩展

常见问题解答与注意事项

问题1：抽象类能否包含已经实现的方法？

问题2：抽象类能否包含构造函数？

问题3：抽象类是否可以包含普通属性？

问题4：抽象类是否可以继承其他抽象类或普通类？

问题5：抽象类是否可以包含抽象属性？

注意事项1：抽象类必须包含至少一个抽象成员

注意事项2：子类必须实现抽象成员

注意事项3：抽象类的构造函数不会被直接调用

阅读免费教程