- static修饰的成员字段：static修饰的成员字段也叫类字段或全局字段，在类被加载时static修饰的成员字段被初始化，与类关联，只要类存在，static字段就存在。一个static字段单独划分一块存储空间，不与具体的对象绑定在一起，该存储空间被类的各个对象所共享。也就是说当声明一个对象时，并不产生static字段的拷贝，而是该类所有的实例对象共用同一个static字段。static修饰的成员字段能在创建任何实例对象之前被访问，而不必引用任何对象，也就是说不管创建多少对象，static修饰的字段只占有一块内存。
class StaticTest
{
static int i=47;
}
Static :对于类的属性来说，对于不同的对象 StaticTest st1=new StaticTest();StaticTest st2=new StaticTest();都只有一个共享的存储空间。
- 引用Static字段有两种方法：可以用一个对象去定位它；也可以用其类名直接调用（最好通过类名，这样不至于让看程序的人感到疑惑）。如果一个成员被声明为static，它就能够在它的类的对象被创建之前被访问，不必引用任何对象。最常见的例子是main()方法，static定义的字段会优先于任何其它非static字段，不论其出现的顺序如何。
- Java字段在类这个级别分两种，类字段（static）和实例字段，而在静态的方法中不能够直接访问实例字段，实例字段需要初始化成一个类的实例后(对象）才可以用。静态的之所以有这种区分是为了区别对待类和对象的成员。如果某个字段或者方法被声明为static，意味着在类初始化时就必须分配内存空间。静态字段属于类，为该类所有对象所共享,在程序开始执行前就分配内存空间，如果前面加上final，功能类似全局常量,不可以修改其值，比如圆周率。静态方法中不能定义静态字段。
- Java语言可以使用static关键字修饰类的成员字段和成员方法。被static修饰的成员字段，成员方法一般被称为静态（或者全局）字段（static field），静态方法（static method）。有别于一般的字段和方法，静态字段，静态方法的作用域是类的所有对象。也就是说，当运行时，在程序空间中，类的所有对象访问到的静态字段都是同一个值，当其中一个对象改变了静态字段的值，其它对象都将受到影响。正因为这样，静态字段，静态方法可以（建议）通过类名.静态字段/类名.静态方法直接存取：1、对象.字段/方法：没有使用static修饰的成员字段、成员方法是作用于对象域的，通常被称作实例字段(instance field)，对象方法(instance method)。当某个对象被创建时，它们才真正地存在于内存空间之中，而且对象本身对它们的改变，不会影响到其它对象。就好像 Person的一个对象zhangsan，zhangsan的改变不会影响到其它Person对象一样。2、类.字段/方法：使用static修饰的成员字段、成员方法可以看作类的固有的，它作用于类的全体对象。当类的所有对象需要共享同一值时，可以使用static来定义。如：PI=3.1415926，这时可以使用static来定义PI字段。当然，通常这种不希望改变static字段的情况，一般使用static final来修饰。
- 如果需要通过计算来初始化的static字段，可以声明为一个static块，Static 块仅在该类被加载时执行一次。
- 声明为static的字段实质上就是全局字段。当声明一个对象时，并不产生static字段的拷贝，而是该类所有的实例字段共用同一个static字段。声明为static的方法有以下几条限制：
-
- 它们仅能调用其它的static 方法。
- 它们只能访问static数据。
- 它们不能以任何方式引用this或super
- 声明为static的字段在定义的地方被初始化，并且只能初始化一次。也就是说如果你在一个方法里定义了一个static字段，当你第二次调用该方法时，该字段不被再次初始化。
- 静态方法：不向对象施加操作的方法，静态方法可以看成是没有this参数的方法。既可以使用类名也可以通过对象来调用静态方法，建议使用类名。this是个隐式参数，代表被构造的对象。
- 例程：public class ExplicitStatic
{
public static void main(String[] args)
{
System.out.println("Inside main()");
Cups.c1.f(99);
}
static Cups x=new Cups();
static Cups y=new Cups();
}
class Cup
{
Cup(int marker)
{
System.out.println("Cup("+marker+")");
}
void f(int marker)
{
System.out.println("f("+marker+")");
}
}
class Cups{
static Cup c1=new Cup(11);
static Cup c2;
Cup c3=new Cup(33);
Cup c4;
{
c3=new Cup(3);
c4=new Cup(4);
}
static
{
c1=new Cup(1);
c2=new Cup(2);
}
Cups()
{
System.out.println("Cups()");
}
}
输出：
Cup(11)
Cup(1)
Cup(2)
Cup(33)
Cup(3)
Cup(4)
Cups()
Cup(33)
Cup(3)
Cup(4)
Cups()
Inside main()
f(99)
首先初始化的是static，顺序是代码顺序up-to-down，然后在是自己调用的方法。
上面的执行顺序是：
1：static Cups x=new Cups(); 转入 Cups对象
2：static Cup c1=new Cup(11); 转入 Cup对象
3：执行Cup的输出 Cup(11);
4：cups对象里的 static Cup c2；
5：static
{
c1=new Cup(1);转入Cup对象 输出 Cup(1)
c2=new Cup(2);转入Cup对象 输出 Cup(2)
}
6：cups对象里的 Cup c3=new Cup(33); 输出 Cup(33)
7：c3=new Cup(3); 输出 Cup(3)
c4=new Cup(4); 输出 Cup(4)
8：Cups()
{
System.out.println("Cups()"); 输出 Cups()
}
9：static Cups y=new Cups();
注意Cups里的static成员已经初始化 所以
static Cup c1=new Cup(11);
static Cup c2;
static{
c1=new Cup(1);
c2=new Cup(2);
}
不再执行！
下面的就和上面一样了！
