C# Overerving
C#-overerving
In deze zelfstudie leren we over C#-overerving en zijn typen met behulp van voorbeelden.
In C# kunnen we met overerving een nieuwe klasse maken van een bestaande klasse. Het is een belangrijk kenmerk van Object-Oriented Programming (OOP).
De klasse waaruit een nieuwe klasse wordt gemaakt, staat bekend als de basisklasse (bovenliggende of superklasse). En de nieuwe klasse heet afgeleide klasse (kind of subklasse)
De afgeleide klasse erft de velden en methoden van de basisklasse. Dit helpt bij de herbruikbaarheid van code in C#.
Hoe overerving in C# uitvoeren?
In C# gebruiken we de : symbool om overerving uit te voeren. Bijvoorbeeld,
class Animal {
// fields and methods
}
// Dog inherits from Animal
class Dog : Animal {
// fields and methods of Animal
// fields and methods of Dog
}
Hier erven we de afgeleide klasse Hond uit de basisklasse Animal . De Hond class heeft nu toegang tot de velden en methoden van Animal klasse.
Voorbeeld:C#-overerving
using System;
namespace Inheritance {
// base class
class Animal {
public string name;
public void display() {
Console.WriteLine("I am an animal");
}
}
// derived class of Animal
class Dog : Animal {
public void getName() {
Console.WriteLine("My name is " + name);
}
}
class Program {
static void Main(string[] args) {
// object of derived class
Dog labrador = new Dog();
// access field and method of base class
labrador.name = "Rohu";
labrador.display();
// access method from own class
labrador.getName();
Console.ReadLine();
}
}
} Uitvoer
I am an animal My name is Rohu
In het bovenstaande voorbeeld hebben we een subklasse afgeleid Hond uit de superklasse Animal . Let op de uitspraken,
labrador.name = "Rohu";
labrador.getName(); Hier gebruiken we labrador (object van hond) om toegang te krijgen tot de naam en display() van het Dier klas. Dit is mogelijk omdat de afgeleide klasse alle velden en methoden van de basisklasse erft.
We hebben ook toegang gekregen tot de naam veld binnen de methode van de Hond klasse.
is-een relatie
In C# is overerving een is-a-relatie. We gebruiken alleen overerving als er een is-a-relatie is tussen twee klassen. Bijvoorbeeld,
- Hond is een dier
- Appel is een Fruit
- Auto is een Voertuig
We kunnen Hond . afleiden van Dier klas. Evenzo, Apple van Fruit klasse en Auto van Voertuig klasse.
beschermde leden in C# Inheritance
Wanneer we een veld of methode declareren als protected , het is alleen toegankelijk vanuit dezelfde klasse en zijn afgeleide klassen.
Voorbeeld:beschermde leden in erfenis
using System;
namespace Inheritance {
// base class
class Animal {
protected void eat() {
Console.WriteLine("I can eat");
}
}
// derived class of Animal
class Dog : Animal {
static void Main(string[] args) {
Dog labrador = new Dog();
// access protected method from base class
labrador.eat();
Console.ReadLine();
}
}
} Uitvoer
I can eat
In het bovenstaande voorbeeld hebben we een klasse gemaakt met de naam Animal . De klasse bevat een beveiligde methode eat() .
We hebben de Hond . afgeleid klasse van het Dier klas. Let op de verklaring,
labrador.eat();
Sinds de protected methode toegankelijk is vanuit afgeleide klassen, hebben we toegang tot de eat() methode van de Hond klasse.
Soorten overerving
Er zijn de volgende soorten overerving:
1. Enkele erfenis
Bij enkele overerving erft een enkele afgeleide klasse van een enkele basisklasse.
2. Overerving op meerdere niveaus
Bij overerving op meerdere niveaus erft een afgeleide klasse van een basis en fungeert dezelfde afgeleide klasse als een basisklasse voor een andere klasse.
3. Hiërarchische overerving
Bij hiërarchische overerving erven meerdere afgeleide klassen van een enkele basisklasse.
4. Meerdere overerving
Bij meervoudige overerving erft een enkele afgeleide klasse van meerdere basisklassen. C# ondersteunt geen meervoudige overerving. We kunnen echter meerdere overerving bereiken via interfaces.
5. Hybride overerving
Hybride overerving is een combinatie van twee of meer soorten overerving. De combinatie van multilevel en hiërarchische overerving is een voorbeeld van hybride overerving.
Methode overschrijven in C#-overname
Als dezelfde methode aanwezig is in zowel de basisklasse als de afgeleide klasse, overschrijft de methode in de afgeleide klasse de methode in de basisklasse. Dit wordt methode-overriding genoemd in C#. Bijvoorbeeld,
using System;
namespace Inheritance {
// base class
class Animal {
public virtual void eat() {
Console.WriteLine("I eat food");
}
}
// derived class of Animal
class Dog : Animal {
// overriding method from Animal
public override void eat() {
Console.WriteLine("I eat Dog food");
}
}
class Program {
static void Main(string[] args) {
// object of derived class
Dog labrador = new Dog();
// accesses overridden method
labrador.eat();
}
}
}
Uitvoer
I eat Dog food
In het bovenstaande voorbeeld is de eat() methode is aanwezig in zowel de basisklasse als de afgeleide klasse.
Wanneer we eat() . aanroepen met behulp van de Hond object labrador ,
labrador.eat(); de methode binnen Hond wordt genoemd. Dit komt omdat de methode binnen Hond overschrijft dezelfde methode binnen Animal .
Let op, we hebben virtual . gebruikt en overschrijven met methoden van respectievelijk de basisklasse en afgeleide klasse. Hier,
virtual- staat toe dat de methode wordt overschreven door de afgeleide klasseoverride- geeft aan dat de methode de methode van de basisklasse overschrijft
basiszoekwoord in C#-overerving
In het vorige voorbeeld zagen we dat de methode in de afgeleide klasse de methode in de basisklasse overschrijft.
Maar wat als we de methode van de basisklasse ook willen aanroepen?
In dat geval gebruiken we de base sleutelwoord om de methode van de basisklasse uit de afgeleide klasse aan te roepen.
Voorbeeld:basiszoekwoord in C#-overerving
using System;
namespace Inheritance {
// base class
class Animal {
public virtual void eat() {
Console.WriteLine("Animals eat food.");
}
}
// derived class of Animal
class Dog : Animal {
// overriding method from Animal
public override void eat() {
// call method from Animal class
base.eat();
Console.WriteLine("Dogs eat Dog food.");
}
}
class Program {
static void Main(string[] args) {
Dog labrador = new Dog();
labrador.eat();
}
}
} Uitvoer
Animals eat food. Dogs eat Dog food.
In het bovenstaande voorbeeld is de eat() methode is aanwezig in zowel de basisklasse Animal en de afgeleide klasse Hond . Let op de verklaring,
base.eat();
Hier hebben we de base . gebruikt trefwoord om toegang te krijgen tot de methode van Animal klas van de Hond klasse.
Belang van overerving in C#
Laten we een situatie bekijken om het belang van overerving te begrijpen.
Stel dat we werken met regelmatige veelhoeken zoals vierkanten, rechthoeken, enzovoort. En we moeten de omtrek van deze polygonen vinden op basis van de invoer.
1. Aangezien de formule om de omtrek te berekenen voor alle regelmatige veelhoeken hetzelfde is, kunnen we een RegularPolygon maken class en een methode calculatePerimeter() om de omtrek te berekenen.
class RegularPolygon {
calculatePerimeter() {
// code to compute perimeter
}
} 2. En erven Vierkant en Rechthoek klassen uit de RegularPolygon klas. Elk van deze klassen heeft eigenschappen om de lengte en het aantal zijden op te slaan, omdat ze voor alle polygonen verschillend zijn.
class Square : RegularPolygon {
int length = 0;
int sides = 0;
} We geven de waarde door van de lengte en zijkanten om omtrek() te berekenen om de omtrek te berekenen.
Dit is hoe overerving onze code herbruikbaar en intuïtiever maakt.
Voorbeeld:belang van overerving
using System;
namespace Inheritance {
class RegularPolygon {
public void calculatePerimeter(int length, int sides) {
int result = length * sides;
Console.WriteLine("Perimeter: " + result);
}
}
class Square : RegularPolygon {
public int length = 200;
public int sides = 4;
public void calculateArea() {
int area = length * length;
Console.WriteLine("Area of Square: " + area);
}
}
class Rectangle : RegularPolygon {
public int length = 100;
public int breadth = 200;
public int sides = 4;
public void calculateArea() {
int area = length * breadth;
Console.WriteLine("Area of Rectangle: " + area);
}
}
class Program {
static void Main(string[] args) {
Square s1 = new Square();
s1.calculateArea();
s1.calculatePerimeter(s1.length, s1.sides);
Rectangle t1 = new Rectangle();
t1.calculateArea();
t1.calculatePerimeter(t1.length, t1.sides);
}
}
} Uitvoer
Area of Square: 40000 Perimeter: 800 Area of Rectangle: 20000 Perimeter: 400
In het bovenstaande voorbeeld hebben we een RegularPolygon . gemaakt klasse die een methode heeft om de omtrek van de regelmatige veelhoek te berekenen.
Hier, het Vierkant en Rechthoek erven van RegularPolygon .
De formule om de omtrek te berekenen is voor iedereen hetzelfde, daarom hebben we de calculatePerimeter() opnieuw gebruikt methode van de basisklasse.
En aangezien de formule om de oppervlakte te berekenen voor verschillende vormen anders is, hebben we een aparte methode gecreëerd binnen de afgeleide klasse om de oppervlakte te berekenen.
C Taal