抽象类中的可选方法实现

interface java abstract java-8

2022-09-04 21:37:24

我正在研究一些框架，我得到了一个抽象类，应该实现。

现在我得到了一些用户应该能够配置的其他东西，但它是可选的。

因此，与其使用抽象方法，不如使用抽象方法：

public abstract class AbstractModule {
    public void doSomething() {
        if (logMessage() != null)
            System.out.println(logMessage());
        doStuff();
    }

    protected abstract String logMessage(); // I'm optional
    protected abstract void doStuff();
}

我想到的只是检查一个接口实现：

public interface Log {
    String logMessage();
}

public abstract class AbstractModule {
    public void doSomething() {
        if (this instanceof Log) {
            if (((Log) this).logMessage() != null)
                System.out.println(((Log) this).logMessage());
        }
        doStuff();
    }

    protected abstract void doStuff();
}

因此，如果有人使用接口 Log 实现 AbstractModule，它也将显示该消息。我看到的实现者的好处是：她不需要关心实现logMessage（），就像在第一个例子中一样。这是一种有效的方法，还是应该以不同的方式进行？

提前致谢！

此致敬意

答案 1

我会将记录器作为模块的组件，并在抽象类中定义一个默认的无操作记录器。通过这种方式，您可以摆脱并保持灵活性。instanceof

interface Log {
    void logMessage();
}

public abstract class AbstractModule {
    protected Log log;

    public AbstractModule(){
        this.log = () -> {};
    }

    public AbstractModule(Log log){
        this.log = log;
    }

    public void doSomething() {        
        log.logMessage();        
        doStuff();
    }

    protected abstract void doStuff();
}

下面是一个扩展的示例类：AbstractModule

public class Module extends AbstractModule{

    public Module(){
        super(() -> System.out.println("message"));         
    }

    @Override
    protected void doStuff() {
        // do stuff     
    }   

}

如果要公开记录器，则可以在抽象类中为记录器定义 getter 方法：

public Log getLogger(){
    return log;
}

答案 2

由于这个问题已被标记为，另一种解决方案是使用 and 方法：java-8interfacedefault

public interface Module {
    public default void doSomething() {
        if (logMessage() != null)
            System.out.println(logMessage());
        doStuff();
    }

    public default String logMessage() { return null; } // I'm optional
    public void doStuff();
}

用法：

class NoLogModule implements Module {
    @Override
    public void doStuff() { }
}

class LogModule implements Module {

    @Override
    public void doStuff() { }

    @Override
    public String logMessage() { return "Message "; }

}

使用此方法而不是抽象类的一个优点是，您的类现在可以从另一个类自由扩展。这种方法的一个缺点是，您无法阻止某人重写该方法（根据您的代码，看起来您并不关心这一点）doSomething