设计模式八股文

最新推荐文章于 2024-06-15 10:13:23 发布
最新推荐文章于 2024-06-15 10:13:23 发布
阅读量852 收藏 18
点赞数 25
文章标签： 设计模式 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45276167/article/details/138820100
版权

什么是设计模式？

设计模式是软件开发过程中经常遇到的问题的通用解决方案。类似于前人总结的经验，遇到相似问题的时候有个参考。

设计模式七大基本原则？

  • 单一职责：一个类应该只作一件事情。将功能分为小的独立的单元。
  • 开放封闭原则：对扩展开放，对修改关闭。
  • 里氏替换原则：任何一个父类出现的地方，都可以用子类替换，而不会导致错误或者异常。
  • 依赖倒置：高层模块不应该依赖于底层，应该依赖于抽象，实现解耦。
  • 接口隔离：一个类不应该强迫它的客户端依赖于它们不需要的方法，接口应该小而专注，不应该包含多余的方法。

责任链模式？

  • 一种行为型设计模式，使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合。
  • 请求沿着链传递，直到有对象处理为止。
  • 分为三个角色：
    • Handler：抽象处理者，定义了一个处理请求的接口或者抽象类，通常会包含一个指向链中下一个处理者的引用。
    • ConcreteHandler：具体处理者，实现抽象处理者的处理方法，如果能处理就处理，不能就转发给下一个。
    • client：客户端，创建处理链，并向链的第一个处理者对象提交请求。
  • 工作流程：
    • 客户端将请求发送给链上的第一个处理者对象
    • 接收到请求后是否能处理
      • 可以就处理
      • 不可以就转发给链上的下一个处理者
    • 过程重复
  • 场景：
    • 过滤器链
    • 日志记录
    • 异常处理
    • 认证授权
  • 优缺点：
    • 降低耦合度
  • 实际举例：
    • 比如在线商店，用户下单的时候需要
      • 检查订单信息是否完整
      • 检查商品库存是否充足
      • 检查用户余额是否充足
      • 确认订单，更新商品库存和用户余额
public interface OrderHandler{
    void handler(Order order);
}
public class CheckOrderHandler implements OrderHandler {
    private OrderHandler next;

    public CheckOrderHandler(OrderHandler next) {
        this.next = next;
    }

    @Override
    public void hand1e(Order order) {
//检查订单信息是否完整
        if (order.isInfoComplete()) {
//如果订单信息完整，则将请求传递给下一个处理者
            next.handle(order);
        } else {
//如果订单信息不完整，则直接返回错误信息
            throw new RuntimeException("订 单信息不完整");
        }
    }

    public class CheckStockHandler implements OrderHandler {
        private OrderHandler next;

        public CheckStockHandler(OrderHandler next) {
            this.next = next;
        }

        @Override
        public void hand1e(Order order) {
//检查商品库存是否充足.
            if (order.getStock() >= order.getQuantity()) {
//如果库存充足，则将请求传递给下一个处理者
                next.handle(order); 
            } else {
//如果库存不足，则直接返回错误信息
                throw new RuntimeException(" 商品库存不足");
            }
        }
    }

    public class CheckBalanceHandler implements OrderHandler {
        private OrderHandler next;

        public CheckBalanceHandler(OrderHandler next) {
            this.next = next;
        }

        @Override
        public void hand1e(Order order) {
//检查用户余额是否充足.
            if (order.getBalance() >= order.getAmount()) {
//如果余额充足，则将请求传递给下一个处理者.
                next.handle(order); 
            } else {
//如果余额不足，则直接返回错误信息
                throw new RuntimeException("用户 余额不足");
            }
        }
    }

    public class ConfirmOrderHandler implements OrderHandler {
        @Override
        public void handle(Order order) {
//确认订单，更新商品库存和用户余额
            order.confirm();
        }
    }



//客户端代码示例
        CheckOrderHandler checkOrderHandler = new
                CheckOrderHandler();
        CheckStockHandler checkStockHandler = new CheckStockHand1er();
        CheckBalanceHandler checkBalanceHandler = new CheckBalanceHandler();
        ConfirmOrderHandler conf
        irmOrderHandler =new

                ConfirmOrderHand1er();
//将处理器按照一定顺序组成责任链
        checkOrderHand1er.setNext(checkStockHandler);
        checkStockHand1er.setNext(checkBalanceHandler);
        checkBalanceHand1er.setNext(confirmOrderHandler);
        // 处理订单
        Order order = new Order();
        checkOrderHandler.handle(order);

工厂模式？

  • 创建型设计模式主要创建对现象，而不暴露对象的逻辑给客户端。
  • 简单工厂

    • 简单工厂模式的角色包括三个：

      • 抽象产品 角色

      • public abstract class Weapon {
    /**
     * 所有的武器都有攻击行为
     */
    public abstract void attack();
}

      • 具体产品角色

      • public class Tank extends Weapon{
    @Override
    public void attack() {
        System.out.println("坦克开炮！");
    }
}


/**
 * 战斗机（具体产品角色）
 * @version 1.0
 * @className Fighter
 * @since 1.0
 **/
public class Fighter extends Weapon{
    @Override
    public void attack() {
        System.out.println("战斗机投下原子弹！");
    }
}


/**
 * 匕首（具体产品角色）
 * @version 1.0
 * @className Dagger
 * @since 1.0
 **/
public class Dagger extends Weapon{
    @Override
    public void attack() {
        System.out.println("砍他丫的！");
    }
}

      • 工厂类 角色

      • public class WeaponFactory {
    /**
     * 根据不同的武器类型生产武器
     * @param weaponType 武器类型
     * @return 武器对象
     */
    public static Weapon get(String weaponType){
        if (weaponType == null || weaponType.trim().length() == 0) {
            return null;
        }
        Weapon weapon = null;
        if ("TANK".equals(weaponType)) {
            weapon = new Tank();
        } else if ("FIGHTER".equals(weaponType)) {
            weapon = new Fighter();
        } else if ("DAGGER".equals(weaponType)) {
            weapon = new Dagger();
        } else {
            throw new RuntimeException("不支持该武器！");
        }
        return weapon;
    }
}

        优点：不需要关注对象创建细节，要什么对象直接向工厂要就可以，初步实现了生产和消费的分离。缺点：工厂为上帝类，不能出问题；不符合OCP开闭原则，扩展时需要修改工厂类。

      • spring通过依赖注入和面向接口编程解决

  • 工厂方法

    • 工厂方法模式既保留了简单工厂模式的优点，同时又解决了简单工厂模式的缺点。

      工厂方法模式的角色包括：

      • 抽象工厂角色

      • 
/**
 * 武器工厂接口(抽象工厂角色)
 * @author 动力节点
 * @version 1.0
 * @className WeaponFactory
 * @since 1.0
 **/
public interface WeaponFactory {
    Weapon get();
}

      • 具体工厂角色

      • /**
 * 具体工厂角色
 * @author 动力节点
 * @version 1.0
 * @className GunFactory
 * @since 1.0
 **/
public class GunFactory implements WeaponFactory{
    @Override
    public Weapon get() {
        return new Gun();
    }
}
package com.powernode.factory;

/**
 * 具体工厂角色
 * @author 动力节点
 * @version 1.0
 * @className FighterFactory
 * @since 1.0
 **/
public class FighterFactory implements WeaponFactory{
    @Override
    public Weapon get() {
        return new Fighter();
    }
}

      • 抽象产品角色

      • /**
 * 武器类（抽象产品角色）
 * @author 动力节点
 * @version 1.0
 * @className Weapon
 * @since 1.0
 **/
public abstract class Weapon {
    /**
     * 所有武器都有攻击行为
     */
    public abstract void attack();
}

      • 具体产品角色

      • /**
 * 具体产品角色
 * @author 动力节点
 * @version 1.0
 * @className Gun
 * @since 1.0
 **/
public class Gun extends Weapon{
    @Override
    public void attack() {
        System.out.println("开枪射击！");
    }
}
package com.powernode.factory;

/**
 * 具体产品角色
 * @author 动力节点
 * @version 1.0
 * @className Fighter
 * @since 1.0
 **/
public class Fighter extends Weapon{
    @Override
    public void attack() {
        System.out.println("战斗机发射核弹！");
    }
}

        扩展时增加一个产品+工厂，缺点：类爆炸

  • 抽象工厂模式：

    • 抽象工厂中包含4个角色：

      • 抽象工厂角色

      • public abstract class AbstractFactory {
    public abstract Weapon getWeapon(String type);
    public abstract Fruit getFruit(String type);
}

      • 具体工厂角色

      • public class WeaponFactory extends AbstractFactory{

    public Weapon getWeapon(String type){
        if (type == null || type.trim().length() == 0) {
            return null;
        }
        if ("Gun".equals(type)) {
            return new Gun();
        } else if ("Dagger".equals(type)) {
            return new Dagger();
        } else {
            throw new RuntimeException("无法生产该武器");
        }
    }

    @Override
    public Fruit getFruit(String type) {
        return null;
    }
}



public class FruitFactory extends AbstractFactory{
    @Override
    public Weapon getWeapon(String type) {
        return null;
    }

    public Fruit getFruit(String type){
        if (type == null || type.trim().length() == 0) {
            return null;
        }
        if ("Orange".equals(type)) {
            return new Orange();
        } else if ("Apple".equals(type)) {
            return new Apple();
        } else {
            throw new RuntimeException("我家果园不产这种水果");
        }
    }
}

      • 抽象产品角色

      • 具体产品角色

      • public abstract class Weapon {
    public abstract void attack();
}
package com.powernode.product;


public class Gun extends Weapon{
    @Override
    public void attack() {
        System.out.println("开枪射击！");
    }
}

public class Dagger extends Weapon{
    @Override
    public void attack() {
        System.out.println("砍丫的！");
    }
}

        优点：能保证一个工厂只使用一个类型的

        • 缺点：不符合OCP、

单例模式？

见另一篇

策略模式和模板设计模式？

  • 策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互相替换。策略模式让算法独立于使用它的客户而变化。
  • // 定义策略接口
public interface PaymentStrategy {
    void pay(int amount);
}

// 具体策略类：信用卡支付
public class CreditCardPaymentStrategy implements PaymentStrategy {
    private String cardNumber;

    public CreditCardPaymentStrategy(String cardNumber) {
        this.cardNumber = cardNumber;
    }

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using Credit Card: " + cardNumber);
    }
}

// 具体策略类：PayPal支付
public class PayPalPaymentStrategy implements PaymentStrategy {
    private String email;

    public PayPalPaymentStrategy(String email) {
        this.email = email;
    }

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using PayPal: " + email);
    }
}

// 环境类：使用策略
public class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(int amount) {
        paymentStrategy.pay(amount);
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();

        // 使用信用卡支付
        cart.setPaymentStrategy(new CreditCardPaymentStrategy("1234-5678-9012-3456"));
        cart.checkout(100);

        // 使用PayPal支付
        cart.setPaymentStrategy(new PayPalPaymentStrategy("example@example.com"));
        cart.checkout(200);
    }
}

  • 模板方法模式：
    • 模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。
    • // 抽象类，定义模板方法和抽象方法
public abstract class Game {
    // 模板方法
    public final void play() {
        initialize();
        startPlay();
        endPlay();
    }

    protected abstract void initialize();
    protected abstract void startPlay();
    protected abstract void endPlay();
}

// 具体类：足球游戏
public class Football extends Game {
    @Override
    protected void initialize() {
        System.out.println("Football Game Initialized! Start playing.");
    }

    @Override
    protected void startPlay() {
        System.out.println("Football Game Started. Enjoy the game!");
    }

    @Override
    protected void endPlay() {
        System.out.println("Football Game Finished!");
    }
}

// 具体类：篮球游戏
public class Basketball extends Game {
    @Override
    protected void initialize() {
        System.out.println("Basketball Game Initialized! Start playing.");
    }

    @Override
    protected void startPlay() {
        System.out.println("Basketball Game Started. Enjoy the game!");
    }

    @Override
    protected void endPlay() {
        System.out.println("Basketball Game Finished!");
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Game game = new Football();
        game.play();

        game = new Basketball();
        game.play();
    }
}
       结合：
    • // 定义支付策略接口
public interface PaymentStrategy {
    void pay(int amount);
}

// 具体支付策略类：信用卡支付
public class CreditCardPaymentStrategy implements PaymentStrategy {
    private String cardNumber;

    public CreditCardPaymentStrategy(String cardNumber) {
        this.cardNumber = cardNumber;
    }

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using Credit Card: " + cardNumber);
    }
}

// 具体支付策略类：PayPal支付
public class PayPalPaymentStrategy implements PaymentStrategy {
    private String email;

    public PayPalPaymentStrategy(String email) {
        this.email = email;
    }

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using PayPal: " + email);
    }
}

      // 抽象类，定义支付流程的模板方法
public abstract class PaymentProcess {
    private PaymentStrategy paymentStrategy;

    public PaymentProcess(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    // 模板方法
    public final void processPayment(int amount) {
        selectItem();
        enterShippingDetails();
        if (confirmOrder()) {
            makePayment(amount);
        }
        sendReceipt();
    }

    protected void selectItem() {
        System.out.println("Item selected.");
    }

    protected void enterShippingDetails() {
        System.out.println("Shipping details entered.");
    }

    protected boolean confirmOrder() {
        System.out.println("Order confirmed.");
        return true;
    }

    protected void makePayment(int amount) {
        paymentStrategy.pay(amount);
    }

    protected void sendReceipt() {
        System.out.println("Receipt sent to customer.");
    }
}

// 具体的支付流程类可以根据需要进行扩展
public class OnlineStorePaymentProcess extends PaymentProcess {
    public OnlineStorePaymentProcess(PaymentStrategy paymentStrategy) {
        super(paymentStrategy);
    }

    @Override
    protected void selectItem() {
        System.out.println("Item selected from online store.");
    }

    @Override
    protected void enterShippingDetails() {
        System.out.println("Online store shipping details entered.");
    }

    @Override
    protected void sendReceipt() {
        System.out.println("Online store receipt sent to customer.");
    }
}

肉松生产线
关注
  • 25
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux 等高频考点。该 PDF 由...
2024最强Java面试八股文
01-04
《2024最强Java面试八股文》是一份针对Java面试的全面指南，内容涵盖JVM、MQ、MyBatis、MySQL、Redis、Spring Boot、Spring Cloud以及设计模式等多个方面。这份资料旨在帮助求职者系统地复习和掌握Java及相关技术的...
八股文之设计模式
极客鼠之家
08-30 859
定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。是不是有点抽象，举个通俗易懂例子孙权看刘备有雄起之意，杀是不能杀了，那会惹天下人唾弃，就想个招儿收拾他一下，那有什么办法呢？孙权有个妹妹——孙尚香，准备招刘备做女婿，然后孙权想办法把刘备软禁起来，孙权的想法还是很单纯的嘛，就是不让你刘备回西川，然后我东吴想干啥就干啥，夺荆州，吞西川也不是不可能的。...
设计模式八股文【七大原则】
小楼一夜听春雨
02-28 249
【简述设计模式七大原则】 1.开放封闭原则：对扩展开放，对修改关闭。在程序进行拓展的时候，不修改原有的代码，实现热插拔 的功能（热插拔（hot-plugging或Hot Swap）即带电插拔，热插拔功能就是允许用户在不关闭系统，不切断电源的情况下取出和更换损坏的硬盘、电源） 2.单一职责原则：一个类，接口或方法只负责一个职责，降低代码复杂度以及变更引起的风险 3.依赖倒置原则：针对接口编程，依赖于抽象类或接口而不依赖于具体实现类 4.接口隔离原则：将不同功能定义在不同接口中实现接口隔离 5.里氏替换原则：任
【八股文】设计模式篇
weixin_45325628的博客
02-20 1544
目录单例模式单例模式的三要素优点单例模式的注意事项（不能用反射）单例的实现方式（思路：思考一下Java创建对象的几种方式？好像解题思路也不对。。。都是通过new出来的）饿汉模式单例（在类加载时会初始化）枚举的特性懒汉模式单例（在类加载时不初始化，调用获取单例的方法时候再初始化）非枚举创建的单例，存在的问题1. 可以使用反射机制调用私有构造器，创建第二个实例2. 序列化前后，实例发生改变单例模式常见面试题1. 哪些类是单例模式的后续类？在Java中哪些类会成为单例？2. 你能在Java中编写单例里的getIn
Java 面试八股文-设计模式
weixin_42435657的博客
02-23 802
文章目录1、你所知道的设计模式有哪些2、单例模式（Binary Search）3、工厂设计模式（Factory）4、代理模式（Proxy） 1、你所知道的设计模式有哪些 Java 中一般认为有 23 种设计模式，我们不需要所有的都会，但是其中常用的几种设计模式应该去掌握。下面列出了所有的设计模式。需要掌握的设计模式我单独列出来了，当然能掌握的越多越好。 总体来说设计模式分为三大类： 创建型模式，共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共7种：适配器模式、装饰器模式、
八股文|设计模式
weixin_41316216的博客
02-14 294
文章目录八股文|设计模式简述设计模式七大原则简述设计模式的分类简述简单工厂模式 八股文|设计模式 简述设计模式七大原则 开放封闭原则：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。 单一职责原则：一个类、接口或方法只负责一个职责，降低代码复杂度以及变更引起的风险。 依赖倒置原则：针对接口编程，依赖于抽象类或接口而不依赖于具体实现类。 接口隔离原则：将不同功能定义在不同接口中实现接口隔离。 里氏替换原则：任何基类可以出现的地方，子类一定可以出现。 迪米特原则：
java面试八股文
weixin_45927841的博客
03-21 5万+
目录一、java（1）集合1.list：LinkedList、ArrayList和Vector2.set：HashSet和TreeSet3.map：HashMap、TreeMap和HashTable4.list和set的区别（2）其他1.面向对象三大特性2.Object类的常用方法3.Java中线程安全的基本数据结构4.string、stringBuffer和stringBuilder5.抽象类与接口的区别6.java的基本数据类型7.java代码块执行顺序8.static关键字9.覆盖（重写）和重载的区别
设计模式八股文：分类和工厂模式
小楼一夜听春雨
03-01 574
【简述设计模式的分类】 1.创建型模式：在创建对象的同时隐藏创建逻辑，不适用new直接实例化 2.结构性模式：通过类和接口间的继承和引用实现创建复杂结构的对象 3.行为型模式：通过类之间不同通信方式实现不同行为 【简单工厂模式】 简单工厂模式指由一个工厂对象来创建实例，适用于工厂类负责创建对象较少的情况 Spring中的BeanFactory使用简单工厂模式，产生Bean对象 【工厂模式】 工厂模式指定义一个创建对象的接口，让接口的实现类决定创建哪种对象，让类的实例化推迟到子类中进行。 Spring中的Fa
【年后找工作】黑马程序员2023Java八股文整理 -- 设计模式篇
Z70769691的博客
02-22 805
策略模式（Strategy Pattern）是一种行为型设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。策略模式使算法的变化独立于使用它们的客户端，从而可以在运行时动态地改变对象的行为。策略模式通常由一个上下文对象和一组实现不同策略的策略类组成。
2024最强秋招八股文（精简、纯手打）
热门推荐
w20001118的博客
07-11 31万+
该篇文章是博主对Java的学习进行的系统性的归纳总结，汇总了Java基础、JUC、JVM、MySQL、Redis、Linux、计算机网络、常用开发框架等常见的一些问题和解决方案,
八股文与算法(网络,数据库,设计模式,数据结构 ).zip
08-19
适合正在找工作的同学
C++八股文整理（面试必备）
05-13
C++ 语⾔基础篇、C++11 新特性、数据结构和算法、计算机⽹络、操作系统、数据库、设计模式、STL 算法讲解
超越设计模式
03-02
这种八股文式的思维在某种程度上严重影响了程序设计的艺术性，并固化了程序设计者的思想，违背了设计模式的初衷。在本文中，作者总结了设计模式背后的核心思想，并提出了几个关键的设计原则，例如面向接口、封装变化...
Java 桥接模式（Bridge Pattern）是设计模式中的一种结构型设计模式，桥接模式的核心思想是将抽象与实现解耦
最新发布
qq_42623400的博客
06-15 249
/ 实现化角色（Implementor）@OverrideSystem.out.println("绘制圆形...");
建造者模式(大话设计模式)C/C++版本
m0_47104421的博客
06-15 184
创建者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时适用的模式；使得建造代码与表示代码分离，隐藏了该产品是如何组装的，多疑若需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以了。
23种设计模式之代理模式
好我谢特的博客
06-09 669
一文看懂代理模式
设计模式-建造者模式
Sun的个人博客
06-10 605
*** Description: 抽象的建造房屋的类*/// 打地基// 砌墙// 封顶// 造房子roofed();/*** Description: 产品*/
java八股文2024
03-13
很抱歉，我不清楚你所说的"Java八股文2024"是指什么。在Java领域中，通常使用"八股文"来形容一些常见的面试题或考试题目，这些题目涵盖了Java语言的基础知识和常见的编程概念。...10. 什么是Java中的设计模式？

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值