Sovraccarico e override di Java

Diciamo sempre che l’overloading del metodo è un polimorfismo statico e l’override è il polimorfismo di runtime. Cosa intendiamo esattamente per statico qui? La chiamata a un metodo è stata risolta durante la compilazione del codice? Quindi, qual è la differenza tra la normale chiamata al metodo e la chiamata a un metodo finale? Quale è collegato al momento della compilazione?

Sovraccarico di metodi significa eseguire più versioni di una funzione in base agli input. Per esempio:

public Double doSomething(Double x) { ... } public Object doSomething(Object y) { ... } 

La scelta del metodo da chiamare viene effettuata in fase di compilazione. Per esempio:

 Double obj1 = new Double(); doSomething(obj1); // calls the Double version Object obj2 = new Object(); doSomething(obj2); // calls the Object version Object obj3 = new Double(); doSomething(obj3); // calls the Object version because the compilers see the // type as Object // This makes more sense when you consider something like public void myMethod(Object o) { doSomething(o); } myMethod(new Double(5)); // inside the call to myMethod, it sees only that it has an Object // it can't tell that it's a Double at compile time 

Metodo Overriding significa definire una nuova versione del metodo da una sottoclass dell’originale

 class Parent { public void myMethod() { ... } } class Child extends Parent { @Override public void myMethod() { ... } } Parent p = new Parent(); p.myMethod(); // calls Parent's myMethod Child c = new Child(); c.myMethod(); // calls Child's myMethod Parent pc = new Child(); pc.myMethod(); // call's Child's myMethod because the type is checked at runtime // rather than compile time 

Spero che aiuti

Hai ragione – le chiamate a metodi sovraccaricati sono realizzate in fase di compilazione. Ecco perché è statico .

Le chiamate ai metodi sovrascritti vengono realizzate in fase di esecuzione, in base al tipo su cui viene invocato il metodo.

Sui metodi virtuali wikipedia dice:

In Java, tutti i metodi non statici sono per impostazione predefinita “funzioni virtuali”. Solo i metodi contrassegnati con la parola chiave final non sono virtuali.

final metodi final non possono essere sovrascritti, quindi vengono realizzati staticamente.

Immagina il metodo:

 public String analyze(Interface i) { i.analyze(); return i.getAnalysisDetails(); } 

Il compilatore non può sovraccaricare questo metodo per tutte le implementazioni di Interface che possono essere passate ad esso.

Non penso che tu possa chiamare un sovraccarico di alcun genere di polimorfismo. I metodi di overload sono collegati in fase di compilazione, il che preclude a chiamarlo polimorfismo.

Il polimorfismo fa riferimento al legame dinamico di un metodo alla sua chiamata quando si utilizza un riferimento di class base per un object class derivato. L’override dei metodi è il modo in cui si implementa questo comportamento polimorfico.

1) Il sovraccarico del metodo viene utilizzato per aumentare la leggibilità del programma. L’override del metodo viene utilizzato per fornire l’implementazione specifica del metodo che è già fornito dalla sua super class.

2) Il sovraccarico del metodo viene eseguito all’interno della class. L’override del metodo si verifica in due classi che hanno una relazione IS-A (ereditarietà).

3) In caso di sovraccarico del metodo, il parametro deve essere diverso. In caso di override del metodo, i parametri devono essere uguali.

4) Il sovraccarico del metodo è l’esempio del polimorfismo del tempo di compilazione. L’override del metodo è l’esempio del polimorfismo del tempo di esecuzione.

5) In java, l’overloading dei metodi non può essere eseguito cambiando solo il tipo di ritorno del metodo. Il tipo di reso può essere uguale o diverso nell’overload del metodo. Ma è necessario modificare il parametro. Il tipo di restituzione deve essere uguale o covariante nel metodo di sovrascrittura.

Sono d’accordo con Rachel, perché nel libro K & B viene direttamente menzionato che l’ overloading non appartiene al polimorfismo nel capitolo 2 (orientamento all’object). Ma in molti posti ho scoperto che sovraccaricare significa polimorfismo statico perché è tempo di compilazione e override significa polimorfismo dinamico perché è tempo di esecuzione.

Ma una cosa interessante è in un libro in C ++ (Object-Oriented Programming in C ++ – Robert Lafore), inoltre viene direttamente menzionato che il sovraccarico significa polimorfismo statico. Ma un’altra cosa è che java e c ++ sono entrambi due linguaggi di programmazione differenti e hanno diverse tecniche di manipolazione degli oggetti, quindi il polimorfismo può essere diverso in c ++ e java?

Il metodo Overloading significa semplicemente fornire due metodi separati in una class con lo stesso nome ma argomenti diversi mentre il metodo return type può o non può essere differente, il che ci consente di riutilizzare lo stesso nome del metodo.

Ma entrambi i metodi sono diversi, quindi possono essere risolti dal compilatore in fase di compilazione, motivo per cui è noto anche come polimorfismo del tempo di compilazione o polimorfismo statico

Il metodo Override significa definire un metodo nella class figlio che è già definito nella class genitore con la stessa firma del metodo, vale a dire stesso nome, argomenti e tipo di ritorno.

 Mammal mammal = new Cat(); System.out.println(mammal.speak()); 

Alla riga il compilatore mammal.speak() dice che viene chiamato il metodo speak() del tipo di riferimento Mammal , quindi per il compilatore questa chiamata è Mammal.speak() .

Ma al momento dell’esecuzione, JVM sa chiaramente che il riferimento dei mammal sta tenendo il riferimento dell’object di Cat , quindi per JVM questa chiamata è Cat.speak() .

Poiché la chiamata al metodo viene risolta in fase di esecuzione da JVM è per questo motivo che è nota anche come Polymorphism di runtime e Dispatch di metodi dinamici .

Differenza tra metodo Sovraccarico e metodo Ignora

Differenza tra metodo Sovraccarico e metodo Ignora

Per maggiori dettagli, puoi leggere Tutto su Metodo Sovraccarico Metodo Override .

Definizione semplice – L’overloading del metodo riguarda la nozione di avere due o più metodi (funzioni) nella stessa class con lo stesso nome ma argomenti diversi.

Mentre il metodo override significa avere due metodi con gli stessi argomenti, ma una diversa implementazione. Uno di essi sarebbe presente nella class Parent (Base Class) mentre un altro sarà nella class derivata (Child Class). Per questo è necessaria l’annotazione Override.

Verifica questo: fai clic qui per un esempio dettagliato

Overriding del sovraccarico di proprietà

I nomi dei metodi ————–> devono essere uguali —————- devono essere uguali

Tipi di argomenti ——————> devono essere diversi (almeno arg)

Metodo Signature

Tipo di reso

Privato, statico, Finale

Modificatore d’accesso

prova a prendere

Risoluzione del metodo

L’overloading del metodo si basa sulla nozione di avere due o più metodi nella stessa class con lo stesso nome ma argomenti diversi.

L’override del metodo significa avere due metodi con gli stessi argomenti, ma diverse implementazioni. Uno di essi esisterebbe nella class genitore, mentre un altro sarà nella class derivata o child. L’annotazione @ Override, sebbene non richiesta, può essere utile per forzare l’override corretto di un metodo in fase di compilazione.

Innanzitutto, desidero discutere del polimorfismo run-time / dinamico e del polimorfismo statico / tempo di compilazione.

Polimorfismo statico / tempo di compilazione: – come suggerisce il nome, associa la chiamata alla funzione appropriata al momento della compilazione. Ciò significa che il compilatore sa esattamente quale chiamata di funzione è associata a quale funzione. L’overloading delle funzioni è un esempio di polimorfismo del tempo di compilazione.

Polimorfismo dinamico / run-time: -In questo tipo di compilatore di polimorfismo non si conoscono le funzioni che chiamano associati a quale funzione fino all’esecuzione del programma. Per esempio. funzione prioritaria.

ORA, quali sono le funzioni prioritarie e l’overloading delle funzioni ???

Sovraccarico delle funzioni: – stesso nome della funzione ma firma / parametro della funzione diversa.

 eg. Area(no. of parameter) { ------------- ---------------- return area;} area of square requires only one parameter area of rectangle requires two parameters(Length and breadth) 

funzione sovrascritta: – modifica il lavoro di una funzione presente sia nella class Superclass che nella class Bambino. per esempio. nome () nella superclass stampa “ciao Rahul” ma dopo aver sovrascritto in class figlio stampa “ciao Akshit”