OOP Variablen zwischen mehreren Klassen

Sora07

Mitglied
Hallo zusammen,
Ich hab vor einer Woche angefangen Java zu lernen. Um mein können zu testen hab ich mir ein kleines Textadventure geschaffen welches auch so läuft wie gewollt. Nun wollte ich es jedoch mit OOP probieren und bin ziemlich schnell auf ein kleines Problem gestoßen, und zwar:

Habe ich eine Spieler Klasse mit verschiedenen Werten wie zB Lebenspunkte
Eine Klasse in der ich den "Kampf" ablaufen lasse, also werden Lebenspunkte abgezogen.
Ich weiß zwar wie ich die Lebenspunkte ( Anfangswert von 100 in der Spieler Klasse ) in meine Kampf Klasse hole und verändere, jedoch würde ich gerne wissen ob es möglich ist den neuen Lebenspunkte werden in meine Spieler Klasse zu übertragen, da sonst jeder neue Kampf wieder die 100 Punkte aus der Spielerklasse nimmt und somit ihn sozusagen resettet.

Die Test1 Klasse sind die Start Lebenspunkte
Code:
public class Test1 {
    int hp=100;  
    public Test1() {
    }   
    public int getHp() {
        return hp;
    }
    public void setHp(int hp) {
        this.hp = hp;
    }      
}

Die Test2 Klasse ist ein eine Beispiel Veränderung der Lebenspunkte

Code:
public class test2 {
   
    Test1 test = new Test1();
    int hp= test.getHp();
    public void Kampf()
    {       
        hp = hp-10;
        System.out.println(hp + " Diese Wert soll in der neue übernahme Wert sein anstatt 100");
    }
}

Test ist die Main welche am ende die veränderten Lebenspunkte erhalten soll

Code:
public class test {
    public static void main(String[] args) {       
        Test1 test = new Test1();
        int hp= test.getHp();       
    System.out.println(hp +" Hp von test 1 übernommen");      
        test2 t = new test2();
        t.Kampf();      
        System.out.println(hp +" Jetzt soll hp anstatt 100 meine veränderten 90 werden");   
    }
}
 
Du kannst einfach beim Kampf player.setHealth(player.getHealth() - enemy.getDamage()); machen, also den Setter von Health benutzen. (enemy damage ist jetzt nur ein Beispiel..)

Und du erstellst immer neue Objekte vom Spieler (test1), du solltest aber den Spieler per Parameter weiterreichen, damit du zum Schluss, beim Ausgeben, dasselbe Objekt, wie zu anfangs hast.
 
public void Kampf()
Z.B, wenn du hier in die Klammern (Klassenname Variablenname,...) eintragen würdest. Also konkret
Java:
public void fight(Player ply){
//code
}
bzw. bei dir fight(Test1 t)

Java:
public class test2 {

    public void Kampf(Test1 t){     
       t.setHp(t.getHp()-10);
    }
}
 
Ok aber wenn ich das so mache, sagt er mir das ich in der Main verändern soll
aus t.Kampf();
soll t.Kampf(test);
gemacht werden.
Warum ? und was genau bewirkt das ?
 
Java:
public class Player
{
      /**
       *  Das Leben das der Spieler aktuell hat 
        */
       private int leben;

       //Der Maximalwert für das Leben
       private static final int LEBEN_MAX = 100;      

       Player()
       {  
             leben = LEBEN_MAX;   // Das Leben ist beim erstellen des Spielers Maximal
        }
        
        /**
          * Diese Methode zieht dem Spieler so viele Leben ab wie übergeben werden 
          * @param leben Das Leben, das abgezogen werden soll.
         */
        public void verliereLeben(int leben)
        {
                this.leben = this.leben-leben;
        }

        /**
           * Diese Methode Resetet das Leben auf den Maximalwert
           */
        public void resetLeben()
        {
               leben = LEBEN_MAX;
        }
}

würde es so versuchen.

Dann müsstest du nicht das ganze Object übergeben sondern nur dass Leben das dem Spieler abgezogen wird.
 
Ok
Ich habe ein bisschen rumprobiert aber irgendwie stelle ich mich ein bisschen an 😀

Hier ist dein Player den hab ich einfach mal als test kopiert und ein getter hinzugefügt um in der Kampf Klasse die aktuellen leben zu haben
Code:
public class Player
{
      /**
       *  Das Leben das der Spieler aktuell hat 
        */
       private int leben;

       //Der Maximalwert für das Leben
       private static final int LEBEN_MAX = 100;      

       Player()
       {  
             leben = LEBEN_MAX;   // Das Leben ist beim erstellen des Spielers Maximal
        }
       
        /**
          * Diese Methode zieht dem Spieler so viele Leben ab wie übergeben werden 
          * @param leben Das Leben, das abgezogen werden soll.
         */
        public void verliereLeben(int leben)
        {
                this.leben = this.leben-leben;
        }

        /**
           * Diese Methode Resetet das Leben auf den Maximalwert
           */
        public void resetLeben()
        {
               leben = LEBEN_MAX;
        }

        public int getLeben() {
            return leben;
        }

       
}

Dann ist hier der Kampf
Code:
public class test2 {
   
    Player ply = new Player();
   
    public void Kampf()
    {
        int leben=ply.getLeben();
        System.out.println(leben);
        leben = leben-90;
        ply.verliereLeben(leben);
        
    }
       
}

Und hier die Main
Code:
public class test {
    public static void main(String[] args) {
       
       
        Player ply = new Player();
       
       
    System.out.println( ply.getLeben()+ " Hp von test 1 übernommen");   
   
        test2 t = new test2();
        t.Kampf();
        System.out.println(ply.getLeben() +" Hier soll keine 100 mehr stehen!");
   
    }

}

Mein letzter System.out.prin sollte mir die aktualisierten Leben anzeigen oder ? Jedenfalls stehen da wieder die 100
Vielen Dank für die antworten bisher !
 
Java:
Player ply = new Player();

in der Kampf-Klasse ist natürlich nicht so sinvoll, da bei jedem Kampf ein neuer Spieler erstellt wird, der wieder 100HP besitzt (was ja das Problem ist, wenn ich es richtig verstanden habe).
Stattdessen musst du den Player als Parameter in fight übergeben (so wie es Cromewell beschrieben hat, es aber von dir noch nicht umgesetzt wurde) oder vergleichbares.
 
Ok es klappt jetzt! Danke !😀
Aber irgendwie verstehe ich nicht den Parameter teil nicht 🙁
Was genau macht der Parameter und warum funktioniert es nicht ohne ?
 
Wenn du einen Parameter übergibst, dann kann die Methode, bzw. der Konstrukter mit dem Objekt arbeiten, auch wenn das Objekt nicht in der Klasse definiert ist, in der die Methode/Konstr. programmiert wurde.

Du kannst dann änderungen an dem übergebenem Objekt vornehmen, die dann Gespeichert werden.
 

Neue Themen


Zurück
Oben