Java Web 设计模式之开闭原则

1.开闭原则(OCP)

遵循开闭原则设计出的模块具有两个主要特征:

(1)对于扩展是开放的(Open for extension)。这意味着模块的行为是可以扩展的。当应用的需求改变时,我们可以对模块进行扩展,使其具有满足那些改变的新行为。也就是说,我们可以改变模块的功能。

(2)对于修改是关闭的(Closed for modification)。对模块行为进行扩展时,不必改动模块的源代码或者二进制代码。模块的二进制可执行版本,无论是可链接的库、DLL或者.EXE文件,都无需改动。

2.通过UML认识OCP

3.代码

(1)IShoe接口

1 package com.alibaba.www.miao;
2
3 public interface IShoe {
4
5     public String getName();
6     public String getType();
7     public int getValue();
8 }

(2)MenShoe实现IShoe接口

 1 package com.alibaba.www.miao;
 2
 3 public class MenShoe implements IShoe {
 4
 5     private String name;
 6     private String type;
 7     private int value;
 8
 9     public MenShoe(String name, String type, int value) {
10         super();
11         this.name = name;
12         this.type = type;
13         this.value = value;
14     }
15
16     @Override
17     public String getName() {
18         return this.name;
19     }
20
21     @Override
22     public String getType() {
23         return this.type;
24     }
25
26     @Override
27     public int getValue() {
28         return this.value;
29     }
30
31 }

(3)GirlShoe实现IShoe接口

 1 package com.alibaba.www.miao;
 2
 3 public class GirlShoe implements IShoe {
 4
 5     private String name;
 6     private String type;
 7     private int value;
 8
 9     public GirlShoe(String name, String type, int value) {
10         super();
11         this.name = name;
12         this.type = type;
13         this.value = value;
14     }
15
16     @Override
17     public String getName() {
18         return this.name;
19     }
20
21     @Override
22     public String getType() {
23         return this.type;
24     }
25
26     @Override
27     public int getValue() {
28         return this.value;
29     }
30
31 }

(4)PriceCutMenShoe继承MenShoe类

 1 package com.alibaba.www.miao;
 2
 3 public class PriceCutMenShoe extends MenShoe {
 4
 5     public PriceCutMenShoe(String name, String type, int value) {
 6         super(name, type, value);
 7     }
 8
 9     public int getValue() {
10         int primeCost = super.getValue();
11         int cutPrice = 0;
12         if (primeCost > 200) {
13             cutPrice = cutPrice * 80 / 100;
14         }
15         if (primeCost > 150) {
16             cutPrice = cutPrice * 85 / 100;
17         }
18         return cutPrice;
19     }
20 }

(5)PriceCutGirlShoe继承GirlShoe类

 1 package com.alibaba.www.miao;
 2
 3 public class PriceCutGirlShoe extends GirlShoe {
 4
 5     public PriceCutGirlShoe(String name, String type, int value) {
 6         super(name, type, value);
 7     }
 8
 9     public int getValue() {
10         int primeCost = super.getValue();
11         int cutPrice = 0;
12         if (primeCost > 200) {
13             cutPrice = cutPrice * 75 / 100;
14             System.out.println("如果原价大于200元,则打折7.5折");
15         }
16         if (primeCost > 150) {
17             cutPrice = cutPrice * 80 / 100;
18             System.out.println("如果原价大于150元,则打折8折");
19         } else {
20             cutPrice = cutPrice * 85 / 100;
21             System.out.println("其他。则打8.5折");
22         }
23         return primeCost;
24     }
25 }

(6)测试ocp.jsp,验证开闭原则

 1 <%@page import="com.alibaba.www.miao.PriceCutGirlShoe"%>
 2 <%@ page language="java" contentType="text/html; charset=UTF-8"
 3     pageEncoding="UTF-8"%>
 4 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 5 <html>
 6 <head>
 7 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 8 <title>Insert title here</title>
 9 </head>
10 <body>
11
12     <%
13         PriceCutGirlShoe a = new PriceCutGirlShoe("女鞋名","女鞋类型",160);
14         out.print("鞋价为:"+a.getValue());
15     %>
16
17 </body>
18 </html>

(7)参考目录结构

源码下载:http://download.csdn.net/detail/sxmiaochuang/7629901

Java Web 设计模式之开闭原则,布布扣,bubuko.com

时间: 2024-12-29 16:22:00

Java Web 设计模式之开闭原则的相关文章

Java Web设计模式之依赖倒换原则

1.依赖倒置原则 A.高层次的模块不应该依赖于低层次的模块,他们都应该依赖于抽象. B.抽象不应该依赖于具体,具体应该依赖于抽象. 2.用UML图来说明一下: 代码说明: (1)管理员接口 1 package com.alibaba.com.miao; 2 3 public interface IEmployee { 4 5 public String code(ICode code); 6 } (2)编码接口 1 package com.alibaba.com.miao; 2 3 public

设计模式之开闭原则

Open-Closed Principle软件设计中的“开-闭原则” 这个原则最早是由Bertrand Meyer提出,英文的原文是:Software entities should be open for extension,but closed for modification.意思是说,一个软件实体应当对扩展开放,对修改关闭.也就是说,我们在设计一个模块的时候,应当使这个模块可以在不被修改的前提下被扩展,换句话说就是,应当可以在不必修改源代码的情况下改变这个模块的行为. 满足OCP的设计给

&quot;围观&quot;设计模式(6)--开闭原则(Open/Closed Principle)

在面向对象编程领域中,开闭原则规定"软件中的对象(类,模块,函数等等)应该对于扩展是开放的,但是对于修改是封闭的",这意味着一个实体是允许在不改变它的源代码的前提下变更它的行为.该特性在产品化的环境中是特别有价值的,在这种环境中,改变源代码需要代码审查,单元测试以及诸如此类的用以确保产品使用质量的过程.遵循这种原则的代码在扩展时并不发生改变,因此无需上述的过程. 开闭原则的命名被应用在两种方式上.这两种方式都使用了继承来解决明显的困境,但是它们的目的,技术以及结果是不同的.----WI

前端用到的设计模式之开闭原则. 里氏代换原则

开闭原则,如果jQuery源码稍微了解,肯定知道它的应用了. 一个模块----函数或对象,应该凭着经验来判断, 对扩展开放,对修改关闭.------ 一般用继承实现扩展,用闭包来实现关闭. 为什么开闭原则?它跟复杂度有什么关系,? 复杂度,就是一个函数里包含的功能个数;当开闭原则不遵守时,想扩展功能,必然去原来的函数里添加代码,导致原来的函数功能增加. 里氏代换原则:是对开闭原则的补充,子类可以扩展父类,但不可改变父类. function changFangxing(height,width){

设计模式SOLID - 开闭原则

The Open – Closed principle have been formed by Bertrand Meyer in 1988, it can be paraphrased as: Software entities (let it be classes, modules, functions, etc.) should be open for extending and closed for modification.  This simple rule means that w

架构中的设计原则之开闭原则(OCP) - 《java开发技术-在架构中体验设计模式和算法之美》

开闭原则OCP(Open for Extension,Closed for Modification).开闭原则的核心思想是:一个对象对扩张开放,对修改关闭. 其实开闭原则的意思就是:对类的改动是通过增加代码进行的,而不是改动现有的代码.也就是说,软件开发人员一旦写出了可以运行的代码,就不应该去改变它,而是要保证它能一直运行下去,如何才能做到这一点呢?这就需要借助于抽象和多态,即把可能变化的内容抽象出来,从而使抽象的部分是相对稳定,而具体的实现层是可以改变和扩展的. 根据开闭原则,我们改变一个软

设计模式--6大原则--开闭原则

开闭原则(Open Closed Principle) 开闭原则的核心是:对扩展开放,对修改关闭 白话意思就是我们改变一个软件时(比如扩展其他功能),应该通过扩展的方式来达到软件的改变,而不应爱修改原有代码来实现变化 开闭原则算是前5中原则的一个抽象总结,前五种是开闭原则的一些具体实现,所以如果使用开闭原则,其实有点虚,因为它没有一个固定的模式,但是最终保证的是提高程序的复用性.可维护性等要求 要使用这一原则还需要结合着它的思想"对扩展开放,对修改关闭"与其他的五大设计原则根据经验来开

设计模式 开闭原则

设计模式 - 开闭原则 即 对立与统一原则 什么是开闭原则 软件实体应该对扩展开放,对修改关闭,即实体应当通过扩展实现变化,而不是修改代码实现变化 什么是软件实体,项目或软件中按照一定逻辑规划划分的模块 抽象 类 方法 书店销售书籍 然后书写代码如下 // 书籍接口 public interface Ibook{ // 名称 public String getName(); // 售价 public int getPrice(); // 作者 public String getAuthor();

设计模式七大原则(一)开闭原则

设计模式七大原则--开闭原则 1.1 定义: 一个软件实体如类.模块和函数应该对扩展开放,对修改关闭. 用抽象构建框架,用实体扩展细节. 1.2 优点: 提高软件系统的可复用性及可维护性. 1.3 问题由来: 在软件的生命周期中,因为变化.升级和维护等原因需要对软件原有代码进行修改时,可能会给旧代码引入错误,也可能会使我们不得不对整个功能进行重构,并且需要原有代码进过重新测试. 1.4 解决方案: 当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是通过修改已有的代码来实现变化. 实现