父包裝子類方法

Question

我讓這些Worker類做了一些工作：

class WorkerOne implements IWorker {
    @Override
    public doWork(Resource resource){
     // do some work
    }
}

我希望所有doWork()方法都被相同的操作包裝。

實現它的一種方法是創建一個抽象類，如下例所示：

abstract class WorkWrapper implements IWorker {
    @Override
    public doBetterWork(){
       Resource resource = // ...
       doWork(resource)
       resource .close();
    }
}


class WorkerOne extends WorkWrapper {

    protected doWork(Resource resource){
     // do some work
    }
}

並調用Worker作為：

WorkerOne worker = new WorkerOne();
worker.doBetterWork();

出於某些原因，我不想使用繼承。 這種包裝有更好的解決方案嗎？

Answer 1

使用可以在接口中定義的default方法，可以避免繼承（ extends ）並堅持實現（ implements ）：

class WorkerOne implements IWorker {
    @Override
    public void doWork(Resource resource){
     // do some work
    }
}

public interface IWorker {
    void doWork(Resource resource);

    default void doBetterWork(){
       Resource resource = // ...
       doWork(resource)
       reource.close();
    }
}

並像以前一樣使用它：

IWorker worker = new WorkerOne();
worker.doBetterWork(); 

我希望所有doWork（）方法都被相同的操作包裝。

就個人而言，我不喜歡非常多的設計，我在API方面暴露了兩種方法，而其中只有一種方法應該由類的客戶端調用。 這是誤導。
為了避免它，我可能會使用組合和裝飾器（不是傳統的裝飾器，因為兩個doWork()方法之間的簽名不同）。

public interface IWorker {
    void doWork(Resource resource);
}

class WorkWrapper{

    private IWorker decorated;
    public WorkWrapper(IWorker decorated){
       this.decorated = decorated;
    }
    @Override
    public doWork(){
       Resource resource = // ...
       decorated.doWork(resource);
       reource.close();
    }
}

class FooWork implements IWorker {

    @Override
    public doWork(Resource resource){
          // do something...
    } 
 }

現在不存在歧義：

WorkWrapper worker = new WorkWrapper(new FooWork());
worker.doWork(); // just this method is exposed now in WorkWrapper 

您可以將它組合到工廠以簡化操作並隱藏客戶端的實現細節：

WorkWrapper worker = FooWork.createWrapperFor();
worker.doWork(); 

Answer 2

您描述的情況似乎是應用模板方法設計模式的確切上下文。 但是，這種模式確實需要繼承。

還有其他選擇。 但是，它非常適合您的要求，我會毫不猶豫地稱它們為“更好”的解決方案。

繼承的明顯替代方法是組合。 在您的情況下，這將意味着應用策略模式。

在應用此模式時， WorkWrapper將成為上下文 ， IWorker將匹配抽象策略的角色，其實現作為具體策略 。

在代碼中：

class WorkWrapperContext {
    private IWorker strategy;

    WorkWrapperContext(IWorker strategy) { 
        this.strategy = strategy;
    }

    public void doBetterWorkOperation() {
        // do some stuff
        strategy.doWork();
    }
}