Cos'è l'ereditarietà multipla in Java?

OOP ed eredità

L'uso della programmazione orientata agli oggetti utilizza il concetto di ereditarietà per estendere la funzionalità degli oggetti. Pensa a quando un programmatore crea un oggetto. In seguito puoi vedere che è necessario creare un oggetto molto simile con solo piccole differenze (magari estendere la funzionalità di un oggetto precedente in un nuovo contesto). Qui è dove appare l'ereditarietà. Un oggetto che un programmatore "deriva" da un altro oggetto "base" eredita i metodi e le variabili della classe e quindi può aggiungere più funzionalità (come nel seguente esempio Java):

sfera di classe pubblica {raggio pubblico int; }

public class Ball estende Sphere {colore stringa pubblico; // Ball aggiunge la variabile "color", ma usa anche la variabile "radius"}

Eredità multipla

Ad un certo punto, un programmatore potrebbe essere tentato di ricavare una singola classe di più classi. Questo è noto come "ereditarietà multipla" e sebbene sembri utile, può causare problemi, come l'importante "problema dei diamanti". Questo problema si verifica quando due classi ereditano dalla stessa classe (come classe B e C derivano dalla classe A), mentre un'altra classe (D) deriva da B e C. Quando viene creato un oggetto D, il sistema lo considera come un tipo di classe base (classe "Palla" o palla e "Sfera" o sfera, ad esempio). Nel problema del diamante, il sistema non è in grado di determinare con decisione quale classe D (è di tipo ABD o ACD?) È quella che causa problemi.

Java e ereditarietà multipla

A causa di problemi con l'ereditarietà multipla, Java non lo consente. Ma in realtà le classi derivate da diverse classi di base possono essere raggiunte in modo sicuro usando "interfacce". Un'interfaccia è simile a una classe, ma non solo definisce la struttura della classe, ma anche il suo codice reale. Una classe base che implementa un'interfaccia non necessariamente "eredita" la funzionalità dell'interfaccia: promette solo l'uso della sua struttura. Poiché una classe che implementa un'interfaccia non eredita da un'altra classe (e non è un tipo della classe base), un programmatore può implementare diverse interfacce utilizzando la stessa classe.

Esempio: ereditarietà e interfacce

L'esempio seguente mostra la differenza tra l'ereditarietà di oggetti e un'interfaccia. Una classe che eredita da un'altra ottiene l'accesso alla classe base perché diventa fondamentalmente un tipo di quella classe (come nelle classi "Ball" e "Sphere"). Una classe che implementa un'interfaccia promette solo di implementare la struttura della sua interfaccia: non è un tipo di tale interfaccia:

interfaccia Basic {int doubleA (); // nota: nessun codice reale è definito nell'interfaccia}

implementazioni di classe pubblica B di base {

pubblico int a;

public int doubleA () // la classe B deve definire il metodo "doubleA ()" per implementare "Basic" {return a * 2;}}