Methoden Methoden und Werte

[DrahtEck]

Moin Moin, schon wieder ein Problem: zuerst ein Beispiel:

public class beispielMethoden {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
    
     
        int gegnerLeben= 100;      // 100%
    
      gegnerleben =  hit(gegnerLeben);

    }
 
    public static int hit(int aktuellesGegnerLeben ) {
    
        int neuGegnerLeben ;    // nach dem Treffer
    
        neuGegnerLeben =  aktuellesGegnerLeben -20 ;

       return neuGegnerLeben;

Meine Frage bezieht sich auf int gegnerLeben= 100; und public static int hit(int aktuellesGegnerLeben ) .

Woher weiss ich denn, dass int gegnerLeben = 100; an (int aktuellesGegnerLeben ) übergeben wird?? das sind doch zwei ganz unterschiedliche Namen, müsste (int aktuellesGegnerLeben) nicht (int gegnerLeben) heißen? das verwirrt leider total!

Ich habe doch gelernet:
Datentype: Int
Name der Variablen: darf es nur einmal geben, ausserdem kann man dem Code nicht so einfach folgen oder verstehen zu mindest nicht am Anfang .

Und die Zweite Frage: return neuGegnerLeben; wird übergeben wo ?? etwa an hit(gegnerLeben); und wird dann in gegnerleben = initialiesiert ?

Warum sind die Namen der Variablen immer anders ?? Wie kann ich dann dem Code folgen? 🤬
In diesem Code z.B. ist alles Glas Klar, verständlich und leicht nachzuvollziehen :

public class returnMethode {

    public static void main(String[] args) {
     
        int summe  = taschenrechner(5, 5, '+');
         System.out.println(summe);
     
     
    }
 
    public static int taschenrechner(int Zahl1, int Zahl2, char operator) {
     
     
        int summe; // hier wird das ergebnis gespeichert, nach der ausführung der public static int taschenrechner
        // werden  werte aller  Variablen  gelöscht wie in int  summe; Die methode wurde ausgeführt.
        // deswegen geben wir in public static void main vor dem Aufruf der Methode     "int summe" = ein taschenrechner(5, 5, '+');
        //sieh oben dort wird der RückgabeWert gespeichert
        if (operator == '+') {
            summe = Zahl1 + Zahl2;
         
         
        }
        else {
         
             summe = Zahl1 - Zahl2;
         
        }
     
     
        return summe;
     
    }

}

 

[mihe7]

Woher weiss ich denn, dass int gegnerLeben = 100; an (int aktuellesGegnerLeben ) übergeben wird?? das sind doch zwei ganz unterschiedliche Namen, müsste (int aktuellesGegnerLeben) nicht (int gegnerLeben) heißen? das verwirrt leider total!

Du hast einmal eine Methode hit. Diese Methode verfügt über einen Parameter und dieser Parameter trägt den Namen aktuellesGegnerLeben. Über diesen Namen kann innerhalb der Methode auf das zugegriffen werden, was der Methode beim Aufruf übergeben wurde. Rufst Du also hit(5) auf, wird die 5 an die Methode übergeben und in der Methode kannst Du dann auf die 5 über den Namen aktuellesGegnerLeben zugreifen.

Wie Dir vielleicht aufgefallen ist, habe ich bislang gegnerLeben nicht erwähnt. Das liegt daran, dass es völlig unerheblich ist, was Du an die Methode übergibst. Der Wert für das Argument beim Methodenaufruf kann eine fixe Zahl sein, aus einer Variablen gelesen werden oder auch der Rückgabewert einer anderen Methode sein.

Beispiel:

hit(5); // Argument ist hier die 5
hit(gegnerLeben); // Argument ist hier der Wert der Variable gegnerLeben
hit(berechnetesLeben()); // Argument ist hier das Ergebnis (Rückgabewert) der Methode berechnetesLeben.

Innerhalb von hit steht das Argument dann unter dem "Namen" aktuellesGegnerLeben zur Verfügung.

 

[DrahtEck]

Du hast einmal eine Methode hit. Diese Methode verfügt über einen Parameter und dieser Parameter trägt den Namen aktuellesGegnerLeben. Über diesen Namen kann innerhalb der Methode auf das zugegriffen werden, was der Methode beim Aufruf übergeben wurde. Rufst Du also hit(5) auf, wird die 5 an die Methode übergeben und in der Methode kannst Du dann auf die 5 über den Namen aktuellesGegnerLeben zugreifen.

Wie Dir vielleicht aufgefallen ist, habe ich bislang gegnerLeben nicht erwähnt. Das liegt daran, dass es völlig unerheblich ist, was Du an die Methode übergibst. Der Wert für das Argument beim Methodenaufruf kann eine fixe Zahl sein, aus einer Variablen gelesen werden oder auch der Rückgabewert einer anderen Methode sein.

Beispiel:

hit(5); // Argument ist hier die 5
hit(gegnerLeben); // Argument ist hier der Wert der Variable gegnerLeben
hit(berechnetesLeben()); // Argument ist hier das Ergebnis (Rückgabewert) der Methode berechnetesLeben.

Innerhalb von hit steht das Argument dann unter dem "Namen" aktuellesGegnerLeben zur Verfügung.

Äähhhh .. jaaaa werde ich mir Morgen durch den Kopf gehen lassen heut geht nichts mehr Sorry.
Vielen dank schon mal für die Antwort und deine Mühe.

 

[mihe7]

Äähhhh .. jaaaa werde ich mir Morgen durch den Kopf gehen lassen heut geht nichts mehr Sorry.
Vielen dank schon mal für die Antwort und deine Mühe.

Ja, lass Dir Zeit. Du solltest das Prinzip aber eigentlich schon von Mathe her kennen. Dort hast Du z. B. eine Funktion f(x) := 5*x + 7. Hier heißt der Parameter der Funktion halt x und in der Rechenvorschrift wird dieses x verwendet. Damit kannst Du jetzt f(100) berechnen f(100) = 5 * 100 + 7 = 507. Ich kann aber auch hergehen und sagen: okay, sei y := 3, dann ist f(y) = 5 * y + 7 = 5 * 3 + 7 = 22. Und wenn ich will kann ich auch sagen f(f(y)) = f(f(3)) = f(22), weil f(3) = 22 ist. Und weiter f(f(y)) = f(22) = 5 * 22 + 7 = 117. Das Ergebnis kann ich auch einer neuen Variablen zuweisen: Sei z := f(f(y)) mit y := 3, dann ist z = 117.

Im Code funktioniert das ziemlich ähnlich:

class Test {
    // erstmal die Funktion f definieren:
    public static int f(int x) {
         return 5 * x + 7;
    }

    public static void main(String[] args) {
        System.out.println(f(100)); // gibt 507 aus
        System.out.println(f(3)); // gibt 22 aus
        System.out.println(f(f(3))); // gibt 117 aus

        int y = 3;
        System.out.println(f(f(y))); // gibt auch 117 aus, weil y == 3

        int z; // Variable z deklarieren
        z = f(f(y)); // f(f(y)) liefert 117 und dieser Wert wird der Variablen z zugewiesen
        System.out.println(z); // gibt den Wert von z, also 117, aus
    }
}

 

[KonradN]

Bezüglich der Variablennamen und so ist immer wichtig zu verstehen: Die Variablen haben einen Gültigkeitsbereich. Und nur innerhalb des Gültigkeitsbereichs solltest Du den Namen betrachten.

public static void main(String[] args) {
    int summe  = taschenrechner(5, 5, '+');
    System.out.println(summe);
}

Hier hast Du eine lokale Variable summe. Der Gültigkeitsbereich ist nur innerhalb dieser Methode. Von der Deklaration an bis zum Ende des Blocks (was hier auch das Ende der Methode ist.

public static int taschenrechner(int Zahl1, int Zahl2, char operator) {
    int summe;

    if (operator == '+') {
        summe = Zahl1 + Zahl2;
    } else {
        summe = Zahl1 - Zahl2;
    }
    
    return summe;
}

Hier haben wir jetzt gleich mehrere Dinge:
a) wir haben Parameter: Zahl1, Zahl2 und operator sind Parameter. Dies sind Elemente, die von außen angegeben werden müssen, wenn die Methode aufgerufen wird und diese sind nur innerhalb der Methode gültig.
b) wir haben wieder eine lokale Variable summe.

Es ist also wichtig, dass man immer den Gültigkeitsbereich betrachtet. Und so lange sich die Gültigkeitsbereiche nicht überlappen, ist es kein Problem, einen Variablennamen mehrfach zu verwenden.

Den Spezialfall, dass ein Gültigkeitsbereich in einen anderen fällt, lassen wir jetzt aussen vor. Da gibt es dann weitere Regeln und es kommt zu speziellem Verhalten.

Und an der Stelle dann auch noch der Hinweis: Benenne Variablen so, dass klar wird, was sie enthalten.
summe = Zahl1 - Zahl2;
Die Subtraktion liefert natürlich keine Summe sondern die Differenz. Also überlege, was in eine Variable geschrieben wird. In der Methode taschenrechner ist in der Variable summe das Ergebnis. Also wäre da ein Name wie ergebnis doch vermutlich sinnvoller.

Etwas in der Art gilt auch für Methoden. Taschenrechner ist ein Nomen. Methoden sollten ein Verb enthalten, den sie machen etwas. Hier wird etwas berechnet, also wäre ein Name wie berechne besser. Dann wird auch der Aufruf deutlicher: berechne(5, 5, '+') zeigt doch eher, was die Methode macht.

Das aber nur als Hinweis am Rande. Mir war nur die Erläuterung der Gültigkeitsbereiche wichtig.

 

[LimDul]

Moin Moin, schon wieder ein Problem: zuerst ein Beispiel:

Woher weiss ich denn, dass int gegnerLeben = 100; an (int aktuellesGegnerLeben ) übergeben wird?? das sind doch zwei ganz unterschiedliche Namen, müsste (int aktuellesGegnerLeben) nicht (int gegnerLeben) heißen? das verwirrt leider total!

Ich versuche es mal mit einen plastischen Beispiel. Die Methode hit ist wie ein Formular.

Du hast einen Zettel (Variable) die die Überschrift (Namen) gegnerLeben hat. Auf dem Zettel steht 100 (Der aktuelle Wert). Damit gehst zum Schalter (Methode) und willst "hit" beantragen (ausführen). Du bekommst ein Formular auf dem steht ein Feld (Parameter) aktuellesGegnerLeben. Du (der Programmier) entscheidet das er dort den Wert von gegnerLeben reinschreiben (übergeben) will. Das Feld wird also mit dem Wert 100 gefüllt und du reichst das Formular über den Schalter. Der Schalterbeamte (aka die Methode) weiß nun, dass der Wert von aktuellesGegnerLeben 100 ist.

Der Schalterbeamte bearbeitet das Formular (führt die Methode aus) und reicht dir am Ende einen Zettel (Rückgabe) auf dem der neue Wert steht. Du nimmst den Wert und schreibst diesen Wert auf deinen Zettel mit der Überschrift gegnerLeben.

 

[DrahtEck]

Moin, hab mir eure Beiträge noch mal in Ruhe angeschaut und

es ist endlich in der Kommandozentrale angekommen. 👍

Das Ergebins;

public class beispielMethoden {
        
    public static int Hit(int lebenAktuell) {
        
        int neugegnerleben ;
        
        neugegnerleben  =  lebenAktuell -20;
        
        return neugegnerleben;
                
    }

    public static void main(String[] args) {
                        
        int gegnerLeben = 100;
        System.out.println(gegnerLeben);          //Ausgabe 100
        
         gegnerLeben = Hit(gegnerLeben);         
        System.out.println(gegnerLeben);        //Ausgabe 80
        
        
        gegnerLeben = Hit(gegnerLeben);
        System.out.println(gegnerLeben);        //Ausgabe 60
                
    }
    
    }

Die Methode zu erst zu definieren war eine gute Idee! Passt zum Mathe Vergleich, kann ich jetzt auch einfacher nachvollziehen.

Danke an alle!

 

[Marinek]

Nur zur Info: Klassennamen schreibt man immer mit einem Großbuchstaben und dann CamelCase.

Methoden fangen immer klein an.

 

[Blender3D]

Moin, hab mir eure Beiträge noch mal in Ruhe angeschaut und

es ist endlich in der Kommandozentrale angekommen. 👍

Das Ergebins;

Hier noch ein kleine Anmerkung zu obigen Beiträgen bezüglich deiner Hit Methode.
Sobald du den Hinweis von @KonradN auf den Gültigkeitsbereich von Variablen verstanden hast, kannst du deine Hit Methode sehr viel kürzer formulieren.

 public static int Hit(int lebenAktuell) {
     return lebenAktuell -20;
 }

Da die Gültigkeit der Variable lebenAktuell sich auf die Methode selbst begrenzt ist die lokal eingeführte Variable neuGegnerLeben unnötig.

Wie @Marinek oben korrekt erwähnt, sollten Methodenname immer mit einem Kleinbuchstaben beginnen und dann die CamelCase Bedingung erfüllen https://en.wikipedia.org/wiki/Camel_case !
Des Weiteren sollte der Name das widerspiegeln was die Methode macht.
Du nennst deine Methode Hit. Übersetzt also Schlag oder Treffer. Der Parameter der Methode heißt dann lebenAktuell.
Also für mich erweckt das den Anschein, dass die Methode eigentlich keinen Treffer ausführt oder auf einen Treffer testet, sondern die übergebenen Lebenspunkte um einen konstanten Wert reduziert. So gesehen passt der gewählte Name nicht wirklich. Auch das Mischen der Sprachen hit (Englisch) (lebenAktuell) finde ich nicht gut.

Deine Hit Methode könnte z.B. man so realisieren.

public static int reduceLivePoints( int points){
    return points - 20; 
}

Eine Methode hit würde z.B. prüfen ob ein Spieler von einem Geschoss oder einem Gegner getroffen wird. Falls ja würde man dann die Methode reduceLivePoints aufrufen.

..
if( hit(..)  ){
    livePoints = reduceLivePoints(livePoints);
    if( livePoints <= 0 )
        gameOver();
    ..

 

[DrahtEck]

Nur zur Info: Klassennamen schreibt man immer mit einem Großbuchstaben und dann CamelCase.

Methoden fangen immer klein an.

Ok !

Da die Gültigkeit der Variable lebenAktuell sich auf die Methode selbst begrenzt ist die lokal eingeführte Variable neuGegnerLeben unnötig.


Du nennst deine Methode Hit. Übersetzt also Schlag oder Treffer. Der Parameter der Methode heißt dann lebenAktuell.
Also für mich erweckt das den Anschein, dass die Methode eigentlich keinen Treffer ausführt oder auf einen Treffer testet, sondern die übergebenen Lebenspunkte um einen konstanten Wert reduziert. So gesehen passt der gewählte Name nicht wirklich. Auch das Mischen der Sprachen hit (Englisch) (lebenAktuell) finde ich nicht gut.

Deine Hit Methode könnte z.B. man so realisieren.

public static int reduceLivePoints( int points){
    return points - 20;
}

Eine Methode hit würde z.B. prüfen ob ein Spieler von einem Geschoss oder einem Gegner getroffen wird. Falls ja würde man dann die Methode reduceLivePoints aufrufen.

..
if( hit(..)  ){
    livePoints = reduceLivePoints(livePoints);
    if( livePoints <= 0 )
        gameOver();
    ..

Super Tipps danke! Das mit if- Anweisung ist eine gute Lösung aber immer ein Schritt nach dem anderen.
Dem mischen von Sprachen stimme ich zu 🤭. Und es ist auch angekommen dass Varieablennamen gut gewählt werden sollten.

Deine Hit Methode könnte z.B. man so realisieren.

public static int reduceLivePoints( int points){
    return points - 20;
}

In meinem Beispiel wollte ich Schritt für Schritt selbst nachvollziehen was die Methode macht was da mit den LokalenVariablen passiert.
Jo nachhinein logischerweise ergibt das Sinn , sehr kompakt.👍

 

[DrahtEck]

Dem mischen von Sprachen stimme ich zu 🤭. Und es ist auch angekommen dass Varieablennamen und Methoden, ClassenNamen gut gewählt werden sollten.