在Java中，关于static关键字

static静态

   可以修饰属性，方法，语句块，（类，暂时不管）

   通过类名访问静态属性和方法

   类名.静态属性

   类名.静态方法

   静态数据被所有对象共享。

   静态数据只初始化一次。

   静态数据在它所在的类的字节码文件被载入到JVM时初始化。

   如下图所示：

代码示例如下：

/********************************静态的属性或方法************************
/*
 * static:静态的，可以用来修饰属性，方法，代码块，内部类
 * 1.当static修饰属性时
 * (1)由类创建的所有对象都共用这一属性；
 * （2）类变量随着类的加载而加载，类变量的加载要早于对象；（类变量就是static修饰的属性，实例变量就是非static修饰的属性）
 * (3)类变量可以通过“类.类变量”来调用；当然也可以通过“对象.类变量”
 * （4）类变量存在静态域中；
 * 
 * 2.当static修饰方法(类方法)
 * （1）随着类的加载而加载，在类中仅有一份，与类变量的特点类似，也可以通过“类.类方法”来调用；
 * （2）静态方法内部可以调用静态的属性或方法，而不能调用非静态的属性或方法；
 * （3）非静态的方法里边可以调用静态的属性或方法，当然也可以调用非静态的属性或方法；
 * （4）静态的方法内是不可以有this或super的；因为this或super表示的是对象，而在对象未创建时，静态的方法就已经存在；
 * 
 * 注：静态的结构（属性，方法，代码块，内部类）的生命周期要早于非静态的结构，同时，被回收也要晚于非静态的
 */
package com;

public class TestStatic {
    public static void main(String[] args) {
        chinese.nation = "China";
        System.out.println(chinese.nation);

        chinese man = new chinese();
        System.out.println(man.nation);
        chinese.info();
    }

}

class chinese{
    protected String name;
    protected int age;
    protected static String nation;

    public chinese() {
        super();
    }


    public chinese(String name, int age) {
        super();
        this.name = name;
        this.age = age;
}


    @Override
    public String toString() {
        return "chinese [name=" + name + ", age=" + age + "]";
    }

    public static void info(){
        //System.out.println("name: " + name); 调用非静态的就会报错
        //System.out.println("this: " + this);调用this会报错；因为在对象未创建时，静态的方法就已经存在；
        System.out.println("nation: " + nation);
    }

}

注： 本例其实可以概括成一句话：静态方法只能访问静态成员，实例方法可以访问静态和实例成员。之所以不允许静态方法访问实例成员变量，是因为实例成员变量是属于某个对象的，而静态方法在执行时，并不一定存在对象。同样，因为实例方法可以访问实例成员变量，如果允许静态方法调用实例方法，将间接地允许它使用实例成员变量，所以它也不能调用实例方法。基于同样的道理，静态方法中也不能使用关键字this。

main()方法是一个典型的静态方法，它同样遵循一般静态方法的规则，所以它可以由系统在创建对象之前就调用。

*********************************静态的属性或方法***********************/

Static初始化块：

 代码块分为静态代码块和非静态代码块
其代码示例如下：

/*
 * 类的第四个成员：代码块
 * 代码块若要被修饰符修饰的话，也只能用static，当然也可以不用，具体看自己的需求；
 * 
 * 非静态代码块：
 * 1.在代码块内，可以初始化类的属性(静态或非静态)，当然也可以调用类的方法(静态或非静态)，
*但一般用来初始化类的属性(静态或非静态)，同时也允许输出语句；
 * 2.若属性没有显示初始化，也就是默认初始化，那么其最先被执行；
 * 2.若属性显示初始化，那么代码块的执行的优先级和属性的优先级相同，主要看起代码分布的位置，位置考前的先执行，
 *具体见“ 关于属性（包括静态和非静态）赋值操作执行的顺序”
 * 3.代码块或属性的优先级高于构造器，也就是说构造器后执行；无论构造器在前还是在后，代码块或属性都将先执行；
 * 4.每创建一个对象，代码块都会执行一次；
 * 
 * 静态代码块：
 * 1.在代码块内，可以初始化类的静态的属性，当然也可以调用类的静态的方法，但一般用来初始化类的静态的属性，同时也允许输出语句；
 * 2.静态代码块只创建一次；
 * 3.一个类可以有多个静态代码块，多个静态代码块之间按顺序执行；静态代码块的执行顺序早于非静态代码块；
 * 4.静态代码块和显示初始化的静态属性是按顺序执行；若静态属性没有显示初始化，也就是默认初始化，那么其是最先被初始化的，
 *具体见“ 关于属性（包括静态和非静态）赋值操作执行的顺序”
 * 
 * 关于属性（包括静态和非静态）赋值操作执行的顺序:1.默认的初始化 2.显示的初始化或代码块的初始化（此时两结构按顺序执行） 
*3.构造器中  4.通过方法对对象的属性进行修改
 */
package com;
public class TestOrder {

/**
* @param args
*/
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Order1 o1 = new Order1();
        System.out.println(o1.toString());

        Order1 o2 = new Order1();
        System.out.println(o2.toString());
    }


}

class Order1{

    //private String orderName;

    Order1(){
        System.out.println("i'm a constructor without paragram");
    }

    {                                         //非静态代码块1
        orderId = 101;
        orderName = "smith";
        System.out.println("我是一个非静态的代码块1");
    }


    static{                                   //静态代码块2
        System.out.println("我是一个静态的代码块2");
        Description = "Order1";
        show2();
    }

    static String Description = "Order3";

    static{                                   //静态代码块1
        System.out.println("我是一个静态的代码块1");
        Description = "Order2";
        show2();
    }


    String orderName = "jack";

    {                                        //非静态代码块2
        orderName = "william";
        System.out.println("我是一个非静态的代码块2");
        show1();
        show2();
    }

    int orderId;

    @Override
    public String toString() {
        return "Order1 [orderId= " + orderId + ", orderName= " + orderName + ",Description = " + Description + "]";
    }

    public void show1(){

    }

    public static void show2(){

    }

}

其运行结果如下：

我是一个静态的代码块2
我是一个静态的代码块1
我是一个非静态的代码块1
我是一个非静态的代码块2
i'm a constructor without paragram
Order1 [orderId= 101, orderName= william,Description = Order2]
我是一个非静态的代码块1
我是一个非静态的代码块2
i'm a constructor without paragram
Order1 [orderId= 101, orderName= william,Description = Order2]

关于静态方法不能调用非静态方法的理解：

代码示例如下：

package com.example.staticTest;

/**
 * Created by Will Smith on 2016/5/29.
 */
public class Dog {

    /***
     *注意：main()方法也是一个静态方法
     * ***/
    public static void main(String[] strings){
        /***
         * 直接在同一个类的静态方法中调用另一个非静态方法就会报错，
         * 故在此予以将其注释掉了...
         * 其不能调用的原因在于：
         * 静态方法的创建跟随着类的创建而创建的，早于对象的创建，
         * 而eat()方法是需要通过对象来进行调用执行的，所以在对象
         * 未创建之前，我们不能直接调用非静态方法
         * ***/
        //eat();
        /***
         * 在同一个类中，静态方法是可以直接调用其静态方法的，
         * 所以这里这样写也就不会报错了
         * **/
        sleep();

        /***
         * 这里能够调用的原因在于，eat()方法是通过对象来调用的，
         * 而此时的对象dog已创建出来，所以也就可以进行调用
         * ***/
        Dog dog = new Dog();
        dog.eat();
    }

    public void eat(){
        System.out.println("Dog is eating");
    }

    public static void sleep(){
        System.out.println("Dog is sleeping");
    }

}

运行结果如下：