Überladen und Überschreiben in C#

Polymorphismus ist eines der wichtigen Konzepte in C#. Es gibt zwei Arten von Polymorphismus: Kompilierzeit und Laufzeit. Um dies zu erreichen, werden Überladungs- bzw. Überschreibungskonzepte verwendet. Beim Überschreiben kann eine untergeordnete Klasse die Methode der übergeordneten Klasse auf andere Weise implementieren, aber die Methode der untergeordneten Klasse hat denselben Namen und dieselbe Methodensignatur wie die übergeordnete Klasse, während es beim Überladen mehrere Methoden in einer Klasse mit demselben Namen und unterschiedlichen Parametern gibt.

Wie funktioniert das Überschreiben und Überladen in C#?

Die Funktionsweise des Überschreibens und Überladens in C# wird unten anhand von Beispielen erläutert:

Überschreiben

Es gibt einige Schlüsselwörter, die wir beim Überschreiben verwenden, wie „virtual“, „override“ und „base“.

Syntax:

class Parent
{
public virtual void Example() // base class
{
Console.WriteLine("parent class");
}
}
class Child: Parent
{
public override void Example() // derived class
{
base.Example();
Console.WriteLine("Child class");
}
}

Hier werden die Schlüsselwörter „virtual“ und „override“ verwendet, was bedeutet, dass die Basisklasse virtuell ist und die untergeordnete Klasse diese Klasse implementieren kann. „override“ bedeutet, dass diese untergeordnete Klasse denselben Namen und dieselbe Methodensignatur wie die übergeordnete Klasse hat.

Beispiel #1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverridingExample
{
class Subject           // base class
{
public virtual void study()              // base class method
{
Console.WriteLine("Study all the subjects");
}
}
class Mathematics: Subject      //  derived class
{
public override void study()        // derived class method
{
Console.WriteLine("Study Mathematics");
}
}
class Program
{
// main method
static void Main(string[] args)
{
Subject s = new Mathematics();
s.study();
Console.ReadLine();
}
}
}

Im obigen Beispiel ist der Methodenname derselbe, aber ihre Implementierung ist unterschiedlich. Die Basisklasse ist virtuell und daher kann die untergeordnete Klasse die Methode der übergeordneten Klasse auf ihre eigene Weise implementieren. Die untergeordnete Klassenmethode verfügt über das Schlüsselwort override, was zeigt, dass es sich bei dieser Methode um eine Override-Methode handelt.

Ausgabe:

Beispiel #2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverridingExample
{
class Subject             // base class
{
public virtual void study()              // base class method
{
Console.WriteLine("Study all the subjects");
}
}
class Mathematics: Subject      //  derived class
{
public override void study()        // derived class method
{
base.study();
Console.WriteLine("Study Mathematics");
}
}
class Program
{
// main method
static void Main(string[] args)
{
Mathematics m = new Mathematics();
m.study();
Console.ReadLine();
}
}
}

Ausgabe:

In diesem Beispiel verfügt die abgeleitete Klasse über ein Basisschlüsselwort, das zum Aufrufen der Basisklassenmethode verwendet wird. In diesem Fall wird die abgeleitete Methode also nach der Basisklassenmethode aufgerufen.

Wichtige Punkte:

• Im übergeordneten Konzept sind der Name der Methode und die Methodensignatur sowie der Zugriffsmodifikator immer derselbe wie der der übergeordneten und untergeordneten Klasse.
• Die übergeordnete Klassenmethode darf nicht statisch sein.

Überlastung

Beim Überladen gibt es mehrere Methoden mit unterschiedlichen Methodensignaturen. Nachfolgend finden Sie einige Beispiele, die zeigen, wie wir eine Überladung erreichen können, indem wir die Anzahl der Parameter, die Reihenfolge der Parameter und die Datentypen der Parameter variieren.

Beispiel #1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
{
class Demo
{
public int Sum(int x, int y)
{
int value = x + y;
return value;
}
public int Sum(int x, int y, int z)
{
int value = x + y + z;
return value;
}
public static void Main(string[] args) // main method
{
Demo d = new Demo();
int sum1 = d.Sum(24, 28);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
int sum2 = d.Sum(10, 20, 30);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
Console.ReadLine();
}
}
}

Im obigen Beispiel gibt es zwei Methoden mit demselben Namen, aber einer unterschiedlichen Anzahl von Parametern.  Die erste Methode besteht aus zwei Parametern, während die zweite drei Parameter hat. Dies wird als Methodenüberladung bezeichnet.

Ausgabe:

Beispiel #2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
{
class Demo
{
public int Sum(int x, int y, int z)
{
int value = x + y + z;
return value;
}
public double Sum(double x, double y, double z)
{
double value = x + y + z;
return value;
}
public static void Main(string[] args) // main method
{
Demo d = new Demo();
int sum1 = d.Sum(24, 28,7);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
double sum2 = d.Sum(10.0, 20.0, 30.0);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
Console.ReadLine();
}
}
}

Im obigen Beispiel gibt es zwei Methoden mit demselben Namen, aber unterschiedlichen Datentypen. Die erste Methode hat einen Integer-Datentyp, während die zweite einen Double-Datentyp hat. In diesem Fall variieren die Parameter aufgrund des unterschiedlichen Datentyps.

Ausgabe:

Beispiel #3

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
{
class Demo
{
public void Details(String name,int id)
{
Console.WriteLine("Name " + name + ", "
+ "Id " + id); ;
}
public void Details(int id,string name)
{
Console.WriteLine("Name " + name + ", "
+ "Id " + id);
}
public static void Main(string[] args) // main method
{
Demo d = new Demo();
d.Details("John", 10);
d.Details("Joe", 20);
Console.ReadLine();
}
}
}

Im obigen Beispiel sind die Namen der Methoden gleich, aber die Reihenfolge der Parameter ist unterschiedlich. Die erste Methode hat einen Namen bzw. eine ID. während der zweite eine ID bzw. einen Namen hat.

Ausgabe:

Wichtige Punkte:

• In einem Überladungskonzept ist es nicht möglich, mehr als eine Methode mit den gleichen Parametern hinsichtlich Reihenfolge, Typ und Anzahl zu definieren.
• Es ist nicht möglich, eine Methode basierend auf den verschiedenen Rückgabetypen zu überladen.

Vorteile des Überladens und Überschreibens in C#

Im Folgenden werden die Vorteile erläutert.

• Überladen ist eine der Möglichkeiten, statischen Polymorphismus zu erreichen, und Überschreiben ist eine der Möglichkeiten, mit denen C# dynamischen Polymorphismus erreicht.
• Es bietet dem Benutzer Flexibilität und die Sauberkeit des Codes.

Fazit

Überladen und Überschreiben spielen eine wichtige Rolle beim Erreichen von Polymorphismus. Durch das Überschreiben können abgeleitete Klassen auf ihre eigene Art und Weise implementiert werden, und beim Überladen geht es andererseits um Methoden mit demselben Namen und verschiedenen Arten von Parameterimplementierungen.

Das obige ist der detaillierte Inhalt vonÜberladen und Überschreiben in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!