面试中常考的设计模式解读

￡神魔★判官ぃ 2021-12-10 10:04 278阅读 0赞

随着Java开发的深入，越来越体会到设计模式的重要性，虽然现在很多框架都已经内嵌好了设计模式，但是对于设计模式的学习，我感觉，还是特别的有必要。因为无论自己去写框架还是去研究框架的源码都非常的重要，设计模式就如同武术中的那些秘籍，对于一个高手来说，你如果单靠蛮力来行走江湖，那么注定你走的不是太远，如果你通过掌握各家武林秘籍来行走江湖那么你注定难逢对手，这里可以看出武林秘籍的重要性，这里的设计模式就如同武林秘籍一般。

## 一、设计原则 ##

**1、单一职责原则**  
一个类，只有一个引起它变化的原因。应该只有一个职责。每一个职责都是变化的一个轴线，如果一个类有一个以上的职责，这些职责就耦合在了一起。这会导致脆弱的设计。当一个职责发生变化时，可能会影响其它的职责。另外，多个职责耦合在一起，会影响复用性。例如：要实现逻辑和界面的分离。from：百度百科

**2、开闭原则（Open Close Principle）**  
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

**3、里氏代换原则（Liskov Substitution Principle）**  
里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。from：百度百科

**4、依赖倒转原则（Dependence Inversion Principle）**  
所谓依赖倒置原则（Dependence Inversion Principle）就是要依赖于抽象，不要依赖于具体。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

实现开闭原则的关键是抽象化，并且从抽象化导出具体化实现，如果说开闭原则是面向对象设计的目标的话，那么依赖倒转原则就是面向对象设计的主要手段。 from：百度百科

**5、接口隔离原则（Interface Segregation Principle）**  
这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

**6、合成复用原则（Composite Reuse Principle）**  
合成复用原则就是指在一个新的对象里通过关联关系（包括组合关系和聚合关系）来使用一些已有的对象，使之成为新对象的一部分；新对象通过委派调用已有对象的方法达到复用其已有功能的目的。简言之：要尽量使用组合/聚合关系，少用继承。

**7、迪米特法则（最少知道原则）（Demeter Principle）**  
为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。也就是说一个软件实体应当尽可能少的与其他实体发生相互作用。这样，当一个模块修改时，就会尽量少的影响其他的模块，扩展会相对容易，这是对软件实体之间通信的限制，它要求限制软件实体之间通信的宽度和深度。

## 二、设计模式系列篇 ##

## 1、单例模式 ##

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。  
**注意事项：**  
1、单例类只能有一个实例。  
2、单例类必须自己创建自己的唯一实例。  
3、单例类必须给所有其他对象提供这一实例。  
**使用场景：**  
1、要求生产唯一序列号。  
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。  
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MTAxMTA1_size_16_color_FFFFFF_t_70]  
**懒汉式：**  
  这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。  
**饿汉式：**  
  优点：没有加锁，执行效率会提高。缺点：类加载时就初始化，浪费内存。它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

public class HungerPerson {
        private String name;
    
        private static final HungerPerson HUNGER_PERSON = new HungerPerson();
    
        /**
         *这个必须是私有化的
         */
        private HungerPerson(){
    
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
    
        /**
         *饿汉本身就是一个对象就是安全的
         */
        public static HungerPerson getHungerPerson(){
            return HUNGER_PERSON;
        }
    }

public class LazyPerson {
        private String name;
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        private static LazyPerson lazyPerson;
    
        /**
         *这个必须是私有化的
         */
        private LazyPerson(){
    
        }
    
        /**
         *双重判断
         */
        public static LazyPerson getLazyPerson(){
            if (lazyPerson == null){
                synchronized (LazyPerson.class){
                    if (lazyPerson == null){
                        new LazyPerson();
                    }
                }
            }
            return lazyPerson;
        }
    }

public class MainClass {
        public static void main(String[] args) {
            HungerPerson holder = HungerPerson.getHungerPerson();
            holder.setName("aa");
            HungerPerson hungerPerson = HungerPerson.getHungerPerson();
            hungerPerson.setName("bb");
            System.out.println(holder.getName());
            System.out.println(hungerPerson.getName());
        }
    }

**  讲了那么多，现在讲一下我对于它的理解：首先，我们从字面意思上分析，“单例”可以解释为单个实例，那么这个设计模式的目的就是想法设法的去创建单个实例，也就是唯一的实例，我们知道我们可以通过new对象创建n个实例出来，显然不符合单例设计模式的要求，那么作为单例模式，一定不会允许这种方式出现，于是，它的策略就是我不让客户端拥有创建实例的机会，它在类的定义中，把构造方法私有化，由这个类本身提供一个实例，通过方法的调用让客户端得到这个唯一的实例即可。**

## 2、简单工厂模式 ##

简单工厂模式属于类的创建型模式，又叫做静态工厂方法模式。通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。  
  简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。  
**该模式中包含的角色及其职责：**  
**工厂（Creator）角色**  
简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。  
**抽象产品（Product）角色**  
简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。  
**具体产品（Concrete Product）角色**  
是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MTAxMTA1_size_16_color_FFFFFF_t_70 1]  
**优点**：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。

**缺点**：很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则

**应用场景：**  
简单工厂模式适用于业务简单的情况下或者具体产品很少增加的情况。而对于复杂的业务环境可能不太适应了。这就应该由工厂方法模式来出场了！！

public interface Person {
        void getAction();
    }

public class ManPerson implements Person{
    
        @Override
        public void getAction() {
            System.out.println("男生在工作。。。");
        }
    }

public class WomanPerson implements Person{
    
        @Override
        public void getAction() {
            System.out.println("女生在工作。。。");
        }
    }

public class PersonFactory {
    
        public static Person getManPerson(String type) throws IllegalAccessException, InstantiationException{
            if ("manperson".equalsIgnoreCase(type)) {
                return ManPerson.class.newInstance();
            } else if ("womanperson".equalsIgnoreCase(type)) {
                return WomanPerson.class.newInstance();
            }else if ("testperson".equalsIgnoreCase(type)){
                return TestPerson.class.newInstance();
            } else {
                System.out.println("没有这种类型！");
                return null;
            }
        }
    
    }

public class MainClass {
        public static void main(String[] args) throws InstantiationException, IllegalAccessException {
            // 这是我们用到的一种方式
            /*ManPerson m = new ManPerson();
            WomanPerson w = new WomanPerson();
            m.getAction();
            w.getAction();*/
            // 高级一点的方式
            /*Person person = new ManPerson();
            Person person1 = new WomanPerson();
            person.getAction();
            person1.getAction();*/
    
            Person personMan = PersonFactory.getManPerson("manperson");
            Person personWoman = PersonFactory.getManPerson("womanperson");
            personMan.getAction();
            personWoman.getAction();
    
            Person test = PersonFactory.getManPerson("testperson");
            test.getAction();
        }
    }

**  简单工厂模式说白了，就是一个过程，在客户端根据你所需要创建的对象，到工厂类中，通过反射找到对应的实现。**

## 3、工厂模式 ##

工厂方法模式同样属于类的创建型模式又被称为多态工厂模式。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中，核心工厂类不再负责产品的创建，这样的和心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使的工厂方法模式可以使系统不修改具体工厂角色的情况下引进新的产品。  
**模式中包含的角色及其职责:**  
**1.抽象工厂(Creator) 角色**  
工厂方法模式的核心，任何工厂类都必须实现这个接口。  
**2.具体工厂( Concrete Creator) 角色**  
具体工厂类是抽象工厂 的一个实现，负责实例化产品对象。  
**3.抽象(Product)角色**  
工厂 方法模式所创建的所有对象的父类，它负责描述所有实例  
所共有的公共接口。  
**4.具体产品(Concrete Product)角色工厂**  
方法模式所创建的具体实例对象  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MTAxMTA1_size_16_color_FFFFFF_t_70 2]  
**优点：**  
子类提供挂钩。基类为工厂方法提供缺省实现，子类可以重写新的实现，也可以继承父类的实现。-- 加一层间接性，增加了灵活性  
屏蔽产品类。产品类的实现如何变化，调用者都不需要关心，只需关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。  
典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不需要关心，符合迪米特法则，符合依赖倒置原则，符合里氏替换原则。  
**多态性**：客户代码可以做到与特定应用无关，适用于任何实体类。  
**缺点**：需要Creator和相应的子类作为factory method的载体，如果应用模型确实需要creator和子类存在，则很好；否则的话，需要增加一个类层次。

public interface Person {
        void getAction();
    }

public class ManPerson implements Person {
    
        @Override
        public void getAction() {
            System.out.println("男生在工作。。。");
        }
    }

public class ManPersonFactory implements PersonFactory {
    
        @Override
        public Person getInstance() {
            return new ManPerson();
        }
    }

public interface PersonFactory {
        Person getInstance();
    }

public class WomanPerson implements Person {
    
        @Override
        public void getAction() {
            System.out.println("女生在工作。。。");
        }
    }

public class WomanPersonFactory implements PersonFactory {
    
        @Override
        public Person getInstance() {
            return new WomanPerson();
        }
    }

public class MainClass {
        public static void main(String[] args) {
            PersonFactory factory = new ManPersonFactory();
            Person person = factory.getInstance();
            person.getAction();
    
            PersonFactory factory1 = new WomanPersonFactory();
            Person person1 = factory1.getInstance();
            person1.getAction();
    
            PersonFactory f = new TestPersonFactory();
            Person p = f.getInstance();
            p.getAction();
    
        }
    }

**  工厂模式是在简单工厂模式的基础上进行改进的，由于简单工厂模式违反了设计模式要求的开闭原则，工厂模式就是对于简单工厂模式的改进，如果你想增加一个新的实现，你不需要去改动原先的代码，你只需要去增加这个系列实现即可。**

## 4、抽象工厂模式 ##

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的。 抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。  
![在这里插入图片描述][20190713164929541.png]  
**1抽象工厂(Creator)角色**  
抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个

**2具体工厂( Consrete Creator) 角色**  
多抽象工厂的一个实现， 负责实例化某个产品族中的产品对象。

**3抽象(Product)角色**  
抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共搜口。

4具体产品(Concrete Product)角色抽象模式所创建的具体实例对象

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MTAxMTA1_size_16_color_FFFFFF_t_70 3]  
**优点**：  
抽象工厂模式隔离了具体类的生产，使得客户并不需要知道什么被创建。  
当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。  
增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。  
**缺点**：增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类，对“开闭原则”的支持呈现倾斜性。  
适应场景：  
![在这里插入图片描述][20190713165102386.png]

public interface Person {
        void getAction();
    }

public interface PersonFactory {
    
        ManPerson getManPerson();
        WomanPerson getWomanPerson();
    }

public class SouthManPerson extends ManPerson{
        @Override
        public void getAction() {
            System.out.println("我是南方的男生。。。");
        }
    }

public class SouthPersonFactory implements PersonFactory {
        @Override
        public ManPerson getManPerson() {
            return new SouthManPerson();
        }
    
        @Override
        public WomanPerson getWomanPerson() {
            return new SouthWomanPerson();
        }
    }

public class SouthWomanPerson extends WomanPerson {
        @Override
        public void getAction() {
            System.out.println("我是南方的女生。。。");
        }
    }

public abstract class WomanPerson implements Person {
    
        @Override
        public abstract void getAction();
    }

public class NorthWomanPerson extends WomanPerson{
    
        @Override
        public void getAction() {
            System.out.println("我是北方的女生。。。");
        }
    }

public class NorthPersonFactory implements PersonFactory{
        @Override
        public ManPerson getManPerson() {
            return new NorthManPerson();
        }
    
        @Override
        public WomanPerson getWomanPerson() {
            return new NorthWomanPerson();
        }
    }

public class NorthManPerson extends ManPerson{
        @Override
        public void getAction() {
            System.out.println("我是北方的男人。。。");
        }
    }

public abstract class ManPerson implements Person {
    
        @Override
        public abstract void getAction();
    }

public class MainClass {
        public static void main(String[] args) {
            PersonFactory factory = new NorthPersonFactory();
            Person person = factory.getManPerson();
            person.getAction();
    
            Person person1 = factory.getWomanPerson();
            person1.getAction();
        }
    }

**  抽象的工厂方法是在工厂模式的基础上再次进行改进的，工厂模式已经可以满足中小型的生产需求，但是对于一些大型的需求， 比如我想替换一个产品组，在实际生产中，比如我想在儿童节的时候把QQ皮肤系列替换成儿童节的，在情人节的时候我想把QQ皮肤替换成情人版的，所以，这个是个更大范围的替换，涉及的更复杂。这个时候就要抽象工厂模式了。这个时候我增加的不再是一个产品了，而是一组产品了，就是说，我增加一组产品然后把这组产品对应的产品也增加上。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MTAxMTA1_size_16_color_FFFFFF_t_70]: /images/20211210/098e048aa190411aa9048af76b032f86.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MTAxMTA1_size_16_color_FFFFFF_t_70 1]: /images/20211210/d90a003a0d47441dbe8953be399d3b6c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MTAxMTA1_size_16_color_FFFFFF_t_70 2]: /images/20211210/19f10cf9acc847f494b5aa40d69fce7b.png
[20190713164929541.png]: /images/20211210/57e967914b0849bb83b665580006aa0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MTAxMTA1_size_16_color_FFFFFF_t_70 3]: /images/20211210/76d4139bd9fe4e97abe7717ec68d05da.png
[20190713165102386.png]: /images/20211210/b7332f85acab4a17a649d099fef762d8.png