Estoy implementando dos clases que comparten muchos métodos, pero no puedo hacer que una herede de la otra porque no tiene sentido, así que opté por una interfaz compartida con todos los métodos compartidos. pero me di cuenta de que muchos métodos también tienen la misma implementación para ambas clases, por lo que mi pregunta sería ¿cómo puedo hacer que estos métodos "hereden" de un método predeterminado como métodos "super" en herencia?
una solución en la que estoy pensando es crear una clase principal para que mis dos clases puedan heredar de ella
La herencia debe usarse cuando necesite referirse a un ancestro común, no para 'compartir' código común. Usted dice que los dos objetos no tienen esta relación pero tienen un código común; el enfoque obvio es factorizar eso en su propia clase (o interfaz o lo que sea) y componer sus objetos:
No proporcionaste un ejemplo, así que inventaré uno:
class CommonStuff { // common members here } class One { private final CommonStuff common; } class Two { private final CommonStuff common; }No hay necesidad de herencia y su acoplamiento duro inherente (juego de palabras).
Sí, Abstract Class es el enfoque correcto para esto si tiene alguna implementación predeterminada para los métodos; de lo contrario, puede optar por la interface .
Escriba toda su lógica común en sus métodos de clase abstracta y haga que estos métodos sean abstract si desea que la subclase anule la implementación; de lo contrario, no necesita convertirlos en métodos abstractos.
Para ampliar mi comentario: desea usar la composición y el patrón decorador con delegación
Por ejemplo:
public interface Foo { public void a(); public void b(); } // used as the inner class public class ConcreteFoo implements Foo { public void a() { // implementation for a } public void b() { // implementation for b } } public class MyContainerA implements Foo { private Foo innerFoo; public MyContainerA(Foo innerFoo) { this.innerFoo = innerFoo; } public void a() { // delegate the method call to the contained object innerFoo.a(); } public void b() { // delegate innerFoo.b(); } public void methodOnlyInContainerA() { } } public class MyContainerB implements Foo { private Foo innerFoo; public MyContainerB(Foo innerFoo) { this.innerFoo = innerFoo; } public void a() { innerFoo.a(); } public void b() { innerFoo.b(); } public void methodOnlyInContainerB() { } }en otra parte:
Foo foo = new ConcreteFoo(); // both guys below use the same inner class MyContainerA contA = new MyContainerA(foo); MyContainerB contB = new MyContainerB(foo);