java 策略模式 实例
时间: 2023-06-04 15:09:07 浏览: 177
策略模式是一种常见的设计模式,它可以实现对同一种算法的多种不同实现,以便在运行时根据需要选择合适的实现。其中包括定义一个算法家族,分别封装起来,让它们之间可以互相替换,此模式让算法的变化独立于使用算法的客户端(调用者),从而实现了算法的灵活性和扩展性。
一个简单的实现策略模式的示例是实现一个收费系统,其中有各种不同的付费方式,如现金、信用卡、支付宝等,而对于每种付费方式,具体的计算方式也不同。通过使用策略模式,在每种付费方式对应的策略类中,分别实现不同的计算方式,从而实现收费系统的灵活性和可扩展性。
在Java中可以采用接口或抽象类来定义策略类,从而实现策略模式。具体实现时,需要定义一个上下文类,用于维护当前使用的策略对象,并提供一些与策略相关的接口,以便客户端调用。客户端可以动态设置上下文类的策略对象,从而实现对不同算法的选择。
以上就是一个简单的Java策略模式实例,希望对您有所帮助。
相关问题
Java 策略模式 实例代码
策略模式是一种行为设计模式,它允许你在运行时改变对象的行为。这种模式通过定义一系列算法,并将每个算法封装成独立的对象,然后让它们之间可以相互替换,以此来实现动态地选择算法。
下面是一个简单的Java策略模式实例代码:
```java
// 定义策略接口
interface ShippingStrategy {
double calculateShippingCost(double weight);
}
// 具体策略实现
class FlatRateShipping implements ShippingStrategy {
@Override
public double calculateShippingCost(double weight) {
return 5.0;
}
}
class FreeShippingForSmallOrders implements ShippingStrategy {
private final double freeWeightThreshold;
public FreeShippingForSmallOrders(double freeWeightThreshold) {
this.freeWeightThreshold = freeWeightThreshold;
}
@Override
public double calculateShippingCost(double weight) {
if (weight <= freeWeightThreshold) {
return 0.0;
} else {
return 10.0; // 对于超过免费重量的部分收费
}
}
}
// 策略上下文
class Order {
private ShippingStrategy shippingStrategy;
public void setShippingStrategy(ShippingStrategy strategy) {
this.shippingStrategy = strategy;
}
public double getTotalCost(double weight) {
double basePrice = 100.0; // 假设订单基础价格
return basePrice + shippingStrategy.calculateShippingCost(weight);
}
}
public class Main {
public static void main(String[] args) {
Order order = new Order();
order.setShippingStrategy(new FlatRateShipping()); // 使用固定费率策略
System.out.println(order.getTotalCost(2)); // 输出:105.0
order.setShippingStrategy(new FreeShippingForSmallOrders(5.0)); // 使用免运费策略
System.out.println(order.getTotalCost(3)); // 输出:100.0
System.out.println(order.getTotalCost(6)); // 输出:110.0
}
}
```
在这个例子中,`Order` 类是策略上下文,它持有不同类型的 `ShippingStrategy` 对象。可以根据需要切换不同的策略来计算运费。
java策略模式应用实例
Java中的策略模式是一种行为型设计模式,它允许在运行时根据不同的算法或策略来改变对象的行为。这种模式可以将算法的实现与调用代码分离,使得它们可以独立地变化。
下面是一个简单的Java策略模式的应用实例:
首先,我们定义一个策略接口(Strategy),它包含一个执行算法的方法:
```java
public interface Strategy {
void execute();
}
```
然后,我们实现两个具体的策略类(ConcreteStrategyA和ConcreteStrategyB),它们分别实现了策略接口中的execute方法:
```java
public class ConcreteStrategyA implements Strategy {
@Override
public void execute() {
System.out.println("执行策略A");
}
}
public class ConcreteStrategyB implements Strategy {
@Override
public void execute() {
System.out.println("执行策略B");
}
}
```
接下来,我们定义一个上下文类(Context),它包含一个策略对象,并提供一个执行策略的方法:
```java
public class Context {
private Strategy strategy;
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public void executeStrategy() {
strategy.execute();
}
}
```
最后,我们可以通过以下方式使用策略模式:
```java
public class Main {
public static void main(String[] args) {
Strategy strategyA = new ConcreteStrategyA();
Strategy strategyB = new ConcreteStrategyB();
Context context = new Context();
context.setStrategy(strategyA);
context.executeStrategy();
context.setStrategy(strategyB);
context.executeStrategy();
}
}
```
在上述示例中,我们通过策略模式将不同的算法封装在具体的策略类中,并通过上下文类来切换和执行不同的策略。这样,我们可以方便地扩展和替换策略,而无需修改客户端代码。
希望这个实例能帮助你更好地理解Java中的策略模式。