Gewusst wie: freigeben von Daten zwischen separaten Klassen in Java

Was ist der beste Weg, um Daten zwischen separaten Klassen in Java? Ich habe eine Reihe von Variablen, die von verschiedenen Klassen in separaten Dateien in unterschiedlicher Weise.
Lassen Sie mich versuchen zu veranschaulichen, eine vereinfachte version meines Problems:

Dies war mein code vor:

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

Nun es sieht wie folgt aus:

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

Jedenfalls, sollte ich pass x-und y-jedes mal (wobei x,y sind Variablen gespeichert, die in der helper-Klasse func) ?

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

Meine Idee war es, ein Spezial-container-Klasse, wo die x-und y-gehalten werden. Die top-level-Klasse eine Instanz der Klasse container und ändern Sie x,y mit der set-Methoden.

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

Meine helper-Klassen haben auch eine Instanz des Containers und es würde auf das gleiche Instanz wie in der oberen Ebene. So haben Sie Zugriff auf die gleichen x,y, wie in der oberen Ebene.

Ich würde gerne wissen, ob ich sollte

Verwendung der container-Klasse
Laden x,y jedes mal in die Unterklassen
?? Einige bessere Methode ??

Hier ist die Antwort, leider, es 'hängt'. Programmierer.se könnte ein fruchtbares Ziel für diese Frage.
Wenn die innere Klasse nicht statisch ist, dann kann es Zugriff auf übergeordnete Klasse Mitglieder sowie...
Es ist nicht eine innere Klasse, wenn es in einer anderen Datei. Und es ist nicht eine Unterklasse, wenn es verlängert nicht die Oberklasse.
Ja, Unterklasse war eine schlechte Wortwahl meinerseits. Ich werde dieses Bearbeiten.

InformationsquelleAutor f20k | 2010-12-12

13

Ich denke, die Antwort auf Ihre Frage ist die Design Pattern-namens Singleton.
Im Grunde können Sie bekommen und nutzt das gleiche (und einzige) Instanz einer Klasse, Wann immer Sie wollen in Ihrem system.

Dies ist seine Umsetzung (bitte verzeihen Sie mögliche Syntaxfehler, habe ich nicht kompilieren):
```
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;
  }
}
```
dann, wenn an anderer Stelle in Ihrem code, den Sie importieren die Container können Sie zum Beispiel schreiben
```
Container.getInstance().x = 3;
temp = Container.getInstance().x;
```
und Sie Einfluss auf die Attribute des einzigartigen container-Instanz, die Sie in Ihrem system

In vielen Fällen ist es jedoch besser, das Dependency Injection-pattern, wie es verringert die Kopplung zwischen verschiedenen Komponenten.
- Sehr interessant. Es hat eine statische variable von sich selbst. Nur Frage mich, wie funktioniert diese Sache, die außerhalb des Bereichs? Wenn es statisch ist, wird es nicht bestehen bleibt? Oder muss ich es einstellen, auf null, wenn ich bin fertig mit ihm?
- Sorry, aber ich glaube, ich habe nicht deine Frage verstanden 🙁 jedenfalls, als dessen Instanz statisch, sobald Sie initialisiert wurde, werden weiterhin in Existenz. Sie müssen nicht, und Sie konnte nicht, setzen Sie es auf null. Betrachten Sie es als eine gemeinsame repository der Variablen 🙂 Aber hier ist eine Erklärung für das Muster en.wikipedia.org/wiki/Singleton_pattern
- Hmm naja das Singleton wird dann Sinn machen, wenn ich nur ab und zu instanziieren Sie es einmal. Allerdings ist mein top-level-Funktion ist eigentlich ein thread, der instanziiert werden/zerstört wird mehrmals während der Ausführung des Programms. Ich nehme auch an, ich kann Sie nur überschreiben Sie die Werte jedes mal.
- erstellen und zerstören den gleichen thread viele Male während der Ausführung eines system ist schon Recht seltsam. Könnten Sie wahrscheinlich wollen, um zu schlafen und wach, sobald es benötigt wird
- Ich Schreibe an einem Spiel für android. Angesichts der Rahmenbedingungen ist es durchaus möglich, für einen Benutzer, um das Spiel zu spielen, dass der thread erstellt und mehrmals zerstört. Das Android-Betriebssystem zerstören den thread, wie nötig, um freie Ressourcen für andere apps. Hmm. Vielleicht legt es schlafen kann funktionieren, aber ich denke android wird noch zerstören, wenn der Benutzer das Spiel verlässt
- Ich möchte hinzufügen, dass man viele Leute sagen, dieses Muster ist das pure böse, aufgrund der Tatsache, es ist eigentlich nur eine Hülle für eine Globale variable. Das problem ist auch, dass in einer singleton-zentrierte Architektur, Klassen' Abhängigkeiten nicht klar. Ich persönlich denke, dass das Singleton-Muster ist nur ein Design-Pattern helfen, Sie sicher sein, die Klasse wird nur eine Instanz. Es ist nicht schlecht an sich, es hängt davon ab, wie Sie es verwenden.
- Verwenden instance != null statt !instance, weil die ! ist nicht definiert für dieses argument-Typ.
InformationsquelleAutor Sindico
0

Ich habe eine harte Zeit zu sehen, was dein problem ist-warum wollen Sie nicht-pass-x, ein y als parameter?

Oh, gut. Sofern Sie noch keinen, ich sehe keine Notwendigkeit für eine neue container-Klasse. Tun es auf diese Weise:
```
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()**
    }
}
```
Natürlich müssen Sie den öffentlichen getter-Methoden getX() und getY (), um Top_Level_Class.

Wenn Sie nicht möchten, SubClass1a abhängig Top_Level_Class dann könnten Sie eine Schnittstelle erstellen, die den Zugriff auf die Variablen.
- Hmm okay. Ich werde werfen Sie einen Blick auf die Schnittstellen mehr. Der Hauptgrund, warum ich nicht wollte, pass x,y, jedes mal, weil ich mehrere Funktionen in mehrere Unterklassen, die jeweils die Verwendung (x,y, z, etc) und es schien nicht Recht zu pass, wie in 6-8 Variablen jedes mal, wenn ich eine Funktion aufrufen. Die sub-Klassen, abhängig zu sein, aber ich versuche, Sie aus der Datei, so dass Sie verwendet werden können, in ein anderes Projekt.
- Ihr Bauchgefühl über die nicht wollen, zu passieren, 6-8 Parameter einer Methode auf dem richtigen Weg. Parameter-Listen sind, die lange im Allgemeinen Hinweis, dass Sie sollten erwägen, die Bündelung dieser Parameter in ein Objekt oder 2.
- vielen Dank für Ihren Vorschlag. Ich denke, ich werde es umsetzen ein container. Es macht sehr viel Sinn. Ich war nur besorgt, dass es wäre schlechter Programmierstil, wenn ich teilten sich die Daten auf diese Weise.
InformationsquelleAutor AlanObject
0

Blockquote
Der Hauptgrund, warum ich nicht wollte, pass x,y, jedes mal, weil ich mehrere Funktionen in mehrere Unterklassen, die jeweils die Verwendung (x,y, z, etc) und es schien nicht Recht zu pass, wie in 6-8 Variablen jedes mal, wenn ich eine Funktion aufrufen. Die sub-Klassen, abhängig zu sein, aber ich versuche, Sie aus der Datei, so dass Sie verwendet werden können, in ein anderes Projekt.
Blockquote

Wenn dies der Fall ist, dann sind Sie besser dran, abstrahieren die Variablen aus einer container-Klasse. Wenn jede Instanz dieser nicht-mehr-abhängig-Klassen verwenden wird, eine große Teilmenge dieser Variablen dann macht es Sinn, Sie alle in einer Instanz. Variablen, dass ein logischer Zusammenhang gefunden werden sollte an der gleichen Stelle. Ihr Ansatz sollte so etwas wie:
```
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
}
```
Dies hält Sie aus immer in eine variable übergeben von spaghetti-code situation, und wenn Sie möchten, verwenden Sie nur ein oder zwei Klassen höher dein code ist modular genug, um port nur mit diesen Klassen und in den container.
- Diese syntax ist falsch, und scheint komplizierter als der ursprüngliche Vorschlag.
InformationsquelleAutor Raskolnikov
0

Diese Frage ist ein bisschen verrückt - der code, der in der Frage nicht kompilieren.
```
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
}
```
Müssen Sie definieren ADoer und BDoer als gut.
- Sorry, der code, den ich schrieb da oben ist, zu helfen, geben eine Vorstellung davon, was ich tun möchte. Es wird nicht wirklich funktionieren. Der eigentliche code ist eigentlich ziemlich kompliziert mit 100+ Zeilen. Ich bin im Grunde versucht, zu teilen einige sehr oft verwendete Variablen in der top_level_class zwischen Helfer-Klassen in separaten Dateien. Die Frage ist, welche Methode wäre am besten - effiziente-Weise und oop-Weise
InformationsquelleAutor Armand

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.