what is inheritance java tutorial with examples
En aquest tutorial s’explica el concepte d’herència a Java, termes relacionats com ara paraules ‘extends’ i ‘super’, subclasse, superclasse, relacions Is-A, HAS-A, etc.:
Després d’aprendre sobre els tres pilars de la POO, és a dir, l’abstracció, l’encapsulació i el polimorfisme a Java, arribem a l’últim pilar de la POO, és a dir, l’herència.
Començant per aquest tutorial, parlarem de l'herència a Java en el següent parell de tutorials.
=> Llegiu la sèrie Easy Training Java.
Què aprendreu:
Herència a Java
L'herència a Java es pot definir com una tècnica o procés en què un objecte d'una classe adquireix el comportament i les propietats d'un altre objecte. Això es fa heretant la classe o establint una relació entre dues classes.
Per exemple, una granota és un amfibi. Igual que altres animals de la classe dels amfibis, la granota pot tenir moltes característiques que són comunes a altres animals. Per tant, aquí un amfibi és una espècie i els animals com les granotes són els seus membres.
Si hem de representar les espècies d’amfibis i els seus membres en una representació de programari mitjançant OOP, el que farem és desenvolupar una classe “Amfibi” que contingui propietats o comportaments comuns als amfibis en general.
D’aquesta manera no hem de duplicar les propietats i el comportament comuns de cada animal amfibi que descrivim. Crearem directament una classe cadascuna per als animals amfibis i heretem de la classe dels amfibis com es mostra a continuació.
Per tant, una idea general darrere de la característica 'Herència' és que podem crear classes noves heretant de les classes ja existents. En heretar de les classes ja existents, podem utilitzar les propietats i el comportament d’aquestes classes. A més, podem afegir més propietats i / o comportament a la nostra nova classe.
La funció d’herència representa un “ pare-fill ”Connexió o relació a Java. La classe de la qual s’hereta la nova classe s’anomena “ Classe pare ”Mentre que la nova classe s’anomena“ Classe infantil '.
L’herència s’utilitza principalment:
- Per a substitució del mètode perquè puguem aconseguir-ho polimorfisme en temps d'execució .
- Per a torneu a utilitzar el codi . Heretant de les classes ja existents, ens assegurem reutilització de codi.
Terminologia comuna utilitzada en herència
- Reutilització: Mecanisme pel qual les noves classes reutilitzen camps o propietats i mètodes d'una classe existent.
- Classe: Una classe és una col·lecció d'objectes que tenen propietats comunes. Una classe es pot veure com una plantilla o una impressió blava per als objectes.
- Subclasse / Classe infantil: Una classe que hereta d’una altra classe és una subclasse o una classe secundària o una classe derivada.
- Super Class / Class Parent: Una classe que és heretada per una altra classe per adquirir propietats i mètodes s’anomena classe o superclasse pare o classe base.
La següent jerarquia d'herències és un exemple que mostra una superclasse i una subclasse.
Tenim una classe d'empleats amb els camps OrganisationName i EmployeeId. També pot tenir altres camps com ara el nom de l’empleat, el departament i altres detalls dels empleats.
A continuació, obtenim una altra classe anomenada ‘SoftwareDeveloper” amb el sou i els avantatges del camp. La classe SoftwareDeveloper hereta de la classe Employee i, per tant, també adquireix les propietats de la classe Employee.
Com es mostra al diagrama anterior, aquí la classe Employee és una classe Super o Base i SoftwareDeveloper és una subclassa o classe derivada.
Paraula clau 'estén' a Java
A Java, la paraula clau ‘extends’ s’utilitza per heretar la classe.
A continuació es mostra la sintaxi general de l’herència de Java:
class SubClass extends SuperClass { //subclass methods and fields }Com es mostra més amunt, la paraula clau 'extends' apareix després del nom de classe a la sintaxi de la declaració de classe.
La paraula clau 'estén' transmet que estem creant una nova classe 'SubClass' que heretarà les propietats i el comportament de 'SuperClass'. En altres paraules, la paraula clau extends indica que estem construint una nova classe SubClass sobre la funcionalitat existent de la SuperClass.
L'herència implementada amb la paraula clau 'extends' és l'herència de classe. Al següent tutorial, parlarem d’una altra paraula clau “implementos” amb la qual podem heretar interfícies.
Un exemple de la classe Employee-SoftwareDeveloper que hem explicat anteriorment es pot representar com:
class Employee{ String OrganizationName; int EmployeeId; } class SoftwareDeveloper extends Employee{ float Salary; float Perks; } Relació IS-A I TÉ-A
Penseu en la següent estructura de classes:
class Mammal{ } class Cow extends Mammal{ }Llavors, com podem interpretar l’estructura anterior? A mesura que la classe de les vaques s’estén o hereta els mamífers, podem dir “Vaca ÉS UN Mamífer ”o“ Vaca ÉS UNA MENA DE Mamífer ”. Per tant, sempre que expressem aquestes relacions, aquesta relació particular és la relació 'IS_A'.
A l’estructura anterior, hem utilitzat la jerarquia de l’herència per expressar el fet que un tipus és d’un altre tipus. Per tant, a l’estructura anterior hem utilitzat una herència per indicar la relació entre la vaca i el mamífer.
De la mateixa manera, podem expressar algunes relacions IS-A més de la següent manera:
A continuació es detallen alguns dels exemples habituals de relacions que podem expressar mitjançant l'herència a Java.
En general, el tipus de relacions IS-A es pot expressar mitjançant l'herència.
Vegem ara l'exemple següent:
Al diagrama anterior, veiem que es mostra que un vehicle té dues parts, és a dir, motor i fre. Llavors, com podem posar aquest escenari en paraules?
Podem dir que “un vehicle conté un motor i un vehicle conté un fre ”.
Per tant, el que expressem aquí no és la relació 'IS-A', sinó una relació de contenció en què especifiquem un objecte com a part d'un altre objecte.
java array elimina l'element a l'índex
A l'exemple anterior, un motor és un part del vehicle. No és un “ tipus de ”Vehicle. Aquest és el ' TÉ ”O relació de contenció o composició a Java. La relació Has-a a Java s’expressa mitjançant la inclusió d’un objecte com a membre de la classe.
Per tant, si seguim el mateix exemple de vehicle anterior, el podem expressar de la manera següent:
class Engine{ } class Brake { } class Vehicle{ Engine e; Brake b; } Per tant, un vehicle té motor i fre. En expressar la relació de la manera anterior, no ens interessa la implementació interna del motor ni del fre. La classe de vehicles farà saber a les classes de Engine i Brake el que cal i aquestes classes ho proporcionaran.
Igual que la relació IS-A, la relació HAS-A també és útil per reutilitzar el codi.
En aquest tutorial, parlarem detalladament de l’herència (IS-A) i, en el següent tutorial, parlarem de Contenció o Composició (HAS-A).
Exemple d’herència de Java
Implantem un exemple senzill a Java per demostrar l’herència.
//example class demonstrating Inheritance in Java class BaseClass { public void display() { System.out.println('BaseClass::Display'); } } //create a new class from BaseClass class DerivedClass extends BaseClass { public void print() { System.out.println('DerivedClass::print'); } } class Main { public static void main(String() args) { //create an object of DerivedClass DerivedClass d1 = new DerivedClass(); d1.display(); //call BaseClass method d1.print(); //call DerivedClass method } }Sortida:
El programa anterior mostra un exemple senzill d’herència. Es declara una BaseClass amb un mètode. A continuació, es declara una altra classe DerivedClass que estén BaseClass. Aquesta classe també té un mètode.
En el mètode principal del programa, creem un objecte DerivedClass i mitjançant aquest objecte anomenem el mètode BaseClass i també el mètode DerivedClass.
La sortida mostra els missatges impresos pels dos mètodes. Com DerivedClass amplia el BaseClass i el mètode BaseClass és públic, és visible per a DerivedClass.
Paraula clau 'súper' a Java
A Herència, ens ocupem de superclasses o classes de pares i classes infantils. Si hem d’accedir de manera intermèdia a membres de superclasses, incloses variables, mètodes o constructors, haurem de tenir algun mecanisme. Aquest mecanisme d'accés als membres de la classe base es proporciona a Java mitjançant una paraula clau 'súper'.
Llavors, en quins escenaris fem servir la paraula clau 'super' a Java?
A continuació, es detallen escenaris en què una paraula clau 'súper' pot ser útil.
- Quan la classe super / base i la classe sub / derivada tenen els mateixos noms per als membres i volem accedir als membres de la superclasse, fem servir la paraula clau super.
- Quan volem accedir al constructor de superclasse des de la subclasse, fem servir la paraula clau super per invocar la paraula clau de superclasse.
A la figura anterior, hem mostrat una estructura d’herència. A la classe base i derivada, tenim una variable String myStr. A la classe derivada, tenim una funció printStr (). En aquest mètode, hem utilitzat la paraula clau 'super' per accedir a la variable myStr des de la classe base.
A la figura, hem mostrat les fletxes que assenyalen la variable membre de la classe base i la variable de classe derivada.
Vegem ara els exemples de programació de l’ús de la paraula clau super per accedir a diversos membres de la superclasse.
# 1) Variable de membre d’accés a la superclassa
El següent programa Java demostra l’ús d’una paraula clau ‘super’ per accedir a variables de la classe base.
class Baseclass { String myStr; } class Subclass extends Baseclass { String myStr; public void printdetails() //Baseclass and Subclass have variables with same name { super.myStr = 'Super'; //refers to parent class member myStr = 'Sub'; System.out.println('Superclass myStr :' + super.myStr+' and Subclass myStr:'+myStr); } } class Main{ public static void main(String() args) { Subclass cobj = new Subclass(); cobj. printdetails (); } } Sortida:
El programa anterior mostra com accedir a les variables membres de la classe base des de la classe derivada quan les variables membres es declaren amb el mateix nom tant a la base com a la classe derivada.
Aquí tenim la variable myStr que es declara tant a la base com a la classe derivada. En el mètode printdetails, ens referim a la variable myStr de la classe base mitjançant “super.myStr”, mentre que la variable de classe derivada myStr s’accedeix directament sense cap qualificador.
# 2) Accediu al mètode de superclasse
A continuació, veurem com anomenar el mètode de la classe base quan el mètode de la classe base i el mètode de la classe derivada tenen els mateixos noms.
El programa següent ho demostra.
class Parent { String myStr; public void print() //parent class method { myStr = 'Parent class myStr'; System.out.println(myStr); } } class Child extends Parent { String myStr; public void print() //child class method with same name as parent { super.print(); //call Parent class print() method myStr = 'Child class myStr'; System.out.println(myStr); } } class Main{ public static void main(String() args) { Child c_obj = new Child(); c_obj.print (); } } Sortida:
# 3) Constructor d'accés a la superclasse
Quan heretem una classe d'una altra, tingueu en compte que els constructors no s'hereten.
Si volem executar qualsevol instrucció dels constructors de superclasse abans d’executar el constructor de classes derivades, també podem trucar al constructor de superclasse mitjançant la paraula clau ‘super’.
Per trucar al constructor de superclasse fem servir el mètode call.
super (llista de paràmetres ...)
El següent mètode demostra l'accés a super constructors a Java.
class Parent { String myStr; public Parent(String name) //base class constructor { myStr = name; } } class Child extends Parent { String myStr; public Child(String name1, String name2) { super(name1); //call base class constructor and pass argument value this.myStr = name2; } public void printDetails() //print details of both constructors { System.out.println('From base class constructor: ' +super.myStr); System.out.println('From derived class constructor: ' + myStr); } } class Main{ public static void main(String() args) { Child cobj = new Child('Super constructor string','Child constructor string'); cobj.printDetails(); } }Sortida:
Com podem veure al programa anterior, hem anomenat el constructor de la superclasse del constructor de classes derivades. Tingueu en compte que per convenció, sempre que vulguem accedir al constructor de superclasse, hauria de ser la primera sentència del constructor de la classe derivada.
Com que la classe base té un constructor parametritzat, també passem el paràmetre adequat a la super trucada mentre cridem al constructor.
Si no es fa cap crida explícita al súper constructor com s'ha indicat anteriorment, el compilador sempre afegeix automàticament una trucada implícita a super (). Tingueu en compte que aquesta serà una trucada al constructor per defecte de la superclasse.
Preguntes freqüents
P # 1) Què és l’herència a Java?
Resposta: Un procés mitjançant el qual una classe adquireix les propietats i el comportament d’una altra classe s’anomena herència. A Java, una classe l’hereta una altra amb la paraula clau ‘extends’.
com eliminar un element de la matriu a Java amb exemple
L’herència afavoreix la reutilització del codi, ja que heretant podem adquirir i utilitzar les propietats i el comportament ja existents d’una classe heretada sense haver d’escriure codi duplicat.
Q # 2) Per què s’utilitza l’herència a Java?
Resposta: L’herència s’utilitza principalment per millorar la reutilització de l’aplicació. Mitjançant l’herència podem utilitzar classes preparades a la nostra aplicació. No hem d’escriure el nostre codi si tenim la funcionalitat a punt.
El segon ús de l'herència és la substitució del mètode. Per implementar el polimorfisme en temps d'execució fem ús de l'herència.
P # 3) Quins avantatges té l’herència?
Resposta: La reutilització és l’avantatge clau de l’herència. Compartir codi mitjançant l’herència també resulta en una millor llegibilitat i una millor organització del codi.
També podem aconseguir polimorfisme en temps d’execució mitjançant la substitució de mètodes mitjançant l’herència.
Q # 4) Quines són les característiques de l'herència?
Resposta: Qualsevol característica o característica adquirida de la generació anterior es fa mitjançant l'herència. Per exemple, el tret d’ull clar que es dóna en moltes famílies és un exemple d’herència.
Des del punt de vista de la programació, l’herència proporciona la característica de reutilització i substitució de mètodes.
P # 5) És necessari super ()?
Resposta: No, perquè si no anomenem super (), el compilador ho fa implícitament per nosaltres. Però la invocació implícita de super () és el constructor de classes base per defecte. Per tant, si necessitem un constructor parametritzat d’una classe base, l’hauríem de dir explícitament.
Conclusió
En aquest tutorial, hem introduït el concepte d’herència a Java. L’herència és el procés d’adquisició de les propietats i el comportament d’una classe d’una altra classe. Aquí hem comentat la definició i la terminologia bàsiques que fem servir en herència.
També hem debatut sobre les relacions Is-A i Has-A a Java. L’herència s’utilitza per implementar una relació Is-A.
A continuació, vam parlar de les paraules clau 'estén' i 'súper' a Java que s'utilitzen en relació amb l'herència. Extends s’utilitza per implementar l’herència. La paraula clau super s’utilitza per referir-se al constructor, mètode o variable de la classe base de la classe derivada.
=> Consulteu la guia de formació Java perfecta aquí.
Lectura recomanada
- Tutorial de classe Java Scanner amb exemples
- Què és Java Vector | Tutorial de Java Vector Class amb exemples
- Java Enum: Tutorial d’enumeració de Java amb exemples
- Java String length () Mètode amb exemples
- Tutorial Java Float amb exemples de programació
- Herència a C ++
- Tipus d’herència en C ++
- Conceptes OOP de Python (classes, objectes i herència de Python)