C# Grundlagenanleitung

C# Fortgeschrittene Anleitung

C# objektorientiert (OOP)

C# Polymorphie

Polymorphie ist die Fähigkeit, dass dasselbe Verhalten mehrere verschiedene Darstellungsformen oder Formen hat.

Polymorphiebedeutet, dass es mehrere Formen gibt. In der objektorientierten Programmierparadigma wird Polymorphie oft als "ein Interface, mehrere Funktionen" dargestellt.

Polymorphie kann statisch oder dynamisch sein. InStatische PolymorphieIn der Funktion reagiert das Ereignis bei der Kompilierung. In动态多态性In der Funktion reagiert auf das Ereignis bei der Ausführung.

In C# ist jeder Typ polymorph, da alle Typen, einschließlich der vom Benutzer definierten Typen, von Object abgeleitet sind.

Polymorphie bedeutet, dass derselbe Interface mit verschiedenen Beispielen unterschiedliche Operationen ausführt, wie im Diagramm gezeigt:

In der Realität, zum Beispiel, wenn wir F drücken1 Diese Aktion:

Wenn die Eingabe im Flash-Bildschirm erfolgt, wird AS angezeigt; 3 Hilfe-Dokument;
Wenn die Eingabe unter Word erfolgt, wird die Word-Hilfe angezeigt;
Unter Windows wird bei der Eingabe die Windows-Hilfe und -Unterstützung angezeigt.

Das gleiche Ereignis, das auf verschiedenen Objekten stattfindet, kann unterschiedliche Ergebnisse verursachen.

Statische Polymorphie

Bei der Kompilierung wird das Verbindungsmechanismus von Funktionen und Objekten als Early Binding oder statisches Binding bezeichnet. C# bietet zwei Technologien, um statische Polymorphie zu erreichen. Dies sind:

函数重载
Operator Overloading

Operator Overloading wird im nächsten Kapitel besprochen. Nachfolgend werden wir die Overloading von Funktionen diskutieren.

函数重载

您可以在同一个范围内对相同的函数名有多个定义。函数的定义必须彼此不同，可以是参数列表中的参数类型不同，也可以是参数个数不同。不能重载只有返回类型不同的函数声明。

下面的示例演示了几个相同的函数 Add()，用于对不同个数参数进行相加处理：

Beispiel

using System;
namespace PolymorphismApplication
{}}
　　　　public class TestData　　
　　　　{}}　　
　　　　　　　　public int Add(int a, int b, int c)　　
　　　　　　　　{}}　　
　　　　　　　　　　　　return a　+　b　+　c;　　
　　　　　　　　}　　
　　　　　　　　public int Add(int a, int b)　　
　　　　　　　　{}}　　
　　　　　　　　　　　　return a　+　b;　　
　　　　　　　　}　　
　　　　}　　
　　　　class Program　　
　　　　{}}　　
　　　　　　　　static void Main(string[] args)　　
　　　　　　　　{}}　　
　　　　　　　　　　　　TestData dataClass = new TestData();
　　　　　　　　　　　　int add1　= dataClass.Add(1,　2);　　
　　　　　　　　　　　　int add2　= dataClass.Add(1,　2,　3);
　　　　　　　　　　　　Console.WriteLine("add1　:"　+　add1);
　　　　　　　　　　　　Console.WriteLine("add2　:"　+　add2);　　
　　　　　　　　}　　
　　　　}　　
}

下面的示例演示了几个相同的函数 print()，用于打印不同的数据类型：

Beispiel

using System;
namespace PolymorphismApplication
{}}
　　　class Printdata
　　　{}}
　　　　　　void print(int i)
　　　　　　{}}
　　　　　　　　　Console.WriteLine("输出整型: {0}", i );
　　　　　　}
　　　　　　void print(double f)
　　　　　　{}}
　　　　　　　　　Console.WriteLine("输出浮点型: {0}", f);
　　　　　　}
　　　　　　void print(string s)
　　　　　　{}}
　　　　　　　　　Console.WriteLine("输出字符串: {0}", s);
　　　　　　}
　　　　　　static void Main(string[] args)
　　　　　　{}}
　　　　　　　　　Printdata p = new Printdata();
　　　　　　　　　//　调用 print 来打印整数
　　　　　　　　　p.print(1);
　　　　　　　　　//　调用 print 来打印浮点数
　　　　　　　　　p.print(1.23);
　　　　　　　　　//　调用 print 来打印字符串
　　　　　　　　　p.print("Hello w3codebox");
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt er das folgende Ergebnis:

输出整型:　1
输出浮点型:　1.23
输出字符串: Hello w3codebox

动态多态性

C# 允许您使用关键字 abstract 创建抽象类，用于提供接口的部分类的实现。当一个派生类继承自该抽象类时，实现即完成。Abstrakte Klasse包含抽象方法，抽象方法可被派生类实现。派生类具有更专业的功能。

请注意，下面是有关抽象类的一些规则：

您不能创建一个抽象类的示例。
您不能在一个抽象类外部声明一个抽象方法。
通过在类定义前面放置关键字 sealed，可以将类声明为密封类。当一个类被声明为 sealed 时，它不能被继承。抽象类不能被声明为 sealed。

下面的程序演示了一个抽象类：

Beispiel

using System;
namespace PolymorphismApplication
{}}
　　　abstract class Shape
　　　{}}
　　　　　　　abstract public int area();
　　　}
　　　class Rectangle: Shape
　　　{}}
　　　　　　private int length;
　　　　　　private int width;
　　　　　　public Rectangle(int a=0, int b=0)
　　　　　　{}}
　　　　　　　　　length = a;
　　　　　　　　　width = b;
　　　　　　}
　　　　　　public override int area()
　　　　　　{}}　
　　　　　　　　　Console.WriteLine("Rechtecksklasse Fl\u00e4che:");
　　　　　　　　　return (width　*　length);　
　　　　　　}
　　　}
　　　class RectangleTester
　　　{}}
　　　　　　static void Main(string[] args)
　　　　　　{}}
　　　　　　　　　Rectangle r = new Rectangle(10,　7);
　　　　　　　　　double a = r.area();
　　　　　　　　　Console.WriteLine("Fläche: {0}", a);
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt er das folgende Ergebnis:

Fläche der Rectangle-Klasse:
Fläche:　70

Wenn eine in der Klasse definierte Funktion in der Vererbungsklasse implementiert werden muss, kannAbstrakte Methode.

Virtuelle Methoden werden mit dem Schlüsselwort virtual deklariert.

virtuelle Methoden können in verschiedenen Vererbungsklassen unterschiedlich implementiert werden.

Aufrufe von virtuellen Methoden im Laufzeitkontext ausgeführt.

Dynamische Polymorphie wird durch Abstrakte Klasse und Abstrakte Methode implementiert.

Nachfolgender Beispielcode erstellt die Basisklasse Shape und die Ableitungen Circle, Rectangle, Triangle, Shape-Klasse bietet eine virtuelle Methode namens Draw, die in jeder Ableitungsmethode überschrieben wird, um die spezifische Form der Klasse zu zeichnen.

Beispiel

using System;
using System.Collections.Generic;
public class Shape
{}}
　　　　public int X { get; private set; }
　　　　public int Y { get; private set; }
　　　　public int Height { get; set; }
　　　　public int Width { get; set; }
　　　
　　　　//　Abstrakte Methode
　　　　public virtual void Draw()
　　　　{}}
　　　　　　　　Console.WriteLine("Führen Sie die Zeichenaufgabe der Basisklasse aus");
　　　　}
}
class Circle : Shape
{}}
　　　　public override void Draw()
　　　　{}}
　　　　　　　　Console.WriteLine("Zeichnen Sie einen Kreis");
　　　　　　　　base.Draw();
　　　　}
}
class Rectangle : Shape
{}}
　　　　public override void Draw()
　　　　{}}
　　　　　　　　Console.WriteLine("Zeichnen Sie ein Rechteck");
　　　　　　　　base.Draw();
　　　　}
}
class Triangle : Shape
{}}
　　　　public override void Draw()
　　　　{}}
　　　　　　　　Console.WriteLine("Zeichnen Sie ein Dreieck");
　　　　　　　　base.Draw();
　　　　}
}
class Program
{}}
　　　　static void Main(string[] args)
　　　　{}}
　　　　　　　　//　Erstellen Sie ein Objekt von List<Shape> und fügen Sie Circle, Triangle und Rectangle hinzu
　　　　　　　　var shapes = new List<Shape>
　　　　　　　　{}}
　　　　　　　　　　　　new Rectangle(),
　　　　　　　　　　　　new Triangle(),
　　　　　　　　　　　　new Circle()
　　　　　　　　};
　　　　　　　　//　Verwende den foreach-Loop, um die abgeleiteten Klassen der Liste zu durchlaufen und die Draw-Methode jedes Shape-Objekts aufzurufen　
　　　　　　　　foreach (var shape in shapes)
　　　　　　　　{}}
　　　　　　　　　　　　shape.Draw();
　　　　　　　　}
　　　　　　　　Console.WriteLine("Dr\u00fcssen Sie eine beliebige Taste dr\u00fccken, um das Programm zu beenden.");
　　　　　　　　Console.ReadKey();
　　　　}
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt er das folgende Ergebnis:

Zeichne ein Rechteck
Zeichne den Basisklassen-Aufgaben aus
Zeichne ein Dreieck
Zeichne den Basisklassen-Aufgaben aus
Zeichne einen Kreis
Zeichne den Basisklassen-Aufgaben aus
Dr\u00fcssen Sie eine beliebige Taste dr\u00fccken, um das Programm zu beenden.

Das folgende Programm demonstriert, wie die Fl\u00e4che verschiedener geometrischer Figuren durch den virtuellen Methoden area() berechnet wird:

Beispiel

using System;
namespace PolymorphismApplication
{}}
　　　class Shape　
　　　{}}
　　　　　　protected int width, height;
　　　　　　public Shape(int a = 0, int b = 0)
　　　　　　{}}
　　　　　　　　　width = a;
　　　　　　　　　height = b;
　　　　　　}
　　　　　　public virtual int area()
　　　　　　{}}
　　　　　　　　　Console.WriteLine("Elternklasse Fl\u00e4che:");
　　　　　　　　　return 0;
　　　　　　}
　　　}
　　　class Rectangle: Shape
　　　{}}
　　　　　　public Rectangle(int a = 0, int b = 0): base(a, b)
　　　　　　{}}
　　　　　　}
　　　　　　public override int area()
　　　　　　{}}
　　　　　　　　　Console.WriteLine("Rechtecksklasse Fl\u00e4che:");
　　　　　　　　　return (width　*　height);　
　　　　　　}
　　　}
　　　class Triangle: Shape
　　　{}}
　　　　　　public Triangle(int a = 0, int b = 0): base(a, b)
　　　　　　{}}
　　　　　　
　　　　　　}
　　　　　　public override int area()
　　　　　　{}}
　　　　　　　　　Console.WriteLine("Dreiecksklasse Fl\u00e4che:");
　　　　　　　　　return (width　*　height　/　2);　
　　　　　　}
　　　}
　　　class Caller
　　　{}}
　　　　　　public void CallArea(Shape sh)
　　　　　　{}}
　　　　　　　　　int a;
　　　　　　　　　a = sh.area();
　　　　　　　　　Console.WriteLine("Fl\u00e4che:　{0}", a);
　　　　　　}
　　　}　　
　　　class Tester
　　　{}}
　　　　　　
　　　　　　static void Main(string[] args)
　　　　　　{}}
　　　　　　　　　Caller c = new Caller();
　　　　　　　　　Rectangle r = new Rectangle(10,　7);
　　　　　　　　　Triangle t = new Triangle(10,　5);
　　　　　　　　　c.CallArea(r);
　　　　　　　　　c.CallArea(t);
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt er das folgende Ergebnis:

Fläche der Rectangle-Klasse:
Fläche:70
Fläche der Triangle-Klasse:
Fläche:25

C# Operatorüberschreibung C# Vererbung