设计模式

 创建型模式：

抽象工厂设计模式：
抽象工厂与抽象产品都只提供抽象方法，具体的产品组合由工厂对象实现完成。
工厂专注于生产产品，不需要关心具体的产品实现；
产品对象关注于设计产品，无需关心使用情况；
该模式有四个角色：抽象工厂、工厂类、抽象产品、产品类。
以下代码描述的是：产品A有两个子产品A1、A2；产品B有两个产品B1、B2；工厂有两个，Factory1 生产A1、B1；Factory2 生产 A2、B2。

abstract class ProductA{
    ProductA(){}
    public abstract void use();    
}
class ProductA1 extends ProductA{
    ProductA1(){}    
    public void use(){
        System.out.println("A1 use");
    }
}
class ProductA2 extends ProductA{
    ProductA2(){}    
    public void use(){
        System.out.println("A2 use");
    }
}

abstract class ProductB{
    ProductB(){}
    public abstract void use();
}
class ProductB1 extends ProductB{
    ProductB1(){}    
    public void use(){
        System.out.println("B1 use");
    }    
}
class ProductB2 extends ProductB{
    ProductB2(){}    
    public void use(){
        System.out.println("B2 use");
    }    
}

abstract class Factory{
    Factory(){}
    public abstract ProductA createProductA();
    abstract ProductB createProductB();
}
class Factory1 extends Factory{
    Factory1(){}
    public ProductA createProductA(){
        return new ProductA1();
    }
    public ProductB createProductB(){
        return new ProductB1();
    }
}
class Factory2 extends Factory{
    Factory2(){}
    public ProductA createProductA(){
        return new ProductA2();
    }
    public ProductB createProductB(){
        return new ProductB2();
    }
}
public class FactoryMain{
    public static void main(String[] args){
        Factory f1 = new Factory1();
        Factory f2 = new Factory2();
        ProductA A_f1 = f1.createProductA();
        ProductB B_f1 = f1.createProductB();
        ProductA A_f2 = f2.createProductA();
        ProductB B_f2 = f2.createProductB();
        A_f1.use();
        B_f1.use();
        A_f2.use();
        B_f2.use();
    }
}

 建造者（生成器）模式:

建造者（生成器）模式把类的构建与它的表示分离，使同样的构建过程可以创建不同的表示。
包含四个角色：Builder,Dirctor,ConcreteBuilder,Product

class Meal{
    Meal(){}
    public String getdrink(){
        return drink; 
    }
    public String getfood(){
        return food;
    }
    public void setdrink(String drink){
        this.drink = drink;
    }
    public void setfood(String food){
        this.food = food;
    }
    public void show(){
        System.out.println(drink+" "+food);
    }
    private String food;
    private String drink;
}
interface MealBuilder {
    abstract public void buildDrink();
    abstract public void buildFood();
    abstract public Meal getMeal();
}
class MealBuilderA implements MealBuilder{
    MealBuilderA(){
        meal = new Meal();
    }
    public void buildDrink(){
        meal.setdrink("drink_A");
    }
    public void buildFood(){
        meal.setfood("food_A");
    }
    public Meal getMeal(){
        return meal;
    }
    private Meal meal;
}
class MealBuilderB implements MealBuilder{
    MealBuilderB(){
        meal = new Meal();
    }
    public void buildDrink(){
        meal.setdrink("drink_B");
    }
    public void buildFood(){
        meal.setfood("food_B");
    }
    public Meal getMeal(){
        return meal;
    }
    private Meal meal;
}
class KFCDirctor{
    KFCDirctor(){}
    public Meal construct(){
        mb.buildDrink();
        mb.buildFood();
        return mb.getMeal();
    }
    public void setMealBuilder(MealBuilder mb){
        this.mb = mb;
    }
    private MealBuilder mb;
}
public class BuilderMain{
    public static void main(String[] args){
        MealBuilder mb_A = new MealBuilderA();
        MealBuilder mb_B = new MealBuilderB();
        KFCDirctor waiter = new KFCDirctor();
        waiter.setMealBuilder(mb_A);
        Meal m_A = waiter.construct();
        waiter.setMealBuilder(mb_B);
        Meal m_B = waiter.construct();
        m_A.show();
        m_B.show();
        
    }
}

 

结构型模式：

适配器模式：

/*
    对象适配器
*/
class Target{
    Target(){}
    public void request(){
        System.out.println("request()");
    }
}
class Adapter extends Target{
    Adapter(Adaptee adaptee){
        this.adaptee = adaptee;
    }
    public void request(){
        adaptee.specificRequest();
    }
    private Adaptee adaptee;
}
class Adaptee{
    Adaptee(){}
    public void specificRequest(){
        System.out.println("specificRequest()");
    }
}
class Client{
    Client(Target t){
        target = t;
        target.request();
    }
    private Target target;
}
class AdapterMain{
    public static void main(String[] args){
        Target t = new Target();
        Adaptee adaptee = new Adaptee();
        Adapter adapter = new Adapter(adaptee);
        new Client(adapter);
    }
}

外观模式：

该模式有两个角色：Facade（外观角色）、SubSystem(子系统角色)

class Facade{
    Facade(){
        systemA = new SystemA();
        systemB = new SystemB();
        systemC = new SystemC();
    }
    public void operation(){
        systemA.operation();
        systemB.operation();
        systemC.operation();
    }
    private SystemA systemA;
    private SystemB systemB;
    private SystemC systemC;
}
class SystemA{
    SystemA(){}
    public void operation(){
        System.out.println("SystemA->operation()");
    }
}
class SystemB{
    SystemB(){}
    public void operation(){
        System.out.println("SystemB->operation()");
    }
}class SystemC{
    SystemC(){}
    public void operation(){
        System.out.println("SystemC->operation()");
    }
}
class FacadeMain{
    public static void main(String[] args){
        Facade fa = new Facade();
        fa.operation();
    }
}

代理模式：

abstract class Subject{
    Subject(){}
    public abstract void request(); 
}
class RealSubject extends Subject{
    RealSubject(){}
    public void request(){
        System.out.println("RealSubject->request()");
    }
}
class Proxy extends Subject{
    Proxy(){}
    public void prerequest(){
        System.out.println("Proxy->prerequest()");
    }
    public void afterrequest(){
        System.out.println("Proxy->afterrequest()");
    }
    public void request(){
        prerequest();
        if(realSubject == null){
            realSubject = new RealSubject();
        }
        realSubject.request();
        afterrequest();
    }
    private RealSubject realSubject = null;
}
class ProxyMain{
    public static void main(String[] args){
        Subject s = new Proxy();
        s.request();
    }
}

 

行为型模式：

中介者模式：把具有复杂关系的对象进行解耦
缺点：具体的中介者类中包含了同事之间的交互细节，这可能导致具体中介者类非常复杂，使得系统难以维护。

import java.util.HashMap;
import java.util.Map;

abstract class Colleague{
    Colleague(){}
    public abstract void send(int n,String msg);
    public abstract String receive(String msg);
    public abstract void setMediator(Mediator m);
}
class ColleagueA extends Colleague{
    ColleagueA(){}
    public void setMediator(Mediator m){
        this.m = m;
    }
    public void send(int n,String msg){
        System.out.println("A send: "+msg);
        m.operate(n,msg);
    }
    public String receive(String msg){
        System.out.println("A receive: "+msg);
        return msg;
    }
    private Mediator m;
}
class ColleagueB extends Colleague{
    ColleagueB(){}
    public void setMediator(Mediator m){
        this.m = m;
    }
    public void send(int n,String msg){
        System.out.println("B send: "+msg);
        m.operate(n,msg);
    }
    public String receive(String msg){
        System.out.println("B receive: "+msg);
        return msg;
    }
    private Mediator m;
}

abstract class Mediator{
    protected Map<Integer,Colleague> M;
    Mediator(){}
    abstract void register(Integer n,Colleague c);
    abstract void operate(Integer n,String msg);
}
class Mediator1 extends Mediator{
    Mediator1(){
        M = new HashMap<Integer,Colleague>();
    }
    public void register(Integer n,Colleague c){
        M.put(n,c);
        c.setMediator(this);
    }
    public void operate(Integer n,String msg){
        Colleague c = M.get(n);
        if(c!=null){
            c.setMediator(this);
            c.receive(msg);
        }else{
            System.out.println("receive is not exist.");
        }
    }
}
class MediatorMain{
    public static void main(String[] args){
        Colleague A = new ColleagueA();
        Colleague B = new ColleagueB();
        Mediator M = new Mediator1();
        M.register(1,A);
        M.register(2,B);
        A.send(2,"Hello,I'm A.");
        B.send(1,"Hello,I'm B.");
    }
}

相关链接：http://design-patterns.readthedocs.org/zh_CN/latest/