面向對象三大特性：繼承、封裝、多態

java面向對象三大特性

面向對象的優點體現在：與人類思維習慣一致；隱藏信息，提高了可維護性和安全性；提高了程序的可重用性。

一、繼承

1、什麼是繼承？

在定義和實現一個類的時候，可以在一個已經存在的類的基礎上來進行，把這個已經存在的類所定義的內容作爲自己的內容，並可以加入若干新的內容，或修改原來的方法使之更適合特殊的需要，這就是繼承。

繼承是子類自動共享父類數據和方法的機制，這是類之間的一種關係，提高了軟件的可重用性和可擴展性。

java中只支持單繼承，也就是說一個類只能擁有一個父類。子類不能繼承父類的構造方法。

java中所有的類都是由java.lang.Object類繼承而來，Object是所有類的祖先類。

繼承的關鍵字是：extends

2、繼承條件下，構造方法的調用規則：

如果子類的構造方法中沒有通過super顯示調用父類的有參構造方法，也沒有通過this顯示調用自身的其他構造方法，則系統會默認先調用父類的無參構造方法；在這種情況下，有沒有super();語句，效果都是一樣的。

如果子類的構造方法中通過super顯示調用父類的有參構造方法，則執行父類相應的構造方法，而不執行父類的無參構造方法。

如果子類的構造方法中通過this顯示調用父類的有參構造方法，則在相應構造方法中應用以上兩條規則。

特別注意的是：如果存在多級繼承關係，則在創建一個子類對象時，以上規則會向更高一級父類應用，一直到執行頂級父類Object類的無參構造方法爲止。

//使用繼承前
class Student {
	public void eat() {
		System.out.println("吃飯");
	}
	
	public void sleep() {
		System.out.println("睡覺");
	}
}

class Teacher {
	public void eat() {
		System.out.println("吃飯");
	}
	
	public void sleep() {
		System.out.println("睡覺");
	}
}



//使用繼承後，老師和學生都是人的範疇，抽取了老師和學生的共性功能，作爲人的功能，讓老師和學生去繼承。
class Person {
	public void eat() {
		System.out.println("吃飯");
	}
	
	public void sleep() {
		System.out.println("睡覺");
	}
}


class Student extends Person {}

class Teacher extends Person {}


class ExtendsDemo {
	public static void main(String[] args) {
		Student s = new Student();
		s.eat();
		s.sleep();
		System.out.println("-------------");
		
		Teacher t = new Teacher();
		t.eat();
		t.sleep();
	}
}

3、super關鍵字：

super代表對當前對象的直接父類對象的默認引用。在子類中可以通過super關鍵字來訪問父類的成員。

注意：

• super必須出現在子類（子類的方法或構造方法）中，而不是其他位置
• 可以訪問父類的成員，如父類的屬性、方法和構造方法
• 注意訪問權限的控制，如無法通過super訪問private成員

4、this關鍵字：

this關鍵字是對一個對象的默認引用，用來表示以後調用當前方法的對象的引用。

使用舉例：

• 使用this調用成員變量，解決成員變量和局部變量的同名衝突
• 使用this調用成員方法
• 使用this調用重載的構造方法，只要在構造方法中使用，必須是構造方法的第一條語句

二、封裝

1、什麼是封裝？

封裝就是將類型的狀態信息隱藏在類內部，不允許外部程序直接訪問，而通過該類提供的方法類實現對象隱藏信息的操作和訪問。

2、封裝的好處：

隱藏類的實現細節；讓使用者只能通過程序規定的方法來訪問數據；可以加入存取控制語句，限制不合理操作。

/**
 *	封裝和private的應用：
 *		A:把成員變量用private修飾
 *		B:提高對應的getXxx()和setXxx()方法
 */
 
//定義學生類
class Student {
	
	private String name;    //姓名
	private int age;        //年齡
	
	//姓名獲取值
	public String getName() {
		return name;
	}
	
	//姓名設置值
	public void setName(String n) {
		name = n;
	}
	
	//年齡獲取值
	public int getAge() {
		return age;
	}
	
	//年齡設置值
	public void setAge(int a) {
		age = a;
	}
}


//測試類
class StudentTest {
	public static void main(String[] args) {
	
		//創建學生對象
		Student s = new Student();
		
		//使用成員變量
		//錯誤：被私有修飾了，外界不能直接訪問了
		//System.out.println(s.name+"---"+s.age);
		System.out.println(s.getName()+"---"+s.getAge());
		
		//給成員變量賦值
		//s.name = "張三";
		//s.age = 22;
		
		//通過方法給賦值
		s.setName("李四");
		s.setAge(22);
		System.out.println(s.getName()+"---"+s.getAge());
	}
}

三、多態

1、什麼是多態？

多態就是同一個實現接口，使用不同的實例而執行不同的操作。

具體來說，多態是指程序中定義的引用變量所指向的具體類型和通過該引用變量發出的方法調用在編程時並不確定，而是在程序運行期間才確定，即一個引用變量到底會指向哪個類的實例對象該引用變量發出的方法調用到底是哪個類中實現的方法，必須在由程序運行期間才能決定。因爲在程序運行時才確定的類，這樣，不用修改源程序代碼，就可以讓引用變量綁定到各種不同的類實現上，從而導致該引用調用的具體方法隨之改變即不修改程序代碼就可以改變程序運行時所綁定的具體代碼，讓程序可以選擇多個運行狀態，這就是多態性。

多態性增強了軟件的靈活性和擴展性。

2、java中實現多態的機制是什麼？

靠的是父類或接口定義的引用變量可以只想子類或具體實現類的實例對象，而程序調用的方法在運行期才動態綁定，就是引用變量所指向的具體實例對象的方法，也就是內存里正在運行的那個對象的方法，而不是引用變量的類中定義的方法。

3、多態的表現形式有哪些？

（1）重載overload

a、參數類型、個數、順序至少有一個不相同。 
b、不能重載只有返回值不同的方法名。 
c、針對於一個類而言。 
d、不能通過訪問權限、返回類型、拋出的異常進行重載； 
e、方法的異常類型和數目不會對重載造成影響；

（2）重寫override

a、方法名、參數、返回值相同。 
b、子類方法不能縮小父類方法的訪問權限，只能比父類的訪問權限更大。 

c、子類方法不能擴大方法的異常範圍，即只能比父類拋出更少的異常，或者是拋出父類拋出的異常的子異常，因爲子類可以解決父類的一些問題，不能比父類有更多的問題。
d、存在於父類和子類之間。 
e、方法被定義爲final不能被重寫。 
f、被覆蓋的方法不能爲private，否則在其子類中只是新定義了一個方法，並沒有對其進行覆蓋。

/**
 *  多態————使用override實現
 */
class A extends Main{
	public String show(A obj)
	{
		System.out.println("調用了A的show方法");
		return "A";
	}
}
class B extends Main{
	public String show(B obj)
	{
		System.out.println("調用了B的show方法");
	return "B";
	}
}
class C extends A{
	public String show(C obj)
	{
		System.out.println("調用了C的show方法");
		return "C";
	}
}

public class Main{
	public static void main(String[] args)
	{
		Main u = new Main();
		A a = new A();
		B b = new B();
		C c = new C();
		System.out.println(u.show(c));//改變c的值爲a，b，看結果
	}
	public String show(Main main)
	{
		if(main instanceof A)
		{
			System.out.println("以A類爲對象調用show方法");
		}
		if(main instanceof B)
		{
			System.out.println("以B類爲對象調用show方法");
		}
		if(main instanceof C)
		{
			System.out.println("以C類爲對象調用show方法");
		}
		return "main";
	}
}

//其中A，B類是Main類的子類，C是A的子類，改變(u.show(c))的值。
//特別的，如果Main引用指向C對象，那麼它同時也指向C對象的父類：A對象。
//所以結果是這樣的：
//    以A類爲對象調用show方法
//    以C類爲對象調用show方法
//    main