静态：static

用法：是一个修饰符；用于修饰成员（成员变量和成员函数）

当成员被静态修饰后，就多了一种调用方式，除了可以被对象调用外，还可以直接被类名调用格式：类名.静态成员

静态的特点：

1.随着类的加载而加载

也就是，说静态会随着类的消失而消失，说明静态的生命周期最长

2.优先于对象的存在

明确一点：静态是先存在的对象是后存在的

3.被所有对象共享

4.可以直接被类名调用

实例变量和类变量的区别

1.存放位置

类变量随着类的加载存在于方法区中，实例变量随着对象的对象的建立存在于堆内存里

2.生命周期

类变量生命周期最长，随着“类”的加载而加载，随着类的消失而消失

实例变量随着“对象”的消失而消失

静态的使用注意事项：

1.静态方法只能访问静态成员（包括成员变量和成员方法）

非静态方法可以访问静态也可以访问非静态

2.静态方法中不可以定义this，super关键字

因为静态优先于对象存在，所以静态方法中不可以出现this，super关键字

3.主函数是静态的。

静态的利弊

利：对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象中都存储一份，可以直接被类名所调用

弊：生命周期过长，访问出现局限性（只能访问静态）

java中用static修饰的类方法可以被其他类引用,而且不需创建对象,更加方便。

声明一个方法在前面加上public static是为了被其它包的类静态调用。

java为什么非静态内部类中不能有static修饰的属性，但却可以有final常量？

public class Demo{
     int x;
     class A{
         static int a = 0;   //这样写是不合法的.
         static final int b=0;   //这样写是合法的
     }
 }

java类加载顺序，首先加载类，执行static变量初始化，接下来执行对象的创建，如果我们要执行代码中的变量int a 初始化，那么必须先执行加载外部类，再加载内部类，最后初始化静态变量 a ,问题就出在加载内部类上面，我们可以把内部类看成外部类的非静态成员，它的初始化必须在外部类对象创建后以后进行，要加载内部类必须在实例化外部类之后完成 ，java虚拟机要求所有的静态变量必须在对象创建之前完成，这样便产生了矛盾。

而java常量放在内存中常量池，它的机制与变量是不同的，编译时，加载常量是不需要加载类的，所以就没有上面那种矛盾。

静态形式的执行顺序

一般顺序：静态块（静态变量）——>成员变量——>构造方法——>静态方法

1、静态代码块（只加载一次） 2、构造方法（创建一个实例就加载一次）3、静态方法需要调用才会执行

public class Print {

    public Print(String s) {
        System.out.print(s + " ");
    }
}

public class Parent {
    public static Print obj1 = new Print("1");
    public Print obj2 = new Print("2");
    public static Print obj3 = new Print("3");


    static {
        new Print("4");
    }

    public static Print obj4 = new Print("5");
    public Print obj5 = new Print("6");

    public Parent() {
        new Print("7");
    }
}

public class Child extends Parent {
    static {
        new Print("a");
    }

    public static Print obj1 = new Print("b");
    public Print obj2 = new Print("c");


    public Child() {
        new Print("d");
    }

    public static Print obj3 = new Print("e");

    public Print obj4 = new Print("f");

    public static void main(String[] args) {
        Parent obj1 = new Child();
        Parent obj2 = new Child();
    }
}

执行main方法，程序输出顺序为： 1 3 4 5 a b e 2 6 7 c f d 2 6 7 c f d

输出结果表明，程序的执行顺序为：

如果类还没有被加载：

1、先执行父类的静态代码块和静态变量初始化，并且静态代码块和静态变量的执行顺序只跟代码中出现的顺序有关。

2、执行子类的静态代码块和静态变量初始化。

3、执行父类的实例变量初始化

4、执行父类的构造函数

5、执行子类的实例变量初始化

6、执行子类的构造函数

如果类已经被加载：

则静态代码块和静态变量就不用重复执行，再创建类对象时，只执行与实例相关的变量初始化和构造方法。