Methoden und Überladung

Methoden definieren das Verhalten eines Objekts. Wir können sie uns als Funktionen vorstellen, die innerhalb einer Klasse deklariert sind und auf den Instanzfeldern des Objekts oder den Eingabeparametern arbeiten.

Eine Methode definieren

Eine Methode in Java besteht aus:

1. Zugriffsmodifikator (z. B. public, private).
2. Rückgabetyp (z. B. int, String oder void, wenn nichts zurückgegeben wird).
3. Methodenname in camelCase.
4. Parameter in runden Klammern.
5. Methodenkörper in geschweiften Klammern.

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }

    // Metodo con tipo di ritorno String
    public String greet() {
        return "Ciao, mi chiamo " + name;
    }
}

Eine Methode aufrufen

Um eine Methode auf einem erstellten Objekt aufzurufen, verwenden wir die Punktsyntax .:

public class Main {
    public static void main(String[] args) {
        Person p = new Person("Marco");
        String message = p.greet(); // Chiamata del metodo
        System.out.println(message);
    }
}

Methoden überladen (Method Overloading)

In Java können zwei oder mehr Methoden innerhalb derselben Klasse denselben Namen haben, vorausgesetzt, sie haben eine unterschiedliche Parameterliste (nach Anzahl, Reihenfolge oder Typ der Parameter). Dieses Konzept ist als Überladen (Overloading) bekannt.

Der Compiler entscheidet anhand der beim Aufruf übergebenen Argumente, welche Methode aufgerufen werden soll.

class Printer {
    // Metodo per stampare un intero
    public void printValue(int number) {
        System.out.println("Intero: " + number);
    }

    // Metodo sovraccaricato per stampare una stringa
    public void printValue(String text) {
        System.out.println("Testo: " + text);
    }
}

Parameterübergabe per Wert (Pass-by-Value)

In Java werden alle Parameter per Wert übergeben (pass-by-value). Das bedeutet, dass Java beim Übergeben eines Arguments an eine Methode eine Kopie des Werts der Variable erstellt und diese an die Methode übergibt.

• Bei primitiven Typen ändert sich der ursprüngliche Wert außerhalb der Methode nie, selbst wenn er innerhalb der Methode geändert wird.
• Bei Objekten/Referenzen wird die Referenz auf das Objekt kopiert. Das bedeutet, dass wir zwar die Adresse, auf die das ursprüngliche Objekt zeigt, nicht ändern können, aber seinen internen Zustand (z. B. die Felder) ändern können und die Änderungen außerhalb sichtbar sind.

Einschränkungen des Überladens: Der Rückgabetyp

Es ist wichtig zu betonen, dass es nicht möglich ist, eine Methode nur basierend auf dem Rückgabetyp zu überladen. Der folgende Code führt beispielsweise zu einem Kompilierungsfehler:

class Example {
    // ERRORE: La firma dei due metodi è considerata identica
    public int getNumber() { return 42; }
    public double getNumber() { return 42.0; }
}

Der Compiler muss Methoden allein anhand der Parameter unterscheiden können, um zur Compilezeit zu entscheiden, welche Version aufgerufen werden soll (das Überladen wird vollständig zur Compilezeit aufgelöst).

Probier es selbst