静态方法

　　通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法。如下所示：

class Simple{
   static void go(){
     System.out.println("Go...");
   }
}
public class Cal{
  public static void main(String[] args){
    Simple.go();
  }
}

　　调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。

静态变量

　　静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了。看下面这段代码：

class Value{
  static int c=0;
  static void inc(){
    c++;
  }
}
class Count{
  public static void prt(String s){
    System.out.println(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变量有点类似于C中的全局变量的概念。值得探讨的是静态变量的初始化问题。我们修改上面的程序：

class Value{
  static int c=0;
  Value(){
    c=15;
  }
  Value(int i){
    c=i;
  }
  static void inc(){
    c++;
  }
}
class Count{
  public static void prt(String s){
    System.out.println(s);
  }
    Value v=new Value(10);
    static Value v1,v2;
    static{
      prt("v1.c="+v1.c+"  v2.c="+v2.c);
      v1=new Value(27);
      prt("v1.c="+v1.c+"  v2.c="+v2.c);
      v2=new Value(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变量，不论其出现的顺序如何。正如在程序中所表现的，虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面。在static{后面跟着一段代码，这是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。如果你能读懂并理解这段代码，会帮助你对static关键字的认识。在涉及到继承的时候，会先初始化父类的static变量，然后是子类的，依次类推。可以参考Think in Java中的讲解。

静态类

　　通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。如下代码所示：

public class StaticCls{
  public static void main(String[] args){
    OuterCls.InnerCls oi=new OuterCls.InnerCls();
  }
}
class OuterCls{
  public static class InnerCls{
    InnerCls(){
      System.out.println("InnerCls");
    }
   }
}

　　输出结果：

InnerCls

INT I 是INSTANT FIELDS，不知道是不是叫对象属性。
STATIC INT I 是CLASS FIELDS，类属性,也叫静态属性。
有STATIC的属性，可以直接被类调用。
public class Box{
   int long;  //箱子长度
   static int G= 9.8;//重力加速度

}

类属性指这个属性属于这个类，而不是具体的类的对象。任何类或者类的对象调用类属性，都指向这唯一的定义。
但是对于long，每创建一个Box box1 = new Box();就会分配一个空间给long.这个long属于box1.
Box box2 = new Box();里就新分配一个空间给box2 的 long.
其他的类调用时，可以是 box1.long和 box2.long和  box1.G和  box2.G和Box.G

这里的G都是指同一个，但是long 就是2个完全独立和不同的属性。

顶

静态字段：每个类中只存在一个静态字段
静态方法：是不向对象施加操作的方法，如Math类的pow方法，是一个静态方法:Math.pow(x,y)
可以把静态方法看成是没有this参数的方法
我们在以下2中情况使用静态方法：
1。该方法不需要访问对象状态，其所需要的参数要通过显示参数提供
2。该方法只需要访问类的静态字段

太高深了．．．．．．
通俗点讲，我自己的理解呀，当然我也是菜鸟，刚学ＪＡＶＡ．
我觉得，像Ｃ里面的结构，其实就是一种自定义的类型本质和int,double....并无太大差别（笼统的讲）．到Ｃ++　　　类已经不是这样了，有了更多的内涵．再到ＪＡＶＡ全是类．还真不习惯．
不过，它们的老祖宗是一样的（千万别骂，我也菜）．也是一种类型．当然了，有更多的功能，也有更多的内涵．
一个类型被申明时，编译程序不会做实质性的工作．只有一种非动态的，静态的东西被实实在在的申明时，编译程序将会在内存里插入标签，并为之分配一块区域．因为这个东西已经被实实在在的执行，它不在是对象的属性了．它只有是这个类本身的属性．
同理，类本身也可是动态的，也可以是静态的．道理一样．
方法也一样．
int i 
只说明你一个愿望，一个想法．当i被赋值时，他才在内存中，按你的所想的int 申请空间就存储．
static int i
在你申请的时候，已经为之分配空间，并且不用赋值（至少c++里是这样），其实已经赋过了，或是自己赋的，或是语言默认的．
正如在编写一些递归的程序中，你如果想用int i来计算递归的层数时，几乎不可能，它是层数动态分配的，当然了，也可以一层一层的传回来．
而用　static int i 就可以，因为，从开始到最后它都占据在申明时所分配的空间里面．它是静态的．

以上，有什么不对，只管批评．我真的很菜．谢谢了．

不同意zhouqi724(猛男) 的说法，一个类中可以有多个静态字段，类的静态字段在初始化过程中仅次于类包的调用过程，静态字段以及静态方法的调用都在静态存储区，而与实例化的对象中普通字段有所不同，因为类的所有静态字段都处于静态存储区，所以静态字段相对于类来说是独一无二的，也只需要实例化一次，也只能实例化一次，每次对其调用影响整个类。因此很容易想象的是静态方法中不能使用this指针，也不能使用非静态的方法，因为它属于整个类，不属于某个对象，而且它的调用地点不在普通对象的地点。

简单的说加了static是类变量  这样的话 static类型的变量就是所有实例共享的了  比方说 有个类中一个static型变量num用来记录类被实例化的次数  每次实例化 num自加1 如果你是用int的话 每次实例化int都会变成初始状态  没办法达到要求 而用static就可以办到