静态变量

寄存器变量是存在CPU的寄存器当中的，这样比存在内存中速度快很多！所以严格按照你的说法来回答就是：不会浪费内存，但会占用CPU的寄存器。静态变量相当于是程序的一部分，程序在计算机运行时，静态变量就一直存在，当程序死亡，静态变量的空间才跟着被注销，除结束进程以外没有别的途径将静态变量销毁。相当于全局变量，因为它会在程序生命周期内一直存在，并且其他函数也能访问。而寄存器变量只是和其他变量存储位置不同，在使用上和一般变量没有区别，仅仅是访问速度更快一些。

synchronized

c语言中变量分为四类，分别是1.auto 自动变量2.static 静态存贮分配变量（又分为内部静态和外部静态）3.extern 外部变量/全程变量（用于外部变量说明）4.register 寄存器变量（分配在硬件寄存器中）四大类，所有变量必须先说明（定义），后使用。下面分别介绍1.自动变量（局部变量）局部变量：在一个函数开头或段开头处说明的变量，它有几个特征，,a、作用域为定义它的函数b、编译器不会对自动变量给予隐含的初值，故其值不确定，因此每次使用前必须明确的置初值。c、形参是自动变量，作用域仅限于相应函数内d、自动变量随函数的引用而存在和消失，由一次调用到下一次调用之间不保持值。2.外部变量：在函数外部定义的变量即为外部变量，它的作用域是整个程序（全程变量）。a. c程序可以分别放在几个文件上，每个文件可以作为一个编译单位分别进行编译。外部变量只需在某个文件上定义一次，其它文件若要引用此变量时，应用extern加以说明（外部变量定义时不必加extern关键字）。b. 在同一文件中，若前面的函数要引用后面定义的外部（在函数之外）变量时，在函数里加extern加以说明。引进外部变量的原因：解决函数单独编译的协调；与变量初始化有关；外部变量的值是永久的；解决数据共享；注意：函数本身也被认为是外部变量3.静态变量：分为内部静态变量和外部静态变量内部静态变量：a.在局部变量前加上static就为内部静态变量b.静态局部变量仍是局部变量，其作用域仍在定义它的函数范围内，但它采用静态存贮分配（由编译程序在编译时分配，而一般的自动变量和函数形参均采用动态存贮分配，即在运行时分配空间），当函数执行完，返回调用点时，该变量并不撤销，再次调用时，其值将继续存在。外部静态变量：a.在函数外部定义的变量前加static即为外部静态变量b.作用域为定义它的文件，即成为该文件的私有变量，其他文件上的函数一律不得直接访问，除非通过它所在文件上的函数进行操作，这可实现数据隐 藏。4.寄存器变量：只有自动（局部）变量和函数参数才能进一步指定为寄存器存贮类a.使用register变量可以提高存取速度，但寄存器变量的数目依赖于具体机器，声明多了也只有前几个有效。b.只限于int,char,short ,unsigned和指针类型用寄存类。c.不能对register变量取地址（即&操作）

外部变量，在定义的时候初始化，外部引用的时候不得初始化。静态变量和自动变量，有初始化值时，按值进行初始化。无初始化值时，静态变量初始化为0.自动变量值随机。

在修饰非成员函数时表示该函数不是全局函数，而仅供本文件使用；在修饰成员函数时，表示该函数只能调用类的静态成员变量并且该方法可以不必经由实例化的类对象就能够应用；static修饰变量：修饰全局变量时，该变量只能供本文件内部使用；修饰成员变量时，该变量成为类变量，存储在静态存储区中，不经过类实例就可以访问该变量；修饰局部变量时，该变量在函数第一次被调用时初始化，并将其存放到静态存储区，函数退出后变量值保持不变，下一次进入函数时将跳过对它的初始化，它的生命周期直到程序退出。最后，要说明的是，static变量在全局中只有一份，不会有多份拷贝。extern用于声明变量时，如果不指出变量的类型，则默认为int，如果不是int的，必须显示指出变量的类型，否则出错。extern实际上只对变量有用，对函数而言，只是个幌子（能够更加清晰明了的让我们知道也让编译器知道该函数可以用于“外交”），没有实质性的作用，以后记住了，看到extern和函数扯上关系，你理都不用理，直接把它拿掉就OK了。但是它还是有那么一点用的，既然“存在的就是合理的”，那么它必然有点用啦，利用它可以在程序中取代include “*.h”来声明函数，在一些复杂的项目中，我比较习惯在所有的函数声明前添加extern修饰。

是这样的,这不是挺明白的嘛.

静态变量在两个类中一样，原因如下：1、是相同的，static变量是属于类的，属于类所有对象的，当一个类调用并改变static属性时，也改变了所有对象的static属性。2、如果是普通变量的话，一个对象改变其普通属性，只是这个对象的属性发生改变，其他对象的这个属性不发生改变。

静态构造函数： （1）用于对静态字段、只读字段等的初始化。 （2）添加static关键字，不能添加访问修饰符，因为静态构造函数都是私有的。 （3）类的静态构造函数在给定应用程序域中至多执行一次：只有创建类的实例或者引用类的任何静态成员才激发静态构造函数 （4）静态构造函数是不可继承的，而且不能被直接调用。 （5）如果类中包含用来开始执行的 Main 方法，则该类的静态构造函数将在调用 Main 方法之前执行。 （6）任何带有初始值设定项的静态字段，则在执行该类的静态构造函数时，先要按照文本顺序执行那些初始值设定项。 （7）如果没有编写静态构造函数，而这时类中包含带有初始值设定的静态字段，那么编译器会自动生成默认的静态构造函数。*************************************************** 静 态 构 造 函 数 练 习* （1）①②③……为执行顺序* （2）输出结果： static A()* static B()* X = 1, Y = 2***************************************************/using System;class A{public static int X;static A() //④ 执行完后返回到③{X = B.Y + 1;Console.WriteLine("static A()");}}class B{public static int Y = A.X + 1; //③ 调用了A的静态成员,// 转到A的静态构造函数---->static B() //② 如果带有初始值设定项的静态字段,// 执行该类的静态构造函数时,// 先要按照文本顺序执行那些初始值设定项。// 转到初始值设定项---->{Console.WriteLine("static B()");}static void Main() //① 程序入口,// 如果类中包含用来开始执行的 Main 方法,// 该类的静态构造函数将在调用 Main 方法之前执行。// 转到B的静态构造函数---->{Console.WriteLine("X = {0}, Y = {1}", A.X, B.Y);//⑤ 输出结果Console.ReadLine();}}

都是不会改变的...区别在于: 常量本身就是值的形式,内存中是不分空间的而静态变量,是变量形式,内存中是要分空间的用途:常量一般是用在程序总体某些公式的最前定义的.比如: 数据库的SEVER,USER,PSW之类的静态变量,是用在参于不变值计算的比如:用户登陆的几种状态可以定义几个静态变量来加以区分.

静态变量，起始于类的加载，终止于类的释放。如果你的静态变量放到activity中，当activity被finish掉的时候，静态变量就不存在了，如果你的静态变量放到了一个静态的方法中应该就不会了，只有程序退出的时候才会消失，java的垃圾回收机制不会回收静态变量的

懒人模式 不想NEW了 就写STATIC

静态变量，起始于类的加载，终止于类的释放。如果你的静态变量放到activity中，当activity被finish掉的时候，静态变量就不存在了，如果你的静态变量放到了一个静态的方法中应该就不会了，只有程序退出的时候才会消失，java的垃圾回收机制不会回收静态变量的

既然要改你当初就别设啊，接口里设变量有意义吗？以前还可以当枚举用，现在有了枚举类了你还在接口里写变量就是傻

不对，静态变量的生存周期是从定义开始，到程序结束。

static修饰的变量只被初始化一次，并且保持最近的值，哪怕创建它的函数已经结束，这个变量也不会被释放，下次调用是同一个地址，所以里面的值是上次的。具体原因请关注变量分配空间相关知识，神马常量区，代码区，堆栈区的

在类的内部，也就是第一层大括号内声明的变量，在C语言中叫全局变量，在C# Java 中叫成员变量，他是对象的属性，可同时赋值也可不赋，有默认值，在new 一个新对象时会在栈内存中申请一块内存 ，在 . 调用时会在堆内存声明一块内存，里面会有你点调用时的属性也就是全局变量（成员变量）调几个有几个，栈中的对象占有的内存 有地址 会指向该对象在堆中声明的内存空间，所以new出来的对象占两块内存。 静态变量是在data segment（ 数据内存）只有一个，直接调用，类名.变量名。方法里声明的变量是局部变量，必须同时赋值，只在栈内存中咱一块空间名和值在一块。 c语言的话得您亲自释放内存，不能释放多，也不能不释放（我没学过，不太清楚），C和Java 里 在方法执行完后new 的对象 会立刻消失，所以指向也消失，原先对象在堆中内存里声明指向的东西也就没用了，垃圾回收器会定期回收这些玩意，您大可不必管!我也是初学，自己的分析，有说错的地方请多多包涵！！！！谢谢！仅供参考！！▼╝

在类的内部，也就是第一层大括号内声明的变量，在C语言中叫全局变量，在C# Java 中叫成员变量，他是对象的属性，可同时赋值也可不赋，有默认值，在new 一个新对象时会在栈内存中申请一块内存 ，在 . 调用时会在堆内存声明一块内存，里面会有你点调用时的属性也就是全局变量（成员变量）调几个有几个，栈中的对象占有的内存 有地址 会指向该对象在堆中声明的内存空间，所以new出来的对象占两块内存。 静态变量是在data segment（ 数据内存）只有一个，直接调用，类名.变量名。方法里声明的变量是局部变量，必须同时赋值，只在栈内存中咱一块空间名和值在一块。 c语言的话得您亲自释放内存，不能释放多，也不能不释放（我没学过，不太清楚），C和Java 里 在方法执行完后new 的对象 会立刻消失，所以指向也消失，原先对象在堆中内存里声明指向的东西也就没用了，垃圾回收器会定期回收这些玩意，您大可不必管!我也是初学，自己的分析，有说错的地方请多多包涵！！！！谢谢！仅供参考！！

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class TestClock extends JFrame{ /** Creates a new instance of TestClock */ public TestClock() { JPanel jp=new JPanel(); final JLabel jl=new JLabel("0"); jp.add(jl); add(jp,BorderLayout.CENTER); JButton jbStart=new JButton("开始"); jbStart.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { JButton j =(JButton)e.getSource(); j.setEnabled(false); dt=new DamThread(new ClockThread(jl)); dt.start(); } }); JButton jbPause=new JButton("暂停"); jbPause.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { JButton j=(JButton)e.getSource(); String s=(String)e.getActionCommand(); if(s.equals("暂停")){ dt.setStatus(ClockStatus.PAUSE); j.setText("继续"); }else{ dt.setStatus(ClockStatus.CONTINUE); j.setText("暂停"); } } }); JButton jbZero=new JButton("清零"); jbZero.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { dt.setStatus(ClockStatus.ZERO); } }); JButton jbStop=new JButton("停止"); jbStop.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { dt.setStatus(ClockStatus.STOP); } }); JPanel jp1=new JPanel(); jp1.add(jbStart); jp1.add(jbPause); jp1.add(jbZero); jp1.add(jbStop); add(jp1,BorderLayout.SOUTH); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); pack(); setLocationRelativeTo(null); } public static void main(String[] args) { TestClock tc=new TestClock(); tc.setVisible(true); } DamThread dt; } class DamThread extends Thread{ public DamThread(ClockThread c){ this.ct=c; ct.start(); this.setDaemon(true); this.STATUS=ClockStatus.START; } public void run(){ while(ct.isAlive()){ CheckStatus(); } }

>>> class MyClass(object):... clsvar = "static"... >>> c1 = MyClass()>>> c2 = MyClass()>>> print c1.clsvar, c2.clsvar, MyClass.clsvarstatic static static>>> c1.clsvar = "changed">>> print c1.clsvar, c2.clsvar, MyClass.clsvarchanged static static>>> MyClass.clsvar = "change common">>> print c1.clsvar, c2.clsvar, MyClass.clsvarchanged change common change common>>>

为了静态方法调用....更多的自己上网找,有问时间都能找到的了..

js没有静态变量

没有静态变量

比如你想知道你点击了几次按钮，就可以用静态变量例子：Option ExplicitPrivate Sub Command1_Click()Static i As Integeri = i + 1Print "您点击了" & i & "次"End Sub

你要清楚什么是对象实例化，什么是变量。你举的这个例子中，int a在main的里面，是一个函数的内部变量，你认为，你一个函数中定义的变量，你这个函数难道还不可以使用吗？？对不对? 这个函数就当然可以使用了。另外的情况，如果你的int a是这样的话：int a=0;public static void main (String[] args) { System.out.println("a的数="+a); }就是在main之前定义，反正就是不是在main里面定义的。那么你这样使用就是不对的，因为按照规则静态的方法是不能使用非静态变量的，这条对不对？？好，那么我给你解释一下，为什么不可以使用吧。第一，JAVA几乎都是面向对象的这样一种思想，所以基本上都是通过实例化对象来完成功能的。静态的方法，是不管你对象实例化与否都存在的，这个能明白吗？第二，而类中定义的属性(就是所谓的变量),是要在对象实例化之后才会存在的，这个明白吗？？好的，因为上面的第二条的原因，你的静态方法不知道你的对象究竟实例化没有，所以静态方法不知道你这个变量存不存在。这个懂吗？？既然，都不知道变量存不存在，那么你怎么可以随便使用呢？？明白了吗？没明白接着提问哈。。。我尽量帮忙

用_static修饰的变量叫静态变量，可以通过 对象 和 类名 访问

在知乎中找到了答案，希望对你有帮助网页链接

不是的，静态方法中的变量是局部变量。如果在Java中，加载类时，局部变量不会被初始化。

静态变量是从属于类的，在java虚拟机加载的时候就会在内存中加载这个变量，可以用类直接调用。而普通的变量是从属于对象的，只有用对象来使用

static 静态方法里 定义的就是静态的变量，只不过作用域只在方法内。 你可以定义一个全局的静态变量。在这个方法中使用。 就可以达到你的计数增长的目的。

我的天啊，你知道这么多名词应该学过编程吧要么百度一下，不就又比较全面精确的解释算了，我复制几个吧变量分为局部与全局，局部变量又可称之为内部变量。由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用。全局变量既可以是某对象函数创建，也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。一个局部变量在被其它对象引用时，会是一个空值。但全局变量却不会出现这种情况成员变量是指定维度的成员变量，用于标识某个维度成员语言无关的通用定义：与程序有着相同生命周期（英语：Object lifetime）的变量；C族语言特有的定义：以static存储类声明的变量。

在面向对象的语言，如java、c#……中，类变量就是static修饰的变量。

建议你看看这个http://hi.baidu.com/anglecloudy/blog/item/c2b27045c5721020cefca33d.html

静态变量静态方法可以全局使用，可以通过类名.方法名/类名.属性名直接调用

静态变量……就是一个当Main()函数运行便已经存在于内存中的一个变量，这个变量可以被读取被修改，但只会直到程序结束而释放。静态函数……静态函数？好吧……静态函数也是当Main()函数运行之前便已经编译好存在于内存中，之后在其他函数里可以调用。C#里面好像规定动态函数只允许调用静态函数，反之不可。这就是牵扯一个声明顺序的问题了……

static静态方法里定义的就是静态的变量，只不过作用域只在方法内。你可以定义一个全局的静态变量。在这个方法中使用。就可以达到你的计数增长的目的。

静态变量是指在整个程序运行期间，该变量都在内存中存在，不会被释放，这样造成的结果是该变量原来的值被保存。动态变量是指该变量在生存期仅仅在过程被调用、执行的时间范围，一旦过程调用结束，该变量即从内存中释放，第二次重新调用这个过程时，动态变量又重新创建。这样造成的结果是:过程调用时不能利用该变量上一次过程调用的结果值。

面向对象中，状态是绑定到实例的，就好像没有一个人的话是没办法给它取名的。而 static 在面向对象术语中就是“没有状态”的意思，所以 static 跟对象实例没有关联，只跟类有关联，因此从一个 static 方法中不能在没有对象实例的情况下访问它的非 static 方法或非 static 变量，因为 static 表示“还没有初始化状态”。状态对应到编程实践中，就是类的实例成员变量。

静态变量只赋一次值，赋值以后不能做修改，动态就是常用的那种，我不懂你这种语言，但是据我看，你这两种定义是没有区别的，还都是动态的

静态变量： 用关键字static修饰的成员变量称作静态变量或类变量；实例变量：没有使用static修饰的成员变量称作实例变量静态变量是与类相关联的数据变量，类变量不仅可以通过某个对象访问也可以直接通过类名访问。 实例变量仅仅是和相应的对象关联的变量，改变其中一个对象的实例变量不会影响其它对象的这个实例变量。实例变量必须通过对象访问。

静态变量可以将静态变量理解为类变量（与对象无关），而实例变量则属于一个特定的对象。静态变量有两种情况：静态变量是基本数据类型，这种情况下在类的外部不必创建该类的实例就可以直接使用静态变量是一个引用。这种情况比较特殊，主要问题是由于静态变量是一个对象的引用，那么必须初始化这个对象之后才能将引用指向它。因此如果要把一个引用定义成static的，就必须在定义的时候就对其对象进行初始化。静态方法与类变量不同，方法（静态方法与实例方法）在内存中只有一份，无论该类有多少个实例，都共用一个方法。静态方法与实例方法的不同主要有：静态方法可以直接使用，而实例方法必须在类实例化之后通过对象来调用。在外部调用静态方法时，可以使用“类名.方法名”或者“对象名.方法名”的形式。实例方法只能使用后面这种方式。静态方法只允许访问静态成员。而实例方法中可以访问静态成员和实例成员。静态方法中不能使用this（因为this是与实例相关的）。

定义一个静态变量static int id = 0;然后在构造方法里写上person(){id++;}这样就行了

用 static 修饰符声明的字段称为静态变量，在类里的静态变量可以不用初始化类直接访问，类似于类的属性.

static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。 被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。 用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。 static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

顾名思义，静态变量就是这个变量在内存中的地址是不会变的。动态变量则是动态分配的。

一个是公用的 一个是私有的 public 其他类或方法可以调用private只能在本类中使用

静态方法：类似于静态变量，静态方法也属于类，不属于实例的。静态类只能访问类的静态变量，或调用类的静态方法。通常静态方法作为工具方法，被其它类使用，而不需要创建类的实例。譬如集合类、Wrapper类(String, Integer等)和工具类(java.util中的类)都有很多静态方法。通常java程序的开始就是一个main()方法，它就是个静态方法。

当在某函数里定义一个静态变量后，这个变量不会即使函数退出了，在下次调用这个函数时，它会使用前次被调用后留下的值。此外，虽然该变量不随函数的退出而继续存在，但函数的外部并不能使用它。

在C++中(以及其他一些语言，如 C#，Java 等面向对象的语言中)类的成员变量被声明为static（称为静态成员变量），意味着它为该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，其修改值为该类的其它所有实例所见。 比如在某个类A中声明一个static int number;初始化为0。这个number就能被所有A的实例共用。在A的构造函数里加上number++，在A的析构函数里加上number--。那么每生成一个A的实例，number就加一，每销毁一个A的实例，number就减一，这样，number就可以记录程序中共生成了多少个A的实例。 这只是静态成员的一种用法而已。常量(constant） 也称常数，是一种恒定的或不可变的数值或数据项。 它们可以是不随时间变化的某些量和信息，也可以是表示某一数值的字符或字符串，常被用来标识、测量和比较。

静态变量可以将静态变量理解为类变量（与对象无关），而实例变量则属于一个特定的对象。静态变量有两种情况：静态变量是基本数据类型，这种情况下在类的外部不必创建该类的实例就可以直接使用静态变量是一个引用。这种情况比较特殊，主要问题是由于静态变量是一个对象的引用，那么必须初始化这个对象之后才能将引用指向它。因此如果要把一个引用定义成static的，就必须在定义的时候就对其对象进行初始化。静态方法与类变量不同，方法（静态方法与实例方法）在内存中只有一份，无论该类有多少个实例，都共用一个方法。静态方法与实例方法的不同主要有：静态方法可以直接使用，而实例方法必须在类实例化之后通过对象来调用。在外部调用静态方法时，可以使用“类名.方法名”或者“对象名.方法名”的形式。实例方法只能使用后面这种方式。静态方法只允许访问静态成员。而实例方法中可以访问静态成员和实例成员。静态方法中不能使用this（因为this是与实例相关的）。

说通俗点，你可以这样想，类其实就是一个模板，而对象就是由这个模板拷贝出来的。在由类创建对象时，就是把类中的所有非静态变量都拷贝给了创建的对象，这些非静态变量都存储在所创建对象的内存空间中，但在这个过程中静态变量是不会拷贝给对象的。明白了吧，也就是说用类创建对象时，所有的变量都拷贝一份给了对象，但只有静态变量是不会拷贝给对象的，它是存储在类的空间中，所有对象可以用它，但用的是同一个静态变量，这个静态变量只在类的空间中保存了一份。至于为什么只初始化一次，那是因为静态变量只在类的空间中保存了一份，它是属于类的，当你第一次加载类的时候，静态变量就会随着一起加载，再往后即便你创建对象了，由于创建时根本就没把静态变量拷贝给对象，当然这个变量也就只初始化一次了。其实只要你能明白静态变量和类的关系，这些问题就没什么好说的。看在我打了这么多字的份上，也该给俺分了吧，嘿嘿！

静态变量可以将静态变量理解为类变量（与对象无关），而实例变量则属于一个特定的对象。静态变量有两种情况：静态变量是基本数据类型，这种情况下在类的外部不必创建该类的实例就可以直接使用静态变量是一个引用。这种情况比较特殊，主要问题是由于静态变量是一个对象的引用，那么必须初始化这个对象之后才能将引用指向它。因此如果要把一个引用定义成static的，就必须在定义的时候就对其对象进行初始化。静态方法与类变量不同，方法（静态方法与实例方法）在内存中只有一份，无论该类有多少个实例，都共用一个方法。静态方法与实例方法的不同主要有：静态方法可以直接使用，而实例方法必须在类实例化之后通过对象来调用。在外部调用静态方法时，可以使用“类名.方法名”或者“对象名.方法名”的形式。实例方法只能使用后面这种方式。静态方法只允许访问静态成员。而实例方法中可以访问静态成员和实例成员。静态方法中不能使用this（因为this是与实例相关的）。

静态变量就是用了static的，啥类型都可以

linux 系统下的static变量Copyright 1999-2020, CSDN.NET, All Rights Reserved 登录linux 系统下的static变量 转载2018-09-01稻花香的思念-2018 码龄2年关注1. static 变量　　静态变量的类型 说明符是static。 静态变量当然是属于静态存储方式，但是属于静态存储方式的量不一定就是静态变量。 例如外部变量虽属于静态 存储方式，但不一定是静态变量，必须由static加以定义后才能成为静态外部变量，或称静态全局变量。　2. 静态局部变量　　静态局部变量属于静态存储方式，它具有以下特点：　　(1)静态局部变量在函数内定义 它的生存期为整个源程序，但是其作用域仍与自动变量相同，只能在定义该变量的函数内使用该变量。退出该函数后， 尽管该变量还继续存在，但不能使用它。　　(2)允许对构造类静态局部量赋初值 例如数组，若未赋以初值，则由系统自动赋以0值。　　(3)对基本类型的静态局部变量若在说明时未赋以初值，则系统自动赋予0值。而对自动变量不赋初值，则其值是不定的。 根据静态局部变量的特点， 可以 看出它是一种生存期为整个源程序的量。虽然离开定义它的函数后不能使用，但如再次调用定义它的函数时，它又可继续使用， 而且保存了前次被调用后留下的 值。 因此，当多次调用一个函数且要求在调用之间保留某些变量的值时，可考虑采用静态局部变量。虽然用全局变量也可以达到上述目的，但全局变量有时会造成 意外的副作用，因此仍以采用局部静态变量为宜。　3.静态全局变量　　全局变量(外部变量)的说明之前再冠以static 就构 成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局 变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在 定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用， 因此 可以避免在其它源文件中引起错误。从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量 后是改变了它的作用域， 限制了它的使用范围。因此static 这个说明符在不同的地方所起的作用是不同的。提示:　　A.若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度；　　B.若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度；　　C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题； D.如果我们需要一个可重入的函数，那么，我们一定要避免函数中使用static变量(这样的函数被称为：带“内部存储器”功能的的函数) E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。变量可以分为：全局变量、静态全局变量、静态局部变量和局部变量按存储区域分，全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域，局部变量存放在内存的栈区。按作用域分，全局变量在整个工程文件内都有效；静态全局变量只在定义它的文件内有效；静态局部变量只在定义它的函数内有效，只是程序仅分配一次内存，函数返回后，该变量不会消失；局部变量在定义它的函数内有效，但是函数返回后失效。全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。

答：在程序开发时，我们经常希望一个变量和方法不随对象的改变而改变，甚至在没有创建对象时也能访问数据和方法，这时就可以在数据和方法上加上Static关键字，被Static修饰的数据就叫做静态变量（数据）而方法就叫静态方法。静态变量在内存中的地址是相同的，所以对于同一类的不同对象，它们静态变量的值肯定是相同的。

可以在过程中使用 Static 语句来声明在过程调用之间仍能保持其值的变量的数据类型。例如，下面的语句声明了一个定长的整型数组：Static EmployeeNumber(200) As Integer下面的语句为 worksheet 的新实例声明了一个变量：Static X As New Worksheet如果在定义对象变量时没有使用 New 关键字，则在使用该变量之前，必须使用 Set 语句将一个已有的对象赋给这个引用对象的变量。在被赋值之前，所声明的这个对象变量有一个特定值 Nothing，这个值表示该变量没有指向任何对象的实例。若在声明中使用了 New 关键字，则在第一次引用对象时将新建一个该对象的实例。如果不指定数据类型或对象类型，且在模块中没有使用 Deftype 语句，则按缺省情况，定义该变量为 Variant 类型。注意 Static 语句与 Static 关键字很相似，但是针对不同的效果来使用的。如果使用 Static 关键字（如 Static Sub CountSales ()）来声明一个过程，则该过程中的所有局部变量的存储空间都只分配一次，且这些变量的值在整个程序运行期间都存在。对非静态过程而言，该过程每次被调用时都要为其变量分配存储空间，当该过程结束时都要释放其变量的存储空间。Static 语句则用来在非静态的过程中声明特定的变量，以使其在程序运行期间能保持其值。在初始化变量时，数值变量被初始化为 0，变长的字符串被初始化为一个零长度的字符串 ("")，而定长的字符串则用 0 填充。Variant 变量被初始化为 Empty。用户自定义类型的变量的每个元素作为各自独立的变量进行初始化。注意 如果在过程中使用 Static 语句，应和其它的声明语句（如 Dim）一样将其放在过程的开始

ok

静态变量在函数调用结束后，它的值不会丢失，下次调用函数时，静态变量的值不会初始化，而是从上次函数结束时的值开始

非静态变量：此变量在其所在子程序开始被执行前自动分配存储空间并初始化，在所在子程序执行完毕后自动释放所分配的存储空间。也就是说，变量的存储空间仅在其所在子程序执行过程中存在；静态变量：此变量与全局、程序集变量一样，被分配给在程序运行期间永久存在的存储空间并仅在应用程序启动运行前被初始化一次。

简单点来说，就是这个变量是只属于类的，是所有实现了这个类的对象所共用的变量。

打开静态变量表，新建一个说明行。在名称栏里，填上要新建的结构变量名称，数据类型中选择 Struct, 这时左边的静态变量表中会出现一个刚才自己新建的结构变量。单击这个变量就可以在右边填写这个结构变量下的其他变量了.

c#并不支持c/c++中的静态局部变量，所以你在那个位置添加static是语法错误的。c#中的static只能用于类型和成员。

说实话，没什么用处，那不是OO的东西，会影响程序的结构

静态变量和动态变量的区别是什么?你能用生活中的实例来类比一下吗静态变量比动态变量多出一个关键字static,比如,动态变量为int i,静态变量则是static int i。

局部静态变量具有文件作用域，全局变量（公用变量）具有全局作用域文件作用域：从局部静态变量的定义处开始，一直到变量所在的文件结束都是存在的

静态变量是从你使用到这个类开始一直到程序结束实例变量是在这个变量的作用域存在，比方函数里面的局部实例变量，在函数返回时就不存在了

1、静态变量：线程非安全。静态变量即类变量，位于方法区，为所有对象共享，共享一份内存，一旦静态变量被修改，其他对象均对修改可见，故线程非安全。2、实例变量：单例模式（只有一个对象实例存在）线程非安全，非单例线程安全。实例变量为对象实例私有，在虚拟机的堆中分配，若在系统中只存在一个此对象的实例，在多线程环境下，“犹如”静态变量那样，被某个线程修改后，其他线程对修改均可见，故线程非安全；如果每个线程执行都是在不同的对象中，那对象与对象之间的实例变量的修改将互不影响，故线程安全。3、局部变量：线程安全。每个线程执行时将会把局部变量放在各自栈帧的工作内存中，线程间不共享，故不存在线程安全问题。静态方法是线程安全的

实例变量要new后，才能调用静态的就不用，可以直接调用。就是说实例变量一开始是不存在的，要new后，系统才给它分配内存，这时才能访问而静态变量是系统一开始就为它分配了内存，自然可以不用new，就可以访问了。

（静态变量又称类变量，静态方法又称类方法）。 静态变量和实例变量的区别？ 1、静态变量用static 关键字修饰，实例变量不需要。 2、静态变量，属于类所有，只要程序加载了，静态变量就会被分配空间，就可以直接使用。 实例变量是对象的属性，只有实例化对象之后，才会被分配空间，才能使用。（即需要new一个才能使用） 3、类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果； 而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象； 例子： public class StaticClass { static int i=5;//静态变量 int j=5;//实例变量 public static void main(String[] args) { System.out.println(StaticClass.i);//可以直接引用 i StaticClass sc=new StaticClass();//必须实例化之后，才能引用 j System.out.println(sc.j); } }

静态变量属于类，不用实例化就已经存在，所有的实例共享同一个静态变量，可以通过类名和实例名来访问。实例变量属于实例，每个实例都有自己的这个变量，只能通过实例名来访问。

不可以吧~

i:0,1,2,3,4,5,6,7,8,9j:0,1,2,3,4,5,6,7,8,9

可以，但是如果没有初始化，则静态变量的内存在编译时会自动清零。

是指程序执行完后这里“程序执行完后”是指你这个程序的进程，也就是main函数的整个运行周期。如果你的硬件系统掉电了，程序自然也没法运行了。

错误！第一，对于动态存储方式，在函数调用开始时分配动态存储空间，函数结束时释放这些空间，例如传值的函数调用，int x=3,y=4; fun(x,y)//函数里x=4,y=3 ;函数调用结束后释放，main函数仍然是x=3,y=4第二，在静态存储区内分配的存储单元，在程序整个运行期间都不释放,若非必要，尽量不要静态变量int main(){ int f(int);int a=2,i;for(i=0;i<3;i++)printf("%d ",f(a));return 0;}int f(int a){ auto int b=0;//自动局部变量static c =3;//静态局部变量b=b+1;c=c+1;return(a+b+c);}输出为 7(2+1+4) 8(2+1+5) 9(2+1+6)

如果 static int m=0；是某函数中的局部变量，那么这个变量只被初始化赋值为0一次，当这个函数被多次调用时，除第一次被调用时 m 的内容被初始化为0外，以后每次调用时，m 都会在上一次函数被调用时产生结果的基础上继续运行的。例如 第一次调用 m被初始化为0， 函数运行结束时 m 的内容为 5， 第二次调用 m的内容就是5，并在次基础上继续运行程序。如果m是在某函数内部定义的局部变量，则m只在该函数内部有效m如果是全局变量，就会在定义语句之后的所有函数内有效。

在主文件中添加对另一个C文件的引用就可以访问它的静态变量了。

静态变量也是变量，其值是按需要可由代码变更的，只是静态变量的生命周期和全局变量一样长，所以它的本次操作值可保留到下次当初值使用。静态变量的在声明时可以初始化，也“可以不初始化”，“不初始化”时编译器会自动初始化为0。还有，静态变量只有在本文件可见，其他文件中即是用extern也不行……

这个问题应该从变量生存期讨论。 一般自动变量的生存期会随着函数调用的结束而结束。而静态变量函数调用结束时仍然存在，直到整个程序运行结束时才结束。 具体的内容和实例可以仔细看一下书上的详细讲解。

楼上几位分析都有道理，但实际中千万别出现这样的代码。C语言对指针的有效性几乎没有什么检查，全靠程序员自己负责。严格说来，这样的程序是有危险的，访问了不该访问的内存。

还会被删吗？不删我就回答