In Java, il Method Overloading consente a metodi diversi di avere lo stesso nome, ma firme diverse in cui la firma può differire per il numero di parametri di input o il tipo di parametri di input o una combinazione di entrambi.
L'overload del metodo in Java è noto anche come Polimorfismo in fase di compilazione , Polimorfismo statico, o Legatura anticipata . Nell'overload del metodo rispetto all'argomento genitore, l'argomento figlio avrà la massima priorità.
Esempio di sovraccarico del metodo
Giava
// Java program to demonstrate working of method> // overloading in Java> > public> class> Sum {> >// Overloaded sum(). This sum takes two int parameters> >public> int> sum(>int> x,>int> y) {>return> (x + y); }> > >// Overloaded sum(). This sum takes three int parameters> >public> int> sum(>int> x,>int> y,>int> z)> >{> >return> (x + y + z);> >}> > >// Overloaded sum(). This sum takes two double> >// parameters> >public> double> sum(>double> x,>double> y)> >{> >return> (x + y);> >}> > >// Driver code> >public> static> void> main(String args[])> >{> >Sum s =>new> Sum();> >System.out.println(s.sum(>10>,>20>));> >System.out.println(s.sum(>10>,>20>,>30>));> >System.out.println(s.sum(>10.5>,>20.5>));> >}> }> |
>
array di ordinamento in Java
>Produzione
30 60 31.0>
Diversi modi di sovraccarico dei metodi in Java
- Modifica del numero di parametri.
- Modifica dei tipi di dati degli argomenti.
- Modifica dell'ordine dei parametri dei metodi
1. Modifica del numero di parametri
L'overload del metodo può essere ottenuto modificando il numero di parametri durante il passaggio a metodi diversi.
Di seguito è riportata l'implementazione del metodo sopra:
Giava
// Java Program to Illustrate Method Overloading> // By Changing the Number of Parameters> > // Importing required classes> import> java.io.*;> > // Class 1> // Helper class> class> Product {> >// Method 1> >// Multiplying two integer values> >public> int> multiply(>int> a,>int> b)> >{> >int> prod = a * b;> >return> prod;> >}> > >// Method 2> >// Multiplying three integer values> >public> int> multiply(>int> a,>int> b,>int> c)> >{> >int> prod = a * b * c;> >return> prod;> >}> }> > // Class 2> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Creating object of above class inside main()> >// method> >Product ob =>new> Product();> > >// Calling method to Multiply 2 numbers> >int> prod1 = ob.multiply(>1>,>2>);> > >// Printing Product of 2 numbers> >System.out.println(> >'Product of the two integer value :'> + prod1);> > >// Calling method to multiply 3 numbers> >int> prod2 = ob.multiply(>1>,>2>,>3>);> > >// Printing product of 3 numbers> >System.out.println(> >'Product of the three integer value :'> + prod2);> >}> }> |
>
>Produzione
Product of the two integer value :2 Product of the three integer value :6>
2. Modifica dei tipi di dati degli argomenti
In molti casi, i metodi possono essere considerati sovraccarichi se hanno lo stesso nome ma tipi di parametri diversi; i metodi sono considerati sovraccaricati.
Di seguito è riportata l'implementazione del metodo sopra:
Giava
// Java Program to Illustrate Method Overloading> // By Changing Data Types of the Parameters> > // Importing required classes> import> java.io.*;> > // Class 1> // Helper class> class> Product {> >// Multiplying three integer values> >public> int> Prod(>int> a,>int> b,>int> c)> >{> >int> prod1 = a * b * c;> >return> prod1;> >}> > >// Multiplying three double values.> >public> double> Prod(>double> a,>double> b,>double> c)> >{> >double> prod2 = a * b * c;> >return> prod2;> >}> }> > class> GFG {> >public> static> void> main(String[] args)> >{> >Product obj =>new> Product();> > >int> prod1 = obj.Prod(>1>,>2>,>3>);> >System.out.println(> >'Product of the three integer value :'> + prod1);> > >double> prod2 = obj.Prod(>1.0>,>2.0>,>3.0>);> >System.out.println(> >'Product of the three double value :'> + prod2);> >}> }> |
>
>Produzione
Product of the three integer value :6 Product of the three double value :6.0>
3. Modifica dell'ordine dei parametri dei metodi
L'overload del metodo può essere implementato anche riorganizzando i parametri di due o più metodi sovraccarichi. Ad esempio, se i parametri del metodo 1 sono (String name, int roll_no) e l'altro metodo è (int roll_no, String name) ma entrambi hanno lo stesso nome, questi 2 metodi sono considerati sovraccarichi con sequenze di parametri diverse .
Di seguito è riportata l'implementazione del metodo sopra:
Giava
// Java Program to Illustrate Method Overloading> // By changing the Order of the Parameters> > // Importing required classes> import> java.io.*;> > // Class 1> // Helper class> class> Student {> >// Method 1> >public> void> StudentId(String name,>int> roll_no)> >{> >System.out.println(>'Name :'> + name +>' '> >+>'Roll-No :'> + roll_no);> >}> > >// Method 2> >public> void> StudentId(>int> roll_no, String name)> >{> >// Again printing name and id of person> >System.out.println(>'Roll-No :'> + roll_no +>' '> >+>'Name :'> + name);> >}> }> > // Class 2> // Main class> class> GFG {> >// Main function> >public> static> void> main(String[] args)> >{> >// Creating object of above class> >Student obj =>new> Student();> > >// Passing name and id> >// Note: Reversing order> >obj.StudentId(>'Spyd3r'>,>1>);> >obj.StudentId(>2>,>'Kamlesh'>);> >}> }> |
>
>Produzione
Name :Spyd3r Roll-No :1 Roll-No :2 Name :Kamlesh>
Cosa succede se il prototipo esatto non corrisponde agli argomenti?
Dal punto di vista della priorità, il compilatore esegue questi passaggi:
- Conversione di tipo ma ad un tipo superiore (in termini di portata) nella stessa famiglia.
- Conversione del tipo nella famiglia successiva superiore (supponiamo che non sia disponibile un tipo di dati lungo per un tipo di dati int, cercherà il tipo di dati float).
Facciamo un esempio per chiarire il concetto:
Giava
// Demo Class> class> Demo {> >public> void> show(>int> x)> >{> >System.out.println(>'In int'> + x);> >}> >public> void> show(String s)> >{> >System.out.println(>'In String'> + s);> >}> >public> void> show(>byte> b)> >{> >System.out.println(>'In byte'> + b);> >}> }> > class> UseDemo {> >public> static> void> main(String[] args)> >{> >byte> a =>25>;> >Demo obj =>new> Demo();> > >// it will go to> >// byte argument> >obj.show(a);> > >// String> >obj.show(>'hello'>);> > >// Int> >obj.show(>250>);> > >// Since char is> >// not available, so the datatype> >// higher than char in terms of> >// range is int.> >obj.show(>'A'>);> > >// String> >obj.show(>'A'>);> > >// since float datatype> >// is not available and so it's higher> >// datatype, so at this step their> >// will be an error.> >obj.show(>7.5>);> >}> }> |
>
>
Produzione
./UseDemo.java:46: error: no suitable method found for show(double) obj.show(7.5); ^ method Demo.show(int) is not applicable (argument mismatch; possible lossy conversion from double to int) method Demo.show(String) is not applicable (argument mismatch; double cannot be converted to String) method Demo.show(byte) is not applicable (argument mismatch; possible lossy conversion from double to byte) 1 error>
Vantaggi del sovraccarico del metodo
- Il sovraccarico del metodo migliora la leggibilità e la riusabilità del programma.
- Il sovraccarico del metodo riduce la complessità del programma.
- Utilizzando l'overload del metodo, i programmatori possono eseguire un'attività in modo efficiente ed efficace.
- Utilizzando l'overloading dei metodi, è possibile accedere a metodi che eseguono funzioni correlate con argomenti e tipi leggermente diversi.
- Gli oggetti di una classe possono anche essere inizializzati in diversi modi utilizzando i costruttori.
Domande importanti in Java
Q1. Possiamo sovraccaricare i metodi statici?
Risposta:
La risposta è ' SÌ ’. Possiamo avere due o più metodi statici con lo stesso nome, ma differenze nei parametri di input. Consideriamo ad esempio il seguente programma Java. Per saperne di più, fare riferimento all’articolo – Possiamo sovraccaricare o sovrascrivere metodi statici in Java?
trova il mio iPhone da Android
Q2. Possiamo sovraccaricare metodi che differiscono solo per parole chiave statiche?
Risposta:
Noi non può sovraccaricare due metodi in Java se differiscono solo per la parola chiave statica (il numero di parametri e i tipi di parametri sono gli stessi). Vedi ad esempio il seguente programma Java. Fare riferimento a questo per i dettagli.
Q3. Possiamo sovraccaricare main() in Java?
Risposta:
Come altri metodi statici, we Potere sovraccarico main() in Java.
Giava
// Java program with overloaded main()>import>java.io.*;>>public>class>Test {>>// Normal main()>>public>static>void>main(String[] args)>>{>>System.out.println(>'Hi Geek (from main)'>);>>Test.main(>'Geek'>);>>}>>>// Overloaded main methods>>public>static>void>main(String arg1)>>{>>System.out.println(>'Hi, '>+ arg1);>>Test.main(>'Dear Geek'>,>'My Geek'>);>>}>>>public>static>void>main(String arg1, String arg2)>>{>>System.out.println(>'Hi, '>+ arg1 +>', '>+ arg2);>>}>}>>>ProduzioneHi Geek (from main) Hi, Geek Hi, Dear Geek, My Geek>
Q4. Java supporta l'overloading degli operatori?
Risposta:
A differenza di C++, Java non consente operatori sovraccarichi definiti dall'utente. Internamente Java esegue l'overload degli operatori, ad esempio + viene sovraccaricato per la concatenazione.
Q5. Possiamo sovraccaricare i metodi sul tipo restituito?
Risposta:
Non possiamo sovraccaricare per tipo di ritorno. Questo comportamento è lo stesso in C++. Fare riferimento a questo per i dettagli.
Giava
/*package whatever //do not write package name here */>>import>java.io.*;>>public>class>Main {>>public>int>foo() {>return>10>; }>>>// compiler error: foo() is already defined>>public>char>foo() {>return>'a'>; }>>>public>static>void>main(String args[]) {}>}>>>Errore
./Main.java:8: error: method foo() is already defined in class Main public char foo() { return 'a'; } ^ 1 error>Tuttavia, i metodi di sovraccarico sul tipo restituito sono possibili nei casi in cui il tipo di dati della funzione chiamata è specificato esplicitamente. Guarda gli esempi qui sotto:
Giava
// Java program to demonstrate the working of method>// overloading in static methods>>import>java.io.*;>>public>class>Main {>>>public>static>int>foo(>int>a) {>return>10>; }>>public>static>char>foo(>int>a,>int>b) {>return>'a'>; }>>>public>static>void>main(String args[])>>{>>System.out.println(foo(>1>));>>System.out.println(foo(>1>,>2>));>>}>}>>>Produzione10 a>Giava
// Java program to demonstrate working of method>// overloading in methods>class>A {>>public>int>foo(>int>a) {>return>10>; }>>>public>char>foo(>int>a,>int>b) {>return>'a'>; }>}>>public>class>Main {>>>public>static>void>main(String args[])>>{>>A a =>new>A();>>System.out.println(a.foo(>1>));>>System.out.println(a.foo(>1>,>2>));>>}>}>>>Produzione10 a>
Q6. Qual è la differenza tra sovraccarico e override?
Risposta:
Il sovraccarico riguarda la stessa funzione con firme diverse. Preponderante riguarda la stessa funzione e la stessa firma ma classi diverse collegate tramite ereditarietà.
L'overloading è un esempio di polimorfismo in fase di compilazione e l'override è un esempio di polimorfismo in fase di esecuzione.
articoli Correlati
- Diversi modi di sovraccarico dei metodi in Java
- Sovraccarico del metodo ed errore nullo in Java
- Possiamo sovraccaricare o sovrascrivere metodi statici in Java?