es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Evitando la dependencia circular entre Arena y Portal.

12 Jul, 2023 Programación

Estoy tratando de resolver esta dependencia circular mientras prefiero mantener ambos objetos inmutables.

public class Arena {

    private final Portal portal;

    Arena(Portal portal) {
        this.portal = portal;
    }

    void close() {
        portal.close();
    }

    void start() {

    }
}

public class Portal {

    private final Arena arena;

    Portal(Arena arena) {
        this.arena = arena;
    }

    void close() {

    }

    void start() {
        arena.start();
    }

}

Básicamente, necesito que el portal pueda activarse y comenzar la arena. Por otro lado, necesito que la Arena se reinicie y cierre tanto a sí misma como al portal. Encontré una solución al tener dos HashMaps <arena, portal=""> y <portal, arena="">, sin embargo, quiero averiguar si hay una mejor manera de resolver esto para aprendizaje y progresión.

Las clases se simplifican aquí, ya que en realidad tienen más variables e identificadores.</portal,></arena,>

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    La dependencia circular es un problema común en la Programación Orientada a Objetos. En el escenario dado, Arena y Portal dependen uno del otro y no es factible crear una instancia de una clase sin crear la otra. Una forma de resolver este problema es introduciendo una tercera clase, actuando como mediador entre las dos clases dependientes.

    Aquí hay un ejemplo de cómo podemos resolver la dependencia circular creando una clase Mediator:

    public class Mediator {
    private Arena arena;
    private Portal portal;

    Mediator() {
        arena = new Arena(this);
        portal = new Portal(this);
    }

    public void start() {
        portal.start();
    }

    public void close() {
        arena.close();
        portal.close();
    }

    public Arena getArena() {
        return arena;
    }

    public Portal getPortal() {
        return portal;
    }
}

public class Arena {
    private final Mediator mediator;

    Arena(Mediator mediator) {
        this.mediator = mediator;
    }

    void close() {
        mediator.getPortal().close();
    }

    void start() {
        // Lógica de Arena aquí
    }
}

public class Portal {
    private final Mediator mediator;

    Portal(Mediator mediator) {
        this.mediator = mediator;
    }

    void close() {
        mediator.getArena().close();
    }

    void start() {
        mediator.getArena().start();
        // Lógica de Portal aquí
    }
}

    En la solución anterior, creamos una clase Mediator que crea instancias de las clases dependientes, Arena y Portal. La clase Mediator actúa como un puente entre las dos clases y les permite comunicarse entre sí sin hacer referencia directa la una a la otra.

    Esta solución también nos permite mantener ambos objetos inmutables mediante el uso de la palabra clave final en la variable mediator en las clases Arena y Portal.

    Para comenzar la Arena, llamamos al método start() en la instancia de Portal, que luego llama al método start() en Arena a través de la clase Mediator. Para cerrar tanto Arena como Portal, podemos llamar al método close() en cualquiera de ellos, lo cual luego llama al método close() en la otra instancia a través de la clase Mediator.

    En general, crear una clase mediador es un enfoque mejor para resolver la dependencia circular, ya que nos permite mantener los objetos inmutables mientras se mantiene la comunicación entre ellos.

Comments are closed.