static修饰的变量是静态变量。
当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。
静态变量与静态方法类似。
所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了

class Value
{
        static int c = 0;

        static void inc()
                {
                        c++;
                }
}

public class Count2
        {
                public static void prt(String s)
                        {
                                System.out.print(s);
                        }

                public static void main(String[] args)
                        {
                                Value v1, v2;
                                v1 = new Value();
                                v2 = new Value();
                                prt("v1.c=" + v1.c + " v2.c=" + v2.c);
                                v1.inc();
                                prt(" v1.c=" + v1.c + " v2.c=" + v2.c);
                        }
        }


结果为：v1.c=0 v2.c=0 v1.c=1 v2.c=1
由此可以证明它们共享一块存储区。


接下来我们看看静态变量的初始化问题。
如果你需要通过计算来初始化你的static变量，你可以声明一个static块，
Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，
一些static变量，以及一个static 初始化块：
class Value3
{
        static int c = 0;

        Value3()
                {
                        c = 15;
                }

        Value3(int i)
                {
                        c = i;
                }

        static void inc()
                {
                        c++;
                }
}

public class Count
        {
                public static void prt(String s)
                        {
                                System.out.println(s);
                        }

                Value3 v = new Value3(10);
                static Value3 v1, v2;
                static        //此即为static块
                        {
                                prt("v1.c=" + v1.c + " v2.c=" + v2.c);
                                v1 = new Value3(27);
                                prt("v1.c=" + v1.c + " v2.c=" + v2.c);
                                v2 = new Value3(15);
                                prt("v1.c=" + v1.c + " v2.c=" + v2.c);
                        }

                public static void main(String[] args)
                        {
                                Count ct = new Count();
                                prt("ct.c=" + ct.v.c);
                                prt("v1.c=" + v1.c + " v2.c=" + v2.c);
                                v1.inc();
                                prt("v1.c=" + v1.c + " v2.c=" + v2.c);
                                prt("ct.c=" + ct.v.c);
                        }
        }

结果为：
v1.c=0 v2.c=0
v1.c=27 v2.c=27
v1.c=15 v2.c=15
ct.c=10
v1.c=10 v2.c=10
v1.c=11 v2.c=11
ct.c=11

第二个例子展示了静态初始化的各种特性。
有人会对static后加大括号感到困惑。
首先要告诉你的是，static定义的变量会优先于任何其它非static变量，就如毕老师所说，类一旦加载，它就近来了。正如在程序中所表现的，虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面。
在static{后面跟着一段代码｝这是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。
在涉及到继承的时候，会先初始化父类的static变量，然后是子类的，依次类推。

给分晚了   总结的不错

太详细了