C#-Lerntagebuch 20 ----statische statische Variablen und Konstanten

Im vorherigen Artikel Delegate (Delegate) Type habe ich beim Definieren der öffentlichen Methode das Schlüsselwort static verwendet, was den Zugriff auf diese Methode über den Namen object.method unmöglich machte. In diesem Artikel erfahren Sie mehr über statische Statik Variablen.

Variablen:

Bevor wir statische Variablen lernen, müssen wir noch die Bedeutung von Variablen verstehen. Programme müssen Vorgänge wie das Lesen, Schreiben und Berechnen von Daten ausführen. Wenn ein bestimmter Wert oder ein bestimmtes Ergebnis gespeichert werden muss, müssen Variablen verwendet werden. Aus der Sicht des Benutzers ist eine Variable der Name, der zur Beschreibung einer Information verwendet wird. In jeder Variablen können verschiedene Arten von Informationen gespeichert werden, z. B. der Name der Person, der Ticketpreis usw.; aus Sicht des Computers stellt die Variable die Speicheradresse dar, um welchen Typ es sich bei der Variablen handelt und um welchen Wert es sich handelt in der Variablen gespeichert. Ein wichtiger Grundsatz bei der Verwendung von Variablen besteht darin, dass Variablen zuerst definiert und dann verwendet werden müssen.

Die Definitions- und Verwendungsregeln von Variablen in C# ähneln denen in C/C++, daher werde ich hier nicht auf Details eingehen (es ist also sehr wichtig, C gut zu lernen^_^)

statische statische Variablen:

Mit dem statischen Modifikator deklarierte Variablen werden als statische Variablen bezeichnet. Sobald die Klasse geladen ist, zu der die statische Variable gehört, bleibt sie bis zum Ende bestehen Programm, das die Klasse enthält. Es gibt zwei Haupteigenschaften von static:

1. Versteckt:

Statische Methoden oder statische Variablen, die in einer Klasse definiert sind, gehören zur Klasse selbst, nicht zu einem Objekt dieser Klasse. Um eine als statisch definierte Methode aufzurufen, muss ihr der Name der Klasse vorangestellt werden. (Selbst eine Änderung im öffentlichen Zugriff funktioniert nicht, weshalb am Ende des vorherigen Artikels darauf hingewiesen wird, dass Instanzmethoden über Instanzen der Klasse verwendet werden müssen. Instanzmethoden können sowohl nicht statische als auch statische Mitglieder der Klasse verwenden.

Zugriffsregeln:

Statische Methoden können nur auf statische Mitglieder der Klasse zugreifen und nicht auf nicht statische Mitglieder der Klasse.
Nicht statische Methoden können auf statische Mitglieder der Klasse zugreifen und kann auch auf nicht-statische Mitglieder der Klasse zugreifen.
Statische Methoden können nicht über Instanzen, sondern nur über Klassennamen aufgerufen werden.

Zum Beispiel im folgenden Beispiel:

class person  
    {  
       public static int i;   //定义一个静态变量i 默认值是0  
       public int k=0;         //定义一个非静态变量 k;  
       public static int sbu()   // 定义一个静态方法   
       {  
           i = 9;  //成功对静态变量赋值  
           k = 5;  //出错了，无法访问非静态变量  
           return k;  
           //综上静态方法只能访问静态变量  
       }  
        public int Add()  //定义一个实例方法  
        {  
            i = 9;    //对静态变量赋值没有问题  
            k = 5;    //对非静态变量赋值也没问题  
            return i;  
            //综上实例方法能够访问所有类型变量  
        }  
  
    }

Wir instanziieren eine Person und ein Objekt, um auf die Methode zuzugreifen:

static void Main(string[] args)  
        {  
            person per = new person();   //实例化一个对象per  
           int i = per.i;   //出错了，per访问不了类里的静态变量  
            int k = per.k; //没有问题  
            per.sbu(); //出错了，per访问不了静态方法  
            person.sbu();  //成功调用  
            per.Add();   //成功调用  
            person.Add();  //出错了，person访问不了实例方法  
              
        }

2. Behalten Sie den Variableninhalt bei persistent:

Die im statischen Datenbereich gespeicherten Variablen werden initialisiert, wenn das Programm gerade mit der Ausführung beginnt, was das einzige Mal ist, dass es initialisiert wird. Es gibt zwei Arten von Variablen, die in statischen Speicherbereichen gespeichert sind: globale Variablen und statische Variablen. Im Vergleich zu globalen Variablen kann statische Variablen jedoch den sichtbaren Bereich von Variablen steuern.

Schreiben Sie einfach ein Beispiel und Sie werden wissen (diesmal habe ich es mit C+++ geschrieben), dass C# die Verwendung von Statik in Methoden nicht zulässt:

#include<iostream>  
  
using namespace std;  
  
int main()  
{  
   for (int i=0;i<4;i++)  
   {  
      static int k =0;   //定义一个静态变量并赋值为0   
      k++;  
      cout<<k<<endl;  //输出  
   }  
    
   return 0;  
  
}

Ergebnis:

Wenn wir im obigen Code statische Variablen entfernen, wird ｋ=0; zu einer nicht statischen Variablen und das Ergebnis ist nur eine Zahl 1;

Konstante:

Eine Konstante ist eine Größe, deren Qualität feststeht. Aus Sicht des Datentyps kann der Typ einer Konstante ein beliebiger Werttyp oder Referenztyp sein. Bei der Deklaration einer Konstante werden der Konstantenname und sein Wert zur Verwendung im Programm deklariert. (Verwendung ist auch ähnlich wie in C) Aber in C# kann der Wert einer Konstante, sobald sie definiert ist, nicht mehr geändert werden

Das Obige ist der Inhalt von C# Learning Diary 20----statische statische Variablen und Konstanten, mehr Für verwandte Inhalte beachten Sie bitte die chinesische PHP-Website (www.php.cn)!

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace demo  
{  
    class Program  
    {  
        const int S = 9;　 //　定义一个常量Ｓ并赋值  
        static void Main(string[] args)  
        {  
            S += 4;  //出错了，常量一旦定义就不能改变常量的值  
           Console.WriteLine(S);  
        }  
    }  
}