Grundlegende Einführung in C#-Klassen

Eine Klasse ist eineDatenstruktur, die Datenelemente (Variablen und Konstanten), Funktionselemente (Methoden, Attribute, Ereignisse usw.) enthalten kann. Indexer, Operatoren, Konstruktoren und Destruktoren) und verschachtelte Typen. Klassen unterstützen die Vererbung, einen Mechanismus, der es Unterklassen ermöglicht, eine Basisklasse zu erweitern und zu spezialisieren.

Kategorie 1.1

1.1.1 Klassendeklaration

Das Syntaxformat ist wie folgt

修饰符 class 类名{
}

Erstellen Sie beispielsweise eine Schülerklasse

public class st{
    public string name;  //姓名
    public int age;      //年纪
    private string gender;//性别
}

1.1.2 Klassenmodifikatoren

NEU: ist nur in verschachtelten Klassendeklarationen zulässig und zeigt an, dass die Klasse von der Basisklasse geerbte Mitglieder mit demselben Namen wie die Basisklassenmitglieder verbirgt

public:Schränkt den Zugriff auf diese Klasse nicht ein, sie ist öffentlich

geschützt:kann nur von seiner Klasse und Unterklassen seiner Klasse aus zugegriffen werden

intern:Jeder Code, der der Assembly zustimmt, kann darauf zugreifen

privat:Nur die Klasse kann darauf zugreifen

Abstract:Abstrakte Klasse, erlaubt keine Erstellung von Instanzen der Klasse

versiegelt:Versiegelte Klasse, darf nicht vererbt werden

1.2 Eigenschaften und Methoden

1.2.1 Eigenschaften

Eine Eigenschaft ist ein Mitglied, das für den Zugriff auf Merkmale eines Objekts oder einer Klasse verwendet wird; Eigenschaften verfügen über Zugriffsfunktionen, die Anweisungen angeben, die ausgeführt werden müssen, wenn ihre Werte gelesen oder geschrieben werden.

1. Eigenschaften von Attributen

a. Attribute können dem Programm Metadaten hinzufügen. Metadaten sind in ein Programm eingebettete Informationen, beispielsweise Compileranweisungen oder Datenbeschreibungen

b. Programme können Reflektion nutzen, um ihre eigenen Metadaten zu überprüfen.

c. Eigenschaften werden normalerweise für die Interaktion mit COM verwendet.

Metadaten sind die Beschreibung von Daten und bilden die Grundlage und Quelle von Daten.

Attribute gibt es in zwei Formen:Eines ist ein Attribut, das in der Basisklassenbibliothek der Common Language Runtime definiert ist;Die anderen sind benutzerdefinierte Eigenschaften die Sie erstellen, um Ihrem Code zusätzliche Informationen hinzuzufügen

2. Syntaxformat von Attributen

Syntaxformat:

访问修饰符 数据类型 属性名
{
    get
    {
    return 变量名;
    }
    set
    {
    变量名=value;
    }

}

Benutzerdefinierte Eigenschaften werden in einer Klasse deklariert, indem die Zugriffsebene angegeben wird, gefolgt vom Typ der Eigenschaft, gefolgt vom Eigenschaftsnamen, gefolgt vom Codemodul, das den Get-Accessor und den Set-Accessor deklariert.

3. Holen Sie sich den Accessor und legen Sie den Accessor fest

Der Get-Accessor ähnelt einem Methodenkörper insofern, als er einen Wert des Eigenschaftstyps zurückgeben muss; der Set-Accessor ähnelt einer Methode mit dem Rückgabetyp void insofern, als er einen impliziten Parameter namens value und dessen Typ verwendet Parameter ist der Typ der Eigenschaft.

Wir führen Sie durch die folgenden beiden Codes, um Get und Set zu verstehen

a. Gewöhnlicher Schreibstil

namespace get和set访问器
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Myclass myclass = new Myclass(); //实例化对象
            myclass.shooiunfo();
            int a = myclass.GetAge();
            Console.WriteLine("age的年龄是" + a);
            int b = myclass.Age;
            Console.WriteLine(b);
        }
    }
    class Myclass
    {
        public string Name = "小王";
        int age = 18;           //前面不加访问修饰符默认为private
        public int GetAge()    //此处类似与get访问器
        {
            return age;
        }
        public void setAge(int ag) //此处类似于set访问器
        {
            if (ag > 120)
                ag = 120;
            else if (ag < 1)
                ag = 1;
            age = ag;
        }
        public int Age
        {
            get { return age; }
            set
            {
                if (value > 120)
                    value = 120;
                else if (value < 1)
                    value = 1;
                age = value;
            }
        }
        public void shooiunfo() //展示字段name和age
        {
            Console.WriteLine(Name);
            Console.WriteLine(age);
        }
    }
}

b. Accessor-Schreibmethode

public int Age
        {
            get { return age; }
            set
            {
                if (value > 120)
                    value = 120;
                else if (value < 1)
                    value = 1;
                age = value;
            }
        }

1.3 Methode

Eine Methode ist ein Mitglied, das eine Berechnung oder Operation implementiert, die von einem Objekt oder einer Klasse ausgeführt werden kann. Klassenmethoden sind hauptsächlich mit der Klasse verknüpfte Aktionen, bei denen es sich um die externe Schnittstelle der Klasse handelt.

1.3.1 Methodendeklaration

Der Name und die Parameterliste einer Methode definieren die Signatur der Methode. Konkret besteht die Signatur einer Methode aus ihrem Namen und der Anzahl ihrer formalen Parameter, Modifikatoren und Typen.

Hinweis: Der Rückgabetyp einer Methode und die in ihrer Parameterliste referenzierten Typen müssen mindestens genauso zugänglich sein wie die Methode selbst.

Im Folgenden finden Sie beispielsweise eine einfache Ausgabemethode

class myclass
{
    public void Name() //方法的声明
    {
        Console.Write("这个类的名字叫做myclass")
    }
}

1.3.2 Parametertypen von Methoden

1. Parameterparameter

Es wird verwendet, um die verwendeten Methodenparameter anzugeben, wenn die Anzahl der Parameter variabel ist. Der Parameter params muss ein eindimensionales Array sein.

 class Program
    {
        static void UseParams(params string[] list)//声明一个静态方法UseParams(),接收一个string[]类型的参数！
     ///此处使用了params参数：用来指定在参数数目可变是采用的方法参数,但必须是一维数组！
        {
            for (int i = 0; i < list.Length; i++)
            {
                Console.WriteLine(list[i]);
            }
        }
        static void Main()
        { 
            string[] strName = new string[5] { "我", "是", "中", "国", "人" };
            UseParams(strName);//将数组strName数组赋值给UseParams中list数组中!
            Console.Read();
        }
    }

2.ref-Parameter

Der ref-Parameter bewirkt, dass Methodenparameter als Referenz übergeben werden. Dies hat zur Folge, dass bei der Rückgabe der Kontrolle an die aufrufende Methode alle an den Parametern in der Methode vorgenommenen Änderungen in der Variablen widergespiegelt werden.

Wenn Sie Ref-Parameter verwenden möchten, müssen sowohl die Methodendeklaration als auch der Methodenaufruf explizit das Schlüsselwort ref verwenden

namespace ref参数
{
    class Program
    {
        public static void Method(ref int i)//声明一个静态方法Method,并接收一个INT类型的ref参数
        ///方法声明和调用都必须显示使用ref关键字
        ///ref参数：使方法参数按引用传递
        {
            i = 44;
        }
        public static void Main()
        {
            int val = 0;
            Method(ref val);
            Console.WriteLine(val);
            Console.WriteLine(10);
            Console.Read();
        }
    }
}

3. Out-Parameter

Der Out-Parameter wird zum Definieren von Ausgabeparametern verwendet, die dazu führen, dass die Parameter als Referenz übergeben werden. Dies ähnelt dem Schlüsselwort ref. Der Unterschied besteht darin, dass ref die Variable vor der Übergabe initialisieren muss, während die durch die definierten Parameter definiert sind Das OUT-Schlüsselwort muss nicht initialisiert werden. Es kann verwendet werden.

class Program
    {
        static void Method(out int i)
        ///于ref相似，不同点于ref要提前初始化而out不需要！
        {
            i = 0;
        }
        public static void Main()
        {
            int value;
            Method(out value);
            Console.WriteLine("输出数："+value);
            Console.Read();
        }
    }

1.3.3 Klassifizierung der Methoden

Methoden werden instatische Methoden undnicht statische Methoden

1. Statische Methode

Statische Methoden funktionieren nicht auf bestimmten Instanzen. Wenn sie aufgerufen werden, müssen sie direkt über den Klassennamen aufgerufen werden.

static void Main(string[] args)
{
    Console.WriteLine(Program.Add(3,5)); //通过类名Program调用
}

public static int Add(int x,int y) //定义静态方法
{
    return x+y;
}

2. Nichtstatische Methoden

Nicht statische Methoden arbeiten mit einer bestimmten Instanz der Klasse. Beim Aufruf müssen Sie eine Instanz (ein Objekt) der Klasse verwenden, um den Aufruf durchzuführen.

static void Main(string[] args)
{
    Add add=new Add();
    Console.WriteLine(add.Add(3,5)); //通过实例化名add调用
}

public int Add(int x,int y) //定义非静态方法
{
    return x+y;
}

3. Überladung der Methoden

Bezieht sich auf Methoden mit demselben Methodennamen, aber unterschiedlichen Datentypen, unterschiedlicher Anzahl und Reihenfolge der Parameter.

  /// <summary>
    /// 方法的重载是指方法名相同，但参数的数据额类型、个数和顺序不同的方法
    /// 只要类中有两个以上的同名方法，但是使用的参数类型、个数和顺序不同，调用时编译器即可判断在那种情况下调用哪种方法。
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Program program = new Program();
            int a = 1;
            int b = 2;
            int c = 3;
            Console.WriteLine(program.Add(a,b));
        }
//以下为重载方法
        public double Add(int x, double y)
        {
            return x + y;
        }
        public int Add(int x, int y,int z)
        {
            return x + y+z;
        }
        public static int Add(int x, int y)
        {
            return x + y;
        }
    }

1.4 Felder

Ein Feld ist eine Variable beliebigen Typs, die direkt in einer Klasse oder Struktur deklariert wird.

Deklarieren Sie ein Feld, das mit Zugriffsmodifikator + Typ + Variablenname deklariert werden kann

public myclass
{
    //以下在类中或结构中的变量都为字段
    public string name;
    int age;
}

1.4.1 Eigenschaften von Feldern

1. Felder verwenden normalerweise nicht das Schlüsselwort public und werden nur empfohlen, wenn sie privat und geschützt sind. Wenn Sie public verwenden möchten, empfiehlt es sich, es in ein Attribut umzuwandeln. Dies geschieht aus Gründen des objektorientierten Designs. Ein einfaches Verständnis ist, dass Felder intern und Attribute extern sind.

2. Sie können das Schlüsselwort static für das Feld verwenden, wodurch das Feld jederzeit vom Aufrufer aufgerufen werden kann, auch wenn keine Instanz einer Klasse vorhanden ist.

3. Sie können für Felder auch das Schlüsselwort static readonly verwenden, das dem Schlüsselwort const sehr ähnlich ist. Der Unterschied zwischen ihnen besteht darin, dass auf static readonly zur Laufzeit zugegriffen werden muss, während auf const bereits zur Kompilierungszeit zugegriffen werden kann.

4. Die Felder werden initialisiert, bevor der Konstruktor der Objektinstanz aufgerufen wird. Wenn der Konstruktor dem Feld einen neuen Wert zuweist, überschreibt er alle bei der Felddeklaration angegebenen Werte.

5. Felder können mit den Schlüsselwörtern ref und out übergeben werden.

1.5 Der Unterschied zwischen Eigenschaften und Methoden

Konzeptionell lässt sich der Unterschied zwischen Feldern und Eigenschaften unterscheiden: Ein Feld ist eine Variable, die zum Speichern von Daten verwendet wird, und eine Eigenschaft ist eine Methode oder ein Funktionsmember. Was ist also der Unterschied zwischen einem Attribut und einer Methode, da es sich um eine Methode handelt?

Wie aus der Definition hervorgeht, sind Attribute eigentlich selbst Methoden. Da Eigenschaften und Methoden jedoch als zwei Konzepte definiert sind, muss es Unterschiede zwischen ihnen geben. Persönlich besteht der größte Unterschied zwischen ihnen darin, dass Attribute keine Parameterliste haben, während Methoden eine Parameterliste haben müssen. Auch wenn keine Parameter vorhanden sind, muss dort eine leere Klammer gesetzt werden. Zweitens müssen in der Attributdefinition zwei Zugriffsmethoden vorhanden sein, set und get, mit denen der Wert des Attributs abgerufen und festgelegt wird. An den übrigen Stellen ist kein Unterschied festzustellen. Die Rechtmäßigkeit der Daten kann auch in den Attributen ermittelt werden, was sich nicht von der Methode unterscheidet.