Einführung in das Überladen und Überschreiben in C #

Polymorphismus ist eines der wichtigsten Konzepte in C #. Es gibt zwei Arten von Polymorphismen: Kompilierungszeit und Laufzeit. Um dies zu erreichen, werden Overloading- und Overriding-Konzepte verwendet. Beim Überschreiben kann eine untergeordnete Klasse die übergeordnete Klassenmethode auf andere Weise implementieren, die untergeordnete Klassenmethode hat jedoch denselben Namen und dieselbe Methodensignatur wie die übergeordnete, während beim Überladen mehrere Methoden mit demselben Namen und verschiedenen Parametern in einer Klasse vorhanden sind.

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

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

Überschreiben

Es gibt einige Schlüsselwörter, die wir beim Überschreiben verwenden, wie "Virtuell", "Überschreiben" und "Basis".

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”);
)
)

Hierbei werden virtuelle Schlüsselwörter und Überschreibungsschlüsselwörter verwendet. Dies bedeutet, dass die Basisklasse virtuell ist und die untergeordnete Klasse diese Klasse implementieren kann. Überschreiben 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 die Implementierung ist unterschiedlich. Die Basisklasse verfügt über eine virtuelle Klasse und kann aufgrund dieser untergeordneten Klasse die Methode der übergeordneten Klasse auf ihre eigene Weise implementieren. Die untergeordnete Klassenmethode hat eine Schlüsselwortüberschreibung, was zeigt, dass diese Methode eine Überschreibungsmethode ist.

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, mit dem die Basisklassenmethode aufgerufen wird. In diesem Fall wird die abgeleitete Methode nach der Basisklassenmethode aufgerufen.

Punkte, die man sich merken sollte:

  • In dem übergeordneten Konzept ist der Name der Methode und der Methodensignatur und des Zugriffsmodifikators immer derselbe wie der Name der Eltern- und der Kindklasse.
  • Die übergeordnete Klassenmethode kann nicht statisch sein.

Überlastung

Beim Überladen gibt es mehrere Methoden mit unterschiedlicher Methodensignatur. Im Folgenden sind einige Beispiele aufgeführt, die zeigen, wie wir eine Überladung erzielen können, indem Sie 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 enthält. 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 ganzzahligen Datentyp, während die zweite einen doppelten 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 identisch, die Reihenfolge der Parameter ist jedoch unterschiedlich. Die erste Methode hat einen Namen und eine ID bzw. wohingegen die zweite ID bzw. Name hat.

Ausgabe:

Punkte, die man sich merken sollte:

  • In einem Überlastungskonzept ist es nicht möglich, mehr als eine Methode mit denselben Parametern in Bezug auf 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 #

  • Überladen ist eine der Möglichkeiten, um statische Werte zu erzielen, und Überschreiben ist eine der Möglichkeiten, mit denen C # dynamischen Polymorphismus erzielt.
  • Es bietet Flexibilität für den Benutzer und Sauberkeit des Codes.

Fazit

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

Empfohlene Artikel

Dies ist eine Anleitung zum Überladen und Überschreiben in C #. Hier werden die Funktionsweise, die Syntax und die Vorteile des Überladens und Überschreibens in C # anhand von Beispielen und der Codeimplementierung erläutert. Sie können sich auch die folgenden Artikel ansehen, um mehr zu erfahren -

  1. Objekte in C #
  2. 2D-Arrays in C #
  3. Überschreiben in C #
  4. In C # tauschen
  5. Polymorphismus in Java
  6. 2D-Grafik in Java
  7. 3 verschiedene Arten von Arrays in PHP (Beispiele)