【面试】Java中的设计模式【我终于懂设计模式了】

Mxin5

已于 2023-10-10 21:07:25 修改

阅读量403

点赞数 1

分类专栏： Interview 文章标签：设计模式 java

于 2022-08-11 00:50:33 首次发布

本文链接：https://blog.csdn.net/m0_64210833/article/details/126275995

版权

Interview 专栏收录该内容

20 篇文章 5 订阅

订阅专栏

5工厂方法模式【解决简单工厂的不足，避免增加新的对象修改原有代码】

6抽象工厂模式【其实就是在工厂接口中新增一个抽象方法（新增ipad）】

11策略模式【这个回看上面模板模式举例中采用了策略模式】

1什么是设计模式？

官方解释：设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。

人话：设计模式就是软件开发人员在开发过程中遇到问题的解决方案。

2为什么使用设计模式？

设计模式就是大佬写代码总结的优秀经验，总结下来了。我们把它拿到我们项目中使用，让我们的代码更加优美，高效，可读性高。

3常用设计模式

单例模式【懒汉式+饿汉式+枚举】

单例模式和简单工厂模式..._GuGuBirdXXXX的博客-CSDN博客

工厂模式【Factory，ThreadFactory，SqlSessionFactory，BeanFactory】

工厂方法模式

抽象工厂模式

模板模式

代理模式

适配器模式

监听器模式

策略模式

4工厂模式【简单工厂模式】

创建简单对象的工厂，通过参数进行业务逻辑判读创建不同的对象。【所有的对象都是一个工厂创建】,需要在工厂增加新的对象创建的时候需要修改原本的代码。

简单工厂的优缺点

优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
缺点：所有的对象都用了同一个工厂去创建，试想一下如果我要增加一个手机类型，那么我的创建实例的工厂需要重新修改【违背了ocp【open-closed principle】开闭原则 】。

简单代码举例：

业务需求：小米手机和华为手机都有相同的功能可以打电话和发短信，然后这时候就认为不能打电话和发短信的手机都不能算是手机。然后手机的生产需要依托于手机工厂进行生产。

1定义一个手机接口，实现了该接口，重写了里面的方法才能表示是手机。

//手机的接口
public interface IPhone {
    void call();
    void sendMsg();
}

2定义小米和华为手机的类去实现手机接口

public class MIPhone implements IPhone{
    @Override
    public void call() {
        System.out.println("小米手机在打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("小米手机在发短信");
    }
}

public class HWPhone implements IPhone{
    @Override
    public void call() {
        System.out.println("华为手机再打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("华为手机在发短信");
    }
}

3创建一个手机工厂创建手机对象

/**
 * 工厂模式==简单工厂模式
 * */
public class PhoneFactory {
    public IPhone createPhone(String type){
        // 采用多态的方式进行接收
        if(type.equals("mi"))return new MIPhone();
        if(type.equals("hw"))return new HWPhone();
        return null;
    }
}

4进行测试

public class FactoryTest {
    public static void main(String[] args) {
        PhoneFactory phoneFactory = new PhoneFactory();
        IPhone mi = phoneFactory.createPhone("mi");
        IPhone hw = phoneFactory.createPhone("hw");
        mi.call();
        hw.call();
    }
}

5工厂方法模式【解决简单工厂的不足，避免增加新的对象修改原有代码】

每个手机对象都有对应的工厂进行创建，新增手机对象时不会修改原本的代码【扩展性比较强】。

1定义一个手机接口，实现了该接口，重写了里面的方法才能表示是手机。

//手机的接口
public interface IPhone {
    void call();
    void sendMsg();
}

2定义小米和华为手机的类去实现手机接口

public class MIPhone implements IPhone{
    @Override
    public void call() {
        System.out.println("小米手机在打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("小米手机在发短信");
    }
}

public class HWPhone implements IPhone{
    @Override
    public void call() {
        System.out.println("华为手机再打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("华为手机在发短信");
    }
}

3为每个手机对象分别创建对应的手机工厂【华为小米】

public class MIFactory implements IFactory {
    @Override
    public IPhone createPhone() {
        return new MIPhone();
    }
}

public class HWFactory implements IFactory{
    @Override
    public IPhone createPhone() {
        return new HWPhone();
    }
}

4进行测试

public class FactoryTest {
    public static void main(String[] args) {
        // 每个对象单独由对应的工厂进行创建
        IPhone hwphone = new HWFactory().createPhone();
        IPhone miphone = new MIFactory().createPhone();
        hwphone.call();
        miphone.call();
    }
}

6抽象工厂模式【其实就是在工厂接口中新增一个抽象方法（新增ipad）】

上面两种模式都只是针对一类产品Phone（AbstractProduct），如果要生成另一种产品，应该怎么表示呢？

抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建

1创建手机和ipad和工厂的接口【接口中的抽象方法必须实现】

public interface IPad {
    void watchTV();
}

//手机的接口
public interface IPhone {
    void call();
    void sendMsg();
}

//工厂接口
public interface IFactory {
    IPhone createPhone();
    IPad createPad();
}

2ipad对象和手机对象和工厂对象去实现对应的接口

public class MIPad implements IPad {
    @Override
    public void watchTV() {
        System.out.println("我是小米PAD看片");
    }
}

public class MIPhone implements IPhone {
    @Override
    public void call() {
        System.out.println("小米手机在打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("小米手机在发短信");
    }
}

public class MIFactory implements IFactory {
    @Override
    public IPhone createPhone() {
        return new MIPhone();
    }

    @Override
    public IPad createPad() {
        return new MIPad();
    }
}

public class MIFactory implements IFactory {
    @Override
    public IPhone createPhone() {
        return new MIPhone();
    }

    @Override
    public IPad createPad() {
        return new MIPad();
    }
}

3为每个手机对象分别创建对应的手机工厂【华为小米】

public class HWFactory implements IFactory {
    @Override
    public IPhone createPhone() {
        return new HWPhone();
    }

    @Override
    public IPad createPad() {
        return new HWPad();
    }
}

public class MIFactory implements IFactory {
    @Override
    public IPhone createPhone() {
        return new MIPhone();
    }

    @Override
    public IPad createPad() {
        return new MIPad();
    }
}

4进行测试

public class FactoryTest {
    public static void main(String[] args) {
        IPhone hwphone = new HWFactory().createPhone();
        IPhone miphone = new MIFactory().createPhone();
        hwphone.call();
        miphone.call();

        //=============
        IPad hpad = new HWFactory().createPad();
        IPad mpad = new MIFactory().createPad();
        hpad.watchTV();
        mpad.watchTV();
    }
}

6模板模式【支付宝微信】

抽取一个抽象类，相似的方法定义成抽象方法（public abstract ），通过具体的子类中去实现。这就是模板方法。

比如支付宝微信都有
//1.支付申请
//2.支付回调
//3.查询订单
//4.订单退款

就可以使用模板技术。

public interface PayStrategy {
    void applyPay();
}

给支付模板的支付申请定义一个接口

2抽取一个支付模板【其中的方法是微信和支付宝都会使用】

//1.支付申请
//2.支付回调
//3.查询订单
//4.订单退款
// 抽象类，继承了该类其中的抽象方法必须重写，普通方法可以不重写
public abstract class PayTemplate implements PayStrategy{

    public void applyPay(){
        System.out.println("发起支付申请");
    }
    // 模板模式，抽取一个抽象类，将相同的方法定义成抽象方法【模板技术】，继承过后采用不用逻辑进行重          //写方法（策略模式）
    public abstract void notifys();
    public abstract void queryOrder();
    public abstract void refund();

    public void doPayProcess(){
        applyPay();
        notifys();
        queryOrder();
        refound();
    }

}

3微信和支付宝继承支付模板，重写里面的方法

//1.支付申请
//2.支付回调
//3.查询订单
//4.订单退款
// 策略模式，执行相同的方法采用不同的策略进行实现。
public class WxpayStrategy extends PayTemplate {

     
    @Override
    public void applyPay() {
        // 直接调用父类的方法（策略）
        super.applyPay();
    }

    @Override
    public void notifys() {
        // 采用重写的方式（策略）
        System.out.println("Wxpay notifys");
    }

    @Override
    public void queryOrder() {
        System.out.println("Wxpay queryOrder");
    }

    @Override
    public void refund() {
        System.out.println("Wxpay refound");
    }
}

//1.支付申请
//2.支付回调
//3.查询订单
//4.订单退款
// 策略模式，执行相同的方法采用不同的策略进行实现。
public class AlipayStrategy extends PayTemplate{

    @Override
    public void applyPay() {
        System.out.println("alipay applyPay");
    }

    @Override
    public void notifys() {
        System.out.println("alipay notifys");
    }

    @Override
    public void queryOrder() {
        System.out.println("alipay queryOrder");
    }

    @Override
    public void refund() {
        System.out.println("alipay refound");
    }
}

4进行测试

public class TemplateTest {
    public static void main(String[] args) {
        //支付宝支付
        //new Alipay().doPayProcess();

        // doPayProcess()是WxpayStrategy继承的PayTemplate支付模板中的方法。
        // 进行调用执行时，执行的是子类WxpayStrategy的重写后的方法。
        // 多态的方式进行调用支付服务方法，子类有就用子类的，子类没有重写就用父类的方法
        new WxpayStrategy().doPayProcess();
    }
}

7代理模式【终于搞懂了】

SpringAOP就是采用的是代理模式中的动态代理，mapper没有实现类，feignClient都是采用的动态代理模式，@Autowired等。
代理模式：对目标对象的功能进行增强 【其实是代理对象中注入了目标对象（将目标对象的类当作自己的成员变量），然后调用目标对象的方法，再进行扩展功能】，比如说在目标对象的某个方法执行前后增加一些代码进行功能增强。这样就能够保证在不修改原本目标对象的前提下，提供额外的功能给目标对象，扩展目标对象的功能。【遵守OCP原则】**

代理模式分为静态代理和动态代理。

静态代理：手写的增强代码可以理解为静态代理。

动态代理:JDK动态代理和cglib动态代理

JDK动态代理【必须要实现接口】（给你生成一个兄弟，你的功能你兄弟也有，并且你兄弟还可以有其他的功能。）

必须需要实现接口--为什么要实现接口？

代理类和原生类需要实现相同的接口，从而具有相同的功能，JDK动态代理就是通过接口创建一个代理类，然后具有相同的接口功能，然后进行增强。

cglib动态代理--采用继承的方式【给你生成一个儿子】

代理对象（类）去继承目标对象（需要代理的类），而且可以进行重写和功能增强。

代码实现静态代理：

1创建一个接口用来表示目标对象本来的方法（功能）

为了让代理对象进行实现，具有目标对象的功能，然后进行代理。

//接口
public interface Subject {
    void sing();
    void dance();
    void rap();
}

2目标对象进行实现接口，重写抽象方法。

//（需要代理的类）
public class ChickenStar implements Subject{

    public void sing(){
        System.out.println("唱");
    }
    public void dance(){
        System.out.println("跳");
    }
    public void rap(){
        System.out.println("rap");
    }
}

3代理对象实现接口，具有目标对象（需要代理的类）相同的功能

【并且，代理对象将目标对象变成自己的成员变量。并且提供构造方法】

//代理对象
public class ChickenStarProxy implements Subject{
    // 代理对象将目标对象变成自己的成员变量
    private ChickenStar star;

    public ChickenStarProxy(ChickenStar star){
        this.star = star;
    }

    public void sing(){
        //前置增强
        System.out.println("前置增强..");
        try {
           // int i = 1 / 0;
           // 调用的代理对象的方法
            star.sing();
            //后置增强          
            System.out.println("后置增强  ..");
        }catch (Exception e){
            System.out.println("出现异常..");
        }
    }

    public void dance(){
        System.out.println("收费..");
        star.dance();
        System.out.println("送明信片..");
    }
    public void rap(){
        System.out.println("收费..");
        star.rap();
        System.out.println("送明信片..");
    }
}

4进行测试

public class ProxyTest {
    public static void main(String[] args) {
        ChickenStarProxy proxy = new ChickenStarProxy(new ChickenStar());
        // 这时候调用的就是代理对象的增强后的方法，但是方法中还是调用了目标对象的方法
        proxy.sing();
        //proxy.dance();
        //proxy.rap();
    }
}

8Spring中使用的是那种代理模式？

使用的是JDK动态代理模式。如果目标对象没有实现接口，就需要使用cglib动态代理

9适配器模式

将不兼容的接口转换为可兼容的接口的中间类。

拦截器HandlerInterceptor，实现需要重写三个抽象方法然后有些业务类不需要全部重写，只需要重写一个，这时候就可以采用适配器HandlerInterceptorAdapter进行空实现这个拦截器HandlerInterceptor接口，然后其他类只需要重写一个方法时就可以实现适配器HandlerInterceptorAdapter这个接口。

JDK1.8之后，给接口中增加了默认方法，比如WebMvcConfigurer，可以有方法体，这样就不需要强制重写接口中的方法了，因此这些适配器类已经失去作用了。

10观察者模式【监听器模式】：

当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新，比如Spring中的ApplicationListener

11策略模式【这个回看上面模板模式举例中采用了策略模式】

InstantiationStrategy【创建对象的不同策略--相同的方法不同的实现方式】采用不同的方式进行创建对象。

支付宝支付和微信支付采用的什么设计模式【模板模式和策略模式】

Mxin5

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
1
评论
【面试】Java中的设计模式【我终于懂设计模式了】

代理模式：对目标对象的功能进行增强【其实是代理对象中注入了目标对象（将目标对象的类当作自己的成员变量），然后调用目标对象的方法，再进行扩展功能】，比如说在目标对象的某个方法执行前后增加一些代码进行功能增强。这样就能够保证在不修改原本目标对象的前提下，提供额外的功能给目标对象，扩展目标对象的功能。【遵守OCP原则】** ...............
复制链接

扫一扫