设计模式

说实话对于面向对象的研究并不是很深，理解自然也不是很深刻。
软件结构体系这门课还是计算机系的老师来给我们带的课，却是本学期所有老师里面教得最好的课了，如果看不懂UML图和不了解设计模式，真的很难说自己是软件工程专业毕业的学生，惭愧。
下面开始小结下设计模式吧。

设计模式的定义

设计模式是一套被反复使用、多人知晓的、经过分类编目的、代码设计经验的总结
每一个设计模式描述一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。这样，你就能一次一次地使用该方案而不必做重复劳动。

设计模式四人帮

• 1994年，Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides，（GOF，Gang of Four）在1994年合作出版的著作：《Design Patterns：Elements of Reusable Object-Oriented Software》（中译本《设计模式：可复用的面向对象软件的基本原理》 或《设计模式》）
• 该书被公认为是设计模式领域的奠基之作，书中归纳了23种设计模式，被称为GOF 23模式。

设计模式的四要素

• pattern name（模式名称）
• problem（问题）
• solution（解决方案）
• consequences（效果）

设计原则

设计原则的作用

• 设计原则的提出是针对软件的可维护性和可复用性问题的
• 设计原则首先都是复用的原则，遵循这些设计原则可以有效地提高系统的复用性。
• 设计原则也是对系统进行合理重构的指南针，在不改变软件现有功能的基础上，通过调整程序代码改善软件的质量、性能，提高软件的扩展性和维护性。

七个设计原则

设计模式的分类

• 创建型
  
  • Factory Method（工厂方法）
  • Abstract Factory（抽象工厂）
  • Builder（建造者）
  • Prototype（原型）
  • Singleton（单例）
• 结构型
  
  • Adapter（适配器）
  • Bridge（桥接）
  • Composite（组合）
  • Decorator（装饰）
  • Facade（外观）
  • Flyweight（享元）
  • Proxy（代理）
• 行为型
  
  • Interpreter（解释器）
  • Template Method（模板方法）
  • Chain of Responsibility（负责链）
  • Command（命令）
  • Iterator（迭代器）
  • Mediator（中介者）
  • Memento（备忘录）
  • Observer（观察者）
  • State（状态）
  • Strategy（策略）
  • Visitor（访问者）

创建型模式

创建型模式，就是创建对象的模式，抽象了实例化的过程。它帮助一个系统独立于如何创建、组合和表示它的那些对象。

创建型模式关注的是对象的创建，将创建对象的过程进行了抽象和封装，作为客户程序仅仅需要去使用对象，而不再惯性创建对象过程中的逻辑。
当你想使用new关键字的时候，就可以考虑创建型模式

结构型模式

结构型模式(Structural Pattern)描述如何将类或者对象结合在一起形成更大的结构，就像搭积木，可以通过简单积木的组合形成复杂的、功能更为强大的结构。

结构型模式

行为型模式分为类行为型模式和对象行为型模式两种：

• 类行为型模式：类的行为型模式使用继承关系在几个类之间分配行为，类行为型模式主要通过多态等方式来分配父类与子类的职责。
• 对象行为型模式：对象的行为型模式则使用对象的聚合关联关系来分配行为，对象行为型模式主要是通过对象关联等方式来分配两个或多个类的职责。根据“合成复用原则”，系统中要尽量使用关联关系来取代继承关系，因此大部分行为型设计模式都属于对象行为型设计模式。

常用的设计模式

工厂方法模式(5星)

定义

Factory Method Pattern: Define an interface for creating an object, but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses

工厂方法模式又称为工厂模式，也叫做虚拟构造器（Virtual Constructor）模式或者多态工厂（polymorphic Factory）模式

简单工厂模式

简单工厂模式，可以根据参数的不同类型返回不同类的实例

简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有相同的父类

简单工厂模式的核心：一个工厂，多种厂品

由于只有一个工厂，不用产生具体的实例，可以直接用静态方法，因此简单工厂模式也经常称为静态工厂模式(static factory pattern)

实例

• 肯德基的鸡翅
• 女娲造人

public interface Human{
    public void getColor(); //每个人种的皮肤都有相应的颜色
    public void talk(); //人类会说话
}
public class YellowHuman implements Human{
    public void getColor(){
        System.out.println("黄色");
    }
    public void talk(){
        System.out.println("黄种人，双字节");  
    }
}
public class HumanFactory{
    public static <T extends Human> T createHuman( Class<T> c ){
        Human human = null;
        try{
            human = (Human)CLass.forName(c.getName()).newInstance();
        }catch( Exception e ){
            System.out.println("人种生成错误");   
        }
        return (T)human;
    }
}
public NvWa{
    public static void main( String[] args ){
        System.out.println("---造出第一个人---");
        Human whiteHuman = HumanFactory.createHuman( whiteHuman.class );
        whiteHuman.getColor();
        whiteHuman.talk();
        System.out.println("---造出第二个人---");
        Human blackHuman = HumanFactory.createHuman( blackHuman.class );
        blackHuman.getColor();
        blackHuman.talk();
        System.out.println("---造出第三个人---");
        Human yellowHuman = HumanFactory.createHuman( yellowHuman.class );
        yellowHuman.getColor();
        yellowHuman.talk();
    }
}

• 用户权限管理

模式角色

• 抽象工厂
• 具体工厂
• 抽象产品
• 具体产品

实例

• 女娲造人（这里将工厂进行抽象，而我们使用的是阴阳八卦炉）

public abstract class AbstractHumanFactory{
    public abstract <T extends Human> T createHuman( Class<T> c );
} 
public class HumanFactory extends AbstractHumanFactory{
    public <T extends Human> T createHuman( Class<T> c ){
        Human human = null;
        try{
            human = (Human)Class.forName( c.getName() ).newInstance();
        }catch ( Exception e ){
            System.out.println("人种生成错误");   
        }
        return (T)human;
    }
}
public class NvWa{
    public static void main( String[] args ) {
        //声明阴阳八卦炉
        AbstractHumanFactory YinYangLu = new HumanFactory();
        Human whiteHuman = YinYangLu.createHuman(whiteHuman.class);
        whiteHuman.getColor();
        whiteHuman.talk();
    }
}

• 电视机工厂

抽象工厂模式（5星）

定义

Abstract Factory Pattern: Provide an interface for creating families of ralated or dependent objects without specifying their concrete classes

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

抽象工厂模式又称为工具（Kit）模式
抽象工厂模式中的具体工厂不只是创建的一种产品，它负责创建一族产品

当一个工厂等级结构可以创建出分别属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更为简单、更有效率

实例

• 还是女娲造人（这里加入了性别）

//抽象产品：人种接口的实现
public interface Human{
    public void getColor(); //每个人种的皮肤都有相应的颜色
    public void talk(); //人类会说话
    public void getSex();
}
//子抽象产品：各色人种的接口的实现
public abstract class AbstractYellowHuman implements Human{
    public void getColor(){
        System.out.println("黄色");
    }
    public void talk(){
        System.out.println("黄种人，双字节");  
    }
}
//具体产品类
public class FemaleYellowHuman extends AbstractYellowHuman{
    public void getSex(){
        System.out.println("黄种女性");     
    }
}
public class MaleYellowHuman extends AbstractYellowHuman{
    public void getSex(){
        System.out.println("黄种男性");     
    }
}
//抽象工厂
public interface HumanFactory{
    public Human createYellowHuman();
    public Human createWhiteHuman();
    public Human createBlackHuman();
}
//具体工厂
public class FemaleFactory implements HumanFactory{
    public createYellowHuman(){
        return new FemaleYellowHuman();
    }
    ...
    ...
    ...
}
public class MaleFactory implements HumanFactory{
    public createYellowHuman(){
        return new FemaleYellowHuman();
    }
    ...
    ...
    ...
}
public class NvWa{
    public static void main(String[] args) {
        HumanFactory maleHumanFactory = new MaleFactory();
        HumanFactory femaleHumanFactory = new FemaleFactory();
        Human maleYellowHuam = maleHumanFactory.createYellowHuman();
        maleYellowHuam.getColor();
        maleYellowHuam.talk();
        maleYellowHuam.getSex();
    }
}

• 电器工厂
  一个电器工厂可以生产多种类型的电器，如海尔工厂可以生产海尔电视机，海尔空调
  TCL工厂可以生产TCL电视机和TCL空调，相同品牌的电器构成一个产品族，而相同类型的产品构成了一个产品等级结构
  
  
  
  • 首先有一个接口，电器工厂，然后对应了两个实现（海尔工厂和TCL工厂），
  • 对于电视机，有一个电视机接口，然后对应两个实现（海尔电视机和TCL电视机），
    这两种产品构成了一个产品等级。
  • 对于空调，有一个空调接口，然后对应两个实现（海尔空调和TCL空调），
    这两种产品也构成了一个产品等级。
  • 每一个工厂实例都能够生产两种电器，一种是电视机，另一种是空调
  • 相应的，海尔工厂的两种产品构成了海尔工厂的产品族，TCL工厂的两种产品构成了海尔工厂的产品族

外观模式（5星）

定义

Facade Pattern: Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.

外观模式（Facade Pattern）：外部与一个子系统的通信必须通过一个统一的外观对象进行，为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

外观模式又翻译为门面模式，它是一种对象结构型模式

模式角色

• Facade：外观角色
• SubSystem：子系统角色

模式结构

实例

• 电源总开关
  现在考察一个电源总开关的例子，以便进一步说明外观模式。为了使用方便，一个电源总开关可以控制四盏灯、一个风扇、一台空调和一台电视机的启动和关闭。通过该电源总开关可以同时控制上述所有电器设备，使用外观模式设计该系统

//子系统角色类
public class AirConditioner{
    public void on(){
        ...
    }
    public void off(){
        ...
    }
}
public class Television{
    ...
}
public class Fan{
    ...
}
public class Light{
    private String position;
    public Light( String position ){
        this.position = position;
    }
    public void on(){
    }
    public void off(){
    }
}
//外观角色类
public class GenralSwitchFacade{
    private Light lights[] = new Light[4];
    private Fan fan;
    private AirConditioner ac;
    private Television tv;
    public GenralSwitchFacade(){
        lights[0] = new Light( "左前");
        lights[1] = new Light( "右前");
        lights[2] = new Light( "左后");
        lights[3] = new Light( "右后");
        fan = new Fan();
        ac = new AirConditioner();
        tv = new Television();
    }
    public void on(){
        lights[0].on();
        lights[1].on();
        lights[2].on();
        lights[3].on();
        fan.on();
        ac.on();
        tv.on();
    }
    public void off(){
        lights[0].off();
        lights[1].off();
        lights[2].off();
        lights[3].off();
        fan.off();
        ac.off();
        tv.off();
    }
}

迭代器模式（5星）

定义

Iterator Pattern: Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

迭代器模式(Iterator Pattern) ：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。

一个聚合对象，如一个列表（list）或者一个集合（set），应该提供一种方法来让别人可以访问它的元素，而又不需要暴露它的内部结构。

针对不同的需要，可能还要以不同的方式遍历整个聚合对象，但是我们并不希望在聚合对象的抽象层接口中充斥着各种不同遍历的操作。
怎样遍历一个聚合对象，又不需要了解聚合对象的内部结构，还能够提供多种不同的遍历方式，这就是迭代器模式所要解决的问题。
怎样遍历一个聚合对象，又不需要了解聚合对象的内部结构，还能够提供多种不同的遍历方式，这就是迭代器模式所要解决的问题。

模式角色

• Iterator:抽象迭代器
• ConcreteIterator:具体迭代器
• Aggregate:抽象聚合类
• ConcreteAggregate:具体聚合类

模式结构

实例

• 电视遥控器
  电视机遥控器就是一个迭代器的实例，通过它可以实现对电视机频道集合的遍历操作，本实例我们将模拟电视机遥控器的实现。

//抽象迭代器
public interface TVIterator{
    void setChannel( int i );
    void next();
    void previous();
    boolean isLast();
    Objects currentChannel();
    boolean isFirst();
}
//抽象聚合类
public interface Television{
    TVIterator createIterator();
}
//具体聚合类和具体迭代类
public class TCLTelevision implements Television{
    private Objects[] obj = {"湖南卫视","北京卫视","上海卫视","湖北卫视","黑龙江卫视"};
    public TVIterator createIterator(){
        return new TCLIterator();
    }
    class TCLIterator implements TVIterator{
        private int currentIndex = 0;
        public void next(){
            if( currentIndex < obj.length ){
                currentIndex++;
            }
        }
        public void previous(){
            if( currentIndex > 0 ){
                currentIndex--;
            }
        }
        public void setChannel( int i ){
            currentIndex = i;
        }
        public Objects currentChannel(){
            return obj[currentIndex];
        }
        public boolean isFirst(){
            ...
        }
        public boolean isLast(){
            ...
        }
    }
}

观察者模式（5星）

定义

Observer Pattern: Define a one-to-many dependency between objects so tha when one object changes state, all its dependents are notified and updated automatically

观察者模式：定义对象间的一种一对多的依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式又叫做发布-视图（Model/View）模式，源-监听器（Source/Listener）模式或从属者（Dependents）模式。观察者模式是一种对象行为型模式

模式角色

• Subject:目标
• ConcreteSubject:具体目标
• Observer:观察者
• ConcreteObserver:具体观察者

模式结构

实例

• 猫、狗与老鼠
  假设猫是老鼠和狗的观察目标，老鼠和狗也就是观察者。
  那么，如果猫叫了，老鼠就会跑，狗也会跟着一起叫，使用观察者模式描述该过程。

import java.util.*;
//抽象目标
public abstract class MySubject{
    protected ArrayList observers = new ArrayList();
    public void attach( MyObserver observer ){
        observers.add( observer );
    }
    public void detach( MyObserver observer ){
        observers.remove( observer );
    }
    public abstract void cry(); //抽象通知方法
}
//抽象观察者
public interface MyObserver{
    void response();    
}
//具体目标
public class Cat extends MySubject{
    public void cry(){
        System.ou.println( "猫叫!" );
        for (Object obs:observers) {
            ((MyObserver)obs).response();
        }
    }
}
//具体观察者
public class Mouse implements MyObserver{
    public void response(){
        System.ou.println( "老鼠跑!" );
    }
}
public class Dog implements MyObserver{
    public void response(){
        System.ou.println( "狗叫!" );
    }
}
//客户端
public class Client{
    public static void main(String[] args) {
        MySubject subject = new Cat();
        MyObserver obs1, obs2, obs3;
        obs1 = new Mouse();
        obs2 = new Mouse();
        obs3 = new Dog();   
        subject.attach(obs1);
        subject.attach(obs2);
        subject.attach(obs3);
        subject.cry();
    }
}

• 李斯与韩非子
  李斯监控韩非子，韩非子有何动静，李斯会做出相应的反应
  

//抽象目标类
public interface IHanFeiZi{
    public void haveBreakfast();
    public void haveFun();
}
//抽象观察者类
public interface ILiSi{
    public update( String context );
}
//具体目标类
public class HanFeiZi implements IHanFeiZi{
    private ILiSi liSi = new LiSi();
    public void haveBreakfast(){
        System.out.println( "韩非子：开始吃饭了...")
        this.liSi.update( "韩非子在吃饭");
    }
    public void haveFun(){
        System.out.println( "韩非子：开始娱乐了...")
        this.liSi.update( "韩非子在娱乐");
    }
}
//具体观察者类
public class LiSi implements ILiSi{
    public void update( String str ){
        System.out.println( "李斯：观察到韩非子活动，开始向老板汇报了...");
        this.reportToQiShiHuang( str );
        System.out.println( "李斯：汇报完毕...");
    }
    private void reportToQiShiHuang( String reportContext ){
        System.out.println( "李斯：报告，秦老板！韩非子有活动了..." 
        + reportContext );
    }
}
//客户端
public class Client{
    public static void main(String[] args) {
        HanFeiZi hanFeiZi = new HanFeiZi();
        hanFeiZi.haveBreakfast();
        hanFeiZi.haveFun();
    }
}

一些杂项

1. 设计模式的原理是面向接口编程
2. 软件危机：泛指在计算机软件的开发和维护过程中所遇到的一系列严重问题
   
   • 软件开发过程中如何满足日益增长的用户需求
   • 如何维护数量不断膨胀的已有软件
3. 软件复用：是指利用现有的软件资源来开发新应用系统的过程。包括三个相关的基本过程：
   
   • 软件对象的开发
   • 软件对象的理解
   • 软件对象的复用
4. 软件体系结构的内容：风格、设计模式、框架

5. 软件开发模型

   • 瀑布模型：文档驱动的、阶段间具有顺序性和依赖性、推迟实现、质量保证

   • 渐增模型：由一组有计划的、循环渐增的、不断改进的过程版本组成。
     各个中间版本可以并行开发。

   • 演化模型（原型模型）：通过系统各个可执行的中间版本以渐增的形式来开发系统的，但是客户需求可以分步逐渐了解，不用在初始时就确定。

   • 螺旋模型：螺旋模型沿着螺线旋转，在四个象限上分别表达四个方面的活动，制定计划、风险分析、实施工程和客户评估
     螺旋模型将瀑布模型与快速原形模型结合起来，并且加入两种模型均忽略了的风险分析。
     优点：对可选方案和约束条件的强调有利于已有软件的重用，也有助于把软件质量作为软件开发的一个重要目标；
     维护和开发之间并没有本质区别。
     缺点：风险驱动的
     主要适用于内部开发的大规模软件项目

   • 智能模型：把瀑布模型和专家系统结合在一起。
   • 喷泉模型： 开发活动之间的无间隙性和循环迭代性。
6. UML的三要素：
   
   • 表示法--图形
   • 过程----适用于面向对象的软件开发过程
   • 工具----（Ratinal Rose等）
7. UML结构
   
8. UML的的四种常用关系和五种视图
   
   • 静态视图： 类图、对象图
   • 实现视图： 构建图、部署图
   • 交互视图： 顺序图、协作图
   • 行为视图： 状态图、活动图
   • 用例视图： 用例图