java面试总结（七）常用设计模式

六大原则*

1、单一职责原则：指的是应该有且仅有一个原因引起类的变更。
2、里氏替换原则：所有引用基类的地方必须能透明地使用其子类的对象，通俗的来讲就是父类能出现的地方子类就可以出现，但是反过来就不行了。子类可以扩展父类的功能，但不能改变父类原有的功能，里氏替换原则为良好的继承定义了一个规范。
3、依赖倒置原则：高层模块不应该依赖低层模块、抽象不应该依赖细节，细节依赖抽象，在Java中的表现为面向接口编程 OOP。
4、接口隔离原则：客户端不应该依赖它不需要的接口；类间的依赖关系应该建立在最小的接口上；根据接口隔离原则拆分接口时，首先必须满足单一职责原则。
5、迪米特法则：一个对象应该对其他对象有最少的了解，一个类只需要知道自己需要耦合或者调用类的public方法即可。
6、开闭原则：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。

一、Spring 框架中用到了的设计模式

1、代理模式—在AOP和remoting中被用的比较多。
2、单例模式—在spring配置文件中定义的bean默认为单例模式。
3、模板方法—用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。
4、前端控制器—Spring提供了DispatcherServlet来对请求进行分发。
5、视图帮助(View Helper )—Spring提供了一系列的JSP标签，高效宏来辅助将分散的代码整合在视图里。
6、依赖注入—贯穿于BeanFactory / ApplicationContext接口的核心理念。
7、工厂模式—BeanFactory用来创建对象的实例。

二、微服务架构的六种常用设计模式

1、代理设计模式
2、聚合设计模式
3、链条设计模式
4、聚合链条设计模式
5、数据共享设计模式
6、异步消息设计模式

三、java中，抽象类与接口之间有什么区别

1.一个类可以实现多个接口 ，但却只能继承最多一个抽象类。
2.抽象类可以包含具体的方法 ， 接口的所有方法都是抽象的。
3.抽象类可以声明和使用字段 ，接口则不能，但接口可以创建静态的final常量。
4.接口的方法都是public的，抽象类的方法可以是public，protected，private或者默认的package。
5.抽象类可以定义构造函数，接口却不能。

四、JDK库使用的设计模式

1、装饰器设计模式（Decorator design pattern）被用于多个Java IO类中。
2、单例模式（Singleton pattern）用于Runtime，Calendar和其他的一些类中。
3、工厂模式（Factory pattern）被用于各种不可变的类如Boolean，像Boolean.valueOf，观察者模式（Observer pattern）被用于Swing和很多的事件监听中。

五、单例设计模式的好处

1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

六、实现线程安全的单例模式

  public class MailListReader {
                private static MailListReader reader = null;
                private MailListReader(){}//构造函数私有
                public static MailListReader getInstance() {
                    if(singleton == null){
                       synchronized (Singleton.class){
                         if(singleton == null){
                                 singleton = new Singleton();
                            }
                         }
                     }
              }
       }

七、详解工厂模式

   简单工厂模式：想象一下，一个蛋糕机，有的人想吃香蕉味，有人想吃苹果味的，那么可以做一种可以生成各种口味的蛋糕机，这种蛋糕机就是简单工厂模式。
   代码实现：
   1、 首先定义一个蛋糕接口，里边有一个方法，就是生产蛋糕
   public interface Cake {
         public void production();
    }
    
  2、定义两个类，AppleCake、BananaCake，并实现Cake接口，实现其中的方法，生产自己独特的口味的蛋糕
      public class AppleCake implements Cake {
	    public void production(){
	        System.out.println("生产苹果味的蛋糕");
           }
       }
     public class BananaCake implements Cake {
	    public void production() {
	        System.out.println("生产香蕉味的蛋糕");
	    }
     }
     
  3、定义一个蛋糕工厂类，制作不同口味的蛋糕
    public class CakeFactory {
	    public static Cake creamCake(String type){
	        Cake cake = null;
	        switch(type){
	            case "Apple":
	                cake = new AppleCake();
	                break;
	            case "Banana":
	                cake = new BananaCake();
	                break;
	            default:
	                break;
	        }
	        return cake;
	    }
  }
  
 4、客户端实现生产自己需要的蛋糕口味
 // 通过统一的蛋糕生产工厂，传入不同参数生产不同口味的蛋糕
	public class CakeClient {
	    public static void main(String[] args) {
	        Cake appleCake = CakeFactory.creamCake("Apple");
	        appleCake.production();
	        Cake bananaCake = CakeFactory.creamCake("Banana");
	        bananaCake.production();
	    }
	}
	小结：简单工厂模式违背了开闭原则，扩展性差。

  工厂方法模式：
      对比上面的简单工厂模式的业务，就是定义一个工厂接口，然后实现一个个生产不同口味的工厂，然后客户端就调用这些不同的工厂实现不同的口味。
      代码实现：
      
      1、 首先定义一个蛋糕接口，里边有一个方法，就是生产蛋糕，然后分别定义AppleCake、BananaCake去实现这个接口，此处省略。
       public interface Cake {
             public void production();
        }
        
      2、定义工厂接口
      public interface CakeFactory {
           public Cake createCake();
      }
      
     3、分别定义AppleCakeFactory、BananaCakeFactory实现刚刚定义的接口
     public class AppleCakeFactory implements CakeFactory {
	   public Cake createCake() {
	        return new AppleIceCake();
	    }
	}
	public class BananaCakeFactory implements CakeFactory {
	    public Cake createIceCake() {
	        return new BananaCake();
	    }
	}

   4、 客户端代码
	public class  CakeClient {
	    public static void main(String[] args) {
	        //生产苹果味蛋糕
	        CakeFactory appleFactory = new AppleCakeFactory();
	        Cake appleIceCake = appleFactory.createIceCake();
	        appleIceCake.production();
	        //生产香蕉口味蛋糕
	        CakeFactory  bananaFactory = new BananaCakeFactory();
	        Cake bananaIceCake = bananaFactory.createIceCake();
	        bananaIceCake.production();
	    }
	}
  小结： 每个工厂只生产一种产品，客户端通过不同的工厂去生产不同的产品，而生产哪一产品的逻辑交给客户端这边去处理就OK了。

  抽象工厂模式：存在多个抽象产品类，每个抽象产品类可以派生出多个具体产品类，工厂提供多种方法，去生产各种类型产品，此处省略代码。
  
  总结：简单工厂模式适用于工厂类需要创建的对象比较少的情况，客户只需要传入具体的参数，就可以忽略工厂的生产细节，去获取想要的对象；工厂方法模式，主要是针对单一产品结构的情景；抽象工厂模式则是针对多级产品结构(系列产品)的一种工厂模式。