什么是類、物件？

因為計算機并不能像我們人這樣去理解世界上的東西，所以為了更好的編輯，就抽象出了類和物件，類就是把功能放在一起，然后由一個人去呼叫這個功能，然后再編輯對應的功能，呼叫者就是物件的實作者

類和類的實體化

類是一類物件的統稱，物件就是這一類具體化的實體
創建類的關鍵字：class

舉例：我們坐年糕的模子就是一個類，而通過這個模子可以做出月餅，在這個例子當中，類就是模具，年糕就是實體化的物件，一個類可以實體化很多物件，舉例：

class Person {
    public String name;
    public int age;
}
public static void main1(String[] args) {
    Person person1 = new Person();
    Person person2 = new Person();
    Person person3 = null;
}

Person 就是一個類，里面的 name 和 int 就是類的成員（欄位），這里的 person1 就是參考，指向的是后面 new 的物件，因為是參考，所以也可以指向 null ，person3 就是指向空（null）參考，person1 person2 person3 就是實體化的物件，

欄位的初始化

欄位就是類里面的成員，在創建這些成員的時候就可以初始化，例如：

class Person {
    public String name = "Lockey";
    public int age = 10;
}

這里就是創建的時候對其進行初始化，其實并不建議直接初始化，建議在類的呼叫者使用的時候再初始化，如下：

class Person {
    public String name;
    public int age;
}
public static void main(String[] args) {
    Person person1 = new Person();
    person1.name = "Lockey";
    person1.age = 10;
    System.out.println(person1.name);
    System.out.println(person1.age);
}

這里就是在類的呼叫者里面對類的欄位進行賦值，在 main 方法當中通過參考呼叫，

類當中實作方法

就像上面的例子，如果類的呼叫者需要名字和年齡的時候，輸出兩行比較麻煩，類的實作者就可以在類內寫一個方法，直接回傳名字和年齡，示例：

class Person {
    public String name;
    public int age;
    public void print() {
        System.out.println("姓名："+name+" 年齡："+age);
    }
}
public static void main(String[] args) {
    Person person1 = new Person();
    person1.name = "Lockey";
    person1.age = 10;
    person1.print();
}

static 靜態關鍵字

static 可以修飾方法，屬性，要注意的是：static 修飾的變數通過類名訪問，直接舉例說明：

class Person {
    public int a;
    public static int count;
}
public static void main(String[] args) {
    Person person1 = new Person();
    person1.a++;
    person1.count++;
    System.out.println(person1.a);
    System.out.println(Person.count);
    Person person2 = new Person();
    person2.a++;
    person2.count++;
    System.out.println(person2.a);
    System.out.println(person2.count);
}

如圖，count 第二次輸出為 2 ，這是因為 conut 是被 static 修飾的變數，被 static 修飾之后就變成了常量，就在靜態區了，所以每個參考當中呼叫的 count 沒變，所以第二次改變 count 的值的時候，就變成 2 了，當 static 修飾方法的時候，無需再創建物件，直接拿類名呼叫就行了，舉例：

class Person {
    public static int count;
    public static void change() {
        count = 100;
    }
}
public static void main(String[] args) {
    Person.change();
    System.out.println(Person.count);
}

通過類名的呼叫直接訪問 static 修飾的變數，

封裝

因為代碼實作的軟體很復雜，所以就出現了類，但是為了閱讀性更高，就出現了封裝，就是把一個類的內容實作為只剩一個或幾個介面，方便類的呼叫者訪問，這樣就降低了代碼的復雜程度，

private 實作封裝

private 就是修飾成員變數或方法的關鍵字，被 private 修飾之后，就不能被類外的呼叫者訪問了，所以就可以配合 public 來實作對外的介面，例如：

class Person {
    private String name = "Lockey";
    private int age = 10;
    public void print() {
        System.out.println("名字是："+name+" 年齡："+age);
    }
}
public static void main(String[] args) {
    Person person = new Person();
    person.print();
}

這里就是利用 private 封裝屬性，使其只能在類內被訪問到，而提供的 public 介面，就讓類的呼叫者在類外就可以訪問到了，所以在類外直接呼叫 print 方法就好了，

setter 和 getter 方法

當我們把欄位（name age）設定為 private 屬性時，就無法在類外進行初始化了，所以就又出現了新的方法：

setter ：在類外直接呼叫此方法，然后設定一個值，

有了 setter 就又有了 getter 方法，getter 就是獲取欄位數的值，通過類外呼叫，將欄位設定為此值，代碼示例：

class Person {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name1) {
        name = name1;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age1) {
        age = age1;
    }
    public void print() {
        System.out.println("名字是："+name+" 年齡："+age);
    }
}
public static void main(String[] args) {
    Person person = new Person();
    person.setName("Lockey");
    person.getName();
    person.setAge(10);
    person.getAge();
    person.print();
}

這里就是呼叫 getter 和 setter 方法，在類外進行訪問，因為 private 對 name 和 age 做了封裝，

構造方法

方法名和類名是相同的，且構造方法沒有回傳值，呼叫完構造方法之后，物件才會產生，

一個物件的產生：
1 為物件分配記憶體，
2 呼叫合適的構造方法，

class Person {
    public Person() {
        System.out.println("Person 不帶引數的構造方法");
    }
}
public static void main(String[] args) {
    Person person = new Person();
}

這里就是實體化類的物件的時候呼叫的構造方法，因為我們自己寫了構造方法，所以這里就呼叫我i們寫過的，就輸出了如圖所示的內容，需要注意的是：如果沒有實作如何的構造方法，編譯器會幫我們默認生成有個不帶引數的構造方法，也就是說，一個類，至少會有一個構造方法，

除了上面這種構造方法，我們還能寫帶有引數的構造方法，例如：

class Person {
    private String name;
    public Person(String name1) {
        name = name1;
        System.out.println("Person(String) 帶一個引數的構造方法");
    }
}
public static void main(String[] args) {
    Person person = new Person("Lockey");
}

如圖：在類初始化的時候，傳入參數 “Lockey” 在類實體化的時候就是呼叫有引數的構造方法，既然能傳引數，那是否可以傳多個引數呢？答案是可以的，例如：

class Person {
    private String name;
    private int age;
    public Person(String name1, int age1) {
        name = name1;
        age = age1;
        System.out.println("Person(String, int) 帶兩個引數的構造方法");
    }
}
public static void main(String[] args) {
    Person person = new Person("Lockey",10);
}

如圖，呼叫的就是傳了兩個引數的構造方法，通過觀察上面的例子，我們可以發現：構造方法也是支持多載的，

this 關鍵字

在類當中，this 表示當前物件的參考（不是當前物件），可以通過 this 來訪問類當中的欄位和方法，用 this 的話，會降低出現 bug 的概率，并且增加代碼的可讀性，例如使用 getter 和 setter 的時候，就可以用 this ，能多用 this 就多用 this ，

class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

匿名物件

匿名物件就是沒有名字的物件，

沒有參考的物件稱為匿名物件.
匿名物件只能在創建物件時使用.
如果一個物件只是用一次, 后面不需要用了, 可以考慮使用匿名物件.

代碼示例：

class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void print() {
        System.out.println("名字是："+name+" 年齡："+age);
    }
}
public static void main(String[] args) {
    new Person("Lockey",10).print();
}

匿名物件的缺點就是只能呼叫一次，