C# - Klassen
Wenn Sie eine Klasse definieren, definieren Sie einen Entwurf für einen Datentyp. Dies definiert eigentlich keine Daten, aber es definiert, was der Klassenname bedeutet. Das heißt, woraus ein Objekt der Klasse besteht und welche Operationen an diesem Objekt ausgeführt werden können. Objekte sind Instanzen einer Klasse. Die Methoden und Variablen, die eine Klasse bilden, werden Mitglieder der Klasse genannt.
Definieren einer Klasse
Eine Klassendefinition beginnt mit dem Schlüsselwort class gefolgt vom Klassennamen; und der Klassenkörper, der von einem Paar geschweifter Klammern eingeschlossen ist. Es folgt die allgemeine Form einer Klassendefinition −
<access specifier> class class_name {
// member variables
<access specifier> <data type> variable1;
<access specifier> <data type> variable2;
...
<access specifier> <data type> variableN;
// member methods
<access specifier> <return type> method1(parameter_list) {
// method body
}
<access specifier> <return type> method2(parameter_list) {
// method body
}
...
<access specifier> <return type> methodN(parameter_list) {
// method body
}
}
Hinweis −
-
Zugriffsbezeichner geben die Zugriffsregeln für die Mitglieder sowie die Klasse selbst an. Wenn nicht erwähnt, ist der Standardzugriffsbezeichner für einen Klassentyp internal . Der Standardzugriff für die Mitglieder ist privat .
-
Der Datentyp gibt den Typ der Variablen an, und der Rückgabetyp gibt den Datentyp der Daten an, die die Methode zurückgibt, falls vorhanden.
-
Um auf die Klassenmitglieder zuzugreifen, verwenden Sie den Punktoperator (.).
-
Der Punktoperator verknüpft den Namen eines Objekts mit dem Namen eines Members.
Das folgende Beispiel veranschaulicht die bisher besprochenen Konzepte −
Live-Demo
using System;
namespace BoxApplication {
class Box {
public double length; // Length of a box
public double breadth; // Breadth of a box
public double height; // Height of a box
}
class Boxtester {
static void Main(string[] args) {
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box(); // Declare Box2 of type Box
double volume = 0.0; // Store the volume of a box here
// box 1 specification
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;
// box 2 specification
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;
// volume of box 1
volume = Box1.height * Box1.length * Box1.breadth;
Console.WriteLine("Volume of Box1 : {0}", volume);
// volume of box 2
volume = Box2.height * Box2.length * Box2.breadth;
Console.WriteLine("Volume of Box2 : {0}", volume);
Console.ReadKey();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −
Volume of Box1 : 210 Volume of Box2 : 1560
Memberfunktionen und Kapselung
Eine Mitgliedsfunktion einer Klasse ist eine Funktion, deren Definition oder Prototyp innerhalb der Klassendefinition ähnlich wie jede andere Variable ist. Es arbeitet mit jedem Objekt der Klasse, deren Mitglied es ist, und hat Zugriff auf alle Mitglieder einer Klasse für dieses Objekt.
Mitgliedsvariablen sind die Attribute eines Objekts (aus der Entwurfsperspektive) und werden privat gehalten, um die Kapselung zu implementieren. Auf diese Variablen kann nur über die öffentlichen Elementfunktionen zugegriffen werden.
Lassen Sie uns obige Konzepte zum Festlegen und Abrufen des Werts verschiedener Klassenmitglieder in einer Klasse einsetzen −
Live-Demo
using System;
namespace BoxApplication {
class Box {
private double length; // Length of a box
private double breadth; // Breadth of a box
private double height; // Height of a box
public void setLength( double len ) {
length = len;
}
public void setBreadth( double bre ) {
breadth = bre;
}
public void setHeight( double hei ) {
height = hei;
}
public double getVolume() {
return length * breadth * height;
}
}
class Boxtester {
static void Main(string[] args) {
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box();
double volume;
// Declare Box2 of type Box
// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// box 2 specification
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// volume of box 1
volume = Box1.getVolume();
Console.WriteLine("Volume of Box1 : {0}" ,volume);
// volume of box 2
volume = Box2.getVolume();
Console.WriteLine("Volume of Box2 : {0}", volume);
Console.ReadKey();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −
Volume of Box1 : 210 Volume of Box2 : 1560
C#-Konstruktoren
Ein Klassen-Konstruktor ist eine spezielle Mitgliedsfunktion einer Klasse, die immer dann ausgeführt wird, wenn wir neue Objekte dieser Klasse erstellen.
Ein Konstruktor hat genau den gleichen Namen wie die Klasse und hat keinen Rückgabetyp. Das folgende Beispiel erklärt das Konzept des Konstruktors −
Live-Demo
using System;
namespace LineApplication {
class Line {
private double length; // Length of a line
public Line() {
Console.WriteLine("Object is being created");
}
public void setLength( double len ) {
length = len;
}
public double getLength() {
return length;
}
static void Main(string[] args) {
Line line = new Line();
// set line length
line.setLength(6.0);
Console.WriteLine("Length of line : {0}", line.getLength());
Console.ReadKey();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −
Object is being created Length of line : 6
Ein Standardkonstruktor hat keine Parameter, aber bei Bedarf kann ein Konstruktor Parameter haben. Solche Konstruktoren werden parametrisierte Konstruktoren genannt . Diese Technik hilft Ihnen, einem Objekt zum Zeitpunkt seiner Erstellung einen Anfangswert zuzuweisen, wie im folgenden Beispiel gezeigt −
Live-Demo
using System;
namespace LineApplication {
class Line {
private double length; // Length of a line
public Line(double len) { //Parameterized constructor
Console.WriteLine("Object is being created, length = {0}", len);
length = len;
}
public void setLength( double len ) {
length = len;
}
public double getLength() {
return length;
}
static void Main(string[] args) {
Line line = new Line(10.0);
Console.WriteLine("Length of line : {0}", line.getLength());
// set line length
line.setLength(6.0);
Console.WriteLine("Length of line : {0}", line.getLength());
Console.ReadKey();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −
Object is being created, length = 10 Length of line : 10 Length of line : 6
C#-Destruktoren
Ein Destruktor ist eine spezielle Mitgliedsfunktion einer Klasse, die immer dann ausgeführt wird, wenn ein Objekt ihrer Klasse den Gültigkeitsbereich verlässt. Ein Destruktor hat genau den gleichen Namen wie die Klasse mit vorangestellter Tilde (~) und kann weder einen Wert zurückgeben noch Parameter annehmen.
Der Destruktor kann sehr nützlich sein, um Speicherressourcen freizugeben, bevor das Programm beendet wird. Destruktoren können nicht vererbt oder überladen werden.
Das folgende Beispiel erklärt das Konzept des Destruktors −
Live-Demo
using System;
namespace LineApplication {
class Line {
private double length; // Length of a line
public Line() { // constructor
Console.WriteLine("Object is being created");
}
~Line() { //destructor
Console.WriteLine("Object is being deleted");
}
public void setLength( double len ) {
length = len;
}
public double getLength() {
return length;
}
static void Main(string[] args) {
Line line = new Line();
// set line length
line.setLength(6.0);
Console.WriteLine("Length of line : {0}", line.getLength());
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −
Object is being created Length of line : 6 Object is being deleted
Statische Member einer C#-Klasse
Mit static können wir Klassenmitglieder als statisch definieren Stichwort. Wenn wir ein Mitglied einer Klasse als statisch deklarieren, bedeutet dies, dass es nur eine Kopie des statischen Mitglieds gibt, egal wie viele Objekte der Klasse erstellt werden.
Das Schlüsselwort statisch impliziert, dass nur eine Instanz des Members für eine Klasse existiert. Statische Variablen werden zum Definieren von Konstanten verwendet, da ihre Werte abgerufen werden können, indem die Klasse aufgerufen wird, ohne eine Instanz davon zu erstellen. Statische Variablen können außerhalb der Elementfunktion oder Klassendefinition initialisiert werden. Sie können auch statische Variablen innerhalb der Klassendefinition initialisieren.
Das folgende Beispiel demonstriert die Verwendung von statischen Variablen −
Live-Demo
using System;
namespace StaticVarApplication {
class StaticVar {
public static int num;
public void count() {
num++;
}
public int getNum() {
return num;
}
}
class 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("Variable num for s1: {0}", s1.getNum());
Console.WriteLine("Variable num for s2: {0}", s2.getNum());
Console.ReadKey();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −
Variable num for s1: 6 Variable num for s2: 6
Sie können auch eine Elementfunktion deklarieren als statisch . Solche Funktionen können nur auf statische Variablen zugreifen. Die statischen Funktionen existieren bereits, bevor das Objekt erstellt wird. Das folgende Beispiel demonstriert die Verwendung von statischen Funktionen −
Live-Demo
using System;
namespace StaticVarApplication {
class StaticVar {
public static int num;
public void count() {
num++;
}
public static int getNum() {
return num;
}
}
class 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 er das folgende Ergebnis −
Variable num: 3
C Sprache