java override method overriding
Aquest tutorial explica com s'aconsegueix el polimorfisme en temps d'execució a Java mitjançant Method Overriding i @override anotació amb exemples senzills:
Ja hem comentat en detall el concepte de polimorfisme i el polimorfisme en temps de compilació. En aquest tutorial, continuarem amb el polimorfisme d'execució a Java.
A diferència del polimorfisme en temps de compilació en què es resol la trucada de mètode en temps de compilació, en polimorfisme en temps d'execució, la trucada de mètode es resol en temps d'execució.
=> Consulteu TOTS els tutorials de Java aquí.
Què aprendreu:
- Polimorfisme en temps d'execució a Java
- Anotació @override a Java
- Sobrecàrrega i anul·lació a Java
- Conclusió
Polimorfisme en temps d'execució a Java
Un polimorfisme en temps d'execució que també es coneix com polimorfisme dinàmic o bé Enviament de mètode dinàmic és un tècnica en què es resol dinàmicament una trucada de mètode anul·lada en temps d'execució.
El polimorfisme en temps d'execució a Java s'aconsegueix utilitzant ' substitució del mètode ”. La substitució del mètode és una tècnica mitjançant la qual es redefineix o anul·la un mètode de la classe pare a la classe infantil.
Quan el mètode s’anul·la en una classe, la tècnica d’enviament del mètode dinàmic resol la trucada al mètode anul·lat en temps d’execució i no en temps de compilació.
Assolir el polimorfisme en temps d'execució a Java: substitució del mètode
La substitució del mètode és l'enfocament que fem servir per aconseguir el polimorfisme en temps d'execució a Java. Com ja s'ha esmentat, la substitució de mètodes és una tècnica en la qual la subclasse afegeix un mètode que ja està present a la seva classe pare i afegeix una nova funcionalitat a aquest mètode. Aleshores diem que el mètode de la classe base és anul·lat.
El nou mètode que vam definir a la subclasse amb el mateix prototip que el mètode de la classe pare, però la implementació diferent s’anomena “ mètode primordial ” . El mètode de la classe pare es coneix com ' Mètode anul·lat '.
millors aplicacions de vr per a VR box
Un cop anul·lat el mètode, queda la pregunta de com es resol la trucada a aquest mètode anul·lat?
Normalment anomenem el mètode anul·lat mitjançant la referència de la classe base. Crearem una referència de tipus base i, a continuació, assignarem un objecte de classe fill amb la nova paraula clau.
Per tant, depèn del contingut de la variable de referència o de quin objecte fa referència la referència de classe base que determina quin mètode s'ha de cridar. Per tant, si els objectes de referència apunten a l’objecte de la classe fill, s’anomena mètode de substitució.
En cas contrari, si l'objecte de referència conté un objecte de classe base, es crida al mètode anul·lat. Un tema que hem de tenir clar en el polimorfisme en temps d'execució, especialment per a l'enviament de mètodes dinàmics, és el 'Upcasting', que s'explica a continuació.
Upcasting
Quan un objecte de referència de la classe pare que hem comentat anteriorment apunta o fa referència a l’objecte de la subclasse, l’anomenem Upcasting.
Anem a entendre el desencadenant amb un exemple senzill.
Penseu que tenim una classe 'BaseClass' i ampliem aquesta BaseClass per crear una nova classe DerivedClass. Aquesta estructura es veu com es mostra a continuació.
class BaseClass { ….//BaseClass code here } class DerivedClass extends BaseClass{ ….//DerivedClass code here }Ara per implementar l'ascensió, declararem una variable de referència del tipus BaseClass. A continuació, assignem un objecte de DerivedClass a la referència de la classe BaseClass tal com es fa a la sentència de codi següent.
BaseClass base = new DerivedClass (); //UpcastingAixí doncs, aquí podem dir que hem elevat l'objecte DerivedClass a BaseClass. Pel que fa al polimorfisme en temps d'execució, el concepte d'ascensió ascendent és molt important.
Per tant, en general, l'ascensió ascendent és el procés d'assignació d'objectes secundaris o secundaris a la referència d'un pare o superclasse.
SuperClass reference = new Subclass Object;El programa Java que es mostra a continuació mostra la substitució del mètode i també mostra com es realitza l'ascensió per resoldre les trucades de mètodes anul·lats en temps d'execució.
//base/parent class class Parent { void Print() //print method { System.out.println('Parent::Print() method'); } } //child class 1 inheriting from Parent class child1 extends Parent { void Print() //overridden print method { System.out.println('child1::Print() method'); } } //child class 2 inheriting from Parent class child2 extends Parent { void Print() //overridden print method { System.out.println('child2::Print() method'); } } class Main { public static void main(String() args) { Parent parent = new Parent(); parent.Print(); //executes parent Print () method parent = new child1(); //upcasting parent.Print(); //executes child1 Print () method parent = new child2(); //upcasting parent.Print(); //executes child2 Print () method Sortida:
Al programa anterior, tenim dues classes, és a dir, child1 i child2, que deriven d’una classe ‘Parent’. La classe pare té un mètode 'Imprimeix' que s'anul·la a les classes child1 i child2. A continuació, al mètode principal, creem un objecte de referència de la classe pare anomenat 'pare'.
Primer, li assignem un objecte de la classe pare i, a continuació, anomenem el mètode “Print ()”. Després ho repetim assignant primer l’objecte child1 i després l’objecte child2 a la referència pare.
etl tester entrevistes a preguntes i respostes
La sortida es mostra, en funció del contingut de la referència pare, i es diu el mètode d’impressió adequat.
Avantatges del polimorfisme dinàmic / en temps d'execució
- Amb el polimorfisme dinàmic, el programador pot anul·lar mètodes.
- Permet a les classes definir un mètode amb implementació general que els seus derivats poden substituir i proporcionar la implementació específica.
- Amb l'enviament de mètodes dinàmics, la trucada al mètode es resol en temps d'execució, a diferència de la sobrecàrrega que es decideix en el moment de la compilació. Això permet una major flexibilitat per als programadors.
Com que el polimorfisme en temps d'execució uneix el mètode adequat a la trucada en temps d'execució i també l'anomenem unió dinàmica o unió tardana . El polimorfisme en temps de compilació, en canvi, és compatible unió estàtica o unió primerenca .
Enquadernació estàtica vs. dinàmica
| Unió estàtica | Enquadernació dinàmica |
|---|---|
| La trucada al mètode resolt en el moment de la compilació és un enllaç estàtic. | La trucada de mètode resolta en temps d'execució és la vinculació dinàmica. |
| La sobrecàrrega del mètode és un exemple d’unió estàtica. | La substitució del mètode és un exemple d’enllaç dinàmic. |
| Els tipus de classes i camps s’utilitzen per a l’enllaç estàtic. | Els objectes s’utilitzen per a l’enllaç dinàmic. |
| Les entitats privades, finals i estàtiques utilitzen la vinculació estàtica. | Els mètodes virtuals utilitzen un enllaç dinàmic. |
Funció / mètode virtual a Java
La funció o mètode virtual a Java és una característica que s’utilitza amb el polimorfisme d’execució. A diferència de C ++, Java no té cap paraula clau 'virtual' especial per indicar que un mètode és virtual. Un mètode que es defineix a la classe base i que es substitueix a la classe derivada és virtual.
A Java, per defecte, tots els mètodes no estàtics, excepte el privat i el final, són una funció virtual. Tingueu en compte que els mètodes que hem comentat anteriorment per implementar el polimorfisme en temps d'execució també són mètodes virtuals.
Com que el mètode estàtic està lligat a Class i no es pot anomenar mitjançant un objecte, no es pot utilitzar amb polimorfisme en temps d'execució i tampoc no és una funció virtual.
Les interfícies a Java són virtuals per defecte. Les classes que implementen interfícies proporcionen implementacions per als mètodes d'interfície. Igual que al polimorfisme en temps d'execució, els mètodes de crida a la interfície també es resolen en temps d'execució.
Recordeu que, atès que els mètodes d'una interfície estan dissenyats per anul·lar-se, tots els mètodes d'interfície són funcions virtuals.
Per exemple, tingueu en compte el codi següent:
interface car{ void accelerate(); } class Maruti implements car{ void accelerate () { System.out.println(“Maruti car accelerated!!”); } }Al codi anterior, el mètode accelerate () és una funció virtual ja que forma part del cotxe de la interfície i està dissenyat per anul·lar-se.
Anotació @override a Java
L'anotació @override és l'anotació predeterminada a Java. Aquesta anotació es va introduir a Java 1.5. L'anotació @override s'utilitza quan el mètode de subclasse substitueix el seu mètode de superclasse.
En utilitzar l’anotació Java @override per indicar que el mètode substitueix el seu mètode de classe pare, un compilador emet un avís si el mètode anotat no s’anula. Per tant, fa obligatori que el mètode s’anul·li quan s’utilitza l’anotació @override.
En segon lloc, mitjançant l’anotació @override fem que el codi sigui més llegible. Podem adonar-nos alhora que s’ha d’anul·lar el mètode que es declara.
La sintaxi general de l’anotació Java @override és
public @interface override El programa Java següent mostra l’ús de l’anotació @override.
//base class definition class BaseClass { public void display() { System.out.println('BaseClass::display () method'); } } //derived class inheriting base class class DerivedClass extends BaseClass { @Override //indicates the display method being overridden public void display() { System.out.println('DerivedClass::display () method'); } } // main class public class Main { public static void main(String args()) { System.out.println('@Override Example'); //BaseClass type object;contain child object BaseClass testObj = new DerivedClass(); //call display method based on contents of object i.e. derived class display () testObj.display(); } } Sortida:
Al programa anterior, tenim una BaseClass que defineix un mètode de visualització. A continuació, obtenim una classe DerivedClass d’aquesta BaseClass i marquem el mètode de visualització amb l’anotació @override. Aquest mètode es substitueix a DerivedClass.
Al mètode principal, creem una referència d’objecte BaseClass i l’assenyalem a l’objecte DerivedClass que fa que la referència cridi al mètode de visualització DerivedClass.
Si no haguéssim implementat el mètode display () a la classe Derived, el compilador hauria donat un avís del compilador ja que està marcat amb l’anotació @override.
Sobrecàrrega i anul·lació a Java
Ara que ja hem debatut sobre la sobrecàrrega i la substitució a Java, resumim aquests dos conceptes.
La sobrecàrrega està relacionada amb el polimorfisme en temps de compilació, és a dir, implementem el polimorfisme en temps de compilació mitjançant la sobrecàrrega. La sobrecàrrega es fa de dues maneres, és a dir, la sobrecàrrega de mètodes i la sobrecàrrega de l’operador.
La sobrecàrrega de mètodes és la tècnica en què tenim més d’un mètode amb el mateix nom però llistes de paràmetres diferents. La llista de paràmetres es diferencia en funció del nombre de paràmetres, tipus de paràmetres o seqüència de paràmetres.
La sobrecàrrega de l’operador a Java és limitada i ens permet sobrecarregar només l’operador ‘+’ que s’utilitza per afegir dos números i concatenar dos objectes de cadena.
La sobrecàrrega es resol en el moment de la compilació i és estàtica. També es diu 'Enquadernació primerenca' .
La substitució de mètodes és una característica amb la qual implementem el polimorfisme en temps d'execució. En la substitució de mètodes, un mètode de la classe pare es substitueix a la classe fill. Això significa que el prototip de mètode tant en super com en subclasse continua sent el mateix, però les implementacions són diferents.
La substitució del mètode utilitza la tècnica d'enviament de mètode dinàmic per resoldre la crida al mètode i decidir si es crida a un mètode de superclasse o subclasse i això es fa en temps d'execució.
Per tant, el polimorfisme en temps d'execució també s'anomena polimorfisme dinàmic o unió tardana.
A continuació, tabulem les diferències entre la sobrecàrrega i la substitució a Java.
Sobrecàrrega de Vs Sobrescripció a Java
| Sobrecàrrega | Sobresortint |
|---|---|
| La sobrecàrrega s'utilitza en polimorfisme en temps de compilació. | La substitució s’implementa en polimorfisme d’execució. |
| Es pot fer a la mateixa classe. Pot requerir herència o no. | La substitució sempre requereix herència. |
| Els mètodes es sobrecarreguen amb el mateix nom de mètode i una llista de paràmetres diferents. | Els mètodes anul·lats tenen els mateixos prototips. |
| El tipus de retorn no es considera a la sobrecàrrega del mètode. | El tipus de retorn ha de ser el mateix en mètodes anul·lats i anul·lats. |
| Millora la llegibilitat del programa. | La substitució permet tenir una implementació específica a nivell de classe. |
Preguntes freqüents
P # 1) Podem anul·lar el mètode estàtic?
Resposta: No, els mètodes estàtics no es poden anul·lar a Java. Això es deu al fet que els mètodes estàtics es basen en classes i es diuen directament per classe. No necessiten objectes per invocar en temps d'execució. Per tant, l’enviament del mètode estàtic el determina el compilador.
Q # 2) Podem anul·lar el constructor?
Resposta: No, no podem anul·lar un constructor. Es diu un constructor quan es crea l'objecte. No s’anomena objecte. A més, un dels requisits de la substitució és el mètode anul·lat i el mètode d’anul·lació hauria de tenir la mateixa signatura de mètode que no és possible en el cas dels constructors.
Q # 3) Per què s’anomena substitució de mètode com a polimorfisme dinàmic?
Resposta: En el cas de la substitució del mètode, la trucada al mètode es resol dinàmicament en temps d'execució. Per tant, s’anomena polimorfisme dinàmic.
Q # 4) Què utilitza el polimorfisme dinàmic a Java?
utilitzant eclipsi per a c ++
Resposta: El polimorfisme dinàmic utilitza una tècnica d'enviament de mètodes dinàmics que admet la substitució de mètodes de manera que la subclassa pugui proporcionar una implementació específica del mètode anul·lat. D’aquesta manera podem implementar les funcions específiques que ens permeten escriure programes eficients.
En segon lloc, tampoc no ens hem de preocupar de resoldre les trucades de mètodes, ja que l’enviament de mètodes dinàmics decideix a quin mètode trucar.
Q # 5) Quina diferència hi ha entre enquadernació estàtica i dinàmica?
Resposta: L’enllaç entre una crida de mètode i la seva implementació s’anomena vinculant. Quan aquest enllaç es resol en temps de compilació, l'anomenem enllaç estàtic. Quan l'enllaç es realitza de forma dinàmica en temps d'execució, l'anomenem enllaç dinàmic.
La vinculació estàtica utilitza el tipus de dades de classe i camps per resoldre les crides de mètodes. La vinculació dinàmica utilitza objectes per resoldre les crides de mètodes. L’enllaç estàtic també s’anomena polimorfisme en temps de compilació i l’enllaç dinàmic també s’anomena polimorfisme en temps d’execució.
Conclusió
En aquest tutorial, hem parlat detalladament del polimorfisme en temps d'execució a Java.
El polimorfisme en temps d'execució s'implementa mitjançant la substitució del mètode. La substitució del mètode es fa a la subclasse en què un mètode definit a la superclasse es redefineix o anul·la a la seva subclasse. La signatura del mètode continua sent la mateixa a la super i a la subclasse.
Mitjançant l’ús de mètodes de substitució podem proporcionar una implementació específica al mateix mètode de la subclasse. D’aquesta manera, podem escriure programes més eficients que impliquin herència. Java proporciona anotació @override per indicar que s’ha d’anul·lar el mètode.
Per defecte, tots els mètodes no estàtics que no són finals són virtuals a Java. Es poden anul·lar tots els mètodes virtuals.
=> Mireu aquí les sèries de formació Java senzilles.
Lectura recomanada
- Substitució de mètodes predefinits a Java
- Java String length () Mètode amb exemples
- Què és el polimorfisme a Java: tutorial amb exemples
- Com s'utilitza el mètode Java toString?
- Java String indexOf Method amb exemples de codi
- Java String conté () Tutorial de mètode amb exemples
- Mètode Java String Split (): com es pot dividir una cadena a Java
- Mètode Java String compareTo amb exemples de programació