# Verbinden von Mehreren Klassen



## 786Newbie (24. Jun 2014)

Heyho leute ich programmiere momentan ein kleines Spielchen (2 Spieler Reaktor).
In dem Spiel hab ich 5 verschiedene Spielmodi , pro modi eine Klasse 
Ich will das so machen,dass sobald ich den Button "schnelles Spiel" anklicke, der Erste Spielmodi startet und wenn ich es  fertig hab, soll es  "ausgehen", die punkte dabei gespeichert halten, und dann das zweite Modus an machen.....dann3te usw.

Problem ist :
1. ich hab ka wie ich das mit reihenfolge hinkrieg, egal was ich versuche entweder starten alle, oder nur ein einziges und danach fertig.

2. Die punkte werden zwar gespeichert, aber sie werden nicht auf nächste klasse übertragen obwohl selbe variable benutze, es fängt wieder bei null an.

3. Mache Java noch nicht lange also bitte leicht erklären 

Hoffe jemand kann mir helfen bin unter  Zeitdruck da ich es in 1-2 Tage fertig habe muss und nur noch an diese 2 Probleme hänge


Hauptklasse:

```
import java.awt.*;
import java.awt.event.*;

public class Startmenu extends Frame implements ActionListener{
	
	// klassen
	Farbnamen frbnmen = new Farbnamen();
	Gesamtpunkte versuch= new Gesamtpunkte();
	Gleich symbol = new Gleich ();
	Maus bilder = new Maus ();
	Weiss kl = new Weiss();
	Zeahler go = new Zeahler();

	//Declarations
	Button b1= new Button ("Schnelles Spiel");
	Button b2= new Button ("Spiel Einrichten");
	
	public void schnellesSpiel (){
		SchnellesSpiel fff= new SchnellesSpiel();
		fff.reihenfolge();	
	}
	
	public void spielEinrichten(){	
		SpielEinrichten ggg= new SpielEinrichten();
		ggg.setVisible(true);
		ggg.setSize(500,500);
	}
	
	Startmenu(){
		super("2Spieler Reaktor");
		setLayout(new GridLayout (8,1));
		add(b1);
		add(b2);
		b1.addActionListener(this);
		b2.addActionListener(this);
	}
	
	public void actionPerformed (ActionEvent e){
		if (e.getSource()==b1){
			schnellesSpiel();
			
		}	
		if (e.getSource()==b2){
			 spielEinrichten();
		}
	}
	public static void main (String []args){
		Startmenu menu = new Startmenu();
		WindowListener wl = new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		};
		menu.addWindowListener(wl);
		menu.setVisible(true);
		menu.setSize(500,500);	

	}
}
```

ERSTER SPIELMODUS

```
import java.awt.*;
import java.awt.event.*;


public class Farbnamen extends Frame implements Runnable, KeyListener {

	// klasse
	Gesamtpunkte versuch = new Gesamtpunkte();

	// Declarations
	Thread t1;
	boolean alreadyPressed = false;
	// Anfangspunkte in diesem Modus
	int punkte = 1;
	int oftdruck=0;
	
	String f;
	String[] farbfeld = { "SCHWARZ", "BLAU", "GRAU", "GRÜN", "ORANGE", "ROT","PINK", "GELB"};
	int i, x;

	// Konstruktur
	Farbnamen() {
		super("2 Spieler Reaktor");
		addKeyListener(this);
	}
	
	// Animation
	public void startAnimation() {
		t1 = new Thread(this);
		t1.start();
	}

	@SuppressWarnings("deprecation")
	public void stopAnimation() {
		t1.stop();	
	}

	public void run() {
		while (true) {
			i = (int) (Math.random() * 8);
			x = (int) (Math.random() * 8);
			repaint();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
			}
		}
	}

	public void paint(Graphics g) {

		// Hintergrundfarbe
		g.setColor(Color.cyan);
		g.fillRect(0, 0, 300, 600);
		g.setColor(Color.gray);
		g.fillRect(300, 0, 300, 600);
		g.setColor(Color.red);
		g.fillRect(600, 0, 300, 600);

		// Spieler1
		g.setColor(Color.black);
		g.drawString("Spieler1", 10, 150);
		g.drawString("Gesamtpunkte: " +versuch.getPunkte1() , 10, 165);
		// Spieler2
		g.drawString("Spieler2", 845, 150);
		g.drawString("Gesamtpunkte: " + versuch.getPunkte2(), 787, 165);

		// Modus farbnamen:


		if (x == 0) {
			g.setColor(Color.black);
		}
		if (x == 1) {
			g.setColor(Color.blue);
		}
		if (x == 2) {
			g.setColor(Color.DARK_GRAY);
		}
		if (x == 3) {
			g.setColor(Color.green);
		}
		if (x == 4) {
			g.setColor(Color.orange);
		}
		if (x == 5) {
			g.setColor(Color.red);
		}
		if (x == 6) {
			g.setColor(Color.pink);
		}
		if (x == 7) {
			g.setColor(Color.yellow);
		}
		g.drawString(farbfeld[i], 450, 300);
		
		//text im mittelfeld
		g.setColor(Color.white);
		g.drawString(versuch.getMittelfeldinfo(), 330, 325);
		g.drawString(versuch.getNewround(), 330, 340);
	}

	public void keyTyped(KeyEvent e) {
	}

	public void keyPressed(KeyEvent e) {
	}

	public void keyReleased(KeyEvent e) {
		// Neue Runde
		if (e.getKeyCode() == KeyEvent.VK_S) {
				oftdruck++;
				alreadyPressed= false;
				versuch.setMittelfeldinfo("Wer ist schneller?");
				versuch.setNewround(" ");
				startAnimation();
				if(oftdruck==4){;
					stopAnimation();	
					setVisible(false);
				}		
		}

		// FALLS GESCHAFT
		if (i == x) {
			
			if (e.getKeyCode() == KeyEvent.VK_ENTER) {
				if (alreadyPressed == false) {
					versuch.setPunkte1(punkte);
					versuch.setMittelfeldinfo("Spieler1 war schneller!");
					versuch.setNewround("Drücke die taste S für eine weitere Runde");
					repaint();
					stopAnimation();
				}
				alreadyPressed = true;
			}
			if (e.getKeyCode() == KeyEvent.VK_SPACE) {
				if (alreadyPressed == false) {
					versuch.setPunkte2(punkte);
					versuch.setMittelfeldinfo("Spieler2 war schneller!");
					versuch.setNewround("Drücke die taste S für eine weitere Runde");
					repaint();
					stopAnimation();
				}
				alreadyPressed= true;
			}
		}
		// FALLS NICHT GESCHAFT
		if (!(i == x)) {
			
			if (e.getKeyCode() == KeyEvent.VK_ENTER) {
				if (alreadyPressed == false) {
					versuch.machwenigerPunkte1(punkte);
					stopAnimation();
					versuch.setMittelfeldinfo("Das war schlecht Spieler1! Versuchs nochmal!");
					versuch.setNewround("Drücke die taste S für eine weitere Runde");
					repaint();
				}
				alreadyPressed= true;
			}
			if (e.getKeyCode() == KeyEvent.VK_SPACE) {
				if (alreadyPressed == false) {
					versuch.machwenigerPunkte2(punkte);
					stopAnimation();
					versuch.setMittelfeldinfo("Das war schlecht Spieler2! Versuchs nochmal!");
					versuch.setNewround("Drücke die taste S für eine weitere Runde");
					repaint();
				}
				alreadyPressed= true;
			}
		}
	}
}
```

ZWEITER SPIELMODUS

```
import java.awt.*;
import java.awt.event.*;
import java.util.HashSet;

public class Gleich extends Frame implements Runnable,KeyListener {

	// klassen
	Gesamtpunkte versuch = new Gesamtpunkte();

	// Declarations
	Thread t1;
	boolean alreadyPressed = false;
	int punkte=1;
	int oftdruck=0;
	
	//6 symbole 
	Image img0  =getToolkit().getImage("C:/Users/Public/Pictures/Sample Pictures/Desert.jpg");
	Image img1  =getToolkit().getImage("C:/Users/Public/Pictures/Sample Pictures/Koala.jpg");
	Image img2  =getToolkit().getImage("C:/Users/Public/Pictures/Sample Pictures/Lighthouse.jpg");
	Image img3  =getToolkit().getImage("C:/Users/Public/Pictures/Sample Pictures/Tulips.jpg");;
	Image img4  =getToolkit().getImage("C:/Users/Public/Pictures/Sample Pictures/Chrysanthemum.jpg");
	Image img5  =getToolkit().getImage("C:/Users/Public/Pictures/Sample Pictures/Jellyfish.jpg");
	
	//Zufalls zahlen der 6 kästen
	int i1,i2,i3,i4,i5,i6;
	
	public Gleich (){	
		super("2Spieler Reaktor");
		addKeyListener(this);
	}

	public void startAnimation(){
		t1 = new Thread(this);
		t1.start();	
	}
	@SuppressWarnings("deprecation")
	public void stopAnimation(){
		t1.stop();
	}
	
	public void run(){
		while (true) {
			//Zufalls zahlen der 6 kästen			
			 i1=(int) (Math.random()*6);//zufallszahl
			 i2=(int) (Math.random()*6);//zufallszahl
			 i3=(int) (Math.random()*6);//zufallszahl
			 i4=(int) (Math.random()*6);//zufallszahl
			 i5=(int) (Math.random()*6);//zufallszahl
			 i6=(int) (Math.random()*6);//zufallszahl	
			repaint();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				}
		}
	}
	public void paint (Graphics g){

		// Hintergrundfarbe
		g.setColor(Color.cyan);
		g.fillRect(0, 0, 300, 600);
		g.setColor(Color.gray);
		g.fillRect(300, 0, 300, 600);
		g.setColor(Color.red);
		g.fillRect(600, 0, 300, 600);

		// Spieler1
		g.setColor(Color.black);
		g.drawString("Spieler1", 10, 150);
		g.drawString("Gesamtpunkte: " + versuch.getPunkte1(), 10, 165);
		// Spieler2
		g.drawString("Spieler2", 845, 150);
		g.drawString("Gesamtpunkte: " + versuch.getPunkte2(), 787, 165);
		
		//MODUS IF 3 GLEICH
		
		//Kasten 1	
		if (i1==0){g.drawImage(img0, 360, 200,50,50, this);}
		if (i1==1){g.drawImage(img1, 360, 200,50,50, this);}
		if (i1==2){g.drawImage(img2, 360, 200,50,50, this);}
		if (i1==3){g.drawImage(img3, 360, 200,50,50, this);}
		if (i1==4){g.drawImage(img4, 360, 200,50,50, this);}
		if (i1==5){g.drawImage(img5, 360, 200,50,50, this);}
		
		//Kasten2
		if (i2==0){g.drawImage(img0, 420,200,50,50, this);}
		if (i2==1){g.drawImage(img1, 420,200,50,50, this);}
		if (i2==2){g.drawImage(img2, 420,200,50,50, this);}
		if (i2==3){g.drawImage(img3, 420,200,50,50, this);}
		if (i2==4){g.drawImage(img4, 420,200,50,50, this);}
		if (i2==5){g.drawImage(img5, 420,200,50,50, this);}
		
		//Kasten3
		if (i3==0){g.drawImage(img0, 480,200,50,50, this);}
		if (i3==1){g.drawImage(img1, 480,200,50,50, this);}
		if (i3==2){g.drawImage(img2, 480,200,50,50, this);}
		if (i3==3){g.drawImage(img3, 480,200,50,50, this);}
		if (i3==4){g.drawImage(img4, 480,200,50,50, this);}
		if (i3==5){g.drawImage(img5, 480,200,50,50, this);}
		
		//Kasten4
		if (i4==0){g.drawImage(img0, 360,260,50,50, this);}
		if (i4==1){g.drawImage(img1, 360,260,50,50, this);}
		if (i4==2){g.drawImage(img2, 360,260,50,50, this);}
		if (i4==3){g.drawImage(img3, 360,260,50,50, this);}
		if (i4==4){g.drawImage(img4, 360,260,50,50, this);}
		if (i4==5){g.drawImage(img5, 360,260,50,50, this);}
		
		//Kasten5	
		if (i5==0){g.drawImage(img0, 420,260,50,50, this);}
		if (i5==1){g.drawImage(img1, 420,260,50,50, this);}
		if (i5==2){g.drawImage(img2, 420,260,50,50, this);}
		if (i5==3){g.drawImage(img3, 420,260,50,50, this);}
		if (i5==4){g.drawImage(img4, 420,260,50,50, this);}
		if (i5==5){g.drawImage(img5, 420,260,50,50, this);}
		
		//Kasten6
		if (i6==0){g.drawImage(img0, 480,260,50,50, this);}
		if (i6==1){g.drawImage(img1, 480,260,50,50, this);}
		if (i6==2){g.drawImage(img2, 480,260,50,50, this);}
		if (i6==3){g.drawImage(img3, 480,260,50,50, this);}
		if (i6==4){g.drawImage(img4, 480,260,50,50, this);}
		if (i6==5){g.drawImage(img5, 480,260,50,50, this);}
		//text im mittelfeld
		g.setColor(Color.white);
		g.drawString(versuch.getMittelfeldinfo(), 330, 325);
		g.drawString(versuch.getNewround(), 330, 340);
	}
	
	public void keyTyped(KeyEvent e) { 
	} 
	public void keyPressed(KeyEvent e) {       	 
 	}
	public void keyReleased(KeyEvent e) {
	 
	// Neue Runde
		if (e.getKeyCode() == KeyEvent.VK_S) {
				oftdruck++;
				alreadyPressed= false;
				versuch.setMittelfeldinfo("Wer ist schneller?");
				versuch.setNewround(" ");
				startAnimation();
				if(oftdruck==5){
					setVisible(false);
					stopAnimation();		
				}
		}
	 
    //Falls mindestens 3 gleich sind
	 HashSet<Integer> set = new HashSet<>(6);
    	set.add(i1);
    	set.add(i2);
    	set.add(i3);
    	set.add(i4);
    	set.add(i5);
    	set.add(i6);
    	if(set.size() <= 4) {
    		if (e.getKeyCode() == KeyEvent.VK_ENTER) {
				if (alreadyPressed == false) {
					versuch.setPunkte1(punkte);
					versuch.setMittelfeldinfo("Spieler1 war schneller!");
					versuch.setNewround("Drücke die taste S für eine weitere Runde");
					repaint();
					stopAnimation();
				}
				alreadyPressed = true;
			}
			if (e.getKeyCode() == KeyEvent.VK_SPACE) {
				if (alreadyPressed == false) {
					versuch.setPunkte2(punkte);
					versuch.setMittelfeldinfo("Spieler2 war schneller!");
					versuch.setNewround("Drücke die taste S für eine weitere Runde");
					repaint();
					stopAnimation();
				}
				alreadyPressed= true;
			}
		}
	   	// falls NICHT mindestens 3 gleich sind
	   	if(set.size() >= 4) {
	   		if (e.getKeyCode() == KeyEvent.VK_ENTER) {
				if (alreadyPressed == false) {
					versuch.machwenigerPunkte1(punkte);
					stopAnimation();
					versuch.setMittelfeldinfo("Das war schlecht Spieler1! Versuchs nochmal!");
					versuch.setNewround("Drücke die taste S für eine weitere Runde");
					repaint();
				}
				alreadyPressed= true;
			}
			if (e.getKeyCode() == KeyEvent.VK_SPACE) {
				if (alreadyPressed == false) {
					versuch.machwenigerPunkte2(punkte);
					stopAnimation();
					versuch.setMittelfeldinfo("Das war schlecht Spieler2! Versuchs nochmal!");
					versuch.setNewround("Drücke die taste S für eine weitere Runde");
					repaint();
				}
				alreadyPressed= true;
			}
		}
	}
}
```
Klasse worin sich variable mit Punkten usw. befinden.

```
public class Gesamtpunkte {

	
	int hhh;
	int punkte1=0,punkte2=0;
	String mittelfeldinfo= new String ("Wer ist schneller?");
	String newround= new String(" ");
	

	
	
		//Punkte für Spieler1 
	public void setPunkte1(int punkte){
			punkte1=punkte1+punkte;
	}
	public void machwenigerPunkte1(int punkte){
			punkte1=punkte1-punkte;
	}
	public int getPunkte1 (){
			return punkte1;
	}

	//Punkte für Spieler2
	public void setPunkte2(int punkte){
		punkte2=punkte2+punkte;
	}
	public void machwenigerPunkte2(int punkte){
		punkte2=punkte2-punkte;
	}
	public int getPunkte2 (){
		return punkte2;
	}
	
	//Meldung im Mittleren Feld
	public void setMittelfeldinfo (String info){
		mittelfeldinfo = info;
	}
	public String getMittelfeldinfo (){
		return mittelfeldinfo;
	}
	
	//String neue Runde
	public void setNewround(String text){
		newround = text;
	}
	public String getNewround(){
		return newround;
	}
	
	
	public void setHHH(int zahl){
		hhh=zahl;
	}
	
	public int getHHH (){
		return hhh;
	}
}
```


----------



## Gucky (25. Jun 2014)

Zuerst kannst du in der paint Methode des Frames diese if Schlange durch einen switch case ersetzen. Das wid performanter, schöner und besser lesbar.

Zu den Spielmodi: Ich würde eine Klasse Anwendung machen, der je nach Spielmodus entweder ein Objekt der, die Klasse AbstractSpielmodus erweiternden, Klasse Spielmodus[ZAHL], welches Methoden bereitstellt, um den Spielmodus auszuführen einen Integer, der für den Spielmodus steht und beide Spielmodi in eine Klasse tun. Bevorzugen tue ich Variante 1.


----------



## 786Newbie (25. Jun 2014)

die vielen If-schlangen mit switch-answeisung wechslen
verstanden (y)

rest null verstanden , too much kommas


----------



## Gucky (25. Jun 2014)

Ok. 

Du erstellst eine Klasse AbstractModus, die Methodenfümpfe, Variablen und ggf. schon fertige Methoden (z.B. getter und setter) beteitstellt.
Dann machst du für jeden deiner Spielmodi eine Klasse Spielmodus1...5 extends AbstractModus.
Dann erstellst du eine Klasse Anwendung, die alles "unter der Haube" steuert.
Dieser übergibst du aus der GUI Klasse eine Zahl über die Methode starteSpielmodus(int) mit optionaler Bereichsüberprüfung.
Die Klasse Anwendung schreibt den geforderten Spielmodus in eine Variable des Typs AbstractModus und ruft die Methoden auf, die den Spielmodus starten und ausführen.


PS: ich hab mir meinen Kommatext noch mal durchgelesen. Der hat wirklich keinen Sinn gemacht.  Es war spät/früh.


----------



## 786Newbie (26. Jun 2014)

ich sollte erwähnen dass mein wissen  von klassen verbinden nur :
klasse ggg = new Klasse();  und 
ggg.methode(); ist xD

also erst mal bissel gegooglet ,korrigier mich bitte falls ich falsch liege:

- eine Klasse AbstractModus mit  methoden, variablen mit getter setter usw.
     -->frage: variablen für was und welche methoden sollten da sein ?

-public class Spielmodus1 extends Abstractmodus{..}
      --> frage: die klasse lässt dann erste spielmodus starten bzw beenden?

-public class Spielmodus2 extends Abstractmodus{..}
    --> --> frage: die klasse lässt dann zweiten spielmodus starten bzw beenden?

-public class Anwendung {..}

-aus der GUI Klasse eine zahl über die Methode starteSpielmodus(int), zu klasse Anwendung übergeben
   -->frage: was ist die GUI klasse? meinst du damit meine Klasse Startmenu?
   -->2.frage: starteSpielmodus soll also nur :   return int;   geben oder?
   -->3.frage: was meinst du mit optionaler Bereichs überprüfung?
    --> 4. Klasse Anwendung startet also je nachdem ob int 1 oder 2 ist, Spielmodus 1 oder 
            Spielmodus2, wodurch das jeweilige mini Spiel startet?

ich hoff ich habs jetzt richtig verstande xD


----------



## Gucky (26. Jun 2014)

Allgemeine Methoden und Variablen, die jeder Spielmodus braucht
Diese Klasse startet ihn nicht nur sondern sie verwaltet ihn
Diese Klasse startet ihn nicht nur sondern sie verwaltet ihn


Die GUI Klasse ist die Klasse, die das GUI macht. Also vermutlich ja.
Starte Spielmodus gibt nichts zurück.
Ob es eine Fehlermeldung geben soll, wenn du versuchst Spielmodus 8 oder -5 zu starten (vorzugsweise eine Exception)
Ja. Anwendung ruft die allgemeinen Methoden aus AbstractModus der Klasse auf, die gerade in der Variable 
	
	
	
	





```
AbstractModus aktModus
```
 in Anwendung steht.


----------



## 786Newbie (26. Jun 2014)

allgmeine variablen,die Jede klasse braucht und sich ständig ändern müssen wie punkte usw.
hab ich in Klasse Gesamtpunkte, damit hätte ich schonmal die Klasse AbstractModus
methoden die ich allgemein bzw in jeder klasse benutze gibt es nicht, außer das was im keyListener steht
sollt ich das auch als eine Methode in Klasse AbstractModus einbauen? damit wenn im jeweilgen Spiel die if bedingung erfüllt ist, es einfach die Methode startet? falls das überhaupt so geht 

Klasse Anwendung bekommt aus der Klasse Startmenu eine Zahl über die methode Startespielmodus(int);
wenn ich die zahl nicht mit return übergebe, wie mach ich es dann?


----------



## Gucky (26. Jun 2014)

Irgendwas müssen die Spielmodi gemeinsam haben. Und da setzt du an. Von mir aus die Methode startModus.
Anwendung macht das hier:

[Java]AbstractModus aktModus = null;

public void startModus(int modus){
  switch (modus){
  case 1: aktModus = new Spielmodus1();
  case 2:...
  ...
  }
  aktModus.startModus();
  //übergib aktModus alle nötigen Werte und Variablen
}
[/Java]

Zum Beispiel reagieren alle Modi auf einen Tastendruck. Den reicht das GUI an Anwendung weiter und diese macht 
	
	
	
	





```
aktModus.tastenDruck(keyCode);
```

Du übergibst doch nichts mit return. Mit return springst du zurück oder du gibst Werte zurück UND springst zurück an den Ort, von dem der Interpreter gekommen ist.


----------



## 786Newbie (26. Jun 2014)

ist zwar bissel dumm dass erst jetzt zu frage, aber habs am anfang denk ich falsch vestande 


"Dann machst du für jeden deiner Spielmodi eine Klasse Spielmodus1...5 extends AbstractModus"

ich habe ja schon für jeden spielmodus klasse gemacht
Klasse 
	
	
	
	





```
Farbnamen
```
, 
	
	
	
	





```
Gleich
```
, 
	
	
	
	





```
Maus
```
, 
	
	
	
	





```
Weiss
```
 ,
	
	
	
	





```
Zeahler
```
meintest du jetzt mit dem satz, ich soll jetzt für Farbnamen, die  Klasse 
	
	
	
	





```
Spielmodus1 extends
```
  AbstractModus mache?
ODER
bei Klasse 
	
	
	
	





```
Farbnamen extends Abstractmodus
```
  machen?

falls die zweite möglichkeit:

```
public class Farbnamen extends Frame implements Runnable, KeyListener {..}
```
wie kann ich nach extend AbstractModus schreiben ohne dass es fehler wird? finds net raus 
oder besser gesagt nie sowas gemacht


----------



## Gucky (26. Jun 2014)

Dann schreibst du Klassen, die alle Klassen für die Spielmodi verwalten und die Spielmodi steuern. Das wäre die best practise, die mir einfiele.
Oder du schreibst das Ganze um.


----------



## 786Newbie (26. Jun 2014)

alles nochmal neu schreibe wäre schlechte idee muss des bis morgen eig. fertig haben da ich noch den bis jetzt 25 seiten langen code durch dokumentieren muss und es bis sonntag bzw montag abgeschickt haben muss xD

"Dann schreibst du Klassen, die alle Klassen für die Spielmodi verwalten und die Spielmodi steuern. "

hab ich ja versucht : 
erst klasse 
	
	
	
	





```
Startmenu
```
 wo es 2 buttons gibt
1. button: schnelles Spiel , startet  klasse, welche spielmodi 1 startet, nach spiel schließt und dann Spielmodi2 startet usw.
2.button : Spiel Einrichten, startet die Klasse 
	
	
	
	





```
SpielEinrichten
```
 worauf hin sich ein fenster 
                mit 5 Checkboxen und ein Button öffnet. 
                Darauf hin sollte je nachdem wie viele Checkboxen auf true sind und dann der Button geklickt , diese Spielmodu nach 
                der reihe starten

hab ja alles mit meinen bis jetzigen ziel hingekriegt , nur nicht reihenfolge

durch deine Erklärungen hab ich jetzt verstande, dass wenn ich 1.Button=("schnelles Spiel") anklicke , soll sich eine Klasse öffnen die das hier tut :

```
AbstractModus aktModus = null;
 
public void startModus(int modus){
  switch (modus){
  case 1: aktModus = new Spielmodus1();
  case 2:...
  ...
  }
  aktModus.startModus();
  //übergib aktModus alle nötigen Werte und Variablen
}
```

sry wenn ich nicht dauernd mitkomme, haben grad Hochsaison Arbeiten in Schule :rtfm:
daher leicht verschlafen 
aber danke dass du mir bei allen 3 probleme hilfst, werde mich eines tages revanchieren


----------



## Gucky (26. Jun 2014)

Dann machst du es so:


```
ArrayList <AbstractModus> modiList;

public Anwendung(){
  modiList = new ArrayList<AbstractModus>(5);
}

public void startModus(int[] spielmodi){
  for (int tempInt : spielmodi) {
    switch(tempInt){
    case 1:
      modiList.add(new Spielmodus1(/*Übergeben sämtlicher benötigter Werte*/));
      break;
    case 2: ...
    }
  }
  
  modiList.get(0).start();
}
```

Ist der Modus beendet, wird er aus der List gelöscht. Anwendung gibt sämtliche Events immer an das erste Element der List weiter.


----------



## 786Newbie (26. Jun 2014)

```
case 1:
	    	modiList.add(new Farbnamen(/*Übergeben sämtlicher benötigter Werte*/));
	    	break;
	    case 2: 
	    	modiList.add(new Gleich());
	    	break;
	    }
	  }
```

wenn ich des so einfüge zeigt es bei mir  
	
	
	
	





```
modilList.add
```
 dass add unterstrichen an
dass ich es zu 
	
	
	
	





```
modiList.addAll
```
 ändernsoll mach ich das, kommt dass ich es wieder zurück zu 

```
.add
```
ändern soll :lol: oder 
	
	
	
	





```
cast argument 1 to Collection<? extends AbstractModus>
```

und bei 
	
	
	
	





```
modiList.get(0).start();
```
soll ich entweder 
	
	
	
	





```
addcast tomodiList.get(0)
```
 oder eine methode start() in klasse AbstractModus erstelle soll, ich nehm mal an es ist, methode erstellen, 
und darin dass stehen soll? :question:

```
AbstractModus aktModus = null;
 
public void startModus(int modus){
  switch (modus){
  case 1: aktModus = new Spielmodus1();
  case 2:...
  ...
  }
  aktModus.startModus();
  //übergib aktModus alle nötigen Werte und Variablen
}
```


----------



## Gucky (26. Jun 2014)

Diese Klasse AbstractModus dient der Zusammenfassung aller Spielmodi. Alle Spielmodi erben von AbstractModus. Diese Klasse hat Methoden, zum Verarbeiten von Events, die von den einzelnen Spielmodi überschrieben werden.

Das was du geschrieben hast, was in die Methode INNERHALB der Spielmodi soll, macht ÜBERHAUPT KEINEN Sinn. Schließlich willst du nicht den Spielmodus starten und der startet dann noch einen Spielmodus. Ich wusste nur niczt die Namen deiner Spielmodi, weshalb ich sie durchnummerier habe.


Ich weiß, es ist spät aber ein bisschen Eigeninitiative und Mitdenken, solltest du trotzdem zeigen. Ansonsten kannst du auch deine Versuche abgeben. Ein Teil läuft ja.


----------



## 786Newbie (27. Jun 2014)

Sry ich geb mein bestes, weis von verbinden von mehreren Klassen nichts, das bisschen was ich weis, ist von google bzw andere kleinere beispiele, ich versuch das jetzt nochmal zu verstehen 

```
Klasse AbstractModus
```
 hat alle variablen, wie Punkte die in Jedem Spielmodi gleichen wert haben soll
Damit alle Spielmodi von AbstractModus erben können, muss ich beim code

```
public class Farbnamen extends AbstractModus....
```
 machen 

momentan hab ich da 

```
public class Farbnamen extends Frame implements Runnable,KeyListener {
```
 stehen, wie kann ich das erben lassen?
 wenn ich 
	
	
	
	





```
extends Frame,AbstractModus
```
 mache gilt es als fehler

"Das was du geschrieben hast, was in die Methode INNERHALB der Spielmodi soll, macht ÜBERHAUPT KEINEN Sinn."
Sry hab da echt nicht nachgedacht war blöd von mir, aber ich komme wirklich nicht darauf, was ich dann in die Methode rein schreibe soll 


Ich hab jetzt Klasse 
	
	
	
	





```
AbstractModus
```
 und alle variablen schonmal reingeschrieben, spezielle methoden, die meine Spielmodi brauchen gibt es nicht.
hab jetzt die Klasse 
	
	
	
	





```
Anwendung
```
 wo ich in der Switch anweisung die verschiednen Spielmodi reingeschrieben habe. es zeigt aber noch den Fehler . add was ich letzten post erwähnte


----------



## 786Newbie (27. Jun 2014)

Klasse AbstractModus :
Ich versteh nur noch nicht wie ich in dieser Klasse alle Spielmodi zusammenfassen soll, 

```
public class AbstractModus {

	int punkte1=0,punkte2=0;
	String mittelfeldinfo= new String ("Wer ist schneller?");
	String newround= new String(" ");

		//Punkte für Spieler1 
	public void setPunkte1(int punkte){
			punkte1=punkte1+punkte;
	}
	public void machwenigerPunkte1(int punkte){
			punkte1=punkte1-punkte;
	}
	public int getPunkte1 (){
			return punkte1;
	}

	//Punkte für Spieler2
	public void setPunkte2(int punkte){
		punkte2=punkte2+punkte;
	}
	public void machwenigerPunkte2(int punkte){
		punkte2=punkte2-punkte;
	}
	public int getPunkte2 (){
		return punkte2;
	}
	
	//Meldung im Mittleren Feld
	public void setMittelfeldinfo (String info){
		mittelfeldinfo = info;
	}
	public String getMittelfeldinfo (){
		return mittelfeldinfo;
	}
	
	//String neue Runde
	public void setNewround(String text){
		newround = text;
	}
	public String getNewround(){
		return newround;
	}
	

}
```


----------



## Gucky (27. Jun 2014)

Du lässt die Klasse AbstractModus von Frame erben.

Dann müsstest du sie noch abstract machen (schließlich heißt sie so  )

Die Klasse AbstractModus beschreibt alle Gemeinsamkeiten zwischen diesen Spielmodi, damit Anwendung keine 5 Variablen braucht, sondern das Ganze in einer List speichern kann. Und das der Compiler meckert, wenn du versuchst die Objekte zur List zu adden ist klar. Schließlich erben die Spielmodi noch nicht von AbstractModus.


----------



## 786Newbie (27. Jun 2014)

```
public abstract class AbstractModus extends Frame {
```
gemacht und gemacht (y)
dadurch waren alle methoden 
wie z.b: 

```
public  void setPunkte1(int punkte){
			punkte1=punkte1+punkte;
	}
```
nicht mehr nutzbar, konnt sie nicht mehr vererben, also hab ich gegooglet
die beide jetzt link aml angeschaut :rtfm:
Galileo Computing :: Java ist auch eine Insel – 5.12 Abstrakte Klassen und abstrakte Methoden

Tutorial / Java Grundlagen / Vererbung

soll ich jetzt alle methoden  in AbstractModus jetzt in dieser schreibweise schreiben? :

```
public abstract  void setPunkte1(int punkte);
```

ich hoff ich konnt dieses mal bissel mit denke


----------



## Gucky (29. Jun 2014)

Ja tust du. 

Ja. Genau so meine ich das. Du könntest auch noch eine Klasse ModusVorlage machen, die alle immer gleichen Methoden (getter/setter) bereitstellt und von Frame erbt. Dann lässt du AbstractModus von ModusVorlage erben und die Modi von AbstractModus aber das wird, glaube ich, zu viel.

Genau so. Und die davon erbenden Klassen implementieren sich die Methoden dann selber.


Grund, aus dem es eine abstrakte Klasse ist und kein Interface: Von Interfaces können Objekte erstellt werden. (Ist mir grade eingefallen)


----------



## 786Newbie (29. Jun 2014)

hehe glaub nicht dass ich so viel zeit hab, muss es am montag bis 8 geschickt haben, und ich peil ja das nicht mal mehr durch xD

hab jetzt in AbstractModus alle methoden abstract gemacht, aber die methoden wurden noch nicht geerbt in anderen klassen


```
public class Farbnamen extends  Frame  implements Runnable, KeyListener{
```
muss ich da bei extends, Abstractmodus schreiben?:

```
public class Farbnamen extends  Frame,AbstractModus  implements Runnable, KeyListener{
```


Hier die AbstractModus klasse:


```
import java.awt.*;


public abstract class AbstractModus extends Frame {

	int hhh;
	int punkte1=0,punkte2=0;
	String mittelfeldinfo= new String ("Wer ist schneller?");
	String newround= new String(" ");

		//Punkte für Spieler1 
	public abstract  void setPunkte1(int punkte);
	public abstract void machwenigerPunkte1(int punkte);
	public abstract int getPunkte1 ();

	//Punkte für Spieler2
	public abstract void setPunkte2(int punkte);
	public abstract void machwenigerPunkte2(int punkte);
	public abstract int getPunkte2 ();
	
	//Meldung im Mittleren Feld
	public abstract void setMittelfeldinfo (String info);
	public abstract String getMittelfeldinfo ();
	
	//String neue Runde
	public abstract void setNewround(String text);
	public abstract String getNewround();
}
```


----------



## Gucky (29. Jun 2014)

Mehrfachvererbung ist in Java nicht möglich. Dafür müsstest du zu C++ wechseln.  
Das ist der Grund, aus dem AbstractModus von Frame erbt. Damit du die Spielmodi nur noch von AbstractModus erben lassen kannst.

Genau so hatte ich mir das vorgestellt. Und dann noch eine Methode, die von allen Spielmmodi überschrieben wird und die den Spielmodus startet.


BTW: ich hab das Gefühl, du würdest erst fragen und dann ert irgendwas machen. Versuch es doch einfach mal. Der Compiler wird meckern, bei der versuchten Mehrfachvererbung.


----------



## 786Newbie (29. Jun 2014)

"Damit du die Spielmodi nur noch von AbstractModus erben lassen kannst."


verstanden hab ich ja dass sie von Abstractmodus erben müssen, aber wie mach ich das?XD
was muss ich als code hinschreiben? 
vorher hab ich ja immer sowas wie:

```
referenz.methodeEins();
```
 geschrieben, was müsst ich jetzt machen? die methoden haben ja jetzt kein body, wie weis dann meine klasse was es machen muss wenn ich die methode aufrufe???:L

Ich weis dass du durch deine erklärung versuchst,dass ich darauf komme was ich machen muss
aber ich nicht einmal eine vermutung wie es gehen konnte :noe:

und nein ich lese deine antwort versuche irgendwas daraus zu mache, dann faile ich, dann google ich, dann probier ich nochmal und dann wenn es geht, frag ich für letzten check dich nochmal 

"Genau so hatte ich mir das vorgestellt. Und dann noch eine Methode, die von allen Spielmmodi überschrieben wird und die den Spielmodus startet."

diese eine Methode , war das die hier?:

```
import java.util.ArrayList;


public class Anwendung {

	ArrayList <AbstractModus> modiList;
	 
	public Anwendung(){
	  modiList = new ArrayList<AbstractModus>(5);
	}
	 
	public void startModus(int[] spielmodi){
	  for (int tempInt : spielmodi) {
	    switch(tempInt){
	    case 1:
	    	modiList.add(new Farbnamen(/*Übergeben sämtlicher benötigter Werte*/));
	    	break;
	    case 2: 
	    	modiList.add(new Gleich());
	    	break;
	    case 3:
	    	modiList.add(new Maus());
	    	break;
	    case 4:
	    	modiList.add(new Weiss());
	    	break;
	    case 5:
	    	modiList.add(new Zeahler());
	    	break;
	    }
	  }
	  
	  modiList.get(0).start();
	}
}
```


----------



## 786Newbie (30. Jun 2014)

vergiss den beitrag davor habs schon verstande

"Und dann noch eine Methode, die von allen Spielmmodi überschrieben wird und die den Spielmodus startet."

wie meinst du das? Ich soll in der Klasse AbstractModus eine methode schreiben, 
die alle Spielmodi überschreibt und startet?
was soll es denn überschreiben? und ich hab vorher immer für spielmodi starten sowas benutzt:

```
Klasse referenz = new Klasse();
referenz.setVisibli(true);
referenz.setSize(600,300);
referenz.startAnimation;
```
wie mache ich es jetzt????:L

"BTW: ich hab das Gefühl, du würdest erst fragen und dann ert irgendwas machen. Versuch es doch einfach mal. Der Compiler wird meckern, bei der versuchten Mehrfachvererbung. "

ich hatte es schon probiert und dich schonmal gefragt, aber du hast nicht drauf geantwortet
also dacht ich dass die frage falsch formuliert habe, und habs halt dann nochmal so gefragt 

nur noch 5 stunden bis zur abgabe xD
ich hoff die methode ist das letzte was ich noch machen muss opcorn:


----------



## Gucky (30. Jun 2014)

Die ganzen Setter kommen in die Methode rein.

[Java]
public abstract class sample{
  public abstract int getZahl();
}

public class one extends sample {
  @override
  public int getZahl(){
    return 1;
  }
}

public class two extends sample {
  @override
  public int getZahl(){
    return 2;
  }
}
[/Java]


Die Java VM ruft automatisch die richtige "Überschreibung" der Methoden auf.
Also wenn in der Variable vom Typ sample ein Objekt vom Typ one steht, so wird beim Aufruf von getZahl() 1 zurückgegeben. Steht ein Objekt vom Typ two drin, so wird 2 zurückgegeben, obwohl es dieselbe Variable ist und derselbe Methodenname.


----------



## 786Newbie (30. Jun 2014)

schuldige ich versteh das hier jetzt nicht

also erst mal, das sollen jetzt 3 klassen darstellen, als beispiel wie man Abstracte klassen benutzt oder?

hab jetzt in JEDEM SPIELMODUS KLASSE das gemacht und jetzt geht es wieder
bin also jetzt damit genauso weit, wie ich anfang ohne abstract war ???:L
hab gestestet und 2 spielmodi gleihczeitig angemacht, gemeinsame punkte gehen immer noch nicht :/


```
public void setPunkte1(int punkte) {
		punkte1= punkte1+punkte;
	}
	public void machwenigerPunkte1(int punkte) {
		punkte1= punkte1-punkte;
	}
	public int getPunkte1() {
		return punkte1;
	}
	public void setPunkte2(int punkte) {
		punkte2=punkte2+punkte;
	}
	public void machwenigerPunkte2(int punkte) {
		punkte2=punkte2-punkte;
	}
	public int getPunkte2() {
		return punkte2;
	}
	public void setMittelfeldinfo(String info) {
		mittelfeldinfo= info;
	}
	public String getMittelfeldinfo() {
		return mittelfeldinfo;
	}
	public void setNewround(String text) {
		newround= text;
	}
	public String getNewround() {
		return newround;
	}
}
```
Meine Klasse Anwendung die alles "unter eine haube" bringe sollte sieht jetzt so aus:
es zeigt jetzt nur noch ein fehler und zwar hier, das ".start", dass ich dafür noch eine methode in abstractmodus einbauen soll. 

```
modiList.get(0).start();
```


```
import java.util.ArrayList;

public class Anwendung {

	ArrayList <AbstractModus> modiList;
	 
	public Anwendung(){
	  modiList = new ArrayList<AbstractModus>(5);
	}
	 
	public void startModus(int[] spielmodi){
	  for (int tempInt : spielmodi) {
	    switch(tempInt){
	    case 1:
	    	modiList.add(new Farbnamen(/*Übergeben sämtlicher benötigter Werte*/));
	    	break;
	    case 2: 
	    	modiList.add(new Gleich());
	    	break;
	    case 3:
	    	modiList.add(new Maus());
	    	break;
	    case 4:
	    	modiList.add(new Weiss());
	    	break;
	    case 5:
	    	modiList.add(new Zeahler());
	    	break;
	    }
	  }
	  
	  modiList.get(0).start();
	}
}
```


oder kurz gesagt was muss ich noch machen dass es funktioniert? ich hab langsam völlig den faden verloren :autsch:


----------



## Gucky (30. Jun 2014)

Die Punkte sind z.B. eine Variable, die von allen verwendet wird. Die müsste dann in AbstractModus schon deklariert und als "static" gekennzeichnet werden.
Oder Anwendung bekommt die Punktzahl und gibt diese an den nächsten Spielmodi weiter.

Du bist weiter. Denn du kannst jetzt alle Spielmodi in einer List speichern.

Die Methode einbauen? Wenn keine da ist, kannst du auch keine aufrufen.

Eine letzte Sache fehlt übrigens noch, nach der Methode: ein Event, dass an Anwendung gesendet wird, damit Anwendung weiß, dass der letzte Spielmodus beendet ist und Anwendung entweder den nächsten Modus startet oder eine Meldung ausgibt, dass alles fertig ist und die Punkte anzeigt(/anzeigen lässt).
Das ist aber relativ einfach und lässt sich mit purem Abschreiben aus dem Internet hinbekommen.


----------



## 786Newbie (30. Jun 2014)

Countdown läuft noch 1std und 20 min:lol:;(
"Die Methode einbauen? Wenn keine da ist, kannst du auch keine aufrufen"
das weis ich zum glück noch 
hab nur kein plan was ich da rein schreibe soll^^

"Die Punkte sind z.B. eine Variable, die von allen verwendet wird. Die müsste dann in AbstractModus schon deklariert und als "static" gekennzeichnet werden.

hab ich ja schon gemacht 
jedes spielmodi benutzt die variablen durch getter und setter methode
aber das problem es ist funktioniert nur
1. wenn beide spiele gleihczeitig offen und visible (true) sind
2. wenn spiemodi1 öffne, darauf 5 punkte hab, und danach es visbile(false) wird
und dann spielmodi2 starte fängts wieder bei 0 an

```
public abstract class AbstractModus extends Frame {

	static int punkte1;
	static int punkte2;
```


----------



## Gucky (30. Jun 2014)

Da kommt alles, was zum Start der Spielmodi erforderlich ist.
Setter für das Frame, sonstige Setter, vielleicht Übergaben von Werten etc.


Dann machen wir das mit den Punkten anders:
Du machst ein vollständiges EventHandling (--> Google). Dies besteht aus:
Interface: 
	
	
	
	





```
SpielmodusBeendetEventListener extends EventListener
```
, welches die Methode 
	
	
	
	





```
public void spielmodusBeendet(SpielmodusBeendetEvent e)
```
 bereitstellt.

Klasse: 
	
	
	
	





```
SpielmodusBeendetEvent extends EventObject
```
, welche Variablen für die Weitergabe der Punkte und öffentliche Getter für diese Variablen bereitstellt.

Klasse: 
	
	
	
	





```
SpielmodusBeendetEventMulticaster implements SpielmodusBeendetEventListener
```
, welche eine private ArrayList<SpielmodusBeendetEventListener> und Methoden zum Hinzufügen eines Listeners (addListener(SpielmodusBeendetEventListener listener){list.add(listener);}) zur ArrayList und Metoden zum Entfernen eines Listeners (removeListener(SpielmodusBeendetEventListener listener({list.remove(listener);}) sowie eine Methode zum Verteilen der Events an alle Objekte in der ArrayList bereitstellt.

Darüber hinaus implementiert Anwendung das Interface SpielmodusBeendetEventListener.

Die Spielmodi implementieren eine Methode 
	
	
	
	





```
processEvent(SpielmodusBeendetEvent e)
```
, welches das Event an den Multicaster weitergibt.



Zuerst erzeugt Anwendung ein neues Objekt vom Typ 
	
	
	
	





```
SpielmodusBeendetEventListener
```
 und ruft die Methode addListener(this); auf, um sich selbst hinzuzufügen. Dieses Objekt wird allen Spielmodi beim Erzeugen im Konstruktor mitgegeben.

Ist also ein Modus beendet, erzeugen die jeweilig beendeten Spielmodi ein neues Objekt vom Typ SpielmodusBeendetEvent. Diesem wird im Konstruktor alles mitgegeben, was benötigt wird. Also Punktzahl und ggf. noch weitere Infos.

Dieses Event wird von der Methode 
	
	
	
	





```
processEvent(SpielmodusBeendetEvent e)
```
 an den Multicaster weitergegeben. Dieser wird verteilt das Event an alle registrierten Listener (nur Anwendung) und ruft dort die Methode 
	
	
	
	





```
spielmodusBeendet(...)
```
 auf.

Anwendung startet daraufhin den nächsten Spielmodus und gibt diesem in der start() Methode Punktzahl mit, sodass sie im Spielmodus verwendet werden kann.


----------



## 786Newbie (30. Jun 2014)

Jetzt hast du so viel geschrieben, aber muss leider sagen selbst wenn ich alles verstanden hätte würde ich das nicht in 20 minuten hinkriegen ^^
trotzdem danke für deine hilfe, ohne dich wär ich halb so weit gekomme, sobald ich zeit habe, gehe ich deine beiträge durch und druck auf Danke Button :toll:


----------



## Gucky (30. Jun 2014)

Kein Problem. Hab ich gerne gemacht . Wenn du deinem Lehrer noch das Konzept eines EventHandlings erklären kannst und das so, dass es so aussieht, als könntest du es noch implementieren, so wird er das bestimmt wohlwollend berücksichtigen


----------

