C # Klasse (Klasse)
Wenn Sie eine Klasse definieren, definieren Sie einen Entwurf für einen Datentyp. Dies gilt definieren tatsächlich keine Daten, aber es definiert den Namen der Klasse, was es bedeutet, das heißt, was eine Objektklasse darstellt und welche Operationen an dem Objekt durchführen. Objekte sind Instanzen von Klassen. Methoden und Variablen, die die Klasse bilden wird Mitglieder der Klasse.
Klassendefinition
Die Definition der Klasse zu beginnen, durch den Klassennamen der Keyword -Klasse gefolgt.Körper der Klasse, innerhalb eines Paares von geschweiften Klammern enthalten. Im Folgenden ist die allgemeine Form der Klassendefinition:
<Zugriffsspezifizierer> Klasse class_name
{
// Member Variablen
<Zugriffsspezifizierer> <Datentyp> variable1;
<Zugriffsspezifizierer> <Datentyp> variable2;
...
<Zugriffsspezifizierer> <Datentyp> variableN;
// Member Methoden
<Zugriffsspezifizierer> <return type> method1 (parameter_list)
{
// Methode Körper
}
<Zugriffsspezifizierer> <return type> method2 (parameter_list)
{
// Methode Körper
}
...
<Zugriffsspezifizierer> <return type> methodN (parameter_list)
{
// Methode Körper
}
}
Bitte beachten Sie:
- Access Identifier <Zugriffsbezeichner> gibt die Zugriffsregel-Klasse und ihre Mitglieder. Wenn nicht anders angegeben, Kennung der Standardzugriff. Standard Access Identifier Klasse istintern, die Standard - Zugriffskennung Mitglieder privat ist.
- Datentyp <data type> gibt den Typ der Variablen, Rückgabetyp <Rückgabetyp> gibt die Art der Daten, die durch das Verfahren kehrt zurück.
- Wenn Sie ein Mitglied der Klasse zugreifen wollen, möchten Sie Punkt zu verwenden Operator (.).
- Dot Operator verbindet den Namen des Namens und die Mitglieder des Objekts.
Die folgenden Beispiele veranschaulichen die Begriffe bisher diskutiert:
using System;
Namespace BoxApplication
{
Klasse Box
{
public double Länge; // Länge public double Breite; // Breite Öffentlichkeit doppelter Höhe; // Höhe}
Klasse Boxtester
{
static void Main (string [] args)
{
Box Box1 = new Box (); // erklären Box1, Typ Box
Box Box2 = new Box (); // erklären Box2, Typ Box
Doppel Volumen = 0,0; // // Box1 Volumen Detaillierung Box1.height = 5,0;
Box1.length = 6,0;
Box1.breadth = 7,0;
// Box2 Detaillierung Box2.height = 10,0;
Box2.length = 12,0;
Box2.breadth = 13,0;
// Box1 Volumen Volumen = Box1.height * Box1.length * Box1.breadth;
Console.WriteLine ( "Box1 Volumen: {0}", Volumen);
// Box2 Volumen Volumen = Box2.height * Box2.length * Box2.breadth;
Console.WriteLine ( "Box2 Volumen: {0}", Volumen);
Console.ReadKey ();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:
Box1 Volumen: 210 Box2 Volumen: 1560
Member-Funktionen und Paket
Klasse Member-Funktionen ist es eine Definition oder Funktionsprototyp in der Klassendefinition, wie jede andere Variable. Als Mitglied der Klasse, kann es auf jede Objektklasse arbeiten, alle Mitglieder und die Klasse des Objekts zugreifen können.
Klassenvariablen sind Eigenschaften von Objekten (von einem Design-Sicht), und sie bleiben privates Paket zu implementieren. Diese Variablen können nur dann verwendet werden, um die öffentlichen Member-Funktionen zuzugreifen.
Lassen Sie uns die oben genannten Konzepte verwenden zu setzen und den Wert einer anderen Art von Klasse-Mitglieder erhalten:
using System;
Namespace BoxApplication
{
Klasse Box
{
private Doppel Länge; // Länge private Doppel Breite; // Breite private Doppel Höhe; // Höhe public void setlength (Doppel len)
{
length = len;
}
public void setBreadth (Doppel bre)
{
Breite = bre;
}
public void setHeight (Doppel hei)
{
height = hei;
}
public double getVolume ()
{
Rückkehr Länge * Breite * Höhe;
}
}
Klasse Boxtester
{
static void Main (string [] args)
{
Box Box1 = new Box (); // erklären Box1, Typ Box
Box Box2 = new Box (); // erklären Box2, Typ Box
Doppel Volumen; // // Box1 Volumen Detaillierung Box1.setLength (6.0);
Box1.setBreadth (7.0);
Box1.setHeight (5,0);
// Box2 Detaillierung Box2.setLength (12,0);
Box2.setBreadth (13,0);
Box2.setHeight (10,0);
// Box1 Volumen = Volumen Box1.getVolume ();
Console.WriteLine ( "Box1 Volumen: {0}", Volumen);
// Box2 Volumen = Volumen Box2.getVolume ();
Console.WriteLine ( "Box2 Volumen: {0}", Volumen);
Console.ReadKey ();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:
Box1 Volumen: 210 Box2 Volumen: 1560
C # Konstruktoren
Constructor der Klasse ist ein Sonderklasse Member - Funktion ausgeführt wird, wenn eine neue Objektklasse zu schaffen.
Name Der Name der Klasse Konstruktor genau das gleiche, es hat keinen Rückgabetyp.
Das folgende Beispiel veranschaulicht das Konzept des Konstruktors:
using System;
Namespace LineApplication
{
Klasse-Linie
{
private Doppel Länge; // Länge der Linie öffentliche Line ()
{
Console.WriteLine ( "Objekt erstellt worden ist");
}
public void setlength (double len)
{
length = len;
}
public double getLength ()
{
Rückkehr Länge;
}
static void Main (string [] args)
{
Line line = new Line ();
// Stellen Sie die Zeilenlänge line.setLength (6,0);
Console.WriteLine ( "Die Länge der Linie: {0}", line.getLength ());
Console.ReadKey ();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:
Erstellt Objekte Leitungslänge: 6
Der Default - Konstruktorhat keine Parameter. Aber wenn Sie einen Konstruktor mit einem Parameter müssen Argumente haben kann, wird dieser Konstruktorparametrisierte Konstruktor aufgerufen.Diese Technik kann Ihnen helfen, das Objekt zu erstellen, während das Objekt Anfangswerte zuweisen, finden Sie in den folgenden spezifischen Beispiele:
using System;
Namespace LineApplication
{
Klasse-Linie
{
private Doppel Länge; // Länge der Linie öffentliche Leitung (Doppel len) // parametrisierte Konstruktor {
Console.WriteLine ( "Objekt erstellt wurde, Länge = {0}", len);
length = len;
}
public void setlength (double len)
{
length = len;
}
public double getLength ()
{
Rückkehr Länge;
}
static void Main (string [] args)
{
Line line = new Line (10,0);
Console.WriteLine ( "Die Länge der Linie: {0}", line.getLength ());
// Stellen Sie die Zeilenlänge line.setLength (6,0);
Console.WriteLine ( "Die Länge der Linie: {0}", line.getLength ());
Console.ReadKey ();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:
Objekt erstellt wurde, Länge = 10 Zeilenlänge: 10 Zeilenlänge: 6
In C # destructor
Klassedestructor ist ein Sonderklasse Memberfunktion, wenn der Objekttyp außerhalb des Bereichs liegt.
Name destructor ist vor dem Namen der Klasse mit einem gewellten (~) als Präfix, wird es keinen Wert zurück, dauert es keine Parameter.
Destructor für das Ende des Programms (wie Dateien, um Speicher frei, usw. Schließen) vor der Freigabe von Ressourcen. Destructors kann nicht vererbt oder überlastet werden.
Das folgende Beispiel veranschaulicht das Konzept der destructor:
using System;
Namespace LineApplication
{
Klasse-Linie
{
private Doppel Länge; // Länge der Linie öffentliche Line () // Konstruktor {
Console.WriteLine ( "Objekt erstellt worden ist");
}
~ Line () // Destruktor {
Console.WriteLine ( "Objekt wurde gelöscht");
}
public void setlength (double len)
{
length = len;
}
public double getLength ()
{
Rückkehr Länge;
}
static void Main (string [] args)
{
Line line = new Line ();
// Stellen Sie die Zeilenlänge line.setLength (6,0);
Console.WriteLine ( "Die Länge der Linie: {0}", line.getLength ());
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:
Erstellt Objekte Leitungslänge: 6 Gelöschte Objekte
C # statisches Element Klasse
Wir können das Schlüsselwortstatisches Klassenmitglied verwenden ist statisch deklariert.Wenn wir ein Klassenmitglied erklären ist statisch, was bedeutet, dass, egal wie viele Klassenobjekt erstellt wird, gibt es nur eine Kopie der statischen Mitglieder.
Nur eine Instanz der Mitglieder des Schlüsselwortstatic bedeutet , dass die Klasse.Statische Variablen verwendet, um Konstanten zu definieren, da ihr Wert direkt ohne die Notwendigkeit aufgerufen werden kann eine Instanz der Klasse Klasse zu erstellen, zu erhalten. Statische Variablen können in der Definition des externen Member-Funktion oder Klasse initialisiert werden. Sie können auch statische Variablen definiert innerhalb der Klasse zu initialisieren.
Das folgende Beispiel zeigt die Verwendung vonstatischen Variablen:
using System;
Namespace StaticVarApplication
{
Klasse StaticVar
{
public static int num;
public void count ()
{
num ++;
}
public int getNum ()
{
Rückkehr num;
}
}
Klasse StaticTester
{
static void Main (string [] args)
{
StaticVar s1 = new StaticVar ();
StaticVar s2 = new StaticVar ();
s1.count ();
s1.count ();
s1.count ();
s2.count ();
s2.count ();
s2.count ();
Console.WriteLine ( "s1 Variable num: {0}", s1.getNum ());
Console.WriteLine ( "s2 Variable num: {0}", s2.getNum ());
Console.ReadKey ();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:
s1 Variable num: 6 s2 Variable num: 6
Sie können auch eineMember - Funktiongesetztwirdalsstatisch deklariert.Solche Funktionen können statische Variablen nur zugreifen. Statische Funktion, bevor das Objekt erstellt wird, es existiert. Das folgende Beispiel zeigt die Verwendung vonstatischen Funktionen:
using System;
Namespace StaticVarApplication
{
Klasse StaticVar
{
public static int num;
public void count ()
{
num ++;
}
public static int getNum ()
{
Rückkehr num;
}
}
Klasse StaticTester
{
static void Main (string [] args)
{
StaticVar s = new StaticVar ();
s.count ();
s.count ();
s.count ();
Console.WriteLine ( "Variable num: {0}", StaticVar.getNum ());
Console.ReadKey ();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:
Variable num: 3