Java - Methoden

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

Jetzt lernen Sie, wie Sie Ihre eigenen Methoden mit oder ohne Rückgabewerte erstellen, eine Methode mit oder ohne Parameter aufrufen und Methodenabstraktion im Programmdesign anwenden.

Erstellungsmethode

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

Syntax

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

Hier,

• öffentliche Statik − Modifikator

• int − Rückgabetyp

• Methodenname − Name der Methode

• a, b − formale Parameter

• int a, int b − Parameterliste

Die Methodendefinition besteht aus einem Methodenkopf und einem Methodenrumpf. Dasselbe wird in der folgenden Syntax gezeigt −

Syntax

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

Die oben gezeigte Syntax enthält −

• Modifikator − Es definiert den Zugriffstyp der Methode und kann optional verwendet werden.

• Rückgabetyp − Methode kann einen Wert zurückgeben.

• nameOfMethod − Dies ist der Methodenname. Die Methodensignatur besteht aus dem Methodennamen und der Parameterliste.

• Parameterliste − Die Parameterliste, das sind Typ, Reihenfolge und Anzahl der Parameter einer Methode. Diese sind optional, die Methode darf keine Parameter enthalten.

• Methodenkörper − Der Methodenkörper definiert, was die Methode mit den Anweisungen macht.

Beispiel

Hier ist der Quellcode der oben definierten Methode namens min() . Diese Methode nimmt zwei Parameter num1 und num2 und gibt das Maximum zwischen den beiden zurück −

/** the snippet returns the minimum between two numbers */

public static int minFunction(int n1, int n2) {
   int min;
   if (n1 > n2)
      min = n2;
   else
      min = n1;

   return min; 
}

Method Calling

Um eine Methode zu verwenden, sollte sie aufgerufen werden. Es gibt zwei Möglichkeiten, wie eine Methode aufgerufen wird, d. h. die Methode gibt einen Wert zurück oder sie gibt nichts zurück (kein Rückgabewert).

Der Prozess des Methodenaufrufs ist einfach. Wenn ein Programm eine Methode aufruft, wird die Programmsteuerung an die aufgerufene Methode übertragen. Diese aufgerufene Methode gibt dann die Kontrolle unter zwei Bedingungen an den Aufrufer zurück, wenn −

• die return-Anweisung wird ausgeführt.
• erreicht die Methode, die die schließende Klammer beendet.

Die Methoden, die void zurückgeben, werden als Aufruf einer Anweisung betrachtet. Betrachten wir ein Beispiel −

System.out.println("This is tutorialspoint.com!");

Der Rückgabewert der Methode kann anhand des folgenden Beispiels verstanden werden −

int result = sum(6, 9);

Das folgende Beispiel zeigt, wie man eine Methode definiert und wie man sie aufruft −

Beispiel

Live-Demo

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);
   }

   /** returns the minimum of two numbers */
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

Dies wird das folgende Ergebnis erzeugen −

Ausgabe

Minimum value = 6

Das Schlüsselwort void

Mit dem Schlüsselwort void können wir Methoden erstellen, die keinen Wert zurückgeben. Hier betrachten wir im folgenden Beispiel eine ungültige Methode methodRankPoints . Diese Methode ist eine void-Methode, die keinen Wert zurückgibt. Der Aufruf einer void-Methode muss eine Anweisung sein, d. h. methodRankPoints(255.7); . Es ist eine Java-Anweisung, die mit einem Semikolon endet, wie im folgenden Beispiel gezeigt.

Beispiel

Live-Demo

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");
      }
   }
}

Dies wird das folgende Ergebnis erzeugen −

Ausgabe

Rank:A1

Parameter nach Wert übergeben

Während der Arbeit unter dem aufrufenden Prozess müssen Argumente übergeben werden. Diese sollten in der gleichen Reihenfolge wie ihre jeweiligen Parameter in der Methodenspezifikation stehen. Parameter können als Wert oder als Referenz übergeben werden.

Das Übergeben von Parametern als Wert bedeutet, dass eine Methode mit einem Parameter aufgerufen wird. Dadurch wird der Argumentwert an den Parameter übergeben.

Beispiel

Das folgende Programm zeigt ein Beispiel für die Übergabe von Parametern als Wert. Die Werte der Argumente bleiben auch nach dem Methodenaufruf gleich.

Live-Demo

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);

      // Invoke the swap method
      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);
      
      // Swap n1 with n2
      int c = a;
      a = b;
      b = c;
      System.out.println("After swapping(Inside), a = " + a + " b = " + b);
   }
}

Dies wird das folgende Ergebnis erzeugen −

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

Wenn eine Klasse zwei oder mehr Methoden mit demselben Namen, aber unterschiedlichen Parametern hat, wird dies als Methodenüberladung bezeichnet. Es unterscheidet sich vom Überschreiben. Beim Überschreiben hat eine Methode denselben Methodennamen, denselben Typ, dieselbe Anzahl von Parametern usw.

Betrachten wir das zuvor besprochene Beispiel zum Finden von Mindestzahlen vom Typ Integer. Angenommen, wir möchten die Mindestanzahl von Doppeltypen finden. Dann wird das Konzept des Überladens eingeführt, um zwei oder mehr Methoden mit demselben Namen, aber unterschiedlichen Parametern zu erstellen.

Das folgende Beispiel erklärt dasselbe −

Beispiel

Live-Demo

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);
      
      // same function name with different parameters
      double result2 = minFunction(c, d);
      System.out.println("Minimum Value = " + result1);
      System.out.println("Minimum Value = " + result2);
   }

   // for integer
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
   
   // for double
   public static double minFunction(double n1, double n2) {
     double min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

Dies wird das folgende Ergebnis erzeugen −

Ausgabe

Minimum Value = 6
Minimum Value = 7.3

Das Überladen von Methoden macht das Programm lesbar. Hier werden zwei Methoden mit demselben Namen, aber unterschiedlichen Parametern angegeben. Das Ergebnis ist die Mindestanzahl aus Integer- und Double-Typen.

Befehlszeilenargumente verwenden

Manchmal möchten Sie einige Informationen an ein Programm übergeben, wenn Sie es ausführen. Dies wird erreicht, indem Befehlszeilenargumente an main( ).

übergeben werden

Ein Befehlszeilenargument ist die Information, die direkt auf den Namen des Programms in der Befehlszeile folgt, wenn es ausgeführt wird. Der Zugriff auf die Kommandozeilenargumente innerhalb eines Java-Programms ist recht einfach. Sie werden als Strings im String-Array gespeichert, das an main() übergeben wird.

Beispiel

Das folgende Programm zeigt alle Kommandozeilenargumente an, die es mit −

aufruft

public class CommandLine {

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

Versuchen Sie, dieses Programm wie hier gezeigt auszuführen −

$java CommandLine this is a command line 200 -100

Dies wird das folgende Ergebnis erzeugen −

Ausgabe

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

Das Schlüsselwort this

dies ist ein Schlüsselwort in Java, das in einer Instanzmethode oder einem Konstruktor als Referenz auf das Objekt der aktuellen Klasse verwendet wird. Mit diesem Sie können auf die Mitglieder einer Klasse wie Konstruktoren, Variablen und Methoden verweisen.

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

Im Allgemeinen ist das Schlüsselwort this wird verwendet, um −

• Unterscheiden Sie die Instanzvariablen von lokalen Variablen, wenn sie innerhalb eines Konstruktors oder einer Methode denselben Namen haben.

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

• Rufen Sie einen Konstruktortyp (parametrisierter Konstruktor oder Standard) von einem anderen in einer Klasse auf. Dies wird als expliziter Konstruktoraufruf bezeichnet.

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

Beispiel

Hier ist ein Beispiel, das this verwendet Schlüsselwort für den Zugriff auf die Mitglieder einer Klasse. Kopieren Sie das folgende Programm und fügen Sie es in eine Datei mit dem Namen This_Example.java ein .

Live-Demo

public class This_Example {
   // Instance variable num
   int num = 10;
	
   This_Example() {
      System.out.println("This is an example program on keyword this");	
   }

   This_Example(int num) {
      // Invoking the default constructor
      this();
      
      // Assigning the local variable num to the instance variable num
      this.num = num;	   
   }
   
   public void greet() {
      System.out.println("Hi Welcome to Tutorialspoint");
   }
      
   public void print() {
      // Local variable num
      int num = 20;
      
      // Printing the local variable
      System.out.println("value of local variable num is : "+num);
      
      // Printing the instance variable
      System.out.println("value of instance variable num is : "+this.num);
      
      // Invoking the greet method of a class
      this.greet();     
   }
   
   public static void main(String[] args) {
      // Instantiating the class
      This_Example obj1 = new This_Example();
      
      // Invoking the print method
      obj1.print();
	  
      // Passing a new value to the num variable through parametrized constructor
      This_Example obj2 = new This_Example(30);
      
      // Invoking the print method again
      obj2.print(); 
   }
}

Dies wird das folgende Ergebnis erzeugen −

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 Argumente (var-args)

JDK 1.5 ermöglicht es Ihnen, 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 Auslassungspunkten (...) an. In einer Methode darf nur ein Parameter variabler Länge angegeben werden, und dieser Parameter muss der letzte Parameter sein. Ihm müssen alle regulären Parameter vorangestellt werden.

Beispiel

Live-Demo

public class VarargsDemo {

   public static void main(String args[]) {
      // Call method with variable args  
	   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);
   }
}

Dies wird das folgende Ergebnis erzeugen −

Ausgabe

The max value is 56.5
The max value is 3.0

Die Methode finalize( )

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 es kann verwendet werden, um sicherzustellen, dass ein Objekt sauber beendet wird.

Beispielsweise könnten Sie finalize( ) verwenden, um sicherzustellen, dass eine geöffnete Datei, die diesem Objekt gehört, geschlossen wird.

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

Innerhalb der Methode finalize( ) spezifizieren Sie die Aktionen, die ausgeführt werden müssen, bevor ein Objekt zerstört wird.

Die Methode finalize() 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 verhindert, der außerhalb seiner Klasse definiert ist.

Das bedeutet, dass Sie nicht wissen können, wann oder ob finalize( ) ausgeführt wird. Wenn Ihr Programm zum Beispiel endet, bevor die Garbage Collection stattfindet, wird finalize( ) nicht ausgeführt.