06 - Methoden (Functions)

Methoden sind wiederverwendbare Codeblöcke, die bestimmte Aufgaben ausführen. Sie helfen dir Wiederholungen von Code zu vermeiden und machen dein Programm einfacher verständlich.

Was ist eine Methode?

Stell dir eine Methode wie ein Rezept vor. Du definierst es einmal und nutzt es, wann immer du es brauchst.

public class Game {
    public static void main(String[] args) {
        greet();        // Methode aufrufen
        greet();        // Nochmal!
    }
    
    // Definition der Methode
    public static void greet() {
        System.out.println("Willkommen bei Hytale!");
    }
}

Methodenstruktur

public static void methodName() {
//  ^      ^     ^      ^     ^
//  |      |     |      |     |
// access static return name parameter
// modifier       type
    // Code hier
}

Du wirst später noch lernen, was public und static bedeuten. Verwende sie im Moment einfach nur.

Methoden mit Parametern

Parameter erlauben die Weitergabe von Daten an Methoden:

public static void greetPlayer(String name) {
    System.out.println("Hallo, " + name + "!");
}

public static void main(String[] args) {
    greetPlayer("Alice");  // Hallo, Alice!
    greetPlayer("Bob");    // Hallo, Bob!
}

Mehrere Parameter

public static void dealDamage(String target, int damage) {
    System.out.println(target + " nimmt " + damage + " Schaden!");
}

public static void main(String[] args) {
    dealDamage("Zombie", 20);    // Zombie nimmt 20 Schaden!
    dealDamage("Skelett", 15);  // Skelett nimmt 15 Schaden!
}

Die Reihenfolge der Parameter ist wichtig

Beim Aufruf einer Methode müssen die Argumente der Parameterreihenfolge entsprechen:

public static void createItem(String name, int quantity, double price) {
    // ...
}

// Richtig
createItem("Schwert", 1, 50.0);

// Falsch - Reihenfolge beachten!
createItem(1, "Schwert", 50.0);  // Fehler!

Methoden mit Rückgabewerten

Methoden können Daten zurücksenden mit return:

public static int add(int a, int b) {
    int sum = a + b;
    return sum;
}

public static void main(String[] args) {
    int result = add(5, 3);
    System.out.println(result);  // 8
}

Der Rückgabetyp muss mit dem übereinstimmen, was du zurückgibst:

void - Gibt nichts zurück
int - Gibt eine ganze Zahl zurück
double - Gibt eine Dezimalzahl zurück
boolean - Gibt true/false zurück
String - Gibt Text zurück

public static String getItemName() {
    return "Diamant Schwert";
}

public static boolean isPlayerAlive(int health) {
    return health > 0;
}

public static double calculateDamage(int attack, double multiplier) {
    return attack * multiplier;
}

Return stoppt die Ausführung

Sobald eine Methode auf return trifft, wird sie sofort beendet. Code nach return wird nicht ausgeführt!

public static int getValue() {
    return 10;
    System.out.println("This never runs!");  // Unerreichbarer Code!
}

Praktische Beispiele

Lebenssystem

public static void displayHealth(String name, int health, int maxHealth) {
    double percentage = (health * 100.0) / maxHealth;
    System.out.println(name + ": " + health + "/" + maxHealth + 
                      " (" + percentage + "%)");
}

public static void main(String[] args) {
    displayHealth("Spieler", 75, 100);
    displayHealth("Boss", 450, 500);
}

Schadensberechnung

public static int calculateDamage(int baseAttack, int weaponDamage, boolean isCritical) {
    int totalDamage = baseAttack + weaponDamage;
    
    if (isCritical) {
        totalDamage *= 2;
    }
    
    return totalDamage;
}

public static void main(String[] args) {
    int damage1 = calculateDamage(10, 15, false);  // 25
    int damage2 = calculateDamage(10, 15, true);   // 50
    
    System.out.println("Normal hit: " + damage1);
    System.out.println("Critical hit: " + damage2);
}

Benötigte EXP-Level

public static int getXPForLevel(int level) {
    return level * 100;
}

public static boolean canLevelUp(int currentXP, int currentLevel) {
    int required = getXPForLevel(currentLevel + 1);
    return currentXP >= required;
}

public static void main(String[] args) {
    int playerXP = 450;
    int playerLevel = 4;
    
    if (canLevelUp(playerXP, playerLevel)) {
        System.out.println("Du kannst hochleveln!");
    } else {
        int needed = getXPForLevel(playerLevel + 1) - playerXP;
        System.out.println("Braucht noch " + needed + " XP");
    }
}

Entfernungsberechnung

public static double calculateDistance(int x1, int y1, int x2, int y2) {
    int dx = x2 - x1;
    int dy = y2 - y1;
    return Math.sqrt(dx * dx + dy * dy);
}

public static boolean isInRange(int x1, int y1, int x2, int y2, double range) {
    double distance = calculateDistance(x1, y1, x2, y2);
    return distance <= range;
}

public static void main(String[] args) {
    // Checke ob der Gegner nah genug ist
    if (isInRange(0, 0, 5, 5, 10.0)) {
        System.out.println("Gegner ist nah genug!");
    }
}

Methodenüberladung

Du kannst mehrere Methoden mit dem selben Namen, aber unterschiedlichen Parametern haben:

public static void displayMessage(String message) {
    System.out.println(message);
}

public static void displayMessage(String message, int times) {
    for (int i = 0; i < times; i++) {
        System.out.println(message);
    }
}

public static void main(String[] args) {
    displayMessage("Hello");           // Ruft die erste Version auf
    displayMessage("Hello", 3);        // Ruft die zweite Version auf
}

Regeln der Methodenüberladung

Methoden werden als anders angesehen, wenn sie eines des Folgenden haben:

Unterschiedliche Anzahl von Parametern
Verschiedene Arten von Parametern
Unterschiedliche Reihenfolge der Parameter

public static void test(int a) { }
public static void test(int a, int b) { }        // Anzahl anders
public static void test(double a) { }            // Typ anders
public static void test(String a, int b) { }     // Typen anders
public static void test(int a, String b) { }     // Reihenfolge anders

// Falsch - Nur der return type ist anders
public static int test(int a) { }

Häufige Schema beim Hytale Modding

Itemerstellung

public static Item createItem(String name, int durability) {
    Item item = new Item();
    item.setName(name);
    item.setDurability(durability);
    return item;
}

public static Item createSword() {
    return createItem("Schwert", 100);
}

public static Item createPickaxe() {
    return createItem("Spitzhacke", 150);
}

Überprüfen der Blockplatzierung

public static boolean canPlaceBlock(int x, int y, int z) {
    // Überprüfe ob die Position valide ist
    if (y < 0 || y > 255) {
        return false;
    }
    
    // Überprüfe ob der Block bereits existiert
    if (isBlockAt(x, y, z)) {
        return false;
    }
    
    return true;
}

public static void placeBlock(int x, int y, int z, String type) {
    if (canPlaceBlock(x, y, z)) {
        // Block platzieren
        System.out.println(type + "platziert bei (" + x + ", " + y + ", " + z + ")");
    } else {
        System.out.println("Du kannst hier keinen Block platzieren!");
    }
}

Überprüfung des Spielerzustands

public static boolean isLowHealth(int health, int maxHealth) {
    return (health * 100.0 / maxHealth) < 25;
}

public static String getHealthStatus(int health, int maxHealth) {
    double percentage = (health * 100.0) / maxHealth;
    
    if (percentage >= 75) {
        return "Gesund";
    } else if (percentage >= 50) {
        return "Verletzt";
    } else if (percentage >= 25) {
        return "Kritisch";
    } else {
        return "Fast tot";
    }
}

Bewährte Verfahren

Methodenbezeichnung

Beschreibende verb-basierte Namen, die erklären, was die Methode tut:

// Gut
public static void calculateDamage() { }
public static boolean isPlayerAlive() { }
public static String getItemName() { }
public static void displayInventory() { }

// Schlecht
public static void dmg() { }        // Zu kurz
public static void method1() { }    // Nicht beschreibend
public static void stuff() { }      // Zu vage

Übungsaufgaben

Temperaturwandler: Schreibe Methoden zum Umwandeln:
- Celsius in Fahrenheit: (C × 9/5) + 32
- Fahrenheit in Celsius: (F - 32) × 5/9
Kreisrechner: Erstelle Methoden zum Berechnen von:
- Fläche: π × radius²
- Umfang: 2 × π × radius
- Nutze Math.PI für π
Item Haltbarkeit: Schreibe diese Methoden:
- damageItem(int current, int damage) - gibt neue Haltbarkeit zurück
- isBroken(int durability) - gibt true zurück, wenn die Haltbarkeit kleiner oder gleich 0 ist
- repairItem(int current, int max) - gibt die maximale Haltbarkeit zurück
Passwort-Validierung: Erstelle eine Methode, die überprüft, ob ein Passwort gültig ist:
- Mindestens 8 Zeichen lang
- Enthält mindestens eine Zahl
- Gibt true zurück wenn gültig, ansonsten false

Häufige Fehler

// Falsch - Return Statement vergessen
public static int getValue() {
    int x = 10;
    // return vergessen!
}

// Richtig
public static int getValue() {
    int x = 10;
    return x;
}

// Falsch - Falscher Rückgabetyp
public static int getText() {
    return "Hallo";  // Fehler! Sollte int zurückgeben, nicht String
}

// Richtig
public static String getText() {
    return "Hallo";
}

// Falsch - Methode wird nicht aufgerufen
public static void main(String[] args) {
    greet;  // Fehler! Fehlende ()
}

// Richtig
public static void main(String[] args) {
    greet();
}

06 - Methoden (Functions)

On this page