Home-theater-designers
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 padre.
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 vedere il titolo di un video youtube cancellato
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, nuove classi possono ora attingere a classi correlate preesistenti e, se necessario, ampliare stati e comportamenti esistenti.
Un esempio reale di come funziona l'ereditarietà sarebbe considerare i frutti. Si tratta di 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 stock se avessi un negozio. Forse potresti avere una sezione di frutta nel tuo inventario e, in quella sezione, avresti oggetti più specifici come mele e arance.
È così che funziona l'ereditarietà.
Utilizzo dell'ereditarietà in Java
L'ereditarietà può essere utilizzata in qualsiasi linguaggio di programmazione che utilizza il paradigma di programmazione orientato 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 padre può avere molte classi figlio, ma ogni classe figlio può avere solo una classe padre (ereditarietà singola). 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 padre da un documento di requisiti software è noto come analisi orientata agli oggetti. Durante questo processo la frase is a viene spesso utilizzata per identificare possibili relazioni di ereditarietà. Attingendo al nostro esempio sopra dovresti essere in grado di vedere che il frutto sarebbe la nostra classe madre.
Esempio di classe madre di frutta
public class Fruit {
//Variable Declaration
protected String seed;
protected String skinColor;
protected String taste;
//Default Constructor
public Fruit(){
seed = '';
skinColor ='';
taste ='';
}
//Primary Constructor
public Fruit(String seed, String skinColor, String taste){
this.seed = seed;
this.skinColor = skinColor;
this.taste = taste;
}
//getters and setters
public String getSeed() {
return seed;
}
public void setSeed(String seed) {
this.seed = seed;
}
public String getSkinColor() {
return skinColor;
}
public void setSkinColor(String skinColor) {
this.skinColor = skinColor;
}
public String getTaste() {
return taste;
}
public void setTaste(String taste) {
this.taste = taste;
}
//eat method
public void eat(){
//general code on how to eat a fruit
}
//juice method
public void juice() {
//general code on how to juice a fruit
}
}Uno degli aspetti più importanti 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 padre perché impedisce alle classi non figlio di accedere agli attributi dei dati della classe padre.
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 vedere perché l'arancia dovrebbe essere una classe figlio adatta della classe frutta sopra.
Esempio di classe per bambini arancione
public class Orange extends Fruit{
//variable declaration
private int supremes;
//default constructor
public Orange() {
supremes = 0;
}
//primary constructor
public Orange(String seed, String skinColor, String taste, int supremes){
super(seed, skinColor, taste);
this.supremes = supremes;
}
//getters and setters
public int getsupremes() {
return supremes;
}
public void setsupremes(int supremes) {
this.supremes = supremes;
}
//eat method
public void eat(){
//how to eat an orange
}
//juice method
public void juice() {
//how to juice and orange
}
//peel method
public void peel(){
//how to peel an orange
}
}C'è una differenza tra l'aspetto di una normale dichiarazione di classe Java e ciò che abbiamo nel nostro codice sopra. La parola chiave estende è ciò che viene utilizzato in Java per rendere possibile l'ereditarietà.
Nel nostro esempio sopra la classe figlia (arancione) estende la classe genitore (frutta). Pertanto, è ora possibile accedere e modificare lo stato e il comportamento della classe frutta dalla classe arancione.
L'attributo unico che ha la nostra classe di arance è identificato con il nome variabile supremes (che è il nome ufficiale per i piccoli segmenti che si trovano nelle arance). È qui che entra in gioco la specializzazione; non tutti i frutti hanno i supremi ma tutte le arance ce l'hanno, quindi è logico riservare la variabile supreme alla classe arancione.
L'aggiunta del metodo della buccia ai metodi preesistenti di mangiare e spremere è anche logico perché, sebbene non tutti i frutti possano essere sbucciati, le arance spesso vengono sbucciate.
Dovresti tenere a mente che se non avessimo intenzione di modificare i metodi esistenti di consumo 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.
Il ruolo dei costruttori nell'ereditarietà
Per impostazione predefinita, i costruttori di classi padre vengono ereditati dalle classi figlie. Pertanto, se viene creato un oggetto di classe figlio, ciò significa che viene creato automaticamente anche un oggetto di classe padre.
Tornando al nostro esempio, ogni volta che viene creato un nuovo oggetto arancione viene creato anche un oggetto frutto perché un'arancia è un frutto.
Dietro le quinte, quando viene creato un oggetto di classe figlio, viene chiamato per primo il costruttore della classe padre, seguito dal costruttore della classe figlio. Nella nostra classe figlia arancione sopra, se viene creato un oggetto arancione senza alcun parametro, verrà chiamato il nostro costruttore di classe frutta predefinito, seguito dal nostro contraente di classe arancione predefinito.
Il super metodo nel nostro costruttore primario sopra è necessario perché specifica che il costruttore primario, e non il costruttore predefinito, della classe fruit genitore deve essere chiamato ogni volta che viene creato un oggetto arancione con parametri.
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 puoi creare le tue relazioni di ereditarietà utilizzando il linguaggio di programmazione Java. Inoltre, ora sai come aggirare la regola di ereditarietà singola di Java creando una relazione nonno.
Credito di immagine: Andreas Wohlfahrt/ Pexels
Condividere Condividere Tweet E-mail Come organizzare il codice orientato agli oggetti con l'ereditarietàAvere la giusta programmazione orientata agli oggetti significa che devi conoscere l'ereditarietà e come può semplificare la codifica e ridurre gli errori.
Leggi Avanti Argomenti correlati- Programmazione
- Giava
- Programmazione orientata agli oggetti
Kadeisha Kean è uno sviluppatore software full-stack e scrittore tecnico/tecnologico. Ha la spiccata capacità di semplificare alcuni dei concetti tecnologici più complessi; producendo materiale che può essere facilmente compreso da qualsiasi principiante della tecnologia. È appassionata di scrivere, sviluppare software interessanti e viaggiare per il mondo (attraverso documentari).
Altro da Kadeisha KeanIscriviti alla nostra Newsletter
Iscriviti alla nostra newsletter per suggerimenti tecnici, recensioni, ebook gratuiti e offerte esclusive!
Clicca qui per iscriverti