Java, l'herència és un pilar important de la POO (programació orientada a objectes). És el mecanisme de Java pel qual una classe pot heretar les característiques (camps i mètodes) d'una altra classe. A Java, l'herència significa crear noves classes a partir de les existents. Una classe que hereta d'una altra classe pot reutilitzar els mètodes i camps d'aquesta classe. A més, també podeu afegir nous camps i mètodes a la vostra classe actual.

Per què necessitem l'herència de Java?

• Reutilitzabilitat del codi: El codi escrit a la Superclasse és comú a totes les subclasses. Les classes infantils poden utilitzar directament el codi de classe pare.
• Anulació del mètode: Anulació del mètode només es pot aconseguir a través de l'herència. És una de les maneres en què Java aconsegueix el polimorfisme en temps d'execució.
• Abstracció: El concepte d'abstracte on no hem d'aportar tots els detalls s'aconsegueix a través de l'herència. Abstracció només mostra la funcionalitat a l'usuari.

Terminologies importants utilitzades en l'herència de Java

• Classe: La classe és un conjunt d'objectes que comparteixen característiques/comportament i propietats/atributs comuns. La classe no és una entitat del món real. És només una plantilla o plànol o prototip a partir del qual es creen objectes.
• Súper classe/classe de pares: La classe les característiques de la qual s'hereten es coneix com a superclasse (o classe base o classe pare).
• Subclasse/classe infantil: La classe que hereta l'altra classe es coneix com a subclasse (o classe derivada, classe estesa o classe secundària). La subclasse pot afegir els seus propis camps i mètodes a més dels camps i mètodes de la superclasse.
• Reutilitzabilitat: L'herència admet el concepte de reutilitzabilitat, és a dir, quan volem crear una nova classe i ja hi ha una classe que inclou part del codi que volem, podem derivar la nostra nova classe de la classe existent. En fer això, estem reutilitzant els camps i mètodes de la classe existent.

Com utilitzar l'herència a Java?

El amplia la paraula clau s'utilitza per a l'herència a Java. L'ús de la paraula clau extends indica que es deriva d'una classe existent. En altres paraules, amplia es refereix a una funcionalitat augmentada.

creació de taules d'oracle

Sintaxi:

class DerivedClass extends BaseClass  {   //methods and fields  }>

Herència en Java Exemple

Exemple: A l'exemple següent d'herència, la classe Bicycle és una classe base, la classe MountainBike és una classe derivada que amplia la classe Bicycle i la classe Test és una classe de conductor per executar el programa.

// Java program to illustrate the // concept of inheritance // base class class Bicycle {  // the Bicycle class has two fields  public int gear;  public int speed;  // the Bicycle class has one constructor  public Bicycle(int gear, int speed)  {  this.gear = gear;  this.speed = speed;  }  // the Bicycle class has three methods  public void applyBrake(int decrement)  {  speed -= decrement;  }  public void speedUp(int increment)  {  speed += increment;  }  // toString() method to print info of Bicycle  public String toString()  {  return ('No of gears are ' + gear + '
'  + 'speed of bicycle is ' + speed);  } } // derived class class MountainBike extends Bicycle {  // the MountainBike subclass adds one more field  public int seatHeight;  // the MountainBike subclass has one constructor  public MountainBike(int gear, int speed,  int startHeight)  {  // invoking base-class(Bicycle) constructor  super(gear, speed);  seatHeight = startHeight;  }  // the MountainBike subclass adds one more method  public void setHeight(int newValue)  {  seatHeight = newValue;  }  // overriding toString() method  // of Bicycle to print more info  @Override public String toString()  {  return (super.toString() + '
seat height is '  + seatHeight);  } } // driver class public class Test {  public static void main(String args[])  {  MountainBike mb = new MountainBike(3, 100, 25);  System.out.println(mb.toString());  } }>

No of gears are 3 speed of bicycle is 100 seat height is 25>

Al programa anterior, quan es crea un objecte de la classe MountainBike, una còpia de tots els mètodes i camps de la superclasse adquireix memòria en aquest objecte. És per això que utilitzant l'objecte de la subclasse també podem accedir als membres d'una superclasse.

Tingueu en compte que durant l'herència només es crea l'objecte de la subclasse, no la superclasse. Per a més informació, consulteu Creació d'objectes Java de classe heretada .

Exemple 2: A l'exemple següent d'herència, la classe Employee és una classe base, la classe Engineer és una classe derivada que amplia la classe Employee i la classe Test és una classe de controlador per executar el programa.

// Java Program to illustrate Inheritance (concise) import java.io.*; // Base or Super Class class Employee {  int salary = 60000; } // Inherited or Sub Class class Engineer extends Employee {  int benefits = 10000; } // Driver Class class Gfg {  public static void main(String args[])  {  Engineer E1 = new Engineer();  System.out.println('Salary : ' + E1.salary  + '
Benefits : ' + E1.benefits);  } }>

Salary : 60000 Benefits : 10000>

Imatge il·lustrativa del programa:

llop contra guineu

A la pràctica, l'herència, i polimorfisme s'utilitzen conjuntament a Java per aconseguir un rendiment ràpid i la llegibilitat del codi.

Tipus d'herència de Java

A continuació es mostren els diferents tipus d'herència suportats per Java.

1. Herència única
2. Herència multinivell
3. Herència jeràrquica
4. Herència múltiple
5. Herència híbrida

1. Herència única

En l'herència única, una subclasse es deriva només d'una superclasse. Hereta les propietats i el comportament d'una classe monoparental. De vegades, també es coneix com a simple herència. A la figura següent, 'A' és una classe pare i 'B' és una classe infantil. La classe 'B' hereta totes les propietats de la classe 'A'.

Herència única

// Java program to illustrate the // concept of single inheritance import java.io.*; import java.lang.*; import java.util.*; // Parent class class One {  public void print_geek()  {  System.out.println('Geeks');  } } class Two extends One {  public void print_for() { System.out.println('for'); } } // Driver class public class Main {  // Main function  public static void main(String[] args)  {  Two g = new Two();  g.print_geek();  g.print_for();  g.print_geek();  } }>

Geeks for Geeks>

2. Herència multinivell

A l'herència multinivell, una classe derivada heretarà una classe base i, a més de la classe derivada, també actua com a classe base per a altres classes. A la imatge següent, la classe A serveix com a classe base per a la classe derivada B, que al seu torn serveix com a classe base per a la classe derivada C. A Java, una classe no pot accedir directament a la membres dels avis .

Herència multinivell

// Importing required libraries import java.io.*; import java.lang.*; import java.util.*; // Parent class One class One {  // Method to print 'Geeks'  public void print_geek() {  System.out.println('Geeks');  } } // Child class Two inherits from class One class Two extends One {  // Method to print 'for'  public void print_for() {  System.out.println('for');  } } // Child class Three inherits from class Two class Three extends Two {  // Method to print 'Geeks'  public void print_lastgeek() {  System.out.println('Geeks');  } } // Driver class public class Main {  public static void main(String[] args) {  // Creating an object of class Three  Three g = new Three();    // Calling method from class One  g.print_geek();    // Calling method from class Two  g.print_for();    // Calling method from class Three  g.print_lastgeek();  } }>

Geeks for Geeks>

3. Herència jeràrquica

A l'herència jeràrquica, una classe serveix com a superclasse (classe base) per a més d'una subclasse. A la imatge següent, la classe A serveix com a classe base per a les classes derivades B, C i D.

// Java program to illustrate the // concept of Hierarchical inheritance class A {  public void print_A() { System.out.println('Class A'); } } class B extends A {  public void print_B() { System.out.println('Class B'); } } class C extends A {  public void print_C() { System.out.println('Class C'); } } class D extends A {  public void print_D() { System.out.println('Class D'); } } // Driver Class public class Test {  public static void main(String[] args)  {  B obj_B = new B();  obj_B.print_A();  obj_B.print_B();  C obj_C = new C();  obj_C.print_A();  obj_C.print_C();  D obj_D = new D();  obj_D.print_A();  obj_D.print_D();  } }>

Class A Class B Class A Class C Class A Class D>

4. Herència múltiple ( Mitjançant interfícies)

En Herències múltiples , una classe pot tenir més d'una superclasse i heretar característiques de totes les classes pares. Tingueu en compte que Java sí no suport múltiples herències amb classes. A Java, només podem aconseguir múltiples herències mitjançant Interfícies . A la imatge següent, la classe C es deriva de les interfícies A i B.

Herència múltiple

// Java program to illustrate the // concept of Multiple inheritance import java.io.*; import java.lang.*; import java.util.*; interface One {  public void print_geek(); } interface Two {  public void print_for(); } interface Three extends One, Two {  public void print_geek(); } class Child implements Three {  @Override public void print_geek()  {  System.out.println('Geeks');  }  public void print_for() { System.out.println('for'); } } // Drived class public class Main {  public static void main(String[] args)  {  Child c = new Child();  c.print_geek();  c.print_for();  c.print_geek();  } }>

Geeks for Geeks>

5. Herència híbrida

És una barreja de dos o més dels tipus d'herència anteriors. Com que Java no admet herències múltiples amb classes, l'herència híbrida que implica l'herència múltiple tampoc és possible amb les classes. A Java, només podem aconseguir l'herència híbrida mitjançant Interfícies si volem implicar l'herència múltiple per implementar l'herència híbrida.
Tanmateix, és important tenir en compte que l'herència híbrida no requereix necessàriament l'ús de l'herència múltiple exclusivament. Es pot aconseguir mitjançant una combinació d'herència multinivell i herència jeràrquica amb classes, herència jeràrquica i única amb classes. Per tant, efectivament és possible implementar l'herència híbrida utilitzant classes soles, sense dependre del tipus d'herència múltiple.

Herència híbrida

Java IS-Un tipus de relació

IS-A és una manera de dir: Aquest objecte és un tipus d'aquest objecte. Vegem com s'utilitza la paraula clau extends per aconseguir l'herència.

com convertir una cadena a enter en java

public class SolarSystem { } public class Earth extends SolarSystem { } public class Mars extends SolarSystem { } public class Moon extends Earth { }>

Ara, basant-nos en l'exemple anterior, en termes orientats a objectes, el següent és cert:

• SolarSystem és la superclasse de la classe de la Terra.
• SolarSystem és la superclasse de la classe de Mart.
• La Terra i Mart són subclasses de la classe SolarSystem.
• La Lluna és la subclasse de les classes de la Terra i del Sistema Solar.

class SolarSystem { } class Earth extends SolarSystem { } class Mars extends SolarSystem { } public class Moon extends Earth {  public static void main(String args[])  {  SolarSystem s = new SolarSystem();  Earth e = new Earth();  Mars m = new Mars();  System.out.println(s instanceof SolarSystem);  System.out.println(e instanceof Earth);  System.out.println(m instanceof SolarSystem);  } }>

true true true>

Què es pot fer en una subclasse?

A les subclasses podem heretar els membres tal qual, substituir-los, amagar-los o complementar-los amb membres nous:

• Els camps heretats es poden utilitzar directament, igual que qualsevol altre camp.
• Podem declarar nous camps a la subclasse que no estiguin a la superclasse.
• Els mètodes heretats es poden utilitzar directament tal com són.
• Podem escriure una nova instància mètode de la subclasse que té la mateixa signatura que la de la superclasse, per tant anul·lant això (com a l'exemple anterior, toString() mètode s'ha anul·lat).
• Podem escriure una nova estàtica mètode de la subclasse que té la mateixa signatura que la de la superclasse, per tant amagant-se això.
• Podem declarar nous mètodes a la subclasse que no es troben a la superclasse.
• Podem escriure un constructor de subclasse que invoqui el constructor de la superclasse, ja sigui implícitament o utilitzant la paraula clau súper .

Avantatges de l'herència a Java:

1. Reutilització del codi: l'herència permet la reutilització del codi i redueix la quantitat de codi que cal escriure. La subclasse pot reutilitzar les propietats i mètodes de la superclasse, reduint la duplicació de codi.
2. Abstracció: l'herència permet la creació de classes abstractes que defineixen una interfície comuna per a un grup de classes relacionades. Això promou l'abstracció i l'encapsulació, fent que el codi sigui més fàcil de mantenir i ampliar.
3. Jerarquia de classes: l'herència permet la creació d'una jerarquia de classes, que es pot utilitzar per modelar objectes del món real i les seves relacions.
4. Polimorfisme: l'herència permet el polimorfisme, que és la capacitat d'un objecte d'adoptar múltiples formes. Les subclasses poden anul·lar els mètodes de la superclasse, la qual cosa els permet canviar el seu comportament de diferents maneres.

Desavantatges de l'herència a Java:

1. Complexitat: l'herència pot fer que el codi sigui més complex i difícil d'entendre. Això és especialment cert si la jerarquia d'herència és profunda o si s'utilitzen múltiples herències.
2. Acoblament estret: l'herència crea un acoblament estret entre la superclasse i la subclasse, cosa que dificulta fer canvis a la superclasse sense afectar la subclasse.

Conclusió

Comprovem alguns punts importants de l'article que s'esmenten a continuació:

què és un sistema de fitxers Linux

• Superclasse per defecte : Excepte Objecte classe, que no té superclasse, cada classe té una i només una superclasse directa (herència única). En absència de cap altra superclasse explícita, cada classe és implícitament una subclasse de la classe Object.
• La superclasse només pot ser una: Una superclasse pot tenir qualsevol nombre de subclasses. Però una subclasse només pot tenir un superclasse. Això es deu al fet que Java no admet múltiples herències amb classes. Tot i que amb interfícies, Java admet múltiples herències.
• Constructors heretats: Una subclasse hereta tots els membres (camps, mètodes i classes imbricades) de la seva superclasse. Els constructors no són membres, de manera que les subclasses no els hereten, però el constructor de la superclasse es pot invocar des de la subclasse.
• Herència de membres privats: Una subclasse no hereta els membres privats de la seva classe pare. Tanmateix, si la superclasse té mètodes públics o protegits (com els getters i setters) per accedir als seus camps privats, aquests també els pot utilitzar la subclasse.

Preguntes freqüents sobre l'herència

1. Què és l'herència Java?

L'herència és un concepte de POO on una classe hereta d'una altra classe que pot reutilitzar els mètodes i camps de la classe pare.

2. Quins són els 4 tipus d'herència a Java?

Hi ha únic, múltiple, multinivell, jeràrquic i híbrid

3. Per a què serveix la paraula clau extend?

La paraula clau Extend s'utilitza per heretar una classe a una altra.

4. Quin és un exemple d'herència a Java?

A continuació s'esmenta un exemple real d'herència a Java:

Considereu un grup de vehicles. Heu de crear classes per a autobusos, cotxes i camions. Els mètodes fuelAmount(), capacity(), applyBrakes() seran els mateixos per a les tres classes.

Referències utilitzades:

1. Head First Java de Kathy Sierra i Bert Bates
2. Java: una guia per a principiants de Herbert Schildt
3. Java: la referència completa de Herbert Schildt
4. Java efectiu de Joshua Bloch
5. Java: les bones parts de Jim Waldo.