Esplorazione dell'ereditarietà nel linguaggio di programmazione Java

L'ereditarietà è uno dei concetti fondamentali della programmazione orientata agli oggetti. Nella programmazione, la parola ereditarietà rappresenta una relazione in cui una classe figlia assume lo stato e il comportamento di una classe genitore.

Lo scopo dell'ereditarietà nello sviluppo del software è facilitare il riutilizzo di software sicuro e affidabile. Uno dei principali vantaggi dell'utilizzo dell'ereditarietà è che elimina il codice ridondante nei programmi.

Come funziona l'ereditarietà

L'idea alla base dell'ereditarietà è che molte classi o oggetti hanno alcuni degli stessi set di attributi e metodi. Pertanto, nello spirito di produrre software affidabile, le nuove classi possono ora attingere da classi correlate preesistenti e, se necessario, espandere gli stati e i comportamenti esistenti.

Un esempio reale di come funziona l'eredità sarebbe considerare i frutti. Questa è un'etichetta ampia che serve a racchiudere una gamma di articoli diversi.

Una mela è un frutto e così è un'arancia. Tuttavia, un'arancia non è una mela, quindi non avresti frutta come uno dei tuoi articoli in magazzino se possedessi un negozio. Forse potresti avere una sezione di frutta nel tuo inventario e sotto quella sezione avresti oggetti più specifici come mele e arance.

Ecco come funziona l'ereditarietà.

Utilizzo dell'ereditarietà in Java

L'ereditarietà può essere utilizzata in qualsiasi linguaggio di programmazione che utilizza l'estensione paradigma di programmazione orientata agli oggetti. Tuttavia, il modo esatto in cui viene utilizzata l'ereditarietà dipende dal linguaggio di programmazione specifico.

Per esempio, C ++ è anche un linguaggio di programmazione orientato agli oggetti. C ++ supporta la cosiddetta ereditarietà multipla, mentre Java supporta solo l'ereditarietà singola.

Ciò significa che in Java una classe genitore può avere molte classi figlie, ma ogni classe figlia può avere solo una singola classe genitore (singola eredità). Tuttavia, esiste un modo per ottenere l'ereditarietà multipla indiretta in Java, creando una relazione nonno, genitore e figlio.

Creazione della classe padre in Java

Il processo di selezione di una classe genitore da un documento di requisiti software è noto come analisi orientata agli oggetti. Durante questo processo la frase "è un" viene spesso utilizzata per identificare possibili relazioni di ereditarietà. Attingendo dal nostro esempio sopra dovresti essere in grado di vedere che il frutto sarebbe la nostra classe genitore.

Esempio di classe genitore di frutta

public class Fruit {
// Dichiarazione di variabili
seme di stringa protetto;
protetto String skinColor;
gusto di stringa protetto;
// Costruttore predefinito
public Fruit () {
seed = "";
skinColor = "";
gusto = "";
}
// Costruttore primario
public Fruit (String seed, String skinColor, String taste) {
this.seed = seme;
this.skinColor = skinColor;
this.taste = gusto;
}
// getter e setter
public String getSeed () {
seme di ritorno;
}
public void setSeed (String seed) {
this.seed = seme;
}
public String getSkinColor () {
return skinColor;
}
public void setSkinColor (String skinColor) {
this.skinColor = skinColor;
}
public String getTaste () {
gusto di ritorno;
}
public void setTaste (String taste) {
this.taste = gusto;
}
// mangia metodo
public void eat () {
// codice generale su come mangiare un frutto
}
// metodo del succo
public void juice () {
// codice generale su come spremere un frutto
}
}

Uno degli aspetti più notevoli della classe genitore sopra è il modificatore di accesso che viene utilizzato con ogni dichiarazione di variabile. Il modificatore di accesso "protetto" è ideale per l'uso nelle classi genitore perché impedisce alle classi non figlie di ottenere l'accesso agli attributi dei dati della classe genitore.

Più avanti nel codice vengono presentati i costruttori, i getter e i setter che sono elementi costitutivi generali per qualsiasi classe Java. Infine, ti vengono presentati due metodi (succo e mangia) che vengono creati nella classe genitore del nostro programma perché sono universali per tutti i frutti: tutti i frutti possono essere mangiati e spremuti.

Creazione di classi figlie in Java

Le classi figlie sono generalmente chiamate classi specializzate o derivate perché ereditano lo stato e il comportamento da un genitore e spesso personalizzano questi attributi per essere più specifici.

Continuando con il nostro esempio, dovresti essere in grado di capire perché l'arancia sarebbe una classe bambino adatta della classe di frutta sopra.

Esempio di classe bambino arancione

public class Orange estende Fruit {
// dichiarazione di variabile
private int supremes;
// costruttore predefinito
public Orange () {
supremi = 0;
}
// costruttore principale
public Orange (String seed, String skinColor, String taste, int supremes) {
super (seme, skinColor, gusto);
this.supremes = supremes;
}
// getter e setter
public int getsupremes () {
ritorno supremo;
}
public void setsupremes (int supremes) {
this.supremes = supremes;
}
// mangia metodo
public void eat () {
// come mangiare un'arancia
}
// metodo del succo
public void juice () {
// come spremere e arancia
}
// metodo peel
public void peel () {
// come sbucciare un'arancia
}
}

C'è una differenza tra l'aspetto di una normale dichiarazione di classe Java e ciò che abbiamo nel nostro codice sopra. La parola chiave "extends" è ciò che viene utilizzato in Java per rendere possibile l'ereditarietà.

Nel nostro esempio sopra la classe figlia (arancione) estende la classe genitore (frutto). Pertanto, lo stato e il comportamento della classe frutta possono ora essere accessibili e modificati dalla classe arancione.

L'attributo unico della nostra classe di arance è identificato con il nome della variabile supremes (che è il nome ufficiale per i piccoli segmenti trovati nelle arance). È qui che entra in gioco la specializzazione; non tutti i frutti hanno supremi ma tutte le arance lo hanno, quindi riservare la variabile supremi per la classe arancione è logico.

Anche l'aggiunta del metodo "buccia" ai metodi preesistenti "mangia" e "succo" è logico perché sebbene non tutti i frutti possano essere sbucciati, le arance spesso vengono sbucciate.

Tieni presente che se non intendessimo modificare i metodi esistenti "mangia" e "succo", non avremmo bisogno di includerli nella nostra classe di arance. I metodi nella classe orange sovrascrivono qualsiasi metodo simile nella classe fruit. Quindi, se tutti i frutti fossero mangiati e spremuti allo stesso modo, non avremmo bisogno di creare questi metodi nella classe delle arance.

I costruttori di ruolo giocano nell'ereditarietà

Per impostazione predefinita, i costruttori della classe genitore vengono ereditati dalle classi figlie. Pertanto, se viene creato un oggetto classe figlio, ciò significa che anche un oggetto classe genitore viene creato automaticamente.

Tornando al nostro esempio, ogni volta che viene creato un nuovo oggetto arancione viene creato anche un oggetto frutta perché un'arancia è un frutto.

Dietro le quinte, quando viene creato un oggetto classe figlio, il costruttore della classe genitore viene chiamato per primo seguito dal costruttore della classe figlia. Nella nostra classe figlio arancione sopra, se un oggetto arancione viene creato senza alcun parametro, verrà chiamato il nostro costruttore di classi di frutta predefinito, seguito dal nostro appaltatore di classe arancione predefinito.

Il metodo "super" nel nostro costruttore principale sopra è necessario perché specifica che il costruttore principale — e non è il costruttore predefinito - della classe frutta genitore dovrebbe essere chiamato ogni volta che è presente un oggetto arancione con parametri creato.

Ora puoi usare l'ereditarietà in Java

Da questo articolo, sei stato in grado di imparare cos'è l'ereditarietà, come funziona e perché è un concetto così importante nella programmazione. È ora possibile creare le relazioni di ereditarietà utilizzando il linguaggio di programmazione Java. Inoltre, ora sai come aggirare la singola regola di ereditarietà di Java creando una relazione con i nonni.

Credito immagine: Andreas Wohlfahrt /Pexels

Come organizzare il codice orientato agli oggetti con l'ereditarietà

Ottenere la corretta programmazione orientata agli oggetti significa che è necessario conoscere l'ereditarietà e come può semplificare la codifica e ridurre gli errori.

Leggi Avanti

Circa l'autore