Java23种设计模式(GOF)——策略模式

策略模式(strategy)


策略模式对应于解决某一个问题的算法族,允许用户从该算法族中任选一个算法解决某一问题,同时可以方便的更换算法或者增加新的算法。并且由客户端决定调用哪个算法。

场景

  • 某个市场人员接到单后的报价策略(CRM系统中常见问题)。报价策略很复杂,简单做如下分类:
    • 普通客户小批量报价
    • 普通客户大批量报价
    • 老客户小批量报价
    • 老客户大批量报价
  • 具体选用哪个报价策略,这需要根据实际情况来确定。

我们可以先用 条件语句(if) 处理,实现起来比较容易,符合一般开发人员的思路。

但假如条件特别多,算法比较复杂时,整个条件代码会变得很长,难以维护。如有新增类型,就需要频繁的修改此处的代码。这时候,可以采用策略模式

案例

/**
 * @author huangyzh
 * @create 2020-05-20 0:20
 */
public interface Strategy {
    double getPrice(double standardPrice);
}
/**
 * @author huangyzh
 * @create 2020-05-20 0:21
 */
public class NewCustomerFewStrategy implements Strategy {
    @Override
    public double getPrice(double standardPrice) {
        System.out.println("普通客户小批量……不打折,原价");
        return standardPrice;
    }
}
/**
 * @author huangyzh
 * @create 2020-05-20 0:22
 */
public class NewCustomerManyStrategy implements Strategy {
    @Override
    public double getPrice(double standardPrice) {
        System.out.println("普通客户大批量……打九折!");
        return standardPrice*0.9;
    }
}

/**
 * @author huangyzh
 * @create 2020-05-20 0:21
 */
public class OldCustomerFewStrategy implements Strategy {
    @Override
    public double getPrice(double standardPrice) {
        System.out.println("老客户小批量……85折");
        return standardPrice*0.85;
    }
}
/**
 * @author huangyzh
 * @create 2020-05-20 0:23
 */
public class OldCustomerManyStrategy implements Strategy {
    @Override
    public double getPrice(double standardPrice) {
        System.out.println("老客户大批量……7折");
        return standardPrice*0.7;
    }
}
/**
 * 负责和具体的策略类交互
 * 这样就可以将具体的算法和直接的调用方分离,使得算法可以独立于调用方
 * @author huangyzh
 * @create 2020-05-20 0:24
 */
public class Context {
    private Strategy strategy;//当前采用的算法对象

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

    public void printPrice(double s){
        System.out.println("报价:"+strategy.getPrice(s));
    }

}
/**
 * @author huangyzh
 * @create 2020-05-20 0:27
 */
public class Test01 {
    public static void main(String[] args) {
        Strategy strategy = new OldCustomerManyStrategy();
        Context c = new Context(strategy);
        c.printPrice(359.0);
    }
}

本质

分离算法,选择实现

开发常见场景

  • JavaSE中GUI编程中,布局管理
  • Spring框架中,Resource接口,资源访问策略
  • javax.servlet.http.HttpServlet#service()
抽象工厂模式是一种创建型设计模式,它提供了一种创建一系列相关或相互依赖对象的接口,而无需指定具体实现类。该模式通过定义一个抽象工厂接口,然后在具体的工厂类中实现该接口,从而创建不同类型的对象。 在Java中,抽象工厂模式通常由以下几个角色组成: 1. 抽象工厂(Abstract Factory):定义了创建一系列产品对象的接口,它包含多个创建产品的抽象方法。 2. 具体工厂(Concrete Factory):实现了抽象工厂接口,负责创建具体的产品对象。 3. 抽象产品(Abstract Product):定义了产品对象的接口,可以是一个抽象类或接口。 4. 具体产品(Concrete Product):实现了抽象产品接口,是具体工厂创建的对象。 下面是一个简单的抽象工厂模式的示例代码: ```java // 抽象产品A interface ProductA { void operationA(); } // 具体产品A1 class ConcreteProductA1 implements ProductA { @Override public void operationA() { System.out.println("具体产品A1的操作"); } } // 具体产品A2 class ConcreteProductA2 implements ProductA { @Override public void operationA() { System.out.println("具体产品A2的操作"); } } // 抽象产品B interface ProductB { void operationB(); } // 具体产品B1 class ConcreteProductB1 implements ProductB { @Override public void operationB() { System.out.println("具体产品B1的操作"); } } // 具体产品B2 class ConcreteProductB2 implements ProductB { @Override public void operationB() { 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 Client { public static void main(String[] args) { AbstractFactory factory1 = new ConcreteFactory1(); ProductA productA1 = factory1.createProductA(); ProductB productB1 = factory1.createProductB(); productA1.operationA(); productB1.operationB(); AbstractFactory factory2 = new ConcreteFactory2(); ProductA productA2 = factory2.createProductA(); ProductB productB2 = factory2.createProductB(); productA2.operationA(); productB2.operationB(); } } ``` 在上述示例中,抽象工厂接口`AbstractFactory`定义了创建产品A和产品B的方法。具体工厂`ConcreteFactory1`和`ConcreteFactory2`分别实现了抽象工厂接口,负责创建具体的产品对象。抽象产品接口`ProductA`和`ProductB`定义了产品对象的操作方法,具体产品类`ConcreteProductA1`、`ConcreteProductA2`、`ConcreteProductB1`和`ConcreteProductB2`实现了抽象产品接口。 通过使用抽象工厂模式,客户端可以通过抽象工厂接口来创建一系列相关的产品对象,而无需关心具体的产品实现类。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值