método de la clase infantil envoltura padres

Itamar:

Tengo estas clases de trabajadores que realizan algún trabajo:

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

Quiero que todos los doWork()métodos a ser envueltos por la misma operación.

Una forma de lograrlo es la creación de una clase abstracta como el siguiente ejemplo:

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

e invocar al trabajador como:

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

Por algunas razones que prefiero no utilizar la herencia. ¿Hay una solución mejor que hacer esta envoltura?

davidxxx:

Con defaultmétodo que puede se define en las interfaces que podría evitar la herencia ( extends) y se adhieren a aplicar ( 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();
    }
}

Y utilizarlo como lo hizo anteriormente:

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

Quiero que todos los métodos DoWork (a) ser envueltos por la misma operación.

En lo personal no me gusta muchísimo diseños en los que expongo dos métodos en términos de API, mientras que sólo uno de ellos debe ser invocado por los clientes de la clase. Eso es engañoso.
Para evitarlo, probablemente utilice composición y decorador (no el decorador convencional, como los de la firma difiere entre los dos doWork()métodos).

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

Ahora no hay ambigüedades es posible:

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

Se puede combinar a la fábrica para hacer las cosas más simples y detalles de implementación que oculta de lado del cliente:

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