设计模式(java版本)

设计模式概述

设计模式概述设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

1. 设计模式不是一种方法和技术，而是一种思想
2. 设计模式和具体的语言无关,学习设计模式就是要建立面向对象的思想，尽可能的面向接口编程，低耦合，高内聚，使设计的程序可复用。
3. 学习设计模式能够促进对面向对象思想的理解，反---之亦然。它们相辅相成

设计模式的几个要素

* 名字 必须有一个简单，有意义的名字
* 问题 描述在何时使用模式
* 解决方案 描述设计的组成部分以及如何解决问题
* 效果 描述模式的效果以及优缺点

设计模式的分类

1.    创建型模式对象的创建
2.    结构型模式对象的组成（结构）
3.    行为型模式对象的行为

创建型模式

简单工厂模式

抽象产品角色

package com.china.shanghai.wanson;

public abstract class Product {
    public abstract void show();
}

具体产品角色

package com.china.shanghai.wanson;

public class ConcreteProduct1 extends Product {
    @Override
    public void show() {
        System.out.println("产品1");
    }
}

package com.china.shanghai.wanson;

public class ConcreteProduct2 extends Product {
    @Override
    public void show() {
        System.out.println("产品2");
    }
}

工厂角色

package com.china.shanghai.wanson;

/**
 * 简单工厂模式概述又叫静态工厂方法模式，
 * 它定义一个具体的工厂类负责创建-些类的实例
 */
public class SimpleFactory {

    public SimpleFactory() {
    }
    public  static ConcreteProduct1 CreateProduct1(){
        return new ConcreteProduct1();
    }
    public static ConcreteProduct2 CreateProduct2(){
        return new ConcreteProduct2();
    }
    public static Product createProduct(String type){
        if("product1".equals(type)){
            return new ConcreteProduct1();
        }else if("product2".equals(type)){
            return new ConcreteProduct2();
        }else {
            return null;
        }
    }
}

驱动测试/客户端测试

package com.china.shanghai.wanson;

public class Driver {
    public static void main(String[] args) {
        /** 方法一
         * 具体类调用
         */
        ConcreteProduct1 concreteProduct1=new ConcreteProduct1();
        concreteProduct1.show();

        ConcreteProduct2 concreteProduct2=new ConcreteProduct2();
        concreteProduct2.show();
        System.out.println("**************************************\n");
        /**方法2
         * 工厂有了后，通过工厂创建
         */
        ConcreteProduct1 concreteProduct11=SimpleFactory.CreateProduct1();
        concreteProduct11.show();
        ConcreteProduct2 concreteProduct21=SimpleFactory.CreateProduct2();
        concreteProduct21.show();

        System.out.println("**************************************\n");
        /** 方法3
         * 改进工厂后
         */
        Product product=SimpleFactory.createProduct("product1");
        product.show();
        product=SimpleFactory.createProduct("product2");
        product.show();
        product=SimpleFactory.createProduct("product3");
        if(product!=null){
            product.show();
        }else {
            System.out.println("对不起," +
                    "我们不生产没这个东西");
        }

    }
}

工厂方法模式

抽象产品

package com.china.wanson;

public abstract class Product {
    public abstract void show();
}

具体产品

package com.china.wanson;

public class ConcreteProduct1 extends Product {
    @Override
    public void show() {
        System.out.println("product1");
    }
}

package com.china.wanson;

public class ConcreteProduct2 extends Product {
    @Override
    public void show() {
        System.out.println("product2");
    }
}

抽象工厂

package com.china.wanson;

public interface Factory {
    public abstract Product createProduct();
}

具体工厂

package com.china.wanson;

public class ConcreteFactory1 implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProduct1();
    }
}


package com.china.wanson;

public class ConcreteFactory2 implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProduct2();
    }
}

驱动测试/客户端测试

package com.china.wanson;

public class Driver {
    public static void main(String[] args) {
        Factory factory=new ConcreteFactory1();
        Product product=factory.createProduct();
        product.show();

        factory=new ConcreteFactory2();
        product=factory.createProduct();
        product.show();



    }
}

抽象工厂模式

详细代码实现

package com.factory;


import com.product.ComboBox.ComboBox;
import com.product.TextField.TextField;
import com.product.button.Button;
//  界面皮肤工厂接口 充当抽象工厂
public interface SkinFactory {
    public Button createButton();
    public TextField createTextField();
    public ComboBox createComboBox();
}





package com.factory.impl;


import com.factory.SkinFactory;
import com.product.ComboBox.ComboBox;
import com.product.ComboBox.impl.SpringComboBox;
import com.product.TextField.TextField;
import com.product.TextField.impl.SpringTextField;
import com.product.button.Button;
import com.product.button.impl.SpringButton;
///Spring皮肤工厂  充当具体工厂
public class SpringSkinFactory implements SkinFactory {
    public Button createButton() {
        return new SpringButton();
    }

    public TextField createTextField() {
        return new SpringTextField();
    }

    public ComboBox createComboBox() {
        return new SpringComboBox();
    }
}


package com.factory.impl;

import com.factory.SkinFactory;
import com.product.ComboBox.ComboBox;
import com.product.ComboBox.impl.SummerComboBox;
import com.product.TextField.TextField;
import com.product.TextField.impl.SummerTextField;
import com.product.button.Button;
import com.product.button.impl.SummerButton;

///Summer皮肤工厂  充当具体工厂
public class SummerSkinFactory implements SkinFactory {
    public Button createButton() {
        return new SummerButton();
    }

    public TextField createTextField() {
        return new SummerTextField();
    }

    public ComboBox createComboBox() {
        return new SummerComboBox();
    }
}


**************************************************************************************************************

package com.product.button;

//按钮接口 充当抽象角色
public interface Button {
    public void display();
}



package com.product.button.impl;

import com.product.button.Button;

//Spring按钮类   充当具体产品
public class SpringButton implements Button {
    public void display() {
        System.out.println("显示绿色按钮");
    }
}



package com.product.button.impl;

import com.product.button.Button;


public class SummerButton implements Button {
    public void display() {
        System.out.println("显示红色按钮");
    }
}

**************************************************************************************
package com.product.ComboBox;

//组合框接口 充当抽象角色
public interface ComboBox {
    public void display();
}


package com.product.ComboBox.impl;


import com.product.ComboBox.ComboBox;

public class SpringComboBox implements ComboBox {
    public void display() {
        System.out.println("显示绿色边框组合框");
    }
}


package com.product.ComboBox.impl;

import com.product.ComboBox.ComboBox;

public class SummerComboBox implements ComboBox {
    public void display() {
        System.out.println("显示红色边框组合框");
    }
}



********************************************************************************************************
package com.product.TextField;


public interface TextField {
    public void display();
}


package com.product.TextField.impl;

import com.product.TextField.TextField;

//Spring文本框  充当具体产品
public class SpringTextField implements TextField {
    public void display() {
        System.out.println("显示绿色边框文本框");
    }
}




package com.product.TextField.impl;


import com.product.TextField.TextField;
//Summer文本框  充当具体产品
public class SummerTextField implements TextField {
    public void display() {
        System.out.println("显示红色边框文本框");
    }
}


*************************************************************************************************

import com.factory.SkinFactory;
import com.factory.impl.SpringSkinFactory;
import com.factory.impl.SummerSkinFactory;
import com.product.ComboBox.ComboBox;
import com.product.TextField.TextField;
import com.product.button.Button;

public class Test {
    public static void main(String[] args) {
//        使用抽象层定义
        SkinFactory skinFactory;

        Button button;
        TextField textField;
        ComboBox comboBox;

        skinFactory=new SpringSkinFactory();

        button=skinFactory.createButton();
        textField=skinFactory.createTextField();
        comboBox=skinFactory.createComboBox();

        button.display();
        textField.display();
        comboBox.display();
        System.out.println("*********************************");

        skinFactory=new SummerSkinFactory();

        button=skinFactory.createButton();
        textField=skinFactory.createTextField();
        comboBox=skinFactory.createComboBox();

        button.display();
        textField.display();
        comboBox.display();

    }
}

抽象工厂

package com.factory;


import com.product.AbstractProductWoman;
import com.product.AbstractProductMan;

//定制抽象工厂类或者接口
public interface AbstractFactory {
    public AbstractProductWoman createWoman();
    public AbstractProductMan createMan();
}

具体工厂

package com.factory;

import com.product.AbstractProductWoman;
import com.product.ConcreteProducNorthtMan;
import com.product.ConcreteProductNorthWoman;
import com.product.AbstractProductMan;
//具体工厂类
public class ConcreteNorthFactory implements AbstractFactory {
    public AbstractProductWoman createWoman() {
        return new ConcreteProducNorthtMan();
    }

    public AbstractProductMan createMan() {
        return new ConcreteProductNorthWoman();
    }
}



package com.factory;


import com.product.AbstractProductWoman;
import com.product.ConcreteProductSouthMan;
import com.product.ConcreteProductSouthWoman;
import com.product.AbstractProductMan;
//具体工厂类
public class ConcreteSouthFactory implements AbstractFactory {
    public AbstractProductWoman createWoman() {
        return new ConcreteProductSouthMan();
    }

    public AbstractProductMan createMan() {
        return new ConcreteProductSouthWoman();
    }
}

抽象产品1

package com.product;


public interface AbstractProductMan {
    public void manufactureMan();

}

抽象产品2

package com.product;


public interface AbstractProductWoman {
    public void manufactureWoman();
}

具体产品1

package com.product;


public class ConcreteProducNorthtMan implements AbstractProductWoman {
    public void manufactureWoman() {
        System.out.println("北方男人");
    }
}

package com.product;

public class ConcreteProductNorthWoman implements AbstractProductMan {

    public void manufactureMan() {
        System.out.println("北方女人");
    }
}

具体产品2

package com.product;


public class ConcreteProductSouthMan implements AbstractProductWoman {
    public void manufactureWoman() {
        System.out.println("南方男人");
    }
}


package com.product;


public class ConcreteProductSouthWoman implements AbstractProductMan {
    public void manufactureMan() {
        System.out.println("南方女人");
    }
}

建造者模式

产品角色

package com.shanghai.wanson.designpattern;

/**
 * 产品角色
 */
public class Product {
    private String partA;
    private String partB;
    private String partC;

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }
    public void show(){
        /**
         * 显示产品的特性
         */
        System.out.println("超微牌子");
    }
}

抽象建造者

package com.shanghai.wanson.designpattern;

/**
 * 抽象建造者
 */
abstract class Builder {
    /**
     * 创建产品对象
     */
    protected Product product=new Product();
    public abstract void builderPartA();
    public abstract void builderPartB();
    public abstract void builderPartC();
    /**
     * 返回产品对象
      */
    public Product getResult(){
        return product;
    }

}

具体建造者

package com.shanghai.wanson.designpattern;

/**
 * 具体建造者
 */
public class ConcreteBuilder extends Builder {
    @Override
    public void builderPartA() {
        product.setPartA("建造partA");
    }

    @Override
    public void builderPartB() {
        product.setPartB("建造partB");
    }

    @Override
    public void builderPartC() {
        product.setPartC("建造partC");
    }
}

指挥者

package com.shanghai.wanson.designpattern;

/**
 * 指挥者
 */
public class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }
    /**
     * 产品构建与组装方法
     */
    public Product construct(){
        builder.builderPartA();
        builder.builderPartB();
        builder.builderPartC();
        return builder.getResult();
    }
}

驱动测试/客户端测试

package com.shanghai.wanson.designpattern;

public class Driver {
    public static void main(String[] args) {
        Builder builder=new ConcreteBuilder();
        Director director=new Director(builder);
        Product product=director.construct();
        product.show();
    }
}

case:建造者模式小案例

package com.product;
//复合产品
public class Actor {
    private String Type;//脸色类型
    private String sex;//性别
    private String face;//脸型
    private String costume;//服装
    private String hairstyle;//发型

    public String getType() {
        return Type;
    }

    public void setType(String type) {
        Type = type;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getFace() {
        return face;
    }

    public void setFace(String face) {
        this.face = face;
    }

    public String getCostume() {
        return costume;
    }

    public void setCostume(String costume) {
        this.costume = costume;
    }

    public String getHairstyle() {
        return hairstyle;
    }

    public void setHairstyle(String hairstyle) {
        this.hairstyle = hairstyle;
    }
}


********************************************************************************************************************
package com.build;

import com.product.Actor;

//角色建造起    ：抽象建造者
public abstract class ActorBuilder {
    protected Actor actor=new Actor();
    public abstract void buildType();
    public abstract void buildSex();
    public abstract void buildFace();
    public abstract void buildCostume();
    public abstract void buildHairstyle();
    public Actor createActor(){
        return actor;
    }


}
****************************************************************************************************************************
package com.build.impl;

import com.build.ActorBuilder;
//天使角色建造器:具体建造者
public class AngelBuilder extends ActorBuilder {
    public void buildType() {
        actor.setType("天使");
    }

    public void buildSex() {
        actor.setSex("女");
    }

    public void buildFace() {
        actor.setFace("漂亮");
    }

    public void buildCostume() {
        actor.setCostume("白裙");
    }

    public void buildHairstyle() {
        actor.setHairstyle("披肩长发");
    }
}
******************************************************************************************************
package com.build.impl;

import com.build.ActorBuilder;
//魔鬼角色建造器:具体建造者
public class GhostBuilder extends ActorBuilder {
    public void buildType() {
        actor.setType("魔鬼");
    }

    public void buildSex() {
        actor.setSex("妖");
    }

    public void buildFace() {
        actor.setFace("丑陋");
    }

    public void buildCostume() {
        actor.setCostume("黑衣");
    }

    public void buildHairstyle() {
        actor.setHairstyle("光头");
    }
}
*******************************************************************************************************
package com.build.impl;

import com.build.ActorBuilder;

//英雄角色建造器:具体建造者
public class HeroBuilder extends ActorBuilder {
    public void buildType() {
        actor.setType("英雄");
    }

    public void buildSex() {
        actor.setSex("男");
    }

    public void buildFace() {
        actor.setFace("英俊");
    }

    public void buildCostume() {
        actor.setCostume("盔甲");
    }

    public void buildHairstyle() {
        actor.setHairstyle("飘逸");
    }
}
**********************************************************************************************************
package com.director;

import com.build.ActorBuilder;
import com.product.Actor;
//指挥官角色 充当指挥者
public class DirectorController {
    public Actor construct(ActorBuilder actorBuilder){
        actorBuilder.buildType();
        actorBuilder.buildSex();
        actorBuilder.buildFace();
        actorBuilder.buildCostume();
        actorBuilder.buildHairstyle();
        return actorBuilder.createActor();
    }
}



*****************************************************************************************

package com.test;

import com.build.ActorBuilder;
import com.build.impl.AngelBuilder;
import com.build.impl.GhostBuilder;
import com.build.impl.HeroBuilder;
import com.director.DirectorController;
import com.product.Actor;

public class Driver {

    public static void main(String[] args) {
     DirectorController directorController=new DirectorController();
        System.out.println("*********************天使**********************************");
        ActorBuilder actorBuilder=new AngelBuilder();
        Actor angle=directorController.construct(actorBuilder);
        String type=angle.getType();
        System.out.println(type+"的外观:\t\t");
        System.out.println("性别:\t"+angle.getSex());
        System.out.println("面容:\t"+angle.getFace());
        System.out.println("服装:\t"+angle.getCostume());
        System.out.println("发型:\t"+angle.getHairstyle());
        System.out.println("*******************************************************");

        System.out.println("**********************英雄*********************************");
        ActorBuilder actorBuilder1=new HeroBuilder();
        Actor hero=directorController.construct(actorBuilder1);
        String type1=hero.getType();
        System.out.println(type1+"的外观:\t\t");
        System.out.println("性别:\t"+hero.getSex());
        System.out.println("面容:\t"+hero.getFace());
        System.out.println("服装:\t"+hero.getCostume());
        System.out.println("发型:\t"+hero.getHairstyle());
        System.out.println("*******************************************************");

        System.out.println("**********************魔鬼*********************************");


        ActorBuilder actorBuilder2=new GhostBuilder();
        Actor ghost=directorController.construct(actorBuilder2);

        String type2=ghost.getType();
        System.out.println(type2+"的外观:\t\t");
        System.out.println("性别:\t"+ghost.getSex());
        System.out.println("面容:\t"+ghost.getFace());
        System.out.println("服装:\t"+ghost.getCostume());
        System.out.println("发型:\t"+ghost.getHairstyle());
        System.out.println("*******************************************************");



    }
}

原型模式

抽象原型类

package com.china.wanson;

public class Prototype implements Cloneable {
    public Prototype clone(){
        Prototype prototypeobject=null;
        try {
           prototypeobject=(Prototype)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return prototypeobject;
    }
}

具体原型类

package com.china.wanson;

public class ConcretePrototype extends Prototype {
    public void show(){
        System.out.println("原型模式实现类");
    }
}

驱动测试/客户端测试

package com.china.wanson;

public class Driver {
    public static void main(String[] args) throws CloneNotSupportedException {
        ConcretePrototype cp=new ConcretePrototype();
        for (int i = 0; i <10 ; i++) {
            ConcretePrototype clonecp=(ConcretePrototype) cp.clone();
            clonecp.show();
        }

    }
}

单例模式

单例模式驱动

package com.wanson.designpatten;

public class Singleton {
    private static volatile Singleton instance=null;        //单例对象
    private Singleton(){        //私有构造函数
    }
    //静态工厂方法
    public static Singleton getInstance(){
        if(instance==null){        //双重检测机制
            synchronized (Singleton.class){        //同步锁
                if(instance==null){
                    instance=new Singleton();        //双重检测机制
                }
            }
        }
        return instance;
    }
}

客户端测试/驱动测试

package com.wanson.designpatten;

import java.util.Calendar;

public class Driver {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        System.out.println(instance);
        Singleton secondInstance = Singleton.getInstance();
        System.out.println(secondInstance);
        Calendar calendar1=Calendar.getInstance();
        System.out.println(calendar1);
        Calendar calendar2=Calendar.getInstance();
        System.out.println(calendar2);
    }
}

单例模式案例

public class Singleton {
    /**
     * 双重锁校验机制     *
     */
    /*private static volatile Singleton instance=null;

    private Singleton() {
        System.out.println("产生一个学习委员");
    }
    public static synchronized Singleton getInstance() {
        if (instance==null){
            instance=new Singleton();
        }else {
            System.out.println("已经有一个学习委员，不能产生新的学习委员");
        }
        return instance;
    }

    public static void setInstance(Singleton instance) {
        Singleton.instance = instance;
    }
    public void getName(){
        System.out.println("我是学习委员:李远远");
    }*/
    /**
     * 懒汉 线程不安全
     */
    /*private static Singleton instance;

    public Singleton() {
        System.out.println("产生一个学习委员");
    }

    public static Singleton getInstance() {
        if(instance==null){
            instance=new Singleton();
        }else {
            System.out.println("已经有一个学习委员，不能产生新的学习委员");
        }
        return instance;
    }
    public void getName(){
        System.out.println("我是学习委员:李远远");
    }*/
    /**
     * 懒汉 线程安全
     */
    /*private static Singleton instance;

    public Singleton() {
        System.out.println("产生一个学习委员");
    }

    public static synchronized Singleton getInstance() {
        if(instance==null){
            instance=new Singleton();
        }else {
            System.out.println("已经有一个学习委员，不能产生新的学习委员");
        }
        return instance;
    }
    public void getName(){
        System.out.println("我是学习委员:李远远");
    }*/

    /**
     * 饿汉
     */
   /* private static Singleton instance=new Singleton();

    public Singleton() {
        System.out.println("产生一个学习委员");
    }

    public static Singleton getInstance() {
        if(instance==null){
            return instance;
        }else {
            System.out.println("已经有一个学习委员，不能产生新的学习委员");
            return instance;
        }

    }
    public void getName(){
        System.out.println("我是学习委员:李远远");
    }*/
    /**
     * 饿汉的 变异版
     */
    /*private static Singleton instance=null;

    static {
        instance=new Singleton();
    }
    public static Singleton getInstance() {
        if(instance==null){
            return instance;
        }else {
            System.out.println("已经有一个学习委员，不能产生新的学习委员");
            return instance;
        }

    }
    public void getName(){
        System.out.println("我是学习委员:李远远");
    }*/

    /**
     * 内部静态类
     */

    private static class SingletonHolder{
        private static final Singleton instance=new Singleton();
    }
    public Singleton() {
        System.out.println("产生一个学习委员");
    }
    public static final Singleton getInstance() {
        if(SingletonHolder.instance==null){
            return SingletonHolder.instance;
        }else {
            System.out.println("已经有一个学习委员，不能产生新的学习委员");
            return SingletonHolder.instance;
        }
    }
    public void getName(){
        System.out.println("我是学习委员:李远远");
    }

}



public class Driver {
    public static void main(String[] args) {
        Singleton singleton=Singleton.getInstance();
        singleton.getName();
        System.out.println("*****************************");
        Singleton singleton1=Singleton.getInstance();
        singleton1.getName();
        if(singleton==singleton1){
            System.out.println("same");
        }else {
            System.out.println("not same");
        }
    }
}

结构型模式

适配器模式

桥接模式

组合模式

装饰模式

外观模式

外观角色

package com.shanghai.wanson.designpattern;
/**
 *外观角色
 */
public class Facade {
    private subSystem01 system01=new subSystem01();
    private subSystem02 system02=new subSystem02();
    private  subSystem03 system03=new subSystem03();

    public void method(){
        system01.methon1();
        system02.methon2();
        system03.methon3();
    }
}

子系统角色01

package com.shanghai.wanson.designpattern;

/**
 * 子系统角色01
 */
public class subSystem01 {
    public void methon1(){
        System.out.println("子系统01方法被调用");
    }
}

子系统角色02

package com.shanghai.wanson.designpattern;

/**
 * 子系统角色02
 */
public class subSystem02 {
    public void methon2(){
    System.out.println("子系统02方法被调用");
}

}

子系统角色03

package com.shanghai.wanson.designpattern;

public class subSystem03 {
    public void methon3(){
        System.out.println("子系统03方法被调用");
    }
}

客户角色或者驱动测试

package com.shanghai.wanson.designpattern;

public class Driver {
    public static void main(String[] args) {
        Facade facade=new Facade();
        facade.method();
    }
}

外观模式优/缺点与适用环境

外观模式是一种使用频率非常高的设计模式，它通过引入ー个外观角色来简化客户端与子系统之间的交互，为复杂的子系统调用提供一个统一的入口，使子系统与客户端的耦合度降低，且客户端调用非常方便。
外观模式并不给系统增加任何新功能，它仅仅是简化调用接口。在几乎所有的软件中都能够找到外观模式的应用，
例如
绝大多数B/S系统都有一个首页或者导航页面，大部分C/S系统都提供了菜单或者工具栏，在这里首页和导航页面就访问子系统，降低了系统的复杂程度。
所有涉及与多个业务对象交互的场景都可以考虑 是BS系统的外观角色，而菜单和工具栏就是CS系统的外观角色，通过它们用户可以快使用外观模式进行重构，
例如 Java EE中的 Session外观模式。

外观模式优点

外观模式的优点主要如下

(1)它对客户端屏蔽了子系统组件，减少了客户端所需处理的对象数目，并使子系统使用起来更加容易。通过引入外观模式，客户端代码将变得很简单，与之关联的对象也很少。

(2)它实现了子系统与客户端之间的松耦合关系，这使得子系统的变化不会影响到调用它的客户端，只需要调整外观类即可


(3)一个子系统的修改对其他子系统没有任何影响，而且子系统内部变化也不会影响到外观对象。

外观模式缺点

外观模式的缺点主要如下:

(1)不能很好地限制客户端直接使用子系统类，如果对客户端访问子系统类做太多限制则减少了可变性和灵活性。

(2)如果设计不当，增加新的子系统可能需要修改外观类的源代码，违背了开闭原则。

外观模式适用环境

在以下情况下可以考虑使用外观模式:

(1)当要为访问一系列复杂的子系统提供一个简单入口时可以使用外观模式。

(2)客户端程序与多个子系统之间存在很大的依赖性。引入外观类可以将子系统与客户端解耦，从而提高子系统的独立性和可移植性。

(3)在层次化结构中可以使用外观模式定义系统中每一层的入口，层与层之间不直接产生联系，而通过外观类建立联系，降低层之间的耦合度。

享元模式

代理模式

package com.shanghai.subject;

//抽象主体角色
public abstract class AbstractSubject {
    public abstract void buyTV();
}





package com.shanghai.proxy;

import com.shanghai.subject.AbstractSubject;
//代理主体角色
public class Proxy extends AbstractSubject {
    RealProxy realProxyBuyer =new RealProxy();



    public void preRequest(){
        System.out.println("询问客户需求比如类型 尺寸 价位 等相关信息");
    }

    public void buyTV() {
        preRequest();
        realProxyBuyer.buyTV();
        postRequest();
    }

    public void postRequest(){
        System.out.println("负责把电视机送到客户家里，然后进行安装事宜");
    }
}





package com.shanghai.proxy;


import com.shanghai.subject.AbstractSubject;

//真实代理角色
public class RealProxy extends AbstractSubject {

    public void buyTV() {
        System.out.println("\t\t\t\t我已经在商场买了一台电视机");
    }
}




package com.shanghai.test;


import com.shanghai.proxy.Proxy;
import com.shanghai.subject.AbstractSubject;

public class Test {
    public static void main(String[] args) {
        AbstractSubject abstractSubject=
                new Proxy();
        abstractSubject.buyTV();
    }
}

行为型模式

职责链模式

package com.wanson.request;
// 采购单类  充当请求类
public class PurchaseRequest {
    private double amount;//采购金额
    private int number;//采购单编号
    private String purpose;//采购目的

    public PurchaseRequest(double amount, Integer number, String purpose) {
        this.amount = amount;
        this.number = number;
        this.purpose = purpose;
    }

    public Double getAmount() {
        return amount;
    }

    public void setAmount(double amount) {
        this.amount = amount;
    }

    public Integer getNumber() {
        return number;
    }

    public void setNumber(Integer number) {
        this.number = number;
    }

    public String getPurpose() {
        return purpose;
    }

    public void setPurpose(String purpose) {
        this.purpose = purpose;
    }
}

********************************************************************************************************************************************************

package com.wanson.handle;

import com.wanson.request.PurchaseRequest;

//审批者类    充当抽象处理者
public abstract class Approver {
    protected Approver successor;//定义后继对象
    protected String name;

    public Approver(String name) {
        this.name = name;
    }
    //设置后继者
    public void setSuccessor(Approver successor) {
        this.successor = successor;
    }
//    抽象请求处理方法
    public abstract void processRequest(PurchaseRequest request);
}
******************************************************************************************************************************************************

package com.wanson.handle.impl;

import com.wanson.handle.Approver;
import com.wanson.request.PurchaseRequest;
// 主任  充当具体处理者
public class Director extends Approver {

    public Director(String name) {
        super(name);
    }

    public void processRequest(PurchaseRequest request) {
        if (request.getAmount()<50000){
            System.out.println("主任"+this.name+"审批采购单:"+
                    request.getNumber()+",金额:"+
                    request.getAmount()+"元,采购目的:"+
                    request.getPurpose()+".");//处理请求
        }else {
            this.successor.processRequest(request);//转发请求
        }
    }
}
********************************************************************************************************************************************************************************

package com.wanson.handle.impl;

import com.wanson.handle.Approver;
import com.wanson.request.PurchaseRequest;
// 副董事长  充当具体处理者
public class VicePresident extends Approver {
    public VicePresident(String name) {
        super(name);
    }

    public void processRequest(PurchaseRequest request) {

        if (request.getAmount() < 100000) {
            System.out.println("副董事长" + this.name + "审批采购单:" +
                    request.getNumber() + ",金额:" +
                    request.getAmount() + "元,采购目的:" +
                    request.getPurpose() + ".");//处理请求

        } else {
            this.successor.processRequest(request);//转发请求
        }
    }
}
********************************************************************************************************************************************************

package com.wanson.handle.impl;

import com.wanson.handle.Approver;
import com.wanson.request.PurchaseRequest;
// 董事长  充当具体处理者
public class President extends Approver {
    public President(String name) {
        super(name);
    }

    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() < 500000) {
            System.out.println("董事长" + this.name + "审批采购单:" +
                    request.getNumber() + ",金额:" +
                    request.getAmount() + "元,采购目的:" +
                    request.getPurpose() + ".");//处理请求

        } else {
            this.successor.processRequest(request);//转发请求
        }
    }
}

*****************************************************************************************************************************************************************************************
package com.wanson.handle.impl;

import com.wanson.handle.Approver;
import com.wanson.request.PurchaseRequest;

public class Congress extends Approver {
    public Congress(String name) {
        super(name);
    }

    public void processRequest(PurchaseRequest request) {
        System.out.println("召开董事会审批采购单:" +
                request.getNumber() + ",金额:" +
                request.getAmount() + "元,采购目的:" +
                request.getPurpose() + ".");//处理请求
    }
}
***************************************************************************************************************************************************************************

package com.test;

import com.wanson.handle.*;
import com.wanson.handle.impl.Congress;
import com.wanson.handle.impl.Director;
import com.wanson.handle.impl.President;
import com.wanson.handle.impl.VicePresident;
import com.wanson.request.PurchaseRequest;

public class Test {
    public static void main(String[] args) {
        Approver
                sunwukong=new Director("孙悟空"),
                tangseng=new VicePresident("唐僧"),
                pusa=new President("观音菩萨"),
                congress=new Congress("董事会");
//        创建责任链
        sunwukong.setSuccessor(tangseng);
        tangseng.setSuccessor(pusa);
        pusa.setSuccessor(congress);

//        创建采购单
        PurchaseRequest purchaseRequest1=new PurchaseRequest(3000,10001,"西游记");
        sunwukong.processRequest(purchaseRequest1);

        PurchaseRequest purchaseRequest2=new PurchaseRequest(60000,10002,"水浒传");
        sunwukong.processRequest(purchaseRequest2);

        PurchaseRequest purchaseRequest3=new PurchaseRequest(160000,1003,"三国演义");
        sunwukong.processRequest(purchaseRequest3);

        PurchaseRequest purchaseRequest4=new PurchaseRequest(800000,1004,"The Plum in the Golden Vase");
        sunwukong.processRequest(purchaseRequest4);


    }
}

命令模式

解释器模式

迭代器模式

抽象迭代器

package com.china.wanson;

public interface Iterator {
    public boolean hasNext();
    public Object next();
}

具体迭代器

package com.china.wanson;

public class ConcreteIterator implements Iterator {
   private List list=null;
   private int index;

    public ConcreteIterator(List list) {
        super();
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        if(index>=list.getSize()){
            return false;
        }else {
            return true;
        }

    }

    @Override
    public Object next() {
        Object object=list.get(index++);
        return object;
    }
}

抽象聚合类

package com.china.wanson;

public interface List {
    public void add(Object object);
    public Object get(int index);
    public Iterator iterator();
    public int getSize();
}

具体聚合类

package com.china.wanson;

public class ConcreteAggregate implements List {
    private Object[]list;
    private int size=0;
    private int index=0;
    public ConcreteAggregate() {
        index=0;
        size=0;
        list=new Object[100];
    }

    @Override
    public void add(Object object) {
        list[index++]=object;
        size++;
    }

    @Override
    public Object get(int index) {
        return list[index];
    }

    @Override
    public Iterator iterator() {
        return new ConcreteIterator(this);
    }

    @Override
    public int getSize() {
        return size;
    }
}

驱动测试/测试客户端

package com.china.wanson;

public class Driver {
    public static void main(String[] args) {
        List list=new ConcreteAggregate();
        list.add("beijing");
        list.add("shanghai");
        list.add("shenzhen");
        Iterator iterator=list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

中介者模式

备忘录模式

观察者模式

抽象观察者

package com.shanghai.wanson.designpattern;

/**
 * 抽象观察者
 */
public interface Observer {
    void response();//反应
}

抽象目标

package com.shanghai.wanson.designpattern;

import java.util.ArrayList;
import java.util.List;

/**
 * 抽象目标
 */
abstract class Subject {
    //定义一个观察者集合    用于存储     所有观察者对象
    protected List<Observer> observers=new ArrayList<Observer>();
    //增加观察者方法
    public void add(Observer observer){
        observers.add(observer);
    }
    //删除观察者方法
    public void remove(Observer observer){
        observers.remove(observer);
    }
    public abstract void notifyObserve();//通知观察者方法
}

具体目标

package com.shanghai.wanson.designpattern;

/**
 * 具体目标
 */
public class ConcreteSubject extends Subject {
    @Override
    public void notifyObserve() {
        System.out.println("具体目标发生改变......");
        System.out.println("---------------------");
        for (Object object:observers){
            ((Observer)object).response();
        }
    }
}

具体观察者1

package com.shanghai.wanson.designpattern;

/**
 * 具体观察者1
 */
public class ConcreteObserver1 implements Observer {
    @Override
    public void response() {
        System.out.println("具体观察者1做出反应！！");
    }
}

具体观察者2

package com.shanghai.wanson.designpattern;

/**
 * 具体观察者2
 */
public class ConcreteObserver2 implements Observer {
    @Override
    public void response() {
        System.out.println("具体观察者2做出反应！！");
    }
}

测试客户端

package com.shanghai.wanson.designpattern;

/**
 * 观察者设计模式
 */
public class ObserverPattern {
    public static void main(String[] args) {
        Subject subject=new ConcreteSubject();
        Observer observer1=new ConcreteObserver1();
        Observer observer2=new ConcreteObserver2();

        subject.add(observer1);
        subject.add(observer2);

        subject.notifyObserve();
    }
}

观察者模式优/缺点与适用环境

观察者模式是一种使用频率非常高的设计模式，无论是移动应用、web应用或者桌面应用，观察者模式几乎无处不在，它为实现对象之间的联动提供了一套完整的解决方案，
凡是涉及一对一或者一对多的对象交互场都可以使用观察者模式。
观察者模式广泛应用于各种编程语言的GUI事件处理的实现，
在基于事件的XML解析技术(例如SAX2)
以及Web事件处理中也都使用了观察者模式。

观察者模式优点

观察者模式优点观察者模式的优息主要如下:

        (1)可以实现表示层和数据逻辑层的分离，定义了稳定的消息更新传递机制，并抽象了更新接口，使得可以有各种各样不同的表示层充当具体观察者角色。


         (2)在观察目标和观察者之间建立一个抽象的耦合。观察目标只需要维持一个抽象观察者的集合，无须了解其具体观察者，由于观察目标和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次

        (3)支播通信，观察目标会向所有已注册的观察者对象发送通知，简化了一对多系统设计的难度

        (4)符合开团原则，增加新的具体观察者无须修改原有系统代码，在具体观察者与观察目标之间不存在关联关系的情况下增加新的观察目标也很方便。

观察者模式缺点

        (1)如果一个观察目标对象有很多直接和间接观察者，将所有的观察者都通知到会花很多时间。


         (2)如果在观察者和观察目标之间存在循环依赖，观察目标会触发它们之间进行循环调用，可能导致系统崩

        (3)观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的而仅仅只是知道观察目标发生了变化。

观察者模式适用环境

在以下情况下可以考虑使用观察者模式: 
        (1)ー个抽象模型有两个方面 ,
                        其中一个方面依赖于另一个方面，将这两个方面封装在独立的对象中使它们可以各自独立地改变和复用

        (2)一个对象的改变将导致一个或多个其他对象也发生改变，而并不知道具体有多少对象将发生改变，也不知道这些对象是谁。

         (3)需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。

状态模式

抽象状态类

package com.com.china.wanson.statepattern;

/**
 * 抽象状态类
 */
public abstract class State {
    public abstract void Handle(Context context);
}

具体状态类

package com.com.china.wanson.statepattern;

/**
 * 具体状态类1
 */
public class ConcreteState1 extends State {

    @Override
    public void Handle(Context context) {
        System.out.println("当前状态A:");
        context.setState(new ConcreteState2());
    }
}

package com.com.china.wanson.statepattern;

/**
 * 具体状态类2
 */
public class ConcreteState2 extends State {
    @Override
    public void Handle(Context context) {
        System.out.println("当前状态B");
        context.setState(new ConcreteState1());
    }
}

环境类或上下文类

package com.com.china.wanson.statepattern;

/**
 * 环境类
 */
public class Context {
    private State state;
    //定义环境类的初始状态
    public Context() {
        this.state = new ConcreteState1();
    }
    //读取状态
    public State getState() {
        return state;
    }
    //设置新的状态
    public void setState(State state) {
        this.state = state;
    }
    //对请求做处理
    public void Handle(){
        state.Handle(this);
    }
}

驱动测试/客户端测试

package com.com.china.wanson.statepattern;

public class Driver {
    public static void main(String[] args) {
        Context context=new Context();
        context.Handle();
        context.Handle();
        context.Handle();
        context.Handle();
        context.Handle();
    }
}

策略模式

模板方法模式

访问者模式