静态变量与非静态变量的区别
静态变量和非静态变量的区别
先来说说静态变量：静态变量使用static 修饰符进行声明，它是在所属类被装载时创建的，而且需要通过类进行访问，所属类的所有实例的同一静态变量都是同一个值。
然后是非静态变量：很明显的，带着static修饰符的变量是静态，那么不带有static 修饰符声明的变量称做非静态变量，它在类被实例化时创建，而且通过对象进行访问的，同一个类的不同实例的同一非静态变量可以是不同的值。
便于理解，这里放上一段代码，namespace CATest{class Program{public static String staticStr ="Class";public String notstaticStr ="Obj";static void Main(string[] args){//静态变量通过类进行访问，该类所有实例的同一静态变量都是同一个值Console.WriteLine("Class1's staticStr: {0}", Program.staticStr);//这里便于理解用Program.staticStr，因为你会发现，如果你去掉前面的类名，直接写staticStr是能正常运行的。
Program tmpObj1 = new Program();tmpObj1.notstaticStr = "tmpObj1";Program tmpObj2 = new Program();tmpObj2.notstaticStr = "tmpObj2";//非静态变量通过对象进行访问，不同对象的同一非静态变量可以有不同的值Console.WriteLine("tmpObj1's notstaticStr: {0}", tmpObj1.notstaticStr);Console.WriteLine("tmpObj2's notstaticStr: {0}", tmpObj2.notstaticStr);Console.ReadKey();}}}运行这段代码，大家可以很清楚看到结果：Class1's staticStr: ClasstmpObj1's notstaticStr: tmpObj1tmpObj2's notstaticStr: tmpObj2。
static和非静态的区别
堆 栈 静态存储区域
释放资源。GC Garbage Collection垃圾回收器
栈是存放函数调用过程中的临时变量的！ 堆是程序运行过程中动态申请的内存的存放处的
4)、实例函数中，既可以使用静态成员，也可以使用实例成员。
5)、静态类中只允许有静态成员，不允许出现实例成员。
6)、静态类无法实例化
7)、静态类在项目中资源共享
使用：
1)、如果你想要你的类当做一个"工具类"去使用，这个时候可以考虑将类写成静态的。
2)、静态类在整个项目中资源共享。
只有在程序全部结束之后，静态类才会释放资源。
静态和非静态的区别
1)、在非静态类中，既可以有实例成员，也可以有静态成员。
2)、在调用实例成员的时候，需要使用对象名.实例成员; 例如：Console.WriteLine();
在调用静态成员的时候，需要使类名.静态成员名;
3)、静态函数中，只能访问静态成员，不允许访问实例成员。
静态与非静态区别
静态与非静态区别静态类vs普通类静态类与普通类的区别有以下几点：1）静态类无法实例化而普通类可以；2）静态类只能从System.Object基类继承；普通可以继承其它任何非static和非sealed类，但也只能继承一个类；3）静态类不能继承接口；普通类可以继承多个接口；4）静态类只能包含静态成员；普通类可以包含静态和非静态成员；5）静态类不能作为字段，方法参数和局部变量使用；普通类可以;静态类的意义：可以用静态类封装一组不与任何对象相关联的方法，如Math类，Console类。
静态构造函数vs实例构造函数静态构造函数与实例构造函数的区别有以下几点：1）静态构造函数属于类，在第一次用到该类时执行且只执行一次；实例构造函数属于对象，在每次初始化一个新对象的时候都会执行；2）静态构造函数只能定义一次，且不能包含参数；实例构造函数可以定义重载，且可以包含参数；3）静态构造函数只能访问类型的静态字段；实例构造函数可以访问类型的静态和非静态字段；4）静态类不能包含访问修饰符，默认为private.静态构造函数的意义：设置类型的初始化，例如初始化类型需要的实例对象，为类型的静态字段赋值等。
静态方法vs实例方法静态方法与实例方法的区别有以下几点：1）静态方法属于类，通过类来调用；实例方法属于对象，通过对象来调用；2）静态方法不能访问类的非静态成员；静态方法的意义：完成一个与特定对象无关的功能。
静态字段vs非静态字段静态字段与非静态字段的区别：静态字段属于类，通过类来调用；非静态字段属于对象，通过对象来调用。
静态字段的意义：可以用静态字段来记录一些属于类本身的信息。
静态类调用静态方法和普通的类调用静态方法的区别1）静态方法属于类所有，类实例化前即可使用；2）非静态方法可以访问类中的任何成员，静态方法只能访问类中的静态成员；3）因为静态方法在类实例化前就可以使用，而类中的非静态变量必须在实例化之后才能分配内存；4）static内部只能出现static变量和其他static方法!而且static方法中还不能使用this等关键字，因为它是属于整个类；5）静态方法效率上要比实例化高，静态方法的缺点是不自动进行销毁，而实例化的则可以做销毁；6）静态方法和静态变量创建后始终使用同一块内存，而使用实例的方式会创建多个内存。
你必须知道的Csharp的25个基础概念
}//5-1-a-s-p-x
}
复制代码
客户端代码：
using System;
using System.Collections.Generic;
using System;
using System.Collections.Generic;
using System.Text;
namespace Example02Lib
{
public class Class1
{
public const String strConst = "Const";
static int Main()
{
string myString;
Console.Write("Enter your message: ");
myString = Console.ReadLine();
return MessageBox(0, myString, "My Message Box", 0);
}
}
}
复制代码
结果：
4.abstract是什么意思？答：abstract修饰符可以用于类、方法、属性、事件和索引指示器（indexer），表示其为抽象成员abstract不可以和static、virtual、override一起使用声明为abstract成员可以不包括实现代码，但只有类中还有未实现的抽象成员，该类就不可以被实例化，通常用于强制继承类必须实现某一成员示例：
静态类与非静态类的区别
静态类与非静态类的区别静态类静态类和非静态类重要的区别是在于静态类不能被实例化，也就是说不能使用 new 关键字创建静态类类型的变量。
使用static关键字来声明静态类，这样的意义在于：首先，它防止程序员写代码来实例化该静态类；其次，它防止在类的内部声明任何实例字段或方法。
静态类的使用关键字： static调用方式：<静态类名.静态方法>注意： 1.在静态类中只能访问静态成员； 2.在静态类中只能有静态成员；静态类的主要特性：1：仅包含静态成员。
2：无法实例化。
3：是密封的。
4：不能包含实例构造函数。
静态成员1：非静态类可以包含静态的方法、字段、属性或事件；2：无论对一个类创建多少个实例，它的静态成员都只有一个副本(体现在在A实例改变了某个静态变量的值将影响所有的实例)；3：静态方法和属性不能访问其包含类型中的非静态字段和事件，并且不能访问任何对象的实例变量；4：静态方法只能被重载，而不能被重写，因为静态方法不属于类的实例成员；5：虽然字段不能声明为static const，但const 字段的行为在本质上是静态的。
这样的字段属于类，不属于类的实例。
因此，可以同对待静态字段一样使用ClassName.MemberName 表示法来访问const 字段；6：C# 不支持静态局部变量(在方法内部定义静态变量)。
非静态类非静态类里即可有静态成员，也可以有非静态成员。
非静态里的静态方法可直接调用即：< 非静态类名.静态方法>非静态里的非静态方法需要实例化后才能被调用，格式如下：< 非静态类名变量=new 非静态类名();>静态类和非静态类的区别：非静态类是储存有状态的一类操作过程，例如语言包的非静态类，声明了之后，可能获取语言的种类，语言元素和一些附加的东西。
静态类可以视为类库里都是单一的过程，不存在“状态”的概念，就可以使用静态类。
非静态类可以包含静态方法，但静态类不能包含非静态方法。
静态变量与非静态变量的区别
{
Console.WriteLine("X = {0}, Y = {1}", A.X, B.Y);//⑤ 输出结果
Console.ReadLine();
}
}
关于C#静态构造函数的几点说明：
静态构造函数是C#的一个新特性，其实好像很少用到 。不过当我们想初始化一些静态变量的时候就需要用到它了 。这个构造函数是属于类的，而不是属于哪里实例的，就是说这个构造函数只会被执行一次 。也就是在创建第一个实例或引用任何静态成员之前，由.NET自动调用 。
5.访问方式
静态成员不能访问非静态成员；非静以后创建的对象都使用的该内存，相应的操作也就是对这块内存进行操作 。也可以看作是另类的全局变量 。
在WebSerivice中想只进行一次初始化，而不用每次都进行初始化这样占用大量资源 。还可以对调用的服务进行管理，比如想把每次调用的服务进行排队执行，可以将想应信息放到Arraylist中，静态时钟中排队执行 。
2、是在创建第一个类实例或任何静态成员被引用时，.NET将自动调用静态构造函数来初始化类，也就是说我们无法直接调用静态构造函数，也就无法控制什么时候执行静态构造函数了 。
3、一个类只能有一个静态构造函数 。
4、无参数的构造函数可以与静态构造函数共存 。尽管参数列表相同，但一个属于类，一个属于实例，所以不会冲突 。
// 转到初始值设定项---->
{
Console.WriteLine("static B()");
}
static void Main() //① 程序入口,
// 如果类中包含用来开始执行的 Main 方法,
static变量的作用
static变量的作⽤在C语⾔中，关键字static的意思是静态的，有3个明显的作⽤：1. 在函数体内，静态变量具有记忆作⽤，即⼀个被声明为静态的变量在这⼀函数被调⽤的过程中其值维持不变。
2. 在模块内（但在函数体外），它的作⽤域范围是有限制的，如果⼀个变量被声明为静态的，那么该变量可以被模块内所有的函数访问，但不能被模块外的其他函数访问。
3. 内部函数应该在当前源⽂件中说明和定义，对于可在当前源⽂件以外使⽤的函数，应该在⼀个头⽂件中说明，使⽤这些函数的源⽂件要包含这个头⽂件。
static全局变量和普通全局变量的区别：static全局变量只初始化⼀次，这是为了防⽌它在其他⽂件单元中引⽤。
static局部变量和普通局部变量的区别：static局部变量只初始化⼀次，下次的运算依据是上⼀次的结果值。
static函数与普通函数的区别在与作⽤域不⼀样，static()函数只在⼀个源⽂件中有效，不能被其它源⽂件使⽤。
静态数据成员的特点：1. 对于⾮静态数据成员，每个类都有⾃⼰的复制品。
⽽静态数据成员被当做是类的成员。
⽆论这个类的对象被定义了多少个，静态数据成员在程序中也只有⼀份复制品，由该类型的所有对象共享访问。
2. 静态数据成员存储在全局数据区。
定义时要分配空间，所以不能在类声明中定义。
由于静态数据成员属于本类的所有对象共享，所以他不属于特的类对象，在没有产⽣类对象时，其作⽤域就可见，即在没有产⽣类的实例时，程序员也可以使⽤它。
3. 静态数据成员也遵从public、protect、private访问规则。
4. static成员变量的初始化在类外，此时不能再带上static的关键字。
private、protect的static成员虽然可以在类外初始化，但是不能在类外被访问。
静态数据成员的优势：1. 静态数据成员没有进⼊程序的全局名字空间，因此不存在与程序中其他全局名字冲突的可能性。
2.可以实现信息隐藏。
静态数据成员可以使private成员，⽽全局变量不能。
java静态数组和非静态数组的区别
java静态数组和⾮静态数组的区别
区别：
1，数组创建时间不同，静态的是⼀定义出来就创建了，动态的则是定义时不创建，使⽤时才创建，⼀定意义上节省了内存空间。
2，使⽤场景不同，⼀开始就知道数组长度的使⽤静态初始化，反之，动态初始化。
静态数组根本不能满⾜我们编程的实际需要，⽐⽅说我需要在程序运⾏过程中动态的向数组中添加数据，这时我们的静态数组⼤⼩是固定的，显然就不能添加数据，要动态添加数据必须要⽤到动态数组，动态数组中的各个元素类型也是⼀致的。
具有容量扩充性，同步性和数据操作效率等特点！
String[] suit = new String[] {
"spades",
"hearts",
"diamonds",
"clubs"
};
或只有
String[] suit = {
"spades",
"hearts",
"diamonds",
"clubs"
};
或作为⼀个 List
List suit = Arrays.asList(
"spades",
"hearts",
"diamonds",
"clubs"
);。
浅谈Java中static和非static的区别
浅谈Java中static和⾮static的区别关于static和⾮static变量的区别1. static 修饰的变量称为类变量或全局变量或成员变量，在类被加载的时候成员变量即被初始化，与类关联，只要类存在，static变量就存在。
⾮static修饰的成员变量是在对象new出来的时候划分存储空间，是与具体的对象绑定的，该成员变量仅为当前对象所拥有的。
2. static修饰的变量在加载的时候先于main⽅法加载在内存中的数据共享区-------⽅法区，⽽⾮static的变量在加载的时候，是要创建变量才加载在堆内存中的。
3. ⼀个static变量单独划分⼀块存储空间，不与具体的对象绑定在⼀起，该存储空间被类的各个对象所共享。
static变量值在⽅法区加载⼀次，⽽⾮static在创建对象时会加载很多次。
每次创建都会拷贝⼀份。
4. 对象在引⽤成员变量是直接通过类名.变量名调⽤，对象在引⽤实例变量时只能通过对象名.变量名调⽤。
5. 在类中调⽤成员变量时直接调⽤或者以类名.变量名⽅式调⽤，实例变量则⽤this或者直接调⽤。
关于static⽅法和⾮static⽅法的区别1. static修饰的⽅法也和static⼀样。
先于main⽅法被加载到⽅法区，以便共享使⽤。
2. 静态的static⽅法中不能使⽤this或者super关键字，因为static⽅法是先于对象创建之前就已经加载的⽅法，是属于类的⽅法，⽽this和super指向的是本类的对象或者⽗类的对象，⾮静态的⽅法是属于对象的，⽅法⾥可以⽤this和super。
3. static⽅法可以⽤对象.⽅法名来调⽤，也可以⽤类名.⽅法名来调⽤。
⽽⾮静态的⽅法只能创建对象后时调⽤。
4. static⽅法是加载⼀次，被所有的对象所共享。
⽽⾮静态⽅法是有多少个对象就拷贝多少次，每个对象只能调⽤⾃⼰的拷贝的⽅法。
5. 对象调⽤⾮静态的⽅法时，不考虑线程安全性的问题，⽽调⽤静态⽅法时，要考虑安全性的问题。
静态类 非静态方法
静态类非静态方法静态类指的是在类声明时有关键字"static"修饰的类，静态类中的方法和属性都是静态的。
静态方法是在类声明时被声明为静态的方法，它们属于类而不是对象，不需要实例化对象就可以直接调用。
而非静态方法是在类声明时没有被声明为静态的方法，它们是属于对象的方法，需要通过实例化对象来调用。
静态类和非静态方法的使用在程序设计中很常见，它们有各自的特点和应用场景。
首先，静态类和静态方法主要用于工具类或服务类的设计。
静态类中的方法通常是一些公共的、通用的功能方法，并且在整个程序中都可以直接通过类名来调用，而不需要创建类的实例。
这样可以减少对象的创建和内存的占用。
例如，Math 类中的abs()方法就是一个静态方法，用于返回一个数的绝对值。
通过Math.abs(-5)，就可以直接调用这个方法，而不需要创建Math的实例。
另一方面，非静态方法通常用于表示对象的行为和状态，它们可以访问和修改对象的属性，并且可以调用其他非静态方法。
非静态方法需要通过创建对象来调用，每个对象都有自己的一组属性和方法，可以根据实际情况来进行操作。
例如，一个Person类有非静态方法eat()，表示吃饭的行为，每个人都有不同的饮食习惯和胃口，因此需要通过创建不同的Person对象来调用各自的eat()方法对应各自的食物习惯。
对于静态类和非静态方法的使用，需要注意以下几点：1. 静态类通常用final修饰，即静态类不能被继承，因为静态类中的方法和属性都是静态的，不适用于子类的扩展和覆盖；2. 静态类中的属性通常也是静态的，用于表示一些全局的变量，例如全局配置信息、数据库连接等；3. 非静态方法可以访问和修改对象的属性，因此需要注意线程安全的问题，在多线程环境下需要进行同步操作；4. 静态方法可以通过类名直接调用，而非静态方法需要通过对象来调用，因此需要创建对象实例；5. 静态类和静态方法通常不需要依赖其他对象或状态，因此不需要创建对象实例，可以更高效地进行调用。
static{}(静态代码块)与{}(非静态代码块)的异同点
static{}(静态代码块)与{}(非静态代码块)的异同点相同点：都是在JVM加载类时且在构造方法执行之前执行，在类中都可以定义多个，一般在代码块中对一些static变量进行赋值。
不同点：静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。
静态代码块只在第一次new执行一次，之后不再执行，而非静态代码块在每new一次就执行一次。
非静态代码块可在普通方法中定义(不过作用不大)；而静态代码块不行。
例：//普通类public class PuTong {public PuTong(){System.out.print("默认构造方法！-->");}//非静态代码块{System.out.print("非静态代码块！-->");}//静态代码块static{System.out.print("静态代码块！-->");}public static void test(){{System.out.println("普通方法中的代码块！");}}}//测试类public class TestClass {/*** 区别两次new静态与非静态代码块执行情况*/public static void main(String[] args) {PuTong c1 = new PuTong();c1.test();PuTong c2 = new PuTong();c2.test();}}/*运行输出结果是：静态代码块！-->非静态代码块！-->默认构造方法！-->普通方法中的代码块！非静态代码块！-->默认构造方法！-->普通方法中的代码块！*/一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的时候,需要使用静态方法,这种代码是被动执行的.两者的区别就是:静态代码块是自动执行的;静态方法是被调用的时候才执行的.作用:静态代码块可用来初始化一些项目最常用的变量或对象;静态方法可用作不创建对象也可能需要执行的代码.3.7.3 静态代码块在类中，可以将某一块代码声明为静态的，这样的程序块叫静态初始化段。
static{}（静态代码块）与{}（非静态代码块）的异同点
static{}（静态代码块）与{}（⾮静态代码块）的异同点相同点：都是在JVM加载类时且在构造⽅法执⾏之前执⾏，在类中都可以定义多个， ⼀般在代码块中对⼀些static变量进⾏赋值。
不同点：静态代码块在⾮静态代码块之前执⾏(静态代码块—>⾮静态代码块—>构造⽅法)。
静态代码块只在第⼀次new执⾏⼀次，之后不再执⾏，⽽⾮静态代码块在每new ⼀次就执⾏⼀次。
⾮静态代码块可在普通⽅法中定义(不过作⽤不⼤)；⽽静态代码块不⾏。
例：//普通类public class PuTong {public PuTong(){System.out.print("默认构造⽅法！-->");}//⾮静态代码块{System.out.print("⾮静态代码块！-->");}//静态代码块static{System.out.print("静态代码块！-->");}public static void test(){{System.out.println("普通⽅法中的代码块！");}}}//测试类public class TestClass {/*** 区别两次new静态与⾮静态代码块执⾏情况*/public static void main(String[] args) {PuTong c1 = new PuTong();c1.test();PuTong c2 = new PuTong();c2.test();}}/*运⾏输出结果是：静态代码块！-->⾮静态代码块！-->默认构造⽅法！-->普通⽅法中的代码块！⾮静态代码块！-->默认构造⽅法！-->普通⽅法中的代码块！*/。
【面试】动态变量与静态变量的区别
【⾯试】动态变量与静态变量的区别
动态变量与静态变量的区分就是定义该属性有⽆static修饰符。
两者之间的主要区别是，
①存储空间不同且⽣命期不同
动态变量：存储在动态数据区，跟随定义的函数出现/消失
静态变量：存储在静态数据区，在应⽤程序结束运⾏之前都不会消失
②作⽤域不同且赋初值不同
动态变量：作⽤在定义函数中，每次进⼊都会重新赋初始值，默认初始值不确定
静态变量：作⽤于整个程序⽂件，每次进⼊都会赋值上次给定的值（有可能是其他函数的赋值），默认值为0或者空字符串。
深入理解C#静态类与非静态类、静态成员的区别
深⼊理解C#静态类与⾮静态类、静态成员的区别静态类静态类与⾮静态类的重要区别在于静态类不能实例化，也就是说，不能使⽤ new 关键字创建静态类类型的变量。
在声明⼀个类时使⽤static 关键字，具有两个⽅⾯的意义：⾸先，它防⽌程序员写代码来实例化该静态类；其次，它防⽌在类的内部声明任何实例字段或⽅法。
静态类是⾃C# 2.0才引⼊的，C# 1.0不⽀持静态类声明。
程序员必须声明⼀个私有构造器。
私有构造器禁⽌开发者在类的范围之外实例化类的实例。
使⽤私有构造器的效果与使⽤静态类的效果⾮常相似。
两者的区别：私有构造器⽅式仍然可以从类的内部对类进⾏实例化，⽽静态类禁⽌从任何地⽅实例化类，其中包括从类⾃⾝内部。
静态类和使⽤私有构造器的另⼀个区别在于，在使⽤私有构造器的类中，是允许有实例成员的，⽽C# 2.0和更⾼版本的编译器不允许静态类有任何实例成员。
使⽤静态类的优点在于，编译器能够执⾏检查以确保不致偶然地添加实例成员，编译器将保证不会创建此类的实例。
静态类的另⼀个特征在于，C#编译器会⾃动把它标记为sealed。
这个关键字将类指定为不可扩展；换⾔之，不能从它派⽣出其他类。
静态类的主要特性：1：仅包含静态成员。
2：⽆法实例化。
3：是密封的。
4：不能包含实例构造函数。
静态成员1：⾮静态类可以包含静态的⽅法、字段、属性或事件；2：⽆论对⼀个类创建多少个实例，它的静态成员都只有⼀个副本；3：静态⽅法和属性不能访问其包含类型中的⾮静态字段和事件，并且不能访问任何对象的实例变量；4：静态⽅法只能被重载，⽽不能被重写，因为静态⽅法不属于类的实例成员；5：虽然字段不能声明为 static const，但 const 字段的⾏为在本质上是静态的。
这样的字段属于类，不属于类的实例。
因此，可以同对待静态字段⼀样使⽤ ClassName.MemberName 表⽰法来访问 const 字段；6：C# 不⽀持静态局部变量(在⽅法内部定义静态变量)。
静态对象与非静态对象
静态对象与⾮静态对象Java静态对象和⾮静态对象有什么区别？？静态对象⾮静态对象是类共同拥有的. 是类独⽴拥有的,内存空间上是固定的空间在各个附属类⾥⾯分配先分配静态对象的空间继⽽再对⾮静态对象分配空间,也就是初始化顺序是先静态再⾮静态.java静态对象和静态属性及静态⽅法⼜有什么区别呢？这三者都和⼀般的对象属性和⽅法相似,可以将静态对象看成的静态属性.只不过楼主要注意的是在⾮静态⽅法⾥是不可以使⽤静态属性的.静态⽅法⾥也⽆法使⽤⾮静态属性(是属性不是参数.参数⼀般是指在⽅法⾥临时新建的数值或对象,属性是类声明部分声明的信息).为什么先声明⼀个静态对象 static Lefthand left;还要在主函数中再实例化该对象呢left=new Lefthand();？因为任何对象在使⽤之前都要进⾏初始化,new就是进⾏对象的分配空间后进⾏初始化.java静态对象到底有什么好处？？我个⼈的理解就是静态对象可以让相同类型的类之间共享共同的属性,这个共享是同步的,⽽且不⽤new,节省了空间1、静态对象的数据在全局是唯⼀的，⼀改都改。
如果你想要处理的东西是整个程序中唯⼀的，弄成静态是个好⽅法。
2、⾮静态的东西你修改以后只是修改了他⾃⼰的数据，但是不会影响其他同类对象的数据。
3、静态对象和⾮静态对象都是对象，是对象都是要实例化的。
不同之处就是2者的数据表现和存储⽅式不⼀样。
4、静态的好处：引⽤⽅便。
对于公⽤类型的变量，直接⽤类名.静态⽅法名或者类名.静态变量名就可引⽤并且直接可以修改其属性值，不⽤getter和setter ⽅法。
保持数据的唯⼀性。
此数据全局都是唯⼀的，修改他的任何⼀处地⽅，在程序所有使⽤到的地⽅都将会体现到这些数据的修改。
有效减少多余的浪费。
Java成员变量、局部变量，静态成员变量、非静态成员变量的区别
Java成员变量、局部变量，静态成员变量、⾮静态成员变量的
区别
成员变量和局部变量的区别
1.定义位置上看
成员变量定义在类中，局部变量定义在⽅法中、或者语句中
2.内存的存储
成员变量跟随对象在堆中存储
局部变量跟着⽅法在栈内存存储
3.⽣命周期
成员变量堆内存存储，声明周期较长
局部变量栈内存存储，使⽤完毕后就消失，声明周期较短
4.作⽤范围
成员变量作⽤范围是整个类，最⼤
局部变量只在⽅法、语句中有效，最⼩
5.初始化赋值
成员变量堆内存，有默认值
局部变量栈内存，必须⼿动赋值
静态成员变量和⾮静态成员变量的区别
1.static修饰成员变量、类变量 ------- 属于类
⾮静态成员变量、实例变量、对象变量 ------- 属于对象
2.内存位置
静态，跟随类的加载⽽加载，随着类的消亡⽽消亡，⽅法区
⾮静态，跟随对象在堆中，没有引⽤变量后，成为垃圾
3.⽣命周期
静态随着类的加载⽽加载，⽣命最长
⾮静态成员变量，随着对象加载，⽣命相对较短
4.调⽤⽅式
静态，可以被类名、对象调⽤，使⽤类名
⾮静态，只能对象调⽤
5.作⽤意义
静态是所有对象共享数据
⾮静态是每个对象的特有数据。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
静态变量与非静态变量的区别静态变量：静态变量使用static修饰符进行声明在所属类被装载时创建通过类进行访
问所属类的所有实例的同一静态变量都是同一个值非静态变量：不带有static修饰符声明
的变量称做非静态变量在类被实例化时创建通过对象进行访问同一个类的不同实例的同一非静态变量可以是不同的值。
对于自动变量，它属于动态存储方式。
但是也可以用static定义它为静态自动变量，或称静态局部变量，从而成为静态存储方式。
由此看来，一个变量可由static进行再说明，并改变其原有的存储方式。
下面介绍静态变量与非静态变量的区别如下：
1.内存分配
静态变量在应用程序初始化时，就存在于内存当中,直到它所在的类的程序运行结束时才消亡；而非静态变量需要被实例化后才会分配内存。
2.生存周期
静态变量生存周期为应用程序的存在周期；非静态变量的存在周期取决于实例化的类的存在周期。
3.调用方式
静态变量只能通过“类.静态变量名”调用，类的实例不能调用；非静态变量当该变量所在的类被实例化后，可通过实例化的类名直接访问。
4.共享方式
静态变量是全局变量，被所有类的实例对象共享，即一个实例的改变了静态变量的值，其他同类的实例读到的就是变化后的值；
非静态变量是局部变量，不共享的。
5.访问方式
静态成员不能访问非静态成员；非静态成员可以访问静态成员。
静态变量在类装载的时候分配内存，以后创建的对象都使用的该内存，相应的操作也就是对这块内存进行操作。
也可以看作是另类的全局变量。
在WebSerivice中想只进行一次初始化，而不用每次都进行初始化这样占用大量资源。
还可以对调用的服务进行管理，比如想把每次调用的服务进行排队执行，可以将想应信息放到Arraylist中，静态时钟中排队执行。
C#静态构造函数及静态变量
静态构造函数：
（1）用于对静态字段、只读字段等的初始化。
（2）添加static关键字，不能添加访问修饰符，因为静态构造函数都是私有的。
（3）类的静态构造函数在给定应用程序域中至多执行一次：只有创建类的实例或者引用类的任何静态成员才激发静态构造函数
（4）静态构造函数是不可继承的，而且不能被直接调用。
（5）如果类中包含用来开始执行的Main方法，则该类的静态构造函数将在调用Main 方法之前执行。
（6）任何带有初始值设定项的静态字段，则在执行该类的静态构造函数时，先要按照文本顺序执行那些初始值设定项。
（7）如果没有编写静态构造函数，而这时类中包含带有初始值设定的静态字段，那么编译器会自动生成默认的静态构造函数。
经典例子：
1/*
2*静态构造函数练习
3*（1）①②③……为执行顺序
4*（2）输出结果：static A()
5*static B()
6*X=1,Y=2
7*/
8using System;
9class A
10{
11public static int X;
12static A()//④执行完后返回到③
13{
14X= B.Y+1;
15Console.WriteLine("static A()");
16}
17}
18class B
19{
20public static int Y= A.X+1;//③调用了A的静态成员,
21//转到A的静态构造函数---->
22static B()//②如果带有初始值设定项的静态字段,
23//执行该类的静态构造函数时,
24//先要按照文本顺序执行那些初始值设定项。
25//转到初始值设定项---->
26{
27Console.WriteLine("static B()");
28}
29static void Main()//①程序入口,
30//如果类中包含用来开始执行的Main方法,
31//该类的静态构造函数将在调用Main方法之前执行。
32//转到B的静态构造函数---->
33{
34Console.WriteLine("X={0},Y={1}", A.X, B.Y);//⑤输出结果
35Console.ReadLine();
36}
37}
关于C#静态构造函数的几点说明：
静态构造函数是C#的一个新特性，其实好像很少用到。
不过当我们想初始化一些静态变量的时候就需要用到它了。
这个构造函数是属于类的，而不是属于哪里实例的，就是说这
个构造函数只会被执行一次。
也就是在创建第一个实例或引用任何静态成员之前，由.NET 自动调用。
38class SimpleClass
39{
40//Static constructor
41static SimpleClass()
42{
43//
44}
45}
在使用静态构造函数的时候应该注意几点：
1、静态构造函数既没有访问修饰符，也没有参数。
因为是.NET调用的，所以像public 和private等修饰符就没有意义了。
2、是在创建第一个类实例或任何静态成员被引用时，.NET将自动调用静态构造函数来初始化类，也就是说我们无法直接调用静态构造函数，也就无法控制什么时候执行静态构造函数了。
3、一个类只能有一个静态构造函数。
4、无参数的构造函数可以与静态构造函数共存。
尽管参数列表相同，但一个属于类，一个属于实例，所以不会冲突。
5、最多只运行一次。
6、静态构造函数不可以被继承。
7、如果没有写静态构造函数，而类中包含带有初始值设定的静态成员，那么编译器会自动生成默认的静态构造函数。
希望通过阅读本文，能给你带来帮助。
本文由西安京科皮肤病医学研究院(/)负责人整理与大家分享！。