浅析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{

     public void depend1(I i){

         i.method1();

     }

     public void depend2(I i){

         i.method2();

     }

     public void depend3(I i){

         i.method3();

     }

 }

 

 class B implements I{

     public void method1() {

         System.out.println("类B实现接口I的方法1");

     }

     public void method2() {

         System.out.println("类B实现接口I的方法2");

     }

     public void method3() {

         System.out.println("类B实现接口I的方法3");

     }

     //对于类B来说，method4和method5不是必需的，但是由于接口A中有这两个方法，

     //所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。

     public void method4() {}

     public void method5() {}

 }

 

 class C{

     public void depend1(I i){

         i.method1();

     }

     public void depend2(I i){

         i.method4();

     }

     public void depend3(I i){

         i.method5();

     }

 }

 

 class D implements I{

     public void method1() {

         System.out.println("类D实现接口I的方法1");

     }

     //对于类D来说，method2和method3不是必需的，但是由于接口A中有这两个方法，

     //所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。

     public void method2() {}

     public void method3() {}

 

     public void method4() {

         System.out.println("类D实现接口I的方法4");

     }

     public void method5() {

         System.out.println("类D实现接口I的方法5");

     }

 }

 

 public class Client{

     public static void main(String[] args){

         A a = new A();

         a.depend1(new B());

         a.depend2(new B());

         a.depend3(new B());

         

         C c = new C();

         c.depend1(new D());

         c.depend2(new D());

         c.depend3(new D());

     }

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

 改造后代码：

 1 interface I1 {
 2     public void method1();
 3 }
 4 
 5 interface I2 {
 6     public void method2();
 7     public void method3();
 8 }
 9 
 interface I3 {
     public void method4();
     public void method5();
 }
 
 class A{
     public void depend1(I1 i){
         i.method1();
     }
     public void depend2(I2 i){
         i.method2();
     }
     public void depend3(I2 i){
         i.method3();
     }
 }
 
 class B implements I1, I2{
     public void method1() {
         System.out.println("类B实现接口I1的方法1");
     }
     public void method2() {
         System.out.println("类B实现接口I2的方法2");
     }
     public void method3() {
         System.out.println("类B实现接口I2的方法3");
     }
 }
 
 class C{
     public void depend1(I1 i){
         i.method1();
     }
     public void depend2(I3 i){
         i.method4();
     }
     public void depend3(I3 i){
         i.method5();
     }
 }
 
 class D implements I1, I3{
     public void method1() {
         System.out.println("类D实现接口I1的方法1");
     }
     public void method4() {
         System.out.println("类D实现接口I3的方法4");
     }
     public void method5() {
         System.out.println("类D实现接口I3的方法5");
     }

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();//原价
         
         int offPrice=0;//打折之后的价格，初始化为0
         if(selfPrice>4000){
             offPrice=selfPrice * 90 / 100;
         }
         else{
             offPrice=selfPrice * 80 / 100;
         }
         
         return offPrice;
     }
 }
 public class BookStore {
     private final static ArrayList<IBook> bookList=new ArrayList<IBook>();
     static{
         bookList.add(new OffNovelBook("天龙八部",3200,"金庸"));
         bookList.add(new OffNovelBook("巴黎圣母院",5600,"雨果"));
         bookList.add(new OffNovelBook("悲惨世界",3500,"雨果"));
         bookList.add(new OffNovelBook("梅",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)+"元");
         }
     }
 
 }    

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

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