Come usare l'eredità in C#
Sommario
Cosa è eredità in C#
Come funziona l'eredità in C#
Tipi di eredità in C#
- Singola eredità
- Ereditarietà multilivello
- Ereditarietà gerarchica
- Ereditarietà multipla (non supportata in C#)
Conclusione
Cosa è eredità in C#
In C# usando l'eredità, una classe può prendere 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, che è nota come classe base o super classe. Viene chiamata una classe formata dopo aver preso le proprietà di una classe di 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 sue caratteristiche uniche.
Come funziona l'eredità in C#
In C#, l'eredità si ottiene attraverso l'uso del colon (:) simbolo. Il nome della classe base è definito dopo il colon ed è specificato dalla classe derivata.
Di seguito è la sintassi per la creazione di una classe derivata che prende proprietà dalla classe base:
Classe Derited Class: Baseclass// membri della classe derivata
Qui in questo codice, Class derivato è il nome della classe derivata e Baseclass è il nome della classe base. IL : il simbolo indica che la classe derivata sta ereditando da baseclass. I membri di DeriDclass possono accedere ai membri di base, a condizione che non siano privati.
Tipi di eredità in C#
C# supporta quattro tipi di eredità: singolo, multi-livello, gerarchico e eredità multipla. Diamo un'occhiata a ogni tipo.
Singola eredità
La singola eredità è il tipo più comune di eredità, in cui una classe derivata prende o eredita le proprietà di una sola classe base.
Per esempio, Il codice dato spiega la gerarchia di classe e dimostra concetti di eredità.
usando il sistema;usando il sistema;
Auto di classe
public void start ()
Console.WriteLine ("auto iniziata");
Classe Tesla: auto
public void accelerate ()
Console.WriteLine ("Tesla Accelerating");
Programma di classe
statico void main (string [] args)
Tesla mytesla = new Tesla ();
mytesla.Inizio(); // output: l'auto ha iniziato
mytesla.Accelerare(); // output: Tesla Accelerating
Nel codice sopra, il Classe di auto è la classe base e ha un metodo chiamato Inizio(), che stampela semplicemente il messaggio L'auto è iniziata alla console.
IL Classe Tesla è derivato dalla classe auto e richiede tutte le proprietà della classe automobilistica. La classe Tesla aggiunge un metodo chiamato Accelerare(), che stampa il messaggio Tesla accelerando alla console.
IL Principale() La funzione definisce un'istanza della classe Tesla chiamata mytesla e chiama i suoi metodi start () e accelerate ().
Ereditarietà multilivello
L'eredità multi-livello è dove una classe derivata eredita da un'altra classe derivata, che a sua volta eredita da una classe di base.
Per esempio, Il seguente codice C# dimostra l'ereditarietà e il metodo che prevale in una gerarchia di classe.
usando il sistema;animale di classe
public void eat ()
Console.WriteLine ("Eaction per animali");
Mammifero di classe: animale
public void run ()
Console.WriteLine ("Mammal Running");
Cane di classe: mammifero
Public void Bark ()
Console.WriteLine ("Dog Barking");
Programma di classe
statico void main (string [] args)
Cane mydog = new dog ();
il mio cane.Mangiare(); // Output: alimentazione degli animali
il mio cane.Correre(); // output: mammifero in esecuzione
il mio cane.Abbaio(); // output: abbaiare il cane
Qui Cane è una classe derivata che eredita Mammifero, che a sua volta eredita da Animale. La classe per cani ha accesso a tutte le proprietà, metodi e comportamenti di mammifero e animale e può anche definire il proprio metodo unico Abbaio().
IL Classe di animali è la classe base e ha un metodo chiamato Mangiare(), che stampela semplicemente il messaggio che mangia l'animale alla console.
IL Classe di mammiferi è derivato dalla classe animale e aggiunge un metodo chiamato Correre(), che stampa il messaggio mammifero in esecuzione sulla console.
IL Classe per cani è derivato dalla classe dei mammiferi e aggiunge un metodo chiamato Abbaio(), che stampa il cane che abbaia alla console.
Il metodo principale () crea un'istanza della classe per cani 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 dei cani, ma sono ereditati dalle sue classi genitori Animale E Mammifero, rispettivamente. IL Abbaio() Il metodo è definito solo nella classe del cane.
Ereditarietà gerarchica
Nell'eredità gerarchica, diversi numeri di classi derivati sono ereditati da una sola classe di base. Per esempio:
usando il sistema;forma di classe
public void Draw ()
Console.WriteLine ("Disegno forma");
Cerchio di classe: forma
PUBBLICO PILL FILL ()
Console.WriteLine ("Riemping Circle");
Classe Square: forma
public void Color ()
Console.WriteLine ("Coloring Square");
Programma di classe
statico void main (string [] args)
Cerchio mycircle = new cerch ();
mycircle.Disegno(); // output: forma di disegno
mycircle.Riempire(); // output: cerchio di riempimento
Square MySquare = new Square ();
mysquare.Disegno(); // output: forma di disegno
mysquare.Colore(); // output: colorare quadrati
Nel codice sopra, entrambi Cerchio E Piazza sono classi derivate che ereditano Forma. Hanno accesso al metodo Draw () definito in forma e possono anche definire i propri metodi unici riempimento () e color ().
Qui abbiamo creato un oggetto della classe Circle denominata mycircle e un oggetto del Piazza Classe nominata mysquare. Quindi chiamiamo il Disegno() Metodo, che viene ereditato dalla classe di forma, su entrambi gli oggetti.
Successivamente, chiamiamo il Riempire() Metodo su Mycircle, che è specifico per la classe Circle e Colore() Metodo su MySquare, che è specifico per la classe quadrata.
L'output verrà stampato sulla console come di seguito:
Ereditarietà multipla
L'eredità multipla è dove una classe derivata eredita da più classi di base. Tuttavia, C# non supporta l'eredità multipla. Per ottenere funzionalità simili, C# utilizza interfacce.
Conclusione
L'eredità in C# consente alle classi di ereditare il comportamento e la funzionalità dalle classi di base. Usando l'eredità, possiamo riutilizzare il codice e creare un flusso gerarchico all'interno del programma. Comprendendo i diversi tipi di eredità, si può scrivere un codice più efficiente e organizzato che sia più facile da mantenere ed estendere.