De methode op Java of Methods of Java is een verzameling instructies die een aantal specifieke taken uitvoeren en het resultaat terugsturen naar de beller. Een Java-methode kan een aantal specifieke taken uitvoeren zonder iets terug te geven. Java-methoden stellen ons in staat dat te doen hergebruiken de code zonder de code opnieuw te typen. In Java moet elke methode deel uitmaken van een klasse die verschilt van talen als C, C++ en Python.

• Een methode is als een functie, d.w.z. gebruikt om het gedrag van een object bloot te leggen.
• Het is een reeks codes die een bepaalde taak uitvoeren.

Syntaxis van methode

 ( list_of_parameters) { //body }>

Voordeel van methode

• Herbruikbaarheid van codes
• Code-optimalisatie

Opmerking: Methoden besparen tijd en helpen ons de code opnieuw te gebruiken zonder de code opnieuw te typen.

Methodeverklaring

Over het algemeen bestaan ​​methodedeclaraties uit zes componenten:

1. Modificator: Het definieert de Toegangstype van de methode, dat wil zeggen vanaf waar deze toegankelijk is in uw toepassing. In Java zijn er 4 soorten toegangsspecificaties.

• openbaar: Het is toegankelijk in alle klassen in uw toepassing.
• beschermd: Het is toegankelijk binnen de klasse waarin het is gedefinieerd en in de subklassen ervan.
• privaat: Het is alleen toegankelijk binnen de klasse waarin het is gedefinieerd.
• standaard: Het wordt gedeclareerd/gedefinieerd zonder enige modifier te gebruiken. Het is toegankelijk binnen dezelfde klasse en hetzelfde pakket waarin de klasse is gedefinieerd.

Opmerking: Het is Optioneel in syntaxis.

2. Het retourtype: Het gegevenstype van de waarde die door de methode wordt geretourneerd, of ongeldig als er geen waarde wordt geretourneerd. Het is Verplicht in syntaxis.

3. Methodenaam: de regels voor veldnamen zijn ook van toepassing op methodenamen, maar de conventie is iets anders. Het is Verplicht in syntaxis.

4. Parameterlijst: Er wordt een door komma's gescheiden lijst met invoerparameters gedefinieerd, voorafgegaan door hun gegevenstype, binnen de bijgevoegde haakjes. Als er geen parameters zijn, moet u lege haakjes () gebruiken. Het is Optioneel in syntaxis.

5. Uitzonderingslijst: De uitzonderingen die u door de methode verwacht, kunnen genereren; U kunt deze uitzondering(en) specificeren. Het is Optioneel in syntaxis.

6. Methodelichaam: het zit tussen beugels. De code die u moet uitvoeren om de beoogde bewerkingen uit te voeren. Het is Optioneel in syntaxis.

Soorten methoden in Java

Er zijn twee soorten methoden in Java:

1. Voorgedefinieerde methode

In Java zijn vooraf gedefinieerde methoden de methode die al is gedefinieerd in de Java-klassebibliotheken en staat bekend als vooraf gedefinieerde methoden. Het is ook bekend als de standaardbibliotheekmethode of ingebouwde methode. We kunnen deze methoden rechtstreeks gebruiken door ze op elk gewenst moment in het programma aan te roepen.

2. Door de gebruiker gedefinieerde methode

De door de gebruiker of programmeur geschreven methode staat bekend als een door de gebruiker gedefinieerde methode. Deze methoden worden aangepast aan de vereisten.

Manieren om een ​​methode te creëren in Java

Er zijn twee manieren om een ​​methode in Java te maken:

probeer catch catch java

1. Instantiemethode: Krijg toegang tot de exemplaargegevens met behulp van de objectnaam. Aangegeven binnen een klas.

Syntaxis:

// Instance Method void method_name(){ body // instance area }>

2. Statische methode: Krijg toegang tot de statische gegevens met behulp van de klassenaam. Aangegeven binnen de klas met statisch trefwoord.

Syntaxis:

//Static Method static void method_name(){ body // static area }>

Methode Handtekening:

Het bestaat uit de naam van de methode en een parameterlijst (aantal parameters, type parameters en volgorde van de parameters). Het retourtype en de uitzonderingen worden er niet als onderdeel van beschouwd.

internet gebruiken

Methode Handtekening van bovenstaande functie:

 max(int x, int y) Number of parameters is 2, Type of parameter is int.>

Een methode benoemen

Een methodenaam bestaat doorgaans uit één woord dat a moet zijn werkwoord in kleine letters of in meerdere woorden, die beginnen met een werkwoord in kleine letters gevolgd door een bijvoeglijk naamwoord, zelfstandig naamwoord. Na het eerste woord moet de eerste letter van elk woord een hoofdletter zijn.

Regels om een ​​methode een naam te geven:

• Houd er bij het definiëren van een methode rekening mee dat de naam van de methode a moet zijn werkwoord en begin met een kleine letters brief.
• Als de naam van de methode uit meer dan twee woorden bestaat, moet de voornaam een ​​werkwoord zijn, gevolgd door een bijvoeglijk naamwoord of zelfstandig naamwoord.
• In de naam van de methode die uit meerdere woorden bestaat, moet de eerste letter van elk woord voorkomen hoofdletter behalve het eerste woord. Bijvoorbeeld findSum, computeMax, setX en getX.

Over het algemeen heeft een methode een unieke naam binnen de klasse waarin deze is gedefinieerd, maar soms kan een methode dezelfde naam hebben als andere methodenamen binnen dezelfde klasse als overbelasting van methoden is toegestaan ​​in Java .

Methode Bellen

De methode moet worden aangeroepen om de functionaliteit ervan te kunnen gebruiken. Er kunnen drie situaties zijn waarin een methode wordt aangeroepen:
Een methode keert terug naar de code die deze heeft aangeroepen wanneer:

• Het voltooit alle instructies in de methode.
• Het bereikt een retourverklaring.
• Gooit een uitzondering.

Voorbeeld:

// Java Program to Illustrate Methods // Importing required classes import java.io.*; // Class 1 // Helper class class Addition {  // Initially taking sum as 0  // as we have not started computation  int sum = 0;  // Method  // To add two numbers  public int addTwoInt(int a, int b)  {  // Adding two integer value  sum = a + b;  // Returning summation of two values  return sum;  } } // Class 2 // Helper class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating object of class 1 inside main() method  Addition add = new Addition();  // Calling method of above class  // to add two integer  // using instance created  int s = add.addTwoInt(1, 2);  // Printing the sum of two numbers  System.out.println('Sum of two integer values :'  + s);  } }>

Sum of two integer values :3>

Voorbeeld 2:

// Java Program to Illustrate Method Calling // Via Different Ways of Calling a Method // Importing required classes import java.io.*; // Class 1 // Helper class class Test {  public static int i = 0;  // Constructor of class  Test()  {  // Counts the number of the objects of the class  i++;  }  // Method 1  // To access static members of the class and  // and for getting total no of objects  // of the same class created so far  public static int get()  {  // statements to be executed....  return i;  }  // Method 2  // Instance method calling object directly  // that is created inside another class 'GFG'.  // Can also be called by object directly created in the  // same class and from another method defined in the  // same class and return integer value as return type is  // int.  public int m1()  {  // Display message only  System.out.println(  'Inside the method m1 by object of GFG class');  // Calling m2() method within the same class.  this.m2();  // Statements to be executed if any  return 1;  }  // Method 3  // Returns nothing  public void m2()  {  // Print statement  System.out.println(  'In method m2 came from method m1');  } } // Class 2 // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating object of above class inside the class  Test obj = new Test();  // Calling method 2 inside main() method  int i = obj.m1();  // Display message only  System.out.println(  'Control returned after method m1 :' + i);  // Call m2() method  // obj.m2();  int no_of_objects = Test.get();  // Print statement  System.out.print(  'No of instances created till now : ');  System.out.println(no_of_objects);  } }>

Inside the method m1 by object of GFG class In method m2 came from method m1 Control returned after method m1 :1 No of instances created till now : 1>

De besturingsstroom van het bovenstaande programma is als volgt:

Parameters doorgeven aan een methode

Er zijn enkele gevallen waarin we niet weten hoeveel parameters moeten worden doorgegeven of er zijn onverwachte gevallen waarbij meer parameters worden gebruikt dan het opgegeven aantal parameters. In dergelijke gevallen kunnen we gebruik maken van

• Array doorgeven als argument
• Variabele-argumenten doorgeven als argument
• Methode Overbelasting.

Geheugentoewijzing voor methodeaanroepen

Methodenaanroepen worden geïmplementeerd via een stapel. Telkens wanneer een methode wordt aangeroepen, wordt er een stapelframe gemaakt binnen het stapelgebied en daarna worden de argumenten die worden doorgegeven aan en de lokale variabelen en de waarde die door deze aangeroepen methode moeten worden geretourneerd, in dit stapelframe opgeslagen en wanneer de uitvoering van de aangeroepen methode is voltooid , zou het toegewezen stapelframe worden verwijderd. Er is een stapelwijzerregister dat de bovenkant van de stapel volgt en dienovereenkomstig wordt aangepast.

Voorbeeld: pseudo-code voor het implementeren van methoden

// Define a class public class Example {  // Define instance variables  private int number;  private String name;  // Define accessor (getter) methods  public int getNumber() {  return number;   }  public String getName() {  return name;   }  // Define mutator (setter) methods  public void setNumber(int number)  {  this.number = number;  }  public void setName(String name) { this.name = name; }  // Define other methods  public void printDetails()  {  System.out.println('Number: ' + number);  System.out.println('Name: ' + name);  } } // Use the methods in another part of the code Example example = new Example(); example.setNumber(123); example.setName('GFG Write'); example.printDetails();>

Er zijn verschillende voordelen aan het gebruik van methoden in Java, waaronder:

• Herbruikbaarheid : Met methoden kunt u code één keer schrijven en deze vele malen gebruiken, waardoor uw code modulairer en gemakkelijker te onderhouden wordt.
• Abstractie : Met methoden kunt u complexe logica wegnemen en een eenvoudige interface bieden die anderen kunnen gebruiken. Dit maakt uw code beter leesbaar en gemakkelijker te begrijpen.
• Verbeterde leesbaarheid : Door uw code op te delen in kleinere, goedbenoemde methoden, kunt u uw code leesbaarder en gemakkelijker te begrijpen maken.
• Inkapseling : Met methoden kunt u complexe logica en gegevens inkapselen, waardoor het gemakkelijker te beheren en te onderhouden is.
• Scheiding van zorg s: Door methoden te gebruiken, kunt u verschillende delen van uw code scheiden en verschillende verantwoordelijkheden aan verschillende methoden toewijzen, waardoor de structuur en organisatie van uw code wordt verbeterd.
• Verbeterde modulariteit : Met methoden kunt u uw code opdelen in kleinere, beter beheersbare eenheden, waardoor de modulariteit van uw code wordt verbeterd.
• Verbeterde testbaarheid : Door uw code op te delen in kleinere, beter beheersbare eenheden, kunt u het gemakkelijker maken om uw code te testen en fouten op te sporen.
• Verbeterde prestatie: Door uw code in goed gestructureerde methoden te organiseren, kunt u de prestaties verbeteren door de hoeveelheid code die moet worden uitgevoerd te verminderen en door het gemakkelijker te maken uw code in de cache op te slaan en te optimaliseren.

Veelgestelde vragen over methoden in Java

V. Wat is een methode in Java-programmeren?

Java-methode is een verzameling instructies die een specifieke taak uitvoeren en het resultaat terugsturen naar de beller.

V. Wat zijn delen van de methode in Java?

De 5 methodenonderdelen in Java worden hieronder vermeld:

1. Modificatoren
2. Retourtype
3. Methodenaam
4. Parameters
5. Methode Lichaam

Gerelateerde artikelen:

• Java wordt strikt door waarde doorgegeven
• Methode-overbelasting en nulfout in Java
• Kunnen we statische methoden in Java overbelasten of negeren?
• Java-quizzen