Cómo compartir datos entre clases separadas en Java

Question

¿Cuál es la mejor forma de compartir datos entre clases separadas en Java? Tengo un conjunto de variables que son usadas por diferentes clases en archivos separados de diferentes maneras. Voy a tratar de ilustrar una versión simplificada de mi problema:

Esta fue mi código antes:

public class Top_Level_Class(){ 
    int x, y; 

    // gets user input which changes x, y; 
    public void main(){ 
     int p, q, r, s; 
     // compute p, q, r, s 
     doA(p,q,r); 
     doB(q,r,s); 
    } 

    public void doA(int p, int q, int r){ 
     // do something that requires x,y and p, q, r 
    } 

    public void doB(int q, int r, int s){ 
     // does something else that requires x, y and q, r, s 
    } 
} 

Ahora se ve algo como esto:

public class Top_Level_Class(){ 
    int x, y; 
    SomeClass1a a = new SomeClass1a(); 
    SomeClass1a b = new SomeClass1b(); 
    // gets user input which changes x, y; 
    public void main(){ 
     int p, q, r, s; 
     // compute p, q, r, s 
     a.doA(p,q,r); 
     b.doB(q,r,s); 
    } 

public class SomeClass1a() { // in its own separate file 
    public void doA(int p, int q, int r){ 
     // do something that requires x,y and p, q, r 
    } 
} 


public class SomeClass1b() { // in its own separate file 
    public void doB(int q, int r, int s){ 
     // does something else that requires x, y and q, r, s 
    } 
} 

Así que de todos modos, debería pasar xey cada vez (donde x, y son variables almacenadas en el func de la clase auxiliar)?

a.set(x,y); 
a.doA(p,q,r); 

Mi idea era tener una clase de contenedor especial donde se mantienen xy y. La clase de nivel superior tendría una instancia de la clase contenedora y cambiaría x, y utilizando los métodos establecidos.

// in the top level class: 
Container c = new Container(x,y); 
a.setContainer(c); 
b.setContainer(c); 

Mis clases de ayuda también tendrían una instancia del contenedor y que apuntarían a la misma instancia que en el nivel superior. De esta forma, acceden a la misma x, y que en el nivel superior.

me gustaría saber si debo

• Utilice la clase de contenedor de carga
• x, y cada vez en las subclases
• ?? ¿Algún método mejor?

Answer 1

Supongo que la respuesta a su pregunta es el patrón de diseño llamado Singleton. Básicamente, le permite obtener y explotar la misma instancia (y única) de una clase cuando lo desee en su sistema.

Esta es su aplicación (por favor, perdona posibles errores de sintaxis, que no compilarlo):

class Container{ 

    //eventually provides setters and getters 
    public float x; 
    public float y; 
    //------------ 

    private static Container instance = null; 
    private void Container(){ 

    } 
    public static Container getInstance(){ 
    if(instance==null){ 
     instance = new Container(); 
     } 
     return instance; 
    } 
} 

entonces, si en su código en otro lugar de importar el contenedor se puede escribir por ejemplo

Container.getInstance().x = 3; 
temp = Container.getInstance().x; 

y usted afectará los atributos de la instancia única de contenedor que tiene en su sistema

En muchos casos, sin embargo, es mejor utilizar Dependency Injec patrón de resolución, ya que reduce el acoplamiento entre los diferentes componentes.

Answer 2

Estoy teniendo dificultades para ver cuál es tu problema, ¿por qué no quieres pasar x an como parámetro?

Oh, bueno. Suponiendo que no lo haga, no veo la necesidad de una nueva clase de contenedor. Hacerlo de esta manera:

public class SubClass1a() { // in its own separate file 
    public void doA(Top_Level_Class caller, int p, int q, int r){ 
     // do something that requires x,y and p, q, r 
     // **to get x use the expression term caller.getX() and caller.getY()** 
    } 
} 

Por supuesto, es necesario agregar el métodos de acceso público getX() y getY() para Top_Level_Class.

Si no desea que SubClass1a dependa de Top_Level_Class, puede crear una interfaz que proporcione acceso a las variables.

Answer 3

cita en bloque La razón principal por la que no quería pasar x, y cada vez es porque tengo varias funciones en varias subclases que cada uso (x, y, z, etc.) y que no parecía derecho a pasar como 6-8 variables cada vez que llamo a una función. Las subclases solían ser dependientes, pero estoy tratando de sacarlas del archivo para que puedan ser utilizadas en un proyecto diferente. Blockquote

Si este es el caso, entonces es mejor que abstraigas tus variables a una clase contenedora. Si cada instancia de estas clases que ya no son dependientes va a usar un gran subconjunto de estas variables, entonces tiene sentido tenerlas todas en una instancia. Las variables que están lógicamente relacionadas se deben encontrar en el mismo lugar.Su enfoque debe ser algo como:

public class Top_Level_Class(){ 
Container container = new Container(x, y, p, q, r, s); 
SubClass1a a = new SubClass1a(container); 
SubClass1a b = new SubClass1b(container); 
// gets user input which changes x, y using container's getters and setters 
public void main(){ 
    // compute and set p, q, r, s 
    a.doA(); 
    b.doB(); 
} 

public class SubClass1a(Container c) { // in its own separate file 
    public void doA(c.getX, c.getY, c.getP, c.getQ, c.getR){ 
     // do something that requires x, y, p, q, and r 
    } 
} 

public class SubClass1b(Container c) { // in its own separate file 

    public void doB(c.getX, c.getY, c.getQ, c.getR, c.getS){ 
     // does something else that requires x, y, q, r, and s 
    } 
} 

public class Container(x, y, p, q, r, s) { 
    //getters and setters for all variables 
} 

Esto le impide entrar en un paso variable de situación de los espaguetis de código, y cuando se quiere utilizar sólo uno o dos de estas clases más tarde su código es modular suficiente para el puerto con solo esas clases y tu contenedor.

Answer 4

Esta pregunta es un poco loca: el código en la pregunta no se compilará.

public class Main { 
    public static void main(String... args) { 
     MutableDataContainer m = new MutableDataContainer(); 
     ImmutableDataContainer i = computeImmutableData(); 
     new ADoer().doA(m, i); 
     new BDoer().doB(m, i); 
    } 
    ... 
} 

class MutableDataContainer { 
    private int x, y; 
    ... // getters and setters below 
} 

class ImmutableDataContainer { 
    private final int p, q, r, s; 
    ... // getters below 
} 

Tendrá que definir y ADoerBDoer también.