# Verschiedene JPanels aus eigenen Klassen in JFrame einfügen, nur ein Panel sichtbar



## hylci (29. Okt 2011)

Hallo zusammen. 
Ich hätte mal eine kleine Frage, an der ich mir seit Tagen die Zähne ausbeiße. Ich versuche gerade eine kleine graphische Oberfläche für ein kleines rundenbasiertes Strategiespiel zu entwerfen. Das wird nichts aufwendiges oder großartiges, ist einfach nur zum Spaß und um meine JAVA-Kenntnisse etwas zu vertiefen, denn ich hab erst vor 2 Monaten damit angefange. Folgendes Problem hat sich mir nun gestellt (Und vielleicht ist auch mein kompletter Ansatz bescheuert, aber wie gesagt, ich bin definitiv ein blutiger Anfänger....):

Die Oberfläche soll folgendermaßen aussehen:

Ein JFrame mit BorderLayout. Im Center soll das (gezeichnete) Spielfeld sein, West und East sollen "Bedienpanels" für die beiden Spieler sein (wird, bzw. soll ein Hot-Seat-Spiel werden). North und South sollen noch weitere Anzeigen hin, wie Rundenanzahl, Spielzeit, etc.

Bisher hab ich drei Klassen erzeugt, die Klasse GUI2, die Klasse Spielfeld und die Klasse BedienpanelLinks. Die Klasse GUI2 erzeugt einen JFrame mir Borderlayout und added die Klassen Spielfeld im Center und BedienpanelLinks in West (Beide Klassen erben von JPanel und erzeugen Panels). Über eine Klasse Test mit mainmethode ruf ich GUI2 auf. Problem ist, dass nur das Spielfeld angezeigt wird und das Bedienpanel links nicht. Wenn ich alles (also Spielfeld und BedienpanelLinks) in einer Klasse erzeuge und alles aus JLabel aufbaue (und nicht wie jetzt in der Klasse Spielfeld das Spielfeld zeichne), dann funktioneirt die Sache, aber so einfach nicht.

Kurz zusammengefast:

Ich verstehe einfach nicht, warum ich das Bedienpanel nicht einfügen kann, bzw warum es mir nicht angezeigt wird. Zum besseren Verständnis, weils sonst ja lles keinen Sinn macht, häng ich die Klassen mal an:

Klasse GUI2:


```
import java.awt.BorderLayout;
import java.awt.Container;
import javax.swing.JFrame;


public class GUI2 extends JFrame {

	
	private Container c;
	int[][]felderAufSpielBrett = new int[6][6];


	public GUI2() {
		super("Brettspiel V. 0.3");
		c = getContentPane();
		c.setLayout(new BorderLayout());
		createSpielfeldLayout(felderAufSpielBrett);
		
		Spielfeld s = new Spielfeld(felderAufSpielBrett);
		c.add(s, BorderLayout.CENTER);
		
		BedienpanelLinks panelLinks = new BedienpanelLinks();
		
		c.add(panelLinks, BorderLayout.WEST);
		

}
	
public int [][] createSpielfeldLayout(int [][] n){
		
		int[] artFeld = new int[Spielfeld.getAnzahlFelder()];
		for (int i = 0; i < artFeld.length; i++) {
			artFeld[i] = i % Spielfeld.getFelderArten();
		}

		Spielfeld.shuffle(artFeld);
		
		int i = 0;
		for (int j = 0; j < Spielfeld.getFelderBreit(); j++) {
			for (int j2 = 0; j2 < Spielfeld.getFelderHoch(); j2++) {
				
				felderAufSpielBrett[j][j2] = artFeld[i];
				i++;
			}
		}
		
		return felderAufSpielBrett;
	}

}
```

Klasse Spielfeld:


```
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JPanel;

public class Spielfeld extends JPanel {

	private static int felderArten = 6;

	private static int felderBreit = 6;
	private static int felderHoch = 6;
	private static int felderGroesse = 60;

	private int lagerplaetze = 5;

	private static int anzahlFelder = felderBreit * felderHoch;
	private int[][] felderArray = new int[felderBreit][felderHoch];

	private int[][] n;

	// Konstruktor

	public Spielfeld(int[][] feld) {
		this.n = feld;
	}

	// Setter und Getter

	public static void setAnzahlFelder(int anzahlFelder) {
		Spielfeld.anzahlFelder = anzahlFelder;
	}

	public static int getAnzahlFelder() {
		return anzahlFelder;
	}

	public static void setFelderArten(int felderArten) {
		Spielfeld.felderArten = felderArten;
	}

	public static int getFelderArten() {
		return felderArten;
	}

	public static void setFelderBreit(int felderBreit) {
		Spielfeld.felderBreit = felderBreit;
	}

	public static int getFelderBreit() {
		return felderBreit;
	}

	public static void setFelderHoch(int felderHoch) {
		Spielfeld.felderHoch = felderHoch;
	}

	public static int getFelderHoch() {
		return felderHoch;
	}

	public static void setFelderGroesse(int felderGroesse) {
		Spielfeld.felderGroesse = felderGroesse;
	}

	public static int getFelderGroesse() {
		return felderGroesse;
	}

	private static java.util.Random rnd = new java.util.Random(); // Zufallsgenerator

	// Methode vertauscht das Element an Position a mit dem
	// Element an Position b des Arrays x
	private static void swap(int[] x, int a, int b) {
		int t = x[a];
		x[a] = x[b];
		x[b] = t;
	}

	// permutiert das Array x
	// jede mögliche Anordnung der Array-Elemente ist gleichwahrscheinlich
	public static void shuffle(int[] x) {
		for (int i = x.length; i > 1; i--)
			swap(x, i - 1, rnd.nextInt(i));
	}

	// Überschriebene paintComponent

	@Override
	public void paintComponent(Graphics g) {
		super.paintComponents(g);
		// Königsplätze

		BufferedImage koenigsPlatz = null;

		try {
			koenigsPlatz = ImageIO.read(new File("FeldWeissMitRand.png"));
		} catch (IOException e) {
			e.printStackTrace();
		}
		//König links
		g.drawImage(koenigsPlatz, 5, (int) (2.75 * felderGroesse) + 7,
				(int) (0.5 * felderGroesse), (int) (0.5 * felderGroesse), this);

		//König rechts
		g.drawImage(koenigsPlatz, (int)(10.3*felderGroesse)-4, (int) (2.75 * felderGroesse) + 7,
				(int) (0.5 * felderGroesse), (int) (0.5 * felderGroesse), this);
		
		// Lagerplätze

		BufferedImage lagerPlatz = null;

		try {
			lagerPlatz = ImageIO.read(new File("FeldGrauMitRand.png"));
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		//Lagerplätze links	
		for (int i = 0; i < lagerplaetze; i++) {

			g.drawImage(
					lagerPlatz,
					(int) ((felderGroesse)) + 4,
					(int) (((i + 1) * (felderHoch * felderGroesse) / lagerplaetze))
							- ((int) (0.75 * felderGroesse)),
					(int) (0.5 * felderGroesse), (int) (0.5 * felderGroesse),
					this);

		}
		//Lagerplätze rechts
		for (int i = 0; i < lagerplaetze; i++) {

			g.drawImage(
					lagerPlatz,
					(int) ((9.3*felderGroesse)) -1,
					(int) (((i + 1) * (felderHoch * felderGroesse) / lagerplaetze))
							- ((int) (0.75 * felderGroesse)),
					(int) (0.5 * felderGroesse), (int) (0.5 * felderGroesse),
					this);

		}
		
		//Lagerplätze rechts
		
		//Mauer
		
		BufferedImage mauer = null;
		try {
			mauer = ImageIO.read(new File("mauer.png"));
		} catch (IOException e) {
			e.printStackTrace();
		}

		//Mauerlinks
		g.drawImage(mauer, (int) (1.8*felderGroesse) +4, 5, (int)(0.4*felderGroesse), (int)(2.5*felderGroesse), this);
		g.drawImage(mauer, (int) (1.8*felderGroesse) +4, 5 + (int) (3.5*felderGroesse), (int)(0.4*felderGroesse), (int)(2.5*felderGroesse), this);
		//Mauer rechts
		g.drawImage(mauer, (int) (8.5*felderGroesse) +2, 5, (int)(0.4*felderGroesse), (int)(2.5*felderGroesse), this);
		g.drawImage(mauer, (int) (8.5*felderGroesse) +2, 5 + (int) (3.5*felderGroesse), (int)(0.4*felderGroesse), (int)(2.5*felderGroesse), this);
		
		
		
		
		// g.drawImage(blau, (1*felderGroesse) -felderGroesse +45 ,
		// (1*felderGroesse) -felderGroesse +45, this);

		for (int i = 0; i < getFelderBreit(); i++) {
			for (int j = 0; j < getFelderHoch(); j++) {
				switch ((n[i][j]) + 1) {

				case 1:
					BufferedImage blau = null;
					try {
						blau = ImageIO.read(new File("eisen.PNG"));
					} catch (IOException e) {
						e.printStackTrace();
					}

					g.drawImage(
							blau,
							(int) ((i + 1) * getFelderGroesse() + ((1.5 * getFelderGroesse()) - 5)),
							(j + 1) * getFelderGroesse()
									- (getFelderGroesse() - 5),
							getFelderGroesse() - 1, getFelderGroesse() - 1,
							null);
					break;
				case 2:
					BufferedImage gruen = null;
					try {
						gruen = ImageIO.read(new File("fleisch.PNG"));
					} catch (IOException e) {
						e.printStackTrace();
					}

					g.drawImage(
							gruen,
							(int) ((i + 1) * getFelderGroesse() + ((1.5 * getFelderGroesse()) - 5)),
							(j + 1) * getFelderGroesse()
									- (getFelderGroesse() - 5),
							getFelderGroesse() - 1, getFelderGroesse() - 1,
							null);
					break;
				case 3:
					BufferedImage braun = null;
					try {
						braun = ImageIO.read(new File("holz.png"));
					} catch (IOException e) {
						e.printStackTrace();
					}

					g.drawImage(
							braun,
							(int) ((i + 1) * getFelderGroesse() + ((1.5 * getFelderGroesse()) - 5)),
							(j + 1) * getFelderGroesse()
									- (getFelderGroesse() - 5),
							getFelderGroesse() - 1, getFelderGroesse() - 1,
							null);
					break;
				case 4:
					BufferedImage gelb = null;
					try {
						gelb = ImageIO.read(new File("weizen.png"));
					} catch (IOException e) {
						e.printStackTrace();
					}

					g.drawImage(
							gelb,
							(int) ((i + 1) * getFelderGroesse() + ((1.5 * getFelderGroesse()) - 5)),
							(j + 1) * getFelderGroesse()
									- (getFelderGroesse() - 5),
							getFelderGroesse() - 1, getFelderGroesse() - 1,
							null);
					break;
				case 5:
					BufferedImage grau = null;
					try {
						grau = ImageIO.read(new File("gold.png"));
					} catch (IOException e) {
						e.printStackTrace();
					}

					g.drawImage(
							grau,
							(int) ((i + 1) * getFelderGroesse() + ((1.5 * getFelderGroesse()) - 5)),
							(j + 1) * getFelderGroesse()
									- (getFelderGroesse() - 5),
							getFelderGroesse() - 1, getFelderGroesse() - 1,
							null);
					break;
				case 6:
					BufferedImage rot = null;
					try {
						rot = ImageIO.read(new File("ziegel.png"));
					} catch (IOException e) {
						e.printStackTrace();
					}

					g.drawImage(
							rot,
							(int) ((i + 1) * getFelderGroesse() + ((1.5 * getFelderGroesse()) - 5)),
							(j + 1) * getFelderGroesse()
									- (getFelderGroesse() - 5),
							getFelderGroesse() - 1, getFelderGroesse() - 1,
							null);
					break;

				}

				// g.fill3DRect((i*50)-45, (j*50)-45, 49 , 49, false);
				// g.draw3DRect((i*50)-45, (j*50)-45, 49 , 49, false);

			}

		}

	}

	private double felderGroesse() {
		// TODO Auto-generated method stub
		return felderGroesse();
	}

}
```


Klasse BedienpanelLinks:


```
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.Image;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class BedienpanelLinks extends JPanel {

	private JLabel holzLeft, weizenLeft, fleischLeft, eisenLeft, ziegelLeft,
			goldLeft;
	private JLabel resHolzLeft, resWeizenLeft, resFleischLeft, resEisenLeft,
			resZiegelLeft, resGoldLeft;
	
	private JLabel resIMGHolzLeft, resIMGWeizenLeft, resIMGFleischLeft,
			resIMGEisenLeft, resIMGZiegelLeft, resIMGGoldLeft;
	

	private JButton bauerLeft,kriegerLeft, ritterLeft, spaeherLeft;
	private JPanel ressourcenLeft;
	private JPanel bedienPanelLeft;
	private JLabel ressourcenNameLeft;

	public BedienpanelLinks() {

		JPanel bedienPanelLeft = new JPanel();
		bedienPanelLeft.setLayout(new GridLayout(3, 1));

		ressourcenLeft = new JPanel();
		ressourcenLeft.setLayout(new GridLayout(6, 3, 5, 5));
		// ressourcenLeft.setAlignmentX(5);
		// ressourcenLeft.setAlignmentY(5);

		ressourcenNameLeft = new JLabel("Ressourcen");

		holzLeft = new JLabel("Holz");
		weizenLeft = new JLabel("Weizen");
		fleischLeft = new JLabel("Fleisch");
		eisenLeft = new JLabel("Eisen");
		ziegelLeft = new JLabel("Ziegel");
		goldLeft = new JLabel("Gold");

		// Bilder von Ressourcen

		ImageIcon eisen = new ImageIcon("eisen.png");
		eisen.setImage(eisen.getImage().getScaledInstance(20, 20,
				Image.SCALE_DEFAULT));

		ImageIcon fleisch = new ImageIcon("fleisch.png");
		fleisch.setImage(fleisch.getImage().getScaledInstance(20, 20,
				Image.SCALE_DEFAULT));

		ImageIcon holz = new ImageIcon("holz.png");
		holz.setImage(holz.getImage().getScaledInstance(20, 20,
				Image.SCALE_DEFAULT));

		ImageIcon weizen = new ImageIcon("weizen.png");
		weizen.setImage(weizen.getImage().getScaledInstance(20, 20,
				Image.SCALE_DEFAULT));

		ImageIcon gold = new ImageIcon("gold.png");
		gold.setImage(gold.getImage().getScaledInstance(20, 20,
				Image.SCALE_DEFAULT));

		ImageIcon ziegel = new ImageIcon("ziegel.png");
		ziegel.setImage(ziegel.getImage().getScaledInstance(20, 20,
				Image.SCALE_DEFAULT));

		resIMGHolzLeft = new JLabel(holz);

		resIMGWeizenLeft = new JLabel(weizen);

		resIMGFleischLeft = new JLabel(fleisch);

		resIMGEisenLeft = new JLabel(eisen);

		resIMGZiegelLeft = new JLabel(ziegel);

		resIMGGoldLeft = new JLabel(gold);

		resHolzLeft = new JLabel("1");
		resWeizenLeft = new JLabel("1");
		resFleischLeft = new JLabel("2");
		resEisenLeft = new JLabel("3");
		resZiegelLeft = new JLabel("2");
		resGoldLeft = new JLabel("3");
		ressourcenLeft.add(holzLeft);
		ressourcenLeft.add(resIMGHolzLeft);
		ressourcenLeft.add(resHolzLeft);
		ressourcenLeft.add(weizenLeft);
		ressourcenLeft.add(resIMGWeizenLeft);
		ressourcenLeft.add(resWeizenLeft);
		ressourcenLeft.add(fleischLeft);
		ressourcenLeft.add(resIMGFleischLeft);
		ressourcenLeft.add(resFleischLeft);
		ressourcenLeft.add(eisenLeft);
		ressourcenLeft.add(resIMGEisenLeft);
		ressourcenLeft.add(resEisenLeft);
		ressourcenLeft.add(ziegelLeft);
		ressourcenLeft.add(resIMGZiegelLeft);
		ressourcenLeft.add(resZiegelLeft);
		ressourcenLeft.add(goldLeft);
		ressourcenLeft.add(resIMGGoldLeft);
		ressourcenLeft.add(resGoldLeft);

		ressourcenLeft.setVisible(true);

		bedienPanelLeft.add(ressourcenNameLeft);
		bedienPanelLeft.add(ressourcenLeft);
		bedienPanelLeft.setVisible(true);
		bedienPanelLeft.setOpaque(false);
		// c.add(bedienPanelLeft, BorderLayout.WEST);
	}

	

}
```


Ich hoffe ihr könnt damit was anfangen und ich habs nicht viel zu wirr gemacht 

Beste Grüße und einen wunderschönen Abend,

hylci


----------



## bERt0r (29. Okt 2011)

Im Konstruktor von BedienPanelLinks machst du ein JPanel:

```
JPanel bedienPanelLeft = new JPanel();
```
auf das addest du alle sachen. In deiner GUI addest du aber das BedienPanelLinks, nicht das bedienpanelLeft.
Entweder du addest das bedienPanelLeft auf mit this.add(bedienpanelLeft) auf dein BedienPanelLinks, oder du sparst dir das bedienpanelLeft und ersetzt die ganzen aufrufe einfach durch this:

```
this.add(ressourcenNameLeft);
        this.add(ressourcenLeft);
```


----------



## hylci (29. Okt 2011)

bERt0r!!!! :toll: Ich könnte dich küssen! Vielen vielen Dank!!!!! 

Irgendwie war das in meinem Kopf vollkommen logisch, dass ich im Konstruktor noch ein Panel erzeugen muss, auf dass ich die einzelnen Unterpanel adde, aber natürlich macht es überhaupt keinen Sinn! :autsch:

Auf jeden Fall noch mal ganz herzlichen Dank, jetzt kann ich endlich weiter machen.  

Nachdem du allerdings so schnell geantwortet hast und deine fachliche Kompetenz damit für mich außer Frage steht würde mich, falls du noch Zeit und Lust hast, noch folgendes interessieren: 
Findest du die grundlegende Struktur für die Erzeugung der ProgrammGUI okay, oder mach ich irgendwas grundlegend falsch (z.B. in der Klasse Spielfeld die Bilder innhalb der paintComponent Mehtode zu laden oder irgendwas anders....)

Beste Grüße und eine überaus hervorragende und annehmliche Nacht,

hylci


----------



## bERt0r (29. Okt 2011)

> Findest du die grundlegende Struktur für die Erzeugung der ProgrammGUI okay, oder mach ich irgendwas grundlegend falsch (z.B. in der Klasse Spielfeld die Bilder innhalb der paintComponent Mehtode zu laden oder irgendwas anders....)


Ja da machst du was grundlegend falsch damit. Das Laden der Bilder gehört in den Konstruktor, das muss schließlich nur einmal gemacht werden. Die paintComponent Methode wird aber sehr oft von der JVM aufgerufen. Besonders weil es sehr lange dauert Bilder von der Festplatte zu laden rate ich dir, lade sie im Konstruktor, speichere sie in Variablen oder einer Collection und greif in der paintComponent Methode dann einfach auf die geladenen Bilder zu.


----------



## hylci (29. Okt 2011)

Alles klar,
vielen Dank, hast mir wirklich sehr geholfen. 

Werd das dann umbauen. Bin mla gespannt, wieviele Fehler ich noch machen werd, bis das Ding einmal halbwegs steht 

Beste Grüße und ne schöne Nacht,

hylci


----------

