El mètode en Java o Methods of Java és una col·lecció d'instruccions que realitzen algunes tasques específiques i retornen el resultat a la persona que truca. Un mètode Java pot realitzar algunes tasques específiques sense retornar res. Els mètodes Java ens permeten reutilitzar el codi sense tornar a escriure el codi. A Java, cada mètode ha de formar part d'alguna classe que sigui diferent dels llenguatges com C, C++ i Python.

• Un mètode és com una funció, és a dir, s'utilitza per exposar el comportament d'un objecte.
• És un conjunt de codis que realitzen una tasca determinada.

Sintaxi del mètode

 ( list_of_parameters) { //body }>

Avantatge del mètode

• Reutilitzabilitat del codi
• Optimització del codi

Nota: Els mètodes estalvien temps i ens ajuden a reutilitzar el codi sense tornar a escriure el codi.

Declaració del mètode

En general, les declaracions de mètode tenen 6 components:

1. Modificador: Defineix el tipus d'accés del mètode, és a dir, des d'on es pot accedir a la vostra aplicació. A Java, hi ha 4 tipus d'especificadors d'accés.

• públic: És accessible a totes les classes de la vostra aplicació.
• protegit: És accessible dins de la classe en què es defineix i en les seves subclasses.
• privat: És accessible només dins de la classe en què es defineix.
• per defecte: Es declara/defineix sense utilitzar cap modificador. És accessible dins de la mateixa classe i paquet dins del qual es defineix la seva classe.

Nota: És Opcional en sintaxi.

2. El tipus de retorn: El tipus de dades del valor retornat pel mètode o void si no retorna cap valor. És Obligatori en sintaxi.

3. Nom del mètode: les regles dels noms de camp també s'apliquen als noms dels mètodes, però la convenció és una mica diferent. És Obligatori en sintaxi.

4. Llista de paràmetres: Dins del parèntesi adjunt es defineix una llista separada per comes dels paràmetres d'entrada, precedida pel seu tipus de dades. Si no hi ha paràmetres, heu d'utilitzar parèntesis buits (). És Opcional en sintaxi.

5. Llista d'excepcions: Les excepcions que espereu pel mètode poden llançar; podeu especificar aquestes excepcions. És Opcional en sintaxi.

6. Cos del mètode: està tancat entre claus. El codi que cal executar per dur a terme les operacions previstes. És Opcional en sintaxi.

Tipus de mètodes en Java

Hi ha dos tipus de mètodes a Java:

1. Mètode predefinit

A Java, els mètodes predefinits són el mètode que ja està definit a les biblioteques de classes de Java es coneix com a mètodes predefinits. També es coneix com a mètode de biblioteca estàndard o mètode integrat. Podem utilitzar directament aquests mètodes només cridant-los al programa en qualsevol moment.

2. Mètode definit per l'usuari

El mètode escrit per l'usuari o programador es coneix com a mètode definit per l'usuari. Aquests mètodes es modifiquen segons el requisit.

Maneres de crear mètodes en Java

Hi ha dues maneres de crear un mètode en Java:

què és un hashset en java

1. Mètode d'instància: Accediu a les dades de la instància mitjançant el nom de l'objecte. Declarat dins d'una classe.

Sintaxi:

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

2. Mètode estàtic: Accediu a les dades estàtiques mitjançant el nom de la classe. Declarat dins de la classe amb estàtica paraula clau.

Sintaxi:

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

Signatura del mètode:

Consisteix en el nom del mètode i una llista de paràmetres (nombre de paràmetres, tipus de paràmetres i ordre dels paràmetres). El tipus de retorn i les excepcions no es consideren part d'aquest.

Mètode Signatura de la funció anterior:

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

Anomenament d'un mètode

El nom d'un mètode és normalment una sola paraula que hauria de ser a verb en minúscules o amb diverses paraules, que comença amb a verb en minúscula seguida d'un adjectiu, substantiu. Després de la primera paraula, la primera lletra de cada paraula s'ha de posar en majúscula.

Regles per anomenar un mètode:

• Quan definiu un mètode, recordeu que el nom del mètode ha de ser a verb i comença amb a minúscula carta.
• Si el nom del mètode té més de dues paraules, el primer nom ha de ser un verb seguit d'un adjectiu o substantiu.
• Al nom del mètode de diverses paraules, la primera lletra de cada paraula ha d'estar en majúscula excepte la primera paraula. Per exemple, findSum, computeMax, setX i getX.

En general, un mètode té un nom únic dins de la classe en què es defineix, però de vegades un mètode pot tenir el mateix nom que altres noms de mètodes dins de la mateixa classe que La sobrecàrrega de mètodes està permesa a Java .

Mètode de trucada

Cal cridar el mètode per utilitzar la seva funcionalitat. Hi pot haver tres situacions quan es crida un mètode:
Un mètode torna al codi que l'ha invocat quan:

• Completa totes les declaracions del mètode.
• Arriba a una declaració de retorn.
• Llança una excepció.

Exemple:

// 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>

Exemple 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>

El flux de control del programa anterior és el següent:

Passar paràmetres a un mètode

Hi ha alguns casos en què no sabem el nombre de paràmetres que cal passar o un cas inesperat per utilitzar més paràmetres que el nombre declarat de paràmetres. En aquests casos podem utilitzar

• Passant Array com a argument
• Passar arguments de variables com a argument
• Sobrecàrrega del mètode.

Assignació de memòria per a trucades de mètodes

Les trucades de mètodes s'implementen mitjançant una pila. Sempre que un mètode s'anomena un marc de pila es crea dins de l'àrea de la pila i després d'això, els arguments passats i les variables locals i el valor que ha de retornar per aquest mètode anomenat s'emmagatzemen en aquest marc de pila i quan s'acaba l'execució del mètode cridat , el marc de pila assignat s'eliminaria. Hi ha un registre de punter de pila que segueix la part superior de la pila que s'ajusta en conseqüència.

Exemple: pseudocodi per implementar mètodes

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

Hi ha diversos avantatges d'utilitzar mètodes a Java, com ara:

• Reutilitzabilitat : Els mètodes us permeten escriure codi una vegada i utilitzar-lo moltes vegades, fent que el vostre codi sigui més modular i més fàcil de mantenir.
• Abstracció : Els mètodes us permeten abstraure la lògica complexa i proporcionen una interfície senzilla perquè altres la facin servir. Això fa que el vostre codi sigui més llegible i més fàcil d'entendre.
• Llegibilitat millorada : En dividir el codi en mètodes més petits i ben anomenats, podeu fer que el vostre codi sigui més llegible i més fàcil d'entendre.
• Encapsulació : Els mètodes us permeten encapsular lògica i dades complexes, facilitant la gestió i el manteniment.
• Separació de preocupacions s: Mitjançant l'ús de mètodes, podeu separar diferents parts del vostre codi i assignar diferents responsabilitats a diferents mètodes, millorant l'estructura i l'organització del vostre codi.
• Modularitat millorada : Els mètodes us permeten dividir el vostre codi en unitats més petites i més manejables, millorant la modularitat del vostre codi.
• Testabilitat millorada : En dividir el codi en unitats més petites i més manejables, podeu fer més fàcil provar i depurar el vostre codi.
• Rendiment millorat: Organitzant el codi en mètodes ben estructurats, podeu millorar el rendiment reduint la quantitat de codi que cal executar i facilitant la memòria cau i l'optimització del codi.

Preguntes freqüents a Mètodes en Java

P. Què és un mètode en programació Java?

El mètode Java és una col·lecció d'instruccions que realitzen alguna tasca específica i retornen el resultat a la persona que truca.

P. Quines són les parts del mètode a Java?

Les 5 parts dels mètodes a Java s'esmenten a continuació:

trencar java

1. Modificadors
2. Tipus de retorn
3. Nom del mètode
4. Paràmetres
5. Cos del mètode

Articles relacionats:

• Java es passa estrictament pel valor
• Sobrecàrrega de mètodes i error nul a Java
• Podem sobrecarregar o anul·lar mètodes estàtics a Java?
• Tests de Java