C#-Vererbung
C#-Vererbung
In diesem Tutorial lernen wir die C#-Vererbung und ihre Typen anhand von Beispielen kennen.
In C# ermöglicht uns die Vererbung, eine neue Klasse aus einer vorhandenen Klasse zu erstellen. Es ist ein Schlüsselmerkmal der objektorientierten Programmierung (OOP).
Die Klasse, aus der eine neue Klasse erstellt wird, wird als Basisklasse (Eltern- oder Oberklasse) bezeichnet. Und die neue Klasse heißt abgeleitete Klasse (Kind- oder Unterklasse)
Die abgeleitete Klasse erbt die Felder und Methoden der Basisklasse. Dies hilft bei der Wiederverwendbarkeit von Code in C#.
Wie führt man Vererbung in C# durch?
In C# verwenden wir den : Symbol, um die Vererbung durchzuführen. Zum Beispiel
class Animal {
// fields and methods
}
// Dog inherits from Animal
class Dog : Animal {
// fields and methods of Animal
// fields and methods of Dog
}
Hier erben wir die abgeleitete Klasse Dog aus der Basisklasse Animal . Der Hund Klasse kann jetzt auf die Felder und Methoden von Animal zugreifen Klasse.
Beispiel:C#-Vererbung
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();
}
}
} Ausgabe
I am an animal My name is Rohu
Im obigen Beispiel haben wir eine Unterklasse Dog abgeleitet aus der Oberklasse Animal . Beachten Sie die Anweisungen,
labrador.name = "Rohu";
labrador.getName(); Hier verwenden wir Labrador (Objekt von Dog), um auf den Namen zuzugreifen und Anzeige() des Tiers Klasse. Dies ist möglich, da die abgeleitete Klasse alle Felder und Methoden der Basisklasse erbt.
Außerdem haben wir auf den Namen zugegriffen -Feld innerhalb der Methode des Dog Klasse.
ist-eine Beziehung
In C# ist Vererbung eine Ist-ein-Beziehung. Wir verwenden Vererbung nur, wenn zwischen zwei Klassen eine is-a-Beziehung besteht. Zum Beispiel
- Hund ist ein Tier
- Apfel ist eine Frucht
- Auto ist ein Fahrzeug
Wir können Dog ableiten von Tier Klasse. Ebenso Apple aus Obst Klasse und Auto von Fahrzeug Klasse.
geschützte Member in der C#-Vererbung
Wenn wir ein Feld oder eine Methode als protected deklarieren , kann nur von derselben Klasse und ihren abgeleiteten Klassen darauf zugegriffen werden.
Beispiel:geschützte Mitglieder in Vererbung
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();
}
}
} Ausgabe
I can eat
Im obigen Beispiel haben wir eine Klasse namens Animal erstellt . Die Klasse enthält eine geschützte Methode eat() .
Wir haben den Hund abgeleitet Klasse von Animal Klasse. Beachten Sie die Anweisung,
labrador.eat();
Seit dem protected Methode von abgeleiteten Klassen aus zugegriffen werden kann, können wir auf eat() zugreifen Methode vom Dog Klasse.
Arten der Vererbung
Es gibt folgende Arten der Vererbung:
1. Einfache Vererbung
Bei der einfachen Vererbung erbt eine einzelne abgeleitete Klasse von einer einzelnen Basisklasse.
2. Vererbung auf mehreren Ebenen
Bei der mehrstufigen Vererbung erbt eine abgeleitete Klasse von einer Basis, und dann fungiert dieselbe abgeleitete Klasse als Basisklasse für eine andere Klasse.
3. Hierarchische Vererbung
Bei der hierarchischen Vererbung erben mehrere abgeleitete Klassen von einer einzigen Basisklasse.
4. Mehrfachvererbung
Bei der Mehrfachvererbung erbt eine einzelne abgeleitete Klasse von mehreren Basisklassen. C# unterstützt keine Mehrfachvererbung. Wir können jedoch Mehrfachvererbung durch Schnittstellen erreichen.
5. Hybride Vererbung
Die hybride Vererbung ist eine Kombination aus zwei oder mehr Vererbungsarten. Die Kombination aus mehrstufiger und hierarchischer Vererbung ist ein Beispiel für hybride Vererbung.
Methodenüberschreibung bei der C#-Vererbung
Wenn dieselbe Methode sowohl in der Basisklasse als auch in der abgeleiteten Klasse vorhanden ist, überschreibt die Methode in der abgeleiteten Klasse die Methode in der Basisklasse. Dies wird in C# als Methodenüberschreibung bezeichnet. Zum Beispiel
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();
}
}
}
Ausgabe
I eat Dog food
Im obigen Beispiel das eat() -Methode ist sowohl in der Basisklasse als auch in der abgeleiteten Klasse vorhanden.
Wenn wir eat() aufrufen mit dem Hund Objekt Labrador ,
labrador.eat(); die Methode in Dog wird genannt. Das liegt daran, dass die Methode innerhalb von Dog überschreibt dieselbe Methode innerhalb von Animal .
Beachten Sie, dass wir virtual verwendet haben und überschreiben mit Methoden der Basisklasse bzw. der abgeleiteten Klasse. Hier,
virtual- ermöglicht das Überschreiben der Methode durch die abgeleitete Klasseoverride- zeigt an, dass die Methode die Methode der Basisklasse überschreibt
Basisschlüsselwort in C#-Vererbung
Im vorherigen Beispiel haben wir gesehen, dass die Methode in der abgeleiteten Klasse die Methode in der Basisklasse überschreibt.
Was aber, wenn wir auch die Methode der Basisklasse aufrufen wollen?
In diesem Fall verwenden wir den base Schlüsselwort zum Aufrufen der Methode der Basisklasse aus der abgeleiteten Klasse.
Beispiel:Basisschlüsselwort in C#-Vererbung
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();
}
}
} Ausgabe
Animals eat food. Dogs eat Dog food.
Im obigen Beispiel das eat() -Methode ist sowohl in der Basisklasse Animal vorhanden und die abgeleitete Klasse Dog . Beachten Sie die Anweisung,
base.eat();
Hier haben wir den base verwendet Schlüsselwort, um auf die Methode von Animal zuzugreifen Klasse vom Hund Klasse.
Bedeutung der Vererbung in C#
Betrachten wir eine Situation, um die Bedeutung der Vererbung zu verstehen.
Angenommen, wir arbeiten mit regelmäßigen Polygonen wie Quadraten, Rechtecken usw. Und wir müssen den Umfang dieser Polygone basierend auf der Eingabe finden.
1. Da die Formel zur Berechnung des Umfangs für alle regulären Polygone gleich ist, können wir ein RegularPolygon erstellen Klasse und eine Methode calculatePerimeter() um den Umfang zu berechnen.
class RegularPolygon {
calculatePerimeter() {
// code to compute perimeter
}
} 2. Und erbe Quadrat und Rechteck Klassen aus dem RegularPolygon Klasse. Jede dieser Klassen hat Eigenschaften, um die Länge und Anzahl der Seiten zu speichern, da sie für alle Polygone unterschiedlich sind.
class Square : RegularPolygon {
int length = 0;
int sides = 0;
} Wir übergeben den Wert der Länge und Seiten zu Berechnungsumfang() um den Umfang zu berechnen.
So macht die Vererbung unseren Code wiederverwendbar und intuitiver.
Beispiel:Bedeutung der Vererbung
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);
}
}
} Ausgabe
Area of Square: 40000 Perimeter: 800 Area of Rectangle: 20000 Perimeter: 400
Im obigen Beispiel haben wir ein RegularPolygon erstellt Klasse, die eine Methode zur Berechnung des Umfangs des regelmäßigen Polygons hat.
Hier das Quadrat und Rechteck erben von RegularPolygon .
Die Formel zur Berechnung des Umfangs ist für alle gleich, daher haben wir calculatePerimeter() wiederverwendet Methode der Basisklasse.
Und da die Formel zur Berechnung der Fläche für verschiedene Formen unterschiedlich ist, haben wir eine separate Methode innerhalb der abgeleiteten Klasse erstellt, um die Fläche zu berechnen.
C Sprache