设计模式

已转移

创建型

• 工厂模式

public class Replace {
    public static void main(String[] args){
         CardFactory card=new CardFactory();
         card.buyCard("mobilecard").BuyCard();
    }
}
interface Card{
    public void BuyCard();
}
class MobileCard implements Card{
    public void BuyCard(){
        System.out.println("mobile card");
    }
}
class ＴeleCard implements Card{
    public void BuyCard(){
        System.out.println("Lian Tong card");
    }
}
class CardFactory{
    public Card buyCard(String str){
        if(str.equals("mobilecard"))
            return new MobileCard();
        else if(str.equals("liantongcard"))
            return new TeleCard();
        else
            return null;
    }
}

• 抽象工厂
  　

• 单例模式
  　　单例模式经常与工厂模式一起用。目的，通过一个static接口实现唯一实例。
  　　懒汉式：在类被使用时才初始化，很少用到时。有线程安全问题，需要锁

public class SingleDemo {
public class SingleDemo {
    private static SingleDemo s = null;
    private SingleDemo(){}
    public static SingleDemo getInstance(){
        /*如果第一个线程获取到了单例的实例对象，
         * 后面的线程再获取实例的时候不需要进入同步代码块中了*/
        if(s == null){
            //同步代码块用的锁是单例的字节码文件对象，且只能用这个锁
            synchronized(SingleDemo.class){
                if(s == null){
                    s = new SingleDemo();
                }
            }
        }
        return s;
    }
}

　　饿汉式：程序启动的时候实例就已经被创建。经常会被用到时使用饿汉式
　

public Simple(){
     private static Single s=new Single();        
     private Single(){

     }  
     public static Simple getSimple(){
         return s;
     } 
}

• bulider模式
  　　一个对象有N个成员变量，并且这些成员变量大部分都是可选的，这是不管是用构造函数还是静态工厂方法都是比较难办的。建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。　　　 　

//Product（产品角色）
class ProgramMonkey {
    private boolean mIsLiterated;
    private boolean mKnowMath;
    private String mLanguage;
    private boolean mKnowDesign;

    public boolean ismIsLiterated() {
        return mIsLiterated;
    }

    public void setmIsLiterated(boolean mIsLiterated) {
        this.mIsLiterated = mIsLiterated;
    }

    public boolean ismKnowMath() {
        return mKnowMath;
    }

    public void setmKnowMath(boolean mKnowMath) {
        this.mKnowMath = mKnowMath;
    }

    public String getmLanguage() {
        return mLanguage;
    }

    public void setmLanguage(String mLanguage) {
        this.mLanguage = mLanguage;
    }

    public boolean ismKnowDesign() {
        return mKnowDesign;
    }

    public void setmKnowDesign(boolean mKnowDesign) {
        this.mKnowDesign = mKnowDesign;
    }

    public void show() {
        System.out.println("\rIsLiterated="+mIsLiterated+"\n"
                            +"KnowMath="+mKnowMath+"\n"
                            +"Language="+mLanguage+"\n"
                            +"KnowDesign="+mKnowDesign+"\n");
    }
}
//Builder（抽象建造者）
abstract class Builder {
    public abstract void buildIsLiterated(boolean arg);
    public abstract void buildKnowMath(boolean arg);
    public abstract void buildLanguage(String arg);
    public abstract void buildKnowDesign(boolean arg);

    public abstract ProgramMonkey getMonkey();
}
//ConcreteBuilder（具体建造者）
class ConcreteProgramMonkey extends Builder {
    private  ProgramMonkey mMonkey = new ProgramMonkey();

    @Override
    public void buildIsLiterated(boolean arg) {
        mMonkey.setmIsLiterated(arg);
    }

    @Override
    public void buildKnowMath(boolean arg) {
        mMonkey.setmKnowMath(arg);
    }

    @Override
    public void buildLanguage(String arg) {
        mMonkey.setmLanguage(arg);
    }

    @Override
    public void buildKnowDesign(boolean arg) {
        mMonkey.setmKnowDesign(arg);
    }

    @Override
    public ProgramMonkey getMonkey() {
        return mMonkey;
    }
}
//Director（指挥者）
class Director {
    private Builder builder = new ConcreteProgramMonkey();

    public ProgramMonkey getMonkeyLow() {
        builder.buildIsLiterated(true);
        builder.buildKnowMath(true);
        builder.buildLanguage("Android");
        builder.buildKnowDesign(false);

        return builder.getMonkey();
    }

    public ProgramMonkey getMonkeyHigh() {
        builder.buildIsLiterated(true);
        builder.buildKnowMath(true);
        builder.buildLanguage("Android/Java/Designer");
        builder.buildKnowDesign(true);

        return builder.getMonkey();
    }
}

public class Main {
    public static void main(String[] args) {
        Director director = new Director();
        ProgramMonkey monkey = director.getMonkeyLow();
        monkey.show();
        monkey = director.getMonkeyHigh();
        monkey.show();
    }
}

行为模式　

• 策略模式
  

  应用实例： 1、Spring中在实例化对象的时候用到Strategy模式。 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。 3、JAVA AWT 中的 LayoutManager。4.SpringMVC
  解决：在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。

• 链式模式
  　例子背景：企业采购审批系统根据采购金额的不同由不同层次的主管人员来审批，主任可以审批5W元以下的采购单，副董事长5-10W，董事长10-50W，50W以上需要开董事会讨论决定。

/**
 * 采购类：请求类
 */
public class PurchaseRequest {
    //采购金额
    private double amount;
    //采购单编号
    private int number;
    //采购目的
    private String purpose;

   public PurchaseRequest(double amount, int 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 int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
    public String getPurpose() {
        return purpose;
    }
    public void setPurpose(String purpose) {
        this.purpose = purpose;
    }
}

/**
 * 审批者类：抽象处理者
 */
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);
}

/**
 * 主任类：具体处理者
 */
public class Director extends Approver {

    public Director(String name) {
        super(name);
    }
    /**
     * 具体请求处理方法
     *
     * @param request
     */
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() < 5000) {
            //处理请求
            System.out.println("主任" + this.name + "审批采购单:" + request.getNumber() +
                    "金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。");
        } else {
            //转发请求
            this.successor.processRequest(request);        }
    }
}
/**
 * 董事长类：具体处理者
 */
public class President extends Approver {

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

    /**
     * 具体请求处理方法
     *
     * @param request
     */
    @Override
    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);
        }
    }

}
/**
 * 董事会类：具体处理者
 */
public class Congress extends Approver {

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

    /**
     * 具体请求处理方法
     *
     * @param request
     */
    @Override
    public void processRequest(PurchaseRequest request) {
        //处理请求
        System.out.println("召开董事会审批采购单:" + request.getNumber() +
                "金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。");

    }

}
public class Client {

    public static void main(String args[]) {
        Approver wjzhang, gyang, jguo, meeting;
        wjzhang = new Director("张无忌");
        gyang = new VicePresident("杨过");
        jguo = new President("郭靖");
        meeting = new Congress("董事会");

        //创建职责链
        wjzhang.setSuccessor(gyang);
        gyang.setSuccessor(jguo);
        jguo.setSuccessor(meeting);

        PurchaseRequest pr1 = new PurchaseRequest(4500, 10001, "购买剑");
        PurchaseRequest pr2 = new PurchaseRequest(65000, 10002, "购买刀");
        PurchaseRequest pr3 = new PurchaseRequest(165500, 10003, "购买书籍");
        PurchaseRequest pr4 = new PurchaseRequest(804500, 10004, "购买岛屿");

        wjzhang.processRequest(pr1);
        wjzhang.processRequest(pr2);
        wjzhang.processRequest(pr3);
        wjzhang.processRequest(pr4);
    }

}

• 观察者模式
  

  spring里面的listener会使用到，当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。异步方式一般
  http://www.runoob.com/design-pattern/observer-pattern.html

结构型
　 - 代理模式
　 代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，
代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。
Spring AOP都用到很多代理方法

 public interface Sub {
    void Request();
}
public class ConcertSub implements Sub {
    public void Request(){
        System.out.println("ConcertSub Request Create");
    }
}
public class ProxyParttenCreate {
    private Sub sub;
    ProxyParttenCreate(Sub sub){
        this.sub=sub;
    }
    void Request(){
        System.out.println("PorxyPartten Request Create");
        sub.Request();
    }
}
public static void main(String[] args){
       Sub sub=new ConcertSub();　　//这一步可能spring帮你做了
       ProxyParttenCreate proxy=new ProxyParttenCreate(sub);
       proxy.Request();
    }