abstract , interface

1. // 抽象類
2. abstractclassAbc{
3. // 抽象類中的抽象方法
4. publicabstractvoid setData(int i);
5. publicvoidPrint(){
6. // 呼叫了抽象方法
7. setData(100);
8. }
9. }
10. // 該類繼承抽象類
11. classBcdextendsAbc{
12. @Override
13. publicvoid setData(int i){
14. System.out.print(i);
15. }
16. }
17. // 主類
18. classMain{
19. // 主方法
20. publicMain(){
21. // 繼承抽象類的類必須實現抽象方法
22. // 除非繼承抽象類的型別也是抽象類
23. Bcd bcd =newBcd();
24. bcd
    .Print();
25. }
26. // 另外一種情況
27. // 實現抽象類的時,必須實現類中抽象方法
28. Abc abc =newAbc(){
29. @Override
30. publicvoid setData(int i){
31. System.out.print(i);
32. }
33. };
34. }

1. // 抽象類
2. abstractclassServer{
3. privateint port;
4. // 抽象類中的抽象方法
5. publicabstractvoid failure(String data);
6. publicabstractvoid success(int code);
7. publicvoid start(){
8. // ... start ...
9. if(true|false){
10. success
    (String data);
11. }else{
12. failuer(int code);
13. }
14. }
15. }
16. // 主類
17. classMain{
18. publicMain(){
19. Server server =newServer(){
20. @Override
21. publicvoid success(String data){
22. System.out.print(data)
23. }
24. @Override
25. publicvoid failure(int code){
26. System.out.print(code)
27. }
28. };
29. server.start();
30. }
31. }

abstract class和interface在Java語言中都是用來進行抽象類定義.

使用abstract class的方式定義Demo抽象類的方式如下：

1. abstractclassDemo｛
2. abstractvoid method1();
3. abstractvoid method2();
4. …
5. ｝

使用interface的方式定義Demo抽象類的方式如下：

1. interfaceDemo{
2. void method1();
3. void method2();
4. …
5. }

在abstract class方式中，Demo可以有自己的資料成員，也可以有非abstarct的成員方法

而在interface方式的實現中，Demo只能夠有靜態的不能被修改的資料成員（也就是必須是static final的）

所有的成員方法都是abstract的。從某種意義上說，interface是一種特殊形式的abstract class。

考慮這樣一個例子，假設在我們的問題領域中有一個關於Door的抽象概念，該Door具有執行兩個動作open和close

此時我們可以通過abstract class或者interface來定義一個表示該抽象概念的型別，定義方式分別如下所示：

使用abstract class方式定義Door：

1. abstractclassDoor{
2. abstractvoid open();
3. abstractvoid close()；
4. }

使用interface方式定義Door：

1. interfaceDoor{
2. void open();
3. void close();
4. }

其他具體的Door型別可以extends使用abstract class方式定義的Door或者implements使用interface方式定義的Door。

看起來好像使用abstract class和interface沒有大的區別。

如果現在要求Door還要具有報警的功能。我們該如何設計針對該例子的類結構呢

解決方案一：

簡單的在Door的定義中增加一個alarm方法，如下：

1. abstractclassDoor{
2. abstractvoid open();
3. abstractvoid close()；
4. abstractvoid alarm();
5. }

1. 或者

1. interfaceDoor{
2. void open();
3. void close();
4. void alarm();
5. }

那麼具有報警功能的AlarmDoor的定義方式如下：

1. classAlarmDoorextendsDoor{
2. void open(){…}
3. void close(){…}
4. void alarm(){…}
5. }

1. 或者

1. classAlarmDoorimplementsDoor｛
2. void open(){…}
3. void close(){…}
4. void alarm(){…}
5. ｝

這種方法違反了面向物件設計中的一個核心原則ISP（Interface Segregation Priciple）

在Door的定義中把Door概念本身固有的行為方法和另外一個概念”報警器”的行為方法混在了一起。

這樣引起的一個問題是那些僅僅依賴於Door這個概念的模組會因為”報警器”這個概念的改變而改變，反之依然。

解決方案二：

既然open、close和alarm屬於兩個不同的概念，根據ISP原則應該把它們分別定義在代表這兩個概念的抽象類中。

定義方式有：這兩個概念都使用abstract class方式定義；

兩個概念都使用interface方式定義；一個概念使用abstract class方式定義，另一個概念使用interface方式定義。

方式定義。如下所示：

1. abstractclassDoor{
2. abstractvoid open();
3. abstractvoid close()；
4. }
5. interfaceAlarm{
6. void alarm();
7. }
8. classAlarmDoorextendsDoorimplementsAlarm{
9. void open(){…}
10. void close(){…}
11. void alarm(){…}
12. }

這種實現方式基本上能夠明確的反映出我們對於問題領域的理解，正確的揭示我們的設計意圖。

其實abstract class表示的是”is a”關係, interface表示的是”like a”關係，大家在選擇時可以作為一個依據

abstract class和interface是Java語言中的兩種定義抽象類的方式，它們之間有很大的相似性。

但是對於它們的選擇卻又往往反映出對於問題領域中的概念本質的理解

對於設計意圖的反映是否正確、合理，因為它們表現了概念間的不同的關係（雖然都能夠實現需求的功能）。

這其實也是語言的一種的慣用法，希望讀者朋友能夠細細體會。