定义:
一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。即一个软件实体应该通过扩展来实现变化,而不是通过修改已有的代码来实现变化。
一、什么是开闭原则
举个书店售书的例子:
代码如下:
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;
}
}
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个设计模式都是从各个不同的角度对变化进行封装的。