基本用法

static关键字修饰类

java里面用static修饰内部类，普通类是不允许声明为静态的，只有内部类才可以。

public class StaticTest {
    //static关键字修饰内部类
    public static class InnerClass{
        InnerClass(){
            System.out.println("============= 静态内部类=============");
        }
        public void InnerMethod() {
            System.out.println("============= 静态内部方法=============");
        }
    }
    public static void main(String[] args) {
        //直接通过StaticTest类名访问静态内部类InnerClass
        InnerClass inner=new StaticTest.InnerClass();
        //静态内部类可以和普通类一样使用
        inner.InnerMethod();
    }
}

如果没有用static修饰InterClass，则只能new 一个外部类实例。再通过外部实例创建内部类。

static关键字修饰方法

修饰方法的时候，其实跟类一样，可以直接通过类名来进行调用：

public class StaticMethod {
    public static void test() {
        System.out.println("============= 静态方法=============");
    };
    public static void main(String[] args) {
        //方式一：直接通过类名
        StaticMethod.test();
        //方式二：通过对象调用
        StaticMethod fdd=new StaticMethod();
        fdd.test();
    }
}

static关键字修饰变量

被static修饰的成员变量叫做静态变量，也叫做类变量，说明这个变量是属于这个类的，而不是属于是对象，没有被static修饰的成员变量叫做实例变量，说明这个变量是属于某个具体的对象的。

我们同样可以使用上面的方式进行调用变量：

public class StaticVar {
    private static String name="java技术栈";

    public static void main(String[] args) {
        //直接通过类名
        StaticVar.name;
    }
}

static关键字修饰代码块

静态代码块在类第一次被载入时执行，在这里主要是想验证一下，类初始化的顺序。

父类静态变量
父类静态代码块

子类静态变量
子类静态代码块

父类普通变量
父类普通代码块
父类构造函数

子类普通变量
子类普通代码块
子类构造函数
//首先我们定义一个父类
public class Father {
    // 父类静态变量
    public static String str1 = "father static str";
    // 父类普通变量
    public String str2 = "father common str";
    // 父类静态代码块
    static {
        System.out.println("father static block");
    }
    // 父类普通代码块
    {
        System.out.println("father common block");
    }
    // 父类构造方法
    public Father() {
        System.out.println("father constructor");
    }
}

//然后定义一个子类
public class Child extends Father {
    // 子类静态变量
    public static String str1 = "child static str";
    // 子类普通变量
    public String str2 = "child common str";
    // 子类静态代码块
    static {
        System.out.println("child static block");
    }
    // 子类普通代码块
    {
        System.out.println("child common block");
    }
    // 子类构造方法
    public Child() {
        System.out.println("child constructor");
    }
}

// 测试
public static void main(String[] args) {
        new Child();
}

输出为：

father static block
child static block
father common block
father constructor
child common block
child constructor

原理讲解

上图为jvm运行时数据区，静态变量存放在方法区中，并且是被所有线程所共享的。

方法区中包含的都是在整个程序中永远唯一的元素，如类信息、static变量等。

举例

定义一个类，包含静态变量、静态方法。

public class Person{
    //静态变量
    static String firstName;

    String lastName;

    public void showName(){
        System.out.println(firstName+lastName);
    }

    //静态方法
    public static void viewName(){
      System.out.println(firstName);
    }

    public static void main(String[] args) {
        Person p =new Person();
        Person.firstName = "张";
        p.lastName="三";
        p.showName();

        Person p2 =new Person();
        Person.firstName="李";
        p2.lastName="四";
        p2.showName();
    }
}
//输出。张三、李四

从内存的角度看一下：