JPanel in andere Klasse übergeben

[Hope]

Hi,
ich habe gedacht ihr könntet mir vielleicht helfen. ^^
Ich hab seit längeren nicht mehr mit Java programmiert und hab leider einige Dinge vergessen und da ich zu diesem Thema nichts im Forum fand dachte ich, ich mache mal ein neuen Thread auf.

Zum Problem:

Ich möchte ein JPanel aus einer anderen Klasse übergeben und auf ein anderes JPanel draufmachen.
(Die ['B][/B'] <-- spiegeln die Stellen im Code die ich zum Übergeben benutzte)

So sieht der Quellcode dazu aus:

fenster.java

import java.awt.*;
import javax.swing.*;

public class fenster {
	private JFrame f;
	private JPanel p;		//Hintergrundpanel
	private int x = 600;	//Größe des Fensters
	private int y = 400;
	private String name = "QC by ...";
	
[B]	spielfeld sf = new spielfeld();[/B]
		
	public fenster(){
		f = new JFrame(name);
		p = new JPanel();
		
		f.setSize(x,y);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setResizable(false);
		f.setLocationRelativeTo(null);
		p.setSize(new Dimension(x,y));
		p.setMaximumSize(new Dimension(x,y));
		p.setMinimumSize(new Dimension(x,y));
		p.setPreferredSize(new Dimension(x,y));
		p.setBackground(Color.BLACK);
		
[B]		JPanel spielF = new JPanel();
		spielF = sf.gebeSpielfeld2();	[/B]	
		p.add(spielF);
		
		f.add(p);		
		f.setVisible(true);	
	}	
}

spielfeld.java

import java.awt.*;
import javax.swing.*;

public class spielfeld {
	private JPanel spf;
	private int x = 200;
	private int y = 200;
	
	public void SpielfeldA(){
		spf = new JPanel();
		spf.setSize(new Dimension(x,y));
		spf.setMaximumSize(new Dimension(x,y));
		spf.setMinimumSize(new Dimension(x,y));
		spf.setPreferredSize(new Dimension(x,y));
		spf.setBackground(Color.YELLOW);
	}
	
[B]	public JPanel gebeSpielfeld2(){
		return spf;
	}[/B]
}

Ich hab versucht mit dem Getter die Variable (JPanel spf) an die fenster.java zu übergeben, aber aus irgendeinen Grund funktioniert dies nicht.

Die Frage ist im Prinzip wie kriege ich das JPanel spf in die fenster.java übergeben ?

Danke schonmal für jegliche Antwort. ^^

Lg Hope

 

[Volvagia]

Du rufst SpielfeldA nicht auf, deshalb wird in spf nichts hineingeschrieben, und du bekommst null zurück. Übrigens schreibst du in spielF ein neues JPanel, und überschreibst es direkt danach mit dem Rückgabewert von sf.

Klassennamen am Besten immer groß, Methoden immer klein.

 

[L-ectron-X]

Vielleicht hilft dir auch der folgende Link in die FAQ: http://www.java-forum.org/einfuehrungen-erste-schritte/14159-zugriff-objekt-anderen.html

 

[BabySuna]

Hallo Das Thema ist zwar schon älter aber ich stehe gerade vor dem gleichen Probelm. Der Link ist leider nicht mehr aktiv.

Wie kann ich JPanel Design aufrufen, welches in einer anderen Klasse geschrieben wurde? Ich habe Ich JTabbedPane, wo das aussehen der einzelnen Tabs in separaten Dateien stehen soll. Und in der Klasse Aussehen soll alles zusammen gefügt werden. Wie erstelle ich das?

Wenn ich alles in eine Datei schreibe, dann läuft es fehlerfrei

Kann mir wer helfen?

 

[kneitzel]

Das hängt immer davon ab, was Du genau derzeit hast.

Du kannst z.B. deine eigenen Komponenten schreiben. Dann hast Du evtl. etwas wie:
public class MyClass extends JPanel { ... }

Dann würdest Du da, wo Du es verwenden würdest, eine neue Instanz von MyClass erstellen.

Oder Du hast in Klasse A etwas, das Du in Klasse b brauchst. Dann kannst Du da Referenzen Weiter geben. Das wäre dann z.B. sowas:

public static void main(String[] args) {
    A a = new A();
    B b = new B();
    b.setA(a); // Hier gibst Du der Instanz in b eine Referenz auf a. Damit kann in B auf diese Instanz zugegriffen werden.
}

Letzteres ist etwas, das man etwas einschränken will. Aber das zu erläutern wird etwas schwer ...

 

[Hag2bard]

Ist das kein guter Stil wenn man Objektreferenzen hin und her schiebt?
Sollte man besser mit Vererbung arbeiten?

 

[Jw456]

Ist das kein guter Stil wenn man Objektreferenzen hin und her schiebt?
Sollte man besser mit Vererbung arbeiten?

wie willst du das mit Vererbung machen seige das mal an dem von @kneitzel gegebehn beispiel.

 

[kneitzel]

Ist das kein guter Stil wenn man Objektreferenzen hin und her schiebt?
Sollte man besser mit Vererbung arbeiten?

Also es werden keine Objektreferenzen "hin und her" geschoben sondern es wird nur dafür gesorgt, dass alle, die etwas kennen müssen, dies auch kennen.

Jetzt versuche ich einmal paar Dinge in sehr wenigen Sätzen zu erläutern. Die Gefahr, Dich damit zu verwirren, ist leider recht hoch - zu jedem Aspekt gibt es ganze Abschnitte in Büchern und Abhandlungen und was weiss ich nicht alles ... Aber ich versuche es mal:

Vererbung sollte man nur da einsetzen, wenn es wirklich notwendig ist. Dabei sind gewisse Fragen wichtig: Wenn A von B abgeleitet wird:
- Ist A ein B? (Beispiel: Ist ein Hund ein Säugetier? Ja, sieht also gut aus. Ist ein Haus eine Katze? Wohl kaum. In einem Haus kann eine Katze sein. Aber ein Haus ist keine Katze!)
- Verhält sich A wie B? (Verhält sich ein Hund wie ein Säugetier? Was für Verhalten hat ein Säugetier? Gebären von Jungtieren und dann das Säugen durch die Mutter... Ja, das machen Hunde auch auch. Also ist so gegeben.)
Die entsprechenden Regeln sind noch etwas umfangreicher und auch relativ komplex. Aber es gibt auch Empfehlungen - eine Empfehlung ist z.B. "Containment over Inheritance" - Es ist oft besser, wenn man einfach eine "hat ein" Beziehung aufbaut als eine "ist eine". typisches Beispiel ist die GUI in einem Programm. Statt da von JFrame abzuleiten (Inheritance) ist es besser, der GUI Klasse ein JFrame zu geben ...

Aber wenn wir noch zurück gehen: Es gibt natürlich einiges mehr das zu erwähnen ist. So sollte man nicht gegen konkrete Implementationen entwickeln. Statt dessen lieber gegen Interfaces.
Nehmen wir ein Beispiel: Du hast eine Liste von Irgendwas. Dazu nutzt Du eine ArrayList<IregendWas>. Wenn Du jetzt in einer Methode sowas übergeben bekommen willst, dann könntest Du schreiben:
void meineMethode(ArrayList<IrgendWas> parameter) { ... }
Jetzt bist Du aber sehr eingeschränkt. Wenn jemand eben nicht mit ArrayList arbeitet, dann kann er die Methode so direkt nicht aufrufen. Daher nimmt man lieber ein Interface, dass so allgemein wie möglich und so deutlich wie nötig ist.
Bei ArrayList gibt es da mehrere Interfaces, die alle aufeinander Aufbauen: List, Collection, Iterable
Brauchst Du, dass die Elemente eine Reihenfolge haben? -> List. Ist keine Reihenfolge wichtig aber Du willst Dinge nutzen, die Collection hat aber nicht Iterable wie z.B. stream() ->Collection. Wenn Du die Elemente nur durchgehen können willst: Iterable.

Bei Rückgaben bist Du so konkret wie möglich / sinnvoll: Wenn Du eine ArrayList zurück gibst, ist List das Interface. Denn eine List ist ja auch eine Collection und ein Iterable. Also egal, was derjenige braucht: Er bekommt etwas brauchbares. Aber das setzt natürlich voraus, dass Du wirklich eine List hast, also Elemente eine Reihenfolge haben.
Hier könnte man auf die Idee kommen und fragen: Wenn so konkret wie möglich: Warum dann nicht direkt das ArrayList zurück geben?
Wir wollen keine konkrete Klasse zurück geben, denn das ist ein Implementierungs-Detail! In welcher List Implementation Du etwas speicherst ist Dein Geheimnis in der Klasse. Das geht niemanden außen etwas an. Dadurch kannst Du es jederzeit ändern. (Stichwort Kapselung)

Ich hoffe, das war so in der Kürze verständlich. Ansonsten einfach ignorieren oder im Detail nachfragen.