浅析JAVA设计模式（三）

4、接口隔离原则: ISP(Interface Segregation Principle)  客户端不应该依赖它不需要的接口，或者说类的依赖的关系应该建立在最小的接口上。举个例子，直接上代码：

 1  interface I {
 2      public  void method1();
 3      public  void method2();
 4      public  void method3();
 5      public  void method4();
 6      public  void method5();
 7 }
 8 
 9  class A{
10      public  void depend1(I i){
11         i.method1();
12     }
13      public  void depend2(I i){
14         i.method2();
15     }
16      public  void depend3(I i){
17         i.method3();
18     }
19 }
20 
21  class B  implements I{
22      public  void method1() {
23         System.out.println("类B实现接口I的方法1");
24     }
25      public  void method2() {
26         System.out.println("类B实现接口I的方法2");
27     }
28      public  void method3() {
29         System.out.println("类B实现接口I的方法3");
30     }
31      // 对于类B来说，method4和method5不是必需的，但是由于接口A中有这两个方法，
32       // 所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。
33       public  void method4() {}
34      public  void method5() {}
35 }
36 
37  class C{
38      public  void depend1(I i){
39         i.method1();
40     }
41      public  void depend2(I i){
42         i.method4();
43     }
44      public  void depend3(I i){
45         i.method5();
46     }
47 }
48 
49  class D  implements I{
50      public  void method1() {
51         System.out.println("类D实现接口I的方法1");
52     }
53      // 对于类D来说，method2和method3不是必需的，但是由于接口A中有这两个方法，
54       // 所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。
55       public  void method2() {}
56      public  void method3() {}
57 
58      public  void method4() {
59         System.out.println("类D实现接口I的方法4");
60     }
61      public  void method5() {
62         System.out.println("类D实现接口I的方法5");
63     }
64 }
65 
66  public  class Client{
67      public  static  void main(String[] args){
68         A a =  new A();
69         a.depend1( new B());
70         a.depend2( new B());
71         a.depend3( new B());
72         
73         C c =  new C();
74         c.depend1( new D());
75         c.depend2( new D());
76         c.depend3( new D());
77     }

  相信大家也看出来了接口I太过臃肿了，实际开发中我们应该尽可能的避免这种现象出现。接口定义尽量细化。针对上面的问题，我们可以采用接口隔离来进行解决接口臃肿的问题。

 改造后代码：

 1  interface I1 {
 2      public  void method1();
 3 }
 4 
 5  interface I2 {
 6      public  void method2();
 7      public  void method3();
 8 }
 9 
10  interface I3 {
11      public  void method4();
12      public  void method5();
13 }
14 
15  class A{
16      public  void depend1(I1 i){
17         i.method1();
18     }
19      public  void depend2(I2 i){
20         i.method2();
21     }
22      public  void depend3(I2 i){
23         i.method3();
24     }
25 }
26 
27  class B  implements I1, I2{
28      public  void method1() {
29         System.out.println("类B实现接口I1的方法1");
30     }
31      public  void method2() {
32         System.out.println("类B实现接口I2的方法2");
33     }
34      public  void method3() {
35         System.out.println("类B实现接口I2的方法3");
36     }
37 }
38 
39  class C{
40      public  void depend1(I1 i){
41         i.method1();
42     }
43      public  void depend2(I3 i){
44         i.method4();
45     }
46      public  void depend3(I3 i){
47         i.method5();
48     }
49 }
50 
51  class D  implements I1, I3{
52      public  void method1() {
53         System.out.println("类D实现接口I1的方法1");
54     }
55      public  void method4() {
56         System.out.println("类D实现接口I3的方法4");
57     }
58      public  void method5() {
59         System.out.println("类D实现接口I3的方法5");
60     }

61 } 

 将I接口细化为I1,I2,I3,这样在对这三个接口进行实现的时候，就不会出现多余的方法去实现而不进行任何操作的现象。注意：在对接口进行细化的时候，我们要求做到尽量和依赖类的业务保持一致。我的理解是，尽量不要违背单一职责原则。虽然与单一职责原则相似，但与单一职责不同的是，单一职责注重职责，而接口隔离原则更注重接口的依赖隔离。其次单一职责原则更注重的是约束类，然后再是接口和方法，接口隔离更注重约束接口，对程序架构的构建。

采用接口隔离原则注意几点：

1.接口尽量小，但是要有限度，过度小会造成接口繁多。

2.为依赖的类定制服务，不把依赖类不需要的方法暴露出来。

3.提高内聚，不要过多的与外交互。

5、迪米特法则 :LOD(Law Of  Demeter ) 一个类应该对自己需要耦合或者调用的类知道的最少，被调用的类内部是怎么实现的，调用者不需要关心，只需要提供者提供了这些方法，能供调用就可以。

下面这个看下老师点名的例子，这个例子讲的挺通俗的，时间关系我在这就不做重复举例了： http://blog.csdn.net/lajiooo/article/details/6365239

 

6、开闭原则:OCP(Open Close Principle) 解释为一个软件实体应该通过扩展来实现变化，而不是通过修改已有的代码来实现变化。

开闭原则是一个非常虚的原则，前面5个原则是对开闭原则的具体解释 。用一个我在《设计模式之禅（第二版）》第45页的书店的一个例子讲解下：

public  interface IBook {
     public String getName();
     public  int getPrice();
     public String getAuthor();
}
public  class NovelBook  implements IBook {
     private String name;
     private  int price;
     private String author;
    
     public NovelBook(String name,  int price, String author) {
         this.name = name;
         this.price = price;
         this.author = author;
    }

    @Override
     public String getName() {
         return name;
    }

    @Override
     public  int getPrice() {
         return price;
    }

    @Override
     public String getAuthor() {
         return author;
    }
}
public  class BookStore {
     private  final  static ArrayList<IBook> bookList= new ArrayList<IBook>();
     static{
        bookList.add( new NovelBook("天龙八部",3200,"金庸"));
        bookList.add( new NovelBook("巴黎圣母院",5600,"雨果"));
        bookList.add( new NovelBook("悲惨世界",3500,"雨果"));
        bookList.add( new NovelBook("梅",4300,"兰陵笑笑生"));
    }
     public  static  void main(String[] args) {
        NumberFormat formatter=NumberFormat.getCurrencyInstance();
        formatter.setMaximumFractionDigits(2);
        System.out.println("书店卖出去的书籍记录如下：");
         for(IBook book:bookList){
            System.out.println("书籍名称："+book.getName()+
                             "\t书籍作者："+book.getAuthor()+
                             "\t书籍价格："+formatter.format(book.getPrice()/100.0)+"元");
        }
    }

} 

 项目已经投产了，但是现在有一个需求，就是所有40元以上的书籍9折销售，其他的书籍8折销售，该怎么去修改程序呢？我想肯定我们不能去修改接口吧，接口是对外的契约，如果修改接口，那要改的地方实在太多了，风险忒大。最直接的想法可能就是直接去修改getPrice()这个方法，这是一个好主意，但是有一个不好的地方，就是修改getPrice()方法之后，显示出来的是打折之后的价格，原来的价格是显示不出来的，这样就没有对比性了，有没有更好的办法呢？这里，让我们来体验一次开闭原则的好处，通过扩展来实现变化，新增了一个OffNovelBook类，继承自NovelBook，并且重写了getPrice()方法，用这个类来处理打折的小说类书籍，不修改原来的代码。新增的类的代码如下：

 

 1  public  class OffNovelBook  extends NovelBook {
 2 
 3      public OffNovelBook(String name,  int price, String author) {
 4          super(name, price, author);
 5     }
 6 
 7     @Override
 8      public  int getPrice() {
 9          int selfPrice= super.getPrice(); // 原价
10          
11          int offPrice=0; // 打折之后的价格，初始化为0
12           if(selfPrice>4000){
13             offPrice=selfPrice * 90 / 100;
14         }
15          else{
16             offPrice=selfPrice * 80 / 100;
17         }
18         
19          return offPrice;
20     }
21 }
22  public  class BookStore {
23      private  final  static ArrayList<IBook> bookList= new ArrayList<IBook>();
24      static{
25         bookList.add( new OffNovelBook("天龙八部",3200,"金庸"));
26         bookList.add( new OffNovelBook("巴黎圣母院",5600,"雨果"));
27         bookList.add( new OffNovelBook("悲惨世界",3500,"雨果"));
28         bookList.add( new OffNovelBook("梅",4300,"兰陵笑笑生"));
29     }
30      public  static  void main(String[] args) {
31         NumberFormat formatter=NumberFormat.getCurrencyInstance();
32         formatter.setMaximumFractionDigits(2);
33         System.out.println("书店卖出去的书籍记录如下：");
34          for(IBook book:bookList){
35             System.out.println("书籍名称："+book.getName()+
36                              "\t书籍作者："+book.getAuthor()+
37                              "\t书籍价格："+formatter.format(book.getPrice()/100.0)+"元");
38         }
39     }
40 
41 }    

上面的例子可以很清晰的让我们了解开闭原则定义。

 

持续更新中........