面试被问设计模式，Java老司机教你怎么应对?看完给我狠怼面试官!!!

设计模式原则：多使用接口、抽象类，从而增加代码的可扩展性，降低模块之间的依赖和联系

单例模式：

定义及使用场合：只有一个对象被创建 建议采用饿汉模式创建，线程安全、容易实现。

public class SingleObject {

   //创建 SingleObject 的一个对象
   private static SingleObject instance = new SingleObject();

   //让构造函数为 private，这样该类就不会被实例化
   private SingleObject(){}

   //获取唯一可用的对象
   public static SingleObject getInstance(){
      return instance;
   }

}

观察者模式：

定义及使用场合：一个对象（subject）被其它多个对象（observer）所依赖，则当一个对象变化时发出通知，其它依赖该对象的对象都会收到通知，并且随之改变【获取资料】

定义观察者 接收通知后操作方法

public interface Observer {  
    public void update();  
}  

定义观察者Observer1 实现接收通知后操作方法

public class Observer1 implements Observer {  
    @Override  
    public void update() {  
        System.out.println("observer1 has received!");  
    }  
}

定义观察者Observer2 实现接收通知后操作方法

public class Observer2 implements Observer {  
    @Override  
    public void update() {  
        System.out.println("observer2 has received!");  
    }  
}

定义主题接口 定义基本方法

public interface Subject {  

    /*增加观察者*/  
    public void add(Observer observer);  

    /*删除观察者*/  
    public void del(Observer observer);  

    /*通知所有的观察者*/  
    public void notifyObservers();  
//加入Java开发交流君样：484138291一起吹水聊天
    /*自身的操作*/  
    public void operation();  
}

定义主题接口抽象实现 实现基本方法

public abstract class AbstractSubject implements Subject {  

    private Vector<Observer> vector = new Vector<Observer>();  
    @Override  
    public void add(Observer observer) {  
        vector.add(observer);  
    }  

    @Override  
    public void del(Observer observer) {  
        vector.remove(observer);  
    }  

    @Override  
    public void notifyObservers() {  
        Enumeration<Observer> enumo = vector.elements();  
        while(enumo.hasMoreElements()){  
        　　enumo.nextElement().update();  
    　　 }　　 }}

定义主题实现类 重写发出通知方法

public class MySubject extends AbstractSubject {  

    @Override  
    public void operation() {  
        System.out.println("update self!");  
        notifyObservers();  
    }  

}

测试类

public class ObserverTest {  

    public static void main(String[] args) {  
        Subject sub = new MySubject();  
        sub.add(new Observer1());  //订阅这个对象
        sub.add(new Observer2());  
//加入Java开发交流君样：484138291一起吹水聊天
        sub.operation();  //发出改变的一个通知
    }  

}

抽象工厂模式：

定义与使用场景：多个对象具有共同的特征，则不需要具体创建各个对象，而是创建对象工厂类即可【获取资料】

例如：同上，将创建对象的工厂类分离，如果需要增加新的发送消息业务，则只需新增一个消息发送类和消息发送类创建工厂类

策略模式：

定义和使用场合：需要动态的在几种类似的算法中选择一种

例如：

定义操作接口

public interface Strategy {
public int doOperation(int num1, int num2);
}
定义加法操作类

public class OperationAdd implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 + num2;
   }
}

定义减法操作类

public class OperationSubstract implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 - num2;
   }
}

定义代理对象

public class Context {
   private Strategy strategy;

   public Context(Strategy strategy){
      this.strategy = strategy;
   }

   public int executeStrategy(int num1, int num2){
      return strategy.doOperation(num1, num2);
   }
}

测试类

public class StrategyPatternDemo {
   public static void main(String[] args) {
       //实例化对象的位置在调用处
       //加入Java开发交流君样：484138291一起吹水聊天
      Context context = new Context(new OperationAdd());        
      System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

      context = new Context(new OperationSubstract());        
      System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

      context = new Context(new OperationMultiply());        
      System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
   }
}

桥接模式：

使用场景及定义：访问多种数据库驱动，不是直接访问，而是通过DriverManger桥来访问

外观模式：

使用场景及定义：整个过程是串行的，有先后顺序

例如：电脑启动，先启动cpu，再启动memory，再启动disk （有点类似将操作封装）

public class Computer {  
//是组合，而非继承。这是与工厂模式的显著区别。
//加入Java开发交流君样：484138291一起吹水聊天
    private CPU cpu;  
    private Memory memory;  
    private Disk disk;  

    public Computer(){  
        cpu = new CPU();  
        memory = new Memory();  
        disk = new Disk();  
    }  

    public void startup(){  
        System.out.println("start the computer!");  
        cpu.startup();  
        memory.startup();  
        disk.startup();  
        System.out.println("start computer finished!");  
    }  

    public void shutdown(){  
        System.out.println("begin to close the computer!");  
        cpu.shutdown();  
        memory.shutdown();  
        disk.shutdown();  
        System.out.println("computer closed!");  
    }  
}  

生产者-消费者模式：

定义与使用场景：生产者将数据放在数据缓冲区，消费者从数据缓冲区获取数据

最后，祝大家早日学有所成，拿到满意offer，快速升职加薪，走上人生巅峰。