In Giava , IL metodo è una raccolta di istruzioni che eseguono un'attività o un'operazione specifica. È ampiamente utilizzato perché fornisce la riusabilità del codice significa che è possibile scriverlo una volta e utilizzarlo più volte. Fornisce inoltre una facile modifica. Ogni metodo ha il suo nome con cui è chiamato . Quando il compilatore legge il nome del metodo, il metodo viene chiamato ed esegue l'attività specificata. In questa sezione impareremo come chiamare predefinito, definito dall'utente, statico, E astratto metodi in Java .
Chiamare il metodo statico in Java
In Giava , un metodo statico è un metodo che viene invocato o chiamato senza creare l'oggetto della classe in cui è definito il metodo. Tutti i metodi che hanno una parola chiave statica prima del nome del metodo sono noti come metodi statici . Possiamo anche creare un metodo statico utilizzando il metodo statico parola chiave prima del nome del metodo. Possiamo chiamare un metodo statico utilizzando il metodo NomeClasse.Nomemetodo .
Il miglior esempio del metodo statico è il principale() metodo. Si chiama senza creare l'oggetto.
stato git -s
Nel programma seguente abbiamo chiamato il metodo statico della classe Math, denominato min() che restituisce il valore minimo di due numeri.
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); } } Produzione:
Minimum number is 23
Chiamare il metodo predefinito in Java
In Java, i metodi predefiniti sono i metodi già definiti nelle classi. Quando richiediamo un metodo predefinito, chiamiamo semplicemente il metodo con il suo nome.
Nell'esempio seguente, abbiamo utilizzato un metodo denominato codice hash() della classe Oggetto . Per chiamare il metodo predefinito codice hash() , abbiamo creato un oggetto ogg della classe Object perché è il metodo della classe Object. Utilizzando l'oggetto che abbiamo chiamato the codice hash() metodo che restituisce a codice hash valore per l'oggetto.
PrefinedMethodCallExample.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); } } Produzione:
Hash Code of the object is: 2036368507
Chiamata del metodo definito dall'utente in Java
Per chiamare un metodo definito dall'utente, innanzitutto creiamo un metodo e poi lo chiamiamo. È necessario creare un metodo nella classe con il nome del metodo, seguito da parentesi (). La definizione del metodo è costituita da un'intestazione e da un corpo del metodo.
Possiamo chiamare un metodo utilizzando quanto segue:
method_name(); //non static method calling
Se il metodo è statico, utilizziamo quanto segue:
obj.method_name(); //static method calling
Dove obj è l'oggetto della classe.
Nell'esempio seguente abbiamo creato due metodi definiti dall'utente denominati mostraMessaggio() E displayMessaggio() . IL mostraMessaggio() Il metodo è un metodo statico e displayMessaggio() Il metodo è un metodo non statico.
Tieni presente che abbiamo chiamato il file mostraMessaggio() metodo direttamente, senza utilizzare l'oggetto. Mentre il displayMessaggio() il metodo viene chiamato utilizzando l'oggetto della 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 } } Produzione:
The static method invoked. Non-static method invoked.
Una classe può contenere due o più metodi con lo stesso nome. Ora sorge la domanda su come possiamo chiamare due metodi con lo stesso nome.
Quando una classe ha due o più metodi con lo stesso nome viene differenziata da uno dei due tipo di restituzione O tipi di parametro O numero di parametri . Questo concetto si chiama sovraccarico del metodo . Per esempio:
python salva json su file
int sum(int x, int y); double sum(double x, double y);
I due metodi precedenti hanno lo stesso nome somma() ma entrambi sono diversi. Il primo metodo sum() restituisce un valore int e analizza due numeri interi x e y come parametri. Mentre il secondo metodo sum() restituisce un valore double e analizza due valori double a e y come parametri.
Creiamo un programma che sovraccarichi sub() metodo.
MetodoOverloadingExample.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); } } Produzione:
subtraction of integer values: 22 subtraction of double values: 13.170000000000002
Chiamare il metodo astratto in Java
Un metodo astratto è un metodo dichiarato con an astratto parola chiave. Il metodo astratto ha solo una dichiarazione di metodo. Il corpo del metodo astratto definito nell'altra classe. il metodo astratto deve essere dichiarato nel file classe astratta . Possiamo impostare la visibilità dei metodi astratti come privata o pubblica. Non possiamo dichiarare un metodo astratto come finale perché viola il vantaggio del metodo astratto.
L'effettiva implementazione del metodo astratto deve avvenire nella classe del bambino. Possiamo definire un metodo astratto come segue:
convertire carattere in stringa
abstract public void findArea();
Creiamo un esempio di chiamata del metodo astratto.
Nell'esempio seguente, abbiamo creato una classe con il nome Metodo astratto Esempio e dichiararlo astratto. In questa classe abbiamo dichiarato un metodo astratto denominato spettacolo() . Successivamente, abbiamo creato un'altra classe denominata Metodo astratto Chiamata che estende il Metodo astratto Esempio classe. In questa classe abbiamo implementato il metodo astratto.
Per chiamare il metodo astratto show(), abbiamo creato un'istanza della classe genitore e invocato il metodo astratto.
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(); } } Produzione:
The abstract method called.