Mejor manera de evitar el código duplicado si dos clases que se extienden de diferentes clases

"Favorecer la composición sobre la herencia" es una cosa útil para recordar.

Tener una clase de Door con abrir y cerrar. Incluya una Door como miembro de A y B

Voila, trabajo hecho.

Así que A.getDoor().close() . B.getDoor().open() etc.

Si necesita una interfaz común para A y B (para que pueda utilizar en algún lugar), a continuación, cree

 interface HasDoor { Door getDoor(); } 

Ahora A y B pueden extender cualquier clase que quieras e implementar HasDoor . Cualquier clase que requiera una puerta puede aceptar un HasDoor (o simplemente aceptar directamente el objeto Door ) y llamar abrir, cerrar, etc.

No hay código duplicado, flexibilidad total.

Si necesita que su Door vuelva a llamar a los métodos en A y B , cree la clase Door como abstracto e implemente en A y B como una clase interna anónima. Los métodos abstractos serán llamados de la Door y entonces usted puede hacer cualquier proceso que sea necesario en A y B cuando se llaman esos métodos.

Por ejemplo, la clase A se convierte en:

  class A implements HasDoor { private Door door = new Door() { @override void notifyDoorChanged(boolean closed) { // The door is telling us its been opened or closed } } @override public Door getDoor() { return door; } } 

Donde está la puerta:

  public abstract class Door { boolean closed; abstract notifyDoorChanged(); public void close() { closed = true; notifyDoorChanged(closed); } // etc } 

Tenga en cuenta que esto es similar al patrón de estrategia – pero no es exactamente lo mismo. El patrón de estrategia tiene un objeto maestro y, a continuación, se conectan varias estrategias (es decir, diferentes formas de puerta). Esto tiene una puerta y varios otros objetos que usan el mismo tipo de puerta, aunque usted podría extenderlo para utilizar el patrón de la estrategia y tener múltiples implementaciones de la puerta muy fácilmente.

Esta es la implementación de la respuesta publicada por Tim B. Es un enfoque muy flexible para ir con. Sigue los principios de la reutilización orientada a objetos:

1. Identificar que varía y separarlos de lo que se mantiene igual.
2. Programa a una interfaz, no una implementación.

3. Favorece la composición del objeto sobre la herencia.

   Clase pública Principal {

     public static void main(String[] args) { X x = new X(); A a = new A(); x.getDoor().open(); x.getDoor().close(); a.getDoor().open(); a.getDoor().close(); } } interface HasDoor { Door getDoor(); } interface Door { public void open(); public void close(); } class A extends B implements HasDoor { Door d; @Override public Door getDoor() { Door door = new Door() { public void open() { System.out.println("Open A's Door"); } public void close() { System.out.println("Close A's Door"); } }; return door; } 

   }

   La clase X extiende Y implementa HasDoor {Door d;

    @Override public Door getDoor() { Door door = new Door() { public void open() { System.out.println("Open X's Door"); } public void close() { System.out.println("Close X's Door"); } }; return door; } 

   }

   Clase B {} clase Y {}

Si no desea utilizar la interfaz HasDoor, puede declarar constructores dentro de la clase X y la clase A que inicializa la instancia de Puerta.

Ejemplo;

 class X extends Y { Door d; public X() { d = new Door() { public void open() { System.out.println("Open X's Door"); } public void close() { System.out.println("Close X's Door"); } }; } } 

Así que aquí su clase a y la clase a tiene que seguir las mismas funciones. Que es ambas clases tienen las mismas funciones.

Ya que las clases ya extendieron otra clase podemos usar la interfaz

 interface door { openDoor(){ } closeDoor(){ } } 

Tanto la clase a como x pueden implementar la interfaz de puerta.

Una clase puede implementar cualquier número de interfaces, pero puede extender sólo una clase.

Si la implementación de la puerta de clase es la misma que podemos hacer de esta manera

 class Door { openDoor(){ impl// } closeDoor(){ impl// } } class A extends b { Door d=new Door(); d.opendoor(); d.closeDorr(); } 

Sí, cree una clase abstracta que contenga el código común. Haga que esta clase abstracta implemente una interfaz que contenga los métodos necesarios.

Haga que ambas clases extiendan la clase abstracta.

Creo que debe crear una interfaz con métodos openDoor () y closeDoor (). Después de eso heredar las clases A y X de esta interfaz e implementar métodos. Si la implementación de métodos es similar, puede crear una clase de utilidad con métodos estáticos.

 public interface YourInterface{ public void openDoor(); public void closeDoor(); } public abstract class YourAbstractClass implements YourInterface{ public abstract void openDoor(); public abstract void closeDoor(); } public class YourClass extends YourAbstractClass{ @Override public void openDoor(); public void closeDoor(); } public class YourSubClass extends YourClass{ //you can just call super methods here super.openDoor(); super.closeDoor(); }