Sommario
Come funziona l'ereditarietà in C#
- Unica eredità
- Ereditarietà multilivello
- Ereditarietà gerarchica
- Ereditarietà multipla (non supportata in C#)
Cos'è l'ereditarietà in C#
In C# usando l'ereditarietà, una classe può acquisire o ereditare le proprietà e i metodi di un'altra classe. In altre parole, consente la creazione di una nuova classe basata su una classe esistente, nota come classe base o superclasse. Viene chiamata una classe formata dopo aver preso le proprietà di una classe base una classe derivata o sottoclasse.
Questa classe derivata in C# non solo prende le proprietà della classe di base, ma può anche aggiungere le proprie caratteristiche uniche.
Come funziona l'ereditarietà in C#
In C#, l'ereditarietà si ottiene tramite l'uso dei due punti (:) simbolo. Il nome della classe di base è definito dopo i due punti ed è specificato dalla classe derivata.
Di seguito è riportata la sintassi per la creazione di una classe derivata che prende le proprietà dalla classe base:
class Classe derivata : BaseClass{
// membri della classe derivati
}
Qui in questo codice, Classe derivata è il nome della classe derivata e BaseClass è il nome della classe base. IL : Il simbolo indica che DerivedClass sta ereditando da BaseClass. I membri di DerivedClass possono accedere ai membri BaseClass, a condizione che non siano privati.
Tipi di ereditarietà in C#
C# supporta quattro tipi di ereditarietà: ereditarietà singola, multilivello, gerarchica e multipla. Diamo un'occhiata a ogni tipo.
Unica eredità
L'ereditarietà singola è il tipo più comune di ereditarietà, in cui una classe derivata acquisisce o eredita le proprietà di una sola classe di base.
Per esempio, il codice fornito spiega la gerarchia delle classi e dimostra i concetti di ereditarietà.
usando Sistema ;usando Sistema ;
auto di classe
{
pubblico vuoto Inizio ( )
{
Consolle. Linea di scrittura ( 'Auto avviata' ) ;
}
}
classe Tesla : Auto
{
pubblico vuoto Accelerare ( )
{
Consolle. Linea di scrittura ( 'Tesla in accelerazione' ) ;
}
}
programma di classe
{
statico vuoto Principale ( corda [ ] arg )
{
Tesla miaTesla = nuova Tesla ( ) ;
myTesla. Inizio ( ) ; // Output: l'auto è partita
myTesla. Accelerare ( ) ; // Output: Tesla in accelerazione
}
}
Nel codice sopra, il Classe auto è la classe base e ha un metodo chiamato Inizio() , che stampa semplicemente il messaggio Auto avviata alla consolle.
IL Classe Tesla è derivato dalla classe Car e accetta tutte le proprietà della classe Car. La classe Tesla aggiunge un metodo chiamato Accelerare() , che stampa il messaggio Tesla in accelerazione alla consolle.
IL Principale() La funzione definisce un'istanza della classe Tesla chiamata myTesla e chiama i suoi metodi Start() e Accelerate().
Ereditarietà multilivello
L'ereditarietà multilivello è il punto in cui una classe derivata eredita da un'altra classe derivata, che a sua volta eredita da una classe base.
Per esempio, il codice C# seguente illustra l'ereditarietà e l'override del metodo in una gerarchia di classi.
usando Sistema ;classe Animale
{
pubblico vuoto Mangiare ( )
{
Consolle. Linea di scrittura ( 'Mangiare animali' ) ;
}
}
classe Mammifero : Animale
{
pubblico vuoto Correre ( )
{
Consolle. Linea di scrittura ( 'Mammifero che corre' ) ;
}
}
classe Cane : Mammifero
{
pubblico vuoto Abbaio ( )
{
Consolle. Linea di scrittura ( 'Cane che abbaia' ) ;
}
}
programma di classe
{
statico vuoto Principale ( corda [ ] arg )
{
Cane mio cane = nuovo cane ( ) ;
il mio cane. Mangiare ( ) ; // Output: Mangiare animali
il mio cane. Correre ( ) ; // Output: Mammifero che corre
il mio cane. Abbaio ( ) ; // Output: cane che abbaia
}
}
Qui Cane è una classe derivata che eredita da Mammifero , che a sua volta eredita da Animale . La classe Dog ha accesso a tutte le proprietà, i metodi e il comportamento di Mammal e Animal e può anche definire il proprio metodo univoco Abbaio() .
IL Classe animale è la classe base e ha un metodo chiamato Mangiare() , che stampa semplicemente il messaggio Animale che mangia sulla console.
IL Classe di mammiferi è derivato dalla classe Animal e aggiunge un metodo chiamato Correre() , che stampa il messaggio Mammal in esecuzione nella console.
IL Classe di cani è derivato dalla classe Mammal e aggiunge un metodo chiamato Abbaio() , che stampa il messaggio Cane che abbaia sulla console.
Il metodo Main() crea un'istanza della classe Dog chiamata il mio cane e chiama i suoi metodi Eat(), Run() e Bark().
Si noti che i metodi Eat() e Run() non sono definiti nella classe Dog, ma sono ereditati dalle sue classi genitore Animale E Mammifero , rispettivamente. IL Abbaio() Il metodo è definito solo nella classe Dog.
Ereditarietà gerarchica
Nell'ereditarietà gerarchica, diversi numeri di classi derivate vengono ereditati da una sola classe di base. Per esempio:
usando Sistema ;classe Forma
{
pubblico vuoto Disegno ( )
{
Consolle. Linea di scrittura ( 'Disegnare la forma' ) ;
}
}
Circolo di classe : Forma
{
pubblico vuoto Riempire ( )
{
Consolle. Linea di scrittura ( 'Cerchio di riempimento' ) ;
}
}
classe Piazza : Forma
{
pubblico vuoto Colore ( )
{
Consolle. Linea di scrittura ( 'Quadrato da colorare' ) ;
}
}
programma di classe
{
statico vuoto Principale ( corda [ ] arg )
{
Circle myCircle = nuovo Circolo ( ) ;
myCircle. Disegno ( ) ; // Output: disegno della forma
myCircle. Riempire ( ) ; // Output: Cerchio di riempimento
Piazza mySquare = nuova Piazza ( ) ;
mySquare. Disegno ( ) ; // Output: disegno della forma
mySquare. Colore ( ) ; // Output: quadrato da colorare
}
}
Nel codice precedente, both Cerchio E Piazza sono classi derivate che ereditano da Forma . Hanno accesso al metodo Draw() definito in Shape e possono anche definire i propri metodi univoci Fill() e Color().
Qui abbiamo creato un oggetto della classe Circle denominato myCircle e un oggetto del Piazza classe denominata mySquare . Quindi chiamiamo il Disegno() metodo, ereditato dalla classe Shape, su entrambi gli oggetti.
Successivamente, chiamiamo il Riempire() metodo su myCircle, che è specifico della classe Circle, e il metodo Colore() metodo su mySquare, che è specifico della classe square.
L'output verrà stampato sulla console come di seguito:
Ereditarietà multipla
L'ereditarietà multipla è dove una classe derivata eredita da più classi di base. Tuttavia, C# non supporta l'ereditarietà multipla. Per ottenere funzionalità simili, C# usa interfacce .
Conclusione
L'ereditarietà in C# consente alle classi di ereditare comportamento e funzionalità dalle classi di base. Usando l'ereditarietà, possiamo riutilizzare il codice e creare un flusso gerarchico all'interno del programma. Comprendendo i diversi tipi di ereditarietà, è possibile scrivere codice più efficiente e organizzato, più facile da mantenere ed estendere.