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;
    }
}