Introduzione all'ereditarietà in C #

L'ereditarietà in C # è il processo di acquisizione di tutte le proprietà di una classe in un'altra classe. Esistono due classi denominate classe base e classe derivata. La classe base è anche conosciuta come classe genitore e le proprietà o i metodi di questa classe che vogliamo ereditare in un'altra classe.

La classe derivata è nota come classe figlio utilizzata per ereditare le proprietà e i metodi della classe base o della classe genitore. Aiuta a riutilizzare nuovamente lo stesso codice e non è necessario definire le stesse proprietà ancora e ancora.

L'ereditarietà è uno dei potenti concetti o attributi fondamentali del linguaggio di programmazione orientato agli oggetti. È ampiamente utilizzato in tutti i linguaggi di programmazione basati su OOP. Il suo scopo principale è di utilizzare nuovamente lo stesso codice. L'esempio della struttura di base dell'ereditarietà è riportato di seguito:

class BaseClass ( )
class ChildClass: BaseClass ()

Tipi di ereditarietà in C #

Esistono diversi tipi di ereditarietà in C #:

1. Ereditarietà a livello singolo

Nell'ereditarietà singola sono presenti solo una classe base e una classe derivata. Significa che la classe figlio erediterà le proprietà della classe genitore e la utilizzerà.

Esempio:
class BaseClass
(
public void hello()
(
Console.WriteLine("Parent's Hello Method");
)
)
class ChildClass : BaseClass
(
public void World()
(
Console.WriteLine("Child's World Method");
)
)

2. Ereditarietà multilivello

In questo tipo di eredità, esiste solo una classe base e sono disponibili più classi derivate. Se una classe viene creata utilizzando un'altra classe derivata è nota come eredità multilivello.

Esempio:

class BaseClass
(
public void hello()
(
Console.WriteLine("Parent's Hello Method");
)
)
class ChildClass : BaseClass
(
public void World()
(
Console.WriteLine("Child's World Method");
)
)
class SecondChildClass : ChildClass
(
public void Hi()
(
)
)

3. Ereditarietà multipla

In questo tipo di eredità, ciò può essere ottenuto con l'aiuto di più interfacce, non con una classe. In parole semplici, C # non supporta più ereditarietà ma se si desidera ottenerlo, è possibile ottenerlo solo con le interfacce.

Esempio:

Interface A ()
Interface B ()
Class C: A, B ()

4. Eredità gerarchica

In questo tipo di eredità, esiste una classe genitore e le altre classi derivate ereditano la stessa classe genitore per ottenere questa eredità.

Esempio :

class BaseClass
(
public void hello()
(
Console.WriteLine("Parent's Hello Method");
)
)
class ChildClass : BaseClass
(
public void World()
(
Console.WriteLine("Child's World Method");
)
)
class SecondChildClass : BaseClass
(
public void Hi()
(
)
)

Vantaggi dell'ereditarietà

I vantaggi dell'ereditarietà sono:

  • Aiuta a utilizzare nuovamente lo stesso codice significa riusabilità del codice.
  • Riduce la ridondanza del codice.
  • Aiuta a leggere il codice più comodamente.
  • Riduce anche la dimensione del codice sorgente e del file.
  • Aiuta a fornire l'estensibilità al codice.
  • Il codice è facile da gestire in quanto diviso in classi della classe base e della classe figlio.
  • I membri privati ​​non sono accessibili nella classe derivata quando i membri della classe base sono ereditati dalla classe derivata.
  • Non supporta eredità multiple ma può essere ottenuto tramite interfacce.
  • Aiuta a raggiungere il polimorfismo che consente a un oggetto di rappresentare più di un tipo.
  • Aiuta a dividere il codice grande in piccoli pezzi.

Caratteristiche dell'ereditarietà

Le caratteristiche di Inheritance sono:

  • L'ereditarietà può essere utilizzata per impedire l'istanza diretta della classe e per ottenere questa parola chiave astratta è stata utilizzata.
  • È possibile accedere ai membri della classe base nella classe derivata ad eccezione dei membri della chiave privata.
  • I membri della classe base possono essere ereditati nella classe derivata ad eccezione del costruttore e del distruttore.
  • In C #, i metodi virtuali di una classe base devono utilizzare la parola chiave override nella classe derivata.
  • In C #, per impedire l'eredità della classe che può essere dichiarata con la parola chiave sigillata.
  • Se i membri ereditati devono essere nascosti con lo stesso nome e la stessa firma nella classe derivata, quel metodo deve essere definito con la nuova parola chiave.

Perché usare l'ereditarietà e come semplifica il lavoro?

L'ereditarietà viene utilizzata quando è necessario utilizzare lo stesso codice in un'altra classe. Quindi, invece di scrivere lo stesso codice, ancora e ancora, esiste un concetto di programmazione orientata agli oggetti che è Ereditarietà che aiuta a usare le stesse funzionalità come i metodi o le proprietà di una classe in un'altra classe. Con l'aiuto del punto e virgola (:), possiamo ereditare i membri della classe base in classe figlio o classe derivata.

Rende facile lavorare perché aiuta a evitare la confusione della chiamata del metodo da cui viene chiamato il metodo di classe. Rende la riusabilità del codice e rende il file più leggero con un minor numero di righe di codice sorgente. Ciò rende il codice meno ridondante e più flessibile da utilizzare in diverse classi. Mantiene la struttura del programma che aiuta a leggere facilmente il codice.

Conclusione - Eredità in C #

  • L'ereditarietà è il concetto più ampiamente usato di programmazione orientata agli oggetti in tutto il linguaggio basato su OOP e così come in C #. Aiuta lo sviluppatore a realizzare molte cose e rende il codice più fluido e leggibile.
  • Il polimorfismo è l'altro concetto di oops che può essere raggiunto solo con l'ereditarietà. La maggior parte dei problemi è stata risolta con questi due concetti che vanno di pari passo.
  • In Ereditarietà la classe base e la classe derivata sono strettamente accoppiate come se ci fosse un cambiamento nella classe base, quindi automaticamente tutte le classi figlie verranno influenzate. L'ereditarietà deve essere utilizzata con molta attenzione, come se i membri dei dati non fossero utilizzati correttamente e la memoria fosse loro assegnata, ciò influisce sulle prestazioni dell'applicazione.
  • Esistono diversi livelli di ereditarietà utilizzati nella programmazione o nello sviluppo di un'applicazione. Può essere implementato in qualsiasi tipo di applicazione come applicazioni basate su Web o desktop. Dipende dallo sviluppatore come e dove utilizzare l'ereditarietà in quanto offre molta flessibilità, funzionalità e aiuta a raggiungere le cose.

Articoli consigliati

Questa è stata una guida all'ereditarietà in C #. Qui abbiamo discusso l'introduzione, i tipi, i vantaggi e le caratteristiche dell'ereditarietà in C #. Puoi anche consultare i nostri altri articoli suggeriti per saperne di più-

  1. Eredità in VB.Net
  2. Che cos'è il multithreading in C #?
  3. Comandi C #
  4. C # vs JavaScript
  5. Eredità in Java
  6. Metodi di multithreading in C #

Categoria:

Sviluppo software