c/c++ static 功能（包括在类里的使用）

平时使用

int   i;

时，其实是删除auto，auto是自动变量，即，在调用函数时，系统会给这些变量分配存储空间，函数调用结束就自动释放这些存储空间（栈区）。

static int i;

表示静态变量。

1.在函数内使用，函数调用完也可保留其值。初始化赋值操作只执行一次。

2.函数外使用，可使全局变量的作用范围限制在本文件中。即此变量对其他文件透明，不能被extern（外部变量声明）扩展。可有效防止文件间起了重名。

3.函数定义时使用

static   int   i() {return 0；}

同2，使该函数只能作用于本文件，对其他文件透明。

4.类里数据使用

class i
{
	private:
		static int x;
}；
int i::x;

需在类外部加上 int i::x 说明,否则无法编译。同一个类的所有对象共享改变量。一般用于统计。

完整程序：

#include<iostream>
using namespace std;
 
class i
{	
	public:
		static int x;
		void putx(int a) { x=a;}
		int getx() { return x;}
};
int i::x=4;

int main()
{     
	i a,b;
	a.putx(2);
	cout<<"x:  "<<a.getx()<<"  "<<b.getx()<<endl;
	b.putx(4);
	cout<<"x:  "<<a.getx()<<"  "<<b.getx()<<endl;
}

输出：
x: 2 2
x： 4 4

5.类里函数使用
静态的函数成员不能访问类中的非静态成员。换句话讲，他只能访问类里的静态成员（静态函数成员或静态数据成员）。
因为：
1）静态数据成员实际上是在类外定义的一个变量。他的生存期和整个程序的生存期一样，在付那个一对象之前，静态数据成员就已经存在。
2）静态函数成员和静态数据成员类似，在对象生成之前也已经存在。这就是说，在对象产生之前，静态的函数成员就能访问其他静态成员，从而可以给对象设置特殊的任务。

Java 中static用法
1.java中static不能作用于局部变量。

2.java中static不改变变量、方法的访问权限。即private的依然只有当前类可以使用。
pubilc static 可以直接通过sout（A.y） 使用
public的可以直接通过A a=new A（）； sout（a.y）；使用

3.在《Java编程思想》P86页有这样一段话：
　　“static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”
　　这段话虽然只是说明了static方法的特殊之处，但是可以看出static关键字的基本作用，简而言之，一句话来描述就是：
　　方便在没有创建对象的情况下来进行调用（方法/变量）。
　　很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

4.执行顺序
三个类
项目结构

package pa;

public class ss extends sta{
    public static int i=1;

    static {
        System.out.println("zi static+I:"+i);
    }

    public ss(){
        System.out.println("zi constract");
    }

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        System.out.println("main in");
        ss s = new ss();
        Class.forName("pa.tt").newInstance();
    }
}

package pa;

public class sta {
    public static int i=2;
    static{
        System.out.println("static father +I:"+i);
    }

    public sta(){
        System.out.println("constract father");
    }
}

package pa;

public class tt {
    public static int i=3;
    static {
        System.out.println("无关+I:"+i);
    }

    public tt() {
        System.out.println("constract wuguan");
    }
}

输出：

static father +I:2
zi static+I:1
main in
constract father
zi constract
无关+I:3
constract wuguan

结果分析
1）
使用main的时候先加载主类

父类静态代码块
子类静态代码块

主类代码执行

父类构造函数
子类构造函数

2）class.forname也会到达初始化这一步。。。