设计模式的面试题（总结最全面的一篇）

private static boolean flag = false;
  
  private Singleton() {
  
  	if (flag == false) {
  		flag = !flag;
  	} else {
  		throw new RuntimeException("单例模式被侵犯！");
  	}
  }
  
  public static void main(String[] args) {
  
  }

package com.lijie;
  
  //饿汉式
  public class Demo1 {
  
      // 类初始化时,会立即加载该对象，线程安全,调用效率高
      private static Demo1 demo1 = new Demo1();
  
      private Demo1() {
          System.out.println("私有Demo1构造参数初始化");
      }
  
      public static Demo1 getInstance() {
          return demo1;
      }
  
      public static void main(String[] args) {
          Demo1 s1 = Demo1.getInstance();
          Demo1 s2 = Demo1.getInstance();
          System.out.println(s1 == s2);
      }
  }

package com.lijie;
  
  //懒汉式
  public class Demo2 {
  
      //类初始化时，不会初始化该对象，真正需要使用的时候才会创建该对象。
      private static Demo2 demo2;
  
      private Demo2() {
          System.out.println("私有Demo2构造参数初始化");
      }
  
      public synchronized static Demo2 getInstance() {
          if (demo2 == null) {
              demo2 = new Demo2();
          }
          return demo2;
      }
  
      public static void main(String[] args) {
          Demo2 s1 = Demo2.getInstance();
          Demo2 s2 = Demo2.getInstance();
          System.out.println(s1 == s2);
      }
  }

package com.lijie;
  
  // 静态内部类方式
  public class Demo3 {
  
      private Demo3() {
          System.out.println("私有Demo3构造参数初始化");
      }
  
      public static class SingletonClassInstance {
          private static final Demo3 DEMO_3 = new Demo3();
      }
  
      // 方法没有同步
      public static Demo3 getInstance() {
          return SingletonClassInstance.DEMO_3;
      }
  
      public static void main(String[] args) {
          Demo3 s1 = Demo3.getInstance();
          Demo3 s2 = Demo3.getInstance();
          System.out.println(s1 == s2);
      }
  }

package com.lijie;
  
  //使用枚举实现单例模式 优点:实现简单、枚举本身就是单例，由jvm从根本上提供保障!避免通过反射和反序列化的漏洞 缺点没有延迟加载
  public class Demo4 {
  
      public static Demo4 getInstance() {
          return Demo.INSTANCE.getInstance();
      }
  
      public static void main(String[] args) {
          Demo4 s1 = Demo4.getInstance();
          Demo4 s2 = Demo4.getInstance();
          System.out.println(s1 == s2);
      }
  
      //定义枚举
  	private static enum Demo {
  		INSTANCE;
  		// 枚举元素为单例
  		private Demo4 demo4;
  
  		private Demo() {
  			System.out.println("枚举Demo私有构造参数");
  			demo4 = new Demo4();
  		}
  
  		public Demo4 getInstance() {
  			return demo4;
  		}
  	}
  }

package com.lijie;
  
  //双重检测锁方式
  public class Demo5 {
  
  	private static Demo5 demo5;
  
  	private Demo5() {
  		System.out.println("私有Demo4构造参数初始化");
  	}
  
  	public static Demo5 getInstance() {
  		if (demo5 == null) {
  			synchronized (Demo5.class) {
  				if (demo5 == null) {
  					demo5 = new Demo5();
  				}
  			}
  		}
  		return demo5;
  	}
  
  	public static void main(String[] args) {
  		Demo5 s1 = Demo5.getInstance();
  		Demo5 s2 = Demo5.getInstance();
  		System.out.println(s1 == s2);
  	}
  }

  简单工厂 ：用来生产同一等级结构中的任意产品。（不支持拓展增加产品）
    工厂方法 ：用来生产同一等级结构中的固定产品。（支持拓展增加产品）   
    抽象工厂 ：用来生产不同产品族的全部产品。（不支持拓展增加产品；支持增加产品族）

我下面来使用代码演示一下：

package com.lijie;
  
  public interface Car {
  	public void run();
  }

package com.lijie;
  
  public class Bmw implements Car {
  	public void run() {
  		System.out.println("我是宝马汽车...");
  	}
  }

package com.lijie;
  
  public class AoDi implements Car {
  	public void run() {
  		System.out.println("我是奥迪汽车..");
  	}
  }

package com.lijie;
  
  public class CarFactory {
  
  	 public static Car createCar(String name) {
  		if ("".equals(name)) {
               return null;
  		}
  		if(name.equals("奥迪")){
  			return new AoDi();
  		}
  		if(name.equals("宝马")){
  			return new Bmw();
  		}
  		return null;
  	}
  }

package com.lijie;
  
  public class Client01 {
  
  	public static void main(String[] args) {
  		Car aodi  =CarFactory.createCar("奥迪");
  		Car bmw  =CarFactory.createCar("宝马");
  		aodi.run();
  		bmw.run();
  	}
  }

package com.lijie;
  
  public interface Car {
  	public void run();
  }

package com.lijie;
  
  public interface CarFactory {
  
  	Car createCar();
  
  }

package com.lijie;
  
  public class AoDi implements Car {
  	public void run() {
  		System.out.println("我是奥迪汽车..");
  	}
  }

package com.lijie;
  
  public class Bmw implements Car {
  	public void run() {
  		System.out.println("我是宝马汽车...");
  	}
  }

package com.lijie;
  
  public class AoDiFactory implements CarFactory {
  
  	public Car createCar() {
  	
  		return new AoDi();
  	}
  }

package com.lijie;
  
  public class BmwFactory implements CarFactory {
  
  	public Car createCar() {
  
  		return new Bmw();
  	}
  
  }

package com.lijie;
  
  public class Client {
  
  	public static void main(String[] args) {
  		Car aodi = new AoDiFactory().createCar();
  		Car jili = new BmwFactory().createCar();
  		aodi.run();
  		jili.run();
  	}
  }

package com.lijie;
  
  //汽车
  public interface Car {
  	   void run();
  }
  
   class CarA implements Car{
  
  	public void run() {
  		System.out.println("宝马");
  	}
  	
  }
   class CarB implements Car{
  
  	public void run() {
  		System.out.println("摩拜");
  	}
  	
  }

package com.lijie;
  
  //发动机
  public interface Engine {
  
      void run();
  
  }
  
  class EngineA implements Engine {
  
      public void run() {
          System.out.println("转的快!");
      }
  
  }
  
  class EngineB implements Engine {
  
      public void run() {
          System.out.println("转的慢!");
      }
  
  }

package com.lijie;
  
  public interface TotalFactory {
  	// 创建汽车
  	Car createChair();
  	// 创建发动机
  	Engine createEngine();
  }
  
  //总工厂实现类，由他决定调用哪个工厂的那个实例
  class TotalFactoryReally implements TotalFactory {
  
  	public Engine createEngine() {
  
  		return new EngineA();
  	}
  
  	public Car createChair() {
  
  		return new CarA();
  	}
  }

package com.lijie;
  
  public class Test {
  
      public static void main(String[] args) {
          TotalFactory totalFactory2 = new TotalFactoryReally();
          Car car = totalFactory2.createChair();
          car.run();
  
          TotalFactory totalFactory = new TotalFactoryReally();
          Engine engine = totalFactory.createEngine();
          engine.run();
      }
  }

package com.lijie;
  
  //接口类
  public class UserDao{
  	public void save() {
  		System.out.println("保存数据方法");
  	}
  }

package com.lijie;
  
  //运行测试类
  public  class Test{
  	public static void main(String[] args) {
  		UserDao userDao = new UserDao();
  		userDao.save();
  	}
  }

package com.lijie;
  
  //代理类
  public class UserDaoProxy extends UserDao {
  	private UserDao userDao;
  
  	public UserDaoProxy(UserDao userDao) {
  		this.userDao = userDao;
  	}
  
  	public void save() {
  		System.out.println("开启事物...");
  		userDao.save();
  		System.out.println("关闭事物...");
  	}
  
  }

//添加完静态代理的测试类
  public class Test{
  	public static void main(String[] args) {
  		UserDao userDao = new UserDao();
  		UserDaoProxy userDaoProxy = new UserDaoProxy(userDao);
  		userDaoProxy.save();
  	}
  }

package com.lijie;
  
  //接口
  public interface UserDao {
      void save();
  }

package com.lijie;
  
  //接口实现类
  public class UserDaoImpl implements UserDao {
  	public void save() {
  		System.out.println("保存数据方法");
  	}
  }

package com.lijie;
  
  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.Method;
  
  // 每次生成动态代理类对象时,实现了InvocationHandler接口的调用处理器对象
  public class InvocationHandlerImpl implements InvocationHandler {
  
  	// 这其实业务实现类对象，用来调用具体的业务方法
      private Object target;
  
      // 通过构造函数传入目标对象
      public InvocationHandlerImpl(Object target) {
          this.target = target;
      }
  
      //动态代理实际运行的代理方法
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          System.out.println("调用开始处理");
          //下面invoke()方法是以反射的方式来创建对象，第一个参数是要创建的对象，第二个是构成方法的参数，由第二个参数来决定创建对象使用哪个构造方法
  		Object result = method.invoke(target, args);
          System.out.println("调用结束处理");
          return result;
      }
  }

package com.lijie;
  
  import java.lang.reflect.Proxy;
  
  public class Test {
      public static void main(String[] args) {
          // 被代理对象
          UserDao userDaoImpl = new UserDaoImpl();
          InvocationHandlerImpl invocationHandlerImpl = new InvocationHandlerImpl(userDaoImpl);
  
          //类加载器
          ClassLoader loader = userDaoImpl.getClass().getClassLoader();
          Class<?>[] interfaces = userDaoImpl.getClass().getInterfaces();
  
          // 主要装载器、一组接口及调用处理动态代理实例
          UserDao newProxyInstance = (UserDao) Proxy.newProxyInstance(loader, interfaces, invocationHandlerImpl);
          newProxyInstance.save();
      }
  }

package com.lijie;
  
  //接口
  public interface UserDao {
      void save();
  }

package com.lijie;
  
  //接口实现类
  public class UserDaoImpl implements UserDao {
  	public void save() {
  		System.out.println("保存数据方法");
  	}
  }

package com.lijie;
  
  import org.springframework.cglib.proxy.Enhancer;
  import org.springframework.cglib.proxy.MethodInterceptor;
  import org.springframework.cglib.proxy.MethodProxy;
  import java.lang.reflect.Method;
  
  //代理主要类
  public class CglibProxy implements MethodInterceptor {
  	private Object targetObject;
  	// 这里的目标类型为Object，则可以接受任意一种参数作为被代理类，实现了动态代理
  	public Object getInstance(Object target) {
  		// 设置需要创建子类的类
  		this.targetObject = target;
  		Enhancer enhancer = new Enhancer();
  		enhancer.setSuperclass(target.getClass());
  		enhancer.setCallback(this);
  		return enhancer.create();
  	}
  
  	//代理实际方法
  	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
  		System.out.println("开启事物");
  		Object result = proxy.invoke(targetObject, args);
  		System.out.println("关闭事物");
  		// 返回代理对象
  		return result;
  	}
  }
  

package com.lijie;
  
  //测试CGLIB动态代理
  public class Test {
      public static void main(String[] args) {
          CglibProxy cglibProxy = new CglibProxy();
          UserDao userDao = (UserDao) cglibProxy.getInstance(new UserDaoImpl());
          userDao.save();
      }
  }

package com.lijie;
  
  //装备类
  public class Arms {
  	//头盔
  	private String helmet;
  	//铠甲
  	private String armor;
  	//武器
  	private String weapon;
  	
  	//省略Git和Set方法...........
  }

package com.lijie;
  
  public interface PersonBuilder {
  
  	void builderHelmetMurder();
  
  	void builderArmorMurder();
  
  	void builderWeaponMurder();
  
  	void builderHelmetYanLong();
  
  	void builderArmorYanLong();
  
  	void builderWeaponYanLong();
  
  	Arms BuilderArms(); //组装
  }

package com.lijie;
  
  public class ArmsBuilder implements PersonBuilder {
      private Arms arms;
  
      //创建一个Arms实例,用于调用set方法
      public ArmsBuilder() {
          arms = new Arms();
      }
  
      public void builderHelmetMurder() {
          arms.setHelmet("夺命头盔");
      }
  
      public void builderArmorMurder() {
          arms.setArmor("夺命铠甲");
      }
  
      public void builderWeaponMurder() {
          arms.setWeapon("夺命宝刀");
      }
  
      public void builderHelmetYanLong() {
          arms.setHelmet("炎龙头盔");
      }
  
      public void builderArmorYanLong() {
          arms.setArmor("炎龙铠甲");
      }
  
      public void builderWeaponYanLong() {
          arms.setWeapon("炎龙宝刀");
      }
  
      public Arms BuilderArms() {
          return arms;
      }
  }

package com.lijie;
  
  public class PersonDirector {
  	
  	//组装
  	public Arms constructPerson(PersonBuilder pb) {
  		pb.builderHelmetYanLong();
  		pb.builderArmorMurder();
  		pb.builderWeaponMurder();
  		return pb.BuilderArms();
  	}
  
  	//这里进行测试
  	public static void main(String[] args) {
  		PersonDirector pb = new PersonDirector();
  		Arms arms = pb.constructPerson(new ArmsBuilder());
  		System.out.println(arms.getHelmet());
  		System.out.println(arms.getArmor());
  		System.out.println(arms.getWeapon());
  	}
  }

package com.lijie;
  
  //模板方法
  public abstract class RestaurantTemplate {
  
  	// 1.看菜单
  	public void menu() {
  		System.out.println("看菜单");
  	}
  
  	// 2.点菜业务
  	abstract void spotMenu();
  
  	// 3.吃饭业务
  	public void havingDinner(){ System.out.println("吃饭"); }
  
  	// 3.付款业务
  	abstract void payment();
  
  	// 3.走人
  	public void GoR() { System.out.println("走人"); }
  
  	//模板通用结构
  	public void process(){
  		menu();
  		spotMenu();
  		havingDinner();
  		payment();
  		GoR();
  	}
  }

package com.lijie;
  
  public class RestaurantGinsengImpl extends RestaurantTemplate {
  
      void spotMenu() {
          System.out.println("人参");
      }
  
      void payment() {
          System.out.println("5快");
      }
  }

package com.lijie;
  
  public class RestaurantLobsterImpl  extends RestaurantTemplate  {
  
      void spotMenu() {
          System.out.println("龙虾");
      }
  
      void payment() {
          System.out.println("50块");
      }
  }

package com.lijie;
  
  public class Client {
  
      public static void main(String[] args) {
          //调用第一个模板实例
          RestaurantTemplate restaurantTemplate = new RestaurantGinsengImpl();
          restaurantTemplate.process();
      }
  }

package com.lijie;
  
  //阿里短信消息
  public interface AliSmsService {
  	void sendSms();
  }

package com.lijie;
  
  public class AliSmsServiceImpl implements AliSmsService {
  
      public void sendSms() {
          System.out.println("阿里短信消息");
      }
  
  }

package com.lijie;
  
  //发送邮件消息
  public interface EamilSmsService {
  	void sendSms();
  }

package com.lijie;
  
  public class EamilSmsServiceImpl implements   EamilSmsService{
  	public void sendSms() {
  		System.out.println("发送邮件消息");
  	}
  }

package com.lijie;
  
  //微信消息推送
  public interface WeiXinSmsService {
     void sendSms();
  }

package com.lijie;
  
  public class WeiXinSmsServiceImpl implements  WeiXinSmsService {
      public void sendSms() {
          System.out.println("发送微信消息推送");
      }
  }

package com.lijie;
  
  public class Computer {
  	AliSmsService aliSmsService;
  	EamilSmsService eamilSmsService;
  	WeiXinSmsService weiXinSmsService;
  
  	public Computer() {
  		aliSmsService = new AliSmsServiceImpl();
  		eamilSmsService = new EamilSmsServiceImpl();
  		weiXinSmsService = new WeiXinSmsServiceImpl();
  	}
  
  	//只需要调用它
  	public void sendMsg() {
  		aliSmsService.sendSms();
  		eamilSmsService.sendSms();
  		weiXinSmsService.sendSms();
  	}
  }

package com.lijie;
  
  public class Client {
  
      public static void main(String[] args) {
          //普通模式需要这样
          AliSmsService aliSmsService = new AliSmsServiceImpl();
          EamilSmsService eamilSmsService = new EamilSmsServiceImpl();
          WeiXinSmsService weiXinSmsService = new WeiXinSmsServiceImpl();
          aliSmsService.sendSms();
          eamilSmsService.sendSms();
          weiXinSmsService.sendSms();
  
          //利用外观模式简化方法
          new Computer().sendMsg();
      }
  }

package com.lijie;
  
  import java.util.ArrayList;
  
  public class User implements Cloneable {
      private String name;
      private String password;
      private ArrayList<String> phones;
  
      protected User clone() {
          try {
              User user = (User) super.clone();
              //重点，如果要连带引用类型一起复制，需要添加底下一条代码，如果不加就对于是复制了引用地址
              user.phones = (ArrayList<String>) this.phones.clone();//设置深复制
              return user;
          } catch (CloneNotSupportedException e) {
              e.printStackTrace();
          }
          return null;
      }
  	
  	//省略所有属性Git Set方法......
  }

package com.lijie;
  
  import java.util.ArrayList;
  
  public class Client {
      public static void main(String[] args) {
          //创建User原型对象
          User user = new User();
          user.setName("李三");
          user.setPassword("123456");
          ArrayList<String> phones = new ArrayList<>();
          phones.add("17674553302");
          user.setPhones(phones);
  
          //copy一个user对象,并且对象的属性
          User user2 = user.clone();
          user2.setPassword("654321");
  
          //查看俩个对象是否是一个
          System.out.println(user == user2);
  
          //查看属性内容
          System.out.println(user.getName() + " | " + user2.getName());
          System.out.println(user.getPassword() + " | " + user2.getPassword());
          //查看对于引用类型拷贝
          System.out.println(user.getPhones() == user2.getPhones());
      }
  }

//默认引用类型为浅复制，这是设置了深复制
  user.phones = (ArrayList<String>) this.phones.clone();

package com.lijie;
  
  //策略模式 定义抽象方法 所有支持公共接口
  abstract class PayStrategy {
  
  	// 支付逻辑方法
  	abstract void algorithmInterface();
  
  }

package com.lijie;
  
  class PayStrategyA extends PayStrategy {
  
  	void algorithmInterface() {
  		System.out.println("微信支付");
  	}
  }

package com.lijie;
  
  class PayStrategyB extends PayStrategy {
  
  	void algorithmInterface() {
  		System.out.println("支付宝支付");
  	}
  }

package com.lijie;
  
  class PayStrategyC extends PayStrategy {
  
  	void algorithmInterface() {
  		System.out.println("银联支付");
  	}
  }

package com.lijie;// 使用上下文维护算法策略
  
  class Context {
  
  	PayStrategy strategy;
  
  	public Context(PayStrategy strategy) {
  		this.strategy = strategy;
  	}
  
  	public void algorithmInterface() {
  		strategy.algorithmInterface();
  	}
  
  }

package com.lijie;
  
  class ClientTestStrategy {
  	public static void main(String[] args) {
  		Context context;
  		//使用支付逻辑A
  		context = new Context(new PayStrategyA());
  		context.algorithmInterface();
  		//使用支付逻辑B
  		context = new Context(new PayStrategyB());
  		context.algorithmInterface();
  		//使用支付逻辑C
  		context = new Context(new PayStrategyC());
  		context.algorithmInterface();
  	}
  }

package com.lijie;
  
  //观察者的接口，用来存放观察者共有方法
  public interface Observer {
      // 观察者方法
      void update(int state);
  }

package com.lijie;
  
  // 具体观察者
  public class ObserverImpl implements Observer {
  
      // 具体观察者的属性
      private int myState;
  
      public void update(int state) {
          myState=state;
          System.out.println("收到消息,myState值改为："+state);
      }
  
      public int getMyState() {
          return myState;
      }
  }

package com.lijie;
  
  import java.util.Vector;
  
  //定义主题，以及定义观察者数组，并实现增、删及通知操作。
  public class Subjecct {
  	//观察者的存储集合，不推荐ArrayList，线程不安全，
  	private Vector<Observer> list = new Vector<>();
  
  	// 注册观察者方法
  	public void registerObserver(Observer obs) {
  		list.add(obs);
  	}
      // 删除观察者方法
  	public void removeObserver(Observer obs) {
  		list.remove(obs);
  	}
  
  	// 通知所有的观察者更新
  	public void notifyAllObserver(int state) {
  		for (Observer observer : list) {
  			observer.update(state);
  		}
  	}
  }

package com.lijie;
  
  //具体主题
  public class RealObserver extends Subjecct {
      //被观察对象的属性
  	 private int state;
  	 public int getState(){
  		 return state;
  	 }
  	 public void  setState(int state){
  		 this.state=state;
  		 //主题对象(目标对象)值发生改变
  		 this.notifyAllObserver(state);
  	 }
  }

package com.lijie;
  
  public class Client {
  
  	public static void main(String[] args) {
  		// 目标对象
  		RealObserver subject = new RealObserver();
  		// 创建多个观察者
  		ObserverImpl obs1 = new ObserverImpl();
  		ObserverImpl obs2 = new ObserverImpl();
  		ObserverImpl obs3 = new ObserverImpl();
  		// 注册到观察队列中
  		subject.registerObserver(obs1);
  		subject.registerObserver(obs2);
  		subject.registerObserver(obs3);
  		// 改变State状态
  		subject.setState(300);
  		System.out.println("obs1观察者的MyState状态值为："+obs1.getMyState());
  		System.out.println("obs2观察者的MyState状态值为："+obs2.getMyState());
  		System.out.println("obs3观察者的MyState状态值为："+obs3.getMyState());
  		// 改变State状态
  		subject.setState(400);
  		System.out.println("obs1观察者的MyState状态值为："+obs1.getMyState());
  		System.out.println("obs2观察者的MyState状态值为："+obs2.getMyState());
  		System.out.println("obs3观察者的MyState状态值为："+obs3.getMyState());
  	}
  }

// 通知所有的观察者更新
  public void notifyAllObserver(int state) {
  	for (Observer observer : list) {
  		observer.update(state);
  	}
  }

package com.lijie;

//具体主题
public class RealObserver extends Subjecct {
    //被观察对象的属性
	 private int state;
	 public int getState(){
		 return state;
	 }
	 public void  setState(int state){
		 this.state=state;
		 //主题对象(目标对象)值发生改变
		 this.notifyAllObserver(state);
	 }
}

package com.lijie;

public class Client {

	public static void main(String[] args) {
		// 目标对象
		RealObserver subject = new RealObserver();
		// 创建多个观察者
		ObserverImpl obs1 = new ObserverImpl();
		ObserverImpl obs2 = new ObserverImpl();
		ObserverImpl obs3 = new ObserverImpl();
		// 注册到观察队列中
		subject.registerObserver(obs1);
		subject.registerObserver(obs2);
		subject.registerObserver(obs3);
		// 改变State状态
		subject.setState(300);
		System.out.println("obs1观察者的MyState状态值为："+obs1.getMyState());
		System.out.println("obs2观察者的MyState状态值为："+obs2.getMyState());
		System.out.println("obs3观察者的MyState状态值为："+obs3.getMyState());
		// 改变State状态
		subject.setState(400);
		System.out.println("obs1观察者的MyState状态值为："+obs1.getMyState());
		System.out.println("obs2观察者的MyState状态值为："+obs2.getMyState());
		System.out.println("obs3观察者的MyState状态值为："+obs3.getMyState());
	}
}