Hvordan bruke arv i C#

Mens vi skriver kode på et objektorientert programmeringsspråk, kan vi komme over situasjoner der vi trenger å gjenbruke eksisterende kode i en ny klasse eller legge til ytterligere funksjonalitet til en eksisterende klasse. I slike tilfeller kommer arven godt med. Arv i objektorientert programmering lar klasser arve egenskapene og atferden til en annen klasse. Denne artikkelen dekker bruken av arv i C# og dens forskjellige typer.

Innholdsfortegnelse

Hva er arv i C#

Hvordan fungerer arv i C#

Arvtyper i C#

• Enkelt arv
• Arv på flere nivåer
• Hierarkisk arv
• Flere arv (ikke støttet i C#)

Konklusjon

Hva er arv i C#

I C# ved hjelp av arv kan en klasse ta eller arve egenskapene og metodene i en annen klasse. Med andre ord, det tillater opprettelse av en ny klasse basert på en eksisterende klasse, som er kjent som baseklassen eller superklassen. En klasse dannet etter å ha tatt egenskapene til en baseklasse kalles en avledet klasse eller underklasse.

Denne avledede klassen i C# tar ikke bare egenskaper til baseklassen, men kan også legge til sine egne unike funksjoner.

Hvordan fungerer arv i C#

I C#oppnås arv ved bruk av tykktarmen (:) symbol. Baseklassenavnet er definert etter tykktarmen, og det er spesifisert av den avledede klassen.

Følgende er syntaks for å lage en avledet klasse som tar egenskaper fra baseklassen:

Klasse avledet Class: BaseClass

// avledede klassemedlemmer

Her i denne koden, DEDEDCLASS er navnet på den avledede klassen, og BaseClass er navnet på baseklassen. De : symbolet indikerer at avledetklasse arver fra baseclass. Medlemmene av DeDivedClass kan få tilgang til BaseClass -medlemmer, forutsatt at de ikke er private.

Arvtyper i C#

C# støtter fire typer arv: enkelt, flernivå, hierarkisk og flere arv. La oss se på hver type.

Enkelt arv

Enkelt arv er den vanligste arven, der en avledet klasse tar eller arver egenskaper til bare en enkelt baseklasse.

For eksempel, Den gitte koden forklarer klassehierarki og demonstrerer arvekonsepter.

ved hjelp av system;
ved hjelp av system;
klassebil

public void start ()

Konsoll.WritLine ("bil startet");


Klasse Tesla: bil

public void Accelerate ()

Konsoll.WritLine ("Tesla Accelerating");


Klasseprogram

statisk tomrom (streng [] args)

Tesla Mytesla = new Tesla ();
Mytesla.Start(); // Output: Bil startet
Mytesla.Akselerere(); // OUTPUT: Tesla Accelerating

I koden ovenfor, Bilklasse er baseklassen og har en metode som heter Start(), som ganske enkelt skriver ut meldingen Bil startet til konsollen.

De Tesla -klasse er avledet fra bilklassen, og den tar alle egenskapene til bilklassen. Tesla -klassen legger til en metode som heter Akselerere(), som skriver ut meldingen Tesla akselererer til konsollen.

De Hoved() Funksjon definerer en forekomst av Tesla -klassen som heter Mytesla og kaller start () og akselererte () metoder.

Arv på flere nivåer

Arv på flere nivåer er der en avledet klasse arver fra en annen avledet klasse, som igjen arver fra en baseklasse.

For eksempel, Følgende C# -kode demonstrerer arv og metode som overstyrer i et klassehierarki.

ved hjelp av system;
Klassedyr

public void spis ()

Konsoll.WritLine ("Animal Eating");


Klassepattedyr: Dyr

public void Run ()

Konsoll.WritLine ("pattedyrløp");


Klassehund: pattedyr

public void bark ()

Konsoll.WritLine ("Dog Barking");


Klasseprogram

statisk tomrom (streng [] args)

Hund MyDog = ny hund ();
min hund.Spise(); // Output: Dyrespising
min hund.Løpe(); // Output: pattedyrløp
min hund.Bark(); // Output: Dog bjeffing

Her Hund er en avledet klasse som arver fra Pattedyr, som igjen arver fra Dyr. Hundeklassen har tilgang til alle egenskapene, metodene og atferden til pattedyr og dyr, og kan også definere sin egen unike metode Bark().

De Dyreklasse er baseklassen og har en metode som heter Spise(), som ganske enkelt skriver ut meldingsdyret som spiser til konsollen.

De Pattedyrklasse er avledet fra dyreklassen og legger til en metode som heter Løpe(), som skriver ut meldingen pattedyr løper til konsollen.

De Hundeklasse er avledet fra pattedyrklassen og legger til en metode som heter Bark(), som skriver ut meldingshunden som bjeffer til konsollen.

Main () -metoden skaper en forekomst av hundeklassen som heter min hund og kaller dens spis (), løp () og bark () metoder.

Merk at EAT () og Run () -metodene ikke er definert i hundeklassen, men arves fra foreldreklassene Dyr og Pattedyr, henholdsvis. De Bark() Metoden er bare definert i hundeklassen.

Hierarkisk arv

I hierarkisk arv blir forskjellige antall avledede klasser arvet fra bare en baseklasse. For eksempel:

ved hjelp av system;
klasseform

public void trekning ()

Konsoll.WritLine ("tegneform");


Klassesirkel: form

public void Fill ()

Konsoll.WritLine ("Fyll Circle");


Klasset Square: form

public void color ()

Konsoll.WritLine ("Coloring Square");


Klasseprogram

statisk tomrom (streng [] args)

Circle MyCircle = new Circle ();
mycircle.Tegne(); // utgang: tegneform
mycircle.Fylle(); // OUTPUT: Fyll sirkel
Firkant MySquare = new Square ();
Mysquare.Tegne(); // utgang: tegneform
Mysquare.Farge(); // Output: Coloring Square

I koden ovenfor, begge Sirkel og Torget er avledede klasser som arver fra Form. De har tilgang til Draw () -metoden definert i form og kan også definere sine egne unike metoder fyll () og farge ().

Her opprettet vi et objekt av sirkelklassen som heter mycircle og et objekt av Torget Klasse som heter Mysquare. Vi kaller da Tegne() metode, som er arvet fra formklassen, på begge objektene.

Deretter kaller vi Fylle() metode på mycircle, som er spesifikk for sirkelklassen, og Farge() Metode på Mysquare, som er spesifikk for Square -klassen.

Utgangen vil bli skrevet ut til konsollen som nedenfor:

Flere arv

Flere arv er der en avledet klasse arver fra flere baseklasser. C# støtter imidlertid ikke flere arv. For å oppnå lignende funksjonalitet bruker C# grensesnitt.

Konklusjon

Arv i C# lar klasser arve oppførsel og funksjonalitet fra baseklasser. Ved hjelp av arv kan vi gjenbruke kode og lage en hierarkisk flyt inne i programmet. Ved å forstå de forskjellige arvenes typer, kan man skrive mer effektiv og organisert kode som er lettere å vedlikeholde og utvide.