面试题：Java中抽象类不同访问修饰符的应用场景

public修饰抽象类

适用场景：当抽象类需要被任何包中的类继承时，使用public修饰。这通常用于设计通用的、可复用的基类，为整个项目或不同模块提供基础架构。
示例：

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

public class Circle extends Shape {
    private double radius;

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

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

在上述代码中，Shape抽象类使用public修饰，任何包中的类都可以继承它来实现具体的形状，如Circle类。

protected修饰抽象类

适用场景：当抽象类只希望被同一个包中的类或者其子类（无论在哪个包）继承时，使用protected修饰。这常用于框架内部的设计，允许相关的子类扩展，但对外部包隐藏细节。
示例：

package com.example.internal;

protected abstract class BaseComponent {
    protected abstract void performAction();
}

package com.example.internal;

public class SpecificComponent extends BaseComponent {
    @Override
    protected void performAction() {
        System.out.println("Specific action performed");
    }
}

// 其他包中的类无法直接继承BaseComponent
// package com.example.other;
// public class UnauthorizedComponent extends BaseComponent { // 编译错误
//     @Override
//     protected void performAction() {
//         System.out.println("Unauthorized action");
//     }
// }

在这个例子中，BaseComponent抽象类使用protected修饰，只有com.example.internal包中的类以及其子类可以继承它。

private修饰抽象类

适用场景：一般很少使用private修饰抽象类，因为抽象类的主要目的是被继承，而private修饰的类无法被外部类继承。但在某些特定的内部类结构中，当一个抽象类只服务于包含它的类，且不希望被外部访问和继承时，可以使用private修饰。
示例：

public class OuterClass {
    private abstract class InnerAbstractClass {
        private abstract void innerAbstractMethod();
    }

    private class InnerConcreteClass extends InnerAbstractClass {
        @Override
        private void innerAbstractMethod() {
            System.out.println("Inner method implementation");
        }
    }

    public void doSomething() {
        InnerConcreteClass inner = new InnerConcreteClass();
        inner.innerAbstractMethod();
    }
}

在上述代码中，InnerAbstractClass是OuterClass的私有内部抽象类，只有OuterClass内部的类可以继承它。

默认（包访问权限）修饰抽象类

适用场景：当抽象类只希望被同一个包中的类继承时，使用默认的包访问权限。这是一种相对保守的设计，将抽象类的使用范围限制在同一个包内，适用于一些只在特定包内复用的抽象结构。
示例：

package com.example.shared;

abstract class UtilityAbstract {
    abstract void utilityMethod();
}

package com.example.shared;

public class UtilityImplementation extends UtilityAbstract {
    @Override
    void utilityMethod() {
        System.out.println("Utility method implemented");
    }
}

// 其他包中的类无法继承UtilityAbstract
// package com.example.other;
// public class OtherImplementation extends UtilityAbstract { // 编译错误
//     @Override
//     void utilityMethod() {
//         System.out.println("Other implementation");
//     }
// }

在这个例子中，UtilityAbstract抽象类使用默认的包访问权限，只有com.example.shared包中的类可以继承它。

星途面试题库

面试题：Java中抽象类不同访问修饰符的应用场景

知识考点

面试题答案

public修饰抽象类

protected修饰抽象类

private修饰抽象类

默认（包访问权限）修饰抽象类