1.繼承 extends

子類繼承父類，子類預設擁有父類的屬性和方法（ps：父類的private屬性不可繼承，但可以通過父類封裝的public方法獲得） 舉例： Test1 有id，name等私有屬性，id已封裝（public），name不進行封裝，還有protected addr 屬性（不進行封裝）

public class Test1 {
	
	private int id=4;
	private String name="zhangsan";
	protected String addr="南昌市";
	public int getId() {
		return id;
	}

Test2繼承Test1類

public class Test2 extends Test1{
	
	private int age;
		
	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String Methoad1(int num) {
		return "test";		
	}

	@Override
	public String toString() {
		return "Test2 [age=" + age + "]";
	}
	
}

在Test1的子類Test2中，可以通過父類Test1的public封裝方法獲取id的值，但無法獲取name的值，因為它是父類的私有屬性，且未進行封裝

Test2 test2=new Test2();		
System.out.println(test2.addr);

但是可以直接呼叫父類的protected屬性（public屬性當然也可以）

2.封裝

public class Test1 {
	
	private int id;
	private String name;
	
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
 

將類的屬性通過get ，set方法進行封裝，保證了資料的安全性

Ps -> elipse預設快捷鍵：

get set 方法： alt+shift+s  +R 
toString 方法：alt+shift+s  +S 
全參建構函式：alt+shift+s  +O 
無參建構函式：alt+/ 

3.多型

多型是  同一個行為  具有  多個不同表現形式或形態  的能力；
多型就是  同一個介面 ，使用不同的例項而執行不同操作；

優點：

1. 消除型別之間的耦合關係
2. 可替換性
3. 可擴充性
4. 介面性
5. 靈活性
6. 簡化性

必要條件：

1.繼承
2.重寫
3.父類引用指向子類物件

Ps：當使用多型方式呼叫方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去呼叫子類的同名方法。

package dismiss;

public class Polymorphic {

public static void main(String[] args) {
	// TODO Auto-generated method stub
		
	show(new Cat());  //cat物件呼叫show方法  
	show(new Dog());  //dog物件呼叫show方法
	
	Animal animal=new Cat();  //使用Animal的引用例項化了一個Cat物件animal
	animal.eat();  //呼叫cat的eat方法
	Cat cat=(Cat) animal;  //Animal 沒有work方法，只有強制轉換陳Cat物件才能呼叫work函式
	cat.work();
	
}
public static void show(Animal a) {
	a.eat();
	if(a instanceof Cat) {
		Cat c=(Cat) a;
		c.work();			
	}else if(a instanceof Dog) {
		Dog d=(Dog) a;
		d.work();
	}
}

}

抽象父類Animal 有抽象方法eat()

abstract class Animal{
	public abstract void eat();	
	
	public void test() {
		System.out.println("123");
	}	
	//overload test 方法的過載——》引數型別、個數、順序至少有一個不相同。 
	public void test(int num) {
		System.out.println("123");
	}
}

Cat類繼承抽象父類Animal

class Cat extends Animal{  //繼承抽象類需要重寫，覆蓋抽象父類的所有**抽象**方法

	@Override
	public void eat() {    //(重寫，覆蓋抽象父類的eat方法)
		// TODO Auto-generated method stub
		System.out.println("I like fish !");
	}
	public void work() {    // 	新增自己的方法work
		
		System.out.println("I can catch mouse !");
	}	
}

Dog 類繼承抽象父類Animal

class Dog extends Animal{

	@Override
	public void eat() {  //(重寫，覆蓋抽象父類的eat方法)
		// TODO Auto-generated method stub
		System.out.println("I like bone");
	}
	public void work() {    // 	新增自己的方法work
		
		System.out.println("I can watch home !");
	}
}

rs：

I like fish ! I can catch mouse ! I like bone I can watch home ! I like fish ! I can catch mouse !

尤其注意：重寫override和過載overload 的區別
過載(overloading) 是在一個類裡面，方法名字相同，而引數不同。
重寫(Overriding)是子類對父類的允許訪問的方法的實現過程進行重新編寫, 返回值和形參都不能改變。即外殼不變，核心重寫！