Innerhalb von Schleife Variablen eines Objectes auslesen.

Kai008

Erfahrenes Mitglied
Hi.
Ich habe jetzt eine Classe (Soldat), die sollen einfach rumlaufen, und wenn sie "mich" endecken mir nachrennen. Vorerst mal kein Problem. Ich speichere die Positionen ect, halt alle Variablen in ein 2D-Array. Zumindest solange ich mit den Listenvariablen noch nicht so vertraut bin.

Ich lese die Variable vorerst eh noch nicht aus sondern benutze einfach new Soldat().init();
In der init() definiere ich Variablen:
Code:
this.typ = Integer.parseInt(gegner[i][0]);
this.energie = Integer.parseInt(gegner[i][1]);
this.posx = Integer.parseInt(gegner[i][2]);
this.posy = Integer.parseInt(gegner[i][3]);
Jetzt würde ich aber gerne in der paint(), also meiner Zeichenfunktion in einer Schleife alle erzeugten Instanzen der Soldat der Reihe nach durchgehen und deren X/Y-Positionen auslesen. Kann mir wer bitte sagen wie man das macht, oder wenigstens einen Tipp geben? Mir fällt nämlich irgendwie überhaupt nichts ein, die einzige Möglichkeit wäre für die Instanzen in der Aufrufschleife zu per Variable zu defininieren, aber soweit ich weiß kann man Variablennamen nicht aus Variablen zusammenzimmern, was imho auch quatsch wäre.


€: OK, habe es nach langem rumprobieren geschafft.
Ich habe ein Array defininiert:

Code:
Soldat gegner[] = new Soldat[10];

und darin gespeichert:

Code:
for(i = 0; i < gegnerinfo.length; i++)
{
	if(gegnerinfo[i][0] != null)
	{
		gegner[i] = new Soldat(gegnerinfo[0][0], gegnerinfo[0][1], gegnerinfo[0][2],gegnerinfo[0][3]);
		gegner[i].start();
	}
}

Damit kann ich jetzt bequem eine Schleife starten und durchgehen.
 
Zuletzt bearbeitet:

stso

Mitglied
Hallo Kai008,
gegen dein Array ist nichts einzuwenden. Mit den Java- Arrays bist du aber etwas unflexibel, da du zum Beispiel auch immer vorher wissen musst wie groß dein Array werden soll.
Schau dir mal die Collection- Klassen aus der Standard- Java- Library an. Die verwendet man so:

Java:
// Soldaten anlegen (kannst du auch in ner Schleife machen)
Soldat james = new Soldat();
Soldat ryan = new Soldat();

// Liste für Soldaten erzeugen
List<Soldat> soldaten = new ArrayList<Soldat>();
soldaten.add(james);
soldaten.add(ryan);

// Alle Soldaten in einer "foreach"- Schleife durchlaufen.
for(Soldat soldat: soldaten)
{
	soldat.paint();
}

Der Vorteil ist das du beliebig viele Soldaten zur Liste hinzufügen und auch wieder entfernen kannst. Listen kannst du auch relativ einfach durchsuchen und sortieren.

Informatonen zu den Collection- Klassen hannst du entweder aus dem "Handbuch der Java-Programmierung":
http://www.javabuch.de/
bekommen oder du liest dir das Kapitel zu Listen im Buch "Java ist auch eine Insel durch":
http://www.galileocomputing.de/open...12_003.htm#mj6937070cdee281590b69b83c3dce149d
 

Kai008

Erfahrenes Mitglied
Danke.
Mein Problem war bis jetzt immer, dass ich wenn ich etwas mache ich es immer gleich mache, auch wenn ein anderer Weg einfacher wäre, weil ich einfach nicht dran denke.
 

crashfinger

Grünschnabel
Eine weitere Möglichkeit wäre eine HashMap.
Diese hat gegenüber der ArrayList den Vorteil, dass man gezielt auf Objekte der Liste wieder zugreifen kann, ohne die gesamte Liste durchlaufen zu müssen.
Dies ist möglich, da für jedes Objekt in der Liste ein Schlüssel definiert werden muss.

Die Klasse Soldat
Code:
public class Soldat {
	private int type;
	private int energy;
	private int posX;
	private int posY;
	
	public Soldat(){}
	
	public Soldat(int type, int energy, int posX, int posY) {
		this.type   = type;
		this.energy = energy;
		this.posX   = posX;
		this.posY   = posY;
	}

	public int getType()  {return type;}
	public int getEnergy(){return energy;}
	public int getPosX()  {return posX;}
	public int getPosY()  {return posY;}
	
	public void setType  (int type)  {this.type = type;}
	public void setEnergy(int energy){this.energy = energy;}
	public void setPosX  (int posX)  {this.posX = posX;}
	public void setPosY  (int posY)  {this.posY = posY;}
	
	//toString-Methode für Debugausgaben überschieben
	public String toString() { 
		return	type	+"\t"+
			energy	+"\t"+
			posX	+"\t"+
			posY;
	}	
}

Klasse zum Füllen und Auslesen einer ArrayList
Code:
import java.util.*;

public class Beispiel1 {

	List soldatenList = new ArrayList();
	
	public Beispiel1(int[][] gegnerinfo) {
		for(int i = 0; i < gegnerinfo.length; i++){
			soldatenList.add(new Soldat(
					gegnerinfo[i][0], 
					gegnerinfo[i][1], 
					gegnerinfo[i][2],
					gegnerinfo[i][3]));
		}
	}
	
	public Soldat getSoldat(int index){
		return (Soldat)soldatenList.get(index);
	}

	public String toString(){
		StringBuffer sb = new StringBuffer();
		for(int i=0; i<soldatenList.size(); i++){
			sb.append((Soldat)soldatenList.get(i) +"\n");
		}
		return sb.toString();
	}
}


Klasse zum Füllen und Auslesen einer HashMap
Code:
import java.util.*;

public class Beispiel2 {
	
	private Map soldatenMap = new HashMap();
	
	/*
	 ich gehe für dieses beispiel davon aus dass
	 in gegnerinfo[i][0] eine eindeutige id für
	 jeden soldaten steht
	 */ 
	public Beispiel2(int[][] gegnerinfo) {
		for(int i = 0; i < gegnerinfo.length; i++){
			soldatenMap.put((Integer)gegnerinfo[i][0], new Soldat(
					gegnerinfo[i][1], 
					gegnerinfo[i][2], 
					gegnerinfo[i][3],
					gegnerinfo[i][4]));
		}
	}
	
	public Soldat getSoldat(int id){
		return (Soldat)soldatenMap.get((Integer)id);
	}
	
	public String toString(){
		StringBuffer sb = new StringBuffer();
		for(Iterator it = soldatenMap.entrySet().iterator(); it.hasNext();){
			sb.append((Soldat)it.next() +"\n");
		}
		return sb.toString();
	}
}

Der entscheidende Unterschied zwischen den beiden Beispiel-Klassen liegt in folgendem:

Die Metode getSoldat(3) liefert im Beispiel1 das dritte Soldat-Object der ArrayList. Dieser muß nicht zwangsläufig der Dritte gewesen sein den man der Liste hinzugefügt hat (wenn z.B. der Erste zwischen durch entfernt wurde).

Im Beispiel2 liefert die Metode getSoldat(3) immer den Soldat mit der Id '3'. Dies trifft nur dann nicht zu wenn der Soldat zuvor aus der Map entfernt wurde oder alle Einträge der Map gelöscht wurden.

Die ArrayList bietet sich immer dann an wenn man immer mit allen Objekten einer Liste arbeiten will, aber nie mit bestimmten einzelnen. Wenn spezifische Objekte einer Liste verarbeitet werden sollen ist die HashMap deutlich komfortabler.