变量是赋予存储位置的名称，对该变量执行的所有操作都会影响该存储位置。在C＃中，必须先声明所有变量，然后才能使用它们。它是程序中存储的基本单位。可以在程序执行期间更改存储在变量中的值。
变量类型
- 局部变量
- 实例变量或非静态变量
- 静态变量或类变量
- 常数变数
- 只读变量
局部变量
在块，方法或构造函数中定义的变量称为局部变量。
- 这些变量是在进入该块或从该块退出后调用该函数或销毁该函数或从该函数返回调用时销毁的。
- 这些变量的范围仅存在于声明该变量的块中。也就是说，我们只能在该块中访问这些变量。
范例1：
// C# program to demonstrate
// the local variables
using System;
class StudentDetails {
// Method
public void StudentAge()
{
// local variable age
int age = 0;
age = age + 10;
Console.WriteLine("Student age is : " + age);
}
// Main Method
public static void Main(String[] args)
{
// Creating object
StudentDetails obj = new StudentDetails();
// calling the function
obj.StudentAge();
}
}
输出：
Student age is : 10
说明：在上述程序中，变量“ age”是函数StudentAge()的局部变量。如果我们在StudentAge()函数之外使用变量age，则编译器将产生错误，如下面的程序所示。
范例2：
// C# program to demonstrate the error
// due to using the local variable
// outside its scope
using System;
class StudentDetails {
// Method
public void StudentAge()
{
// local variable age
int age = 0;
age = age + 10;
}
// Main Method
public static void Main(String[] args)
{
// using local variable age outside it's scope
Console.WriteLine("Student age is : " + age);
}
}
错误：
prog.cs(22,43): error CS0103: The name `age’ does not exist in the current context
实例变量或非静态变量
实例变量是非静态变量，在类中声明，但在任何方法，构造函数或块之外。当实例变量在类中声明时，这些变量在创建类的对象时创建，而在对象被销毁时被销毁。与局部变量不同，我们可以对实例变量使用访问说明符。
例子：
// C# program to illustrate the
// Instance varibles
using System;
class Marks {
// These variables are instance variables.
// These variables are in a class and
// are not inside any function
int engMarks;
int mathsMarks;
int phyMarks;
// Main Method
public static void Main(String[] args)
{
// first object
Marks obj1 = new Marks();
obj1.engMarks = 90;
obj1.mathsMarks = 80;
obj1.phyMarks = 93;
// second object
Marks obj2 = new Marks();
obj2.engMarks = 95;
obj2.mathsMarks = 70;
obj2.phyMarks = 90;
// displaying marks for first object
Console.WriteLine("Marks for first object:");
Console.WriteLine(obj1.engMarks);
Console.WriteLine(obj1.mathsMarks);
Console.WriteLine(obj1.phyMarks);
// displaying marks for second object
Console.WriteLine("Marks for second object:");
Console.WriteLine(obj2.engMarks);
Console.WriteLine(obj2.mathsMarks);
Console.WriteLine(obj2.phyMarks);
}
}
输出 ：
Marks for first object:
90
80
93
Marks for second object:
95
70
90
说明：在上面的程序中，变量engMarks，mathsMarks，phyMarks是实例变量。如果上述程序中有多个对象，则每个对象将拥有自己的实例变量副本。从上面的输出中可以清楚地看到，每个对象都有自己的实例变量副本。
静态变量或类变量
静态变量也称为类变量。如果使用static修饰符显式声明了变量，或者如果在任何静态块下声明了变量，则这些变量称为静态变量。
- 这些变量的声明与实例变量的声明类似，不同之处在于，在任何方法构造函数或块之外的类中，使用static关键字声明静态变量。
- 与实例变量不同，无论我们创建多少个对象，每个类只能有一个静态变量的副本。
- 静态变量在程序执行开始时创建，并在执行结束时自动销毁。
注意：要访问静态变量，无需创建该类的任何对象，只需按以下方式访问变量：
class_name.variable_name;
例子：
// C# program to illustrate
// the static variables
using System;
class Emp {
// static variable salary
static double salary;
static String name = "Aks";
// Main Method
public static void Main(String[] args)
{
// accessing static variable
// without object
Emp.salary = 100000;
Console.WriteLine(Emp.name + "'s average salary:"
+ Emp.salary);
}
}
输出：
Aks's average salary:100000
注意：非静态变量的初始化与实例创建和构造函数调用相关联，因此非静态变量也可以通过构造函数进行初始化。我们不会通过构造函数初始化静态变量，因为每次构造函数调用时，它将使用新值覆盖现有值。
实例变量和静态变量之间的差异
- 每个对象都有自己的实例变量副本，而我们每个类只能有一个静态变量副本，无论我们创建了多少个对象。
- 使用一个对象对实例变量进行的更改不会反映在其他对象中，因为每个对象都有自己的实例变量副本。如果是静态的，则更改将反映在其他对象中，因为静态变量是类的所有对象所共有的。
- 我们可以通过对象引用访问实例变量，并且可以使用类名直接访问静态变量。
- 在类的生命周期中，静态变量即初始化一次且仅初始化一次，而如果没有创建实例，则实例变量初始化0次，如果创建n个实例，则初始化n次。
- 静态变量和实例变量的语法为：
class Example { static int a; // static variable int b; // instance variable }
常量变量
如果使用关键字“ const ”声明变量，则将其作为常量变量，并且这些常量变量在声明后不能修改一次，因此必须仅在声明时进行初始化。
示例1：下面的程序将显示错误，因为在常量变量声明时未提供任何值。
// C# program to illustrate the
// constant variables
using System;
class Program {
// constant variable max
// but no value is provided
const float max;
// Main Method
public static void Main()
{
// creating object
Program obj = new Program();
// it will give error
Console.WriteLine("The value of b is = " + Program.b);
}
}
错误：
prog.cs(8,17): error CS0145: A const field requires a value to be provided
示例2：显示常量变量用法的程序
// C# program to illustrate the
// constant variable
using System;
class Program {
// instance variable
int a = 10;
// static variable
static int b = 20;
// constant variable
const float max = 50;
// Main Method
public static void Main()
{
// creating object
Program obj = new Program();
// displaying result
Console.WriteLine("The value of a is = " + obj.a);
Console.WriteLine("The value of b is = " + Program.b);
Console.WriteLine("The value of max is = " + Program.max);
}
}
输出：
The value of a is = 10
The value of b is = 20
The value of max is = 50
有关常量的要点：
- 常量变量的行为将类似于静态变量的行为，即在类的生命周期中仅初始化一次且仅初始化一次，并且不需要访问或初始化该类的实例。
- 静态变量和常量变量之间的区别在于，静态变量可以被声明，而常量变量一旦声明就不能被修改。
只读变量
如果使用readonly关键字声明了一个变量，则它将是只读变量，并且这些变量不能像常量一样被修改，但必须在初始化后才能进行修改。
- 在声明时不必强制初始化只读变量，也可以在构造函数下对其进行初始化。
- 只读变量的行为将类似于非静态变量的行为，即仅在创建类的实例之后初始化，并且对于所创建的类的每个实例一次。
示例1：在下面的程序中，只读变量k没有初始化为任何值，但是当我们打印变量的值时，int的默认值即0将显示如下：
// C# program to show the use
// of readonly variables
// without initializing it
using System;
class Program {
// instance variable
int a = 80;
// static variable
static int b = 40;
// Constant variables
const float max = 50;
// readonly variables
readonly int k;
// Main Method
public static void Main()
{
// Creating object
Program obj = new Program();
Console.WriteLine("The value of a is = " + obj.a);
Console.WriteLine("The value of b is = " + Program.b);
Console.WriteLine("The value of max is = " + Program.max);
Console.WriteLine("The value of k is = " + obj.k);
}
}
输出：
The value of a is = 80
The value of b is = 40
The value of max is = 50
The value of k is = 0
示例2：显示构造函数中readonly变量的初始化。
// C# program to illustrate the
// initialization of readonly
// variables in the constructor
using System;
class Geeks {
// instance variable
int a = 80;
// static variable
static int b = 40;
// Constant variables
const float max = 50;
// readonly variables
readonly int k;
// constructor
public Geeks()
{
// initializing readonly
// variable k
this.k = 90;
}
// Main Method
public static void Main()
{
// Creating object
Geeks obj = new Geeks();
Console.WriteLine("The value of a is = " + obj.a);
Console.WriteLine("The value of b is = " + Geeks.b);
Console.WriteLine("The value of max is = " + Geeks.max);
Console.WriteLine("The value of k is = " + obj.k);
}
}
输出 ：
The value of a is = 80
The value of b is = 40
The value of max is = 50
The value of k is = 90
示例3：演示只读变量在其声明和外部构造函数之后何时初始化的程序：
// C# program to illustrate the
// initialization of readonly
// variables twice
using System;
class Geeks {
// instance variable
int a = 80;
// static variable
static int b = 40;
// Constant variables
const float max = 50;
// readonly variables
readonly int k;
// constructor
public Geeks()
{
// first time initializing
// readonly variable k
this.k = 90;
}
// Main Method
public static void Main()
{
// Creating object
Geeks obj = new Geeks();
Console.WriteLine("The value of a is = " + obj.a);
Console.WriteLine("The value of b is = " + Geeks.b);
Console.WriteLine("The value of max is = " + Geeks.max);
// initialzing readonly variable again
// will compile time error
obj.k = 55;
Console.WriteLine("The value of k is = " + obj.k);
}
}
错误：
prog.cs(41,13): error CS0191: A readonly field `Geeks.k’ cannot be assigned to (except in a constructor or a variable initializer)
有关只读变量的要点：
- 只读变量和实例变量之间的唯一区别是，可以修改实例变量，但不能修改只读变量。
- 常量变量是整个类的固定值，而只读变量是特定于类实例的固定值。