开闭原则（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();  

12.          }

实现这个接口

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.             

38.          }

场景：大街上

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.              }  

24.          }

运行结果：

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

姓名:张含韵 年龄: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();  

6.             }

实现接口

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.             

48.          }

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

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

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

QQ 744437114
　　疯狂软件官网：http://www.fkjava.org
　　疯狂java视频 android视频：http://www.fkjava.org/video.html