C# Schnittstelle

C# Schnittstelle
Genau wie Klassen gibt es einige andere Container, die als Schnittstellen bezeichnet werden, die Methoden, Ereignisse und Eigenschaften enthalten. Schnittstellen enthalten nur die Erklärung und die Definition der Funktionen; die gesamte Beschreibung wird woanders im Programm oder hauptsächlich in anderen Klassen verwendet, die die Schnittstelle erben. Schnittstellen haben ihre privaten Mitglieder nicht. Alle Mitglieder der Funktionsbeschreibung sind öffentlich und fungieren als abstrakte Informationen. Eine Schnittstelle wird definiert, indem die Schnittstelle der Schlüsselwortnamen zusammen mit dem Namen verwendet wird, den Sie geben möchten. Durch die Verwendung von Klassen können wir das Phänomen mehrerer Erbschaften nicht ausführen. Durch die Verwendung von Schnittstellen ist es jedoch möglich, mehrere Erbschaften auszuführen. Die Arbeit der Schnittstelle wird hier diskutiert.

Syntax, um eine Schnittstelle zu deklarieren

Schnittstelle




Nachdem wir die Schnittstelle definiert haben, werden wir sie nun mit der folgenden Syntax implementieren:

# Klasse X: name_of_interface

Diese Erklärung erfolgt mit dem Namen der Schnittstelle, die einer Klasse mit einem Dickdarm zugeordnet ist. Auf diese Weise werden alle Mitglieder in der Schnittstelle als leer deklariert. Eine Klasse, die die Schnittstelle implementiert, sollte alle Funktionen der Schnittstelle implementieren.

Implementierung der Schnittstelle

Beispiel 1

Wir werden die Schnittstelle nach der Erklärung einer Bibliothek mit ihrem Namen deklarieren. In der Benutzeroberfläche deklarieren wir nur den Funktionsnamen. Der Rückgabetyp wird ebenfalls erwähnt. Die Schnittstelle enthält nur die Header der Funktion, die nicht die Beschreibung der Funktion enthält. Also schließen wir den Grenzflächenkörper, weil hier nur eine einzige Funktion definiert ist.

Schnittstelle inter1

void display ();

Damit die Funktion ausgeführt werden kann, verwenden wir eine Klasse als einfaches C -scharfer Programm, das deklariert wird. Aber für die Schnittstelle wird der Klassenname entlang der Schnittstelle deklariert, um sich damit zu verbinden.

# Klassentestklasse: inter1

In der Klasse ist die Funktion geschrieben. Wir haben einfach die Konsolenanweisung verwendet, um einen Beispielsatz anzuzeigen.

Im Hauptprogramm erstellen wir das Objekt für die Klasse. Diese Erklärung erfolgt dynamisch mit der Verwendung des "neuen" Schlüsselworts.

TestClass t = Neue TestClass (); Dieses Objekt wird verwendet, um die in der Klasse deklarierte Funktion zu rufen, nachdem das Objekt erstellt wurde.

# T.Anzeige();

Jetzt werden wir den Code mithilfe eines MCS -Compilers und Mono ausführen, um die Datei mit dem auszuführen .Exe -Erweiterung.

$ Mcs Datei.CS
$ mono -Datei.exe

Bei der Ausführung sehen Sie, dass der Satz angezeigt wird, der in der Interfaceand deklariert wurde, die in einer separaten Funktion ausgeführt wurde, auf die das Objekt im Hauptprogramm zugegriffen hat.

Beispiel 2

Im Gegensatz zum ersten Beispiel werden wir drei abstrakte Methoden in einer Schnittstelle verwenden. Diese Funktionen hängen mit dem Fahrzeug zusammen. Jede Funktion enthält Parameter, um die Werte zu akzeptieren, die aus dem Funktionsaufruf gesendet wurden.

Wenn die Schnittstelle deklariert wird, wird eine Klasse implementiert, um alle Funktionen in der Schnittstelle zu verwenden. Wir haben zwei Klassen mit zwei verschiedenen Arten von Fahrzeugen verwendet. Jede implementieren alle drei Funktionen, die in der Schnittstelle deklariert sind.

Die erste Funktion, die sich auf den Ausrüstung bezieht.

# Gear = Newgear;

Die zweite Funktion handelt von der Beschleunigung. Der gesendete Wert im Parameter wird also dem vorherigen hinzugefügt.

# Speed ​​= Geschwindigkeit + Inkrement;

Im Gegensatz zur Beschleunigung wird die Bremsfunktion den gesendeten Wert von der vorherigen abzüglich oder verringern.

# Geschwindigkeit = Geschwindigkeit - Dekrement;

Die Werte von Geschwindigkeit und Zahnrad werden durch die Funktion angezeigt. Es wird nicht in der Schnittstelle deklariert und ist die statische Funktion der Klasse.

Eine andere Klasse wurde entwickelt, um die Schnittstelle zu implementieren. Alle Ansätze für jede Funktion sind die gleichen, wie wir für die erste Klasse beschrieben haben. In ähnlicher Weise wird in der Anzeigefunktion alle vorhandenen Daten angezeigt.

Jetzt ist es an der Zeit, das Hauptprogramm zu erklären, um über die Objekte auf jede Klasse zuzugreifen. Es wird ein Klassenmuster erstellt, das das Hauptprogramm darin hat. Da wir zwei Klassen haben, um die Schnittstelle (Fahrrad und Fahrrad) zu implementieren, erstellen wir für jede Klasse Objekte separat.

Erstens für das Fahrrad:

# Fahrradfahrrad = neues Fahrrad ();

Die Objekterstellung wird dynamisch erledigt. Durch dieses Objekt wird jede Funktion aufgerufen.

# Fahrrad.ChangeGear (2);

Jeder Parameter der Funktion enthält den ganzzahligen Typwert im Argument. Anschließend wird jedes Ergebnis angezeigt, indem die Anzeigefunktion aufgerufen wird.

Nach dem Fahrrad wird die Instanz für das Fahrrad erstellt.

# Bike Bike = New Bike ();

In ähnlicher Weise werden alle Funktionsaufrufe über dieses Fahrradobjekt durchgeführt.

# Fahrrad.Beschleunigung (4);

Jetzt werden wir den Code ausführen, um zu sehen, wie er funktioniert. Bei der Ausführung werden sowohl die Werte für den Gang als auch die Geschwindigkeit für jede Klasse je nach Abfolge von Objekterstellung und Funktion, die durch das Objekt aufruft, getrennt angezeigt.

Beispiel 3

Im vorherigen Beispiel haben wir nur die Werte direkt im Programm angezeigt, die in der Schnittstelle deklariert sind. Aber diesmal werden wir die Fläche eines Polygons berechnen, indem wir die Funktion in zwei verschiedenen Formen haben. Schauen wir uns die Implementierung des Beispiels an. Erstens werden wir hier die Schnittstelle deklarieren.

Schnittstelle ipolygone

Hohlraum calculatearea ();

Die Funktion enthält keine Parameter damit. Dies bedeutet, dass alle Variablen lokal in der Funktion definiert sind. Nach der Schnittstelle werden wir ein Klassenrechteck deklarieren, das die Ipolygon -Schnittstelle implementiert. Also werden wir die Klasse mit dem Schnittstellennamen in Verbindung bringen.

# Klasse Rechteck: ipolygone

In der Klasse die Funktion Kalkulatearea wird eingesetzt. In der Funktion werden alle Variablen mit einem Wert zugewiesen. Diese Werte werden dann in der Formel verwendet, um die Fläche des Rechtecks ​​zu berechnen.

# int Area = l * b;

Nach den Berechnungen wird der resultierende Wert angezeigt.

Das gleiche Phänomen zur Implementierung der Ipolygon -Schnittstelle erfolgt für die quadratische Form. Aber da alle Seiten des Quadrats gleich sind, brauchen wir keine zweiseitigen Längen. Alle Seiten sind von gleicher Länge, so dass die Fläche berechnet wird, indem zwei Längen miteinander multipliziert werden.

# int Area = l * l;

Im Hauptprogramm werden die Objekte für beide Klassen erstellt, und dann wird die Funktion durch diese Objekte aufgerufen.

Rechteck ri = neues rechteck ();
R1.calculateArea ();

Der gleiche Ansatz geht für die quadratische Klasse.

Führen Sie nun den Code aus, Sie können feststellen, dass beide Bereiche verschiedener Quadrate angezeigt werden, indem die Funktionen über ihre Objekte aufgerufen werden.

Abschluss

C Sharp -Schnittstelle wird verwendet, um einige bestimmte Informationen auf eine bestimmte Weise auszublenden, um nur die wichtigen Informationen anzuzeigen, die wichtig sind. Während der Definition der Schnittstelle haben wir gesehen, dass nur der Header der Funktion beschrieben wird. Die Header -Erklärung besteht aus dem Rückgabetyp der Funktion und dem Argument, das im Parameter vorhanden ist. In diesem Artikel haben wir einige Beispiele im Linux -Betriebssystem implementiert. In jedem Beispiel wird eine separate Schnittstelle definiert, die eine einzelne oder Anzahl von Schnittstellen enthält, die später in ihren jeweiligen Klassen beschrieben werden.