繼承是多個事物之間存在的一種關係，可以通過is--a（是一個）來判斷是否存在繼承關係。
特點:
1.事物之間應該具備一定的層次結構，並且具有可傳遞性。
2.子類繼承了父類，那麼就繼承了父類中所有的屬性和方法，但是私有屬性和構造方法除外。
子類不能繼承父類的構造方法是因爲，不能通過子類創建父類的對象。
3.子類繼承了父類，子類還可以擁有自己特有的屬性和方法。
4.在Java中只支持單一繼承，也就是說一個子類只能有一個父類，但是一個父類可以有多個子類。
作用:主要是爲了提高代碼的重用性
在Java中使用extends關鍵字實現類與類之間的繼承關係
語法:
[訪問修飾符] class 子類 extends 父類{
}
示例：
public class Son extends Father{
int age=20;
public void play(){
System.out.println(age);
System.out.println(house+car+money);
makeMoney();
}
public static void main(String[]args){
Son s=new Son();
s.play();
}
}
/**
父類
*/
class Father{
String house="100棟別墅";
String car="a6";
String money="1000000000000000000$";
//private int age=80;
public void makeMoney(){
System.out.println("一天24小時不停得造錢（美元）");
}
}
2.super關鍵字
前提:super關鍵字只能出現在有繼承關係的子類中。
作用:super表示的是對父類對象的引用。（也就說可以把super看作當前子類的父類對象）
用法:
1.調用父類中的屬性和方法
super.屬性名稱;
super.方法名稱(參數列表);
2.明確指明調用父類中的哪個構造方法,此時super關鍵字一定要出現在子類構造方法的第一句代碼
super(參數列表);
注意:
1.在有繼承關係的類中，創建子類對象時，一定是先執行父類中的構造方法，然後在執行子類中的構造方法。
2.如果子類構造方法沒有顯式調用超類構造方法，那麼會調用父類的默認構造方法。
3.如果父類沒有默認構造方法，而且子類構造方法又沒有顯示調用父類的其它構造方法，那麼編譯將報錯。此時，需要在子類構造方法中顯示調用父類構造方法，則在子類構造方法的第一條語句用關鍵字 super(參數列表)的形式來調用。
示例：
/**
super關鍵字的示例
*/
public class Son2 extends Father2{
int age=20;
public Son2(){
super(10);
System.out.println("子類構造方法執行了");
}
public void play(){
System.out.println(super.house+super.car+super.money);
super.makeMoney();
}
public static void main(String[]args){
Son2 s=new Son2();
s.play();
}
}
/**
父類
*/
class Father2{
String house="100棟別墅";
String car="a6";
String money="1000000000000000000$";
//private int age=80;
public Father2(int num){
System.out.println("父類中的構造方法執行了"+num);
}
public void makeMoney(){
System.out.println("一天24小時不停得造錢（美元）");
}
}
private修飾的屬性或方法只能在本類中訪問。
默認修飾的屬性或方法只能在本類或同一個包中的類。
protected修飾的屬性和方法只能在本類或同一個包中的類或者不同包內的子類中訪問。
注意：protected修飾的屬性如果在子類中訪問，只能通過父類對象或者直接對屬性訪問，在子類中不能通過創建父類對象
訪問protected修飾的屬性。
public修飾的屬性和方法任何一個類都可以訪問。
注意:類一般用public或默認的修飾符
示例：
/**
訪問修飾符
*/
public class Test1{
private int age=20;
public static void main(String[]args){
Test2 t=new Test2();
System.out.println(t.num);
}
}
class Test2{
private String name="zhangsan";
String address="beijing";
protected int num=100;
}
在有繼承關係的子類中，纔可以發生重寫這一多態特徵。
定義:在有繼承關係的子類中，子類重寫父類中的方法，就需要和父類中的方法名稱一致，返回類型一致，參數列表一致，而且訪問修飾符的範圍不能被縮小。
目的:當父類中的方法所完成的功能，滿足不了子類的需求時，子類就可以對父類中的方法進行重寫。
示例：
/**
重寫 示例
*/
public class Son3 extends Father3{
public void makeMoney(){
super.makeMoney();
System.out.println("造人民幣");
}
public static void main(String[]args){
Son3 s=new Son3();
s.makeMoney();
}
}
/**
父類
*/
class Father3{
public void makeMoney(){
System.out.println("美元");
}
}
java.lang.Object類是所有Java類的父類
如果在類的聲明中未明確使用extends關鍵字指定父類，則默認爲繼承自Object類
Object類中的toString()方法，輸出對象時格式爲：類名@對象哈希碼的十六進制整數值
6.final關鍵字
用法:
1.final修飾變量，那麼這個變量其實是一個常量，一旦賦值就不能更改。
2.final修飾方法中的參數，稱爲最終參數，在方法體中不能再給最終參數賦值。
3.final修飾類，類不能繼承。
4.final修飾的方法不能被重寫
示例：
/**
final 關鍵字 示例
*/
public class Test7 extends Test8{
public static void main(String[]args){
final int NUM=100;
// NUM=200;
Test7 t=new Test7();
t.display(100);
}
public void test2(){
}
public void display(final int NUM){
//NUM=1000;
System.out.println(NUM);
}
}
class Test8{
public final void test2(){
}
}
所謂的向上轉型，就是把子類對象給父類，可以把對象看作是一個父類對象來使用。
動態綁定機制：在程序運行時，會根據對象的真正的創建者，來決定調用父類或者子類的方法(也就說對象是誰創建的就調用哪個類中的方法)
發生動態綁定機制的條件:
1.要有繼承
2.要有重寫
3.要有向上轉型發生
4.要用向上轉型的對象，調用重寫的方法。
所謂的向下轉型，就是把父類對象給子類，可以把對象看作是一個子類對象來使用。
千萬注意:向下轉型一定是在向上轉型的基礎，做類型的還原。不能直接把一個父類對象，強制轉換成子類對象。
使用向下轉型需要使用強制轉換符。
instanceof關鍵字判斷對象是否屬於某個類，語法:
對象名稱 instanceof 類名(接口名稱)
示例1：
/**
向上轉型 示例
*/
public class Son4 extends Father4{
public static void main(String[]args){
//發生向上轉型
Father4 f=new Son4();
f.test1();
//f.display();//會報錯，會找不到display方法，因爲此時的對象是父類的類型
}
/*
如果使用向上轉型的對象，調用子類中的非重寫方法，就可以證明向上轉型以後的對象，確實是屬於父類這種類型
*/
public void display(){
System.out.println("方法display");
}
public void test1(){
System.out.println("okok");
}
}
/**
父類
*/
class Father4{
public void test1(){
System.out.println("ok");
}
}
示例2：
/**
向下轉型 示例
*/
public class Son5 extends Father5{
public static void main(String[]args){
Father5 f=new Son5();
Son5 s=(Son5)f;
s.test();
//Son6 s1=(Son6)f;
System.out.println(f instanceof Father5);
System.out.println(f instanceof Son5);
System.out.println(f instanceof Son6);
Father5 f2=new Father5();
System.out.println(f2 instanceof Son5);
System.out.println(s instanceof Father5);
System.out.println(s instanceof Son6);
}
public void test(){
System.out.println("okok");
}
}
/**
父類
*/
class Father5{
public void display(){
System.out.println("ok");
}
}
class Son6 extends Father5{
}
面向對象編程練習題
1.寫一個類，名爲Animal，該類有兩個私有屬性，name(代表動物的名字)，和legs(代表動物的腿的條數)；要求爲兩個私有屬性提供public 的訪問方法。並提供兩個重載的構造方法，一個需要兩個參數，分別用這兩個參數給私有屬性name和legs賦值。另一個無參，默認給name賦值爲AAA,給legs賦值爲4；該類還有兩個重載的move()方法，其中一個無參，在屏幕上輸出一行文字:XXX Moving!!(XXX爲該動物的名字)；另一個需要一個int參數n,在屏幕上輸出n次
XXX Moving!!
2.寫一個類Fish,繼承自Animal類，並提供一個構造方法，該構造方法需要一個參數name,並給legs賦默認值0;該類還要求覆蓋Animal類中的無參move()方法，要求輸出：XXX Swimming!!
3.寫一個類Bird,繼承自Animal類，並提供一個構造方法，該構造方法需要一個參數name,並給legs賦默認值2;該類還要求覆蓋Animal類中的無參move()方法，要求輸出：XXX Flying!!
4.寫一個類Zoo,定義一個主方法，在主方法中分別生成若干個Animal,Fish和Bird。並調用他們的屬性和方法。(用上多態)
5. 請編碼實現如下需求。樂器（Instrument）分爲：鋼琴(Piano)、小提琴(Violin)；各種樂器的彈奏（ play ）方法各不相同。編寫一個測試類InstrumentTest，要求：編寫方法testPlay，對各種樂器進行彈奏測試。要依據樂器的不同，進行相應的彈奏。在main方法中進行測試。
6. 請編碼實現動物世界的繼承關係：動物（Animal）具有行爲：吃（eat）、睡覺（sleep）；動物包括：兔子（Rabbit），老虎（Tiger）；這些動物吃的行爲各不相同（兔子吃草，老虎吃肉）；但睡覺的行爲是一致的。請通過繼承實現以上需求，並編寫測試類AnimalTest進行測試。
第三章：面向對象題2
1. 請編碼實現如下需求。樂器（Instrument）分爲：鋼琴(Piano)、小提琴(Violin)；各種樂器的彈奏（ play ）方法各不相同。編寫一個測試類InstrumentTest，要求：編寫方法testPlay，對各種樂器進行彈奏測試。要依據樂器的不同，進行相應的彈奏。在main方法中進行測試。
2. 請編碼實現動物世界的繼承關係：動物（Animal）具有行爲：吃（eat）、睡覺（sleep）；動物包括：兔子（Rabbit），老虎（Tiger）；這些動物吃的行爲各不相同（兔子吃草，老虎吃肉）；但睡覺的行爲是一致的。請通過繼承實現以上需求，並編寫測試類AnimalTest進行測試。
3.定義一個電器類，然後分別定義它的兩個子類：電視機和電腦，再定義一個判定類判定在動態運行時是哪臺電器在運行。
說明：動態運行其實就是動態綁定機制