Java设计模式汇总

骑猪看日落 2021-09-21 04:16 271阅读 0赞

### 一、设计原则 ###

**1、开闭原则（Open Close Principle）**

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

**2、里氏代换原则（Liskov Substitution Principle）**

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

**3、依赖倒转原则（Dependence Inversion Principle）**

针对口编程，**依赖于抽象而不依赖于具体**。

**4、接口隔离原则（Interface Segregation Principle）**

使用多个隔离的接口，比使用单个接口要好。还是一个**降低类之间的耦合度的意思**：降低依赖，降低耦合。

**5、迪米特法则（最少知道原则）（Demeter Principle）**

一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

**6、合成复用原则（Composite Reuse Principle）**

原则是尽量使用**合成 / 聚合**的方式，而不是使用继承

--------------------

### 二、常见设计模式 ###

（一）工厂模式

1.作用：一个抽象的接口，多个抽象接口的**实现类**，**一个工厂，用来实例化抽象的接口**。

2.优点：一个调用者想**创建一个对象**，直接向工厂请求即可，**不需要知道具体实现**，以提高系统的可维护性、可扩展性。

3.缺点：产品修改时，工厂也要进行修改。

（二）抽象工厂模式

1.作用：抽象工厂模式（Abstract Factory Pattern）是**围绕一个超级工厂创建其他工厂**。

2.优点:当一个产品类型（每一**类中有多个产品**）被设计成一起工作时，有良好的维护性。

3.缺点：产品类扩展困难。

（三）单例模式

1.作用：保证**一个类仅有一个实例**，并提供一个访问它的全局访问点。

2.特点

*  单例类只能有一个实例。
 *  **单例类必须自己创建自己的唯一实例**。
 *  单例类必须**给所有其他对象提供这一实例**。

3.单例模式分为懒汉式和饿汉式

*  饿汉式：在**程序启动或单件模式类被加载的时候，单例模式实例就已经被创建**。
 *  懒汉式：当程序**第一次访问单例模式实例时才进行创建**。

如何选择：  
如果单件模式实例在系统中经常会被用到，饿汉式是一个不错的选择。  
反之如果单件模式在系统中会很少用到或者几乎不会用到，那么懒汉式是一个不错的选择。

**【代码示例】**

//饿汉式单例模式
    class Singleton{ 
    	//私有的构造函数，保证外类不能实例化本类
    	private Singleton(){ }
    	//自己创建一个类的实例化
    	private static Singleton singleton = new Singleton();
    	//创建一个get方法，返回一个实例s
    	public static Singleton getInstance(){ 
    		return singleton;
    	}
    
    //懒汉式单例模式
    class Singleton { 
    	// 私有的构造函数，保证外类不能实例化本类
    	private Singleton() { 
    	}
     
    	// 自己创建一个类的实例化
    	private static Singleton singleton;
     
    	// 创建一个get方法，返回一个实例s
    	public static Singleton getInstance(){ 
    		//判断singleton是否为null，如果为null，即判定需要实例化
    		if (singleton == null) { 
    			singleton = new Singleton();
    		}
    		return singleton;
    	}
    }

**懒汉式在多线程中是不支持的，所以相对来说，更多的是用饿汉式**

（四）适配器模式

1.作用：**将一个类的接口转换成客户希望的另外一个接口**。Adapter 模式使得**原本由于接口不兼容而不能一起工作的那些类可以在一起工作**。

2.模式中的角色

*  目标接口（Target）：客户所期待的接口。目标可以是具体的或抽象的类，也可以是接口。
 *  需要适配的类（Adaptee）：需要适配的类或适配者类。
 *  适配器（Adapter）：实现了目标接口，通过包装一个需要适配的对象，把原接口转换成目标接口。

**通过适配器把需要适配的类转成目标类**

3.优点

*  接口可以转成自己希望的另一个接口
 *  提高了类的复用。

4.缺点

*  过多地使用适配器，会让系统非常零乱，不易整体进行把握。

（五）装饰器模式

1.作用：**对已有的业务逻辑进一步的封装，使其增加额外的功能**。即向一个现有的对象添加新的功能，同时又不改变其结构。

2.优点：可以提供**比继承更多的灵活性**。在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。

3.缺点：多层装饰比较复杂。

4.参与角色：

*  抽象构件角色（Component）：通常是一个抽象类或者一个接口，定义了一系列方法，方法的实现可以由子类实现或者自己实现。通常不会直接使用该类，而是通过继承该类或者实现该接口来实现特定的功能。
 *  具体构件角色（Concrete Component）：是 Component 的子类，实现了对应的方法，它就是那个被装饰的类。
 *  装饰角色（Decorator）：是 Component 的子类，它是具体装饰角色共同实现的抽象类（也可以是接口），并且持有一个 Component 型的对象引用，它的主要作用就是把客户端的调用委派到被装饰类。
 *  具体装饰角色（Concrete Decorator）：它是具体的装饰类，是 Decorator 的子类，当然也是 Component 的子类。它主要就是定义具体的装饰功能

5.个人理解，子类的继承依旧是实现功能增加的基础，目标类继承目标基类实现已有业务逻辑，装饰基类继承抽象类和接口实现装饰的抽象方法，装饰类继承装饰基类，在目标类的基础上再次增加功能。

【代码示例】

// 被修饰基类——IComponentOutput接口
    public interface IComponentOutput { 
        void operator();
    }
    
    // 被修饰子类——Output类
    public class Output implements IComponentOutput { 
        @Override
        public void operator() { 
            System.out.println("输出字节流");
        }
    }
    
    // 修饰基类——AbstractBuffer抽象类
    public abstract class AbstractBuffer implements IComponentOutput { 
    	//修饰类需要引入被修饰类的基类对象，非常重要！！！
        private IComponentOutput output;
    
        public AbstractBuffer(IComponentOutput output) { 
            this.output = output;
        }
    
        @Override
        public void operator() { 
            output.operator();
        }
    }
    
    // 修饰实现类——Buffer1类
    public class Buffer1 extends AbstractBuffer { 
        public Buffer1(IComponentOutput output) { 
            super(output);
        }
    
        @Override
        public void operator() { 
            super.operator();
            this.b1();
        }
    
        void b1() { 
            System.out.println("附加1");
        }
        
    }
    
    // 修饰实现类——Buffer2类
    public class Buffer2 extends AbstractBuffer { 
    
        public Buffer2(IComponentOutput output) { 
            super(output);
        }
    
        @Override
        public void operator() { 
            super.operator();
            this.b2();
        }
    
        void b2() { 
            System.out.println("附加2");
        }
    }
    
    public class Client { 
        public static void main(String[] args) { 
    
            IComponentOutput output = new Output();
            output.operator();
    
            System.out.println("===定制1===");
            AbstractBuffer b1 = new Buffer1(output);
            AbstractBuffer b2 = new Buffer2(b1);
            b2.operator();
        }
    }
    
    执行结果为：
    输出字节流
    ===定制1===
    输出字节流
    附加1
    附加2

注意：修饰类需要引入被修饰类的基类对象，因为这是保证可以多次修饰，传入的对象是已经被修饰过的对象，就可以在已经修饰的基础上再次修饰。

（六）桥接模式

1.作用：将**抽象部分与实现部分分离，使它们都可以独立的变化**。把两个角色之间的继承关系改为了耦合的关系。

（七） 代理模式

1.作用：一个类代理另一个类的功能。

2.模式中的角色

*  抽象角色：声明真实对象和代理对象的共同接口。
 *  代理角色：代理对象角色内部含有对真实对象的引用，继承了抽象对象。
 *  真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

3.缺点：由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。

（八）观察者模式

1.作用：它定义了**一种一对多的依赖关系**，让多个观察者对象同时监听某一个主题对象。这个主题**对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己**。

2.优点

*  观察者模式在被观察者和观察者之间建立一个抽象的耦合。
 *  观察者模式支持广播通讯。**被观察者会向所有的登记过的观察者发出通知**。

3.缺点

*  如果一个被观察者对象有**很多的直接和间接的观察者**的话，将所有的观察者都通知到会花费很多时间。
 *  如果在观察者和观察目标之间有**循环依赖**的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
 *  观察者模式没**有相应的机制让观察者知道所观察的目标对象是怎么发生变化的**，而仅仅只是知道观察目标发生了变化。

4.参与角色

*  Subject：抽象主题（抽象被观察者），每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以**增加和删除观察者对象**。
 *  ConcreteSubject：具体主题（具体被观察者），把**所有观察者对象保存在一个集合里**，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
 *  Observer：抽象观察者，是观察者者的抽象类，它**定义了一个更新接口，使得在得到主题更改通知时更新自己**。
 *  ConcrereObserver：具体观察者，是实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。

5.应用场景

*  聊天室程序，服务器转发信息给所有客户端。
 *  网络游戏，服务器将客户端状态进行分发。
 *  邮件订阅等。

6.注意，在 JDK 中已经提供了 java.util.Observable 和 java.util.Observer 来实观察者模式。但**是被观察者是一个类而不是接口，限制了它的复用能力**。（因为类只能单继承，而接口则可以实现多个接口）

**【代码实现】**

/** * 观察者接口 * */
    public interface Observer { 
        /** * 定义更新方法 * 收到通知的时候，进行更新 * */
        public abstract void update(String info);
    }
    
    /** * 被观察者接口 * */
    public interface Observerable { 
        /** * 定义维持观察者的接口 ：添加，删除，通知所有 * */
        void add(Observer observer);
        void remove(Observer observer);
        void notifyAllObserver(String info);
    }
    
    // 观察者实现类
    package designpatterns.observer;
    
    public class Client implements Observer { 
        private String name;
    
        public Client(String name) { 
            this.name = name;
        }
    
        @Override
        public void update(String info) { 
            System.out.println(name + " 接收到信息：" + info);
        }
    }
    
    // 被观察者实现类
    package designpatterns.observer;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class Server implements Observerable { 
    
        // 定义持有观察者的队列
        private List<Observer> list;
    
        public Server() { 
            list = new ArrayList<>();
        }
    
        @Override
        public void add(Observer observer) { 
            list.add(observer);
        }
    
        @Override
        public void remove(Observer observer) { 
            if (!list.isEmpty()) { 
                list.remove(observer);
            }
        }
    
        @Override
        public void notifyAllObserver(String info) { 
            for (Observer o : list) { 
                o.update(info);
            }
        }
    
        public void serverAction(String info) { 
            System.out.println("服务器更新信息啦");
            notifyAllObserver(info);
        }
    
    }

--------------------

### 三、设计模式常见问题 ###

**1.装饰者和代理模式的区别**

装饰者模式关注的是对象的动态添加功能。代理模式关注的是对对象的控制访问，对它的用户隐藏对象的具体信息。

**2.装饰者模式和适配器模式**

装饰者模式：动态地将责任附加到对象上，若要扩展功能，装饰者模提供了比继承更有弹性的替代方案。  
通俗的解释：装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

适配器模式：将一个类的接口，转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间。  
适配器模式有三种：类的适配器模式、对象的适配器模式、接口的适配器模式。  
通俗的说法：适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。

*  装饰者模式和被装饰的类要实现同一个接口，或者装饰类是被装饰的类的子类。 适配器模式和被适配的类具有不同的接口。
 *  适配器模式被用于桥接两个接口，而装饰模式的目的是在不修改类的情况下给类增加新的功能。

**3.工厂模式与抽象工厂模式的区别**

首先来看看这两者的定义区别：

*  工厂模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类
 *  抽象工厂模式：为创建**一组相关或相互依赖的对象提供一个接口**，而且无需指定他们的具体类

个人觉得这个区别在于产品，如果产品单一，最合适用工厂模式，但是如果有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。再通俗深化理解下：工厂模式针对的是一个产品等级结构 ，抽象工厂模式针对的是面向多个产品等级结构的。

**4.什么时候使用享元模式**

**享元模式通过共享对象来避免创建太多的对象**。为了使用享元模式，你需要确保你的对象是不可变的，这样你才能安全的共享。

**5.说出几个在 JDK 库中使用的设计模式**

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

**6.什么是责任链设计模式**

责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。在这种模式中，**通常每个接收者都包含对另一个接收者的引用**。如果一**个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推**。

--------------------

**【Java 面试那点事】**

**这里致力于分享 Java 面试路上的各种知识，无论是技术还是经验，你需要的这里都有！**

**这里可以让你【快速了解 Java 相关知识】，并且【短时间在面试方面有跨越式提升】**

**面试路上，你不孤单！**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70]: /images/20210920/036849b7faa8422ba1da74127e970229.png