Java抽象类的使用场景
2021-10-055.6k 阅读
一、Java抽象类基础概念回顾
在深入探讨Java抽象类的使用场景之前，我们先来回顾一下抽象类的基本概念。在Java中，使用 abstract 关键字修饰的类被称为抽象类。抽象类不能被实例化，它主要是为了给其他类提供一个通用的框架或模板。
例如，我们定义一个简单的抽象类 Shape：
abstract class Shape {
// 抽象类可以包含成员变量
protected String color;
// 构造函数
public Shape(String color) {
this.color = color;
}
// 抽象方法，没有方法体，必须由子类实现
public abstract double getArea();
// 普通方法，可以有方法体
public void displayColor() {
System.out.println("The color of the shape is " + color);
}
}
在上述代码中，Shape 类是抽象类，它包含一个成员变量 color，一个构造函数，一个抽象方法 getArea 和一个普通方法 displayColor。
二、代码复用场景
- 通用属性和方法抽取
- 当多个相关的类具有一些共同的属性和方法时，可以将这些共同部分抽取到一个抽象类中，实现代码复用。
- 例如，在一个图形绘制的项目中，有
Circle（圆形）、Rectangle（矩形）和Triangle（三角形）等图形类。这些图形都有颜色属性，并且都需要计算面积。我们可以定义一个抽象的Shape类来抽取这些共同部分。
abstract class Shape {
protected String color;
public Shape(String color) {
this.color = color;
}
public abstract double getArea();
public void displayColor() {
System.out.println("The color of the shape is " + color);
}
}
class Circle extends Shape {
private double radius;
public Circle(String color, double radius) {
super(color);
this.radius = radius;
}
@Override
public double getArea() {
return Math.PI * radius * radius;
}
}
class Rectangle extends Shape {
private double width;
private double height;
public Rectangle(String color, double width, double height) {
super(color);
this.width = width;
this.height = height;
}
@Override
public double getArea() {
return width * height;
}
}
class Triangle extends Shape {
private double base;
private double height;
public Triangle(String color, double base, double height) {
super(color);
this.base = base;
this.height = height;
}
@Override
public double getArea() {
return 0.5 * base * height;
}
}
在这个例子中，Shape 抽象类抽取了 color 属性和 displayColor 方法，Circle、Rectangle 和 Triangle 类继承自 Shape 类，复用了这些属性和方法，同时各自实现了 getArea 方法来计算自身的面积。这样，当我们需要添加新的图形类时，只需要继承 Shape 类并实现 getArea 方法即可，大大减少了代码的重复编写。
2. 避免重复代码导致的维护问题
- 如果没有抽象类进行代码复用，每个图形类都需要自己实现颜色相关的代码和面积计算的框架代码。这不仅会导致大量的重复代码，而且在维护时，如果需要修改颜色的显示方式或者面积计算的框架逻辑，就需要在每个图形类中进行修改，这很容易出现遗漏或者不一致的情况。
- 而通过抽象类，我们只需要在抽象类中修改相关的代码，所有继承自该抽象类的子类都会自动应用这些修改，提高了代码的可维护性。例如，如果我们要在显示颜色时添加一些前缀信息，只需要在
Shape类的displayColor方法中进行修改：
public void displayColor() {
System.out.println("This shape's color is " + color);
}
这样，Circle、Rectangle 和 Triangle 类的 displayColor 方法都会自动更新，无需在每个子类中进行修改。
三、定义通用接口或协议场景
- 为子类定义必须实现的方法
- 抽象类可以定义抽象方法，这些抽象方法就像是一种协议，要求子类必须实现这些方法，以确保子类具有某些特定的行为。
- 例如，在一个游戏开发项目中，有不同类型的角色，如
Warrior（战士）、Mage（法师）和Archer（弓箭手）。这些角色都需要有攻击行为，我们可以定义一个抽象的Character类：
abstract class Character {
protected String name;
public Character(String name) {
this.name = name;
}
// 抽象方法，要求子类实现攻击行为
public abstract void attack();
public void displayName() {
System.out.println("The character's name is " + name);
}
}
class Warrior extends Character {
public Warrior(String name) {
super(name);
}
@Override
public void attack() {
System.out.println(name + " attacks with a sword!");
}
}
class Mage extends Character {
public Mage(String name) {
super(name);
}
@Override
public void attack() {
System.out.println(name + " casts a fireball!");
}
}
class Archer extends Character {
public Archer(String name) {
super(name);
}
@Override
public void attack() {
System.out.println(name + " shoots an arrow!");
}
}
在上述代码中，Character 抽象类定义了 attack 抽象方法，Warrior、Mage 和 Archer 子类必须实现这个方法，从而保证每个角色都有攻击行为。这样，在游戏的核心逻辑中，我们可以统一处理不同角色的攻击行为，而不需要为每个角色类型编写特定的攻击逻辑。
2. 规范子类的行为
- 除了定义必须实现的方法，抽象类还可以通过抽象方法的参数和返回值类型来规范子类的行为。例如，假设我们有一个
DataProcessor抽象类，用于处理不同类型的数据：
abstract class DataProcessor {
// 抽象方法，处理数据并返回处理结果
public abstract String processData(String data);
}
class StringReverser extends DataProcessor {
@Override
public String processData(String data) {
StringBuilder reversed = new StringBuilder(data);
return reversed.reverse().toString();
}
}
class StringUpperCaseConverter extends DataProcessor {
@Override
public String processData(String data) {
return data.toUpperCase();
}
}
在这个例子中，DataProcessor 抽象类定义了 processData 抽象方法，要求子类必须实现该方法来处理字符串数据并返回处理后的字符串。StringReverser 和 StringUpperCaseConverter 子类按照这个规范实现了不同的处理逻辑。通过这种方式，我们可以在更高层次的代码中统一调用 processData 方法，而不必关心具体的处理细节，只要子类遵循抽象类定义的接口规范即可。
四、模板方法设计模式场景
- 模板方法模式概述
- 模板方法设计模式是一种基于抽象类的设计模式。在这种模式中，抽象类定义了一个算法的框架，将一些步骤延迟到子类中实现。抽象类提供了一个模板方法，这个方法定义了算法的整体流程，而其中的某些步骤可以是抽象的，由子类来具体实现。
- 例如，我们有一个制作咖啡和茶的场景。制作咖啡和茶都有一些共同的步骤，如烧水、冲泡和倒入杯子，但是冲泡的具体方式不同。我们可以使用模板方法模式来实现：
abstract class BeverageMaker {
// 模板方法，定义制作饮料的整体流程
public final void prepareBeverage() {
boilWater();
brew();
pourInCup();
addCondiments();
}
private void boilWater() {
System.out.println("Boiling water...");
}
private void pourInCup() {
System.out.println("Pouring into cup...");
}
// 抽象方法，由子类实现冲泡方式
protected abstract void brew();
// 抽象方法，由子类实现添加调料方式
protected abstract void addCondiments();
}
class CoffeeMaker extends BeverageMaker {
@Override
protected void brew() {
System.out.println("Brewing coffee grounds...");
}
@Override
protected void addCondiments() {
System.out.println("Adding sugar and milk...");
}
}
class TeaMaker extends BeverageMaker {
@Override
protected void brew() {
System.out.println("Steeping tea leaves...");
}
@Override
protected void addCondiments() {
System.out.println("Adding lemon...");
}
}
在上述代码中，BeverageMaker 抽象类定义了 prepareBeverage 模板方法，这个方法包含了制作饮料的整体流程。其中，boilWater 和 pourInCup 方法是固定的，而 brew 和 addCondiments 方法是抽象的，由 CoffeeMaker 和 TeaMaker 子类分别实现。这样，我们可以通过调用 prepareBeverage 方法来制作不同的饮料，而不需要为每种饮料重复编写烧水和倒入杯子的代码。
2. 模板方法模式的优势
- 代码复用：模板方法模式通过在抽象类中定义通用的算法框架，实现了代码的复用。在制作饮料的例子中，烧水和倒入杯子的代码在
BeverageMaker抽象类中只编写了一次，CoffeeMaker和TeaMaker子类都可以复用这些代码。 - 灵活性：虽然抽象类定义了算法的框架，但子类可以通过实现抽象方法来定制算法的某些步骤，从而实现不同的行为。例如，
CoffeeMaker和TeaMaker子类通过不同的brew和addCondiments实现，制作出了不同的饮料。 - 可维护性：如果需要修改算法的整体流程，只需要在抽象类的模板方法中进行修改，所有子类都会自动应用这些修改。例如，如果我们需要在冲泡之前增加一个预热杯子的步骤，只需要在
prepareBeverage方法中添加一行代码：
public final void prepareBeverage() {
preheatCup();
boilWater();
brew();
pourInCup();
addCondiments();
}
private void preheatCup() {
System.out.println("Preheating the cup...");
}
这样，CoffeeMaker 和 TeaMaker 子类的制作流程都会自动增加预热杯子的步骤，无需在每个子类中进行修改，提高了代码的可维护性。
五、框架设计场景
- 为框架提供基础结构
- 在大型Java框架的设计中，抽象类常常被用来提供基础结构。例如，在Spring框架中，
HttpServletBean是一个抽象类，它为Spring的Servlet相关组件提供了基础结构。它定义了一些通用的属性和方法，如获取Servlet的初始化参数等。 - 下面我们通过一个简单的Web框架示例来展示抽象类在框架设计中的作用。假设我们要设计一个简单的Web框架，处理不同类型的HTTP请求。我们可以定义一个抽象的
HttpRequestHandler类：
- 在大型Java框架的设计中，抽象类常常被用来提供基础结构。例如，在Spring框架中，
abstract class HttpRequestHandler {
protected String requestUrl;
public HttpRequestHandler(String requestUrl) {
this.requestUrl = requestUrl;
}
// 抽象方法，处理HTTP GET请求
public abstract void handleGetRequest();
// 抽象方法，处理HTTP POST请求
public abstract void handlePostRequest();
// 通用方法，记录请求信息
public void logRequest() {
System.out.println("Handling request for URL: " + requestUrl);
}
}
class UserInfoHandler extends HttpRequestHandler {
public UserInfoHandler(String requestUrl) {
super(requestUrl);
}
@Override
public void handleGetRequest() {
System.out.println("Returning user information for GET request...");
}
@Override
public void handlePostRequest() {
System.out.println("Updating user information for POST request...");
}
}
在这个例子中，HttpRequestHandler 抽象类为处理HTTP请求提供了基础结构，定义了处理GET和POST请求的抽象方法以及记录请求信息的通用方法。UserInfoHandler 类继承自 HttpRequestHandler 类，具体实现了处理用户信息相关的GET和POST请求的逻辑。这样，在框架的核心部分，我们可以通过统一的方式调用 HttpRequestHandler 的方法来处理不同类型的请求，而具体的请求处理逻辑由各个子类实现。
2. 便于框架的扩展和定制
- 抽象类使得框架具有良好的扩展性和定制性。其他开发者可以通过继承抽象类并实现抽象方法来为框架添加新的功能或者定制现有功能。在上述Web框架示例中，如果我们需要处理新类型的请求，如PUT请求，只需要在
HttpRequestHandler抽象类中添加一个抽象方法handlePutRequest：
abstract class HttpRequestHandler {
protected String requestUrl;
public HttpRequestHandler(String requestUrl) {
this.requestUrl = requestUrl;
}
public abstract void handleGetRequest();
public abstract void handlePostRequest();
// 新增处理PUT请求的抽象方法
public abstract void handlePutRequest();
public void logRequest() {
System.out.println("Handling request for URL: " + requestUrl);
}
}
class FileUploadHandler extends HttpRequestHandler {
public FileUploadHandler(String requestUrl) {
super(requestUrl);
}
@Override
public void handleGetRequest() {
System.out.println("Returning file upload form for GET request...");
}
@Override
public void handlePostRequest() {
System.out.println("Uploading file for POST request...");
}
@Override
public void handlePutRequest() {
System.out.println("Updating file for PUT request...");
}
}
通过这种方式，我们可以很方便地为框架添加新的请求处理逻辑，而不需要修改框架的核心代码，提高了框架的灵活性和可扩展性。
六、多态性实现场景
- 通过抽象类实现多态
- 多态性是Java的重要特性之一，抽象类在实现多态性方面发挥着重要作用。通过抽象类和继承，我们可以创建一个抽象类的引用，并将其指向不同子类的对象，从而实现多态行为。
- 继续以之前的图形绘制项目为例，我们可以在一个测试类中展示多态的实现：
public class ShapeTest {
public static void main(String[] args) {
Shape circle = new Circle("Red", 5);
Shape rectangle = new Rectangle("Blue", 4, 6);
Shape triangle = new Triangle("Green", 3, 8);
Shape[] shapes = {circle, rectangle, triangle};
for (Shape shape : shapes) {
shape.displayColor();
System.out.println("Area: " + shape.getArea());
}
}
}
在上述代码中，我们创建了 Shape 抽象类的引用 circle、rectangle 和 triangle，并将它们分别指向 Circle、Rectangle 和 Triangle 子类的对象。然后，我们将这些引用放入一个数组中，并通过遍历数组调用 displayColor 和 getArea 方法。由于多态性，Java虚拟机在运行时会根据对象的实际类型（即 Circle、Rectangle 或 Triangle）来调用相应的方法，从而实现不同图形的颜色显示和面积计算。
2. 多态性的优势
- 代码简洁性：通过多态，我们可以使用统一的方式处理不同类型的对象，而不需要为每个对象类型编写特定的处理代码。在图形绘制的例子中，我们可以通过一个
Shape数组和一个循环来处理所有图形，而不需要分别为Circle、Rectangle和Triangle编写单独的处理逻辑，使代码更加简洁。 - 可扩展性：当我们需要添加新的图形类型时，只需要创建一个新的子类继承自
Shape抽象类，并实现getArea方法。然后，在使用多态的代码中，新的图形类型可以无缝地融入现有逻辑，无需修改大量代码。例如，如果我们添加一个Square（正方形）类：
class Square extends Shape {
private double side;
public Square(String color, double side) {
super(color);
this.side = side;
}
@Override
public double getArea() {
return side * side;
}
}
在 ShapeTest 类中，我们只需要在 Shape 数组中添加一个 Square 对象，就可以像处理其他图形一样处理正方形：
public class ShapeTest {
public static void main(String[] args) {
Shape circle = new Circle("Red", 5);
Shape rectangle = new Rectangle("Blue", 4, 6);
Shape triangle = new Triangle("Green", 3, 8);
Shape square = new Square("Yellow", 7);
Shape[] shapes = {circle, rectangle, triangle, square};
for (Shape shape : shapes) {
shape.displayColor();
System.out.println("Area: " + shape.getArea());
}
}
}
这种可扩展性使得代码能够更好地适应需求的变化，提高了软件系统的灵活性和维护性。
七、限制实例化场景
- 确保抽象类不被实例化
- 抽象类的一个重要特点是不能被实例化，这有助于确保抽象类的设计目的得以实现。例如，我们定义一个
Animal抽象类，它代表所有动物的抽象概念，而不应该有直接的Animal实例，因为“动物”本身是一个抽象概念，具体的动物应该是Dog、Cat等子类的实例。
- 抽象类的一个重要特点是不能被实例化，这有助于确保抽象类的设计目的得以实现。例如，我们定义一个
abstract class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public abstract void makeSound();
}
class Dog extends Animal {
public Dog(String name) {
super(name);
}
@Override
public void makeSound() {
System.out.println(name + " barks!");
}
}
class Cat extends Animal {
public Cat(String name) {
super(name);
}
@Override
public void makeSound() {
System.out.println(name + " meows!");
}
}
在上述代码中，如果允许 Animal 类被实例化，就会违背其抽象的本质，因为“动物”本身不应该有具体的实例，只有具体的动物类型（如 Dog 和 Cat）才有意义。Java通过语法限制，不允许直接创建抽象类的实例，从而保证了抽象类的正确使用。
2. 强制使用子类实例
- 由于抽象类不能被实例化，使用抽象类的地方必须使用其子类的实例。这就强制开发者使用具体的、有实际意义的子类对象，从而更好地实现软件系统的功能。例如，在一个动物园管理系统中，我们可能有一个
AnimalManager类来管理动物：
class AnimalManager {
private Animal animal;
public AnimalManager(Animal animal) {
this.animal = animal;
}
public void makeAnimalSound() {
animal.makeSound();
}
}
在使用 AnimalManager 类时，我们必须传入 Animal 子类的实例，如 Dog 或 Cat：
public class ZooManagement {
public static void main(String[] args) {
Dog dog = new Dog("Buddy");
AnimalManager dogManager = new AnimalManager(dog);
dogManager.makeAnimalSound();
Cat cat = new Cat("Whiskers");
AnimalManager catManager = new AnimalManager(cat);
catManager.makeAnimalSound();
}
}
这样，通过抽象类的不可实例化特性，我们确保了在系统中使用的是具体的动物类型，而不是抽象的“动物”概念，使系统更加符合实际需求。
八、总结抽象类使用场景的注意事项
- 合理定义抽象类
- 在定义抽象类时，要确保抽象类确实代表了一种抽象概念，并且其中的抽象方法和通用方法是合理的。如果抽象类定义得过于宽泛或不合理，可能会导致子类实现困难或者代码逻辑混乱。例如，在定义
Shape抽象类时，我们将与图形相关的通用属性和方法抽取到抽象类中，而不是将一些与图形无关的方法也放入其中，这样可以保证抽象类的清晰性和合理性。
- 在定义抽象类时，要确保抽象类确实代表了一种抽象概念，并且其中的抽象方法和通用方法是合理的。如果抽象类定义得过于宽泛或不合理，可能会导致子类实现困难或者代码逻辑混乱。例如，在定义
- 避免过度抽象
- 虽然抽象类有助于代码复用和框架设计，但过度抽象也会带来问题。过度抽象可能导致抽象类层次过多，代码变得复杂难懂，增加开发和维护的成本。例如，如果在图形绘制项目中，我们定义了过多的抽象层次，可能会使得从抽象类到具体子类的关系变得模糊，不利于代码的理解和修改。因此，在设计抽象类时，要根据实际需求进行适度的抽象，确保抽象层次合理。
- 注意抽象类与接口的选择
- 在Java中，抽象类和接口都可以用于定义抽象类型，但它们有不同的特点和适用场景。抽象类可以包含成员变量、构造函数和具体方法，而接口只能包含抽象方法（从Java 8开始接口可以有默认方法和静态方法，但这与抽象类的特性仍有区别）。如果需要定义一些通用的属性和部分实现的方法，抽象类可能更合适；如果只需要定义一组方法的签名，而不需要任何实现和属性，接口可能是更好的选择。例如，在图形绘制项目中，
Shape抽象类包含了color属性和displayColor具体方法，所以使用抽象类更合适；而如果我们定义一个Drawable接口，只要求实现draw方法，不包含任何属性和具体方法，那么接口就是更好的选择。正确选择抽象类和接口可以使代码结构更加合理，提高代码的可读性和可维护性。
- 在Java中，抽象类和接口都可以用于定义抽象类型，但它们有不同的特点和适用场景。抽象类可以包含成员变量、构造函数和具体方法，而接口只能包含抽象方法（从Java 8开始接口可以有默认方法和静态方法，但这与抽象类的特性仍有区别）。如果需要定义一些通用的属性和部分实现的方法，抽象类可能更合适；如果只需要定义一组方法的签名，而不需要任何实现和属性，接口可能是更好的选择。例如，在图形绘制项目中，