static的作用static的作用

static静态方法和变量的作用和好处??

一般静态变量都是公用的、全局的，程序一启动就会在内存开辟一块空间，存放它们。

静态的不必实例化就能直接使用，是说在没有生成任何对象时就能运用该方法，所以静态方法里不能对非静态的成员变量做操作。

一般静态方法操作静态成员变量或全局变量。

关键字static的作用是什么?

在Java语言中，static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。

被static修饰的成员变量和成员方法独立于该类的任何对象。

也就是说，它不依赖类特定的实例，被类的所有实例共享。

只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。

因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量。

static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用），但是不能在其他类中通过类名来直接引用，这一点很重要。

实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。

static前面加上其它访问权限关键字的效果也以此类推。

static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为： 类名.静态方法名(参数列表...) 类名.静态变量名 用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大）。

static在Java语言中的使用有四种：(变量、方法、代码块、内部类) 1、static变量 按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类 变量；另一种是没有被static修饰的变量，叫实例变量。

两者的区别是： 对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过 程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。

对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

2、静态方法 静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。

因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！ 因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

3、static代码块 static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

例如： // -- Java code example :) public class Test5 { private static int a; private int b; static { Test5.a = 3 ; System.out.println(a); Test5 t = new Test5(); t.f(); t.b = 1000 ; System.out.println(t.b); } static { Test5.a = 4 ; System.out.println(a); } public static void main(String[] args) { // TODO 自动生成方法存根 } // -- static代码块的位置可以随便放置！ static { Test5.a = 5 ; System.out.println(a); } public void f(){ System.out.println( " hhahhahah " ); } } 运行结果： 3 hhahhahah 1000 4 5 利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。

4. 静态内部类（Inner Class） 为正确理解static在应用于内部类时的含义，必须记住内部类的对象默认持有创建它的那个封装类的一个对象的句柄。

然而，假如我们说一个内部类是static的，这种说法却是不成立的。

static内部类意味着： (1) 为创建一个static内部类的对象，我们不需要一个外部类对象。

(2) 不能从static内部类的一个对象中访问一个外部类对象。

但在存在一些限制：由于static成员只能位于一个类的外部级别，所以内部类不可拥有static数据或static内部类。

倘若为了创建内部类的对象而不需要创建外部类的一个对象，那么可将所有东西都设为static。

为了能正常工作，同时也必须将内部类设为static。

如下所示： //: Parcel10.Java // Static inner classes package c07.parcel10; abstract class Contents { abstract public int value(); } interface Destination { String readLabel(); } public class Parcel10 { private static class PContents extends Contents { private int i = 11; public int value() { return i; } } protected static class PDestination implements Destination { private String label; private PDestination(String whereTo) { label = whereTo; } public String readLabel() { return label; } } public static Destination dest(String s) { return new PDestination(s); } public static Contents cont() { return new PContents(); } public static void main(String[] args) { Contents c = cont(); Destination d = dest("Tanzania"); } } ///:~ 在main()中，我们不需要Parcel10的对象；相反，我们用常规的语法来选择一个static成员，以便调用将句柄返回Contents和Destination的方法。

通常，我们不在一个接口里设置任何代码，但static内部类可以成为接口的一部分。

由于类是“静态”的，所以它不会违反接口的规则——static内部类只位于接口的命名空间内部： //: IInterface.java// Static inner classes inside interfaces interface IInterface { static class Inner { int i, j, k; public Inner() {} void f() {} } } ///:~ 建议大家在每个类里都设置一个main()，将其作为那个类的测试床使用。

但这样做的一个缺点就是额外代码的数量太多。

若不愿如此，可考虑用一个static内部类容纳自己的测试代码。

如下所示： //: TestBed.java// Putting test code in a static inner class class TestBed { TestBed() {} void f() { System.out.println("f()"); } public static class Tester { public static void main(String[] args) { TestBed t = new TestBed(); t.f(); } } } ///:~ 这样便生成一个独立的、名为TestBed$Tester的类（为运行程序，请使用“java TestBed$Tester”命令）。

可将这个类用于测试，但不需在自己的最终发行版本中包含它。

PS: 静态内部类--代码示例 Java中我们经常会使用到内部类（inner classes），如果没有Static的内部类，它的instance的创建是依赖于其元类的。

这样的关系似乎比较难表达，让我们直接看下面的代码： 1: public class Outer { 2: int var; 3 4: void outerHoge() { 5: System.out.println("hogehoge"); 6: } 7: 8: void outerHote2() { 9: 10: Inner i = new Inner(); 11: staticHoge sh = new StaticHoge(); 12: 13: 17: // Inner i2 = new this.Inner(); 18: } 19: 20: 21: class Inner { 22: void innerHoge() { 23: 26: var = 1; 27: outerHoge(); 28: } 29: } 30: 31: static class StaticHoge() { 32: void methodHoge() { 33: 36: // var = 10; 37: // outerHoge(); 38: // Inner inner = new Inner(); 39: } 40: } 41: } static的内部类的使用，我们可以像Package一样用它： 1: public class Outer2 { 2: public static class StaticHoge1 { 3: //... 4: } 5: public static class StaticHoge2 { 6: //... 7: } 8: } 可以像下面这样使用： 1: Outer2.StaticHoge1 sh1 = new Outer2.StaticHoge1(); 2: Outer2.StaticHoge2 sh2 = new Outer2.StaticHoge2();

c语言中static 到底有啥作用啊？

声明成static跟声明在函数体外面是差不多的（当然可见性上是不同的） 如果你是看那句里面的等号不顺眼， 这是因为， c里等号的意义是分两种情况的，一种是在表达式里， 而另一种是在变量声明中。

在变量声明中的等号不可以看作是赋值， 它只是初始化，也就是说它的意义只是告诉编译器如何初始化这个内存空间。

所以虽然这句写在这里，但是多次运行这个函数的时候并不会进行多次的赋值. 而下面的 +=这里面就是赋值的意思了，每次都会运行的。

简单的说， 对声明语句要特殊看待。

静态static的功能

C、C++还是C#? C++的static有两种用法：面向过程程序设计中的static和面向对象程序设计中的static。

前者应用于普通变量和函数，不涉及类；后者主要说明static在类中的作用。

一、面向过程设计中的static 1、静态全局变量 在全局变量前，加上关键字static，该变量就被定义成为一个静态全局变量。

我们先举一个静态全局变量的例子，如下： //Example 1#include <iostream.h>void fn();static int n; //定义静态全局变量void main(){ n=20; cout<<n<<endl; fn();}void fn(){ n++; cout<<n<<endl;} 静态全局变量有以下特点： 该变量在全局数据区分配内存； 未经初始化的静态全局变量会被程序自动初始化为0（自动变量的值是随机的，除非它被显式初始化）； 静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的； 静态变量都在全局数据区分配内存，包括后面将要提到的静态局部变量。

对于一个完整的程序，在内存中的分布情况如下图： 代码区 全局数据区 堆区 栈区 一般程序的由new产生的动态数据存放在堆区，函数内部的自动变量存放在栈区。

自动变量一般会随着函数的退出而释放空间，静态数据（即使是函数内部的静 态局部变量）也存放在全局数据区。

全局数据区的数据并不会因为函数的退出而释放空间。

细心的读者可能会发现，Example 1中的代码中将 static int n; //定义静态全局变量 改为 int n; //定义全局变量 程序照样正常运行。

的确，定义全局变量就可以实现变量在文件中的共享，但定义静态全局变量还有以下好处： 静态全局变量不能被其它文件所用； 其它文件中可以定义相同名字的变量，不会发生冲突； 您可以将上述示例代码改为如下： //Example 2//File1#include <iostream.h>void fn();static int n; //定义静态全局变量void main(){ n=20; cout<<n<<endl; fn();}//File2#include <iostream.h>extern int n;void fn(){ n++; cout<<n<<endl;} 编译并运行Example 2，您就会发现上述代码可以分别通过编译，但运行时出现错误。

试着将 static int n; //定义静态全局变量 改为 int n; //定义全局变量 再次编译运行程序，细心体会全局变量和静态全局变量的区别。

2、静态局部变量 在局部变量前，加上关键字static，该变量就被定义成为一个静态局部变量。

我们先举一个静态局部变量的例子，如下： //Example 3#include <iostream.h>void fn();void main(){ fn(); fn(); fn();}void fn(){ static n=10; cout<<n<<endl; n++;} 通常，在函数体内定义了一个变量，每当程序运行到该语句时都会给该局部变量分配栈内存。

但随着程序退出函数体，系统就会收回栈内存，局部变量也相应失效。

但有时候我们需要在两次调用之间对变量的值进行保存。

通常的想法是定义一个全局变量来实现。

但这样一来，变量已经不再属于函数本身了，不再仅受函数的控制，给程序的维护带来不便。

静态局部变量正好可以解决这个问题。

静态局部变量保存在全局数据区，而不是保存在栈中，每次的值保持到下一次调用，直到下次赋新值。

静态局部变量有以下特点： 该变量在全局数据区分配内存； 静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化； 静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0； 它始终驻留在全局数据区，直到程序运行结束。

但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束； 3、静态函数 在函数的返回类型前加上static关键字,函数即被定义为静态函数。

静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。

静态函数的例子： //Example 4#include <iostream.h>static void fn();//声明静态函数void main(){ fn();}void fn()//定义静态函数{ int n=10; cout<<n<<endl;} 定义静态函数的好处： 静态函数不能被其它文件所用； 其它文件中可以定义相同名字的函数，不会发生冲突； 二、面向对象的static关键字（类中的static关键字） 1、静态数据成员 在类内数据成员的声明前加上关键字static，该数据成员就是类内的静态数据成员。

先举一个静态数据成员的例子。

//Example 5#include <iostream.h>class Myclass{public: Myclass(int a,int b,int c); void GetSum();private: int a,b,c; static int Sum;//声明静态数据成员};int Myclass::Sum=0;//定义并初始化静态数据成员Myclass::Myclass(int a,int b,int c){ this->a=a; this->b=b; this->c=c; Sum+=a+b+c;}void Myclass::GetSum(){ cout<<"Sum="<<Sum<<endl;}void main(){ Myclass M(1,2,3); M.GetSum(); Myclass N(4,5,6); N.GetSum(); M.GetSum();} 可以看出，静态数据成员有以下特点： 对于非静态数据成员，每个类对象都有自己的拷贝。

而静态数据成员被当作是类的成员。

无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷 贝，由该类型的所有对象共享访问。

也就是说，静态数据成员是该类的所有对象所共有的。

对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共 用。

所以，静态数据成员的值对每个对象都是一样的，它的值可以更新； 静态数据成员存储在全局数据区。

静态数据成员定义时要分配空间，所以不能在类声明中定义。

在Example 5中，语句int Myclass::Sum=0;是定义静态数据成员； 静态数据成员和普通数据成员一样遵从public,protected,private访问规则； 因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以，它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它； 静态数据成员初始化与一般数据成员初始化不同。

静态数据成员初始化的格式为： ＜数据类型＞＜类名＞::＜静态数据成员名＞=＜值＞ 类的静态数据成员有两种访问形式： ＜类对象名＞.＜静态数据成员名＞ 或 ＜类类型名＞::＜静态数据成员名＞ 如果静态数据成员的访问权限允许的话（即public的成员），可在程序中，按上述格式来引用静态数据成员 ； 静态数据成员主要用在各个对象都有相同的某项属性的时候。

比如对于一个存款类，每个实例的利息都是相同的。

所以，应该把利息设为存款类的静态数据成员。

这 有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局数据区的内存，所以节省存储空间。

第二，一旦利息需要改变时，只要改变一次， 则所有存款类对象的利息全改变过来了； 同全局变量相比，使用静态数据成员有两个优势： 静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其它全局名字冲突的可能性； 可以实现信息隐藏。

静态数据成员可以是private成员，而全局变量不能； 2、静态成员函数 与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。

静态成员函数与静态数据成员一样，都是类的内部 实现，属于类定义的一部分。

普通的成员函数一般都隐含了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。

通常情况下，this 是缺省的。

如函数fn()实际上是this->fn()。

但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指 针。

从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。

下面举个静态成员函数的例子。

//Example 6#include <iostream.h>class Myclass{public: Myclass(int a,int b,int c); static void GetSum();/声明静态成员函数private: int a,b,c; static int Sum;//声明静态数据成员};int Myclass::Sum=0;//定义并初始化静态数据成员Myclass::Myclass(int a,int b,int c){ this->a=a; this->b=b; this->c=c; Sum+=a+b+c; //非静态成员函数可以访问静态数据成员}void Myclass::GetSum() //静态成员函数的实现{// cout<<a<<endl; //错误代码，a是非静态数据成员 cout<<"Sum="<<Sum<<endl;}void main(){ Myclass M(1,2,3); M.GetSum(); Myclass N(4,5,6); N.GetSum(); Myclass::GetSum();} 关于静态成员函数，可以总结为以下几点： 出现在类体外的函数定义不能指定关键字static； 静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数； 非静态成员函数可以任意地访问静态成员函数和静态数据成员； 静态成员函数不能访问非静态成员函数和非静态数据成员； 由于没有this指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长； 调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数，也可以直接使用如下格式： ＜类名＞::＜静态成员函数名＞（＜参数表＞） 调用类的静态成员函数。

C语言static的作用。

题中，i为静态局部变量，在fun1函数中，i声明的同时初始化，初值为0，以后再调用函数，i不再重新初始化，连续调用10次函数，i依次累加，最后结果为10； j为静态全局变量，在声明的同时你没有赋值，j的值在调用函数时，被重新赋值，不会累加，你可以把j=0；写到上面static int j=0；再看看效果

static的作用

声明静态变量的,静态变量只能被初始化一次,如果不初始化的话编译器自动将其设置为0,静态变量分为全局静态变量和局部静态变量2 种,前者在整个程序中可见,后者在特定函数或语句中可见