1. 面向抽象原則

1.1 抽象類

特點：

        1.抽象類中的abstract方法可有可無，也可以有非abstract方法

        2.抽象類不能用new建立物件

        3.抽象類的非抽象子類必須重寫父類的abstract方法

        4.作為向上轉型物件。抽象類不能建立物件，但可以讓抽象類的物件成為其非抽象子類的向上轉型物件，呼叫子類的方法

1. abstractclass A {  
2.     publicabstractint add(int x,int y);  
3. }  
4. class B extends A {  
5.     publicint add(int x, int y) {  
6.         return x+y;  
7.     }  
8. }  
9. publicclass App {  
10.     publicstaticvoid main(String[] args) {  
11.         A a = new B();  
12.         System.out.println(a.add(3, 4));  
13.     }  
14. }  

1.2 介面

        1.介面中只能有public許可權的abstract方法，不能有非abstract方法

        2.介面由類去實現，並且必須重寫介面中的abstract方法

        3.介面回撥。把實現介面的類的物件的引用賦給該介面宣告的介面變數，那麼此介面變數就可以呼叫被類實現的介面中的方法

1. interface Com {  
2.     publicabstractint sub(int x,int y);  
3. }  
4. class ComImp implements Com {  
5.     publicint sub(int x, int y) {  
6.         return x-y;  
7.     }  
8. }  
9. publicclass App {  
10.     publicstaticvoid main(String[] args) {  
11.         Com com = new ComImp();  
12.         System.out.println(com.sub(3, 4));  
13.     }  
14. }  

1.3 面向抽象

        例如，現在有一個Circle類，有一個getArea()方法計算圓的面積：

Circle.Java

1. publicclass Circle {  
2.     double r;  
3.     Circle(double r) {  
4.         this.r = r;  
5.     }  
6.     publicdouble getArea() {  
7.         return(3.14*r*r);  
8.     }  
9. }  

        現在要設計一個Pillar類（柱體類），有一個getVolume方法計算體積

Pillar.java

1. publicclass Pillar {  
2.     Circle bottom;  //將Circle物件作為成員
3.     double height;  
4.     public Pillar(Circle bottom, double height) {  
5.         this.bottom = bottom;  
6.         this.height = height;  
7.     }  
8.     publicdouble getVolume() {  
9.         return bottom.getArea()*height;  
10.     }  
11. }  

        因此需要重新設計Pillar類，這時不需要關心底是什麼形狀，而應該關心底是否有計算面積的方法。所以底不應該是某個具體類宣告的變數，這樣才能應對不同的需求。

接下來重新設計PIllar類。 首先設計一個抽象類（或介面）Geometry(幾何)，有一個抽象的getArea()方法。

Geometry.java

1. publicabstractclass Geometry {  
2.     publicabstractdouble getArea();  
3. }  

Pillar.java

1. publicclass Pillar {  
2.     Geometry bottom;    //bottom是抽象類Geometry宣告的變數
3.     double height;  
4.     public Pillar(Geometry bottom, double height) {  
5.         this.bottom = bottom;  
6.         this.height = height;  
7.     }  
8.     publicdouble getVolume() {  
9.         return bottom.getArea()*height;  
10.     }  
11. }  

Circle.java

1. publicclass Circle extends Geometry  {  
2.     double r;  
3.     Circle(double r) {  
4.         this.r = r;  
5.     }  
6.     publicdouble getArea() {  
7.         return(3.14*r*r);  
8.     }  
9. }  

Rectangle.java

1. publicclass Rectangle extends Geometry {  
2.     double length;  
3.     double width;  
4.     public Rectangle(double length, double width) {  
5.         this.length = length;  
6.         this.width = width;  
7.     }  
8.     publicdouble getArea() {  
9.         return length*width;  
10.     }  
11. }  

        現在就可以用Pillar建立具有矩形底或圓形底的柱體了。

App.java

1. publicclass App {  
2.     publicstaticvoid main(String[] args) {  
3.         Pillar pillar;  
4.         Geometry bottom;  
5.         bottom = new Rectangle(100, 50);  
6.         pillar = new Pillar(bottom, 50);  
7.         System.out.println("矩形底的柱體的體積：" + pillar.getVolume());  
8.         bottom = new Circle(50);  
9.         pillar = new Pillar(bottom, 50);  
10.         System.out.println("圓形底的柱體的體積：" + pillar.getVolume());  
11.     }  
12. }  

        通過面向抽象來設計Pillar類，使得Pillar類不再依賴具體類，因此每當系統增加Geometry的子類時，比如增加一個Triabgle子類，那麼不需要修改Pillar類的任何程式碼，就可以使用Pillar創建出具有三角形底的柱體。

2. 開-閉原則

        所謂“開-閉原則“（Open-Closed Principle）就是讓設計對擴充套件開放，對修改關閉。本質就