[c#-Tutorial] C#-Klasse (Klasse)

C#-Klasse (Klasse)

Wenn Sie eine Klasse definieren, definieren Sie einen Entwurf eines Datentyps. Damit werden eigentlich keine Daten definiert, sondern es wird definiert, was der Name der Klasse bedeutet, also woraus ein Objekt der Klasse besteht und welche Operationen an diesem Objekt ausgeführt werden können. Objekte sind Instanzen von Klassen. Die Methoden und Variablen, aus denen eine Klasse besteht, werden zu Mitgliedern der Klasse.

Klassendefinition

Die Definition einer Klasse beginnt mit dem Schlüsselwort „class“, gefolgt vom Namen der Klasse. Der Hauptteil der Klasse, eingeschlossen in ein Paar geschweifte Klammern. Das Folgende ist 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 
    }
}

Bitte beachten Sie:

Der Zugriffsspezifizierer ef28130359e61a55167bb6a53b9c73a5 gibt die Zugriffsregeln für die Klasse und ihre Mitglieder an. Wenn nicht angegeben, wird die Standardzugriffskennung verwendet. Die Standardzugriffskennung für eine Klasse ist intern und für Mitglieder ist sie privat.

Datentyp 6f58afedf579acd98d87d27ef0264503 gibt den Typ der Variablen an, Rückgabetyp 28175b3ecb7731928057fda91f2a80a0 gibt den von der zurückgegebenen Methode zurückgegebenen Datentyp an.

Wenn Sie auf Mitglieder einer Klasse zugreifen möchten, möchten Sie den Punktoperator (.) verwenden.

Der Punktoperator verknüpft den Namen des Objekts und den Namen des Mitglieds.

Das folgende Beispiel veranschaulicht die bisher besprochenen Konzepte:

using System;
namespace BoxApplication
{
    class Box
    {
       public double length;   // 长度
       public double breadth;  // 宽度
       public double height;   // 高度
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();        // 声明 Box1，类型为 Box
            Box Box2 = new Box();        // 声明 Box2，类型为 Box
            double volume = 0.0;         // 体积

            // Box1 详述
            Box1.height = 5.0;
            Box1.length = 6.0;
            Box1.breadth = 7.0;

            // Box2 详述
            Box2.height = 10.0;
            Box2.length = 12.0;
            Box2.breadth = 13.0;
           
            // Box1 的体积
            volume = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine("Box1 的体积： {0}",  volume);

            // Box2 的体积
            volume = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine("Box2 的体积： {0}", volume);
            Console.ReadKey();
        }
    }
}

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

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

Member Funktionen und Kapselung

Eine Mitgliedsfunktion einer Klasse ist eine Funktion, deren Definition oder Prototyp in der Klassendefinition liegt, genau wie andere Variablen. Als Mitglied einer Klasse kann es auf jedes Objekt der Klasse zugreifen und auf alle Mitglieder der Klasse des Objekts zugreifen.

Mitgliedsvariablen sind Eigenschaften des Objekts (aus Designsicht) und werden privat gehalten, um eine 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 Klassenmitglieder in einer Klasse festzulegen und abzurufen:

using System;
namespace BoxApplication
{
    class Box
    {
       private double length;   // 长度
       private double breadth;  // 宽度
       private double height;   // 高度
       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();        // 声明 Box1，类型为 Box
            Box Box2 = new Box();		 // 声明 Box2，类型为 Box
            double volume;				 // 体积


            // Box1 详述
            Box1.setLength(6.0);
            Box1.setBreadth(7.0);
            Box1.setHeight(5.0);

            // Box2 详述
            Box2.setLength(12.0);
            Box2.setBreadth(13.0);
            Box2.setHeight(10.0);
       
            // Box1 的体积
            volume = Box1.getVolume();
            Console.WriteLine("Box1 的体积： {0}" ,volume);

            // Box2 的体积
            volume = Box2.getVolume();
            Console.WriteLine("Box2 的体积： {0}", volume);
           
            Console.ReadKey();
        }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, wird er erzeugt Folgende Ergebnisse:

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

Konstruktor in C#

Der Konstruktor einer Klasse ist eine spezielle Mitgliedsfunktion der 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, er hat keinen Rückgabetyp.

Das folgende Beispiel veranschaulicht das Konzept des Konstruktors:

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // 线条的长度
      public Line()
      {
         Console.WriteLine("对象已创建");
      }

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

      static void Main(string[] args)
      {
         Line line = new Line();    
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength());
         Console.ReadKey();
      }
   }
}

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

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

Die Standardeinstellung Der Konstruktor akzeptiert keine Parameter. Wenn Sie jedoch einen Konstruktor mit Parametern benötigen, der Parameter haben kann, wird dieser Konstruktor als parametrisierter Konstruktor bezeichnet. Diese Technik kann Ihnen dabei helfen, Objekten beim Erstellen Anfangswerte zuzuweisen. Weitere Informationen finden Sie im folgenden Beispiel:

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // 线条的长度
      public Line(double len)  // 参数化构造函数
      {
         Console.WriteLine("对象已创建，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("线条的长度： {0}", line.getLength()); 
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength()); 
         Console.ReadKey();
      }
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, werden die folgenden Ergebnisse erzeugt:

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

Destruktor in C#

Der Destruktor einer Klasse ist eine spezielle Mitgliedsfunktion der Klasse, die ausgeführt wird, wenn das Objekt der Klasse den Gültigkeitsbereich verlässt.

Dem Namen des Destruktors wird eine Tilde (~) vor dem Namen der Klasse vorangestellt. Er gibt keinen Wert zurück und akzeptiert keine Parameter.

Der Destruktor wird verwendet, um Ressourcen freizugeben, bevor das Programm beendet wird (z. B. Dateien schließen, Speicher freigeben usw.). Destruktoren können nicht vererbt oder überladen werden.

Das folgende Beispiel veranschaulicht das Konzept des Destruktors:

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // 线条的长度
      public Line()  // 构造函数
      {
         Console.WriteLine("对象已创建");
      }
      ~Line() //析构函数
      {
         Console.WriteLine("对象已删除");
      }

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

      static void Main(string[] args)
      {
         Line line = new Line();
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength());           
      }
   }
}

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

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

Statische Mitglieder von C#-Klassen

Wir können das Schlüsselwort static verwenden, um Klassenmitglieder als statisch zu definieren. Wenn wir ein Klassenmitglied als statisch deklarieren, bedeutet dies, dass es unabhängig von der Anzahl der erstellten Objekte der Klasse nur eine Kopie des statischen Mitglieds gibt.

关键字 static 意味着类中只有一个该成员的实例。静态变量用于定义常量，因为它们的值可以通过直接调用类而不需要创建类的实例来获取。静态变量可在成员函数或类的定义外部进行初始化。您也可以在类的定义内部初始化静态变量。

下面的实例演示了静态变量的用法：

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 的变量 num： {0}", s1.getNum());
            Console.WriteLine("s2 的变量 num： {0}", s2.getNum());
            Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

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

您也可以把一个成员函数声明为 static。这样的函数只能访问静态变量。静态函数在对象被创建之前就已经存在。下面的实例演示了静态函数的用法：

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("变量 num： {0}", StaticVar.getNum());
            Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

变量 num： 3

 以上就是【c#教程】C# 类（Class）的内容，更多相关内容请关注PHP中文网（www.php.cn）！