En Java , el mètode és una col·lecció d'enunciats que realitza una tasca o operació específica. S'utilitza àmpliament perquè proporciona reutilitzabilitat de codi significa que s'escriu una vegada i l'utilitza moltes vegades. També proporciona una fàcil modificació. Cadascú mètode té el seu propi nom amb el qual és va trucar . Quan el compilador llegeix el nom del mètode, es crida el mètode i realitza la tasca especificada. En aquest apartat, aprendrem com trucar a predefinits, definits per l'usuari, estàtics, i abstracte mètodes en Java .
Trucada al mètode estàtic a Java
En Java , un mètode estàtic és un mètode que s'invoca o es crida sense crear l'objecte de la classe en què es defineix el mètode. Tots els mètodes que tenen una paraula clau estàtica abans del nom del mètode es coneixen com mètodes estàtics . També podem crear un mètode estàtic mitjançant l' estàtica paraula clau abans del nom del mètode. Podem cridar un mètode estàtic mitjançant l' ClassName.methodName .
El millor exemple del mètode estàtic és el principal () mètode. S'anomena sense crear l'objecte.
sql per ordre aleatori
En el programa següent, hem anomenat el mètode estàtic de la classe Math, anomenat min() que retorna el valor mínim de dos nombres.
StaticMethodCallExample.java
import java.util.*; public class StaticMethodCallExample { public static void main(String args[]) { int a; //calling static method of the Math class a=Math.min(23,98); System.out.println('Minimum number is: ' + a); } } Sortida:
Minimum number is 23
Crida al mètode predefinit a Java
A Java, els mètodes predefinits són els mètodes que ja estan definits a les classes. Quan necessitem un mètode predefinit, només anomenem el mètode pel seu nom.
En l'exemple següent, hem utilitzat un mètode anomenat hashCode() de la classe Objecte . Per cridar el mètode predefinit hashCode() , hem creat un objecte obj de la classe Object perquè és el mètode de la classe Object. Utilitzant l'objecte que hem anomenat el hashCode() mètode que retorna a codi hash valor per a l'objecte.
PredefinedMethodCallExample.java
public class PredefinedMethodCallExample { public static void main(String[] args) { int a; Object obj=new Object(); a=obj.hashCode(); System.out.println('Hash Code of the object is: '+a); } } Sortida:
Hash Code of the object is: 2036368507
Trucada al mètode definit per l'usuari a Java
Per cridar un mètode definit per l'usuari, primer, creem un mètode i després l'anomenem. S'ha de crear un mètode a la classe amb el nom del mètode, seguit de parèntesis (). La definició del mètode consta d'una capçalera i un cos del mètode.
Podem cridar un mètode utilitzant el següent:
method_name(); //non static method calling
Si el mètode és un mètode estàtic, fem servir el següent:
obj.method_name(); //static method calling
On obj és l'objecte de la classe.
A l'exemple següent, hem creat dos mètodes definits per l'usuari anomenats mostrar missatge() i displayMessage() . El mostrar missatge() mètode és un mètode estàtic i displayMessage() El mètode és un mètode no estàtic.
Tingueu en compte que hem anomenat el mostrar missatge() mètode directament, sense utilitzar l'objecte. Mentre que displayMessage() El mètode s'anomena utilitzant l'objecte de la classe.
MethodCallExample.java
public class MethodCallExample { //user-defined static method static void showMessage() { System.out.println('The static method invoked.'); } //user-defined non-static method void displayMessage() { System.out.println('Non-static method invoked.'); } public static void main(String[] args) { //calling static method without using the object showMessage(); //called method //creating an object of the class MethodCallExample me=new MethodCallExample(); //calling non-static method me.displayMessage(); //called method } } Sortida:
travessa d'arbres
The static method invoked. Non-static method invoked.
Una classe pot contenir dos o més mètodes amb el mateix nom. Ara sorgeix la pregunta de com podem anomenar dos mètodes amb el mateix nom.
Quan una classe té dos o més mètodes amb el mateix nom, es diferencia per qualsevol tipus de retorn o tipus de paràmetres o nombre de paràmetres . Aquest concepte s'anomena sobrecàrrega del mètode . Per exemple:
int sum(int x, int y); double sum(double x, double y);
Els dos mètodes anteriors tenen el mateix nom suma() però tots dos són diferents. El primer mètode sum() retorna un valor int i analitza dos enters x i y com a paràmetres. Mentre que el segon mètode sum() retorna un valor doble i analitza dos valors dobles a i y com a paràmetres.
Creem un programa que es sobrecarregui sub() mètode.
MethodOverloadingExample.java
public class MethodOverloadingExample { static int sub(int x, int y) { return x - y; } static double sub(double x, double y) { return x - y; } public static void main(String[] args) { int a = sub(45, 23); double b = sub(23.67,10.5); System.out.println('subtraction of integer values: ' +a); System.out.println('subtraction of double values: ' +b); } } Sortida:
subtraction of integer values: 22 subtraction of double values: 13.170000000000002
Crida al mètode abstracte en Java
Un mètode abstracte és un mètode que es declara amb un abstracte paraula clau. El mètode abstracte només té una declaració de mètode. El cos del mètode abstracte definit a l'altra classe. el mètode abstracte s'ha de declarar al classe abstracta . Podem establir la visibilitat dels mètodes abstractes com a privats o públics. No podem declarar un mètode abstracte com a final perquè viola l'avantatge del mètode abstracte.
La implementació real del mètode abstracte ha de ser a la classe del nen. Podem definir un mètode abstracte de la següent manera:
cadena a nombre enter
abstract public void findArea();
Creem un exemple de crida al mètode abstracte.
En l'exemple següent, hem creat una classe amb el nom ResumMètodeExemple i declarar-lo com a abstracte. En aquesta classe, hem declarat un mètode abstracte anomenat espectacle() . Després d'això, hem creat una altra classe anomenada AbstractMethodClling que s'estén el ResumMètodeExemple classe. En aquesta classe, hem implementat el mètode abstracte.
Per cridar el mètode abstracte show(), hem creat una instància de la classe pare i hem invocat el mètode abstracte.
AbstractMethodCalling.java
//abstract class abstract class AbstractMethodExample { //abstract method declaration abstract void show(); } public class AbstractMethodCalling extends AbstractMethodExample { //abstract method implementation void show() { System.out.println('The abstract method called.'); } public static void main(String args[]) { AbstractMethodExample obj = new AbstractMethodCalling(); //calling abstract method obj.show(); } } Sortida:
The abstract method called.