Klassen Eine Klasse in mehreren Klassen einbinden

[me.lina]

Hi,
eigentlich ist das wohl etwas, was man sehr oft braucht, dennoch konnte ich keine Lösung ergooglen (wohl die falschen suchbegriffe).

Also wie ich die Methoden einer Klasse in einer anderen Aufrufe ist mir klar:
Klassenname name = new Klassenname();
und dann anwenden mit name.methode bzw. name.parameter.

Mein Problem liegt darin, wie ich das mache, wenn ich z.b. den selben Parameter in verschiedenen Klassen benötige. Das Problem wird z.b. sehr schnell in Swing deutlich, da dort mit jeder Initialisierung das gleiche Fenster nochmals aufpoppt.

Ich hab mal versucht ein möglichst simples Beispiel des Problems zu erstellen.
Im Hauptprogramm in Klasse A sollen erst einmal alle Methoden ausgeführt werden, dann benötigt aber auch Klasse B eine initalisierung von Klasse C damit es methodeC aufrufen kann. Soll Klasse C methodeB aufrufen können, müsste ich das gleiche machen, das führt aber logischerweise zu einem Loop.

public class A{

   
    public static void main(String[] args) {
        B b = new B();
        C c = new C();
        System.out.println("Klasse A ruft methodeB:");
        b.methodeB();
        System.out.println("Klasse A ruft methodeC:");
        c.methodeC();
    }
}

public class B {
      
    B(){
    C c = new C();
    System.out.println("Klasse B ruft methodeC:");
    c.methodeC();
    }
   
   
    public void methodeB(){
        System.out.println("Test B");
        }

}

public class C {
   
    //Erzeugt Loop
    /*C(){
    B b = new B();
    System.out.println("Klasse C ruft methodeB:");
    b.methodeB();
    }*/
   
    public void methodeC(){
        System.out.println("Test C");
        }

}

Wäre das ein Swing-Code, wäre zudem Fenster B schon 2x vorhanden.

Wie kann ich nun also die Methoden und Paramter von Klasse B z.B. in Klasse C einbinden?
nur mit B b; hab ich es schon versucht.

Der Beispielcode mit sysout macht natürlich nicht viel Sinn, aber ich denke er verdeutlicht das Problem ganz gut.
In meinem realen Problem muss ich die Parameter und methoden zwischen verschiedenen Panels und Fenstern hin und her geben und würde mir dadurch auch loops erzeugen.

Bestimmt ist die Lösung relativ simpel.

lg

 

[VfL_Freak]

Wie kann ich nun also die Methoden und Paramter von Klasse B z.B. in Klasse C einbinden?

Du importierst 'B' und gut is ... oder verstehe ich die Frage nicht ??

 

[me.lina]

vielleicht denkst du ja an ein anderes importieren als ich? ich mache das wie gesagt immer mit Klasse name = new Klasse(); und wenn ich das in C nun machen würde, würde ich wie geschrieben einen loop erzeugen. Deshalb ist ein Teil des Codes in C auch auskommentiert.

 

[Joose]

Der Konstruktor sollte nur das Objekt initialisieren also die Attribute mit (gültigen) Startwerten belegen.

In dem Beispiel wie deinem würde ich mir überlegen ob das Design nicht falsch ist. Ansonsten deklariere in beiden Klassen eine "initialize" Methode, welche jeweils ein Objekt der anderen Klasse als Parameter entgegen nimmt.

 

[VfL_Freak]

Ach so, ich glaube, jetzt weiß ich was Du meinst!
Du willst halt immer nur eine Instanz haben ...

Entweder übergibst Du einmal erzeugte Objekte an die jeweiloigen Konstruktoren oder Du nutzt dies hier:
http://javabeginners.de/Design_Patterns/Singleton_-Pattern.php

Gruß Klaus

to late ... 🙁

 

[me.lina]

Entweder übergibst Du einmal erzeugte Objekte an die jeweiloigen Konstruktoren

meint ihr das derart? Irgendwie scheine ich euch dabei wohl falsch verstanden zu haben.

public class A{

    public static void main(String[] args) {
        B b = new B();
        C c = new C(b);
        System.out.println("Klasse A ruft methodeB:");
        b.methodeB();
        System.out.println("Klasse A ruft methodeC:");
        c.methodeC();
    }
  
}

Dann bekomme ich nur in Klasse B probleme, da die Variable b (welche an C übergeben werden soll) nicht gefunden wurde.

public class B {
    B(){
    C c = new C(b); //Fehler: b nicht gefunden
    c.methodeC();
    }
    public void methodeB(){
        System.out.println("Test B");
        }

}

public class C {
  
    C(B b){
    System.out.println("Klasse C ruft methodeB:");
    b.methodeB();
    }
  
    public void methodeC(){
        System.out.println("Test C");
        }

}

Das funktioniert natürlich erstrecht nicht:

public class A{

    public static void main(String[] args) {
        B b = new B(c);   //Fehler: c nicht gefunden
        C c = new C(b);
        System.out.println("Klasse A ruft methodeB:");
        b.methodeB();
        System.out.println("Klasse A ruft methodeC:");
        c.methodeC();
    }
  
}

Ja ich gebe zu, wahrscheinlich hätte ich doch ein umfangreicheres beispiel (in swing) nutzen sollen, ich wollte es nur möglichst simpel halten.
Aber letztenendes scheint ihr ja zum Glück verstanden zu haben, was ich meinte.

edit: bzw mal anders gefragt, wie würde man das denn normalerweile lösen, wenn man Parameter zwischen mehreren Klassen hin und her geben und Methoden aufrufen will?

 

[VfL_Freak]

hmm, das schein bei Dir noch einige Grundlagen zu fehlen ... 😉

public class A 
{
    public static void main( String[] args)
   {
        B b = new B();
        C c = new C();  // ist ok, 'b' ist bekannt

dann:

public class B
{
B()
{
C c = new C( b ); //Fehler: b nicht gefunden
// klar, 'b' ist hier ja auch nicht deklariert
// ----
// theoretisch so:
C c = new C( this );
}
[/code]

gilt dann für den Rest entsprechend!

theoretisch geht sowas:

public class A
{
  public static void main(String[] args)
  {
  B b = null;
  C c = null;
  b = new B(c);
  c = new C(b);
  }
}

Du musst dann in den Konstruktoren prüfen, pber das übergebene Objekt null ist oder nicht !

IMHO macht ein solches Konstrukt aber auch keinen Sinn. Was willst Du einer solchen Klasse ?

Gruß Klaus

 

[me.lina]

Naja Grundlagen eigentlich nicht wirklich, nur mit der erweiterten Vererbung ( nicht nur von A nach B) hab ich mich bislang nicht beschäftigt.
(Warum im letzten Beispiel Fehler gezeigt werden, war mir natürlich klar, nur nicht wie eben die Lösung auszusehen hätte)

Ich umschreibe das Ziel/Problem am Beispiel meines Programms noch mal (aber eigtl ist das kein swing-problem, deshalb wollte ich es einfacher halten):

Klasse Haupt ruft einfach nur das ganze Programm auf.
Klasse GUI erstellt die grafische Oberfläche (class GUI extends JFrame)
Klasse Daten ist zum speichern der Daten in eine Liste da
Klasse Panel1 erstellt das Anzeigepanel (class Panel1 extends JPanel)
Klasse Panel2 erstellt das Controlpanel (class Panel2 extends JPanel)


"GUI" initialisiert die Panel
"Panel2" muss nun auf Methoden und Parameter von Daten, GUI und Panel1 zugreifen können
"Panel1" muss auf GUI zugreifen können

 

[Joose]

Hast du dir meinen Vorschlag überhaupt mal angeschaut bzw. überlegt?

public class A {
   public static void main(String[] args) {
     B b = new B();
     C c = new C();
     b.init(c);
     c.init(b);
     
     System.out.println("Klasse A ruft methodeB:");
     b.methodeB();
     System.out.println("Klasse A ruft methodeC:");
     c.methodeC();
   }
}

public class B {   
   B() {
   }
   
   init(C c) {
     System.out.println("Klasse B ruft methodeC:");
     c.methodeC();
   }
   
   public void methodeB() {
     System.out.println("Test B");
   }
}

public class C {
   C() {
   }
   
   public init(B b) {
     System.out.println("Klasse C ruft methodeB:");
     b.methodeB();
   }
   
   public void methodeC() {
     System.out.println("Test C");
   }
}

Aber ich würde immer noch auf einen Designfehler tippen 😉

 

[me.lina]

So, jetzt bin ich wieder da. Natürlich habe ich deinen Beitrag vorhin gelesen, auch wenn er aufgrund der Formatierungsfehler ziemlich schwierig zu lesen war.
Aber du fragtest auch, was ich mit einer solchen Klasse will, also hab ich dir umschrieben, welches Prinzip ich verfolge.
Ich werd jetzt mal gucken, ob sich das in meinem eigentlichen Programmcode umsetzen lässt, beim ersten Test vorhin zwischen Tür und Angel, wollte es nicht.

 

[Joose]

So, jetzt bin ich wieder da. Natürlich habe ich deinen Beitrag vorhin gelesen, auch wenn er aufgrund der Formatierungsfehler ziemlich schwierig zu lesen war.

Hm, ich habe oben doch nur 2 Sätze geschrieben, komisch das sich da Formatierungsfehler eingeschlichen haben, aber egal.

Aber du fragtest auch, was ich mit einer solchen Klasse will, also hab ich dir umschrieben, welches Prinzip ich verfolge.

Jap das habe ich gelesen. Wenn du sowas realisieren willst dann musst du einfach beachten das der Konstruktor dazu da ist ein Objekt in einen gültigen Zustand zu bringen, mehr nicht. Also keinen weiteren Code ausführen
Sprich Parameter prüfen und Attribute setzen.
Weitere Initialisierungen könnten eben wie von mir gezeigt in einer "init" Methode vorgenommen werden.

"GUI" initialisiert die Panel
"Panel2" muss nun auf Methoden und Parameter von Daten, GUI und Panel1 zugreifen können
"Panel1" muss auf GUI zugreifen können

Einfachste Lösung:

public class GUI extends JFrame {
   private Panel1 panel1;
   private Panel2 panel2;
  
   public GUI() {
     panel1 = new Panel1(this);
     panel2 = new Panel2(this);
   }
}

public class Panel1 extends JPanel {
   private GUI gui;
  
   public Panel1(GUI gui) {
     this.gui = gui;
   }
}

public class Panel2 extends JPanel {
   private GUI gui;
  
   public Panel2(GUI gui) {
     this.gui = gui;
   }
}

Was mir aber gar nicht gefällt ist das GUI und Panel1/2 von JFrame bzw. JPanel ableiten.
Man erweitert eine Klasse wenn man deren Funktionalität erweitern/anpassen will, nicht aber wenn ich nur ein bestimmtes Layout definieren will oder ähnliches
Dazu dieser Link: java - Why shouldn't you extend JFrame and other components? - Stack Overflow

 

[me.lina]

Hm, ich habe oben doch nur 2 Sätze geschrieben, komisch das sich da Formatierungsfehler eingeschlichen haben, aber egal.

Ja die Zitate waren irgendwie "verpfuscht" und voll mit BBCode, aber wie du schon sagtest: auch egal.

Also ich habs mit der Übergabe gemacht, gestern noch mal bissl Ordnung reingebracht, weil das irgendwann ein riesen Chaos war, aber es geht. Ist nicht hübsch, aber geht. Danke also soweit 🙂 den letzten Hinweis guck ich mir dann auch die Tage noch mal an.