Java抽象类在API设计中的作用

Java抽象类基础概念

在深入探讨Java抽象类在API设计中的作用之前，我们先来回顾一下Java抽象类的基础概念。

什么是抽象类

在Java中，抽象类是一种不能被实例化的类，它被设计用来为其他类提供一个通用的框架。抽象类通过关键字abstract来修饰。例如：

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()。

抽象类的特点

1. 不能实例化：抽象类不能直接被实例化，即不能使用new关键字创建抽象类的对象。例如，Shape s = new Shape("red");这样的代码是错误的，会导致编译错误。
2. 包含抽象方法：抽象类可以包含抽象方法，抽象方法是只有方法声明而没有方法体的方法。抽象方法必须由子类来实现。如上述Shape类中的getArea()方法。
3. 可以包含普通方法：抽象类也可以包含普通方法，这些方法有完整的方法体，子类可以直接继承使用，如displayColor()方法。
4. 子类继承：如果一个类继承自抽象类，那么它必须实现抽象类中的所有抽象方法，除非该子类本身也是抽象类。

Java API设计概述

API（Application Programming Interface）即应用程序编程接口，它定义了一组类、接口、方法等，供其他开发者调用以实现特定功能。

API设计的目标

1. 易用性：API应该易于理解和使用，开发者能够快速上手，减少学习成本。例如，Java集合框架的API设计得非常直观，List、Set、Map等接口提供了清晰的操作方法，使得开发者可以方便地操作集合数据。
2. 可扩展性：随着业务需求的变化，API应该能够方便地进行扩展，添加新的功能而不影响现有的使用。例如，在Java的java.util.concurrent包中，随着并发编程需求的不断发展，新的并发工具类和接口不断被添加到该包中，同时保持了对旧版本代码的兼容性。
3. 稳定性：API一旦发布，应该保持相对稳定，不应该频繁地进行不兼容的修改，以免破坏依赖该API的应用程序。例如，Java的核心类库API在多年的发展中，一直保持了较高的稳定性，一些基础类和接口（如java.lang.String）的基本功能和接口一直没有大的变动。

API设计的层次结构

1. 高层抽象：在API设计中，高层抽象定义了整体的概念和框架，为开发者提供了一个宏观的视角。例如，在Java图形绘制API（如java.awt和javax.swing包）中，Component类是一个高层抽象，它定义了所有图形组件的基本属性和行为，如大小、位置、可见性等。
2. 中层实现：中层实现基于高层抽象，提供了具体的实现细节，但仍然保持一定的通用性。例如，JButton类继承自AbstractButton类，而AbstractButton类又继承自JComponent类（JComponent类是Component类的扩展）。AbstractButton类为按钮的通用行为提供了部分实现，而JButton类在此基础上进一步定制化，如添加了默认的图标、文本等属性。
3. 底层基础：底层基础为API提供了最基本的功能支持，通常与操作系统、硬件等底层资源交互。例如，在Java的I/O API中，FileInputStream和FileOutputStream类用于与文件进行字节流的读写操作，它们依赖于操作系统的文件系统功能，是实现高层I/O操作（如BufferedReader和BufferedWriter）的底层基础。

Java抽象类在API设计中的作用

提供通用框架

1. 统一行为定义 在API设计中，抽象类可以为一组相关的类定义统一的行为。例如，在一个图形绘制API中，我们可能有不同类型的图形，如圆形、矩形、三角形等。我们可以创建一个抽象的Shape类，在其中定义一些通用的行为，如获取面积、获取周长等抽象方法。

abstract class Shape {
    public abstract double getArea();
    public abstract double getPerimeter();
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }

    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double getArea() {
        return width * height;
    }

    @Override
    public double getPerimeter() {
        return 2 * (width + height);
    }
}

通过这种方式，所有继承自Shape类的具体图形类都必须实现getArea()和getPerimeter()方法，从而保证了在计算面积和周长等行为上的一致性。这使得开发者在使用这些图形类时，能够以统一的方式进行操作，提高了API的易用性。

2. 规范数据结构和操作 抽象类还可以规范数据结构和操作。例如，在一个数据库访问API中，我们可以创建一个抽象的DatabaseObject类，定义一些通用的属性和操作。

abstract class DatabaseObject {
    private int id;

    public DatabaseObject(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public abstract void save();
    public abstract void delete();
}

class User extends DatabaseObject {
    private String name;

    public User(int id, String name) {
        super(id);
        this.name = name;
    }

    @Override
    public void save() {
        // 实现将用户数据保存到数据库的逻辑
        System.out.println("Saving user " + name + " with id " + getId() + " to database.");
    }

    @Override
    public void delete() {
        // 实现从数据库中删除用户数据的逻辑
        System.out.println("Deleting user " + name + " with id " + getId() + " from database.");
    }
}

在这个例子中，DatabaseObject类定义了一个id属性和save()、delete()抽象方法。所有继承自DatabaseObject类的具体数据库对象类（如User类）都必须实现这些方法，从而规范了数据库对象的基本操作，使得数据库访问逻辑更加统一和易于管理。

实现代码复用

1. 复用通用代码 抽象类可以包含普通方法，这些普通方法的代码可以被所有子类复用。例如，在一个日志记录API中，我们可以创建一个抽象的Logger类，包含一些通用的日志记录逻辑。

abstract class Logger {
    protected String logLevel;

    public Logger(String logLevel) {
        this.logLevel = logLevel;
    }

    public void log(String message) {
        if ("DEBUG".equals(logLevel)) {
            System.out.println("[DEBUG] " + message);
        } else if ("INFO".equals(logLevel)) {
            System.out.println("[INFO] " + message);
        } else if ("ERROR".equals(logLevel)) {
            System.out.println("[ERROR] " + message);
        }
    }

    public abstract void logToFile(String message);
}

class ConsoleLogger extends Logger {
    public ConsoleLogger(String logLevel) {
        super(logLevel);
    }

    @Override
    public void logToFile(String message) {
        // 这里不实现将日志记录到文件的逻辑，因为是控制台日志记录器
        System.out.println("ConsoleLogger does not support logging to file.");
    }
}

class FileLogger extends Logger {
    private String filePath;

    public FileLogger(String logLevel, String filePath) {
        super(logLevel);
        this.filePath = filePath;
    }

    @Override
    public void logToFile(String message) {
        // 实现将日志记录到文件的逻辑
        System.out.println("Logging message '" + message + "' to file " + filePath);
    }
}

在上述代码中，Logger类的log()方法实现了根据不同日志级别打印日志的通用逻辑。ConsoleLogger和FileLogger类继承自Logger类，它们可以直接复用log()方法的代码，而只需要实现自己特有的logToFile()方法。这样，避免了在每个具体的日志记录类中重复编写日志级别判断和打印的代码，提高了代码的复用性。

2. 减少冗余代码 通过抽象类实现代码复用，可以有效地减少冗余代码。例如，在一个图形绘制API中，如果我们没有使用抽象类，每个图形类都需要自己实现一些通用的功能，如设置颜色、获取颜色等。

// 没有使用抽象类的情况
class CircleWithoutAbstract {
    private String color;
    private double radius;

    public CircleWithoutAbstract(String color, double radius) {
        this.color = color;
        this.radius = radius;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class RectangleWithoutAbstract {
    private String color;
    private double width;
    private double height;

    public RectangleWithoutAbstract(String color, double width, double height) {
        this.color = color;
        this.width = width;
        this.height = height;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getArea() {
        return width * height;
    }
}

可以看到，CircleWithoutAbstract和RectangleWithoutAbstract类中都重复编写了getColor()和setColor()方法。而使用抽象类后：

abstract class ShapeWithAbstract {
    protected String color;

    public ShapeWithAbstract(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public abstract double getArea();
}

class CircleWithAbstract extends ShapeWithAbstract {
    private double radius;

    public CircleWithAbstract(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class RectangleWithAbstract extends ShapeWithAbstract {
    private double width;
    private double height;

    public RectangleWithAbstract(String color, double width, double height) {
        super(color);
        this.width = width;
        this.height = height;
    }

    @Override
    public double getArea() {
        return width * height;
    }
}

在这种情况下，getColor()和setColor()方法被移到了抽象类ShapeWithAbstract中，CircleWithAbstract和RectangleWithAbstract类直接继承这些方法，减少了冗余代码，使代码结构更加清晰。

增强可扩展性

1. 方便添加新功能 当需要在API中添加新功能时，抽象类可以提供一个很好的扩展点。例如，在一个游戏开发API中，我们有一个抽象的GameObject类，定义了游戏对象的基本行为。

abstract class GameObject {
    public abstract void draw();
    public abstract void update();
}

class Player extends GameObject {
    @Override
    public void draw() {
        System.out.println("Drawing player.");
    }

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

class Enemy extends GameObject {
    @Override
    public void draw() {
        System.out.println("Drawing enemy.");
    }

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

如果我们现在需要为游戏对象添加碰撞检测功能，我们可以在GameObject抽象类中添加一个抽象方法checkCollision(GameObject other)。

abstract class GameObject {
    public abstract void draw();
    public abstract void update();
    public abstract boolean checkCollision(GameObject other);
}

class Player extends GameObject {
    @Override
    public void draw() {
        System.out.println("Drawing player.");
    }

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

    @Override
    public boolean checkCollision(GameObject other) {
        // 实现玩家与其他游戏对象的碰撞检测逻辑
        System.out.println("Checking player collision with other object.");
        return false;
    }
}

class Enemy extends GameObject {
    @Override
    public void draw() {
        System.out.println("Drawing enemy.");
    }

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

    @Override
    public boolean checkCollision(GameObject other) {
        // 实现敌人与其他游戏对象的碰撞检测逻辑
        System.out.println("Checking enemy collision with other object.");
        return false;
    }
}

这样，所有继承自GameObject类的具体游戏对象类都必须实现新添加的checkCollision()方法，从而方便地为整个游戏对象体系添加了碰撞检测功能，而不需要对现有的代码结构进行大规模的修改。

2. 支持多态扩展 抽象类通过多态性支持API的扩展。例如，在一个报表生成API中，我们有一个抽象的Report类，定义了生成报表的基本操作。

abstract class Report {
    public abstract void generate();
}

class SalesReport extends Report {
    @Override
    public void generate() {
        System.out.println("Generating sales report.");
    }
}

class InventoryReport extends Report {
    @Override
    public void generate() {
        System.out.println("Generating inventory report.");
    }
}

如果我们现在需要添加一种新的报表类型，如财务报表，我们只需要创建一个新的类继承自Report类，并实现generate()方法。

class FinancialReport extends Report {
    @Override
    public void generate() {
        System.out.println("Generating financial report.");
    }
}

在使用报表生成API的代码中，我们可以通过多态的方式来处理不同类型的报表，而不需要修改太多的代码。

public class ReportGenerator {
    public static void generateReports(Report[] reports) {
        for (Report report : reports) {
            report.generate();
        }
    }

    public static void main(String[] args) {
        Report[] reports = {new SalesReport(), new InventoryReport(), new FinancialReport()};
        generateReports(reports);
    }
}

这种方式使得API可以很容易地添加新的功能，同时保持代码的灵活性和可维护性。

提高稳定性

1. 限制底层实现暴露 抽象类可以隐藏底层实现细节，只向外部暴露必要的接口，从而提高API的稳定性。例如，在一个文件存储API中，我们有一个抽象的FileStorage类，定义了文件存储的基本操作。

abstract class FileStorage {
    public abstract void saveFile(String filePath, byte[] data);
    public abstract byte[] loadFile(String filePath);
}

class LocalFileStorage extends FileStorage {
    @Override
    public void saveFile(String filePath, byte[] data) {
        // 实现将文件保存到本地文件系统的逻辑
        System.out.println("Saving file " + filePath + " to local file system.");
    }

    @Override
    public byte[] loadFile(String filePath) {
        // 实现从本地文件系统加载文件的逻辑
        System.out.println("Loading file " + filePath + " from local file system.");
        return new byte[0];
    }
}

class CloudFileStorage extends FileStorage {
    @Override
    public void saveFile(String filePath, byte[] data) {
        // 实现将文件保存到云存储的逻辑
        System.out.println("Saving file " + filePath + " to cloud storage.");
    }

    @Override
    public byte[] loadFile(String filePath) {
        // 实现从云存储加载文件的逻辑
        System.out.println("Loading file " + filePath + " from cloud storage.");
        return new byte[0];
    }
}

在这个例子中，FileStorage抽象类定义了文件存储的接口，而具体的实现细节（如本地文件系统存储或云存储）被隐藏在子类中。外部使用该API的开发者只需要与FileStorage抽象类及其定义的方法进行交互，而不需要关心具体的存储实现。这样，当底层存储实现发生变化（如从本地文件系统存储改为云存储）时，只需要修改子类的代码，而不会影响到使用该API的其他代码，从而提高了API的稳定性。

2. 保证接口兼容性 抽象类定义的接口在一定程度上保证了API的兼容性。一旦抽象类的接口确定下来，只要不修改接口定义，就可以保证对依赖该API的代码的兼容性。例如，在一个图形绘制API中，Shape抽象类定义了getArea()和getPerimeter()等方法。

abstract class Shape {
    public abstract double getArea();
    public abstract double getPerimeter();
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }

    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

如果我们需要对Circle类的面积计算方法进行优化，我们可以在不改变Shape抽象类接口的情况下，在Circle类中修改getArea()方法的实现。

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double getArea() {
        // 使用更高效的算法计算面积
        return Math.PI * Math.pow(radius, 2);
    }

    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

这样，依赖Shape抽象类接口的其他代码（如用于计算一组图形总面积的代码）不会受到影响，保证了API的兼容性，使得API在发展过程中能够保持相对稳定。

抽象类与接口在API设计中的对比

语法层面的区别

1. 抽象类可以有成员变量和构造函数 抽象类可以包含成员变量，这些成员变量可以被其子类继承和使用。同时，抽象类可以有构造函数，用于初始化成员变量。例如：

abstract class AbstractClassExample {
    protected int value;

    public AbstractClassExample(int value) {
        this.value = value;
    }

    public abstract void doSomething();
}

而接口中只能定义常量（默认使用public static final修饰），不能定义普通的成员变量，也不能有构造函数。

interface InterfaceExample {
    int CONSTANT_VALUE = 10;

    void doSomething();
}

2. 抽象类可以有普通方法实现 抽象类可以包含普通方法，这些方法有完整的方法体，子类可以直接继承使用。如前面提到的Logger抽象类中的log()方法。

abstract class Logger {
    protected String logLevel;

    public Logger(String logLevel) {
        this.logLevel = logLevel;
    }

    public void log(String message) {
        if ("DEBUG".equals(logLevel)) {
            System.out.println("[DEBUG] " + message);
        } else if ("INFO".equals(logLevel)) {
            System.out.println("[INFO] " + message);
        } else if ("ERROR".equals(logLevel)) {
            System.out.println("[ERROR] " + message);
        }
    }

    public abstract void logToFile(String message);
}

接口中所有的方法都是抽象的，不能有方法体（在Java 8及以后，可以有默认方法和静态方法，但默认方法也只是提供了一种实现的方式，与抽象类的普通方法实现还是有区别的）。

interface LoggerInterface {
    void log(String message);
    void logToFile(String message);
}

设计理念的区别

1. 抽象类体现的是“is - a”关系 抽象类通常用于表示一组具有共同特征和行为的对象，子类与抽象类之间是一种“is - a”的关系。例如，Circle类继承自Shape抽象类，Circle是一种Shape，它们具有共同的属性（如颜色）和行为（如获取面积、获取周长）。

abstract class Shape {
    protected String color;

    public Shape(String color) {
        this.color = color;
    }

    public abstract double getArea();
    public abstract double getPerimeter();
}

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

    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

2. 接口体现的是“can - do”关系 接口通常用于表示一种能力或行为，实现接口的类表示它“can - do”（能够做）接口中定义的事情。例如，Runnable接口定义了一个run()方法，任何实现Runnable接口的类都表示它能够运行一个线程。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("MyRunnable is running.");
    }
}

一个类可以实现多个接口，这体现了接口的灵活性，使得一个类可以具有多种不同的能力。

在API设计中的适用场景

1. 抽象类适用于有共同实现逻辑的情况 当一组类有共同的实现逻辑，并且需要共享一些状态（成员变量）时，抽象类是一个很好的选择。例如，在一个电商系统API中，可能有Product抽象类，包含一些通用的属性（如产品名称、价格）和方法（如获取产品信息），具体的BookProduct、ElectronicsProduct等类继承自Product抽象类，并根据自身特点实现一些抽象方法。

abstract class Product {
    protected String name;
    protected double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }

    public abstract String getDetails();
}

class BookProduct extends Product {
    private String author;

    public BookProduct(String name, double price, String author) {
        super(name, price);
        this.author = author;
    }

    @Override
    public String getDetails() {
        return "Book: " + name + " by " + author + ", price: " + price;
    }
}

class ElectronicsProduct extends Product {
    private String brand;

    public ElectronicsProduct(String name, double price, String brand) {
        super(name, price);
        this.brand = brand;
    }

    @Override
    public String getDetails() {
        return "Electronics: " + name + " from " + brand + ", price: " + price;
    }
}

2. 接口适用于定义行为契约的情况 当需要定义一种行为契约，而不关心具体实现，并且一个类可能需要实现多种不同行为时，接口更为合适。例如，在一个图形处理API中，可能有Drawable接口定义了draw()方法，Shape类（可以是抽象类）和Image类都可以实现Drawable接口，以表示它们都具有可绘制的能力。

interface Drawable {
    void draw();
}

abstract class Shape implements Drawable {
    protected String color;

    public Shape(String color) {
        this.color = color;
    }

    public abstract double getArea();
    public abstract double getPerimeter();
}

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

    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a circle with color " + color);
    }
}

class Image implements Drawable {
    private String filePath;

    public Image(String filePath) {
        this.filePath = filePath;
    }

    @Override
    public void draw() {
        System.out.println("Drawing an image from " + filePath);
    }
}

设计抽象类的最佳实践

合理定义抽象方法

1. 基于通用行为抽象 在设计抽象类时，抽象方法应该基于一组相关类的通用行为进行抽象。例如，在一个图形绘制API中，Shape抽象类的getArea()和getPerimeter()方法就是基于所有图形都具有面积和周长的通用行为进行抽象的。

abstract class Shape {
    public abstract double getArea();
    public abstract double getPerimeter();
}

这样，所有继承自Shape类的具体图形类（如Circle、Rectangle等）都必须实现这些方法，保证了行为的一致性。

2. 避免过度抽象 虽然抽象类用于定义通用框架，但也应该避免过度抽象。过度抽象可能导致抽象方法难以理解和实现，增加使用API的难度。例如，在一个文件操作API中，如果定义一个抽象类FileOperation，并抽象出一个方法performFileAction()，这个方法的抽象程度就过高，因为不清楚具体要执行什么样的文件操作。更好的做法是根据具体的文件操作类型，如读取、写入、删除等，抽象出具体的方法，如readFile()、writeFile()、deleteFile()等。

abstract class FileOperation {
    public abstract void readFile(String filePath);
    public abstract void writeFile(String filePath, String content);
    public abstract void deleteFile(String filePath);
}

提供合适的构造函数和成员变量

1. 通过构造函数初始化成员变量 抽象类可以通过构造函数来初始化成员变量，这些成员变量可以被子类继承和使用。例如，在Shape抽象类中，通过构造函数初始化color成员变量。

abstract class Shape {
    protected String color;

    public Shape(String color) {
        this.color = color;
    }
}

这样，子类在创建对象时可以通过调用父类构造函数来初始化颜色属性，同时也可以根据自身需要添加更多的成员变量和构造函数。

2. 合理设置成员变量的访问修饰符 成员变量的访问修饰符应该根据实际需求合理设置。如果成员变量需要被子类直接访问，可以使用protected修饰符；如果成员变量只在抽象类内部使用，可以使用private修饰符。例如，在Shape抽象类中，color变量使用protected修饰符，因为子类可能需要获取或修改颜色。

abstract class Shape {
    protected String color;

    public Shape(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

而如果有一些内部使用的辅助变量，可以使用private修饰符。

abstract class Shape {
    protected String color;
    private int internalCounter;

    public Shape(String color) {
        this.color = color;
        this.internalCounter = 0;
    }

    // 内部使用的方法，用于操作internalCounter
    private void incrementInternalCounter() {
        internalCounter++;
    }
}

文档化抽象类

1. 注释抽象类和抽象方法 对抽象类和抽象方法进行详细的注释是非常重要的。注释应该说明抽象类的目的、功能，以及抽象方法的作用、参数和返回值等。例如，对于Shape抽象类及其getArea()方法，可以这样注释：

/**
 * 抽象的Shape类，作为所有图形类的基类，定义了图形的通用行为。
 * 所有具体的图形类（如Circle、Rectangle等）都应该继承自该类，并实现其抽象方法。
 */
abstract class Shape {
    protected String color;

    public Shape(String color) {
        this.color = color;
    }

    /**
     * 获取图形的面积。
     * @return 图形的面积，返回值类型为double。
     */
    public abstract double getArea();

    /**
     * 获取图形的周长。
     * @return 图形的周长，返回值类型为double。
     */
    public abstract double getPerimeter();
}

这样，使用该API的开发者可以通过注释快速了解抽象类和抽象方法的用途，减少学习成本。

2. 提供使用示例 除了注释，还可以提供一些使用抽象类的示例代码。例如，对于Shape抽象类，可以提供如下示例代码，展示如何创建具体的图形类并使用其方法。

public class ShapeExample {
    public static void main(String[] args) {
        Shape circle = new Circle("red", 5.0);
        System.out.println("Circle area: " + circle.getArea());
        System.out.println("Circle perimeter: " + circle.getPerimeter());

        Shape rectangle = new Rectangle("blue", 4.0, 6.0);
        System.out.println("Rectangle area: " + rectangle.getArea());
        System.out.println("Rectangle perimeter: " + rectangle.getPerimeter());
    }
}

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

    @Override
    public double getPerimeter() {
        return 2 * Math.PI * 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;
    }

    @Override
    public double getPerimeter() {
        return 2 * (width + height);
    }
}

通过示例代码，开发者可以更直观地理解如何使用抽象类及其子类，提高API的易用性。

总结抽象类在API设计中的关键要点

1. 通用框架提供者：抽象类为API中的一组相关类提供通用框架，定义统一的行为和规范数据结构及操作，使开发者能以一致方式操作相关对象，提升API易用性。例如图形绘制API里的Shape抽象类，规范了各类图形获取面积和周长的行为。
2. 代码复用推动者：借助抽象类的普通方法实现代码复用，减少冗余。像日志记录API的Logger抽象类，其子类复用log()方法，仅需实现特有方法，优化了代码结构。
3. 可扩展性增强者：方便添加新功能，通过在抽象类添加抽象方法，子类实现新功能，不影响现有代码结构。同时支持多态扩展，新类继承抽象类并实现方法，利用多态在不大量修改代码前提下添加新功能。
4. 稳定性保障者：限制底层实现暴露，抽象类隐藏具体实现细节，外部仅与抽象类接口交互，底层实现变更不影响外部代码。保证接口兼容性，只要不修改抽象类接口，就可维持对依赖代码的兼容性。
5. 与接口对比：语法上，抽象类有成员变量、构造函数和普通方法实现，接口则有不同限制。设计理念上，抽象类体现“is - a”关系，接口体现“can - do”关系。适用场景方面，抽象类适合有共同实现逻辑和共享状态的情况，接口适合定义行为契约和多行为实现。
6. 最佳实践遵循者：合理定义抽象方法，基于通用行为抽象且避免过度抽象。提供合适构造函数和成员变量，通过构造函数初始化并合理设置访问修饰符。同时文档化抽象类，注释抽象类和方法并提供使用示例，提升API易用性和可理解性。

在Java API设计中，合理运用抽象类能打造出易用、可扩展、稳定且高效的API，为开发者提供强大且便捷的编程工具。