Java知识点 丨 Java抽象类的作用是什么？

Java抽象类的作用是定义一组相关类的通用行为和属性，并通过抽象方法强制子类实现特定的行为。下面详细论述一下Java抽象类的几个主要作用：

1、定义通用行为：

抽象类可以用于定义一组相关类的共同行为。通过抽象类，可以将这些共同行为抽象为方法，并在抽象类中进行实现。子类继承抽象类后，可以直接使用这些通用的方法，无需重复编写相同的代码。

例如，假设我们有一组形状类，包括圆形、矩形和三角形。这些形状类都具有计算面积和周长的方法。我们可以定义一个抽象类Shape，其中包含计算面积和周长的抽象方法，然后让这些形状类继承Shape类并实现这些抽象方法。这样，我们可以在抽象类中定义通用的行为，避免在每个形状类中重复实现计算面积和周长的逻辑。

2、强制子类实现特定行为：

抽象类可以包含抽象方法，这些方法没有具体的实现。子类必须实现这些抽象方法，否则子类也必须声明为抽象类。通过抽象方法的存在，抽象类可以强制其子类实现特定的行为，确保子类具有某些必要的功能。

继续上述形状类的例子，抽象类Shape中可以定义一个抽象方法calculateArea()，要求子类实现该方法以计算形状的面积。这样，无论是圆形、矩形还是三角形，都必须实现自己的calculateArea()方法，确保每个形状类都具有计算面积的功能。

3、实现多态性：

抽象类是实现多态性的重要机制之一。通过将抽象类作为参数类型或返回类型，可以实现方法的参数多态和返回值多态。这样可以让程序更加灵活，能够处理不同子类对象的统一接口。

假设我们有一个图形工具类，其中有一个方法draw(Shape shape)用于绘制形状。Shape类是抽象类，它有多个子类，如Circle、Rectangle和Triangle。通过将Shape类作为参数类型，可以接受任意形状的对象作为参数，并调用其相应的方法。这样，在调用draw()方法时，可以传入不同的子类对象，实现多态性的效果。

abstract class Shape {
    public abstract void draw();
}

class Circle extends Shape {
    public
       @Override
       public void draw() {
           System.out.println("Drawing a circle");
       }
   }

   class Rectangle extends Shape {
       @Override
       public void draw() {
           System.out.println("Drawing a rectangle");
       }
   }

   class Triangle extends Shape {
       @Override
       public void draw() {
           System.out.println("Drawing a triangle");
       }
   }

   public class GraphicsTool {
       public void draw(Shape shape) {
           shape.draw();
       }
   }

   public class Main {
       public static void main(String[] args) {
           GraphicsTool tool = new GraphicsTool();

           Shape circle = new Circle();
           Shape rectangle = new Rectangle();
           Shape triangle = new Triangle();

           tool.draw(circle);      // 输出：Drawing a circle
           tool.draw(rectangle);   // 输出：Drawing a rectangle
           tool.draw(triangle);    // 输出：Drawing a triangle
       }
   }

在上述示例中，Shape类是抽象类，它定义了一个抽象方法draw()。Circle、Rectangle和Triangle是Shape类的子类，它们分别实现了draw()方法。GraphicsTool类有一个draw()方法，接受一个Shape类型的参数，并调用其draw()方法。在Main类中，我们创建了不同的形状对象，并使用GraphicsTool类的draw()方法进行绘制。通过将不同的子类对象传入draw()方法，实现了多态性的效果。

4、提供模板方法：

抽象类可以定义模板方法，这些方法提供了算法的框架，但允许子类根据需要实现特定的步骤。模板方法在设计模式中非常常见，它提供了一种标准的方法实现，并允许子类根据实际情况进行定制。

例如，假设我们有一个游戏开发框架，其中有一个抽象类Game，它定义了游戏的基本逻辑流程。Game类中有一个模板方法play()，它定义了游戏的整体流程，包括初始化、开始游戏、更新状态和结束游戏等步骤。这些步骤可以在抽象类中实现，但具体的实现细节可以留给子类去实现。

abstract class Game {
    public final void play() {
        initialize();
        startGame();
        update();
        endGame();
    }

    public abstract void initialize();
    public abstract void startGame();
    public abstract void update();
    public abstract void endGame();
}

class Chess extends Game {
    @Override
    public void initialize() {
        System.out.println("Initializing chess game");
    }

    @Override
    public void startGame() {
        System.out.println("Starting chess game");
    }

    @Override
    public void update() {
        System.out.println("Updating chess game");
    }

    @Override
    public void endGame() {
        System.out.println("Ending chess game");
    }
}

class Poker extends Game {
    @Override
    public void initialize() {
        System.out.println("Initializing poker game");
       }

       @Override
       public void startGame() {
           System.out.println("Starting poker game");
       }

       @Override
       public void update() {
           System.out.println("Updating poker game");
       }

       @Override
       public void endGame() {
           System.out.println("Ending poker game");
       }
   }

   public class Main {
       public static void main(String[] args) {
           Game chess = new Chess();
           Game poker = new Poker();

           chess.play();
           // 输出：
           // Initializing chess game
           // Starting chess game
           // Updating chess game
           // Ending chess game

           poker.play();
           // 输出：
           // Initializing poker game
           // Starting poker game
           // Updating poker game
           // Ending poker game
       }
   }

在上述示例中，Game类是抽象类，定义了游戏的基本逻辑流程，并提供了一个模板方法play()。Chess和Poker是Game类的子类，它们分别实现了抽象方法，具体实现了初始化、开始游戏、更新状态和结束游戏的逻辑。在Main类中，我们创建了Chess和Poker对象，并调用它们的play()方法，实现了游戏的流程。通过使用模板方法，抽象类提供了一个标准的方法实现框架，并允许子类根据具体需求进行定制化实现。

以上是关于Java抽象类的作用的详细论述，并通过示例代码说明了抽象类在实际编程中的应用场景和用法。抽象类在面向对象编程中发挥着重要的作用，提供了代码复用、强制子类实现、多态性和模板方法等功能，帮助提高代码的可维护性、扩展性和灵活性。

黑马程序员Java零基础视频教程_上部(Java入门，含斯坦福大学练习题+力扣算法题和大厂java面试题）

黑马程序员Java零基础视频教程_下部(Java入门，含斯坦福大学练习题+力扣算法题和大厂java面试题）