【面试专题】设计模式篇①

news2024/11/26 14:45:34

1.工厂设计模式

工厂设计模式是一种创建型模式，它提供了一种创建对象的接口，但具体创建的对象类型可以在运行时决定。工厂设计模式主要解决的是创建对象的灵活性问题。

工厂设计模式主要包括简单工厂模式、工厂方法模式和抽象工厂模式三种。

  1. 简单工厂模式：通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。这种模式属于类的创新型模式，又叫静态工厂方法模式。简单工厂模式严重违背了“开闭原则”，难以拓展。
  2. 工厂方法模式：定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口。这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。
  3. 抽象工厂模式：是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

简单工厂模式：

//抽象产品
interface Product {
    void doSomething();
}
 
//具体产品1
class ConcreteProduct1 implements Product {
    @Override
    public void doSomething() {
        System.out.println("具体产品1");
    }
}
 
//具体产品2
class ConcreteProduct2 implements Product {
    @Override
    public void doSomething() {
        System.out.println("具体产品2");
    }
}
 
//工厂类
class Factory{
    public static Product createProduct(int type) {
        switch (type) {
            case 1:
                return new ConcreteProduct1();
            case 2:
                return new ConcreteProduct2();
            default:
                return null;
        }
    }
}
 
//测试类
public class Test {
    public static void main(String[] args) {
        Factory.createProduct(1).doSomething();//输出具体产品1
        Factory.createProduct(2).doSomething();//输出具体产品2
    }
}

工厂方法模式：

//抽象产品
interface Product{
    void doSomething();
}
 
//具体产品1
class ConcreteProduct1 implements Product{
    @Override
    public void doSomething() {
        System.out.println("具体产品1");
    }
}
 
//具体产品2
class ConcreteProduct2 implements Product{
    @Override
    public void doSomething() {
        System.out.println("具体产品2");
    }
}
 
//抽象工厂
interface Factory {
    Product createProduct();
}
 
//具体工厂1
class ConcreteFactory1 implements Factory{
    @Override
    public Product createProduct() {
        return new ConcreteProduct1();
    }
}
 
//具体工厂2
class ConcreteFactory2 implements Factory{
    @Override
    public Product createProduct() {
        return new ConcreteProduct2();
    }
}
 
//测试类
public class Test {
    public static void main(String[] args) {
        Factory factory1 = new ConcreteFactory1();
        factory1.createProduct().doSomething(); //输出具体产品1
        Factory factory2 = new ConcreteFactory2();
        factory2.createProduct().doSomething(); //输出具体产品2
    }
}

抽象工厂模式：

//抽象产品A
interface ProductA{
    void doSomething();
}
 
//具体产品A1
class ConcreteProductA1 implements ProductA{
    @Override
    public void doSomething() {
        System.out.println("具体产品A1");
    }
}
 
//具体产品A2
class ConcreteProductA2 implements ProductA{
    @Override
    public void doSomething() {
        System.out.println("具体产品A2");
    }
}
 
//抽象产品B
interface ProductB{
    void doSomething();
}
 
//具体产品B1
class ConcreteProductB1 implements ProductB{
    @Override
    public void doSomething() {
        System.out.println("具体产品B1");
    }
}
 
//具体产品B2
class ConcreteProductB2 implements ProductB{
    @Override
    public void doSomething() {
        System.out.println("具体产品B2");
    }
}
 
//抽象工厂
interface AbstractFactory{
    ProductA createProductA();
    ProductB createProductB();
}
 
//具体工厂1
class ConcreteFactory1 implements AbstractFactory{
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}
 
//具体工厂2
class ConcreteFactory2 implements AbstractFactory{
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }
    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}
 
//测试类
public class Test {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        factory1.createProductA().doSomething(); //输出具体产品A1
        factory1.createProductB().doSomething(); //输出具体产品B1
        AbstractFactory factory2 = new ConcreteFactory2();
        factory2.createProductA().doSomething(); //输出具体产品A2
        factory2.createProductB().doSomething(); //输出具体产品B2
    }
}

2.策略模式

策略模式是一种行为型设计模式，它允许在运行时选择算法的行为。在Java中，可以通过接口和抽象类来实现策略模式。以下是一个简单的示例，展示应该如何使用Java编写策略模式。

首先，定义一个接口，该接口将定义策略算法的方法。

public interface Strategy {
    int execute(int num1, int num2);
}

接下来，创建实现该接口的不同策略类。

public class Add implements Strategy {
    public int execute(int num1, int num2) {
        return num1 + num2;
    }
}

public class Subtract implements Strategy {
    public int execute(int num1, int num2) {
        return num1 - num2;
    }
}

public class Multiply implements Strategy {
    public int execute(int num1, int num2) {
        return num1 * num2;
    }
}

然后，在主程序中，创建一个Context类，该类使用指定的策略执行算法。

public class Context {

    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
        return strategy.execute(num1, num2);
    }
}

最后，实例化不同的策略并将它们传递给Context类。

public class StrategyPatternExample {

    public static void main(String[] args) {
        Context context = new Context(new Add());
        System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

        context = new Context(new Subtract());
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

        context = new Context(new Multiply());
        System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
    }
}

输出：

10 + 5 = 15
10 - 5 = 5
10 * 5 = 50

这个例子演示了如何实现策略模式，它允许在运行时选择算法的行为。

3.策略模式+工厂模式 实现登录

工厂方法模式是一种创建型模式，它将对象的创建委托给工厂类，由工厂类负责创建具体的对象实例。而策略模式是一种行为型模式，它定义了一系列算法，并将每个算法封装起来，使它们可以互换。

通过工厂方法模式，我们可以根据输入的参数，创建出对应的策略对象，然后通过策略对象来实现登录功能。具体实现如下：

1.创建策略接口，定义登录方法。

public interface LoginStrategy {
    boolean login(String username, String password);
}

2.创建具体的策略实现类，实现登录方法。

public class EmailLoginStrategy implements LoginStrategy {
    @Override
    public boolean login(String username, String password) {
        // 基于邮箱的登录逻辑
        return true;
    }
}

public class PhoneLoginStrategy implements LoginStrategy {
    @Override
    public boolean login(String username, String password) {
        // 基于手机号的登录逻辑
        return true;
    }
}

public class UsernameLoginStrategy implements LoginStrategy {
    @Override
    public boolean login(String username, String password) {
        // 基于用户名的登录逻辑
        return true;
    }
}

3.创建工厂接口，定义创建策略对象的方法。

public interface LoginStrategyFactory {
    LoginStrategy createLoginStrategy(String type);
}

4.创建具体的工厂实现类，根据输入的参数创建对应的策略对象。

public class LoginStrategyFactoryImpl implements LoginStrategyFactory {
    @Override
    public LoginStrategy createLoginStrategy(String type) {
        switch (type) {
            case "email":
                return new EmailLoginStrategy();
            case "phone":
                return new PhoneLoginStrategy();
            case "username":
                return new UsernameLoginStrategy();
            default:
                return null;
        }
    }
}

5.最终的登录类中，调用工厂方法来创建对应的策略对象，并调用登录方法。

public class Login {
    public boolean login(String type, String username, String password) {
        LoginStrategyFactory factory = new LoginStrategyFactoryImpl();
        LoginStrategy strategy = factory.createLoginStrategy(type);
        return strategy.login(username, password);
    }
}

这样，我们就可以根据输入的参数，动态地创建出对应的策略对象来实现登录功能。而且当需要增加新的登录方式时，只需要添加新的策略类和工厂方法即可。

4.责任链模式

责任链模式可以用于将多个处理请求的对象连接起来，形成一条处理链，将请求沿着这条链传递，直到有对象能够处理该请求为止，从而实现请求的处理和解耦的目的。下面以一个简单的示例说明如何在Java中实现责任链设计模式。

abstract class Handler {
     protected Handler handler;

     void setNext(Handler handler){
         this.handler = handler;

     }

    public abstract void process(OrderInfo order);


}


import java.math.BigDecimal;

public class OrderInfo {
    private String  productId;
    private String userId;
    private BigDecimal amount;


    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public BigDecimal getAmount() {
        return amount;
    }

    public void setAmount(BigDecimal amount) {
        this.amount = amount;
    }
}

public class OrderValidition extends Handler {

    @Override
    public void process(OrderInfo order) {
        System.out.println("OrderValidition--------");
        handler.process(order);
    }
}

public class OrderFill extends Handler{
    @Override
    public void process(OrderInfo order) {
        System.out.println("OrderFill----");
        handler.process(order);
    }
}

public class OderAmountCalcuate extends Handler {
    @Override
    public void process(OrderInfo order) {
        System.out.println("OderAmountCalcuate----");
        handler.process(order);
    }
}

public class OderCreate extends Handler {

    @Override
    public void process(OrderInfo order) {
        System.out.println("OderCreate ----");

    }
}

public class Client {
    public static void main(String[] args) {

        OrderValidition orderValidition = new OrderValidition();
        OrderFill orderFill = new OrderFill();
        OderAmountCalcuate oderAmountCalcuate = new OderAmountCalcuate();
        OderCreate oderCreate = new OderCreate();
        
        orderValidition.setNext(orderFill);
        orderFill.setNext(oderAmountCalcuate);
        oderAmountCalcuate.setNext(oderCreate);

        orderValidition.process(new OrderInfo());


    }
}

OrderValidition--------
OrderFill----
OderAmountCalcuate----
OderCreate ----

5.单例模式

推荐视频：【单例模式】猛男因不懂单例模式，被面试官无情嘲讽_哔哩哔哩_bilibili

单例模式是一种创建型设计模式，用于确保类只有一个实例存在，并提供一个全局访问点。它的主要思想是，一个类只允许创建一个对象（或实例），并提供一个访问该对象的全局访问点。

单例模式的应用场景包括：

  1. 全局唯一的配置管理器。

  2. 全局唯一的状态管理器。

  3. 数据库连接池。

  4. 多线程池。

  5. 全局唯一的日志记录器。

  6. 具有特殊限制或唯一性要求的资源管理器。

单例模式的实现方式有多种，包括饿汉式单例、懒汉式单例、双重校验锁单例、静态内部类单例等。其中，饿汉式和懒汉式是最基础的两种实现方式。

1.饿汉式单例模式

饿汉式单例模式在类加载时即创建一个实例，不存在线程安全问题，但会影响性能，因为即使不需要使用该实例，也会一直占用内存。

public class Singleton {
    // 静态实例，类加载时即创建
    private static Singleton instance = new Singleton();
    // 私有构造方法，防止外部创建实例
    private Singleton() {}
    // 全局访问方法
    public static Singleton getInstance() {
        return instance;
    }
}

2.懒汉式单例模式

懒汉式单例模式在第一次访问实例时才创建，但存在线程安全问题，需要进行加锁处理。

public class Singleton {
    // 私有静态实例，延迟加载
    private static Singleton instance = null;
    // 私有构造方法，防止外部创建实例
    private Singleton() {}
    // 全局访问方法，加锁保证线程安全
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
3.双重校验锁单例

双重校验锁单例是一种常用的单例模式实现方式，它既保证了线程安全性，又提高了效率，下面是Java实现双重校验锁单例的代码：

public class Singleton {
    // volatile修饰的变量在多线程环境下保证可见性和有序性
    private volatile static Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                // 双重校验锁，第一个if判断为了避免不必要的同步，第二个if保证同步情况下只有一个instance被创建
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

上述代码中，instance变量使用了volatile关键字修饰，保证在多线程环境下对instance的读写操作都是可见的，避免出现线程A修改了instance变量值而线程B不可见的情况。

在getInstance()方法中，第一个if判断为了避免多个线程同时进入synchronized代码块，进而造成系统资源的浪费。第二个if保证了在同步代码块中，只有一个instance被创建，避免线程安全问题的发生。

总之，使用双重校验锁单例可以保证线程安全性和效率，是一种常用的单例模式实现方式。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1169456.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

虹科示波器 | 汽车免拆检修 | 2010款江铃陆风X8车发动机怠速抖动、加速无力

虹科示波器 | 汽车免拆检修 | 2010款江铃陆风X8车发动机怠速抖动、加速无力

一、故障现象 一辆2010款江铃陆风X8车，搭载4G6GS4N发动机，累计行驶里程约为20万km。该车在其他修理厂进行发动机大修，维修后试车，发动机怠速抖动、加速无力。用故障检测仪检测，发动机控制模块（ECM&#xff…
阅读更多...
JVM常用命令

JVM常用命令

jps —查看pid jstat -gcutil 4364 1000 2000 —查看堆内存占用百分比，每秒打印1次，总共打印2000次 S0：幸存1区当前使用比例 S1：幸存2区当前使用比例 E：伊甸园区使用比例 O：老年代使用比例 M：元…
阅读更多...
常用的Linux远程桌面配置方法

常用的Linux远程桌面配置方法

TigerVNC 是 VNC（虚拟网络计算）的高性能、平台中立的实现，VNC 是一种客户端/服务器应用程序，允许用户在远程计算机上启动图形应用程序并与之交互。 TigerVNC 提供运行 3D 和视频应用程序所需的性能水平，并尝试在其支持…
阅读更多...
基于单片机的温室环境数据监测系统的设计

基于单片机的温室环境数据监测系统的设计

收藏和点赞，您的关注是我创作的动力 文章目录 概要 一、总体方案设计2.1 总体架构设计 二、整体硬件电路设计3.1 主控制器电路 三 系统设计概要4.2 主程序设计原理图程序 四、 结论五、 文章目录 概要 与农业发达国家相比，我国的农业科技方面还处于刚刚…
阅读更多...
腾讯云双11云服务器活动：88元一年的云服务器值得买吗？

腾讯云双11云服务器活动：88元一年的云服务器值得买吗？

作为一名程序员，在选择云服务器时，最关注的是网络稳定性、价格以及云服务商的规模。腾讯云在2023年10月23日的​双11活动​中推出了一款性价比极高的云服务器，为我们提供了一个非常有吸引力的选择。 1. 关注网络稳定性、价格和云服务商规模 …
阅读更多...
jar包的精细化运营，Java模块化简介 | 京东云技术团队

jar包的精细化运营，Java模块化简介 | 京东云技术团队

图：模块化手机概念 一、什么是Java模块化 Java模块化（module）是Java9及以后版本引入的新特性。 官方对模块的定义为：一个被命名的，代码和数据的自描述集合。（ the module, which is a named, self-descri…
阅读更多...
【C语法学习】15 - fopen()函数

【C语法学习】15 - fopen()函数

文章目录 1 函数原型2 返回值3 参数3.1 文件名3.2 模式3.2.1 以"r"模式打开3.2.2 以"w"模式打开3.2.3 以"a"模式打开3.2.4 以"r"模式打开3.2.5 以"w"模式打开3.2.6 以"a"模式打开 1 函数原型 fopen()&#xff1a…
阅读更多...
AI大模型架构师专家，你会问什么来测试我的水平，如何解答上述问题，学习路径是什么

AI大模型架构师专家，你会问什么来测试我的水平，如何解答上述问题，学习路径是什么

0. 沈剑老师的大模型产品应用经验： 提示词三步骤： 假如我是xxx专家，你会问什么来测试我的水平；假如你是xxx专家，你会如何解答上述问题；假如你是xxx专家，上述问题的学习路径是什么；…
阅读更多...
面试算法54：所有大于或等于节点的值之和

面试算法54：所有大于或等于节点的值之和

题目 给定一棵二叉搜索树，请将它的每个节点的值替换成树中大于或等于该节点值的所有节点值之和。假设二叉搜索树中节点的值唯一。例如，输入如图8.10（a）所示的二叉搜索树，由于有两个节点的值大于或等于6（即…
阅读更多...
GCN火车票识别项目 P3 PaddleOCR识别火车票信息

GCN火车票识别项目 P3 PaddleOCR识别火车票信息

从这节开始，就正式进入GCN项目的代码环节，我们先使用PaddleOCR，识别出火车票上的文字信息，并提取文字所位置，整理后另存为一个csv文件。 项目的目的是要做信息抽取，所以对训练和测试数据，需要手…
阅读更多...
存储器（详解）

存储器（详解）

概念 存储器（Memory）是计算机系统中用于存储和检索数据的硬件设备或组件。它在计算机中扮演着重要的角色，允许计算机暂时或永久地存储程序、数据和中间结果。 存储器是许多存储单元的集合，按单元号顺序排列。每个单元由若干二进制…
阅读更多...
专为个人打造专注工作的便签APP工具推荐哪个

专为个人打造专注工作的便签APP工具推荐哪个

工作中很多人都比较懒散，工作起来动力不足，常常拖延消极怠工，等到一天结束后进行工作盘点时才发现很多项任务都没有处理完；这和日常工作不能专注于工作有很大的关系。 专注工作，在日常办公时可以选择一些好用的手机便…
阅读更多...
【Android】android studio 怎么下载NDK

【Android】android studio 怎么下载NDK

序言 新版的android studio在【Project Structure】里面的NDK路径是灰色的，无法点击，导致找不到ndk路径，也无法添加ndk。 下载方法 去这里找，一定要点这个按钮才能出现ndk。 下载之后，要在这个文件里面添加ndk路径
阅读更多...
【不良人7】源源死后，谁将接替成为新的BOSS？全季反派分析

【不良人7】源源死后，谁将接替成为新的BOSS？全季反派分析

Hello,小伙伴们，我是小郑继续为大家深度解析国漫资讯。 深度解析，国漫精品《不良人》在历经6季的精彩演绎后，终于迎来了李嗣源的下线。这一消息对于广大《不良人》粉丝来说无疑是一个巨大的惊喜。而在即将到来的第7季中，剧情将由…
阅读更多...
RPC 原理详解

RPC 原理详解

文章目录 什么是 RPCRPC 基本原理RPC核心功能服务寻址数据编解码网络传输一次RPC的调用过程 实践基于HTTP协议的RPC基于TCP协议的RPC 什么是 RPC RPC（Remote Procedure Call），即远程过程调用，它允许像调用本地服务一样调用远程服…
阅读更多...
思路视野杂志思路视野杂志社思路视野编辑部2023年第24期目录

思路视野杂志思路视野杂志社思路视野编辑部2023年第24期目录

公共文化 公共图书馆文旅融合实践与模式思考 白雪1-3 公共图书馆管理与服务创新路径分析 陈静4-6 提升办公室文书档案管理工作的实践探讨 黄强7-9 《思路视野》投稿邮箱：cn7kantougao163.com(注明投稿“《思路视野》”) 崔编辑Q Q ：296078736 微信号&am…
阅读更多...
STL-set和map

STL-set和map

目录 一、pair和make_pair 1. pair 2. make_pair 二、set （一）set的模板参数列表 （二）set的构造 （三）set的插入 1. 测试1 2. 测试2 （四）low_bound和upper_bound&#xff…
阅读更多...
mediapipe流水线分析 一

mediapipe流水线分析 一

object detection Graph 以目标检测为例分析mediapip流水线处理机制 一 流水线上游输入处理 1 Calculator 算子 它是在MediaPipe框架中用于创建插件/算子 机制的基础 在MediaPipe中，插件是一种可扩展的计算模块，可以用于实现各种不同的计算功能。calc…
阅读更多...
路由器基础（九）：防火墙基础

路由器基础（九）：防火墙基础

防火墙 (Fire Wall) 是网络关联的重要设备，用于控制网络之间的通信。外部网络用户的访问必须先经过安全策略过滤，而内部网络用户对外部网络的访问则无须过滤。现在的防火墙还具有隔离网络、提供代理服务、流量控制等功能。 一、三种防火墙技术 常见的…
阅读更多...
努努之歌：英雄联盟外传 SongOfNunu(单人冒险游戏) 免安装中文版下载

努努之歌：英雄联盟外传 SongOfNunu(单人冒险游戏) 免安装中文版下载

《努努之歌：英雄联盟外传》是一款由Tequila Works开发的单人冒险游戏。置身于弗雷尔卓德的未知之地，探索扣人心弦的故事，一步步揭开努努和威朗普的过去，了解背后的真相。 游戏介绍 建立深厚友谊 扮演小男孩努努，在好朋…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023