龙空技术网

Java设计模式很难吗,这篇带你熟悉设计模式

玄明Hanko 2327

前言:

现在我们对“java熟悉的设计模式”大体比较关切,各位老铁们都需要了解一些“java熟悉的设计模式”的相关知识。那么小编同时在网络上汇集了一些有关“java熟悉的设计模式””的相关知识,希望看官们能喜欢,你们一起来了解一下吧!

3.1 概述

可以发现,设计模式好像都是类似的。越看越感觉都着不多。其实都是类似面向接口编程的一种体现,只不过侧重点不一样或者说要体现的结果不一样。

3.2 使用场景

问题一:应对可能变化的对象实现

方案:间接创建

模式:工厂模式

问题二:为请求指定相应的操作(类似请假审批,不同时长对应不同职位的审批人)

方案:程序根据请求动态选择操作

模式:责任链模式

3.3 具体说明3.3.1 策略模式策略模式说明

一个行为型模式,包含多个行为或职责的业务,通过策略模式简化

public class StrategyContext {    Strategy strategy;    public StrategyContext(Strategy strategy) {        this.strategy = strategy;    }    /**     *      */    public int context(int a, int b) {        return strategy.operator(a,b);    }}

策略模式的核心为StrategyContext上下文类,持有strategy对象,在context完成操作。

策略模式实践

如何使用策略模式解决大量使用if else 或大量switch问题,策略模式+反射。

策略模式后好像使用都还是要用if else来决定调用哪个类,所以在引入策略模式后,在上下文类还要增加反射。

public class StrategyContext {    Strategy strategy;    public StrategyContext(String type) throws Exception {        Class clazz = Class.forName(type);        this.strategy = (Strategy) clazz.newInstance();    }    /**     *      */    public int context(int a, int b) {        return strategy.operator(a,b);    }

当然这里的type可以用个枚举来解决。感觉代价非常大是不是没必要,不过代码的可读性还是增强了。

p.s. 在框架里策略模式中的Context一般不会直接出现,类似spring中直接在使用时就通过注解给设置了

3.3.2、装饰器模式

描述:原接口Shape不变,方法数量不变,在方法实现中增加修饰

场景:

场景一:一个类功能简单,满足不了我们的需求

场景二:给原方法增加日志功能,不改变原方法,新的实现类去实现此功能,带入的对象为接口对象

特点

原接口Shape不动,增加新的装饰类ShapeDecorator原方法名不变,只是增加或修饰此方法体ColorShapeDecorator装饰类持有原对象,只是增加了修饰

public class ColorShapeDecorator extends ShapeDecorator {    public ColorShapeDecorator(Shape shape) {        super(shape);    }    @Override    public void draw() {        setColor();        shape.draw();    }    private void setColor() {       //设置画图颜色    }}
3.3.3 代理模式

设置一个中间代理来控制访问原目标对象,达到增强原对象的功能和简化访问方式的目的

场景:

场景一:不改变原方法,对原方法增加耗时的计算

场景二:rpc远程调用,client端进行动态代理类似耗时计算一样,用户不用关心client的具体实现

分类

静态代理模式动态代理模式

说明

静态代理模式

/** * 与适配器模式的区别,适配器模式主要改变所考虑对象的接口, * 而代理模式不能改变所代理类的接口。与装饰器模式的区别, * 装饰器模式是为了增强功能,代理模式是为了加以控制 */public class ProxySigntureService implements SigntureService {    private SigntureService signatureService;    /**     * Default constructor     */    public ProxySigntureService(SigntureService signatureService) {        this.signatureService = signatureService;    }    public void sign() {        //控制对这个对象的访问        // 实现电子签名    }}
动态代理模式
public class DynamicProxySignatureService implements InvocationHandler {    private Object obj;    public DynamicProxySignatureService(Object obj) {        this.obj = obj;    }    @Override    public Object invoke(Object proxyObj, Method method, Object[] objects)            throws Throwable {        return method.invoke(obj,objects);    }}

参考文章:

3.3.4 适配器模式

描述:原接口不变,增加方法数量

场景:

场景一:原接口不变,在基础上增加新的方法。

场景二:接口的抽象方法很多,不想一一实现,使用适配器模式继承原实现类,再实现此接口

适配器模式适合需要增加一个新接口的需求,在原接口与实现类基础上需要增加新的接口及方法。类似原接口只能method01方法,需求是增加method02方法,同时不再使用之前接口类。

新接口

public interface Targetable {    /**     *      */    public void method01();    /**     *      */    public void method02();}

原接口实现类

public class Source {    public void method01() {        // TODO implement here    }}

适配器类,用于实现新接口。继承原实现类,同时实现新接口。

public class Adapter extends Source implements Targetable {    /**     *      */    public void method02() {        // TODO implement here    }}

测试类

public class AdapterTest {    public static void main(String[] args) {        Targetable targetable = new Adapter();        targetable.method01();        targetable.method02();    }}
3.3.5 单例模式

保证被创建一次,节省系统开销。

1)单例实现方式

饿汉式懒汉式懒汉式+synchronized双重校验静态内部类枚举(推荐方式)

2)实现代码

饿汉式

package com.hanko.designpattern.singleton;/** * 饿汉式 (饿怕了,担心没有吃,所以在使用之前就new出来) *优点:实现简单,安全可靠 *缺点:在不需要时,就已实例化了 * @author hanko * @version 1.0 * @date 2020/9/14 18:50 */public class HungrySingleton {    //特点一 静态私有变量 直接初始化    private static HungrySingleton instance = new HungrySingleton();    //特点二 构造函数私有    private HungrySingleton(){    }    public static HungrySingleton getInstance(){        return instance;    }    public void doSomething(){        //具体需要实现的功能    }}
懒汉式
package com.hanko.designpattern.singleton;/** * 懒汉式(非常懒,所以在要使用时再去new) *优点:简单 *缺点:存在线程安全问题 * @author hanko * @version 1.0 * @date 2020/9/14 18:50 */public class SluggardSingleton {    //特点一 静态私有变量,先不初始化    private static SluggardSingleton instance;    //特点二 构造函数私有    private SluggardSingleton(){    }    //特点三 null判断,没有实例化就new    public static SluggardSingleton getInstance(){        if(instance == null){            instance = new SluggardSingleton();        }        return instance;    }    public void doSomething(){        //具体需要实现的功能    }}
懒汉式+Synchronized
package com.hanko.designpattern.singleton;/** * 懒汉式(非常懒,所以在要使用时再去new) *优点:简单 *缺点:存在线程安全问题 * @author hanko * @version 1.0 * @date 2020/9/14 18:50 */public class SluggardSingleton {    //特点一 静态私有变量,先不初始化    private static SluggardSingleton instance;    //特点二 构造函数私有    private SluggardSingleton(){    }    //特点三 null判断,没有实例化就new    public static synchronized SluggardSingleton getInstance(){        if(instance == null){            instance = new SluggardSingleton();        }        return instance;    }    public void doSomething(){        //具体需要实现的功能    }}
双重校验
package com.hanko.designpattern.singleton;/** * 双重校验 *对懒汉式单例模式做了线程安全处理增加锁机制 * volatile变量级 * synchronized 类级 * @author hanko * @version 1.0 * @date 2020/9/15 9:53 */public class DoubleCheckSingleton {    //特点一 静态私有变量,增加volatile变量级锁    private static volatile DoubleCheckSingleton instance;    //特点二 构造函数私有    private DoubleCheckSingleton(){    }    //特点三 双重null判断  synchronized类级锁    public static DoubleCheckSingleton getInstance(){        if (instance == null){            synchronized(DoubleCheckSingleton.class){                if (instance == null){                    instance = new DoubleCheckSingleton();                }            }        }        return instance;    }}
静态内部类
package com.hanko.designpattern.singleton;/** * 内部静态类方式 *优点:静态内部类不会在InnerStaticSingleton类加载时加载, * 而在调用getInstance()方法时才加载 *缺点:存在反射攻击或者反序列化攻击 * @author hanko * @version 1.0 * @date 2020/9/15 10:03 */public class InnerStaticSingleton {    //特点一:构造函数私有    private InnerStaticSingleton(){    }    //特点二:静态内部类    private static class InnerSingleton{        private static InnerSingleton instance = new InnerSingleton();    }    public InnerSingleton getInstance(){        return InnerSingleton.instance;    }    public void doSomething(){        //do Something    }}
枚举(推荐方式)
package com.hanko.designpattern.singleton;/** * 枚举实现单例简单安全 * * @author hanko * @version 1.0 * @date 2020/9/14 19:01 */public enum EnumSingleton {    INS;    private Singleton  singleton;    EnumSingleton() {        singleton = new Singleton();    }    public void doSomething(){          singleton...         //具体需要实现的功能    }}EnumSingleton.INS.doSomething();
3.3.6 工厂模式

(简单工厂、抽象工厂):解耦代码。

简单工厂:用来生产同一等级结构中的任意产品,对于增加新的产品,无能为力。

工厂方法:用来生产同一等级结构中的固定产品,支持增加任意产品。

抽象工厂:用来生产不同产品族的全部产品,对于增加新的产品,无能为力;支持增加产品族。

参考文章:

3.3.7 观察者模式

定义了对象之间的一对多的依赖,这样一来,当一个对象改变时,它的所有的依赖者都会收到通知并自动更新。

3.3.8 外观模式

提供一个统一的接口,用来访问子系统中的一群接口,外观定义了一个高层的接口,让子系统更容易使用。

3.3.9 状态模式

允许对象在内部状态改变时改变它的行为,对象看起来好像修改了它的类。与策略模式类似,策略模式侧重点在一个事的不同实现方式抽离出来,而状态模式是一个事的不同状态抽离出来(开始、进行中、结束),每次状态完成自己的业务逻辑。

3.4 总结:适配器模式(原功能不变,增加新功能)、装饰器模式(装饰原功能)、代理模式(控制原功能)策略模式侧重点在一个事的不同实现方式抽离出来,而状态模式是一个事的不同状态抽离出来(开始、进行中、结束),每次状态完成自己的业务逻辑。

标签: #java熟悉的设计模式 #java设计模式的好处有哪些