Java Methoden meistern: Erstellen, Aufrufen und Abstraktion

Was ist eine Java-Methode?

Eine Java-Methode ist eine Sammlung von Anweisungen, die zusammengefasst werden, um eine Operation auszuführen. Wenn Sie beispielsweise die Methode System.out.println() aufrufen, führt das System tatsächlich mehrere Anweisungen aus, um eine Nachricht auf der Konsole anzuzeigen.

In diesem Kapitel lernen Sie, wie Sie eigene Methoden mit oder ohne Rückgabewerte erstellen, Methoden mit oder ohne Parameter aufrufen und Methodenabstraktion im Programmdesign anwenden.

Methoden erstellen

Betrachten Sie das folgende Beispiel, um die Syntax einer Methode zu erklären:

Syntax

public static int methodName(int a, int b) {
    // method body
}

Hierbei ist:

public static – Modifier (Zugriffsmodifizierer)
int – Rückgabetyp
methodName – Name der Methode
a, b – formale Parameter
int a, int b – Parameterliste

Eine Methodendefinition besteht aus einem Methodenkopf und einem Methodenrumpf. Die Syntax lautet:

modifier returnType nameOfMethod (Parameter List) {
    // method body
}

Die obige Syntax umfasst:

modifier – Definiert den Zugriffstyp der Methode und ist optional.
returnType – Die Methode kann einen Wert zurückgeben.
nameOfMethod – Dies ist der Methodenname. Die Methodensignatur besteht aus dem Methodennamen und der Parameterliste.
Parameter List – Die Liste der Parameter: Typ, Reihenfolge und Anzahl der Parameter einer Methode. Diese sind optional, eine Methode kann null Parameter enthalten.
method body – Der Methodenrumpf definiert, was die Methode mit den Anweisungen tut.

Beispiel: Minimum zweier Zahlen berechnen

/** Gibt das Minimum zwischen zwei Zahlen zurück */
public static int minFunction(int n1, int n2) {
    int min;
    if (n1 > n2)
        min = n2;
    else
        min = n1;
    return min;
}

Methoden aufrufen

Um eine Methode zu verwenden, muss sie aufgerufen werden. Es gibt zwei Arten, wie eine Methode aufgerufen wird: Die Methode gibt einen Wert zurück oder gibt nichts zurück (kein Rückgabewert, void).

Der Prozess des Methodenaufrufs ist einfach. Wenn ein Programm eine Methode aufruft, wird die Programmsteuerung an die aufgerufene Methode übergeben. Diese gibt die Steuerung an den Aufrufer in zwei Fällen zurück:

wenn die return-Anweisung ausgeführt wird
wenn das schließende Klammerzeichen der Methode erreicht wird

Methoden, die void zurückgeben, gelten als Aufruf einer Anweisung. Beispiel:

System.out.println("Dies ist tutorialspoint.com!");

Methoden, die einen Wert zurückgeben, können wie folgt verstanden werden:

int result = sum(6, 9);

Vollständiges Beispiel: Methode definieren und aufrufen

public class ExampleMinNumber {
    public static void main(String[] args) {
        int a = 11;
        int b = 6;
        int c = minFunction(a, b);
        System.out.println("Minimum Value = " + c);
    }

    /** Gibt das Minimum von zwei Zahlen zurück */
    public static int minFunction(int n1, int n2) {
        int min;
        if (n1 > n2)
            min = n2;
        else
            min = n1;
        return min;
    }
}

Ausgabe:

Minimum value = 6

Das void-Schlüsselwort

Das Schlüsselwort void ermöglicht es uns, Methoden zu erstellen, die keinen Wert zurückgeben. Im folgenden Beispiel betrachten wir eine void-Methode namens methodRankPoints. Diese Methode gibt keinen Wert zurück. Der Aufruf einer void-Methode muss eine Anweisung sein, z. B. methodRankPoints(255.7);. Es handelt sich um eine Java-Anweisung, die mit einem Semikolon endet.

Beispiel

public class ExampleVoid {
    public static void main(String[] args) {
        methodRankPoints(255.7);
    }

    public static void methodRankPoints(double points) {
        if (points >= 202.5) {
            System.out.println("Rank:A1");
        } else if (points >= 122.4) {
            System.out.println("Rank:A2");
        } else {
            System.out.println("Rank:A3");
        }
    }
}

Ausgabe:

Rank:A1

Parameterübergabe nach Wert (Pass by Value)

Beim Aufrufprozess müssen Argumente übergeben werden. Diese müssen in derselben Reihenfolge stehen wie ihre jeweiligen Parameter in der Methodenspezifikation. Parameter können nach Wert oder nach Referenz übergeben werden.

Parameterübergabe nach Wert bedeutet, eine Methode mit einem Parameter aufzurufen. Dabei wird der Argumentwert an den Parameter übergeben.

Beispiel

Das folgende Programm zeigt ein Beispiel für die Parameterübergabe nach Wert. Die Werte der Argumente bleiben gleich, auch nach dem Methodenaufruf.

public class SwappingExample {
    public static void main(String[] args) {
        int a = 30;
        int b = 45;
        System.out.println("Before swapping, a = " + a + " and b = " + b);
        // swap-Methode aufrufen
        swapFunction(a, b);
        System.out.println("\n**Now, Before and After swapping values will be same here**:");
        System.out.println("After swapping, a = " + a + " and b is " + b);
    }

    public static void swapFunction(int a, int b) {
        System.out.println("Before swapping(Inside), a = " + a + " b = " + b);
        // n1 mit n2 vertauschen
        int c = a;
        a = b;
        b = c;
        System.out.println("After swapping(Inside), a = " + a + " b = " + b);
    }
}

Ausgabe:

Before swapping, a = 30 and b = 45
Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30
**Now, Before and After swapping values will be same here**:
After swapping, a = 30 and b is 45

Methodenüberladung (Method Overloading)

Wenn eine Klasse zwei oder mehr Methoden mit demselben Namen, aber unterschiedlichen Parametern hat, spricht man von Methodenüberladung. Dies unterscheidet sich von Überschreiben (Overriding). Beim Überschreiben hat eine Methode denselben Namen, Typ, Anzahl der Parameter usw.

Betrachten wir das vorherige Beispiel zur Ermittlung der Minimalzahl vom Typ int. Angenommen, wir wollen das Minimum vom Typ double finden. Dann wird das Konzept der Überladung eingeführt, um zwei oder mehr Methoden mit demselben Namen, aber unterschiedlichen Parametern zu erstellen.

Beispiel

public class ExampleOverloading {
    public static void main(String[] args) {
        int a = 11;
        int b = 6;
        double c = 7.3;
        double d = 9.4;
        int result1 = minFunction(a, b); // gleicher Funktionsname, andere Parameter
        double result2 = minFunction(c, d);
        System.out.println("Minimum Value = " + result1);
        System.out.println("Minimum Value = " + result2);
    }

    // für Integer
    public static int minFunction(int n1, int n2) {
        int min;
        if (n1 > n2)
            min = n2;
        else
            min = n1;
        return min;
    }

    // für Double
    public static double minFunction(double n1, double n2) {
        double min;
        if (n1 > n2)
            min = n2;
        else
            min = n1;
        return min;
    }
}

Ausgabe:

Minimum Value = 6
Minimum Value = 7.3

Überladene Methoden machen das Programm lesbarer. Hier werden zwei Methoden mit demselben Namen, aber unterschiedlichen Parametern bereitgestellt. Das Minimum aus Integer- und Double-Typen ist das Ergebnis.

Verwendung von Kommandozeilenargumenten

Manchmal möchte man Informationen in ein Programm übergeben, wenn man es ausführt. Dies geschieht durch die Übergabe von Kommandozeilenargumenten an main().

Ein Kommandozeilenargument ist die Information, die direkt auf den Programmnamen in der Kommandozeile folgt, wenn es ausgeführt wird. Auf die Kommandozeilenargumente innerhalb eines Java-Programms zuzugreifen, ist einfach. Sie werden als Strings im String-Array gespeichert, das an main() übergeben wird.

Beispiel

Das folgende Programm zeigt alle Kommandozeilenargumente an, mit denen es aufgerufen wurde:

public class CommandLine {
    public static void main(String args[]) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]: " + args[i]);
        }
    }
}

Führen Sie dieses Programm wie folgt aus:

$ java CommandLine this is a command line 200 -100

Ausgabe:

args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

Das this-Schlüsselwort

this ist ein Schlüsselwort in Java, das als Referenz auf das Objekt der aktuellen Klasse innerhalb einer Instanzmethode oder eines Konstruktors verwendet wird. Mit this können Sie auf die Member einer Klasse zugreifen, wie Konstruktoren, Variablen und Methoden.

Hinweis – Das Schlüsselwort this wird nur innerhalb von Instanzmethoden oder Konstruktoren verwendet.

Im Allgemeinen wird das Schlüsselwort this verwendet, um:

Instanzvariablen von lokalen Variablen zu unterscheiden, wenn sie dieselben Namen haben, innerhalb eines Konstruktors oder einer Methode.

class Student {
    int age;
    Student(int age) {
        this.age = age;
    }
}

Einen Konstruktortyp (parametrisierter Konstruktor oder Default-Konstruktor) von einem anderen in einer Klasse aufzurufen. Dies wird als explizite Konstruktoraufrufung bezeichnet.

class Student {
    int age;
    Student() {
        this(20);
    }
    Student(int age) {
        this.age = age;
    }
}

Beispiel: this-Schlüsselwort zur Memberzugriff

public class This_Example {
    // Instanzvariable num
    int num = 10;

    This_Example() {
        System.out.println("This is an example program on keyword this");
    }

    This_Example(int num) {
        // Default-Konstruktor aufrufen
        this();
        // Lokale Variable num der Instanzvariable num zuweisen
        this.num = num;
    }

    public void greet() {
        System.out.println("Hi Welcome to Tutorialspoint");
    }

    public void print() {
        // Lokale Variable num
        int num = 20;
        // Lokale Variable ausgeben
        System.out.println("value of local variable num is : " + num);
        // Instanzvariable ausgeben
        System.out.println("value of instance variable num is : " + this.num);
        // greet-Methode der Klasse aufrufen
        this.greet();
    }

    public static void main(String[] args) {
        // Klasse instanziieren
        This_Example obj1 = new This_Example();
        // print-Methode aufrufen
        obj1.print();
        // Neuen Wert an num-Variable über parametrisierten Konstruktor übergeben
        This_Example obj2 = new This_Example(30);
        // print-Methode erneut aufrufen
        obj2.print();
    }
}

Ausgabe:

This is an example program on keyword this
value of local variable num is : 20
value of instance variable num is : 10
Hi Welcome to Tutorialspoint
This is an example program on keyword this
value of local variable num is : 20
value of instance variable num is : 30
Hi Welcome to Tutorialspoint

Variable Arguments (Varargs)

JDK 1.5 ermöglicht es, eine variable Anzahl von Argumenten desselben Typs an eine Methode zu übergeben. Der Parameter in der Methode wird wie folgt deklariert:

typeName... parameterName

In der Methodendeklaration geben Sie den Typ gefolgt von drei Punkten (...) an. In einer Methode darf nur ein variabler Parameter angegeben werden, und dieser Parameter muss der letzte Parameter sein. Reguläre Parameter müssen ihm vorangehen.

Beispiel

public class VarargsDemo {
    public static void main(String args[]) {
        // Methode mit variablen Argumenten aufrufen
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }

    public static void printMax(double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }
        double result = numbers[0];
        for (int i = 1; i < numbers.length; i++)
            if (numbers[i] > result)
                result = numbers[i];
        System.out.println("The max value is " + result);
    }
}

Ausgabe:

The max value is 56.5
The max value is 3.0

Die finalize()-Methode

Es ist möglich, eine Methode zu definieren, die kurz vor der endgültigen Zerstörung eines Objekts durch den Garbage Collector aufgerufen wird. Diese Methode heißt finalize() und kann verwendet werden, um sicherzustellen, dass ein Objekt sauber beendet wird.

Zum Beispiel könnten Sie finalize() verwenden, um sicherzustellen, dass eine von diesem Objekt gehaltene offene Datei geschlossen wird.

Um einer Klasse einen Finalizer hinzuzufügen, definieren Sie einfach die finalize()-Methode. Die Java-Laufzeitumgebung ruft diese Methode auf, wann immer sie ein Objekt dieser Klasse recyceln will.

Innerhalb der finalize()-Methode geben Sie die Aktionen an, die vor der Zerstörung eines Objekts ausgeführt werden müssen.

Die finalize()-Methode hat diese allgemeine Form:

protected void finalize() {
    // finalization code here
}

Hier ist das Schlüsselwort protected ein Spezifizierer, der den Zugriff auf finalize() durch Code außerhalb der Klasse verhindert.

Das bedeutet, dass Sie nicht wissen können, wann oder sogar ob finalize() ausgeführt wird. Wenn Ihr Programm beispielsweise vor der Garbage Collection endet, wird finalize() nicht ausgeführt.

Java Reguläre Ausdrücke: Pattern Matching mit java.util.regex meistern Java I/O meistern: Dateien, Streams und Ein-/Ausgabe-Grundlagen

Java