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

开发 后端
开闭原则算是前5中原则的一个抽象总结,前五种是开闭原则的一些具体实现,所以如果使用开闭原则,其实有点虚,因为它没有一个固定的模式,但是最终保证的是提高程序的复用性、可维护性等要求。

开闭原则(Open Closed Principle)

开闭原则的核心是:对扩展开放,对修改关闭。

白话意思就是我们改变一个软件时(比如扩展其他功能),应该通过扩展的方式来达到软件的改变,而不应爱修改原有代码来实现变化。

开闭原则算是前5中原则的一个抽象总结,前五种是开闭原则的一些具体实现,所以如果使用开闭原则,其实有点虚,因为它没有一个固定的模式,但是最终保证的是提高程序的复用性、可维护性等要求。

要使用这一原则还需要结合着它的思想“对扩展开放,对修改关闭”与其他的五大设计原则根据经验来开发项目。

大体是这个意思,如果想深究,还需要看看其他的书籍。

下面是使用开闭原则的一个简单示例,虽有些不准确,但是是这个意思(领会精神)。

定义一个接口,寻找美女

  1. package com.loulijun.chapter6;  
  2.    
  3. public interface IFindGirl {  
  4.     //年龄  
  5.     public int getAge();  
  6.     //姓名  
  7.     public String getName();  
  8.     //长相  
  9.     public String getFace();  
  10.     //身材  
  11.     public String getFigure();  

实现这个接口

  1. package com.loulijun.chapter6;  
  2.    
  3. public class FindGirl implements IFindGirl {  
  4.     private String name;  
  5.     private int age;  
  6.     private String face;  
  7.     private String figure;  
  8.        
  9.     public FindGirl(String name, int age, String face, String figure)  
  10.     {  
  11.         this.name = name;  
  12.         this.age = age;  
  13.         this.face = face;  
  14.         this.figure = figure;  
  15.     }  
  16.    
  17.     @Override 
  18.     public int getAge() {  
  19.         return age;  
  20.     }  
  21.    
  22.     @Override 
  23.     public String getFace() {  
  24.         return face;  
  25.     }  
  26.    
  27.     @Override 
  28.     public String getFigure() {  
  29.         return figure;  
  30.     }  
  31.    
  32.     @Override 
  33.     public String getName() {  
  34.         return name;  
  35.     }  
  36.        
  37.    

场景:大街上

  1. package com.loulijun.chapter6;  
  2.    
  3. import java.text.NumberFormat;  
  4. import java.util.ArrayList;  
  5.    
  6. public class Street {  
  7.     private final static ArrayList<IFindGirl> girls = new ArrayList<IFindGirl>();  
  8.     //静态初始化块  
  9.     static 
  10.     {  
  11.         girls.add(new FindGirl("张含韵",23,"可爱型","165cm/47kg"));  
  12.         girls.add(new FindGirl("高圆圆",33,"时尚型","165cm/48kg"));  
  13.         girls.add(new FindGirl("章泽天",19,"清纯型","168cm/47kg"));  
  14.     }  
  15.     public static void main(String args[])  
  16.     {  
  17.         System.out.println("----------美女在这里----------");  
  18.         for(IFindGirl girl:girls)  
  19.         {  
  20.             System.out.println("姓名:"+girl.getName()+" 年龄:"+girl.getAge()+  
  21.                     "  长相:"+girl.getFace()+"  身材:"+girl.getFigure());  
  22.         }  
  23.     }  

运行结果:

----------美女在这里----------

姓名:张含韵 年龄:23 长相:可爱型 身材:165cm/47kg
姓名:高圆圆 年龄:33 长相:时尚型 身材:165cm/48kg
姓名:章泽天 年龄:19 长相:清纯型 身材:168cm/47kg

但是如果想独立分出一个外国美女的类别的话(比如增加一个国籍),可以通过修改接口、修改实现类、通过扩展来实现。

如果修改接口,也就意味着修改实现类,这样对项目的变动太大了,所以不推荐

如果修改实现类,这样虽能解决问题,但是明显有些牵强,如果需要其他变动的时候会显得逻辑混乱

所以,通过扩展来实现是最简单的方式

如何扩展:

可以定义一个IForeigner接口继承自IFindGirl,在IForeigner接口中添加国籍属性getCountry(),然后实现这个接口即可,然后就只需要在场景类中做稍微修改就可以了

  1. package com.loulijun.chapter6;  
  2.    
  3. public interface IForeigner extends IFindGirl {  
  4.     //国籍  
  5.     public String getCountry();  

实现接口

  1. package com.loulijun.chapter6;  
  2.    
  3. public class ForeignerGirl implements IForeigner {  
  4.     private String name;  
  5.     private int age;  
  6.     private String country;  
  7.     private String face;  
  8.     private String figure;  
  9.        
  10.     public ForeignerGirl(String name, int age, String country, String face, String figure)  
  11.     {  
  12.         this.name = name;  
  13.         this.age = age;  
  14.         this.country = country;  
  15.         this.face =face;  
  16.         this.figure = figure;  
  17.     }  
  18.     @Override 
  19.     public String getCountry() {  
  20.         // TODO Auto-generated method stub  
  21.         return country;  
  22.     }  
  23.    
  24.     @Override 
  25.     public int getAge() {  
  26.         // TODO Auto-generated method stub  
  27.         return age;  
  28.     }  
  29.    
  30.     @Override 
  31.     public String getFace() {  
  32.         // TODO Auto-generated method stub  
  33.         return face;  
  34.     }  
  35.    
  36.     @Override 
  37.     public String getFigure() {  
  38.         // TODO Auto-generated method stub  
  39.         return figure;  
  40.     }  
  41.    
  42.     @Override 
  43.     public String getName() {  
  44.         // TODO Auto-generated method stub  
  45.         return name;  
  46.     }  
  47.    

然后在场景类中只需要修改如下代码即可,其他不变

  1. girls.add(new ForeignerGirl("Avirl",28,"美国","性感型","160cm/45kg")); 

不过这些设计原则到不是绝对的,而是根据项目需求,实际需求来定夺使用。

原文链接:http://www.cnblogs.com/loulijun/archive/2012/03/14/2394055.html

【编辑推荐】

  1. 设计模式6大原则:迪米特法则
  2. 设计模式6大原则:接口隔离原则
  3. 设计模式6大原则:依赖倒置原则
  4. 设计模式6大原则:里氏置换原则
  5. 设计模式6大原则:单一职责原则
责任编辑:林师授 来源: 娄立军的博客
相关推荐

2012-03-05 13:58:34

设计模式里氏置换

2012-03-07 10:40:19

Java设计模式

2012-03-07 11:03:13

Java设计模式

2012-03-08 10:57:00

Java设计模式

2012-03-12 16:10:26

Java设计模式

2011-09-07 09:21:01

设计模式

2015-09-23 17:12:18

API设计原则

2010-05-07 17:59:05

Unix服务器

2021-07-29 14:42:55

设计模式Java

2015-09-24 08:52:53

API设计原则

2010-03-31 17:26:52

SaaS

2010-09-09 13:54:06

DIV CSS

2024-10-14 09:52:39

软件项目开发软件项目估算

2020-06-09 07:00:00

面向对象编程编程原则

2020-09-18 11:25:43

智能

2011-07-19 18:13:15

高效数据库

2010-09-14 13:49:38

CSS代码

2012-02-01 13:24:37

2010-08-16 13:35:21

数据库设计

2011-06-29 15:44:19

SEO
点赞
收藏

51CTO技术栈公众号