C# Klasse

Wenn Sie eine Klasse definieren, definieren Sie einen Bauplan für einen Datentyp. Dies definiert nicht tatsächlich Daten, sondern es definiert, was der Klassenname bedeutet, das heißt, woraus die Objekte der Klasse bestehen und welche Operationen auf diesem Objekt ausgeführt werden können. Objekte sind Instanzen der Klasse. Die Methoden und Variablen, aus denen eine Klasse besteht, werden Member der Klasse genannt.

Klassendefinition

Die Definition einer Klasse beginnt mit dem SchlüsselwortclassBegin, gefolgt vom Klassennamen. Der Rumpf der Klasse, eingeschlossen in ein Paar geschweifter Klammern. Das Folgende ist die allgemeine Form einer Klassendefinition:

<Zugriffsspezifizierer> class  class_name
{
    // Membervariablen
    <Zugriffsspezifizierer> <Datentyp> variable1;
    <Zugriffsspezifizierer> <Datentyp> variable2;
    ...
    <Zugriffsspezifizierer> <Datentyp> variableN;
    // Member-Methoden
    <Zugriffsspezifizierer> <Rückgabe typ> method1(parameter_list)
    {
        // Methodenrumpf
    }
    <Zugriffsspezifizierer> <Rückgabe typ> method2(parameter_list)
    {
        // Methodenrumpf
    }
    ...
    <Zugriffsspezifizierer> <Rückgabe typ> methodN(parameter_list)
    {
        // Methodenrumpf
    }
}

Bitte beachten Sie:

  • Der Zugriffsspezifizierer <Zugriffsspezifizierer> legt die Zugriffsregeln für die Klasse und ihre Member fest. Wenn nicht angegeben, wird der Standard-Zugriffsspezifizierer verwendet. Der Standard-Zugriffsspezifizierer für eine Klasse istinternal, und der Standard-Zugriffsbezeichner für Member istprivate。
  • Der Datentyp <Datentyp> gibt den Typ einer Variablen an, und der Rückgabetyp <Rückgabetyp> gibt den Datentyp an, der von der Methode zurückgegeben wird.
  • Um auf ein Member einer Klasse zuzugreifen, verwenden Sie den Punktoperator (.).
  • Der Punktoperator verbindet den Objektnamen und den Membernamen.

Das folgende Beispiel veranschaulicht die bisher besprochenen Konzepte:

Beispiel

using System;
namespace BoxApplication
{
    class Box
    {
       public double length;   // Länge
       public double breadth;  // Breite
       public double height;   // Höhe
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();        // Deklariere Box1 vom Typ Box
            Box Box2 = new Box();        // Deklariere Box2 vom Typ Box
            double volume = 0.0;         // Volumen

            // Box1-Details
            Box1.height = 5.0;
            Box1.length = 6.0;
            Box1.breadth = 7.0;

            // Box2-Details
            Box2.height = 10.0;
            Box2.length = 12.0;
            Box2.breadth = 13.0;
           
            // Volumen von Box1
            volume = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine("Volumen von Box1: {0}", volume);

            // Volumen von Box2
            volume = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine("Volumen von Box2: {0}", volume);
            Console.ReadKey();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Box1 的体积： 210
Box2 的体积： 1560

Memberfunktionen und Kapselung

Eine Memberfunktion einer Klasse ist eine Funktion, deren Definition oder Prototyp innerhalb der Klassendefinition steht, genau wie andere Variablen. Als Member der Klasse kann sie auf jedes Objekt der Klasse operieren und auf alle Member der Klasse dieses Objekts zugreifen.

Membervariablen sind Attribute eines Objekts (aus Entwurfssicht), und sie bleiben privat, um Kapselung zu erreichen. Auf diese Variablen kann nur über öffentliche Memberfunktionen zugegriffen werden.

Lassen Sie uns die oben genannten Konzepte verwenden, um die Werte verschiedener Klassenmember in einer Klasse festzulegen und abzurufen:

Beispiel

using System;
namespace BoxApplication
{
    class Box
    {
       private double length;   // Länge
       private double breadth;  // Breite
       private double height;   // Höhe
       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();        // Deklariere Box1 vom Typ Box
            Box Box2 = new Box();        // Deklariere Box2 vom Typ Box
            double volume;               // Volumen


            // Box1-Details
            Box1.setLength(6.0);
            Box1.setBreadth(7.0);
            Box1.setHeight(5.0);

            // Box2-Details
            Box2.setLength(12.0);
            Box2.setBreadth(13.0);
            Box2.setHeight(10.0);
       
            // Volumen von Box1
            volume = Box1.getVolume();
            Console.WriteLine("Volume of Box1: {0}" ,volume);

            // Volumen von Box2
            volume = Box2.getVolume();
            Console.WriteLine("Volumen von Box2: {0}", volume);
           
            Console.ReadKey();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Box1 的体积： 210
Box2 的体积： 1560

Konstruktoren in C#

KlasseKonstruktorEs ist eine spezielle Memberfunktion einer Klasse, die ausgeführt wird, wenn ein neues Objekt der Klasse erstellt wird.

Der Name des Konstruktors ist genau derselbe wie der Name der Klasse, und er hat keinen Rückgabetyp.

Das folgende Beispiel veranschaulicht das Konzept eines Konstruktors:

Beispiel

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // Länge der Linie
      public Line()
      {
         Console.WriteLine("Objekt erstellt");
      }

      public void setLength( double len )
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line();    
         // Länge der Linie festlegen
         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, liefert er die folgenden Ergebnisse:

对象已创建
线条的长度： 6

StandardkonstruktorEr hat keine Parameter. Aber wenn Sie einen Konstruktor mit Parametern benötigen, kann er Parameter haben; diese Art von Konstruktor heißtparametrisierter Konstruktor. Diese Technik kann Ihnen helfen, Objekten beim Erstellen gleichzeitig Anfangswerte zuzuweisen. Einzelheiten finden Sie im folgenden Beispiel:

Beispiel


using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // Länge der Linie
      public Line(double len)  // Parametrisierter Konstruktor
      {
         Console.WriteLine("Object 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("Die Länge der Linie: {0}", line.getLength());
         // Länge der Linie festlegen
         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, liefert er die folgenden Ergebnisse:

对象已创建，length = 10
线条的长度： 10
线条的长度： 6

Destruktoren in C#

KlasseDestruktorEr ist eine spezielle Memberfunktion einer Klasse, die ausgeführt wird, wenn ein Objekt der Klasse den Gültigkeitsbereich verlässt.

Der Name des Destruktors ist der Klassenname mit vorangestellter Tilde (~). Er gibt keinen Wert zurück und nimmt keine Parameter an.

Ein Destruktor wird verwendet, um Ressourcen vor dem Beenden eines Programms freizugeben (z. B. Schließen von Dateien, Freigeben von Speicher usw.). Destruktoren können nicht vererbt oder überladen werden.

Das folgende Beispiel veranschaulicht das Konzept eines Destruktors:

Beispiel


using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // Länge der Linie
      public Line()  // Konstruktor
      {
         Console.WriteLine("Objekt erstellt");
      }
      ~Line() //Destruktor
      {
         Console.WriteLine("Object deleted");
      }

      public void setLength( double len )
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line();
         // Länge der Linie festlegen
         line.setLength(6.0);
         Console.WriteLine("Die Länge der Linie: {0}", line.getLength());          
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

对象已创建
线条的长度： 6
对象已删除

Statische Member einer C#-Klasse

Wir könnenstaticverwenden. Das Schlüsselwort definiert ein Klassenmember als statisch. Wenn wir ein Klassenmember als statisch deklarieren, bedeutet das, dass unabhängig davon, wie viele Objekte der Klasse erstellt werden, nur eine Kopie dieses statischen Members existiert.

SchlüsselwörterstaticBedeutet, dass es nur eine Instanz dieses Members in der Klasse gibt. Statische Variablen werden verwendet, um Konstanten zu definieren, da ihre Werte durch direktes Aufrufen der Klasse abgerufen werden können, ohne eine Instanz der Klasse zu erstellen. Statische Variablen können außerhalb von Memberfunktionen oder der Klassendefinition initialisiert werden. Man kann statische Variablen auch innerhalb der Klassendefinition initialisieren.

Das folgende Beispiel zeigt diestatische Variablen-Verwendung:

Beispiel

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("s1's variable num: {0}", s1.getNum());
            Console.WriteLine("s2's variable num: {0}", s2.getNum());
            Console.ReadKey();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

s1 的变量 num： 6
s2 的变量 num： 6

Sie können auch eineMemberfunktionalsstaticdeklarieren. Solche Funktionen können nur auf statische Variablen zugreifen. Statische Funktionen existieren bereits, bevor Objekte erstellt werden. Das folgende Beispiel demonstriertstatische FunktionenVerwendung:

Beispiel

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, liefert er die folgenden Ergebnisse:

变量 num： 3
Weitere Erweiterungen