设计模式

设计模式

大量的实践中总结、理论化之后优选的代码结构、编程风格、解决问题的方案和途径。

设计模式（design pattern）是一套被反复使用、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被理解、保证代码可靠性。 设计模式是代码编制真正工程化，设计模式是软件工程的基石。

在项目中合理的运用设计模式可以解决很多问题，每个模式描述了问题以及该问题的核心解决方案。

组成部分：

模式名称：名词，用来描述模式的问题、解决方案和效果

问题：描述何时使用该模式

解决方案：描述模式的组成，各自的职责，相互关系

效果：描述使用模式的效果及使用这个模式是应该权衡的问题

7大原则：

1：开闭原则(open close principle)：实现热插拔，提高扩展性。

在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。

2：里氏代换原则(Liskov Substitution principle)：实现抽象的规范，实现子父类互相替换；

里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

3：依赖倒转原则(Dependence Inversion principle)：这个原则是开闭原则的基础，针对接口编程，实现开闭原则的基础；

4：接口隔离原则(interface segregation priciple)：降低耦合度，接口单独设计，互相隔离；

使用多个隔离的接口，比使用单个接口要好；其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

5：迪米特法则，又称不知道原则(Demeter priciple)：功能模块尽量独立；

一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

6：合成复用原则(composite reuse priciple)：尽量使用聚合，组合，而不是继承；

7：单一职责原则(Single Responsibility Principle)：不要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责，应该仅有一个引起它变化的原因

23种设计模式
创建型模式（5个）	结构型模式（7个）	行为型模式（11个）
这些设计模式提供了一种在创建对象的同时隐藏 创建逻辑方式，而不是使用 new 运算符直接实例化对象。 这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。	这些设计模式关注类和对象的组合。 继承的概念被用来组合接口和定义组合对象获得新功能的方式。	这些设计模式特别关注对象之间的通信。
工厂模式 抽象工厂模式 单例模式 建造者模式 原型模式	适配器模式 桥接模式 过滤器模式 组合模式 装饰器模式 外观模式 享元模式 代理模式	责任链模式） 命令模式 解释器模式 迭代器模式 中介者模式 备忘录模式 观察者模式 状态模式 空对象模式 策略模式 模板模式 访问者模式

 

几个常用的设计模式详解：

单例设计模式：

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

 

应用实例： 1、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。 2、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

 

优点： 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。 2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

单例模式的实现有多种方式，如下所示：

1、懒汉式，线程不安全

public class Singleton {  

    private static Singleton instance;  

    private Singleton (){}    

    public static Singleton getInstance() {  

    if (instance == null) {  

        instance = new Singleton();  

    }  

    return instance;  

    }  

}  

2：饿汉式，线程安全

public class Singleton {  

    private static Singleton instance = new Singleton();  

    private Singleton (){}  

    public static Singleton getInstance() {  

    return instance;  

    }  

}  

策略模式：

在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

主要解决：在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护。

何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。

如何解决：将这些算法封装成一个一个的类，任意地替换。

关键代码：实现同一个接口。

应用实例： 1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。 3、JAVA AWT 中的 LayoutManager。

优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。

缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。

使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

步骤 1

创建一个接口。

Strategy.java

public interface Strategy {

   public int doOperation(int num1, int num2);

}

步骤 2

创建实现接口的实体类。

public class OperationAdd implements Strategy{

   @Override

   public int doOperation(int num1, int num2) {

      return num1 + num2;

   }

}

public class OperationSubstract implements Strategy{

   @Override

   public int doOperation(int num1, int num2) {

      return num1 - num2;

   }

}

public class OperationMultiply implements Strategy{

   @Override

   public int doOperation(int num1, int num2) {

      return num1 * num2;

   }

}

步骤 3

创建 Context 类。

public class Context {

   private Strategy strategy;

   public Context(Strategy strategy){

      this.strategy = strategy;

   }

   public int executeStrategy(int num1, int num2){

      return strategy.doOperation(num1, num2);

   }

}

步骤 4

使用 Context 来查看当它改变策略 Strategy 时的行为变化。

StrategyPatternDemo.java

public class StrategyPatternDemo {

   public static void main(String[] args) {

      Context context = new Context(new OperationAdd());        

      System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

      context = new Context(new OperationSubstract());        

      System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

      context = new Context(new OperationMultiply());        

      System.out.println("10 * 5 = " + context.executeStrategy(10, 5));

   }

}

步骤 5

验证输出。

组合设计模式：

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。

这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。

意图：将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

主要解决：它在我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以向处理简单元素一样来处理复杂元素，从而使得客户程序与复杂元素的内部结构解耦。

何时使用： 1、您想表示对象的部分-整体层次结构（树形结构）。 2、您希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。

如何解决：树枝和叶子实现统一接口，树枝内部组合该接口。

关键代码：树枝内部组合该接口，并且含有内部属性 List，里面放 Component。

应用实例： 1、算术表达式包括操作数、操作符和另一个操作数，其中，另一个操作符也可以是操作数、操作符和另一个操作数。 2、在 JAVA AWT 和 SWING 中，对于 Button 和 Checkbox 是树叶，Container 是树枝。

优点： 1、高层模块调用简单。 2、节点自由增加。

缺点：在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。

使用场景：部分、整体场景，如树形菜单，文件、文件夹的管理。

 

步骤 1

创建 Employee 类，该类带有 Employee 对象的列表。

步骤 2

使用 Employee 类来创建和打印员工的层次结构。

public class CompositePatternDemo {

   public static void main(String[] args) {

      Employee CEO = new Employee("John","CEO", 30000);

      Employee headSales = new Employee("Robert","Head Sales", 20000);

      Employee headMarketing = new Employee("Michel","Head Marketing", 20000);

      Employee clerk1 = new Employee("Laura","Marketing", 10000);

      Employee clerk2 = new Employee("Bob","Marketing", 10000);

 

      Employee salesExecutive1 = new Employee("Richard","Sales", 10000);

      Employee salesExecutive2 = new Employee("Rob","Sales", 10000);

 

      CEO.add(headSales);

      CEO.add(headMarketing);

 

      headSales.add(salesExecutive1);

      headSales.add(salesExecutive2);

      headMarketing.add(clerk1);

      headMarketing.add(clerk2);

      //打印该组织的所有员工

      System.out.println(CEO);

      for (Employee headEmployee : CEO.getSubordinates()) {

         System.out.println(headEmployee);

         for (Employee employee : headEmployee.getSubordinates()) {

            System.out.println(employee);

         }

      }        

   }

}

步骤 3

验证输出。

工厂模式

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

更多请看：http://www.runoob.com/design-pattern/factory-pattern.html