Java程序用抽象類(abstract class)來實現自然界的抽象概念。抽象類的作用在于將許多有關的類組織在一起，提供一個公共的類，即抽象類，而那些被它組織在一起的具體的類將作為它的子類由它派生出來。抽象類刻畫了公有行為的特征，并通過繼承機制傳送給它的派生類。在抽象類中定義的方法稱為抽象方法，這些方法只有方法頭的聲明，而用一個分號來代替方法體的定義，即只定義成員方法的接口形式，而沒有具體操作。只有派生類對抽象成員方法的重定義才真正實現與該派生類相關的操作。
在各子類繼承了父類的抽象方法之后，再分別用不同的語句和方法體來重新定義它，形成若干個名字相同，返回值相同，參數列表也相同，目的一致但是具體實現有一定差別的方法。抽象類中定義抽象方法的目的是實現一個接口，即所有的子類對外都呈現一個相同名字的方法。抽象類是它的所有子類的公共屬性的集合，是包含一個或多個抽象方法的類。使用抽象類的一大優點就是可以充分利用這些公共屬性來提高開發和維護程序的效率。對于抽象類與抽象方法的限制如下：
（1）凡是用abstract 修飾符修飾的類被稱為抽象類。凡是用abstract修飾符修飾的成員方法被稱為抽象方法。
（2）抽象類中可以有零個或多個抽象方法，也可以包含非抽象的方法。
（3）抽象類中可以沒有抽象方法，但是，有抽象方法的類必須是抽象類。
（4）對于抽象方法來說，在抽象類中只指定其方法名及其類型，而不書寫其實現代碼。
（5）抽象類可以派生子類，在抽象類派生的子類中必須實現抽象類中定義的所有抽象方法。
（6）抽象類不能創建對象，創建對象的工作由抽象類派生的子類來實現。
（7）如果父類中已有同名的abstract方法，則子類中就不能再有同名的抽象方法。
（8）abstract不能與final并列修飾同一個類。
（9）abstract 不能與private、static、final或native并列修飾同一個方法。
Java語言規定，當一個類里面有抽象方法的時候，這個類必須被聲明為抽象類。
子類繼承父類時，如果這個父類里面有抽象方法，并且子類覺得可以去實現父類的所有抽象方法，那么子類必須去實現父類的所有抽象方法，如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
/** * 子類Dog繼承抽象類Animal，并且實現了抽象方法enjoy * @author gacl * */class Dog extends Animal { /** * Dog類添加自己特有的屬性 */ public String furColor; public Dog(String n, String c) { super(n);//調用父類Animal的構造方法 this.furColor = c; } @Override public void enjoy() { System.out.println("狗叫...."); }} |
這個父類里面的抽象方法，子類如果覺得實現不了，那么把就子類也聲明成一個抽象類，如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
/** * 這里的子類Cat從抽象類Animal繼承下來，自然也繼承了Animal類里面聲明的抽象方法enjoy()， * 但子類Cat覺得自己去實現這個enjoy()方法也不合適，因此它把它自己也聲明成一個抽象的類， * 那么，誰去實現這個抽象的enjoy方法，誰繼承了子類，那誰就去實現這個抽象方法enjoy()。 * @author gacl * */abstract class Cat extends Animal { /** * Cat添加自己獨有的屬性 */ public String eyeColor; public Cat(String n, String c) { super(n);//調用父類Animal的構造方法 this.eyeColor = c; }} |
這里的子類Cat從抽象類Animal繼承下來，自然也繼承了Animal類里面聲明的抽象方法enjoy()，但子類Cat覺得自己去實現這個enjoy()方法也不合適，因此它把它自己也聲明成一個抽象的類，那么，誰去實現這個抽象的enjoy方法，誰繼承了子類，那誰就去實現這個抽象方法enjoy()。如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/** * 子類BlueCat繼承抽象類Cat，并且實現了從父類Cat繼承下來的抽象方法enjoy * @author gacl * */class BlueCat extends Cat { public BlueCat(String n, String c) { super(n, c); } /** * 實現了抽象方法enjoy */ @Override public void enjoy() { System.out.println("藍貓叫..."); } } |
完整的測試代碼如下：
|
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
|
package javastudy.summary;/** * 父類Animal * 在class的前面加上abstract，即聲明成這樣：abstract class Animal * 這樣Animal類就成了一個抽象類了 */abstract class Animal { public String name; public Animal(String name) { this.name = name; } /** * 抽象方法 * 這里只有方法的定義，沒有方法的實現。 */ public abstract void enjoy(); }/** * 這里的子類Cat從抽象類Animal繼承下來，自然也繼承了Animal類里面聲明的抽象方法enjoy()， * 但子類Cat覺得自己去實現這個enjoy()方法也不合適，因此它把它自己也聲明成一個抽象的類， * 那么，誰去實現這個抽象的enjoy方法，誰繼承了子類，那誰就去實現這個抽象方法enjoy()。 * @author gacl * */abstract class Cat extends Animal { /** * Cat添加自己獨有的屬性 */ public String eyeColor; public Cat(String n, String c) { super(n);//調用父類Animal的構造方法 this.eyeColor = c; }}/** * 子類BlueCat繼承抽象類Cat，并且實現了從父類Cat繼承下來的抽象方法enjoy * @author gacl * */class BlueCat extends Cat { public BlueCat(String n, String c) { super(n, c); } /** * 實現了抽象方法enjoy */ @Override public void enjoy() { System.out.println("藍貓叫..."); } }/** * 子類Dog繼承抽象類Animal，并且實現了抽象方法enjoy * @author gacl * */class Dog extends Animal { /** * Dog類添加自己特有的屬性 */ public String furColor; public Dog(String n, String c) { super(n);//調用父類Animal的構造方法 this.furColor = c; } @Override public void enjoy() { System.out.println("狗叫...."); }}public class TestAbstract { /** * @param args */ public static void main(String[] args) { /** * 把Cat類聲明成一個抽象類以后，就不能再對Cat類進行實例化了， * 因為抽象類是殘缺不全的，缺胳膊少腿的，因此抽象類不能被實例化。 */ //Cat c = new Cat("Catname","blue"); Dog d = new Dog("dogname","black"); d.enjoy();//調用自己實現了的enjoy方法 BlueCat c = new BlueCat("BlueCatname","blue"); c.enjoy();//調用自己實現了的enjoy方法 }} |
