java 中抽象类和接口的组合使用,核心策略是“以接口定义契约,以抽象类提供骨架”。具体做法是让一个抽象类实现多个接口,并在其中提供通用的方法实现或状态管理,而将特定行为留给子类通过继承该抽象类并覆盖抽象方法来扩展。这样做既能利用接口解决 java 单继承的限制,又能通过抽象类复用代码,避免在每个实现类中重复编写相同的基础逻辑。

如何设计支持多种算法的通用处理框架
当需要为不同场景提供统一的处理流程,但某些步骤的具体实现差异较大时,可以采用模板方法模式结合接口与抽象类。定义一个包含所有必要步骤的接口,然后创建一个抽象基类实现这些接口,并将可变步骤标记为抽象方法。这样,调用者只需关注最终结果,而具体的算法细节由继承抽象类的子类决定。

public interface DataProcessor {
void validate();
void process();
void save();
}
public abstract class AbstractProcessor implements DataProcessor {
@Override
public final void process() {
System.out.println("Start processing...");
validate();
executeCoreLogic();
save();
System.out.println("Processing finished.");
}
protected abstract void executeCoreLogic();
}
public class JsonProcessor extends AbstractProcessor {
@Override
protected void executeCoreLogic() {
System.out.println("Parsing JSON data...");
}
@Override
public void validate() {
System.out.println("Validating JSON structure...");
}
@Override
public void save() {
System.out.println("Saving to database...");
}
}
public class XmlProcessor extends AbstractProcessor {
@Override
protected void executeCoreLogic() {
System.out.println("Parsing XML data...");
}
@Override
public void validate() {
System.out.println("Validating XML schema...");
}
@Override
public void save() {
System.out.println("Saving to file...");
}
}
运行上述代码,创建 JsonProcessor 实例并调用 process(),输出顺序固定为:先打印 "Start processing...",接着执行 validate() 打印 "Validating JSON structure...",然后执行 executeCoreLogic() 打印 "Parsing JSON data...",再执行 save() 打印 "Saving to database...",最后打印 "Processing finished."。若换成 XmlProcessor,中间两行会变为 XML 相关的验证和解析信息,但整体流程控制不变。
如何在共享状态的同时保持行为的多态性
如果多个实现类需要共享某些字段(如日志记录器、配置对象或连接池),但各自的行为逻辑不同,可以让抽象类持有这些共享状态并提供访问方法,同时实现接口以暴露行为。抽象类可以初始化这些状态,子类无需关心初始化和生命周期管理,只需专注于自身特有的业务逻辑。这种结构确保了状态的一致性,同时保留了多态调用的灵活性。
使用Atmosphere构建通过WebSocket、SSE、gRPC、WebTransport、MCP、A2A和AG-UI流传输的JVM代理网关,并带有治理钩子。

public interface Service {
String getName();
void start();
void stop();
}
public abstract class BaseService implements Service {
protected String serviceName;
protected boolean running = false;
public BaseService(String name) {
this.serviceName = name;
}
@Override
public String getName() {
return serviceName;
}
@Override
public final void start() {
if (running) return;
doInitialize();
running = true;
System.out.println(serviceName + " started.");
}
@Override
public final void stop() {
if (!running) return;
doCleanup();
running = false;
System.out.println(serviceName + " stopped.");
}
protected abstract void doInitialize();
protected abstract void doCleanup();
}
public class DatabaseService extends BaseService {
public DatabaseService() {
super("DatabaseService");
}
@Override
protected void doInitialize() {
System.out.println("Connecting to DB...");
}
@Override
protected void doCleanup() {
System.out.println("Closing DB connection...");
}
}
public class CacheService extends BaseService {
public CacheService() {
super("CacheService");
}
@Override
protected void doInitialize() {
System.out.println("Loading cache into memory...");
}
@Override
protected void doCleanup() {
System.out.println("Flushing cache to disk...");
}
}
创建 DatabaseService 实例后调用 start(),内部会先检查 running 状态,若为 false 则调用 doInitialize() 打印 "Connecting to DB...",然后将 running 设为 true 并打印 "DatabaseService started."。再次调用 start() 因 running 已为 true 而直接返回,无额外输出。调用 stop() 时,会调用 doCleanup() 打印 "Closing DB connection...",设置 running 为 false 并打印 "DatabaseService stopped."。此过程展示了共享状态 running 和 serviceName 如何在抽象类中被统一管理,而具体初始化与清理逻辑由子类多态实现。
当抽象类中的默认实现被覆盖时会发生什么
在抽象类实现接口的场景中,如果抽象类提供了某个接口方法的非抽象默认实现,而子类选择覆盖该方法,那么子类实例调用该方法时将执行子类的版本,而非抽象类的默认版本。这是 Java 多态的基本特性:运行时类型决定方法调用。如果子类没有覆盖,则调用抽象类的默认实现。这种机制允许抽象类提供“开箱即用”的功能,同时允许子类根据需要定制行为。关键在于,抽象类中的方法如果是 final 的,则不能被覆盖;如果不是 final 且不是抽象的,子类可以选择覆盖或不覆盖。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南










