设计模式学习笔记——开闭原则

定义：

一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。即一个软件实体应该通过扩展来实现变化，而不是通过修改已有的代码来实现变化。

一、什么是开闭原则

举个书店售书的例子：

代码如下：

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()方法，用这个类来处理打折的小说类书籍，不修改原来的代码。新增的类的代码如下：

public class OffNovelBook extends NovelBook {

	public OffNovelBook(String name, int price, String author) {
		super(name, price, author);
	}

	@Override
	public int getPrice() {
		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)+"元");
		}
	}

}

通过新增加了一个类，从而实现了我们想要的变化，而且对原有代码几乎没有做任何修改（对BookStore类的修改是必须的），这样的方式，我觉得是每个程序员都愿意做的事吧？变化所引起的风险降到了最小的限度。开闭原则对扩展开放，对修改关闭，并不意味着不做任何的修改，低层模块的改变，必然会引起高层模块进行耦合，否则就是一个孤立无意义的代码片段。

二、开闭原则的重要性

1、对测试的影响

比如说上面的NovelBook类写好之后，要对它的getPrice()方法进行测试：

public class NovelBookTest extends TestCase{
	private String name="平凡的世界";
	private int price=6000;
	private String author="路遥";
	private IBook novelBook=new NovelBook(name,price,author);
	
	public void testGetPrice(){
		super.assertEquals(this.price, this.novelBook.getPrice());
	}
}

这个时候，要是修改了getPrice()方法，那就要相应的修改单元测试类，如果是一个复杂的逻辑，那么测试类就要被改的面目全非，而且，一个类一般只有一个测试类，其中有很多的测试方法，在一堆本来就很复杂的断言中进行大量修改，难免会出现测试遗漏的情况，这是我们不能容忍的。而如果通过开闭原则，采用的是通过扩展来完成的变化，新建一个测试类，只要对这个测试类中的方法进行测试就可以了，其他的不用管，也管不着，这个时候就会感觉到，哇，整个世界都清静了……

public class OffNovelBookTest extends TestCase {
	private IBook below40NovelBook=new OffNovelBook("平凡的世界",3000,"路遥");
	private IBook above40NovelBook=new OffNovelBook("平凡的世界",6000,"路遥");
	
	public void testGetPriceBelow40(){
		super.assertEquals(2400, this.below40NovelBook.getPrice());
	}
	
	public void testGetPriceAbove40(){
		super.assertEquals(5400, this.above40NovelBook.getPrice());
	}
}

2、开闭原则提高复用性

3、开闭原则可以提高可维护性，这一点在上面已经看到好处了

三、如何使用开闭原则

开闭原则是一个非常虚的原则，前面5个原则是对开闭原则的具体解释，这么难以捉摸，我们到底应该如何去使用开闭原则呢？

1、抽象约束（非常重要的一点）

（1）通过抽象或接口约束扩展，对扩展进行边界限定，不允许出现在接口或抽象类中不存在的public方法；

（2）参数类型、引用对象尽量使用接口或者抽象类，而不是实现类

（3）抽象层尽量保持稳定

举例：还是扩展上面的例子，假如书店现在要销售计算机类的书籍，我们应该怎么去扩展呢？见下类图：

public interface IComputerBook extends IBook {
	public String getScope();
}

public class ComputerBook implements IComputerBook {
	
	private String name;
	private int price;
	private String author;
	private String scope;
	
	public ComputerBook(String name, int price, String author, String scope) {
		this.name = name;
		this.price = price;
		this.author = author;
		this.scope = scope;
	}

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

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

	@Override
	public String getAuthor() {
		return author;
	}

	@Override
	public String getScope() {
		return scope;
	}

}

BookStore类稍作修改：

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,"兰陵笑笑生"));
		bookList.add(new ComputerBook("设计模式之禅",4500,"秦小波","软件设计"));
	}
	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)+"元");
		}
	}
}

这样实现是不是很好？简单而且不需要和其他的业务逻辑进行耦合。那么为什么可以这样去实现呢？这就是抽象在起着巨大的作用，假如说BookStore类中的ArrayList<IBook>改成ArrayList<NovelBook>，依赖于具体类而不是抽象类，还能这样写吗？显然是不可以的。所以， 要实现对扩展的开放，首要的前提条件是抽象约束。

2、封装变化

将相同的变化封装到一个接口或抽象类中，将不同的变化封装到不同的接口或抽象类中，不应该有两个不同的变化出现在同一个接口或抽象类中。

23个设计模式都是从各个不同的角度对变化进行封装的。