设计模式java代码实现

创建型模式(5)

单例模式

package site.yuanrui.establish;
/**  
 * @Title: Single.java  
 * @Package site.yuanrui  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
/*节省内存空间
避免频繁创建销毁对象，提高性能
避免对共享资源的多重占用
可以全局访问*/
public class SinglePattern {
    public static void main(String[] args) {
        System.out.println("Singleto:"+(Singleton.getInstance()!=null));
        System.out.println("Singleto2:"+(Singleton2.getInstance()!=null));
    }

}
class Singleton{
    private static Singleton singleton = new Singleton();
    private Singleton(){}
    public static Singleton getInstance() {
        return singleton;
    }
}
class Singleton2{
    private static Singleton2 singleton2;
    private Singleton2(){}
    public static synchronized Singleton2 getInstance(){
        if (singleton2 ==null) {
            singleton2 = new Singleton2();
        }
        return singleton2;
    }
}

工厂模式

package site.yuanrui.establish;
/**  
 * @Title: FactoryPattern.java  
 * @Package site.yuanrui  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
public class FactoryPattern {
    public static void main(String[] args) {
        IFactory factory = new Factory();
        IProduct product = factory.createProduct();
        product.productMethod();
    }

}
interface IProduct{
    public void productMethod();
}
class Product implements IProduct{
    @Override
    public void productMethod() {
        System.out.println("Product");
        
    }
}
interface IFactory{
    public IProduct createProduct();
}
class Factory implements IFactory{

    @Override
    public IProduct createProduct() {
            return new Product();
    }
}

抽象工厂模式

package site.yuanrui.establish;
/**  
 * @Title: AbstractFactoryPattern.java  
 * @Package site.yuanrui  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
//可以在类内部对产品族进行约束                          
public class AbstractFactoryPattern {
    public static void main(String[] args) {
        IFactory1 factory = new Facctory();
        factory.createProduct1().show();
        factory.createProduct2().show();
    }

}
interface IProduct1{
    public void show();
}
interface IProduct2{
    public void show();
}
class Product1 implements IProduct1{

    @Override
    public void show() {
        System.out.println("这是I型产品");
    }
}
class Product2 implements IProduct2{

    @Override
    public void show() {
        System.out.println("这是II型产品");
    }
}
interface IFactory1{
    public IProduct1 createProduct1();
    public IProduct2 createProduct2();
}
class Facctory implements IFactory1{

    @Override
    public IProduct1 createProduct1() {
        return new Product1();
    }

    @Override
    public IProduct2 createProduct2() {
        return new Product2();
    }
    
}

建造者模式

package site.yuanrui.establish.builderPattern;


/**  
 * @Title: BuilderPattern.java  
 * @Package site.yuanrui  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
/**
一般用来创建更为复杂的对象，因为对象的创建过程更为复炸，因此将对象的创建过程独立出来组成一个新的类-导演类
 */
public class BuilderPattern {
    public static void main(String[] args) {
        Director director = new Director();
        Product product1 = director.getAProduct();
        Product product2 = director.getBPorduct();
        product1.showProduct();
        product2.showProduct();
    }
}
class Product{
    private String name;
    private String type;
    public void showProduct(){
        System.out.println("名称："+this.name);
        System.out.println("型号："+this.type);
    }
    public void setName(String name){
        this.name = name;
    }
    public void setType(String type){
        this.type = type;
    }
}
abstract class Builder{
    public abstract void setPart(String arg1,String arg2);
    public abstract Product getProduct();
}
class ConcreteBuilder extends Builder{
    private Product product = new Product();
    public Product getProduct(){
        return product;
    }
    @Override
    public void setPart(String arg1, String arg2) {
        product.setName(arg1);
        product.setType(arg2);;
    }
}
class Director{
    private Builder builder = new ConcreteBuilder();
    public Product getAProduct(){
        builder.setPart("宝马汽车", "X7");
        return builder.getProduct();
    }
    public Product getBPorduct(){
        builder.setPart("奥迪汽车", "Q5");
        return builder.getProduct();
    }
}

原型模式

package site.yuanrui.establish;
/**  
 * @Title: PrototypePattern.java  
 * @Package site.yuanrui  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
/*主要用于队形的复制
简化对象的创建
需要重复地创建相似对象的可以考虑使用原型模式*/
public class PrototypePattern {
    public static void main(String[] args) {
        ConcretePrototype cp = new ConcretePrototype();
        for (int i = 0; i < 10; i++) {
            ConcretePrototype clonecp = (ConcretePrototype) cp.clone();
            clonecp.show();System.out.println(i);
        }
    }

}
class Prototype implements Cloneable{//只有实现了该接口的类上才能使用clone方法
    public Prototype clone(){
        Prototype prototype = null;
        try {
            prototype = (Prototype) super.clone();
        }
        catch (CloneNotSupportedException e) {
            e.printStackTrace();
         }
        return prototype;
    }
}
class ConcretePrototype extends Prototype{
    public void show() {
        System.out.print("原型模式实现类");
        
    }
}

结构型模式(7)

适配器模式

package site.yuanrui.structure;

import com.sun.org.apache.xerces.internal.impl.dv.ValidatedInfo;

/**  
 * @Title: AdapterPattern.java  
 * @Package site.yuanrui.structure  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月24日  
 * @version V1.0  
*/
/*
 * 适用性：
 * 想使用一个已经存在的类，而它的接口不符合你的需求
 * 你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类协同工作
 * 想使用一些已经存在的子类，不可能对每个进行子类化以匹配他们的接口。对象适配器可以适配它的父类接口
 * */
public class AdapterPattern {
    public static void main(String[] args) {
        Target target = new Adapter(new Adaptee());
        target.adapteeMethod();
        target.adapterMethod();
    }
}
//定义Client使用的与特定领域相关的接口
interface Target{
    void adapteeMethod();
    void adapterMethod();
}
//定义一个已经存在的接口，这个接口需要适配
class Adaptee{
    public void adapteeMethod(){
        System.out.println("Adaptee method!");
    }
}
//对Adaptee的接口与Target接口进行适配
class Adapter implements Target{
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }
    @Override
    public void adapteeMethod() {
        adaptee.adapteeMethod();
    }
    @Override
    public void adapterMethod() {
        System.out.println("Adapter method!");
    }
}

桥接模式

package site.yuanrui.structure;


/**  
 * @Title: BridgingPattern.java  

 * @Package site.yuanrui.structure  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月24日  
 * @version V1.0  
*/
/*
 * 将抽象部分与它的实现部分分离，使它们都可以独立地变化
 * 
 * 
 * 不希望在抽象和它的实现部分之间有一个固定的绑定关系
 * 类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充
 * 对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译
 * 想在多个对象间共享实现，单同时要求客户并不知道这一点
 * */
public class BridgingPattern {
    public static void main(String[] args) {
        Person1 man = new Man1();
        Person1 lady = new Lady();
        Clothing jacket = new Jacker();
        Clothing trouser = new Trouser();
       
        
        
        jacket.personDressCloth(man);
        trouser.personDressCloth(man);
        
        jacket.personDressCloth(lady);
        trouser.personDressCloth(lady);
        System.out.println("====================");
        man.dress();
    }

}
//定义抽象类的接口：维护一个指想实现类对象的指针
abstract class Person1{
    private Clothing clothing;
    private String type;
    public Clothing getClothing() {
        return clothing;
    }
    public void setClothing(Clothing clothing) {
        this.clothing = clothing;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public abstract void dress();
    
}
//扩展由Person定义的接口
class Man1 extends Person1{
    public Man1() {
        setType("男人");
    }
    @Override
    public void dress() {
        Clothing clothing = getClothing();
        clothing.personDressCloth(this);
    }
    
}
class Lady extends Person1{
    public Lady() {
        setType("女人");
    }
    @Override
    public void dress() {
        Clothing clothing = getClothing();
        clothing.personDressCloth(this);
    }
    
}
//定义实现类的接口，该接口不一定要与person1的接口完全一一致
//一般，该接口仅提供基本操作，而person则定义了基于这些基本操作的较高层次的操作
abstract class Clothing{
    public abstract void personDressCloth(Person1 person);
}
//实现clothing接口并定义它的具体实现
class Trouser extends Clothing{
    public void personDressCloth(Person1 person1) {
        System.out.println(person1.getType()+"穿裤子");
        person1.setClothing(this);
    }
}
class Jacker extends Clothing{

    @Override
    public void personDressCloth(Person1 person1) {
        System.out.println(person1.getType()+"穿马甲");
        person1.setClothing(this);
    }
    
}

组合模式

package site.yuanrui.structure;

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

/**  
 * @Title: CombinationPattern.java  
 * @Package site.yuanrui.structure  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月24日  
 * @version V1.0  
*/
/**
 *想表示对象的部分-整体层次结构
 *希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象
 */
public class CombinationPattern {
    public static void main(String[] args) {
        Employer pm = new ProjectManager("项目经理");
        Employer pa = new ProjectAssistant("项目助理");
        Employer programmer1 = new Programmer("程序员一");
        Employer programmer2 = new Programmer("程序员2");
        
        
        pm.add(pa);
        pm.add(programmer2);
        
        List<Employer> ems = pm.getEmployers();
        for (Employer em:ems) {
            System.out.println(em.getName());
        }
    }
}
//为组合中的对象声明接口，实现所有类共有的接口的缺省行为
abstract class Employer{
    private String name;
    public List < Employer > employers;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    public abstract void add(Employer employer);
    public abstract void delete(Employer employer);
    public void printfInfo() {
        System.out.println(name);
    }
    public List < Employer > getEmployers() {
        return this.employers;
    }
}
//叶子节点，叶节点没有子节点，在组合中定义结点对象的行为
class Programmer extends Employer{
    public Programmer(String name) {
        setName(name);
        employers = null;//程序员，表示没有下属了
    }
    public void add(Employer employer) {
    }
    @Override
    public void delete(Employer employer) {
    }
}
class ProjectAssistant extends Employer{
    public ProjectAssistant(String name) {
       setName(name);
       employers = null;
    }
    @Override
    public void add(Employer employer) {
        // TODO Auto-generated method stub
    }
    @Override
    public void delete(Employer employer) {
        // TODO Auto-generated method stub
    }
}
//定义有子部件的那些部件的行为
//存储子部件
class ProjectManager extends Employer{
    public ProjectManager(String name) {
        setName(name);
        employers = new ArrayList<>();
    }

    @Override
    public void add(Employer employer) {
        employers.add(employer);
    }

    @Override
    public void delete(Employer employer) {
        employers.remove(employer);
    }
}

装饰模式

package site.yuanrui.structure;

import java.lang.annotation.Repeatable;

/**  
 * @Title: DecoratePattern.java  
 * @Package site.yuanrui.structure  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月24日  
 * @version V1.0  
*/
/*
 * 适用性：
 *  在不影响其他对象的情况下，以动态、透明的方法给单个对象添加职责
 *  处理那些可以撤销的职责
 *  当不能采用生成子类的方法进行扩充时
 * */
public class DecoratePattern {
    public static void main(String[] args) {
        Man man = new Man();
        ManDecoratorA md1 = new ManDecoratorA();
        ManDecoratorB md2 = new ManDecoratorB();
        md1.setPerson(man);
        md2.setPerson(md1);
        md2.eat();
    }
}
//定义一个对象接口，可以给这些对象动态添加职责
interface Person{
    void eat();
}
class Man implements Person{

    @Override
    public void eat() {
        System.out.println("男人在吃");
    }
}
//维持一个指向Component对象的指针，并定义一个与Component接口一一致的接口
abstract class Decorator implements Person{
    protected Person person;
    public void setPerson(Person person) {
        this.person = person;
    }
    public void eat(){
        person.eat();
    }
}
//向组件添加职责
class ManDecoratorA extends Decorator{
    public void eat(){
        super.eat();
        reEat();
        System.out.println("ManDecoratorA类");
    }
    public void reEat() {
        System.out.println("在吃一顿饭");
    }
}
class ManDecoratorB extends Decorator{
    public void eat() {
        super.eat();
        System.out.println("===========");
        System.out.println("ManDecoratorB类");
    }
}

外观模式

package site.yuanrui.structure;
/**  
 * @Title: AppearancePattern.java  
 * @Package site.yuanrui.structure  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月24日  
 * @version V1.0  
*/
/*
 * 为子系统中的一组接口提供一个一致的界面
 * 
 * 定制子系统同时不影响不需要定制的客户
 * 分离了子系统与客户以及其他的子系统分离，提高了子系统的独立性和可移植性
 * 使用该模式定义子系统中每层的入口点，如果子系统之间是相互依赖的，可以让他们通过facade进行通讯
 * */
public class AppearancePattern {
    public static void main(String[] args) {
        ServiceA sa = new ServiceAImpl();
        ServiceB sb = new ServiceBImpl();
        sa.methodA();
        sb.methodB();
        
        
        System.out.println("=================");
        
        
        Facade facade = new Facade();
        facade.methodA();
        facade.methodB();
    }
}
interface ServiceA{
    void methodA();
}
interface ServiceB{
    void methodB();
}

interface ServiceC{
    void methodC();
}
class ServiceAImpl implements ServiceA{

    @Override
    public void methodA() {
        System.out.println("这是服务A");
    }
    
}
class ServiceBImpl implements ServiceB{

    @Override
    public void methodB() {
        System.out.println("这是服务B");
    }
}
class ServiceCImpl implements ServiceC{

    @Override
    public void methodC() {
        System.out.println("这是服务C");
    }
}
//参与者
class Facade{
    ServiceA sa;
    ServiceB sb;
    ServiceC sc;
    public Facade() {
        sa = new ServiceAImpl();
        sb = new ServiceBImpl();
        sc = new ServiceCImpl();
    }
    public void methodA() {
        sa.methodA();
        sb.methodB();
    }
    public void methodB() {
          sb.methodB();
          sc.methodC();
    }
    public void methodC() {
          sc.methodC();
          sa.methodA();
    }
}

享元模式

package site.yuanrui.structure;
/**  
 * @Title: SharePattern.java  
 * @Package site.yuanrui.structure  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月24日  
 * @version V1.0  
*/
/*
 * 使用共享技术有效地支持大量细粒度的对象
 * */
public class SharePattern {
    //TODO 共元模式

}

代理模式

package site.yuanrui.structure;
/**  
 * @Title: AgentPattern.java  
 * @Package site.yuanrui.structure  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月24日  
 * @version V1.0  
*/
/*
 * 为其他对象提供一种代理以控制对这个对象的访问
 * 适用性：
 *  远程代理为一个对象在不同的地址空间提供局部代表‘
 *  虚代理根据需要创建开销很大的对象
 *  保护代理控制对原始对象的访问
 *  智能指引取代了简单的指针，它在访问对象时执行了一些附加操作
 * 
 * */
public class AgentPattern {
    public static void main(String[] args) {
        Object object = new ProxyObject();
        object.action();
    }
}
class ProxyObject implements Object{
    Object object;
    public ProxyObject() {
        System.out.println("这是代理类");
        object = new ObjectImpl();
    }
    @Override
    public void action() {
        System.out.println("代理开始");
        object.action();
        System.out.println("代理结束");
    }
}
interface Object{
    void action();
}
class ObjectImpl implements Object{

    @Override
    public void action() {
        System.out.println("==============");
        System.out.println("这是被代理的类");
        System.out.println("==============");
    }
}

行为型模式(11)

访问者模式

package site.yuanrui.behavior;

import java.util.*;

/**  
 * @Title: VisitorPattern.java  
 * @Package site.yuanrui.behavior  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
/**
扩展性良好：元素类可以通过接收不同访问者来实现对不同操作的扩展
适用场景：一个对象中存在这一些与本对象不相干的操作，将这些操作封装到访问者中去
        一组对象中，存在着相似的操作，将这些重复的操作封装到访问者中
缺陷：添加新的元素类较复杂
 */
public class VisitorPattern {
    public static void main(String[] args) {
        List < Element > list = ObjectStruture.getList();
        for (Element element : list) {
            element.accept(new Visitor());
        }
    }

}
abstract class Element{
    public abstract void accept(IVisitor visitor);
    public abstract void doSomething();
}
interface IVisitor{
    public void visit(ConcreteElement1 el1);
    public void visit(ConcreteElement2 el2);
    
}
class ConcreteElement1 extends Element{

    @Override
    public void accept(IVisitor visitor) {
        visitor.visit(this);
    }

    @Override
    public void doSomething() {
        System.out.println("这是元素1");
    }
   
}
class ConcreteElement2 extends Element{

    @Override
    public void accept(IVisitor visitor) {
        visitor.visit(this);
    }

    @Override
    public void doSomething() {
        System.out.println("这是元素2");
    }
   
}
class Visitor implements IVisitor{
    public void visit(ConcreteElement1 el1) {
        el1.doSomething();
    }

    public void visit(ConcreteElement2 el2) {
        el2.doSomething();
    }
}
class ObjectStruture{
    public static List<Element> getList(){
        List < Element > list = new ArrayList<Element>();
        Random ran = new Random();
        for (int i = 0; i < 10; i++) {
            int a = ran.nextInt(100);
            if (a>50) {
                list.add(new ConcreteElement1());
            }else{
                list.add(new ConcreteElement2());
            }
        }
        return list;
    }
}

模版模式

package site.yuanrui.behavior;

import jdk.internal.dynalink.beans.StaticClass;

/**  
 * @Title: templatePattern.java  
 * @Package site.yuanrui.behavior  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
public class TemplatePattern {
    public static int[] a = {10,32,1,9,5,7,12,0,4,3};
    public static void main(String[] args) {
        AbstractSort s = new ConcreteSort();
        s.showSortResult(a);
    }

}
abstract class AbstractSort{
    /**
     * 
     * @Title: sort 
     * @Description: 将数组array由小到大排序
     * @param array 
     * @return void 
     * @throws**
     */
    protected abstract void sort(int[] array);
    public void showSortResult(int[] array) {
        this.sort(array);
        System.out.println("排序结果");
        for (int i = 0; i < array.length; i++) {
            System.out.printf("%3s",array[i]);
        }
    }
}
class ConcreteSort extends AbstractSort{

    protected void sort(int[] array) {
        for(int i = 0;i<array.length-1;i++){
            selectSort(array,i);
        }
    }
    private void selectSort(int[] array, int index) {
        int MinValue = 32767;
        int indexMin = 0;
        int Temp;
        for (int i = index; i < array.length; i++) {
            if (array[i]<MinValue) {
                MinValue = array[i];
                indexMin = i;
            }
        }
        Temp = array[index];
        array[index] = array[indexMin];
        array[indexMin] = Temp;
    }
   
}

策略模式

package site.yuanrui.behavior;
/**  
 * @Title: StrategyPattern.java  
 * @Package site.yuanrui.behavior  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
//定义一组算法，将每个算法都封装起来，并且使他们之间可以互换
/**
 策略类之间可以自由切换，易于扩展，避免使用多重条件
 
 缺点：维护各个策略类会带来额外开销
     必须对客户端（调用者）暴露所有的策略类
 */
public class StrategyPattern {
    public static void main(String[] args) {
        Context context;
        System.out.println("----执行策略1----");
        context = new Context(new ConcreteStrategy1());
        context.execute();
        
        System.out.println("----执行策略2----");
        context = new Context(new ConcreteStrategy2());
        context.execute();
        
    }
}
interface IStrategy{
    public void doSomething();
}
class ConcreteStrategy1 implements IStrategy{
    public void doSomething(){
        System.out.println("具体策略1");
    }
}
class ConcreteStrategy2 implements IStrategy{

    @Override
    public void doSomething() {
        System.out.println("具体策略2");
    }
    
}
class Context{
    private IStrategy strategy;
    public Context(IStrategy strategy){
        this.strategy = strategy;
    }
    public void  execute(){
        strategy.doSomething();
    }
}

状态模式

package site.yuanrui.behavior;
/**  
 * @Title: StatePattern.java  
 * @Package site.yuanrui.behavior  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月24日  
 * @version V1.0  
*/
public class StatePattern {
    public static void main(String[] args) {
        Context1 context1 = new Context1();
        context1.setWeather(new Sunshine());
        System.out.println(context1.weatherMessage());
        
        
        System.out.println("===========");
        
        Context1 context12 = new Context1();
        context12.setWeather(new Rain());
        System.out.println(context12.weatherMessage());
    }
}
class Context1{
    private Weather weather;
    public void setWeather(Weather weather) {
        this.weather = weather;
    }
    public Weather getWeather() {
        return this.weather;
    }
    public String weatherMessage(){
        return weather.getWeather();
    }
}
interface Weather{
    String getWeather();
}
class Rain implements Weather{

    @Override
    public String getWeather() {
        return "下雨";
    }
}
class Sunshine implements Weather{

    @Override
    public String getWeather() {
        return "阳光";
    }
}

观察者模式

package site.yuanrui.behavior;

import java.util.Observable;
import java.util.Vector;

/**  
 * @Title: ObserverPattern.java  
 * @Package site.yuanrui.behavior  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
public class ObserverPattern {
    public static void main(String[] args) {
        Subject sub = new ConcreteSubject();
        sub.addObserver(new ConcreteObserver1());;
        sub.addObserver(new ConcreteObserver2());
        sub.doSomething();
    }
}
abstract class Subject{
    private Vector < Observer > obs = new Vector<Observer>();
    public void addObserver(Observer obs){
        this.obs.add(obs);
    }
    public void delObserver(Observer obs){
        this.obs.remove(obs);
    }
    public void notifyObserver(){
        for(Observer o:obs){
            o.update();
        }
    }
    public abstract void doSomething();
}
//被观察者
class ConcreteSubject extends Subject{
    public void doSomething(){
        System.out.println("被观察者事件发生");
        this.notifyObserver();
    }
}
interface Observer{
    public void update();
}
class ConcreteObserver1 implements Observer{
    @Override
    public void update() {
        System.err.println("观察者1收到信息，并进行处理");
     }

}
class ConcreteObserver2 implements Observer{
    public void update() {
        System.err.println("观察者2收到信息，并进行处理");
     }
}

备忘录模式

package site.yuanrui.behavior;


/**  
 * @Title: MemorandumPattern.java  
 * @Package site.yuanrui.behavior  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
/*
 * 发起人状态改变时，使用备忘录模式可以把这个错误的改变还原
 * 备份的状态是保存在发起人角色之外的，这样，发起人角色就不需要对各个备份的状态进行管理
 * 缺点：对资源的消耗严重；
 * 可用于jdbc事务操作，文本编辑器的ctrl+Z恢复等
 * */
public class MemorandumPattern {
        public static void main(String[] args) {
            Originator originator = new Originator();
            originator.setState("状态1");
            System.out.println("初始状态"+originator.getState());
            Caretaker caretaker = new Caretaker();
            caretaker.setMemento(originator.createMemento());
            
            originator.setState("状态2");
            System.out.println("状态2");
            System.out.println("改变后状态:"+originator.getState());
            originator.restoreMemento(caretaker.getMemento());
            System.out.println("恢复后状态:"+originator.getState());
        }
}
//发起者
class Originator{
    private String state = "";
    public String getState() {
        return this .state;
    }
    public void setState(String state){
        this.state = state;
    }
    public Memento createMemento() {
        return new Memento(this.state);
    }
    public void restoreMemento(Memento memento){
        this.setState(memento.getState());
    }
}
//备忘录
class Memento{
    private String state = "";
    public Memento(String state) {
        this.state = state;
    }
    public String getState(){
        return this.state;
    }
    public void setState(String state){
        this.state = state;
    }
}
//管理者
class Caretaker{
    private Memento memento;
    public Memento getMemento() {
        return memento;
    }
    public void setMemento(Memento memento){
        this.memento = memento;
    }
}

中介者模式

package site.yuanrui.behavior;
/**  
 * @Title: Intermediary.java  
 * @Package site.yuanrui.behavior  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
public class IntermediaryPattern {
    
}
abstract class AbstractColleague{
    protected int number;
    public int getNumber(){
        return number;
    }
    public void setNumber(int number){
        this.number = number;
    }
    public abstract void setNumber(int number,AbstractColleague coll);
}
class ColleagueA extends AbstractColleague{
    public void setNumber(int number,AbstractColleague coll){
        this.number = number;
        coll.setNumber(number*100);
    }
}
class ColleagueB extends AbstractColleague{
    public void setNumber(int number,AbstractColleague coll) {
        this.number = number;
        coll.setNumber(number/100);
    }
}

迭代器模式

package site.yuanrui.behavior;

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

import sun.launcher.resources.launcher;

/**  
 * @Title: IteratorPattern.java  
 * @Package site.yuanrui.behavior  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
/*简化了便利方式
可以提供多种遍历方式
封装性良好
缺点：较为繁琐
Collection,List,Set,Map等集合都有自己的迭代器
*/
public class IteratorPattern {
    public static void main(String[] args) {
        Aggregate ag = new ConcreteAggregate();
        ag.add("小明");
        ag.add("小红");
        ag.add("小刚");
        Iterator it = ag.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
            
        }
    }

}
interface Iterator{
    public Object next();
    public boolean hasNext();
}
class ConcreteIterator implements Iterator{
    private List list = new ArrayList<>();
    private int cursor = 0;
    public ConcreteIterator(List list) {
        this.list = list;
    }
    @Override
    public Object next() {
        Object obj = null;
        if (this.hasNext()) {
            obj = this.list.get(cursor++);
        }
        return obj;
    }
    @Override
    public boolean hasNext() {
        if (cursor == list.size()) {
            return false;
        }
        return true;
    }
}
interface Aggregate{
    public void add(Object obj);
    public void remove(Object obj);
    public Iterator iterator();
}
class ConcreteAggregate implements Aggregate{
    private List list = new ArrayList();
    @Override
    public void add(Object obj) {
        list.add(obj);
    }
    

    @Override
    public void remove(Object obj) {
        list.remove(obj);
    }

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

解释器模式

package site.yuanrui.behavior;

import java.util.Stack;

/**  
 * @Title: InterpreterPattern.java  
 * @Package site.yuanrui.behavior  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月24日  
 * @version V1.0  
*/
/*
 * 给定一种语言，定义他的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中句子
 * 
 * 
 * 使用场景
 *      有一个简单的语法规则
 *      一些重复发生的问题
 *  缺陷：维护麻烦，引起类的膨胀，由于使用的大量的循环和递归，效率是一个不容忽视的问题
 * */
public class InterpreterPattern {
    public static void main(String[] args) {
        String expression = "";
        char[] charArray = expression.toCharArray();
        Context2 ctx = new Context2();
        Stack < Expression > stack = new Stack<Expression>();
        for (int i = 0; i < charArray.length; i++) {
            //进行语法判断，递归调用
        }
        Expression exp = stack.pop();
        exp.interpreter(ctx);
    }
}
class Context2{}
abstract class Expression{
    public abstract Object interpreter(Context2 ctx);
}
class TerminalExpression extends Expression{
    public Object interpreter(Context2 ctx) {
        return null;
    }
}
class NonterminalExpression extends Expression{
    public NonterminalExpression(Expression...expressions) {
    }
    public Object interpreter(Context2 ctx) {
        return null;
    }
}

命令模式

package site.yuanrui.behavior;
/**  
 * @Title: CommandPattern.java  
 * @Package site.yuanrui.behavior  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
/**
将命令的调用者与执行者分开，使双方不必关心对方是如何操作的
    封装性好，扩展性好
缺陷：命令如果很多，开发难度增加
 */
public class CommandPattern {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Command command = new ConcreteCommand(receiver);
        //客户端直接执行具体命令方式（此方式与类图相符）
        command.execute();
        
        //客户端通过调用者来执行命令
        Invoker invoker = new Invoker();
        invoker.setCommand(command);
        invoker.action();
    }
}
//调用者
class Invoker{
    private Command command;
    public void setCommand(Command command){
        this.command = command;
    }
    public void action() {
        this.command.execute();
    }
    
}
abstract class Command{
    public abstract void execute();
}
class ConcreteCommand extends Command{
    private Receiver receiver;
    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }
    @Override
    public void execute() {
        this.receiver.doSomething();
    }
}
//接收者
class Receiver{
    public void doSomething() {
        System.out.println("接收者-业务逻辑处理");
    }
    
}

责任链模式

package site.yuanrui.behavior;


/**  
 * @Title: ResponsibilityPattern.java  
 * @Package site.yuanrui.behavior  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
//相对于if else相比，耦合性要低一下
public class ResponsibilityPattern {
    public static void main(String[] args) {
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();
        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);
        Response response = handler1.handleRequest(new Request(new Level(2)));
    }
}
class Level{
    private int level = 0;
    public Level(int level){
        this.level = level;
    }
    public boolean above(Level level){
        if (this.level >= level.level) {
            return true;
        }
        return false;
    }
}
class Request{
    Level level;
    public Request(Level level){
        this.level = level;
    }
    public Level getLevel(){
        return level;
    }
}
class Response{}
abstract class Handler{
    private Handler nexthandler;
    public final Response handleRequest(Request request){
        Response response = null;
        if (this.getHandlerLevel().above(request.getLevel())) {
            response = this.response(request);
        }else{
            if (this.nexthandler!=null) {
                this.nexthandler.handleRequest(request);
            }
            else {
                System.out.println("----没有合适的处理器----");
            }
            
        }
        return response;
    }
    public void setNextHandler(Handler handler){
        this.nexthandler = handler;
    }
    protected abstract Level getHandlerLevel();
    public abstract Response response(Request request);
}
class ConcreteHandler1 extends Handler{
    @Override
    protected Level getHandlerLevel() {
        return new Level(1);
    }

    @Override
    public Response response(Request request) {
        System.out.println("----请求由处理器1进行处理---");
        return null;
    }
}
class ConcreteHandler2 extends Handler{
    @Override
    protected Level getHandlerLevel() {
        return new Level(3);
    }

    @Override
    public Response response(Request request) {
        System.out.println("----请求由处理器2进行处理---");
        return null;
    }
}
class ConcreteHandler3 extends Handler{
    @Override
    protected Level getHandlerLevel() {
        return new Level(5);
    }

    @Override
    public Response response(Request request) {
        System.out.println("----请求由处理器3进行处理---");
        return null;
    }
}