C# Learning Diary 20 ---- variables et constantes statiques statiques

Dans l'article précédent Delegate (Delegate) Type , j'ai utilisé le mot-clé static lors de la définition de la méthode publique, ce qui rendait impossible l'accès à cette méthode via le nom object.method. Dans cet article, nous en apprendrons davantage sur static static. variables.

Variables :

Avant d'apprendre les variables statiques, nous devons encore comprendre la signification des variables. Les programmes doivent effectuer des opérations telles que la lecture, l'écriture et le calcul de données. Lorsqu'une valeur ou un résultat spécifique doit être enregistré, des variables doivent être utilisées. Du point de vue de l'utilisateur, une variable est le nom utilisé pour décrire une information. Chaque variable peut être stockée dans une variable. Différents types d'informations, tels que : le nom d'une personne, le prix d'un billet, etc. du point de vue de l'ordinateur, la variable représente l'adresse de stockage, le type de la variable et ce qu'elle contient. le type de valeur est stocké dans la variable. Un principe important lors de l’utilisation de variables est que les variables doivent d’abord être définies puis utilisées.

Les règles de définition et d'utilisation des variables en C# sont similaires à celles en C/C, je n'entrerai donc pas dans les détails ici (il est donc assez important de bien apprendre le C^_^)

Variables statiques statiques :

Les variables déclarées avec le modificateur static sont appelées variables statiques. Une fois la classe à laquelle appartient la variable statique chargée, elle existera jusqu'à la fin du. programme contenant la classe. Il existe deux propriétés principales de static :

1. Caché :

Les méthodes statiques ou les variables statiques définies dans une classe appartiennent à la classe elle-même, et non à un objet de cette classe. Pour appeler une méthode définie comme statique, elle doit être précédée du nom de la classe. (Même la modification de l'accès public ne fonctionnera pas, c'est pourquoi à la fin de l'article précédent) Les méthodes d'instance doivent être utilisées via les instances de la classe. Les méthodes d'instance peuvent utiliser des membres non statiques de la classe ainsi que des membres statiques de la classe.

Règles d'accès :

Les méthodes statiques ne peuvent accéder qu'aux membres statiques de la classe et ne peuvent pas accéder aux membres non statiques de la classe
Les méthodes non statiques peuvent accéder aux membres statiques de la classe ; et peut également accéder à la classe Membres non statiques ;
Les méthodes statiques ne peuvent pas être appelées à l'aide d'instances, mais ne peuvent être appelées qu'à l'aide de noms de classe.

Par exemple, dans l'exemple suivant :

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;  
            //综上实例方法能够访问所有类型变量  
        }  
  
    }

On instancie une personne et un objet pour accéder à la méthode :

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. Conserver le contenu de la variable persistant :

Les variables stockées dans la zone de données statiques seront initialisées lorsque le programme commence juste à s'exécuter, ce qui est la seule fois où il est initialisé. Il existe deux types de variables stockées dans les zones de stockage statiques : les variables globales et les variables statiques. Cependant, par rapport aux variables globales, les variables statiques peuvent contrôler la plage visible des variables. Après tout, les variables statiques sont utilisées pour se cacher.

Écrivez simplement un exemple et vous saurez (cette fois je l'ai écrit avec C+++) C# n'autorise pas l'utilisation de statique dans les méthodes :

#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;  
  
}

Résultat :

Si nous supprimons la statique dans le code ci-dessus, alors ｋ=0; devient une variable non statique, et le résultat ne sera qu'un nombre 1 ;

Constante :

Une constante est une quantité dont la qualité est fixe Du point de vue du type de données, le type d'une constante peut être n'importe quel type de valeur ou type de référence. La déclaration d'une constante consiste à déclarer le nom de la constante et sa valeur à utiliser dans le programme. (L'utilisation est également similaire à C) Mais en C#, une fois qu'une constante est définie, sa valeur ne peut pas être modifiée

Ce qui précède est le contenu du C# Learning Diary 20 ----variables statiques statiques et constantes, plus Pour le contenu associé, veuillez faire attention au site Web PHP chinois (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);  
        }  
    }  
}