English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

C# Grundlagenanleitung

C# fortgeschrittene Anleitung

C# objektorientiert (OOP)

C# Operatorüberschreibung

Sie können die eingebauten Operatoren in C# neu definieren oder überschreiben. Daher können Programmierer auch Operatoren benutzerdefinierter Typen verwenden. Überschriebene Operatoren sind Funktionen mit speziellen Namen, die durch den Schlüsselwort operator durch den Symbol des Operators, der das Folgende folgt, definiert. Wie andere Funktionen auch, haben überschriebene Operatoren einen Rückgabetyp und eine Parameterliste.

Beispielsweise sehen Sie die folgende Funktion:

public static Box operator+　(Box b, Box c)
{
　　　Box box = new Box();
　　　box.length = b.length　+　c.length;
　　　box.breadth = b.breadth　+　c.breadth;
　　　box.height = b.height　+　c.height;
　　　return box;
}

Die obige Funktion implementiert den Additionsoperator für die benutzerdefinierte Klasse Box:+）。Es addiert die Eigenschaften von zwei Box-Objekten und gibt das resultierende Box-Objekt zurück.

Implementierung des Operatorüberschreibens

Das folgende Programm zeigt die vollständige Implementierung:

using System;
namespace OperatorOvlApplication
{
　　　class Box
　　　{
　　　　　　private double length;　　　　　　//　Länge
　　　　　　private double breadth;　　　　　//　Breite
　　　　　　private double height;　　　　　　//　Höhe
　　　　　　public double getVolume()
　　　　　　{
　　　　　　　　　return length　*　breadth　*　height
　　　　　　}
　　　　　　public void setLength(double len)
　　　　　　{
　　　　　　　　　length = len;
　　　　　　}
　　　　　　public void setBreadth(double bre)
　　　　　　{
　　　　　　　　　breadth = bre;
　　　　　　}
　　　　　　public void setHeight(double hei)
　　　　　　{
　　　　　　　　　height = hei;
　　　　　　}
　　　　　　//　überschreiben　+　der Operator zur Addition von zwei Box-Objekten
　　　　　　public static Box operator+　(Box b, Box c)
　　　　　　{
　　　　　　　　　Box box = new Box();
　　　　　　　　　box.length = b.length　+　c.length;
　　　　　　　　　box.breadth = b.breadth　+　c.breadth;
　　　　　　　　　box.height = b.height　+　c.height;
　　　　　　　　　return box;
　　　　　　}
　　　}
　　　class Tester
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　Box Box1　= new Box();　　　　　　　　　//　Erklärung von Box1vom Typ Box
　　　　　　　　　Box Box2　= new Box();　　　　　　　　　//　Erklärung von Box2vom Typ Box
　　　　　　　　　Box Box3　= new Box();　　　　　　　　　//　Erklärung von Box3vom Typ Box
　　　　　　　　　double volume = 0.0;　　　　　　　　　　//　Volumen
　　　　　　　　　//　Box1　Beschreibung
　　　　　　　　　Box1.setLänge(6);
　　　　　　　　　Box1.setBreite(7);
　　　　　　　　　Box1.setHeight(5);
　　　　　　　　　//　Box2　Beschreibung
　　　　　　　　　Box2.setLänge(12);
　　　　　　　　　Box2.setBreite(13);
　　　　　　　　　Box2.setHeight(10);
　　　　　　　　　//　Box1　der Volumen
　　　　　　　　　volume = Box1);
　　　　　　　　　Console.WriteLine("Box1　der Volumen: {0}
　　　　　　　　　//　Box2　der Volumen
　　　　　　　　　volume = Box2);
　　　　　　　　　Console.WriteLine("Box2　der Volumen: {0}
　　　　　　　　　//　Zwei Objekte addieren
　　　　　　　　　Box3　Gleichheit　Box1　+　Box2;
　　　　　　　　　//　Box3　der Volumen
　　　　　　　　　volume = Box3);
　　　　　　　　　Console.WriteLine("Box3　der Volumen: {0}
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt er die folgenden Ergebnisse：

Box1　Der Volumen：　210
Box2　Der Volumen：　1560
Box3　Der Volumen：　5400

Überschreibbare und nicht überschreibbare Operatoren

Die folgende Tabelle beschreibt die Fähigkeit zur Überschreibung von Operatoren in C#:

OperatorBeschreibung
+, -, !, ~, ++, --Diese einzeiligen Operatoren haben nur einen Operanden und können überschrieben werden.
+, -, *, /, %Diese binären Operatoren haben zwei Operanden und können überschrieben werden.
==, !=, <, >, <=, >=Diese Vergleichsoperatoren können überschrieben werden.
&&, ||Diese bedingten logischen Operatoren können nicht direkt überschrieben werden.
+=, -=, *=, /=, %=Diese Zuweisungsoperatoren können nicht überschrieben werden.
=, ., ?:, ->, new, is, sizeof, typeofDiese Operatoren können nicht überschrieben werden.

Online-Beispiel

Um die oben genannten Diskussionen zu erweitern, lassen Sie uns den obigen Beispiel erweitern und mehr Operatoren überschreiben:

using System;
namespace OperatorOvlApplication
{
　　　　class Box
　　　　{
　　　　　　　private double length;　　　　　　//　Länge
　　　　　　　private double breadth;　　　　　//　Breite
　　　　　　　private double height;　　　　　　//　Höhe
　　　　　　
　　　　　　　public double getVolume()
　　　　　　　{
　　　　　　　　　return length　*　breadth　*　height
　　　　　　　}
　　　　　　public void setLength(double len)
　　　　　　{
　　　　　　　　　　length = len;
　　　　　　}
　　　　　　public void setBreadth(double bre)
　　　　　　{
　　　　　　　　　　breadth = bre;
　　　　　　}
　　　　　　public void setHeight(double hei)
　　　　　　{
　　　　　　　　　　height = hei;
　　　　　　}
　　　　　　//　überschreiben　+　der Operator zur Addition von zwei Box-Objekten
　　　　　　public static Box operator+　(Box b, Box c)
　　　　　　{
　　　　　　　　　　Box box = new Box();
　　　　　　　　　　box.length = b.length　+　c.length;
　　　　　　　　　　box.breadth = b.breadth　+　c.breadth;
　　　　　　　　　　box.height = b.height　+　c.height;
　　　　　　　　　　return box;
　　　　　　}
　　　　　　
　　　　　　public static bool operator ==(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.length == rhs.length && lhs.height == rhs.height　
　　　　　　　　　　　　　&& lhs.breadth == rhs.breadth)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator !=(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.length != rhs.length || lhs.height != rhs.height　
　　　　　　　　　　　　　　|| lhs.breadth != rhs.breadth)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator <(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.Länge < rhs.Länge && lhs.Höhe　
　　　　　　　　　　　　　　< rhs.height && lhs.Breite < rhs.Breite)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator >(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.Länge > rhs.Länge && lhs.Höhe　
　　　　　　　　　　　　　　> rhs.height && lhs.Breite > rhs.Breite)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator <=(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.Länge <= rhs.Länge && lhs.Höhe　
　　　　　　　　　　　　　　<= rhs.height && lhs.Breite <= rhs.Breite)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator >=(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.Länge >= rhs.Länge && lhs.Höhe　
　　　　　　　　　　　　　>= rhs.height && lhs.Breite >= rhs.Breite)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public override string ToString()
　　　　　　{
　　　　　　　　　　return String.Format("({0}, ",1}, {2})
　　　　　　}
　　　
　　　}
　　　　
　　　class Tester
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　Box Box1　= new Box();　　　　　　　　　　//　Erklärung von Box1vom Typ Box
　　　　　　　　Box Box2　= new Box();　　　　　　　　　　//　Erklärung von Box2vom Typ Box
　　　　　　　　Box Box3　= new Box();　　　　　　　　　　//　Erklärung von Box3vom Typ Box
　　　　　　　　Box Box4　= new Box();
　　　　　　　　double volume = 0.0;　　　//　Volumen
　　　　　　　　//　Box1　Beschreibung
　　　　　　　　Box1.setLänge(6);
　　　　　　　　Box1.setBreite(7);
　　　　　　　　Box1.setHeight(5);
　　　　　　　　//　Box2　Beschreibung
　　　　　　　　Box2.setLänge(12);
　　　　　　　　Box2.setBreite(13);
　　　　　　　　Box2.setHeight(10);
　　　　　　　//　Verwenden Sie die überschriebene ToString() -Methode, um zwei Kästen anzuzeigen
　　　　　　　　Console.WriteLine("Box1: {0}1);
　　　　　　　　Console.WriteLine("Box2: {0}2);
　　　　　　　　
　　　　　　　　//　Box1　der Volumen
　　　　　　　　volume = Box1);
　　　　　　　　Console.WriteLine("Box1　der Volumen: {0}
　　　　　　　　//　Box2　der Volumen
　　　　　　　　volume = Box2);
　　　　　　　　Console.WriteLine("Box2　der Volumen: {0}
　　　　　　　　//　Zwei Objekte addieren
　　　　　　　　Box3　Gleichheit　Box1　+　Box2;
　　　　　　　　Console.WriteLine("Box3: {0}3);
　　　　　　　　//　Box3　der Volumen
　　　　　　　　volume = Box3);
　　　　　　　　Console.WriteLine("Box3　der Volumen: {0}
　　　　　　　　//Vergleich der Kästen
　　　　　　　　Wenn　(Box1　> Box2)
　　　　　　　　　　Console.WriteLine("Box1　größer als Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Nicht größer als　Box2");
　　　　　　　　Wenn　(Box1　< Box2)
　　　　　　　　　　Console.WriteLine("Box1　Kleiner als　Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Nicht kleiner als　Box2");
　　　　　　　　Wenn　(Box1　Größer als　Box2)
　　　　　　　　　　Console.WriteLine("Box1　Größer als oder gleich　Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Nicht größer als oder gleich　Box2");
　　　　　　　　Wenn　(Box1　Kleiner als oder gleich　Box2)
　　　　　　　　　　Console.WriteLine("Box1　Kleiner als oder gleich　Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Nicht kleiner als oder gleich　Box2");
　　　　　　　　Wenn　(Box1　Ungleichheit　Box2)
　　　　　　　　　　Console.WriteLine("Box1　Ungleichheit　Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Gleichheit　Box2");
　　　　　　　　Box4　Gleichheit　Box3;
　　　　　　　　Wenn　(Box3　Gleichheit　Box4)
　　　　　　　　　　Console.WriteLine("Box3　Gleichheit　Box4");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box3　Ungleichheit　Box4");
　　　　　　　　Console.ReadKey();
　　　　　　}
　　　　}
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt er die folgenden Ergebnisse：

Box1：　(6,　7,　5)
Box2：　(12,　13,　10)
Box1　Der Volumen：　210
Box2　Der Volumen：　1560
Box3：　(18,　20,　15)
Box3　Der Volumen：　5400
Box1　Nicht größer als　Box2
Box1　Kleiner als　Box2
Box1　Nicht größer als oder gleich　Box2
Box1　Kleiner als oder gleich　Box2
Box1　Ungleichheit　Box2
Box3　Gleichheit　Box4
C# Namensraum (Namespace)C# Polymorphie