`
ITCheng
  • 浏览: 73384 次
  • 来自: 北京
社区版块
存档分类
最新评论

面向对象的设计原则_开闭原则

阅读更多

动机

一个设计良好的应用程序应该充分考虑到开发和维护阶段需求的频繁变化,通常情况下,添加一个新的功能需要做出很多修改,我们应该使对已有代码的修改最小化,因为他们已经经过了测试。对现有代码做出修改将会以一种不可预料的方式影响它们的已有功能。

 

开放-关闭原则 (以下简称开闭原则)

开-闭原则:

一个软件实体应该对扩展开发,对修改关闭。

 

开闭原则是说我们应该努力设计不需要修改的模块。在扩展系统的行为时,我们只需要添加新的代码,而不需要修改已有的代码。一般可以通过添加新的子类和重写父类的方法来实现。

 

满足开闭原则的模块符合下面两个标准:

  • 对扩展开放 ------- 模块的行为可以被扩展从而满足新的需求。
  • 对修改关闭 ------- 不允许修改模块的源代码。(或者尽量使修改最小化)

这两个标准看似相互矛盾的,那么我们怎么实现他们呢?

怎样实现开闭原则

  • 抽象
  • 多态
  • 继承
  • 接口

要想使一个软件系统的所有模块都满足开闭原则是不太现实的,不过我们应该努力使大部分模块满足开闭原则。开闭原则是面向对象设计的核心,满足该原则可以达到最大限度的复用和可维护性。

 


实例

考虑下面某个类的方法:

 

Java代码 复制代码 收藏代码
  1. public double totalPrice(Part[] parts) {   
  2. double total = 0.0;   
  3. for (int i=0; i<parts.length; i++) {   
  4. total += parts[i].getPrice();   
  5. }   
  6. return total;   
  7. }  
public double totalPrice(Part[] parts) {
double total = 0.0;
for (int i=0; i<parts.length; i++) {
total += parts[i].getPrice();
}
return total;
}

 

上面函数的功能是计算给定的零件数组中所有零件价格的总和,如果Part是一个基类或者接口,那我们就可以利用多态的特性,当有新的零件被添加进来时不需要修改该函数的代码。这样它就可以满足开闭原则。

 

但是如果我们的会计部门规定当计算主板和内存的价格时,需要添加一些额外的费用,请看下面的代码:

Java代码 复制代码 收藏代码
  1. public double totalPrice(Part[] parts) {   
  2. double total = 0.0;   
  3. for (int i=0; i<parts.length; i++) {   
  4. if (parts[i] instanceof Motherboard)   
  5. total += (1.45 * parts[i].getPrice());   
  6. else if (parts[i] instanceof Memory)   
  7. total += (1.27 * parts[i].getPrice());   
  8. else  
  9. total += parts[i].getPrice();   
  10. }   
  11. return total;   
  12. }  
public double totalPrice(Part[] parts) {
double total = 0.0;
for (int i=0; i<parts.length; i++) {
if (parts[i] instanceof Motherboard)
total += (1.45 * parts[i].getPrice());
else if (parts[i] instanceof Memory)
total += (1.27 * parts[i].getPrice());
else
total += parts[i].getPrice();
}
return total;
}

 

 

现在它还符合开闭原则吗?不!每次会计部门发布一个新的价格政策时,我们都需要修改totalPrice()方法!它对修改不是关闭的,显然,价格政策的改变意味着我们必须修改某处的代码,那么我们应该怎么做呢?为了使用我们第一个版本的totalPrice()方法,我们需要把Part的getPrice()方法的价格政策包含进来。

下面是Part和ConcretePrat类:

Java代码 复制代码 收藏代码
  1. // Class Part is the superclass for all parts.   
  2. public class Part {   
  3. private double price;   
  4. public Part(double price) (this.price = price;}   
  5. public void setPrice(double price) {this.price = price;}   
  6. public double getPrice() {return price;}   
  7. }   
  8. // Class ConcretePart implements a part for sale.   
  9. // Pricing policy explicit here!   
  10. public class ConcretePart extends Part {   
  11. public double getPrice() {   
  12. // return (1.45 * price); //Premium   
  13. return (0.90 * price); //Labor Day Sale   
  14. }   
  15. }  
// Class Part is the superclass for all parts.
public class Part {
private double price;
public Part(double price) (this.price = price;}
public void setPrice(double price) {this.price = price;}
public double getPrice() {return price;}
}
// Class ConcretePart implements a part for sale.
// Pricing policy explicit here!
public class ConcretePart extends Part {
public double getPrice() {
// return (1.45 * price); //Premium
return (0.90 * price); //Labor Day Sale
}
}

 

但是,现在如果价格政策改变,我们必须修改Part的子类,一个更好的方法是建立一个PricePolicy类,它可以为我们提供不同的价格政策:

Java代码 复制代码 收藏代码
  1. /**  
  2. * Class PricePolicy implements a given price policy.  
  3. */  
  4. public class PricePolicy {   
  5. private double factor;   
  6. public PricePolicy (double factor) {   
  7. this.factor = factor;   
  8. }   
  9. public double getPrice(double price) {return price * factor;}   
  10. }  
/**
* Class PricePolicy implements a given price policy.
*/
public class PricePolicy {
private double factor;
public PricePolicy (double factor) {
this.factor = factor;
}
public double getPrice(double price) {return price * factor;}
}

 

使用这种方法,我们可以在运行时动态的设置Part对象所引用的PricePoilcy对象,在实际的程序中,零件的价格和相关的PricePolicy可以从数据库中获取。

 

总结

像许多其他原则一样,开闭原则只是面向对象设计的一个原则,实现一个灵活的设计需要额外的时间和努力,引入新的抽象层会增加代码的复杂性。因此,该原则适用于那些需求会经常发生变化的系统。有许多设计模式可以帮助我们扩展功能而不需要修改代码。例如,装饰模式等。

分享到:
评论

相关推荐

    面向对象设计原则PPT

    面向对象设计原则概述 单一职责 开闭原则 里氏代换原则 依赖倒转原则 接口隔离原则 合成复用原则 迪米特法则

    对面向对象设计原则的总结

    对面向对象设计原则的总结,设计模式:“开-闭”原则,里氏代换原则、依赖倒转原则、合成/聚合复用原则、迪米特法则、接口隔离原则

    面向对象设计原则

    面向对象设计原则概述 单一职责原则 开闭原则 里氏代换原则 依赖倒转原则 接口隔离原则 合成复用原则 迪米特法则

    面向对象设计原则(Java).ppt

    面向对象设计原则,开闭原则,迪米特法则,里氏代换,接口隔离

    面型对象设计原则——开闭原则(OCP)的Demo+静态结构图

    C# 版本,OCP原则的Demo,内部培训资料。

    面向对象设计原则源码及文档

    面向对象设计原则是OOPS(Object-Oriented Programming System,面向对象的程序设计系统)编程的核心。在设计面向对象的程序的时,模式不是一定要套的,但是有一些原则最好是遵守。这些原则已知的有七个,包括:单一...

    Java_面向对象设计原则总结

    Java_面向对象设计原则总结 一 类的设计原则 1 依赖倒置原则-Dependency Inversion Principle (DIP) 2 里氏替换原则-Liskov Substitution Principle (LSP) 3 接口分隔原则-Interface Segregation Principle...

    面向对象七大基本设计原则.pdf

    面向对象七大基本设计原则.pdf

    Java面向对象程序设计杨晓燕面向对象基本原则和模式.pptx

    开放-封闭原则 所谓"开放-封闭原则"(Open-Closed Principle),也称"开-闭原则",就是让设计对扩展开放,对修改关闭。也就是说,不允许更改的是系统的抽象层,而允许更改的是系统的实现层。高层模块不应该依赖低层...

    uml作业面向对象的设计原则

    里氏替换原则,开闭原则,满足OCP开闭原则的方案,内附有测试代码

    第2章_面向对象设计原则.ppt

    面向对象设计原则概述 单一职责原则 开闭原则 里氏代换原则 依赖倒转原则 接口隔离原则 合成复用原则 迪米特法则

    面向对象程序设计六大原则

    面向对象程序设计六大原则 一、“开-闭”原则(Open-Closed Principle,OCP) 1.1“开-闭”原则的定义及优点 1)定义:一个软件实体应当对扩展开放,对修改关闭( Software entities should be open for extension,but...

    JAVA面向对象的设计原则

    JAVA面向对象设计原则,单一职责原则,开闭原则(OCP) 替换原则(LSP)

    面向对象设计原则java

    详细介绍了: 单一职责原则 开闭原则 里氏代换原则 依赖倒转原则 接口隔离原则 合成复用原则 迪米特法则

    面向对象的设计原则 doc

    面向对象设计根本的指导原则是提高可维护性和可复用性。这些原则主要有:1. 开闭原则;2. 依赖倒转原则;3. 里氏代换原则;4. 合成/聚合复用原则;5. 迪米特原则;6. 接口隔离原则

    设计原则与设计模式

    面向对象设计原则:面向对象设计原则、开闭原则、里氏替换原则、里氏替换原则、里氏替换原则

    面向对象六大设计原则

    1、“开-闭”原则(Open-Closed Principle,OCP) 2、里氏替换原则(Liskov Substitution Principle,LSP) 3、依赖倒置原则(Dependence Inversion Principle,DIP) 4、接口隔离原则(Interface Separate ...

    Java设计模式-面向对象七大设计原则

    例如:随着计算机的不断发展,程序学习这门技术也越来越重要,很多人都开启了...面向对象设计原则一共有七个:开闭原则、里氏替换原则、依赖倒转原则、单一职责原则、接口隔离原则、组合/聚合复用原则、迪米特法则。

    python开闭原则.docx

    python开闭原则 开闭原则是面向对象设计中的一个重要原则,它指出一个软件实体(类、模块、函数等)应该对扩展开放,对修改关闭。这意味着当需要添加新功能时,应该通过扩展现有代码来实现,而不是修改已有代码。...

Global site tag (gtag.js) - Google Analytics