Eredità in Java

Java è un linguaggio orientato agli oggetti. Ciò significa che tutto in Java è costituito da classi e dai loro oggetti e obbedisce ai paradigmi dell'OOP (programmazione orientata agli oggetti). Uno di questi paradigmi è l'ereditarietà, un meccanismo in Java mediante il quale una classe può ereditare le caratteristiche (campi e metodi) di un'altra classe. In poche parole, in Java, ereditarietà significa creare nuove classi basate su quelle esistenti.

Attori chiave dell'ereditarietà in Java

• L'ereditarietà è il concetto secondo cui una classe può ripetere parzialmente o completamente le proprietà e i metodi del suo genitore (la classe da cui eredita).
• Una classe figlia, o sottoclasse, o classe estesa o classe derivata è una classe che eredita da un'altra classe.
• Una classe genitore, superclasse o classe base è una classe che ha un numero di funzioni e queste funzioni possono essere passate (ereditate) da un'altra classe (classe figlia).
• L'override del metodo sta modificando il comportamento di un metodo della classe derivata. Di solito si tratta di un comportamento più specifico e raffinato. Se si sovrascrive un metodo nell'erede che è già nella classe genitore, in un certo senso sostituisce il metodo genitore.
• Una classe può avere solo una classe antenata, ma ogni classe può avere molti "figli".

Come funziona

La catena di ereditarietà è diretta dalla classe più astratta a quella più concreta. Cioè, la superclasse è la più astratta nella catena di classi. Spesso è indicato come astratto (classe base che non richiede un'implementazione). Tutte le classi successive sono più specifiche. Ad esempio, esiste una classe chiamata "Gadget". Può avere un “peso” sul campo (o uno stato), la capacità della batteria sul campo, un livello di carica sul campo e metodi (o comportamenti) di “lavoro” e di ricarica. In questo caso i metodi possono essere astratti, ovvero non hanno un'implementazione specifica. Anche se non possiamo dire che tipo di gadget sia, è assolutamente qualsiasi gadget ricaricabile. Creiamo una sottoclasse Telefono della classe Gadget. Non ha più bisogno di ridefinire peso e batteria, li eredita semplicemente dal gadget astratto. Ma bisognerà chiarire il comportamento dell’opera. Puoi anche aggiungere altri campi “diagonale schermo”, connettori e così via. È possibile aggiungere un nuovo metodo "Aggiorna sistema operativo". Successivamente, possiamo creare altre due classi ed entrambe verranno ereditate da Telefono, Android e iPhone. Entrambe le classi ereditano tutti i campi e i metodi del gadget e dello smartphone e i metodi possono essere sovrascritti. La prima classe necessita del campo "Nome della marca", mentre l'iPhone non ha bisogno di questo campo, poiché solo un'azienda produce tali smartphone.

class Gadget {
…
}
}
//subclass of Gadget class
class Phone extends Gadget {
…
}
//subclass of Phone class
class IPhone extends Phone {
…
}
//subclass of Phone class
class AndroidPhone extends Phone {
…
}

Una classe figlia eredita tutti i membri pubblici e protetti della classe genitore. Non importa in quale pacchetto si trova la sottoclasse. Se la classe figlia si trova nello stesso pacchetto della classe genitore, eredita anche i membri privati ​​del pacchetto genitore. Puoi utilizzare i membri ereditati così come sono, sostituirli, nasconderli o aggiungere nuovi membri:

• È possibile utilizzare direttamente i campi ereditati come qualsiasi altro campo.
• Puoi dichiarare un campo nella classe figlia che ha lo stesso nome della classe genitore. Lo sta nascondendo (quindi meglio non farlo).
• Puoi dichiarare nuovi campi nella classe figlia (quelli che la classe genitore non ha).
• I metodi ereditati possono essere utilizzati direttamente senza sovrascrivere nella classe derivata.
• Inoltre puoi scrivere un nuovo metodo di istanza in una sottoclasse che abbia la stessa firma di un metodo nella classe genitore. Questa procedura lo sovrascrive.
• Puoi dichiarare nuovi metodi nella classe figlia che non sono stati dichiarati nella classe Parent.
• Puoi scrivere un costruttore di sottoclasse che chiami il costruttore della superclasse implicitamente o con la parola chiave super.

Esempio

Creiamo una classe Base MusicalInstrument con campi peso e marchio, nonché un metodo work() . Definiamo anche un costruttore.

public class MusicalInstrument {
   int weight;
   String tradeMark;

   public MusicalInstrument(int weight, String tradeMark) {
       this.weight = weight;
       this.tradeMark = tradeMark;
   }

   public void work() {
       System.out.println("the instrument is playing...");
   }
}

Non è del tutto chiaro che tipo di strumento musicale sia e come suonarlo. Creiamo uno strumento più specifico, il violino. Avrà gli stessi campi dello Strumento musicale (verranno chiamati nel costruttore utilizzando la parola chiave super. Possiamo anche sovrascrivere il metodo di lavoro e creare un metodo per impostare la corda del violino per corda.

public class Violin extends MusicalInstrument {
   String master;
   String owner;
   int age;
   boolean isTuned;

   public Violin(int weight, String tradeMark, String master, String owner, int age, boolean isTuned) {
       super(weight, tradeMark);
       this.master = master;
       this.owner = owner;
       this.age = age;
       this.isTuned = isTuned;
   }

   @Override
   public void work() {
       System.out.println("THe violin's playing");

   }

   public void violinTuning () {
     System.out.println("I'm tuning 1st string...");
     System.out.println("I'm tuning 2nd string...");
     System.out.println("I'm tuning 3rd string...");
     System.out.println("I'm tuning 4th string...");
}


}

Creiamo una classe Demo per testare la classe Violin e vedere esattamente come funziona l'ereditarietà.

public class InheritDemo {

   public static void main(String[] args) {

       Violin violin = new Violin(1, null, "Amati", "Kremer", 285, false);
       violin.violinTuning();
       violin.work();
   }
}

In questo caso l’output del programma sarà il seguente: Cioè, se è presente un metodo sovrascritto nella classe figlia, il metodo antenato non verrà più chiamato. E se non fosse lì? Cioè, la classe Violino assomiglia a questa:

public class Violin extends MusicalInstrument {
   String master;
   String owner;
   int age;
   boolean isTuned;

   public Violin(int weight, String tradeMark, String master, String owner, int age, boolean isTuned) {
       super(weight, tradeMark);
       this.master = master;
       this.owner = owner;
       this.age = age;
       this.isTuned = isTuned;
   }

  // @Override


 //  }

   public void violinTuning () {
       System.out.println("I'm tuning 1st string...");
       System.out.println("I'm tuning 2nd string...");
       System.out.println("I'm tuning 3rd string...");
       System.out.println("I'm tuning 4th string...");
   }

}

L'output è: Cioè, il metodo antenato verrà chiamato automaticamente. A proposito, la classe figlia può essere definita tramite l'antenato, ovvero per eseguire l'upcasting:

Parent parent = new Child()

Questa inizializzazione viene utilizzata per accedere solo ai membri presenti nella classe genitore e ai metodi sovrascritti. Nel nostro esempio sarebbe:

public class InheritDemo {

   public static void main(String[] args) {

       MusicalInstrument violin = new Violin(1, null, "Amati", "Kremer", 285, false);
       //violin.violinTuning();
       violin.work();
   }
}

In tal caso, non siamo in grado di configurare il metodo violino. Allo stesso tempo, però, verrà chiamato il metodo work() della classe discendente, se esiste.

La gerarchia delle classi della piattaforma Java

In Java tutto è composto da classi e queste sono subordinate a una gerarchia. La domanda sorge spontanea: esiste una classe da cui vengono ereditate tutte le altre? La risposta è sì, in effetti una classe del genere esiste. E si chiama semplicemente Object . La classe Object del pacchetto java.lang definisce e implementa il comportamento comune a tutte le classi, comprese quelle create. Nella piattaforma Java, molte classi derivano direttamente da Object , altre classi derivano da alcune di queste classi e così via, formando una gerarchia di classi.

Tipi di ereditarietà in Java

Evidenziamo alcuni tipi di ereditarietà in Java. 1. Eredità singola Questo tipo è proprio come nel nostro esempio sopra, le sottoclassi ereditano le caratteristiche di una super classe. Nell'immagine seguente, la classe A funge da classe base per la classe derivata B. 2. Ereditarietà multilivello Questa è solo una catena di ereditarietà, ovvero esiste una classe base A, la classe B viene ereditata da essa e la classe C viene ereditato dalla classe B. In Java, una classe non può accedere direttamente ai membri del nonno. 3. Eredità gerarchica Nell'ereditarietà gerarchica, una classe funge da superclasse (classe base) per più di una sottoclasse. Sopra abbiamo fornito un esempio della classe Phone, che può avere due "figli": AndroidPhone e IPhone.

class A {
    public void printA() {
System.out.println("A");
 }
}

class B extends A {
    public void printB() {
 System.out.println(" B"); }
}

class C extends A {
    public void printC() {
System.out.println("C");
}
}

class D extends A {
    public void printD() {
System.out.println("D");
 }
}

public class Demo {
    public static void main(String[] args)
    {
        B objB = new B();
        objB.printA();
        objB.printB();

        C objC = new C();
        objC.printA();
        objC.printC();

        D objD = new D();
        objD.printA();
        objD.printD();
    }
}

L'output è: 4. Ereditarietà multipla, cioè la presenza di più antenati... ma aspetta, l'ereditarietà multipla classica non è supportata in Java. In una certa misura, può essere implementato utilizzando non classi, ma interfacce.

interface A {
   public void printA();
}

interface B {
   public void printB();
}

interface C extends A, B {
   public void print();
}
class InheritDemo implements C {
   @Override
   public void print()
   {
       System.out.println("Print something");
   }

   @Override
   public void printA() {
   }

   @Override
   public void printB() {
   }
}