什么是繼承？
多個類中存在相同屬性和行為時，將這些內容抽取到單獨一個類中，那么多個類無需再定義這些屬性和行為，只要繼承那個類即可。
多個類可以稱為子類，單獨這個類稱為父類、超類或者基類。
子類可以直接訪問父類中的非私有的屬性和行為。
通過 extends 關鍵字讓類與類之間產生繼承關系。
class SubDemo extends Demo{} //SubDemo是子類，Demo是父類
繼承有什么好處？
•提高代碼的復用性。
•讓類與類之間產生了關系，是多態的前提。
繼承的特點
1、Java只支持單繼承，不支持多繼承。
|
1
2
3
|
//一個類只能有一個父類，不可以有多個父類。class SubDemo extends Demo{} //okclass SubDemo extends Demo1,Demo2...//error |
2.Java支持多層（重）繼承(繼承體系)。
|
1
2
3
|
class A{}class B extends A{}class C extends B{} |
使用繼承時的注意事項
•如果類之間存在著：is a 的關系，就可以考慮使用繼承。
•不要為了繼承部分功能，而去使用繼承。
super和this有什么區別？
super是一個關鍵字，代表父類的存儲空間標識。(可以理解為父親的引用)
super和this的用法相似。
this代表對象的引用(誰調用就代表誰)；
super代表當前子類對父類的引用。
使用場景
•當子父類出現同名成員時，可以用super進行區分；
•子類要調用父類構造函數時，可以使用super語句。
區別
1.成員變量
this.變量 -- 本類的
super.變量 -- 父類的
2.構造方法
this(...) -- 本類的
super(...) -- 父類的
3.成員方法
this.方法名() -- 本類的
super.方法名() -- 父類的
super();和this();都是在構造函數的第一行，不能同時出現。
方法的重寫（覆蓋）
子類中出現與父類一模一樣的方法時（除了權限修飾符，權限修飾符大于等于不包括private，返回值類型，方法名和參數列表相同），會出現覆蓋操作，也稱為重寫或者復寫。
父類私有方法，子類看不到，因此父類私有方法的重寫也就無從談起。
覆蓋注意事項：
•覆蓋時，子類方法權限一定要大于等于父類方法權限；
•靜態只能覆蓋靜態。
覆蓋的使用場景：
當子類需要父類的功能，而功能主體子類有自己特有內容時，可以復寫父類中的方法，這樣，既沿襲了父類的功能，又定義了子類特有的內容。
方法重寫和重載有什么區別？
方法的重寫用在子類方法與父類方法一模一樣時，除權限修飾符，返回值類型，方法名和參數列表都是相同的。
重載用在同一個類中各方法方法名相同，參數列表不同（與返回值類型沒有關系）的情況。
子父類中構造方法的用法：
1.子類的初始化過程中，首先回去執行父類的初始化動作。因為子類的構造方法中默認有一個super()。子類要使用父類的成員變量，這個初始化，必須在子類初始化之前完成。所以，子類的初始化過程中，會先執行父類的初始化。
2.如果父類沒有無參構造方法
•使用super調用父類的帶參構造。推薦方式。
•使用this調用本身的其他構造。
靜態代碼塊、構造代碼塊，構造方法的執行順序：
父類靜態代碼塊→子類靜態代碼塊→父類構造代碼塊→父類構造方法→子類構造代碼塊→子類構造方法
final關鍵字
final是一個關鍵字，可以用于修飾類，成員變量，成員方法。
特點：
它修飾的類不能被繼承。
它修飾的成員變量是一個常量。
它修飾的成員方法是不能被子類重寫的。
final修飾的常量定義一般都有書寫規范,被final修飾的常量名稱,所有字母都大寫。
final修飾成員變量,必須初始化,初始化有兩種
顯示初始化；
構造方法初始化。
但是不能兩個一起初始化
final和private的區別：
final修飾的類可以訪問；
private不可以修飾外部類，但可以修飾內部類（其實把外部類私有化是沒有意義的）。
final修飾的方法不可以被子類重寫；
private修飾的方法表面上看是可以被子類重寫的，其實不可以，子類是看不到父類的私有方法的。
final修飾的變量只能在顯示初始化或者構造函數初始化的時候賦值一次，以后不允許更改；
private修飾的變量，也不允許直接被子類或一個包中的其它類訪問或修改，但是他可以通過set和get方法對其改值和取值。
多態
概念：
對象在不同時刻表現出來的不同狀態。
多態的前提：
要有繼承或者實現關系。
要有方法的重寫。
要有父類引用指向子類對象。
程序中的體現：
父類或者接口的引用指向或者接收自己的子類對象。
好處和作用：
多態的存在提高了程序的擴展性和后期可維護性。
弊端：
父類調用的時候只能調用父類里的方法，不能調用子類的特有方法，因為你并不清楚將來會有什么樣的子類繼承你。
多態的成員特點：
成員變量：編譯時期：看引用型變量所屬的類中是否有所調用的變量；
運行時期：也是看引用型變量所屬的類是否有調用的變量。
成員變量無論編譯還是運行都看引用型變量所屬的類，簡單記成員變量，編譯和運行都看等號左邊。
成員方法：編譯時期：要查看引用變量所屬的類中是否有所調用的成員；
運行時期：要查看對象所屬的類中是否有所調用的成員。如果父子出現同名的方法,會運行子類中的方法,因為方法有覆蓋的特性。
編譯看左邊運行看右邊。
靜態方法:編譯時期：看的引用型變量所屬的類中是否有所調用的變量；
運行時期：也是看引用型變量所屬的類是否有調用的變量。
編譯和運行都看等號左邊。
一定不能夠將父類的對象轉換成子類類型！
父類的引用指向子類對象，該引用可以被提升，也可以被強制轉換。
多態自始至終都是子類對象在變化！
|
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
43
44
45
46
47
48
49
50
51
52
53
|
//多態向下轉型和向上轉型的例子，多態轉型解決了多態中父類引用不能使用子類特有成員的弊端。class PolymorphicTest2 { public static void main(String[] args) { Phone p1 = new Nokia(); //向上轉型，類型提升 Nokia no = (Nokia)p1; //向下轉型，強制將父類的引用轉換成子類類型，不能將Nokia類型轉成Moto或Nexus類型 no.print(); //輸出結果為Phone---null---0，因為繼承了父類的方法 Phone p2 = new Moto(); Moto m = (Moto)p2; m.print(); //輸出結果為Moto---yellow---1599，方法重寫，子類方法覆蓋父類方法 Phone p3 = new Nexus(); Nexus ne = (Nexus)p3; ne.print(); }}class Phone{ String color; int price; public void print(){ System.out.println("Phone---" + color + "---" + price ); } }class Nokia extends Phone{ String color = "red"; int price = 1009; //public void print(){ // System.out.println("Nokia---" + color + "---" + price); //}}class Moto extends Phone{ String color = "yellow"; int price = 1599; public void print(){ System.out.println("Moto---" + color + "---" + price); }}class Nexus extends Phone{ String color = "black"; int price = 1999; public void print(){ System.out.println("Nexus---" + color + "---" + price); }}} |
抽象（abstract）
抽象就是從多個事物中將共性的，本質的內容抽象出來。
抽象類：
Java中可以定義沒有方法體的方法，該方法的具體實現由子類完成，該方法稱為抽象方法，包含抽象方法的類就是抽象類。
由來：
多個對象都具備相同的功能，但是功能具體內容有所不同，那么在抽取過程中，只抽取了功能定義，并未抽取功能主體，那么只有功能聲明，沒有功能主體的方法稱為抽象方法。
抽象類特點：
抽象方法一定在抽象類中；
抽象方法和抽象類都必須被abstract關鍵字修飾；
抽象類不可以用new創建對象，因為調用抽象方法沒意義；
抽象類中的抽象方法要被使用，必須由子類復寫其所有的抽象方法后，建立子類對象調用； 如果子類只覆蓋了部分的抽象方法，那么該子類還是一個抽象類；
抽象類中可以有抽象方法，也可以有非抽象方法，抽象方法用于子類實例化；
如果一個類是抽象類，那么，繼承它的子類，要么是抽象類，要么重寫所有抽象方法。
特殊：抽象類中可以不定義抽象方法，這樣做僅僅是不讓該類建立對象。
抽象類的成員特點：
成員變量：可以是變量，也可以是常量；
構造方法：有構造方法；
成員方法：可以是抽象方法，也可以是非抽象方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
abstract class 葵花寶典 { public abstract void 自宮();}class 岳不群 extends 葵花寶典 { public void 自宮(){ System.out.println("剪刀"); }}class 林平之 extends 葵花寶典{ public void 自宮(){ System.out.println("指甲刀"); }}class AbstractTest { public static void main(String[] args) { 岳不群 岳 = new 岳不群(); 岳.自宮(); 林平之 林 = new 林平之(); 林.自宮(); }} |
抽象類注意事項：
抽象類不能被實例化，為什么還有構造函數？
只要是class定義的類里面就肯定有構造函數。抽象類中的函數是給子類實例化的。
一個類沒有抽象方法，為什么定義為抽象類?
不想被繼承，還不想被實例化。
抽象關鍵字abstract不可以和哪些關鍵字共存？
final：如果方法被抽象，就需要被覆蓋，而final是不可以被覆蓋，所以沖突。
private：如果函數被私有了，子類無法直接訪問，怎么覆蓋呢？
static：不需要對象，類名就可以調用抽象方法。而調用抽象方法沒有意義。
接口（interface）
接口是抽象方法和常量值的集合。從本質上講，接口是一種特殊的抽象類，這種抽象類只包含常量和方法的定義，而沒有變量和方法的實現。
格式：interface 接口名{}
接口的出現將”多繼承“通過另一種形式體現出來，即”多實現“。
實現（implements）
格式：class 類名 implements 接口名 {}
特點：
接口不能被實例化。
一個類如果實現了接口，要么是抽象類，要么實現接口中的所有方法。
接口的成員特點：
接口中的成員修飾符是固定的！
成員常量：public static final，接口里定義的變量是全局常量，而且修飾符只能是這三個關鍵字，都可以省略，常量名要大寫。
成員方法：public abstract，接口里定義的方法都是抽象的，兩個修飾符關鍵字可省略。
推薦：永遠手動給出修飾符。
繼承與實現的區別：
類與類之間稱為繼承關系：因為該類無論是抽象的還是非抽象的，它的內部都可以定義非抽象方法，這個方法可以直接被子類使用，子類繼承即可。只能單繼承，可以多層繼承。（(class)）
類與接口之間是實現關系：因為接口中的方法都是抽象的，必須由子類實現才可以實例化。可以單實現，也可以多實現；還可以在繼承一個類的同時實現多個接口。（(class) extends (class) implements (interface1,interface2…)）
接口與接口之間是繼承關系：一個接口可以繼承另一個接口，并添加新的屬性和抽象方法，并且接口可以多繼承。（(interface) extends (interface1,interface2…)）
抽象類和接口的區別：
成員變量
抽象類能有變量也可以有常量
接口只能有常量
成員方法
抽象類可以有非抽象的方法,也可以有抽象的方法
接口只能有抽象的方法
構造方法
-抽象類有構造方法
-接口沒有構造方法
類與抽象類和接口的關系
類與抽象類的關系是繼承 extends
類與接口的關系是實現 implements
接口的思想特點：
1.接口是對外暴露的規則；
2.接口是程序的功能擴展；
3.接口的出現降低耦合性；(實現了模塊化開發,定義好規則,每個人實現自己的模塊,大大提高了開發效率)
4.接口可以用來多實現；
5.多個無關的類可以實現同一個接口；
6.一個類可以實現多個相互直接沒有關系的接口；
7.與繼承關系類似，接口與實現類之間存在多態性。
|
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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
//運動員和教練的案例（下圖是思路分析）/* 籃球運動員和教練 乒乓球運動員和教練 現在籃球運動員和教練要出國訪問,需要學習英語 請根據你所學的知識,分析出來哪些是類,哪些是抽象類,哪些是接口*/interface SpeakEnglish { public abstract void speak();}interface GoAboard{ public abstract void aboard();}abstract class Person { private String name; private int age; public Person(){} public Person(String name,int age){ this.name = name; this.age = age; } public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setAge(int age){ this.age = age; } public int getAge(){ return age; } //吃飯 public abstract void eat(); //睡覺 public void sleep(){ System.out.println("Zzz..."); }}//運動員abstract class Player extends Person { public abstract void study();}//教練abstract class Coach extends Person { public abstract void teach();}//籃球運動員class BasketballPlayer extends Player implements SpeakEnglish,GoAboard{ public void eat(){ System.out.println(getAge() + "歲的" + getName() + "吃雞腿"); } public void study(){ System.out.println(getAge() + "歲的" + getName() + "學扣籃"); } public void speak(){ System.out.println(getAge() + "歲的" + getName() + " Say Hello World"); } public void aboard(){ System.out.println(getAge() + "歲的" + getName() + " Go Aboard"); }}//乒乓運動員class PingPangPlayer extends Player{ public void eat(){ System.out.println(getAge() + "歲的" + getName() + "吃雞蛋"); } public void study(){ System.out.println(getAge() + "歲的" + getName() + "學扣球"); }}//籃球教練class BasketballCoach extends Coach implements SpeakEnglish { public void eat(){ System.out.println(getAge() + "歲的" + getName() + "啃雞爪"); } public void teach(){ System.out.println(getAge() + "歲的" + getName() + "教扣籃"); } public void speak(){ System.out.println(getAge() + "歲的" + getName() + " Say Hello Java"); } public void aboard(){ System.out.println(getAge() + "歲的" + getName() + " Go Aboard"); }}//乒乓球教練class PingPangCoach extends Coach{ public void eat(){ System.out.println(getAge() + "歲的" + getName() + "吃雞蛋皮"); } public void teach(){ System.out.println(getAge() + "歲的" + getName() + "教扣球"); }}class PlayerAndCoach { public static void main(String[] args) { //籃球運動員 BasketballPlayer bp = new BasketballPlayer(); bp.setName("郭艾倫"); bp.setAge(33); bp.eat(); bp.sleep(); bp.study(); bp.speak(); bp.aboard(); System.out.println("***********************"); //籃球教練 BasketballCoach bc = new BasketballCoach(); bc.setName("波波維奇"); bc.setAge(65); bc.eat(); bc.sleep(); bc.teach(); bc.speak(); bc.aboard(); System.out.println("***********************"); //多態 Person p = new BasketballPlayer(); p.setName("Kobe Bryant"); p.setAge(33); p.eat(); p.sleep(); //p.study(); //p.speak(); BasketballPlayer bp2 = (BasketballPlayer)p; bp2.study(); bp2.speak(); bp2.aboard(); System.out.println("***********************"); }} |
內部類
將一個類定義在另一個類里面，里面的那個類就稱為內部類。內部類的出現，再次打破了Java單繼承的局限性。
訪問特點：
內部類可以直接訪問外部類的成員，包括私有成員。
外部類要訪問內部類的成員，必須要建立內部類的對象。
內部類分類及共性：
共性：
內部類仍然是一個獨立的類，在編譯之后會內部類會被編譯成獨立的.class文件，但是前面冠以外部類的類名和$符號。
內部類不能用普通的方式訪問。內部類是外部類的一個成員，因此內部類可以自由地訪問外部類的成員變量，無論是否是private的。
成員內部類
在外部類中有成員變量和成員方法，成員內部類就是把整個一個類作為了外部類的成員；
成員內部類是定義在類中方法外的類；
創建對象的格式為：外部類名.內部類名 對象名 = 外部類對象.內部類對象；
成員內部類之所以可以直接訪問外部類的成員，那是因為內部類中都持有一個外部類對象的引用：外部類名.this；
成員內部類可以用的修飾符有final，abstract，public，private，protected，static.
靜態內部類
靜態內部類就是成員內部類加上靜態修飾符static，定義在類中方法外。
在外部類中訪問靜態內部類有兩種場景：
在外部類中訪問靜態內部類中非靜態成員：*外部類名.內部類名 對象名 = 外部類名.內部對象*，需要通過創建對象訪問；
在外部類中訪問靜態內部類中的靜態成員：同樣可以使用上面的格式進行訪問，也可以直接使用外部類名.內部類名.成員。
局部內部類
局部內部類是定義在方法中的類。
方法內部類只能在定義該內部類的方法內實例化，不可以在此方法外對其實例化。
方法內部類對象不能使用該內部類所在方法的非final局部變量。
可以用于方法內部類的修飾符有final，abstract；
靜態方法中的方法內部類只能訪問外部的靜態成員。
匿名內部類
匿名內部類是內部類的簡化寫法，是建立一個帶內容的外部類或者接口的子類匿名對象。
前提：
內部類可以繼承或實現一個外部類或者接口。
格式：
new 外部類名或者接口名(){重寫方法};
通常在方法的形式參數是接口或者抽象類，并且該接口中的方法不超過三個時，可以將匿名內部類作為參數傳遞。
不同修飾符修飾的內容(和內部類無關)
| 類 | 成員變量 | 成員方法 | 構造方法 | |
|---|---|---|---|---|
| private | Y | Y | Y | |
| 默認 | Y | Y | Y | Y |
| protected | Y | Y | Y | |
| public | Y | Y | Y | Y |
| abstract | Y | Y | ||
| static | Y | Y | Y | |
| final | Y | Y | Y |
注意，常見規則如下：
•以后，所有的類都用public修飾。并且，在一個java文件中，只寫一個類。
•以后，所有的成員變量用private修飾。
•以后，所有的成員方法用public修飾。
如果是抽象類或者接口：public abstract + …
•以后，所有的構造方法用public修飾。
如果類是工具類或者單例類：構造用private修飾
四種權限修飾符
| 本類 | 同包（無關類或子類） | 不同包（子類） | 不同包（無關類） | |
|---|---|---|---|---|
| private | Y | |||
| 默認 | Y | Y | ||
| protected | Y | Y | Y | |
| public | Y | Y | Y | Y |
推薦：
•成員變量 private
•構造方法 public
•成員方法 public
以上這篇淺談java 面對對象(抽象 繼承 接口 多態)就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持服務器之家。
