一、對象和類的概念
類：對具有相同屬性和方法的一類事物的抽象。
對象：具體的某一事物，代表自身的一些屬性和方法。
二、類（對象）之間的關系
關聯（組合、聚合），繼承，依賴、實現
三、面向對象設計思想
面向對象---》考慮哪些類，對象---》類和對象有屬性、方法-----》類和類之間的關系
四、重載、重寫和隱藏
1). 重載(overload)：
方法重載就是多個方法名稱相同但是參數類型或者參數個數不同的方法，與返回值類型和修飾符無關
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
class Test { public int test(int a) { return a; } public String test(String a) { return a; } public float test(int a, String b) { return 0f; } public float test(String a, int b) { return 1.0f; } String test(float a) { return ""; } String test(int a) {//該方法不是重載 return ""; }} |
前面五個互為重載，第一個和第六個雖然返回值類型不同，但參數相同，所以第一個和第六個參數不是重載
2). 重寫(override):
子類繼承父類時，子類的方法名稱、參數類型、參數個數與父類完全相同，則認為子類重寫了父類的方法。
方法重寫規則：
- 參數列表和原方法完全相同
- 返回值類型和原方法相同或者為父類返回值類型的子類型
- 不能比原方法限制更嚴格的訪問級別(舉例：父類方法為public，那么子類不能為protected、private)
- 父類方法被定義為final時，則不能被重寫
- 父類方法被定義為static時，不能被重寫，但是可以重寫聲明一個相同的方法（參考隱藏）
- 不能拋出新的異常或比原方法更廣泛的異常（父類拋出IOException，重寫方法不能拋出Exception只能拋出IOException或者IOException子類異常）
3). 隱藏:
隱藏是針對于父類的成員變量和靜態方法而言的。子類中聲明了和父類相同的變量名或靜態方法(方法名相同、參數列表相同、返回類型相同)則實現了對父類成員變量和靜態方法的隱藏，下面舉個例子有助理解：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
class A { static int a = 1; static int b = 2; int c = 33; public static void printA() { System.out.print(a); } public static void printB() { System.out.print(b); } }class B extends A { static int a = 3; static int b = 4; int c = 44; public static void printB() { System.out.print(b); } }public class Test { public static void main(String[] args) { B.printA(); B.printB(); System.out.print(B.a); A a = new B(); B b = new B(); a.printB(); b.printB(); System.out.print(a.c); System.out.print(b.c); } } |
輸出結果：
1 4 3 2 4 33 44
如果子類中有相同名稱的靜態方法或變量父類的會被隱藏，如果子類中存在同名的靜態方法或變量，則會隱藏父類中得靜態方法或變量，此時子類調用的就是子類中自己的靜態方法或變量；如果子類中不存在同名的靜態方法或變量，則會調用父類中的靜態方法或變量；父類調用的始終是其本身的靜態方法和變量。
五、封裝：
封裝是把對象的屬性和操作結合為一個獨立的整體，隱藏對象內部操作的實現，用戶只需要通過其對外提供的方法來訪問該對象，無需知道其內部實現細節。
優點：
- 隱藏內部實現細節，提供公共訪問方式
- 類內部可以自由修改不影響其調用者
- 減少耦合度，提高安全性
六、繼承：
繼承是一個對象獲取另一個對象屬性的過程，關鍵字為extends和implements。
1). IS-A關系(一個對象所屬于另一個對象)：
方式一. 用extends來實現繼承：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class Animal { public void eat() { System.out.println("Animal eating..."); }}public class Mammal extends Animal { public void eat() { System.out.println("Mammal eating..."); }}public class Dog extends Mammal { public void eat() { System.out.println("Dog eating..."); }} |
方式二. 用implements來實現繼承：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public interface Animal { void eat();}public class Mammal extends Animal { public void eat() { System.out.println("Mammal eating..."); }}public class Dog extends Mammal { public void eat() { System.out.println("Dog eating..."); }} |
無論方式一還是方式二，我們都可以用instanceof關鍵字檢查得出：Mammal是一個Animal(哺乳動物也是動物)；Dog既是一個Mammal，也是一個Animal(狗既是哺乳動物也是動物)。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class Test { /** * instanceof關鍵字檢查代碼 */ public static void main(String[] args) { Mammal m = new Mammal(); Dog d = new Dog(); System.out.print(m instanceof Animal); System.out.print(d instanceof Mammal); System.out.print(d instanceof Animal); }} |
輸出結果：
true true true
2). HAS-A關系(一個對象含有另一個對象的一些屬性)：
|
1
2
3
4
5
6
7
|
public class Car{}public class Speed{}public class Benz extends Car{ private Speed sp; } |
Benz含有Spend屬性，但Benz不是Spend
七、多態：
實現多態的三個必要條件：繼承、重寫、父類引用指向子類對象。
1). 向上轉型：
我們實例化一個Dog對象可以用 Dog d = new Dog(); 我們也可以用 Animal d = new Dog(); ，后者就是向上轉型(父引用指向子對象)，上面兩種方式創建出來的對象d，調用d.eat();輸出的結果都是Dog eating...，這就體現出了java得多態。向上轉型創建的對象會遺失掉和父類不同的方法和變量(不能用來調用子類特有的方法和變量)。
2). 舉例說明：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
class A { public String show(D obj) { return ("A and D"); } public String show(A obj) { return ("A and A"); }}class B extends A { public String show(B obj) { return ("B and B"); } public String show(A obj) { return ("B and A"); }}class C extends B {}class D extends B {}class Test { public static void main(String[] args) { A a1 = new A(); A a2 = new B(); B b = new B(); C c = new C(); D d = new D(); System.out.println(a1.show(b)); // ① System.out.println(a1.show(c)); // ② System.out.println(a1.show(d)); // ③ System.out.println(a2.show(b)); // ④ System.out.println(a2.show(c)); // ⑤ System.out.println(a2.show(d)); // ⑥ System.out.println(b.show(b)); // ⑦ System.out.println(b.show(c)); // ⑧ System.out.println(b.show(d)); // ⑨ }} |
輸出結果：
A and A // ①
A and A // ②
A and D // ③
B and A // ④
B and A // ⑤
A and D // ⑥
B and B // ⑦
B and B // ⑧
A and D // ⑨
前三個比較簡單不容易出錯，看看下面幾個：
-
④：a2是A的引用指向B對象，向上轉型創建的對象會遺失掉和父類不同的方法和變量，所以a2只能調用
show(D obj)、show(A obj)兩個方法，所以a2.show(b)應該調用show(A obj)方法，B中重寫了該方法，所以運行時JVM會調用B類中重寫的show(A obj)方法，所以輸出B and A； - ⑤: 原理同④；
-
⑥：
a2.show(d)應該調用show(D obj)方法，B中沒有重寫該方法所以調用的為A類中的該方法，所以輸出為A and D; -
⑦⑧⑨：b為B類對象，可調用A類中
show(D obj)、B類中show(B obj)、B類中show(A obj)方法，所以輸出如上。
總結
以上就是關于Java面向對象知識點整理的全部內容了，希望本文的內容對大家學習或者使用java能帶來一定的幫助，如果有疑問大家可以留言交流。
原文鏈接：http://www.jianshu.com/p/3f0b40860a1d
