1、對類和物件的初步認識

什么是類？什么是物件？
簡單的來說：
類：相當于一個模板，用來描述和包含一類物件的行為和屬性，一個類，可以產生無數的物件，
物件：就是類的一個實體是由模板產生的樣本，有行為和屬性，比如說一個人是一個物件，他的行為有吃飯、睡覺，打豆豆，而他的屬性有姓名、年齡，性別，

JAVA是基于面向物件的，關注的是物件，將一件事情拆分成不同的物件，靠物件之間的互動完成，
在我們開發時我們要：找物件，建物件，用物件，并維護物件之間的關系，這也是我們學習的重點，
簡而言之
面向物件就是用代碼(類)來描述客觀世界的事物的一種方式. 一個類主要包含一個事物的屬性和行為，

2、類和類的實體化

宣告一個類就是創建一個新的資料型別，而類在 Java 中屬于參考型別， Java 使用關鍵字 class 來宣告類，
基本語法

// 創建類
class <class_name>{
    field;//成員屬性
    method;//成員方法
}
// 實體化物件
<class_name> <物件名> = new <class_name>();

class，用來定義一個類，class_name表示類的名字，類名的書寫格式為大駝峰，在類里面包含了欄位（屬性，成員變數），也包含了方法（行為），
示例

class Person {
   public int age;//成員屬性 實體變數
   public String name;
   public String sex;
   public void eat() {//成員方法
      System.out.println("吃飯!");
   }
   public void sleep() {
      System.out.println("睡覺!");
   }
}

用型別別創建物件的程序，稱為類的實體化

class Person{
    public String name;//成員變數
    public int age;
    public String sex;
    public void eat(){//成員方法
        System.out.println("吃飯");
    }
    public void sleep(){
        System.out.println("睡覺");
    }
}
public class text {
    public static void main(String[] args) {
         Person person=new Person();//通過new實體化物件
         person.eat();//通過物件的參考來訪問普通的成員變數
         person.sleep();
         //產生物件 實體化物件
         Person person1=new Person();
         Person person2=new Person();
    }
}

輸出結果為

吃飯
睡覺

3、類的成員

普通成員變數和方法

類中的成員包括成員變數（欄位，屬性）和成員方法（行為），

class Person{
    public String name;//成員變數
    public int age;
    public String sex;
    public void eat(){//成員方法
        System.out.println("吃飯");
    }
    public void sleep(){
        System.out.println("睡覺");
    }
}

注意：如果未賦初值，列印的結果就是變數型別的默認值，例如：

class Person{
    public String name;//
    public int age;
    public String sex;
}
public class text {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);  //結果為null
        System.out.println(person.age);   //結果為0
    }

靜態成員變數和方法

普通成員變數通過static關鍵字的修飾變為靜態成員變數，
成員變數被static所修飾，存放在方法區中，所有類共享，且不屬于物件，
訪問方式為：類名.屬性
示例：

class TextDemo{
    public int a;
    public static int count;
}
public class text {
    public static void main(String[] args) {
      TextDemo t1=new TextDemo();
      t1.a++;
      TextDemo.count++;                    //結果
      System.out.println(t1.a);            // 1
      System.out.println(TextDemo.count);  // 1

      TextDemo t2=new TextDemo();
      t2.a++;
      TextDemo.count++;
      System.out.println(t1.a);            // 1
      System.out.println(TextDemo.count);  // 2
    }
}

同理，方法也可以被static修飾

public static void eat(){
        System.out.println("吃飯");
    }

在定義時注意以下幾點：

1. 普通的方法里不能定義靜態的成員變數
2. 普通的方法里可以定義靜態的方法
3. 靜態的方法里不能定義普通的成員變數
4. 靜態的方法中不能定義普通的方法

因為static定義的變數是類變數，是屬于類的，
方法的呼叫需要對應的參考，而static的定義可以使類不需要參考直接呼叫，這就出現了沖突，
拓展：

1.null在java中表示“空參考”，表示不參考任何物件，相當于C語言中的空指標，

Person person=null;

2.表示person2這個參考指向 person1 這個參考所指向的物件，相當于指向同一個物件，

Person person1=new Person();
Person person2=person1;

3.一個參考不可以指向多個物件，

4.參考不一定在堆疊上，如圖示：

class Person{
    public int age;
    public String name;
}
class Text {
    Person person =new Person();
    public static void main(String[] args) {
      Text text=new Text();
    }
}

4、封裝

private/ public 這兩個關鍵字表示 “訪問權限控制” .

• 被 public 修飾的成員變數或者成員方法, 可以直接被類的呼叫者使用，
• 被 private 修飾的成員變數或者成員方法,不能被類的呼叫者使用，

當我們使用 private 來修飾欄位的時候, 就無法直接使用這個欄位了，
此時如果需要獲取或者修改這個 private 屬性, 就需要使用 getter / setter 方法

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;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class text {
    public static void main(String[] args) {
        Person person =new Person();
        person.setAge(12);
        person.setName("345");
        person.getAge();
        person.getName();
        System.out.println(person);
    }
}

結果為Person{name='345', age=12}

this.代表當前物件的參考，

5、構造方法

基本語法

構造方法:是一種特殊方法, 使用關鍵字new實體化新物件時會被自動呼叫, 用于完成初始化操作（用來構造物件），
構造的程序為：

• 為物件分配記憶體空間
• 呼叫合適的構方法

語法規則：

1. 方法名與類名相同
2. 構造方法沒有回傳值型別宣告
3. 每一個類中一定至少存在一個構造方法（沒有明確定義，則系統自動生成一個無參構造）

注意事項：

1. 如果沒有實作任何的構造方法，編譯器會幫我們默認生成一個不帶引數的構造方法，也就是說一個類至少會有一個構造方法，即使我們沒有寫，
2. 如果當前類有其他的構造方法，那么編譯器就不會幫我們生成不帶引數的構造方法，
3. 構造方法之間可以構成多載，

class Person{
    public String name;
    public int age;
    public Person(){   //如果沒有寫不帶引數的構造方法，編譯器會默認生成一個，這里是寫了
        System.out.println("不帶引數的構造方法");
    }
    public Person(String name){   //構造帶一個String型別引數的構造方法
        this.name=name;
        System.out.println("帶一個引數的構造方法");
    }
    public Person(String name,int age){   //構造帶一個String型別和一個int型別引數的構造方法
        this.name=name;
        this.age=age;
        System.out.println("帶兩個引數的構造方法");
    }
}
public class text {
    public static void main(String[] args) {
        Person person =new Person();  //這里其實就是在呼叫不帶引數的構造方法
        Person person1=new Person("123");
        Person person2=new Person("123",456);
    }
}

this關鍵字

this有三種用法：

 - this.data             呼叫當前物件的屬性
 - this.func()           呼叫當前物件的方法
 - this()                呼叫當前物件的其他構造方法

this()呼叫當前物件的其他構造方法如下所示：

注意：
this()必須放在第一行，并且只能放在構造方法中，

6、代碼塊

代碼塊分為本地代碼塊、實體代碼塊、靜態代碼塊，同步代碼塊，
在這里我們學習的重點是實體和靜態代碼塊，

class Person{
    public String name;
    public int age;
    {
        System.out.println("實體代碼塊"); //實體代碼塊
    }

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

呼叫的結果是

靜態代碼塊
實體代碼塊
Person()不帶引數的構造方法
實體代碼塊
Person()不帶引數的構造方法

class Person{
    public String name;
    public int age;
    static int count;
    {
        System.out.println("實體代碼塊"); //這個就是實體代碼塊
    }

    static{
        System.out.println("靜態代碼塊"); //靜態代碼塊
    }
    public Person(){
        System.out.println("Person()不帶引數的構造方法");
    }
}
public class text {
    public static void main(String[] args) {
        System.out.println(Person.count);
    }
}

結果是：

靜態代碼塊
0

根據上述代碼，可以發現靜態代碼塊只會被執行一次而且是最先執行的（在類加載的時候就執行），并且靜態代碼塊不用實體化物件也會被執行，

若果都是靜態的前提下，靜態代碼塊與靜態變數的執行順序要看代碼定義的順序（當變數未被初識話的情況下例外），

class Person{
    public String name;
    public int age;
    public static int count=10;
    static{
        count=99;
    }
}
public class text {
    public static void main(String[] args) {
        System.out.println(Person.count);  // 結果為99
    }
}

7、匿名物件

匿名只是表示沒有名字的物件

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

class Person{
    public String name;
    public int age;
    public void eat(){
        System.out.println("吃飯");
    }
    public void sleep(){
        System.out.println("睡覺");
    }
}
public class text {
    public static void main(String[] args) {
        new Person().eat();
        new Person().sleep();
        Person person1=new Person();
        person1.eat();
        person1.sleep();
    }
}

根據代碼可以看出區別，匿名物件相當于一個一次性的物件，