Java中的static关键字

static可以用来修饰属性、方法、代码块、内部类。

static修饰成员变量

static修饰的成员变量（属性）也被称为静态变量：

• 多个对象共享同一个静态变量，当通过某个对象修改静态变量时，会导致其他对象调用此静态变量是修改过的。
• 静态变量随着类的加载而加载，可以通过 类.静态变量 的方式进行调用。
• 静态变量要早于对象的创建。
• 由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法区的静态域中。

Student类：

public class Student {
    private String name;
    private int age;
    static String room; //所在教室

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 //省略getter、setter
}

测试如下：

public class Demo01StaticField {
    public static void main(String[] args) {
        Student s1 = new Student("tom", 20);
        s1.room = "101教室";
        System.out.println(s1.room); //101教室
        Student s2 = new Student("jerry", 18);
        System.out.println(s2.room); //101教室
    }
}

static修饰方法

使用static修饰的方法称为静态方法：

• 静态方法随着类的加载而加载，可以通过 类.静态方法 的方式进行调用。
• 静态方法中只能调用静态的方法或属性，非静态方法既可以调用非静态的方法或属性也可以调用静态的方法和属性。

class StaticTest {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        //对于静态方法来说，可以通过对象名进行调用，也可以通过类名来调用
        MyClass.methodStatic();
    }
}

public class MyClass {
    int num; //成员变量
    static int numStatic; //静态变量

    //成员方法
    public void method() {
        System.out.println("这是一个普通的成员方法");
        System.out.println(num);
        System.out.println(numStatic);
    }

    //静态方法
    public static void methodStatic() {
        System.out.println("这是一个静态方法");
        System.out.println(numStatic);
        //静态不能直接访问非静态
//        System.out.println(num);

    }

static修饰代码块

代码块的作用：用来初始化类、对象，只能使用static修饰。

静态代码块的格式：

static {
    //静态代码块中的内容
}

• 当第一次使用到本类时，静态代码块执行唯一的一次。
• 静态内容总是优先于非静态，所以静态代码块比构造方法先执行。
• 如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行。

public class Person {
    static {
        System.out.println("静态代码块执行了");
    }

    public Person(){
        System.out.println("构造方法执行！");
    }
}

class TestStatic{
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
    }
}

输出内容如下：

静态代码块执行了
构造方法执行！
构造方法执行！

单例模式

某个类只能存在一个对象实例。

饿汉式：

public class SingletonTest1 {
    public static void main(String[] args) {
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        System.out.println(bank1 == bank2);
    }
}

//饿汉式
class Bank {
    //1.私有化类的构造器
    private Bank() {

    }

    //2.创建内部类的对象
    private static Bank instance = new Bank();

    //3.提供公共的静态方法，返回类的对象
    public static Bank getInstance() {
        return instance;
    }
}

懒汉式：

public class SingletonTest2 {
    public static void main(String[] args) {
        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();
        System.out.println(order1 == order2);
    }
}

class Order {
    //1.私有化类的构造器
    private Order() {
    }

    //2.声明当前类的对象
    private static Order instance = null;

    //声明static的方法返回当前类的对象
    public static Order getInstance() {
        if (instance == null) {
            instance = new Order();
        }
        return instance;
    }
}