1、工厂

工厂就好比是主管，产品就好像码农。这主管比较懒，有人找他，他就只是负责对应的人，其他啥也不干。

1.1 简单工厂

对最终干活的码农抽取一个公共接口。

public interface Phone {
    void make();
}
public class MiPhone implements Phone {
    public MiPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi phone!");
    }
}
public class IPhone implements Phone {
    public IPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make iphone!");
    }
}
public class PhoneFactory {
    public Phone makePhone(String phoneType) {
        if(phoneType.equalsIgnoreCase("MiPhone")){
            return new MiPhone();
        }
        else if(phoneType.equalsIgnoreCase("iPhone")) {
            return new IPhone();
        }
        return null;
    }
}
public class Demo {
    public static void main(String[] arg) {
        PhoneFactory factory = new PhoneFactory();
        Phone miPhone = factory.makePhone("MiPhone");            // make xiaomi phone!
        IPhone iPhone = (IPhone)factory.makePhone("iPhone");    // make iphone!
    }
}

1.2 工厂方法

连同管理码农的主管一块抽象了（此时一个主管管一个码农吧）

public interface AbstractFactory {
    Phone makePhone();
}
public class XiaoMiFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}
public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
}
public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        appleFactory.makePhone();        // make iphone!
    }
}

1.3 抽象工厂

主管工作量翻倍了，一个主管管理多个码农了。

public interface PC {
    void make();
}
public class MiPC implements PC {
    public MiPC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi PC!");
    }
}
public class MAC implements PC {
    public MAC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make MAC!");
    }
}
public interface AbstractFactory {
    Phone makePhone();
    PC makePC();
}
public class XiaoMiFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
    @Override
    public PC makePC() {
        return new MiPC();
    }
}
public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
    @Override
    public PC makePC() {
        return new MAC();
    }
}
public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        miFactory.makePC();                // make xiaomi PC!
        appleFactory.makePhone();        // make iphone!
        appleFactory.makePC();            // make MAC!
    }
}

2、策略模式

主管负责了一些任务，但是具体任务都是交给手下的码农去干的。

public interface Weapon {
    public void gun();
}
public class FirstGun implements Weapon {

    @Override
    public void gun() {
        System.out.println("使用AWM狙击步枪。");
    }
}
public class SecondGun implements Weapon {
    
    @Override
    public void gun() {
        System.out.println("使用S12K。");
    }
}
public class Context {
    Weapon weapon;
    
    public Context(Weapon weapon) { //构造函数
        super();
        this.weapon = weapon;
    }
    
    public Weapon getWeapon() { //get方法
        return weapon;
    }
    
    public void setWeapon(Weapon weapon) { //set方法
        this.weapon = weapon;
    }
    
    public void gun() {
        weapon.gun();
    }
}
public class StrategyClient {

    public static void main(String[] args) {
        //使用构造函数默认选择一把AWM狙击步枪（一个策略）
        Context context=new Context(new FirstGun());
        context.gun();
        
        //使用get、set方法切换到S12K（切换策略）　　　　 System.out.println("------右前方30米发现敌人------");
        contex.set(new SecondGun());
        context.gun();    }
}

3、适配器模式

主管继承了码农的一个共有对象，可以直接通知其做任务。

//目标接口
interface Target{
    public void request();
}
//适配者接口（源角色）
class Adaptee{
    public void specificRequest(){       
        System.out.println("适配者中的业务代码被调用！");
    }
}
//类适配器类
class ClassAdapter extends Adaptee implements Target{
    public void request(){
        specificRequest();
    }
}
//客户端代码
public class ClassAdapterTest{
    public static void main(String[] args){
        System.out.println("类适配器模式测试：");
        Target target = new ClassAdapter();
        target.request();
    }
}

4、代理模式

5、责任链模式（拦截器）

就是主管把任务告诉每一个，大家自己认领自己任务。

public static void main(String[] args){
        //组装责任链 
        Handler handler1=new ConcreteHandler1(); 
        Handler handler2=new ConcreteHandler2(); 
        handler1.setNext(handler2); 
        //提交请求 
        handler1.handleRequest("two");    
}
//抽象处理者角色
abstract class Handler{
    private Handler next;
    public void setNext(Handler next){
        this.next=next; 
    }
    public Handler getNext(){ 
        return next; 
    }   
    //处理请求的方法
    public abstract void handleRequest(String request);       
}
//具体处理者角色1
class ConcreteHandler1 extends Handler{
    public void handleRequest(String request){
        if(request.equals("one")) {
            System.out.println("具体处理者1负责处理该请求！");       
        }else{
           if(getNext()!=null){
                getNext().handleRequest(request);             
            }else{
                System.out.println("没有人处理该请求！");
            }
        } 
    } 
}
//具体处理者角色2
class ConcreteHandler2 extends Handler{
    public void handleRequest(String request){
        if(request.equals("two")){
            System.out.println("具体处理者2负责处理该请求！");       
        }else{
            if(getNext()!=null){
                getNext().handleRequest(request);             
            }else{
                System.out.println("没有人处理该请求！");
            }
        } 
    }
}

6、状态模式

主管给码农们分配了不同的任务（状态）。码农们只能干自己的任务。

  /**
   * Created by xpeng on 2018/5/13.
   * 定义一个电梯的接口
   */
public abstract class LiftState {
    //定义一个环境角色，也就是封装状态的变换引起的功能变化
    protected LiftState liftState;
    public void setLiftState(LiftState liftState){
        this.liftState = liftState;
    }
    public abstract void open();
    public abstract void close();
    public abstract void run();
    public abstract void stop();
}
/**
 * Created by xpeng on 2018/5/13.
 * 在电梯停止的状态下能做什么事情
 */

public class StoppingState extends LiftState {
    //停止状态，开门，是可以滴
    @Override
    public void open() {
        super.contextState.setLiftState(ContextState.openningState);
        super.contextState.getLiftState().open();
    }

    @Override
    public void close() {
    }

    @Override
    public void run() {
        super.contextState.setLiftState(ContextState.runingState);
        super.contextState.getLiftState().run();
    }

    @Override
    public void stop() {
        Log.e("xyz", " 电梯停止了... ");
    }
}

7、原型模式

复用对象，重新对其属性赋值。