一、面向物件
二、類和類的實體化
- 2.1類
- 2.2類的實體化
- 2.3類的成員
- - 2.3.1 欄位/屬性/成員變數
  - 認識 null
  - 2.3.2 方法 (method)
  - 2.3.3 static 關鍵字
  - - a.修飾屬性
    - b.修飾方法
    - c.代碼塊
    - d.修飾類
三、封裝
- 3.1 private實作封裝
- 3.2 getter和setter方法
四、構造方法
- this關鍵字
五、代碼塊
- 匿名物件
- toString方法

一、面向物件

面向物件（OOP）的程式是由物件組成的,每個物件包含對用戶公開的特定功能部分，程式中的很多物件來自標準庫，還有一些是自定義的，究竟是自己構造物件，還是從外界購買物件完全取決于開發專案的預算和時間，但是, 從根本上說，只要物件能夠滿足要求,就不必關心其功能的具體實作程序，在OOP中，不必關心物件的具體實作，只要能夠滿足用戶的需求即可，
面向物件注重的是物件，也就是參與程序所涉及到的主體，是通過邏輯將一個個功能實作連接起來，簡而言之面向物件就是用代碼(類)來描述客觀世界的事物的一種方式，一個類主要包含一個事物的屬性和行為，
【面向物件概念】：
1.面向物件是思考問題的一種思考方式，是一種思想，比如：概念與實體，理論與實踐，名和實等等，
2.類就是一類物件的統稱，物件就是這一類具體化的一個實體，
3.面向物件的好處：將復雜的事情變簡單了，只要面對一個物件就行，

二、類和類的實體化

2.1類

類就是一類物件的統稱，物件就是這一類具體化的一個實體，
簡單的例子：我們做月餅的模子就是一個類，而通過這個模子可以做出月餅，那么在這個例子當中，類就是那個模子，而月餅就是那個物件,所以月餅就是一個物體，一個模子可以實體化無數個物件，總的來說：類相當于一個模板，物件是由模板產生的樣本，一個類，可以產生無數的物件，宣告一個類就是創建一個新的資料型別，而類在 Java 中屬于參考型別， Java 使用關鍵字 class 來宣告類，
我們來看一下簡單的宣告一個類：

class Person{
    //欄位 屬性 成員變數 定義在類的內部，方法的外部
    //成員變數分為普通成員變數，靜態成員變數
    public String name;
    public int age;
    //成員方法
    //成員方法分為普通成員方法和靜態成員方法
    public void eat(){
        System.out.println(name +"正在吃飯");
    }
    public void sleep(){
        System.out.println(name +"正在睡覺");
    }
}

class為定義類的關鍵字， Person為類的名字，{}中為類的主體，
類中的元素稱為：成員屬性，類中的函式稱為：成員方法，

2.2類的實體化

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

類只是一個模型一樣的東西，限定了類有哪些成員.
一個類可以實體化出多個物件，實體化出的物件占用實際的物理空間，存盤類成員變數.
做個比方，類實體化出物件就像現實中使用建筑設計圖建造出房子，類就像是設計圖，只設計出需要什么東西，但是并沒有物體的建筑存在，同樣類也只是一個設計，實體化出的物件才能實際存盤資料，占用物理空間.

舉一個例子：

class Person{
    public String name;
    public int age;//成員屬性 實體變數
    //成員方法
    //成員方法分為普通成員方法和靜態成員方法
    public void eat(){ //成員方法
        System.out.println(name +"正在吃飯");
    }
    public void sleep(){ //成員方法
        System.out.println(name +"正在睡覺");
    }
}
public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();//通過new實體化物件
        person.name = "zhang";
        person.age = 10;
        System.out.println(person.name); //成員變數的訪問需要通過物件的參考來訪問
        person.eat();//通過物件的參考呼叫方法
        person.sleep();
        //產生物件          實體化物件
		Person person2 = new Person();//一個類可以實體化出多個物件
		Person person3 = new Person()
    }

總結：

new關鍵字用于創建一個物件的實體.
使用 . 來訪問物件中的屬性和方法.
同一個類可以實體化多個物件.

2.3類的成員

類的成員可以包含以下：欄位、方法、代碼塊、內部類和介面等，
首先來看一下欄位（成員變數）：

2.3.1 欄位/屬性/成員變數

在類中, 但是方法外部定義的變數. 這樣的變數我們稱為 “欄位” 或 “屬性” 或 “成員變數”，
對于一個物件的欄位如果沒有顯式設定初始值, 那么會被設定一個默認的初值，

默認值規則：

對于各種數字型別,默認值為0.
對于boolean型別,默認值為false.
對于參考型別(String, Array,以及自定制類),默認值為null.

很多時候我們不希望欄位使用默認值, 而是需要我們顯式設定初值, 可以這樣寫:

class Person {
	public String name = "張三";
	public int age = 18;
}

認識 null

null 在 Java 中為 “空參考”, 表示不參考任何物件. 類似于 C 語言中的空指標. 如果對 null 進行 . 操作就會引發例外.

 public static void main2(String[] args) {
        Person person = null;//代表這個參考不指向任何物件
        Person person1 = new Person();
        Person person3 = person1;//代表person3這個參考指向person1這個參考所指向的物件

        person1 = new Person(); //一個參考不可以同時指向多個物件
        person1 = new Person();
        person1 = new Person();
    }

2.3.2 方法 (method)

方法用于描述一個物件的行為，
如2.2例子中的eat方法和sleep方法，表示 Person 這個物件具有一個 “展示自我” 的行為.這樣的eat方法和sleep方法是和 person 實體相關聯的. 如果創建了其他實體, 那么eat方法和sleep方法的行為就會發生變化，

2.3.3 static 關鍵字

所有被static所修飾的方法或者屬性，全部不依賴于物件.

a.修飾屬性

Java靜態屬性和類相關, 和具體的實體無關. 換句話說, 同一個類的不同實體共用同一個靜態屬性.

class TestDemo{
	public int a;
	public static int count;
}
public class Main{
public static void main(String[] args) {
	TestDemo t1 = new TestDemo();
	t1.a++;
	TestDemo.count++;
	System.out.println(t1.a);
	System.out.println(TestDemo.count);
	System.out.println("============");
	TestDemo t2 = new TestDemo();
	t2.a++;
	TestDemo.count++;
	System.out.println(t2.a);
	System.out.println(TestDemo.count);
	}
}

輸出結果：

1 1
============
1 2

count被static所修飾，所有類共享，且不屬于物件，訪問方式為：類名 . 屬性

b.修飾方法

如果在任何方法上應用 static 關鍵字，此方法稱為靜態方法，

靜態方法屬于類，而不屬于類的物件，
可以直接呼叫靜態方法，而無需創建類的實體，
靜態方法可以訪問靜態資料成員，并可以更改靜態資料成員的值，
對于靜態成員變數直接通過類名訪問：類名.靜態的成員屬性/方法，

public static void staticFunc() {  
//在靜態方法內部不可以呼叫普通方法，靜態的方法不依賴于物件
        System.out.println("static::func()");
    }
    public void eat(){
        System.out.println(name + "正在吃");
    }
    public void print(){
        staticFunc();
//在普通方法內部可以呼叫靜態方法，但是不可以定義靜態變數
        System.out.println("姓名:" + name + ",年齡:" + age);
    }

靜態方法和實體無關, 而是和類相關. 因此這導致了兩個情況:

靜態方法不能直接使用非靜態資料成員或呼叫非靜態方法(非靜態資料成員和方法都是和實體相關的).
this和super兩個關鍵字不能在靜態背景關系中使用(this 是當前實體的參考, super是當前實體父類實體的參考, 也是和當前實體相關.

c.代碼塊

使用static定義的代碼塊，一般用于初始化靜態成員屬性,后面在代碼塊處會詳細解釋，

d.修飾類

三、封裝

3.1 private實作封裝

private/ public 這兩個關鍵字表示 “訪問權限控制” .
被 public 修飾的成員變數或者成員方法, 可以直接被類的呼叫者使用.
被 private 修飾的成員變數或者成員方法, 不能被類的呼叫者使用.
換句話說, 類的使用者根本不需要知道, 也不需要關注一個類都有哪些 private 的成員. 從而讓類呼叫者以更低的成本來使用類.

private 不光能修飾欄位, 也能修飾方法，通常情況下我們會把欄位設為 private 屬性, 但是方法是否需要設為public, 就需要視具體情形而定. 一般我們希望一個類只提供 “必要的” public 方法, 而不應該是把所有的方法都無腦設為public.

3.2 getter和setter方法

當我們使用 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;
    }
 }

【注意】：

getName 即為 getter 方法, 表示獲取這個成員的值.
setName 即為 setter 方法, 表示設定這個成員的值.
當set方法的形參名字和類中的成員屬性的名字一樣的時候，如果不使用this, 相當于自賦值. this 表示當前實體的參考.
不是所有的欄位都一定要提供 setter / getter 方法, 而是要根據實際情況決定提供哪種方法.

四、構造方法

構造方法是一種特殊方法, 使用關鍵字new實體化新物件時會被自動呼叫, 用于完成初始化操作.構造方法沒有回傳值，
new 執行程序:

為物件分配記憶體空間.
呼叫物件的構造方法.

語法規則:

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

【注意】：

如果類中沒有提供任何的建構式，那么編譯器會默認生成一個不帶有引數的建構式.也就是說：一個類至少會有一個構造方法.
若當前類中有其他的構造方法，那么編譯器就不會幫我們生成不帶引數的構造方法.
構造方法之間可以構成多載,規則和普通方法的多載一致.
多載：方法名相同，引數串列不同，回傳值不做要求，

class Person{
    private   String name;
    private   int age;
public  Person(){
        System.out.println("不帶引數的構造方法");
    }
     public  Person(String name,int age){
        this.name = name;
          System.out.println("帶1個引數的構造方法");
   }
    public  Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("帶2個引數的構造方法");
   }
   public void show(){
	System.out.println("name: "+name+" age: "+age);
	}
}
public class Main{
public static void main(String[] args) {
	Person p1 = new Person();//呼叫不帶引數的建構式，如果程式沒有提供會呼叫不帶引數的建構式
	p1.show();
	Person p2 = new Person("zhangfei");//呼叫帶有1個引數的建構式
	p2.show();
	Person p3 = new Person("zhangfei",80);//呼叫帶有2個引數的建構式
	p3.show();
	}
}

this關鍵字

this表示當前物件參考(注意不是當前物件). 可以借助 this 來訪問物件的欄位和方法

1、this.data 呼叫當前物件的屬性
例：

	public void setName(String name){
        this.name = name;//this代表當前物件的參考
    }
    public String getName(){
        return name;
    }

2、this.func() 呼叫當前物件的方法
例：

public void eat(){
        System.out.println(name + "正在吃");
    }
    public void print(){
    	this.eat();
        staticFunc();
		//在普通方法內部可以呼叫靜態方法，但是不可以定義靜態變數
        System.out.println("姓名:" + name + ",年齡:" + age);
    }

3、this()呼叫當前物件的其他構造方法,存放在建構式當中! ! !
例：

 public  Person(){
       this("name",12);//呼叫帶2個引數的構造方法  this必須放到第一行
        System.out.println("不帶引數的構造方法");
    }
    public  Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("帶2個引數的構造方法");
    }

輸出結果：

帶2個引數的構造方法
不帶引數的構造方法
name 12

五、代碼塊

使用 {} 定義的一段代碼.
根據代碼塊定義的位置以及關鍵字，又可分為以下四種：
1.普通代碼塊
2.構造塊
3.靜態塊
4.同步代碼塊

class Person{
    //普通成員變數，屬于物件
    private   String name;
    private   int age;

    //靜態的成員變數不可以在方法中定義
    public static int count = 10;//靜態成員變數->類變數 放在方法區

    {
        this.age = 90;
        System.out.println("實體代碼塊");
    }
    static {
        //本質上來說初始化靜態的東西
        count = 99;  //如果都是靜態的情況下，那么和定義的順序是有關系的
        System.out.println("靜態代碼塊");
    }

public static void main5(String[] args) {
        Person person1 = new Person();//靜態代碼塊，實體代碼塊
        System.out.println("==============");
        Person person2 = new Person();  //實體代碼塊  靜態代碼塊只會被執行一次
    }
     public static void main6(String[] args) {
        System.out.println(Person.count);//不用實體化物件，靜態代碼塊也能被執行，并且只被執行一次
    }

靜態代碼塊和實體代碼塊在類加載時被執行，
靜態代碼塊不管生成多少個物件，其只會執行一次，且是最先執行的，
靜態代碼塊執行完畢后, 實體代碼塊（構造塊）執行，再然后是建構式執行，
靜態代碼塊不用實體化物件，都可以被執行，

匿名物件

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

class Person {
	private String name;
	private int age;
	public Person(String name,int age) {
	this.age = age;
	this.name = name;
}
public void show() {
	System.out.println("name:"+name+" " + "age:"+age);
	}
}
public class Main {
	public static void main(String[] args) {
	new Person("caocao",19).show();//通過匿名物件呼叫方法
	}
}
// 執行結果
name：caocao age：19

toString方法

在上面的四中我們用到了show方法，其實我們可以用toString方法來實作：

@Override //重寫
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';