进阶学习之旅-设计模式之(委派模式&策略模式)

最新推荐文章于 2023-01-31 10:57:04 发布
最新推荐文章于 2023-01-31 10:57:04 发布
阅读量256 收藏
点赞数
分类专栏： 设计模式 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44993313/article/details/119301564
版权

文章目录

1.课程学习目标

1.掌握委派模式，精简程序逻辑，提升代码的可读性。

2.通过学习策略模式来消除程序中大量的if…else… 和switch语句。

3.深刻理解策略模式的应用场景，提高算法的保密性和安全性。

2.内容定位

1.希望通过对于委派模式的学习，让自己写出更加优雅代码的人群。

2.希望通过策略模式的学习，来消除程序中大量的冗余代码和多重条件转移语句的人群。

3.委派模式详解

3.1委派模式的定义

1.委派模式(Delegate Pattern) 的基本作用就是负责任务的调度和分配，和代理模式很像，可以看做是一种特殊情况下的静态代理的全权代理，但是代理模式注重过程，而委派模式注重结果。

2.不属于GOF 23种设计模式之一。

3.属于行为型模式。

4.Delegate 结尾的一般都是委派模式,Dispatcher

3.2 demo案例

3.2.1模拟Boss指派任务给Leader 由员工完成任务执行

main

/**
 * @PackageName: com.raven.pattern.delegate.simple
 * @ClassName: SimpleTest
 * @Blame: raven
 * @Date: 2021-08-01 14:07
 * @Description: 委派模式简单案例 模仿BOSS下达指令给leader BOSS不关心到底具体由谁再干活 只需要让leader完成任务即可
 * leader不直接自己干活，而根据任务的特点 ，调用不同的employee 进行执行任务
 */
public class SimpleTest {

    public static void main(String[] args) {
        Boss boss = new Boss();
        boss.execute("JAVA",new Leader());
        boss.execute("GO",new Leader());

    }
}

定义boss类 leader类

public class Boss {

    public void execute(String command , Leader leader){
        leader.doCommand(command);
    }
}


/**
 * @PackageName: com.raven.pattern.delegate.simple
 * @ClassName: Leader
 * @Blame: raven
 * @Date: 2021-08-01 10:42
 * @Description: leader知道每一个员工所擅长的语言，当有需求到达时，根据需求要求的语言，交于不同的员工进行开发任务。
 */
public class Leader {

    private static Map<String, IEmployee> employeeMap = new HashMap<>();

    private static String JAVA = "JAVA";
    private static String GO = "GO";
    private static String DEFAULT = JAVA;

    static {
        employeeMap.put(JAVA, new EmployeeA());
        employeeMap.put(GO, new EmployeeB());
    }

    public void doCommand(String command) {
        if (!employeeMap.containsKey(command)) {
            employeeMap.get(DEFAULT).doing(command);
        } else {
            employeeMap.get(command).doing(command);
        }
    }
}

定义员工类

/**
 * @PackageName: com.raven.pattern.delegate.simple
 * @ClassName: IEmplyee
 * @Blame: raven
 * @Date: 2021-08-01 10:44
 * @Description: 定义员工接口 规范员工行为
 */
public interface IEmployee {

    /**
     * 员工可以干活
     * @param command 命令行为
     */
    void doing(String command);
}

/**
 * @PackageName: com.raven.pattern.delegate.simple
 * @ClassName: EmployeeA
 * @Blame: raven
 * @Date: 2021-08-01 10:39
 * @Description:
 */
public class EmployeeA implements IEmployee{
    @Override
    public void doing(String command) {
        System.out.println("我是员工，A我擅长JAVA，我执行" + command + "命令");
    }
}

/**
 * @PackageName: com.raven.pattern.delegate.simple
 * @ClassName: EmployeeB
 * @Blame: raven
 * @Date: 2021-08-01 10:39
 * @Description:
 */
public class EmployeeB  implements  IEmployee{

    @Override
    public void doing(String command){
        System.out.println("我是员工B，我擅长GO,我执行"  + command + "命令");
    }
}

3.2.2 模拟spring mvc dispatchServlet 根据不同的uri 执行不同的controller代码

disptacherServlet

/**
 * @PackageName: com.raven.pattern.delegate.mvc
 * @ClassName: DispatcherServlet
 * @Blame: raven
 * @Date: 2021-08-01 14:22
 * @Description: 模拟手写mvc dispatcherServlet 委派设计模式
 * <p>
 * 模拟 根据不同的uri 调用不同的controller方法
 */
public class DispatcherServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 完成调度
        doDispatch(req, resp);
    }

    /**
     * 委派模式 将服务调用的事情委派给dispatch
     * 通过dispatch 完成调度，根据请求不同的uri 调用不同controller代码 执行业务逻辑
     *
     * @param req
     * @param resp
     * @throws IOException
     */
    private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        String requestURI = req.getRequestURI();
        String mid = req.getParameter("mid");

        if (StringUtils.equals("getOrderById", requestURI)) {
            new OrderController().getOrderById(mid);
        } else if (StringUtils.equals("getUserById", requestURI)) {
            new UserController().getUserById(mid);
        } else if (StringUtils.equals("logout", requestURI)) {
            new SystemController().logout();
        } else {
            resp.getWriter().write("404 not found !");
        }
    }
}

controller

public class OrderController {
    public void getOrderById(String id){
        System.out.println("获取订单详情！");
    }
}

public class UserController {
    public void getUserById(String mid){
        System.out.println("获取用户信息！");
    }
}

public class SystemController {
    public void logout(){
        System.out.println("退出服务器！");
    }
}

3.3 spring中的委派模式

BeanDefinitionParserDelegate

4.策略模式详解

4.1策略模式的定义

1.策略模式(Stratege pattern) 是指定义了算法家族、分别封装起来，让他们之间可以互相转换，此模式让算法的变化不会影响到使用算法的用户。

2.可以避免多重分支的if…else… 和switch语句。

4.2策略模式的适用场景

1.加入系统中有很多类，而他们的区别仅仅在于他们的行为不同

2.一个系统需要动态地在几种算法中选择一种。

4.3策略模式优点

1.策略模式符合开闭原则。

2.避免使用多重条件转移语句,如if … else…语句、switch语句。

3.使用策略模式可以提高算法的保密性和安全性。

4.4策略模式的缺点

1.客户端必须知道所有的策略,并且自行决定使用哪一个策略类。

2.代码中会产生非常多的策略类，增加维护难度。

4.5策略模式案例Demo

4.5.1模拟选购商品不同活动采用不同的优惠策略

活动main

/**
 * @PackageName: com.raven.pattern.strategy.promotion
 * @ClassName: PromotionActivityTest
 * @Blame: raven
 * @Date: 2021-08-01 16:14
 * @Description: 创建促销活动 指定活动名称 根据不同的活动名称返回不同的促销活动内容
 */
public class PromotionActivityTest {
    public static void main(String[] args) {
        /**
         *  避免了if else 判断不同活动使用不同策略 促销活动工厂内部决定返回促销策略
         */
        PromotionActivity promotionActivity618 = new PromotionActivity(PromotionStrategyFactory.getPromotionStrategyByPromotionKey(""));
        promotionActivity618.execute();

        PromotionActivity promotionActivity1111 = new PromotionActivity(PromotionStrategyFactory.getPromotionStrategyByPromotionKey("返现活动"));
        promotionActivity1111.execute();
    }
}

/**
 * @PackageName: com.raven.pattern.strategy.promotion
 * @ClassName: PromotionActivity
 * @Blame: raven
 * @Date: 2021-08-01 15:54
 * @Description: 定义促销活动，每一场促销活动都需要指定促销策略
 */
public class PromotionActivity {

    private IPromotionStrategy promotionStrategy;

    public PromotionActivity(IPromotionStrategy promotionStrategy) {
        this.promotionStrategy = promotionStrategy;
    }

    public void execute() {
        promotionStrategy.doPromotion();
    }
}

策略工厂

/**
 * @PackageName: com.raven.pattern.strategy.promotion
 * @ClassName: IPromotionStratrgy
 * @Blame: raven
 * @Date: 2021-08-01 15:50
 * @Description: 定义营销活动策略规范
 */
public interface IPromotionStrategy {
    /**
     * 执行促销活动
     */
    void doPromotion();
}

public class GroupbuyStrategy implements IPromotionStrategy {
    @Override
    public void doPromotion() {
        System.out.println("促销活动为团购活动,五人一起团购，每人减400元！");
    }
}

public class EmptyStrategy implements IPromotionStrategy{
    @Override
    public void doPromotion() {
        System.out.println("现在没有活动！");
    }
}

public class CashbackStrategy implements IPromotionStrategy{
    @Override
    public void doPromotion() {
        System.out.println("促销活动为返现活动，返现200元！");
    }
}

/**
 * @PackageName: com.raven.pattern.strategy.promotion
 * @ClassName: PromotionStrategyFactory
 * @Blame: raven
 * @Date: 2021-08-01 15:56
 * @Description: 促销活动工厂 懒汉式单例模式 + 策略模式
 */
public class PromotionStrategyFactory {
    private PromotionStrategyFactory() {
    }

    private static PromotionStrategyFactory factory;
    private static Map<String, IPromotionStrategy> PROMOTION_STRATEGY_MAP = new HashMap<>();

    static {
        factory = new PromotionStrategyFactory();
        PROMOTION_STRATEGY_MAP.put(PromotionKeyEnum.CASH_BACK.getPromotionName(), new CashbackStrategy());
        PROMOTION_STRATEGY_MAP.put(PromotionKeyEnum.GROUP_BUY.getPromotionName(), new GroupbuyStrategy());
    }

    public static PromotionStrategyFactory getFactory() {
        return factory;
    }

    /**
     * 根据促销活动名称返回促销活动内容
     * @param promotionName
     * @return
     */
    public static IPromotionStrategy getPromotionStrategyByPromotionKey(String promotionName) {
        IPromotionStrategy promotionStrategy = PROMOTION_STRATEGY_MAP.get(promotionName);
        return Objects.isNull(promotionStrategy) ? new EmptyStrategy() : promotionStrategy;
    }
}

public enum PromotionKeyEnum {
    EMPTY("无活动"),
    GROUP_BUY("团购活动"),
    CASH_BACK("返现活动")
    ;
    @Getter
    private String promotionName;

    PromotionKeyEnum(String promotionName) {
        this.promotionName = promotionName;
    }
}

4.5.2根据不同的支付方式进行不同的支付策略

支付main

/**
 * @PackageName: com.raven.pattern.strategy.pay
 * @ClassName: OrderPayTest
 * @Blame: raven
 * @Date: 2021-08-01 17:05
 * @Description: 模拟用户使用不同支付方式支付订单
 * 根据用户选择的支付方式不同，调用不同的支付体系完成支付操作
 */
public class OrderPayTest {

    public static void main(String[] args) {
        Order order = new Order("0001", "OR00001", 90);
        MsgResult msgResult = order.pay(PayStrategy.WE_CHAT_PAY);
        System.out.println(msgResult);

        System.out.println("====================");
        Order order2 = new Order("0001", "OR00002", 90);
        MsgResult msgResult2 = order2.pay(PayStrategy.ALI_PAY);
        System.out.println(msgResult2);

    }
}

/**
 * @PackageName: com.raven.pattern.strategy.pay
 * @ClassName: Order
 * @Blame: raven
 * @Date: 2021-08-01 16:43
 * @Description: 订单对象 支付时调用支付接口
 */
public class Order {
    private String uid;
    private String orderId;
    private double amount;

    public Order(String uid, String orderId, double amount) {
        this.uid = uid;
        this.orderId = orderId;
        this.amount = amount;
    }

    /**
     * 订单支付 不同支付方式返回不同支付策略
     * @param payType
     * @return
     */
    public MsgResult pay(String payType) {
        Payment payment = PayStrategy.getPayment(payType);
        System.out.println("欢迎使用" + payment.getName() + "支付");
        System.out.println("支付订单号为：" + orderId);
        System.out.println("本次交易金额为" + amount + "元");
        return payment.pay(uid, amount);
    }
}

/**
 * @PackageName: com.raven.pattern.strategy.pay
 * @ClassName: MsgResult
 * @Blame: raven
 * @Date: 2021-08-01 16:45
 * @Description: 支付结果封装
 */
public class MsgResult {
    private int code;
    private String msg;
    private Object data;

    public MsgResult(int code, String msg, Object data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }

    @Override
    public String toString() {
        return "支付状态:" + "[" + code + "], " + msg + ", 交易详情：" + data;
    }
}

支付策略

/**
 * @PackageName: com.raven.pattern.strategy.pay.payport
 * @ClassName: PayStrategy
 * @Blame: raven
 * @Date: 2021-08-01 16:57
 * @Description: 支付策略类 根据不同的支付方式封装返回不同的支付策略
 */
public class PayStrategy {
    private PayStrategy() {
    }

    public static final String ALI_PAY = "支付宝支付";
    public static final String WE_CHAT_PAY = "微信支付";

    private static Map<String, Payment> PAYMENT_MAP = new HashMap<>();

    static {
        PAYMENT_MAP.put(ALI_PAY, new AliPay());
        PAYMENT_MAP.put(WE_CHAT_PAY, new WechatPay());
    }

    public static Payment getPayment(String payType) {
        return PAYMENT_MAP.getOrDefault(payType, new AliPay());
    }
}

public class AliPay extends Payment {
    @Override
    public String getName() {
        return "支付宝支付";
    }

    @Override
    public double queryBalance(String uid) {
        return 100;
    }
}

public class WechatPay  extends Payment {
    @Override
    public String getName() {
        return "微信支付";
    }

    @Override
    public double queryBalance(String uid) {
        return 10;
    }
}

public abstract class Payment {

    /**
     * 获取支付方式名称
     * @return
     */
    public abstract String getName();

    /**
     * 查询账户余额
     * @param uid
     * @return
     */
    public abstract double queryBalance(String uid);

    /**
     * 支付校验 当账号余额不足时，无法完成支付
     * @param uid
     * @param amount
     * @return
     */
    public MsgResult pay(String uid, double amount) {
        if (queryBalance(uid) < amount) {
            return new MsgResult(500, "支付失败", "余额不足！");
        }
        return new MsgResult(200, "支付成功", "支付金额:" + amount);
    }
}

4.6 基于策略模式重写 DispatcherServlet


/**
 * @PackageName: com.raven.pattern.delegate.mvc
 * @ClassName: DispatcherServlet
 * @Blame: raven
 * @Date: 2021-08-01 14:22
 * @Description: 模拟手写mvc dispatcherServlet 委派设计模式
 * <p>
 * 模拟 根据不同的uri 调用不同的controller方法
 */
public class DispatcherServlet extends HttpServlet {

    /**
     * 通过工厂模式将controller封装到List集合中
     */
    private List<Handler> handlerMapping = Lists.newArrayList();

    /**
     * 初始化mapping
     * 通过反射将所有的实体属性封装到List中
     *
     * @throws ServletException
     */
    @Override
    public void init() throws ServletException {
        Class<OrderController> orderClazz = OrderController.class;
        try {
            handlerMapping.add(new Handler(orderClazz.newInstance(),
                    orderClazz.getMethod("getOrderById", String.class),
                    "getOrderById"
            ));
        } catch (InstantiationException | IllegalAccessException | NoSuchMethodException e) {
            e.printStackTrace();
        }

    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 完成调度
//        doDispatch(req, resp);

        doDispatch2(req, resp);
    }

    /**
     * 通过反射执行根据不同的url 执行不同的controller中的策略
     * @param req
     * @param resp
     */
    private void doDispatch2(HttpServletRequest req, HttpServletResponse resp) {
        String requestURI = req.getRequestURI();
        String mid = req.getParameter("mid");

        Handler handler = null;
        for (Handler h : handlerMapping) {
            if (StringUtils.equals(requestURI, h.getUrl())) {
                handler = h;
                break;
            }
        }

        try {
            Object o = handler.getMethod().invoke(handler.getController(), mid);
            resp.getWriter().write(o.toString());
        } catch (IllegalAccessException | InvocationTargetException | IOException e) {
            e.printStackTrace();
        }
    }

    @Data
    class Handler {
        private Object controller;
        private Method method;
        private String url;

        public Handler(Object controller, Method method, String url) {
            this.controller = controller;
            this.method = method;
            this.url = url;
        }
    }
}

4.7spring中的策略模式

InstantiationStrategy、Resource

序号设计模式名称博客链接demo 代码链接
1.工厂设计模式https://blog.csdn.net/weixin_44993313/article/details/118046794https://github.com/Gaoning97/coding-life/tree/main/spring/src/main/java/com/raven/pattern/factory
2.单例设计模式https://blog.csdn.net/weixin_44993313/article/details/118112188https://github.com/Gaoning97/coding-life/tree/main/spring/src/main/java/com/raven/pattern/singleton
3.委派模式&策略模式https://blog.csdn.net/weixin_44993313/article/details/119301564https://github.com/Gaoning97/coding-life/tree/main/spring/src/main/java/com/raven/pattern/strategy
4.模板模式&适配器模式https://blog.csdn.net/weixin_44993313/article/details/119301564https://github.com/Gaoning97/coding-life/tree/main/spring/src/main/java/com/raven/pattern/template
5.装饰者模式&观察者模式https://blog.csdn.net/weixin_44993313/article/details/119512428https://github.com/Gaoning97/coding-life/tree/main/spring/src/main/java/com/raven/pattern/decorator
6.设计模式总结https://blog.csdn.net/weixin_44993313/article/details/119547100/
树叶要走风怎么挽留
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++设计模式-行为型模式-策略模式
06-19
c++设计模式-行为型模式-策略模式；qt工程；c++简单源码； 策略（Strategy）模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于...
java设计模式之委派模式原理分析
08-25
"java设计模式之委派模式原理分析" 委派模式（Delegate Pattern）是一种常用的设计模式，它允许对象将请求委托给另一个对象，以便完成特定的任务。在 Java 中，委派模式通常用于实现松耦合、灵活性高的系统设计。 ...
设计模式之委派模式
Cocoxzq000的博客
04-23 110
文章目录前言案例一案例二总结 前言 委派模式(Delegate Pattern) 不属于Gof23种设计模式，委派模式的基本作用就是负责任务的调度和分配 ，跟代理模式很像，可以看做是一种特殊情况下的静态的全权代理，但是代理模式注重过程，而委派模式注重结果。委派模式在Spring中应用的非常多，最常见的DispatcherServlet就用到了委派模式。生活中常见的委派场景也有很多，例如老板(Boss)给项目经理(Leader)下达任务，项目经理会根据实际情况给每个员工派发任务，待员工把任务完成，再有项目
java基础-委派模式
qq_32363305的博客
07-06 1338
概述 委派模式（Delegate Pattern）又叫委托模式。它的基本作用就是负责任务的调度和任务分配，将任务的分配和执行分离开来。可以看做是一种特殊情况下的静态代理的全权代理。 不属于GOF 23种设计模式之一。 属于行为型模式。 场景 1、委派对象本身不知道如何处理一个任务（或一个请求)，把请求交给其它对象来处理。 2、实现程序的解耦。 优点 通过任务委派能够将一个大型的任务细化，然后通过统一管理这些子"任务的完成情况实现任务的跟进，能够加快任务执行的效率。 缺点 任务委派方式需..
委派模式——从SLF4J说起
BASK2312的博客
01-31 179
熟悉JAVA服务器开发的同学应该都使用过日志模块，并且大概率使用过"log4j-over-slf4j"和“slf4j-log4j”这两个包。那么这两个包的区别是什么？为什么会互相引用包含呢？这篇文章会解释下这几个概念的区别。首先说一下SLF4J。核心链路， 开放接口。为了达到某个目的，特定的一组构件，按照特定的顺序，特定的协同标准，共同执行计算的逻辑。给定特定的输入和输出，将实现细节交给外部的功能接口。举个比较现实的例子：传统汽车。
委派设计模式
Charge8的博客
12-05 698
委派设计模式
Java 经典设计模式讲解以及项目实战
最新发布
06-14
Java 经典设计模式讲解以及项目实战 设计模式简介：主要介绍各种设计模式的概念和运用场景等 设计模式综合运用：主要是笔者在实际工作中运用到的一些设计模式综合运用事例的提炼 Spring设计模式简介：主要是讲述...
PHP设计模式之责任链模式的深入解析
01-21
这个设计模式通常和复合模式一起使用，其中有些叶子或容器对象默认委派操作给它们的父对象。另一个例子是，本地化通常是使用责任链处理的，当德语翻译适配器没有为翻译关键词找到合适的结果时，就返回到英语适配器或...
设计模式之委托模式的demo
03-25
使用c++实现的委托模式源代码，供学习设计模式参考使用
分析模式-责任模式
02-21
这个模式主要是通过对现实世界中组织结构的抽象，将上下级之间的所属关系转化为责任关系，从而指导软件设计。在责任模式中，重点是理解参与者的角色、责任的定义以及如何通过接口而非实现来构建这些关系。 首先，...
常用设计模式学习脑图
01-10
常用设计模式脑图，脑图中根据每个设计模式进行了详细的备注解释！我们的最强大脑在哪里？...（单例模式、原型模式、工厂模式、代理模式、策略模式、适配器模式、委派模式、装饰器模式、观察者模式）
学习php设计模式 php实现命令模式(command)
12-18
命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。 请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行操作。命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必...
设计模式模板+委托.pdf
12-10
模板模式是一种行为设计模式，它使你能在不破坏封装性的前提下，定义一系列算法的族，每一种算法都由一个方法来实现。这种类型的设计模式属于行为模式。 模板模式的关键在于一个抽象类（或接口）定义了算法的主要...
PHP常用的三种设计模式
12-18
在编程领域，设计模式是解决常见问题的经过验证的可重用方案，它们代表了最佳实践，可以帮助开发者构建更高效、可维护的代码。在PHP中，设计模式的应用广泛，尤其是单例模式，它在控制类的实例化方面发挥了重要作用...
代理模式 委派模式 策略模式_Delegate 委派模式和代理模式strategy的区别?策略模式如何实现消除多层if else?...
weixin_33404102的博客
12-24 241
@[toc]委派模式委派模式，可以精简程序逻辑，提升代码的可读性。委派模式(Delegate Pattern)的基本作用就是负责任务的调用和分配任务。例如：老板(Boss)给项目经理(Leader)下达任务，项目经理会根据实际情况给每个员工派发工作任务，待员工把工作任务完成之后，再由项目经理汇报工作进度和结果给老板。和代理模式的区别跟代理模式很像，可以看做是一种特殊情况下的静态代理的全权代理，但是...
java 设计模式之-委派模式
qq_21134059的博客
05-28 159
java 设计模式之-委派模式 定义 并不属于23种设计模式，但是面向对象常用的一种设计模式，但在我们使用的spring框架里会经常看见其身影。其原理就是两个类A,B具有相同的属性和方法，但是客户端通过调用b的方法或属性就能调用a的方法和属性，而客户端是不知道a的存在，就好比你在闪修上下一个维修手机的工单，你并不知道它们公司的维修工程师，它自动给你委派一位维修工程师给你上门服务。 举个例子 在我们平时开发工作中当产品经理拟定了一个功能，该功能需要前端工程师和后端工程师一起协同完成。此时产品经理并不会跟前端工
【设计模式】委派模式——登录案例
叁滴水 的博客
10-11 3477
委派模式不属于23种设计模式，但是spring中出现了委派模式的影子,委派模式从字面上即可大概想到这个模式的含义，即想做有些事，但是我自己不想做，那么我委派给你做。老板让经理去做一个项目，经理肯定不会亲自去做，会合理的安排给自己的手下去完成这个项目。这时委派模式的含义就比较清楚了。
委派模式
nidongla的博客
05-01 130
一、定义优惠券网 https://m.fenfaw.net/ 委派模式又叫委托模式，是一种面向对象的设计模式，允许对象组合实现与继承相同的代码重用。它的基本作用就是负责任务的调用和分配任务，是一种特殊的静态代理，可以理解为全权代理，但是代理模式注重过程，而委派模式注重结果。委派模式属于行为型模式，不属于GOF23种设计模式中。 委派模式有3个参与角色 抽象任务角色（ITask）：定义一个抽象接口，它有若干实现类。 委派者角色（Delegate）：负责在各个具体角色实例之间做出决策，判断并调用具体实现的方法.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值