[Java]Einzelne Instanzen koordiniert aufrufen ?

[Defenz0r]

Hallo, gibt es eine Möglichkeit, Instanzen eines Konstruktors zu Kennzeichnen, und diese mit dem entsprechenden Schlüssel wieder aufzurufen?
Habe die Aufgabe alle Instanzen generisch in eine Funktion einzupacken, wenn z.B die Eingabe Ataccke 1 war, soll getMove() diese Atacke die mit der 1 gekennzeichnet wurde ausgegeben werden und gesettet werden sollen.
Das die ausgewählte Atacke die Momentane Stärke/100 * die ausgewählte Stärke => Totale Angriffsstärke ist


Gruß

 

[fadade]

......... könntest du vielleicht deine Frage noch etwas umformulieren? Ich verstehe die Frage irgendwie wohl nicht ganz ^^

Klar kannst du in einer Klasse eine statische Liste über die erzeugten Instanzen führen und diese mit einem Getter per Schlüsselwert abrufen, z.B.:

//PSEUDO-CODE!

class xyz{
     static List<xyz> lst = new List<xyz>(); //liste mit erzeugten Instanzen

     public static xyz GetInstance(TYP schluessel) {
     return lst[schluessel]; //oder wie auch immer. Und dann in einer anderen/übergeordneten Methode kannst du von dem hier gelieferten Objekt Daten abrufen
     } 

     //Konstruktor
     public xyz() {
     lst.add(this); //ggf. keine Liste sondern Dictionary/Baum/whatever mit Schlüsseln. Bei der Liste wären die Schlüssel z.B. Indexwerte
     ...
     }

}

Ist aber nicht unbedingt sinnvoll mit Schlüsseln zu arbeiten, statt einfach mit den direkten Referenzen auf die Objekte. Ging mir neulich bei einem geometrischen Problem ganz ähnlich ... Dreiecke haben 3 Eckpunkte und in meinem ersten Ansatz habe ich dort einfach Zahlen verwendet um die Eckpunkte in einer Menge eindeutig identifizieren zu können; statt einfach 3 Referenzen direkt auf die Objekte der Eckpunkte in der Klasse Dreieck zu halten

 

[Defenz0r]

Entschuldigung für die undeutliche Fragestellung, mein Momentanes Problem:
Problem letzte Zeilen etwas weiter unten

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

 public class Moves {
  Moveconstructor         Hieb                   = new Moveconstructor(50, "Hieb");
  Moveconstructor         Kick                   = new Moveconstructor(40, "Kick");
  Moveconstructor         Kratzer                = new Moveconstructor(20, "Kratzer");
  Moveconstructor         Paralyse               = new Moveconstructor(0,  "Paralyse");
  // Anfang Methoden
  
  
  public void SetMap(){
    Map<Integer,Moveconstructor> map=new HashMap<Integer,Moveconstructor>();
    Set<Map.Entry<Integer,Moveconstructor>> s = map.entrySet();
    
    map.put(new Integer(1), Hieb);
    map.put(new Integer(2), Kick);
    map.put(new Integer(3), Kratzer);
    map.put(new Integer(4), Paralyse);
    
  }
  
  
  public int getMap (int setInt){
    
    //MACH etwas, wenn man eine Instanz dieses Objekts ausführt und es mit z.B 1 füllt, soll die Stärke von Hieb zurückkommen.
    //Bei 2 die Stärke von Kick usw etc
    //Also GetMove(Zahl);
    return;
    }
    // Ende Methoden
    
  }

 

[fadade]

Achso, du möchtest nicht die einzelnen Instanzen kennzeichnen, sondern die Attackentypen mit Schlüsselwerten unterscheiden (richtig?^^).

Da wird deine Datenkonstruktion oben so in der Form nicht funktionieren, denn in deiner SetMap()-Methode erzeugst du zwar eine mehr oder weniger richtige Datenstruktur mit den Typen der Attacken, aber 1.) gibt die Methode nichts zurück und 2.) hat die Methode keinen Bezug zu externen Resourcen, sprich du holst dir im RAM einen Speicherbereich für die Methode - wirfst da ein paar Daten rein und löschst den Bereich wieder. Zusammenfassend passiert also eher gar nix

Besser wäre grob folgendes:

 public class Moves 
{   

[B]private static Moveconstructor[] moveTable;[/B] //statische Tabelle/Liste/Datenstruktur, auf die du in jeder Methode zugreifen kannst

//Folgende muss am anfang des Programms einmal aufgerufen werden um die "Lookup-Tabelle" zu initialisieren und einzurichten
 public [U]static [/U]void SetupMapTable() 
{  
        moveTable = new Moveconstructor[4]; //bisher gibts ja 4 attackentypen
        moveTable[0] = new Moveconstructor(50, "Hieb");
        moveTable[1] = new Moveconstructor(40, "Kick");
        moveTable[2] = new Moveconstructor(20, "Kratzer");
        moveTable[3] = new Moveconstructor(0, "Paralyse");
}         

public int getSchadenswertAusMap (int index){          
     return moveTable[index].getSchadenswert(); //hierzu muss allerdings in der Klasse Moveconstructor ein entsprechender Getter vorhanden sein
}       

}//class end

Voraussetzung ist eben, dass du in deiner Klasse Moveconstructor auch jeweils den Wert für den Schaden und ggf. auch Namen abrufen kannst. Alternativ könntest du auch einfach ein integer-Array erstellen und an die Position 0 setzt du 50 (wert von Hieb), an Stelle 1 setzt du 40 (wert von Kick) usw.

Wenn dir die Sache mit den statischen Elementen noch nicht so zusagt, wäre wohl erstmal nur die Variante über viele if-Abfragen, von wegen

class .... (keine statischen elemente)
{
public int getSchadenswertAusMap (int index){          
     if(index == 0) return 50; //wert für hieb
     else if (index == 1) return 40; .... usw.
     }       
}//class end

Das könnte man natürlich auch noch etwas flexibler gestalten, ist aber m.M.n. nicht die beste Variante.


Vielleicht hast du ganz oben schon gesehen, dass ich zweimal Typ hervorgehoben habe
Hat damit zu tun, dass du das Wunderbar in eine Vererbungshierarchie Verpacken könntest!
(Da ich z.T. in den Kommentaren weitergeschrieben habe, wäre es vielleicht wichtig folgenden Code-Abschnitt etwas ausführlicher zu lesen)

//Basisklasse für deine Attacken
class Attacke{
     private int schadenswert;
     private String name;
     
     //z.b. was noch hier reinpassen würde
     private int verstaerkung_gegen_pflanzen;
     private ***** zusatzwirkung_gegen_****;
     //etc.

     public int getSchaden() { return this.schadenswert; }
     protected void setShaden(int i) { this.schadenswert = i; } //setzen nicht von außen erlauben
}//class end


...


class Hieb implements Attacke { //Ableitung der Basisklasse, hier wird unterscheidung von Schadenswerten/Namen/etc. gemacht
public Hieb() {
     this.setSchaden(50);
}
}//class end

//und jetzt kannst du unabhängig vom typ der attacke immer den schadenswert per Getter holen. Natürlich müsstest du dann die jeweils gewünschte(n) Attacke(n) dann auch irgendwo zwischenspeichern. In einem Spielobjekt kannst du z.B. nun eine Liste führen:

class Spielobjekt {
List<Attacke> meineAttacken = new List<..>();

public Spielobjekt() {
    //grundllegende attacken für das objekt zur verfügung stellen
    meinAttacken.Add(new Hieb());
    meineAttacken.Add(new Kick());
    //usw.
    //die Attacken an sich setzen ihre Werte ja im Konstruktor (und können sie ggf. auch aus einer statischen Lookup-Tabelle entnehmen.
    //nun kannst du mit this.Attacken[ATTCK_NR].getSchadenswert() die Zahl 50 für Hieb bekommen :-)
    //die ATTCK_NR kannst du ggf. vorher vom spieler auswählen lassen
}
}//class end

Allerdings ist das u.U. auch nicht die beste Lösung für dein komplettes Logiksystem, da du wahrscheinlich ja nur die Schadenswerte von Attacken direkt abrufst und sie von der Energie eines Gegners einfach abziehst. Dann machen diese Klassenstrukturen auch nicht soo viel Sinn. Die würden sich eher anbieten, wenn du in der (Basis-)Klasse Attacke dann eine statische generische Methode hast, in der du zwei spielobjekte und eine attacke als Parameter angibst und dann in der Methode die Logik der jeweiligen Attacke ausgeführt wird.
Aber ich weiß gar nicht, ob dir das alles schon bekannt ist und zusagen würde, also höre ich hier erstmal auf rumzusülzen und erwarte erstmal eine Rückmeldung

 

[Defenz0r]

Hat sich soweit geklärt...

Werde Editieren wenn ich wieder Probleme bekomm