java常见设计模式

设计模式分类

包含23种设计模式，分别是

创建型模式：用于描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。包含单例、原型、工厂方法、抽象工厂、建造者等 5 种创建型模式。

结构型模式：用于描述如何将类或对象按某种布局组成更大的结构。包含代理、适配器、桥接、装饰、外观、享元、组合等 7 种结构型模式。

行为型模式：用于描述类或对象之间怎样相互协作共同完成单个对象无法单独完成的任务。包含模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等 11 种行为型模式。

设计模式七大原则

• 开闭原则:对扩展开放，对修改关闭
• 里氏替换原则:继承必须确保超类所拥有的性质在子类中仍然成立
• 依赖倒置原则: 要面向接口编程，不要面向实现编程
• 单一职责原则: 控制类的粒度大小、将对象解耦、提高其内聚性
• 接口隔离原则:要为各个类建立它们需要的专用接口
• 迪米特法则:只与你的直接朋友交谈，不跟“陌生人”说话合成
• 复用原则: 尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现

单例模式

单例模式最重要的就是构造器私有

饿汉式

/**
 *饿汉式
 */
public class Hungry {
    private Hungry() {
    }

    private static Dog dog = new Dog();

    public Dog getInstance(){
        return dog;
    }

}

懒汉式 

/**
 * 懒汉式
 */
public class Lazy {

    private Lazy() {
    }

    private volatile static Dog dog = null;

    public Dog getInstance(){
        if (dog==null){
            synchronized (Lazy.class){
                if (dog==null){
                    dog=new Dog();
                }
            }
        }
       return dog;
    }
}

工厂模式

作用：实现创建者和调用者的分离

详细分类：简单工厂模式、工厂方法模式、抽象工厂模式  

核心概念：创建对象时不通过new的方式，而是通过工厂进行对象的创建

代码：见设计模式项目 

应用场景: 

• JDK中Calendar的getlnstance方法
• JDBC中的Connection对象的获取
• Spring中IOC容器创建管理bean对象
• 反射中Class对象的newInstance方法 

抽象工厂模式

针对的是一个产品组

静态代理模式

角色分析：

•  抽象角色：一般会使用接口或抽象类解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
• 客户：访问代理对象的人

代码见 设计模式

好处：

• 可以使真实角色的操作更加纯粹!不用去关注一些公共的业务
• 公共也就就交给代理角色!实现了业务的分工
• 公共业务发生扩展的时候，方便集中管理!

缺点:

• 一个真实角色就会产生一个代理角色;代码量会翻倍-开发效率会变低-

动态代理模式

动态代理的代理类是动态生成的，不是我们直接写好的

动态代理分为两大类：基于接口，基于类的动态代理

• 基于接口：JDK动态代理
• 基于类：cglib

实现动态代理需要了解两个类：Proxy代理，invocationhandler调用处理程序

动态代理是基于反射实现的

代码：

1. 实现InvocationHandler
2. 创建需要被代理的对象
3. 创建代理对象
4. 通过反射的方式实现代理的处理程序

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MyDynamicProxy implements InvocationHandler {

    //代理的对象
    private Object object;

    public void setObject(Object object) {
        this.object = object;
    }

    //创建代理对象
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), object.getClass().getInterfaces(), this);
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object invoke = method.invoke(object, args);
        return invoke;
    }
}

    public static void main(String[] args) {
        MyDynamicProxy proxy = new MyDynamicProxy();
        proxy.setObject(new Host());
        Rent rentProxy = (Rent) proxy.getProxy();
        rentProxy.rent();
    }

模板方法模式

概念

在面向对象程序设计过程中，程序员常常会遇到这种情况：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。

例如，去银行办理业务一般要经过以下4个流程：取号、排队、办理具体业务、对银行工作人员进行评分等，其中取号、排队和对银行工作人员进行评分的业务对每个客户是一样的，可以在父类中实现，但是办理具体业务却因人而异，它可能是存款、取款或者转账等，可以延迟到子类中实现。

结构

模板方法（Template Method）模式包含以下主要角色：

• 抽象类（Abstract Class）：负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。

  • 模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。

  • 基本方法：是实现算法各个步骤的方法，是模板方法的组成部分。基本方法又可以分为三种：

    • 抽象方法(Abstract Method) ：一个抽象方法由抽象类声明、由其具体子类实现。

    • 具体方法(Concrete Method) ：一个具体方法由一个抽象类或具体类声明并实现，其子类可以进行覆盖也可以直接继承。

    • 钩子方法(Hook Method) ：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。

      一般钩子方法是用于判断的逻辑方法，这类方法名一般为isXxx，返回值类型为boolean类型。

• 具体子类（Concrete Class）：实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的组成步骤

案例实现

【例】炒菜

炒菜的步骤是固定的，分为倒油、热油、倒蔬菜、倒调料品、翻炒等步骤。现通过模板方法模式来用代码模拟。类图如下：

代码如下：

public abstract class AbstractClass {
    
    public final void cookProcess() {
        //第一步：倒油
        this.pourOil();
        //第二步：热油
        this.heatOil();
        //第三步：倒蔬菜
        this.pourVegetable();
        //第四步：倒调味料
        this.pourSauce();
        //第五步：翻炒
        this.fry();
    }
​
    public void pourOil() {
        System.out.println("倒油");
    }
​
    //第二步：热油是一样的，所以直接实现
    public void heatOil() {
        System.out.println("热油");
    }
​
    //第三步：倒蔬菜是不一样的（一个下包菜，一个是下菜心）
    public abstract void pourVegetable();
​
    //第四步：倒调味料是不一样
    public abstract void pourSauce();
​
​
    //第五步：翻炒是一样的，所以直接实现
    public void fry(){
        System.out.println("炒啊炒啊炒到熟啊");
    }
}
​
public class ConcreteClass_BaoCai extends AbstractClass {
​
    @Override
    public void pourVegetable() {
        System.out.println("下锅的蔬菜是包菜");
    }
​
    @Override
    public void pourSauce() {
        System.out.println("下锅的酱料是辣椒");
    }
}
​
public class ConcreteClass_CaiXin extends AbstractClass {
    @Override
    public void pourVegetable() {
        System.out.println("下锅的蔬菜是菜心");
    }
​
    @Override
    public void pourSauce() {
        System.out.println("下锅的酱料是蒜蓉");
    }
}
​
public class Client {
    public static void main(String[] args) {
        //炒手撕包菜
        ConcreteClass_BaoCai baoCai = new ConcreteClass_BaoCai();
        baoCai.cookProcess();
​
        //炒蒜蓉菜心
        ConcreteClass_CaiXin caiXin = new ConcreteClass_CaiXin();
        caiXin.cookProcess();
    }
}

注意：为防止恶意操作，一般模板方法都加上 final 关键词。

 优缺点

优点：

• 提高代码复用性

  将相同部分的代码放在抽象的父类中，而将不同的代码放入不同的子类中。

• 实现了反向控制

  通过一个父类调用其子类的操作，通过对子类的具体实现扩展不同的行为，实现了反向控制 ，并符合“开闭原则”。

缺点：

• 对每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大，设计也更加抽象。

• 父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构，它提高了代码阅读的难度。

观察者模式

概念

又被称为发布-订阅（Publish/Subscribe）模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。

结构

在观察者模式中有如下角色：

• Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。

• ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。

• Observer：抽象观察者，是观察者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。

• ConcrereObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。

优缺点

1，优点：

• 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。

• 被观察者发送通知，所有注册的观察者都会收到信息【可以实现广播机制】

2，缺点：

• 如果观察者非常多的话，那么所有的观察者收到被观察者发送的通知会耗时

• 如果被观察者有循环依赖的话，那么被观察者发送通知会使观察者循环调用，会导致系统崩溃