1. Java繼承

繼承要符合的關系是：is-a，父類更通用，子類更具體.

1.1 繼承的特性

• 子類擁有父類非private的屬性，方法。
• 子類可以擁有自己的屬性和方法，即子類可以對父類進行擴展。
• 子類可以用自己的方式實現父類的方法。
• Java的繼承是單繼承，但是可以多重繼承，單繼承就是一個子類只能繼承一個父類，多重繼承就是，例如A類繼承B類，B類繼承C類，所以按照關系就是C類是B類的父類，B類是A類的父類，這是java繼承區別于C++繼承的一個特性。
• 提高了類之間的耦合性（繼承的缺點，耦合度高就會造成代碼之間的聯系）。

1.2 繼承關鍵字

繼承可以使用 extends 和 implements 這兩個關鍵字來實現繼承，而且所有的類都是繼承于 java.lang.Object，當一個類沒有繼承的兩個關鍵字，則默認繼承object（這個類在 java.lang 包中，所以不需要 import）祖先類。

• 在 Java 中，類的繼承是單一繼承，也就是說，一個子類只能擁有一個父類，所以 extends 只能繼承一個類。
• 使用 implements 關鍵字可以變相的使java具有多繼承的特性，使用范圍為類繼承接口的情況，可以同時繼承多個接口

final關鍵字：

• final 關鍵字聲明類可以把類定義為不能繼承的，即最終類
• 用于修飾方法，該方法不能被子類重寫
• 實例變量也可以被定義為 final，被定義為 final 的變量不能被修改。被聲明為 final 類的方法自動地聲明為 final，但是實例變量并不是 final

1.3 構造器

子類不能繼承父類的構造器（構造方法或者構造函數），但是父類的構造器帶有參數的，則必須在子類的構造器中顯式地通過super關鍵字調用父類的構造器并配以適當的參數列表。
如果父類有無參構造器，則在子類的構造器中用super調用父類構造器不是必須的，如果沒有使用super關鍵字，系統會自動調用父類的無參構造器。

class SuperClass {private int n;SuperClass(){System.out.println("SuperClass()");}SuperClass(int n) {System.out.println("SuperClass(int n)");this.n = n;} } class SubClass extends SuperClass{private int n;SubClass(){super(300); // 必須在子類的構造器中顯式地通過super關鍵字調用父類的構造器(帶參)System.out.println("SubClass");} public SubClass(int n){System.out.println("SubClass(int n):"+n);this.n = n;} } public class TestSuperSub{public static void main (String args[]){SubClass sc = new SubClass(); // new SubClass()中調用父類的帶參構造器SubClass sc2 = new SubClass(200); // 會調用父類的無參構造器} }

輸出結果為：

SuperClass(int n) SubClass SuperClass() SubClass(int n):200

到底是調用父類的帶參數還是無參構造器還要看實例化對象語句。

1.4 面向對象編程——繼承和多態

繼承的注意點：

• 子類不是父類的子集，子類一般比父類包含更多的數據域和方法。
• 父類中的 private 數據域在子類中是不可見的，因此在子類中不能直接使用它們。
• 繼承是為”是一個”的關系建模的，父類和其子類間必須存在”是一個”的關系，否則不能用繼承。
• 但也并不是所有”是一個”的關系都應該用繼承。例如，正方形是一個矩形，但不能讓 Square 類來繼承 Rectangle 類，因為正方形不能從矩形擴展得到任何東西。正確的繼承關系是 Square 類繼承 Shape 類
• Java 只允許單一繼承（即一個子類只能有一個直接父類），C++ 可以多重繼承（即一個子類有多個直接父類）。

super 關鍵字:
super 表示使用它的類的父類。super 可用于：

• 調用父類的構造方法（帶參）；
• 調用父類的方法（子類覆蓋了父類的方法時，即重寫）；
• 訪問父類的數據域（可以這樣用但沒有必要這樣用）。

注意：super 語句必須是子類構造方法的第一條語句（必須是子類構造方法的第一句）。不能在子類中使用父類構造方法名來調用父類構造方法。 父類的構造方法不被子類繼承（這也就是為什么要用super關鍵字）。調用父類的構造方法的唯一途徑是使用 super 關鍵字，如果子類中沒顯式調用，則編譯器自動將 super(); 作為子類構造方法的第一條語句。這會形成一個構造方法鏈。

注意：靜態方法中不能使用 super 關鍵字。

如果是繼承的方法，是沒有必要使用 super 來調用，直接即可調用。但如果子類覆蓋或重寫了父類的方法，則只有使用 super 才能在子類中調用父類中的被重寫的方法。

1.5 final 的作用隨著所修飾的類型而不同

1、final 修飾類中的屬性或者變量
無論屬性是基本類型還是引用類型，final 所起的作用都是變量里面存放的”值”不能變。

這個值，對于基本類型來說，變量里面放的就是實實在在的值，如 1，”abc” 等。
而引用類型變量里面放的是個地址，所以用 final 修飾引用類型變量指的是它里面的地址不能變，并不是說這個地址所指向的對象或數組的內容不可以變，這個一定要注意。

例如：類中有一個屬性是 final Person p=new Person(“name”); 那么你不能對 p 進行重新賦值，但是可以改變 p 里面屬性的值 p.setName(‘newName’);
final 修飾屬性，聲明變量時可以不賦值，而且一旦賦值就不能被修改了。對 final 屬性可以在三個地方賦值：聲明時、初始化塊中、構造方法中，總之一定要賦值。
2、final修飾類中的方法
作用：可以被繼承，但繼承后不能被重寫。
3、final修飾類
作用：類不可以被繼承。

在編寫代碼要注意：
執行父類構造函數的語句只能放在函數內語句的首句，不然會報錯。
在繼承關系中，在調用函數（方法）或者類中的成員變量時，JVM（JAVA虛擬機）會先檢測當前的類（也就是子類）是否含有該函數或者成員變量，如果有，就執行子類中的，如果沒有才會執行父類中的。如下：

public class Start {public static void main(String[] args){Cat cat=new Cat("Jack","黑色");cat.eat();cat.run();cat.sleep();}}class Animal {String name;public Animal(){}//必須要寫這個構造函數，不然Cat類的代碼會出錯public Animal(String name){this.name=name;}void eat(){System.out.println(name+"正在吃");}void run(){System.out.println(name+"正在奔跑");}void sleep(){System.out.println(name+"正在睡覺");} }class Cat extends Animal {String color;public Cat(String name,String color){this.name=name;this.color=color;}void eat(){System.out.println(color+"的"+name+"正在吃魚");} }

運行結果如下：

黑色的Jack正在吃魚 Jack正在奔跑 Jack正在睡覺

當子類出現與父類一樣的函數時，這個被稱為 重寫 也叫 覆蓋
Object類是所有類的直接父類或間接父類，也就是說是所有類的根父類，這個可以運用于參數的傳遞
如下：

public class Start {public static void main(String[] args){A a=new A();B b=new B();C c=new C();D d=new D();speak(a);speak(b);speak(c);speak(d);} // instanceof 關鍵字是用于比較類與類是否相同，相同返回true，不同返回false //當你不清楚你需要的參數是什么類型的，可以用Object來代替，Object可以代替任何類static void speak(Object obj){if(obj instanceof A)//意思是：如果參數是 A 類，那么就執行一下語句{A aobj=(A)obj;//這里是向下轉換，需要強制轉換aobj.axx();}else if(obj instanceof B){B bobj=(B)obj;bobj.bxx();}else if(obj instanceof C){C cobj=(C)obj;cobj.cxx();}} } //這里舉了四個類，他們的函數都不同，但都是 Object 類的子類 class A {void axx(){System.out.println("Good morning!");System.out.println("This is A");} }class B {void bxx(){System.out.println("Holle!");System.out.println("This is B"); } }class C {void cxx(){System.out.println("Look!");System.out.println("This is C"); } }class D {void dxx(){System.out.println("Oh!Bad!");System.out.println("This is D"); } }

運行結果：

Good morning! This is A Holle! This is B Look! This is C

2. Java 重寫(Override)與重載(Overload)

2.1 Java 重寫(Override)

重寫是子類對父類的允許訪問的方法的實現過程進行重新編寫, 返回值和形參都不能改變。即外殼不變，核心重寫！

重寫的好處在于子類可以根據需要，定義特定于自己的行為。 也就是說子類能夠根據需要實現父類的方法。

重寫方法不能拋出新的檢查異常或者比被重寫方法申明更加寬泛的異常。例如： 父類的一個方法申明了一個檢查異常 IOException，但是在重寫這個方法的時候不能拋出 Exception 異常，因為 Exception 是 IOException 的父類，只能拋出 IOException 的子類異常。
在面向對象原則里，重寫意味著可以重寫任何現有方法。

在編譯階段，只是檢查參數的引用類型。然而在運行時，Java虛擬機(JVM)指定對象的類型并且運行該對象的方法。
思考以下例子：

class Animal{public void move(){System.out.println("動物可以移動");} }class Dog extends Animal{public void move(){System.out.println("狗可以跑和走");}public void bark(){System.out.println("狗可以吠叫");} }public class TestDog{public static void main(String args[]){Animal a = new Animal(); // Animal 對象Animal b = new Dog(); // Dog 對象a.move();// 執行 Animal 類的方法b.move();//執行 Dog 類的方法b.bark();} } TestDog.java:30: cannot find symbol symbol : method bark() location: class Animalb.bark();^

該程序將拋出一個編譯錯誤，因為b的引用類型Animal沒有bark方法

2.2 方法的重寫規則

• 參數列表必須完全與被重寫方法的相同；
• 返回類型必須完全與被重寫方法的返回類型相同；
• 訪問權限不能比父類中被重寫的方法的訪問權限更低。例如：如果父類的一個方法被聲明為public，那么在子類中重寫該方法就不能聲明為protected。
• 父類的成員方法只能被它的子類重寫。
• 聲明為final的方法不能被重寫。
• 聲明為static的方法不能被重寫，但是能夠被再次聲明。
• 子類和父類在同一個包中，那么子類可以重寫父類所有方法，除了聲明為private和final的方法。
• 子類和父類不在同一個包中，那么子類只能夠重寫父類的聲明為public和protected的非final方法。
• 重寫的方法能夠拋出任何非強制異常，無論被重寫的方法是否拋出異常。但是，重寫的方法不能拋出新的強制性異常，或者比被重寫方法聲明的更廣泛的強制性異常，反之則可以
• 構造方法不能被重寫。
• 如果不能繼承一個方法，則不能重寫這個方法。

2.3 重載(Overload)

重載(overloading) 是在一個類里面，方法名字相同，而參數不同。返回類型可以相同也可以不同。
每個重載的方法（或者構造函數）都必須有一個獨一無二的參數類型列表。
最常用的地方就是構造器的重載。
重載規則

• 被重載的方法必須改變參數列表(參數個數或類型或順序不一樣)；
• 被重載的方法可以改變返回類型；
• 被重載的方法可以改變訪問修飾符；
• 被重載的方法可以聲明新的或更廣的檢查異常；
• 方法能夠在同一個類中或者在一個子類中被重載。
• 無法以返回值類型作為重載函數的區分標準。

重寫與重載之間的區別：

總結：
方法的重寫(Overriding)和重載(Overloading)是java多態性的不同表現，重寫是父類與子類之間多態性的一種表現，重載可以理解成多態的具體表現形式。
(1)方法重載是一個類中定義了多個方法名相同,而他們的參數的數量不同或數量相同而類型和次序不同,則稱為方法的重載(Overloading)。
(2)方法重寫是在子類存在方法與父類的方法的名字相同,而且參數的個數與類型一樣,返回值也一樣的方法,就稱為重寫(Overriding)。
(3)方法重載是一個類的多態性表現,而方法重寫是子類與父類的一種多態性表現。

重載與重寫的簡明理解:
重載反映的是“隨機應變”. 同樣一項功能, 根據數據類型的不同, 采用不同的處理方式. 比如, 同樣是吃飯, 去高檔餐廳吃西餐, 你會西裝革履, 但是去吃火鍋, 穿便裝就比較合適.
重寫反映的是“父子差異”. 你”繼承”了父親吃火鍋的愛好, 但是吃同一份鴛鴦鍋(注意, 數據類型相同) , 你喜歡涮紅湯, 你父親喜歡涮清湯.

補充：父類聲明變量指向子類實例，該父類變量不能調用父類不存在的變量和方法，否則會編譯錯誤

class Animal{public void move(){System.out.println("動物可以移動");} }class Dog extends Animal{public int age;public void move(){age = 10;System.out.println("狗可以跑和走");}public void bark(){System.out.println("狗可以吠叫");} }public class TestOverride{public static void main(String args[]){Animal a = new Animal(); // Animal 對象Animal b = new Dog(); // Dog 對象a.move();// 執行 Animal 類的方法b.move();//執行 Dog 類的方法// b.age;//去掉前注釋符號，會編譯錯誤// b.bark();//去掉前注釋符號，會編譯錯誤} }

摘自：
http://www.runoob.com/java/java-override-overload.html
http://www.runoob.com/java/java-inheritance.html

總結

以上是生活随笔為你收集整理的Java继承、重写与重载 笔记的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。