一、類和物件

1、物件導向

（1）物件導向與 程式導向 （理解）
● 程式導向的操作是以程式的基本功能實現為主，實現之後就完成了，也不考慮修改的可能性，物件導向，更多的是要進行子模組化的設計，每一個模組都需要單獨存在，並且可以被重複利用，所以，物件導向的開發更像是一個具備標準的開發模式。

程式導向：強調的是功能行為，以函式為最小單位，考慮怎麼做。
物件導向：強調具備了功能的物件，以類/物件為最小單位，考慮誰來做。
（2）物件導向的特徵
● 物件導向可以將複雜的工程邏輯簡單化，增強程式碼的複用性。
● 物件導向具有封裝，繼承，多型等特性。

2、類和物件

1、類 ：抽象概念的集合，即模板，確定物件將會擁有的屬性和行為(方法)。
2、物件：是一種個性的表示，表示一個獨立的個體，每個物件擁有自己獨立的屬性，依靠屬性來區分不同物件。
3、類和物件關係：類是抽象的概念，僅為模板，不能直接使用，物件是一個具體的實體，可以直接被使用。類只有通過例項化的物件才可以被使用，所以在實際開發中應該先產生類，之後再產生物件。

3、類和物件的定義與使用

定義類

許可權修飾符 class 類名{
	//屬性
	許可權修飾符 屬性型別 屬性名稱;
	//方法
	許可權修飾符 方法名（形參）{
		方法體;
	}
}

範例：定義一個people類

public class People{
	public String name;
	private int age;
	public People(String name1, int age){       //構造方法
		name = name1;
        this.age = age;
    }
	public void eat(){
		System.out.println(name + "在吃飯");
	}
}

類定義完成之後，無法直接使用。如果要使用，必須依靠物件，那麼由於類屬於引用資料型別，所以物件的產生格式有如下兩種：
1、宣告的同時例項化物件
類名稱 物件名稱 = new 類名稱 () ;
2、先宣告，再例項化物件
類名稱 物件名稱 = null ;
物件名稱 = new 類名稱 () ;

當一個例項化物件產生之後，可以按照如下的方式進行類的操作：
物件.屬性：表示呼叫類之中的屬性；
物件.方法()：表示呼叫類中的方法。

## 構造方法：
1、使用new+構造方法 來建立一個新物件
2、構造方法是定義在Java類中的一個用來初始化物件的方法，構造方法與類名同名且沒有返回值
3、當沒有指定構造方法時，系統會自動新增無參構造方法。
4、當有指定構造方法，無論是有參/無參的構造方法，都不會自動新增無參構造方法。
5、構造方法的過載：方法名相同，但引數不同的多個構造方法，呼叫時會自動根據不同引數選擇相應的方法。

4、物件呼叫成員方法

方式：物件.方法名 呼叫

People people1 = new People("zs",19);   //new一個物件people1
String name = people1.getName();       //物件people1呼叫getName方法。

people1.getName()；的底層實現是getName(people1);
將people1當做引數傳遞進去。

public String getName(){
	return this.name;
}

此getName方法的底層實際上是getName(people this)。
return this.name。 返回的是當前物件的name。那麼誰呼叫此方法就返回誰的name屬性。

5、許可權修飾符

Java中四種許可權修飾符：public(公共的)、protected(受保護的)、default(預設的(也可以不寫))、private(私有的)

修飾符	同一類中	同一包中	子類	任何地方
public	√	√	√	√
protected	√	√	√
default	√	√
private	√

● public(公共的)：具有公共訪問許可權。如果類中的屬性或方法被public修飾，則此類中的屬性或方法可以被任何類呼叫。
● protected(保護的) ：被其修飾的類、屬性、方法只能被類本身及子類訪問，即使子類在不同包中也可以訪問，但不能訪問與子類同包的其他類。對不管是不是同包的子類公開，對同包下沒有父子關係的其他類私有
● default(預設的(也可以不寫))：具有包訪問許可權，被此修飾的屬性或方法只允許在同一個包中進行訪問。同包下相當於公開。
● private(私有的)：被其修飾的類、屬性、方法只能被該類物件訪問，其子類不能訪問，更不能跨包訪問。

6、this關鍵字

1. 如果區域性變數和 成員變數 產生命名衝突 用this指明當前物件
2. 建構函式過載，在一個建構函式中用this(形參)呼叫其他的建構函式。舉例如下方程式碼第11行。
   ● 1、建構函式不能用this()相互呼叫。
   ● 2、this()呼叫建構函式不能在成員函式中呼叫
   ● 3、當前建構函式 不能通過this 呼叫多個建構函式。
   ● 4、this()呼叫必須位於當前建構函式有效程式碼第一行。

1、public class People {
2、    //屬性—>例項變數/成員變數
3、    String name;
4、      double age;
5、    // 建構函式 初始化 成員變數
6、    public People(String name1, double age) {
7、        name = name1;
8、        this.age = age;
9、    }
10、    public People(){
11、        this("sz",19);
12、    }
13、}

二、封裝

1、what

將類的某些資訊隱藏在類內部,不允許外部程式直接訪問,而是通過該類提供的方法來實現對隱藏資訊的操作和訪問

2、why

● 1：通過隱藏物件的屬性來保護物件內部的狀態（隱藏資訊、實現細節）。
● 2：可以對成員變數進行更精確的控制，容易保證類內部資料間的一致性，從而提高軟體的可靠性。
● 3：提高物件資料的安全性，提高了程式碼的可用性和可維護性。

3、how

Java中通過將資料宣告為私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()實現對該屬性的操作。

三、繼承

1、繼承的定義

● 當我們定義有很多部分具有相同屬性和方法的類時，如果每一個類都定義這些相同屬性和方法，容易造成程式碼冗餘，為了允許使用現有類的功能，並且無需改動原有類的情況下，引入繼承的概念。
● 允許重用的現有類成為父類（或基類，超類），由父類派生出來的類稱為子類（或派生類）。
● 繼承就是子類繼承父類的特徵和行為，使得子類物件具有父類的例項域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。

2、繼承的使用

public class Animal {
    private String name;
    private int age;

    public Animal(String name , int age){
        this.name = name;
        this.age = age;
    }
}

public class Dog extends Animal {  //實現繼承的關鍵字 extends
    private String color;

    public Dog(String name,int age,String color){
        super(name,age);           //呼叫父類的構造方法。
        this.color = color;
    }
}

在這個例子中Dog類繼承了Animal類，所以Dog類繼承了Animal類裡面的屬性name 和 age。就不會造成重複定義，和程式碼冗餘。

super關鍵字

● 1、用於從子類訪問父類的成員。
● 2、子類呼叫父類的構造方法super()，super()只能在派生類的構造方法中呼叫，位於方法首行。
● 3、呼叫父類已被重寫的方法。
● 4、訪問父類的資料成員 super.成員變數 或 super.成員方法。

3、繼承的特徵

1. 傳遞性。若類C繼承類B，類B繼承類A,則類C既有從類B哪裡繼承的屬性和方法，也有從類A那裡繼承的屬性和方法，還可以有自己新定義的屬性和方法。
2. 單繼承。Java只支援單重繼承，而通過介面來實現多繼承。

4、方法重寫

1）什麼是方法的重寫:

如果子類對繼承父類的方法不滿意,是可以重寫父類繼承的方法的，當呼叫方法時會優先呼叫子類的方法。
（2）語法規則:
● 子類中該方法的名字、返回值、引數列表和父類的方法都應該相同。
● 子類中的重寫方法訪問許可權不能比父類小。
● 若父類是抽象(abstract)類，則子類必須重寫父類的抽象方法，否則子類還是抽象類。
● 父類分final方法不能被重寫。

四、多型

1、多型的概念
同一個行為具有多種不同的表現形式或形態能力，允許不同類的物件對同一訊息做出相應。即同一訊息可以根據傳送物件的不同採用多種不同的行為方式。

2、多型的前提條件
要有繼承
要有方法的重寫
要有父類引用指向子類物件

3、多型的分類

1. 靜多型(靜態繫結，編譯期多型)
   靜多型也稱編譯時多型，就是常說的方法過載。根據形參的個數或型別的不同，從而呼叫不同的方法，在編譯期間就已經確定要呼叫的方法。
2. 動多型(動態繫結，執行時多型)
   父類引用指向子類物件，父類引用呼叫的方法根據實際 new 出來的物件呼叫實際物件的方法。

4、多型的實現

public class Animal {//定義一個Animal父類
	System.out.println("吃東西")           //定義一個吃飯的方法
}
 
//定義Cat類繼承Animal
class Cat extends Animal {
	public void eat() {     //定義一個Cat類的吃飯方法
		System.out.println("貓在吃飯");
	}
}
 
//定義Dog類繼承Animal
class Dog extends Animal {
	public void eat() {
		System.out.println("狗在吃飯");
	}
}
 
public class TestDemo {    //測試類
	public static void main(String[] args) {
		Animal a = new Cat();   //父類引用指向子類物件
		Animal b = new Dog();
		
		a.eat();    //父類引用呼叫的方法根據實際 new 出來的物件呼叫實際物件的方法。
		b.eat();


		//instanceof關鍵字
		System.out.println(a instanceof Animal);//true	
		System.out.println(b instanceof Animal);//true	
		System.out.println(a instanceof Cat);//true	
		System.out.println(b instanceof Dog);//true	
		System.out.println(a instanceof Dog);//編譯不通過	
	}
}

5、instanceof關鍵字

作用：判斷一個引用型別變數所指向的物件是否是一個類(或介面、抽象類、父類)的例項。
返回值為Boolean型別。

舉例如上述程式碼最後5行。

此部落格為學習總結，若有錯誤，歡迎大家指正。