Java - Methoden

Een Java-methode is een verzameling instructies die zijn gegroepeerd om een bewerking uit te voeren. Wanneer u de System.out.println() . aanroept methode, het systeem voert bijvoorbeeld verschillende instructies uit om een bericht op de console weer te geven.

Nu leert u hoe u uw eigen methoden met of zonder retourwaarden kunt maken, een methode met of zonder parameters kunt aanroepen en methode-abstractie kunt toepassen in het programmaontwerp.

Aanmaakmethode

Gezien het volgende voorbeeld om de syntaxis van een methode uit te leggen −

Syntaxis

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

Hier,

openbare statische − modificatie
int − retourtype
methodeNaam − naam van de methode
a, b − formele parameters
int a, int b − lijst met parameters

Methodedefinitie bestaat uit een methodeheader en een methodebody. Hetzelfde wordt getoond in de volgende syntaxis −

Syntaxis

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

De hierboven getoonde syntaxis bevat −

aanpasser − Het definieert het toegangstype van de methode en is optioneel om te gebruiken.
retourtype − Methode kan een waarde retourneren.
nameOfMethod − Dit is de naam van de methode. De methodehandtekening bestaat uit de methodenaam en de parameterlijst.
Parameterlijst − De lijst met parameters, dit is het type, de volgorde en het aantal parameters van een methode. Deze zijn optioneel, de methode kan nul parameters bevatten.
methodetekst − De hoofdtekst van de methode definieert wat de methode doet met de instructies.

Voorbeeld

Hier is de broncode van de hierboven gedefinieerde methode genaamd min() . Deze methode heeft twee parameters num1 en num2 en retourneert het maximum tussen de twee −

/** 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; 
}

Oproepmethode

Voor het gebruik van een methode moet deze worden aangeroepen. Er zijn twee manieren waarop een methode wordt aangeroepen, d.w.z. methode retourneert een waarde of retourneert niets (geen retourwaarde).

Het proces van het aanroepen van een methode is eenvoudig. Wanneer een programma een methode aanroept, wordt de programmabesturing overgedragen naar de aangeroepen methode. Deze aangeroepen methode geeft dan de controle terug aan de beller in twee condities, wanneer −

de return-instructie wordt uitgevoerd.
het bereikt de methode die eindigt op het sluiten van accolades.

De methoden die void retourneren, worden beschouwd als een aanroep van een instructie. Laten we een voorbeeld bekijken −

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

De methode die waarde retourneert kan worden begrepen door het volgende voorbeeld −

int result = sum(6, 9);

Hieronder volgt een voorbeeld om te demonstreren hoe een methode gedefinieerd en aangeroepen kan worden −

Voorbeeld

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

Dit levert het volgende resultaat op −

Uitvoer

Minimum value = 6

Het ongeldige zoekwoord

Met het void-sleutelwoord kunnen we methoden maken die geen waarde retourneren. Hier, in het volgende voorbeeld, beschouwen we een void-methode methodRankPoints . Deze methode is een ongeldige methode, die geen waarde retourneert. Aanroep naar een ongeldige methode moet een statement zijn, bijv. methodRankPoints(255.7); . Het is een Java-statement dat eindigt met een puntkomma, zoals in het volgende voorbeeld.

Voorbeeld

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

Dit levert het volgende resultaat op −

Uitvoer

Rank:A1

Parameters doorgeven op waarde

Tijdens het werken met een aanroepproces moeten argumenten worden doorgegeven. Deze moeten in dezelfde volgorde staan als hun respectievelijke parameters in de methodespecificatie. Parameters kunnen worden doorgegeven op waarde of als referentie.

Parameters doorgeven op waarde betekent het aanroepen van een methode met een parameter. Hierdoor wordt de argumentwaarde doorgegeven aan de parameter.

Voorbeeld

Het volgende programma toont een voorbeeld van het doorgeven van een parameter op waarde. De waarden van de argumenten blijven hetzelfde, zelfs na het aanroepen van de methode.

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

Dit levert het volgende resultaat op −

Uitvoer

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

Overbelasting methode

Wanneer een klasse twee of meer methoden met dezelfde naam maar verschillende parameters heeft, staat dit bekend als overbelasting van de methode. Het is iets anders dan overheersen. Bij overschrijven heeft een methode dezelfde methodenaam, hetzelfde type, aantal parameters, enz.

Laten we eens kijken naar het eerder besproken voorbeeld voor het vinden van minimale aantallen integers. Als, laten we zeggen dat we het minimum aantal dubbele typen willen vinden. Vervolgens wordt het concept van overbelasting geïntroduceerd om twee of meer methoden te creëren met dezelfde naam maar met verschillende parameters.

Het volgende voorbeeld legt hetzelfde uit −

Voorbeeld

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

Dit levert het volgende resultaat op −

Uitvoer

Minimum Value = 6
Minimum Value = 7.3

Overbelastingsmethoden maken het programma leesbaar. Hier worden twee methoden gegeven met dezelfde naam maar met verschillende parameters. Het minimum aantal van gehele en dubbele typen is het resultaat.

Opdrachtregelargumenten gebruiken

Soms wil je wat informatie doorgeven aan een programma wanneer je het uitvoert. Dit wordt bereikt door opdrachtregelargumenten door te geven aan main( ).

Een opdrachtregelargument is de informatie die direct volgt op de naam van het programma op de opdrachtregel wanneer het wordt uitgevoerd. Toegang krijgen tot de opdrachtregelargumenten in een Java-programma is vrij eenvoudig. Ze worden opgeslagen als strings in de String-array die wordt doorgegeven aan main( ).

Voorbeeld

Het volgende programma geeft alle opdrachtregelargumenten weer waarmee het wordt aangeroepen met −

public class CommandLine {

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

Probeer dit programma uit te voeren zoals hier getoond −

$java CommandLine this is a command line 200 -100

Dit levert het volgende resultaat op −

Uitvoer

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

Het dit zoekwoord

dit is een trefwoord in Java dat wordt gebruikt als een verwijzing naar het object van de huidige klasse, met in een instantiemethode of een constructor. dit gebruiken je kunt verwijzen naar de leden van een klasse, zoals constructors, variabelen en methoden.

Opmerking − Het trefwoord dit wordt alleen gebruikt binnen instantiemethoden of constructors

Over het algemeen is het zoekwoord dit wordt gebruikt om −

Onderscheid de instantievariabelen van lokale variabelen als ze dezelfde naam hebben, binnen een constructor of een methode.

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

Roep het ene type constructor (geparametriseerde constructor of standaard) van een ander type in een klasse aan. Het staat bekend als expliciete constructor-aanroep.

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

Voorbeeld

Hier is een voorbeeld dat dit . gebruikt trefwoord om toegang te krijgen tot de leden van een klas. Kopieer en plak het volgende programma in een bestand met de naam This_Example.java .

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

Dit levert het volgende resultaat op −

Uitvoer

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

Variabele argumenten(var-args)

Met JDK 1.5 kunt u een variabel aantal argumenten van hetzelfde type doorgeven aan een methode. De parameter in de methode wordt als volgt gedeclareerd −

typeName... parameterName

In de methodedeclaratie geeft u het type op gevolgd door een weglatingsteken (...). Er mag slechts één parameter met variabele lengte worden opgegeven in een methode, en deze parameter moet de laatste parameter zijn. Alle reguliere parameters moeten eraan voorafgaan.

Voorbeeld

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

Dit levert het volgende resultaat op −

Uitvoer

The max value is 56.5
The max value is 3.0

De finalize( )-methode

Het is mogelijk om een methode te definiëren die wordt aangeroepen net voor de definitieve vernietiging van een object door de vuilnisman. Deze methode heet finalize( ) , en het kan worden gebruikt om ervoor te zorgen dat een object netjes eindigt.

U kunt bijvoorbeeld finalize( ) gebruiken om ervoor te zorgen dat een geopend bestand dat eigendom is van dat object, wordt gesloten.

Om een finalizer aan een klasse toe te voegen, definieert u eenvoudig de methode finalize( ). De Java runtime roept die methode aan wanneer het op het punt staat een object van die klasse te recyclen.

Binnen de methode finalize( ) specificeert u de acties die moeten worden uitgevoerd voordat een object wordt vernietigd.

De methode finalize( ) heeft deze algemene vorm −

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

Hier is het trefwoord beschermd een specificatie die toegang tot finalize( ) verhindert door code die buiten zijn klasse is gedefinieerd.

Dit betekent dat u niet kunt weten wanneer of zelfs of finalize( ) zal worden uitgevoerd. Als uw programma bijvoorbeeld eindigt voordat de garbagecollection plaatsvindt, wordt finalize( ) niet uitgevoerd.

Java - Reguliere expressies Java - Bestanden en I/O

Java