java 策略模式 示例
时间: 2023-10-22 07:32:44 浏览: 36
好的,关于 Java 的策略模式示例,我可以给您一个简单的例子:比如,我们需要设计一个程序,用于计算不同商品的优惠价格,那么我们就可以使用策略模式来实现。首先定义一个接口,里面定义一个抽象方法用于计算价格,然后编写不同的实现类,分别代表不同的优惠策略,比如满100元减20元,满200元减50元等等,最后在程序中根据不同的条件选择具体的策略,来计算最终价格。这样,我们就可以实现一个灵活且可扩展性较高的优惠计算程序了。
相关问题
java 策略模式示例代码
### 回答1:
以下是一个使用Java实现策略模式的示例代码:
首先,我们需要定义一个策略接口,它声明了一个方法,该方法将由不同的具体策略实现类来实现。
```java
public interface PaymentStrategy {
public void pay(double amount);
}
```
接下来,我们需要创建具体的策略类,这些类将实现策略接口中定义的方法。在这个例子中,我们创建了两个具体的策略类,分别是CreditCardStrategy和PaypalStrategy。
```java
public class CreditCardStrategy implements PaymentStrategy {
private String name;
private String cardNumber;
private String cvv;
private String dateOfExpiry;
public CreditCardStrategy(String name, String cardNumber, String cvv, String dateOfExpiry) {
this.name = name;
this.cardNumber = cardNumber;
this.cvv = cvv;
this.dateOfExpiry = dateOfExpiry;
}
@Override
public void pay(double amount) {
System.out.println(amount + " paid with credit/debit card");
}
}
public class PaypalStrategy implements PaymentStrategy {
private String emailId;
private String password;
public PaypalStrategy(String emailId, String password) {
this.emailId = emailId;
this.password = password;
}
@Override
public void pay(double amount) {
System.out.println(amount + " paid using Paypal");
}
}
```
接下来,我们需要创建一个Context类,它将持有一个对策略接口的引用,并在运行时根据客户端的选择来设置具体的策略实现。
```java
public class PaymentContext {
private PaymentStrategy strategy;
public PaymentContext(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void setStrategy(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void pay(double amount) {
strategy.pay(amount);
}
}
```
最后,我们可以在客户端代码中使用这些类来进行支付操作。
```java
public static void main(String[] args) {
PaymentContext context = new PaymentContext(new CreditCardStrategy("John Doe", "1234567890123456", "123", "12/24"));
context.pay(100);
context.setStrategy(new PaypalStrategy("john.doe@example.com", "password"));
context.pay(50);
}
```
在这个例子中,我们首先使用信用卡策略来支付100美元,然后使用PayPal策略来支付50美元。由于我们使用了策略模式,客户端代码不需要知道具体的支付实现细节,而只需要知道如何使用支付上下文对象来进行支付操作。
### 回答2:
策略模式是一种行为设计模式,用于将算法的不同实现封装成不同的策略对象,使得它们可以互相替换并独立于客户端代码变化。以下是一个Java策略模式示例代码的简单实现:
首先,我们需要定义一个策略接口,声明所有具体策略类都要实现的方法:
```java
public interface PaymentStrategy {
void pay(double amount);
}
```
然后,我们可以创建不同的具体策略类,每个类实现策略接口,并提供各自的具体实现:
```java
public class CreditCardStrategy implements PaymentStrategy {
private String cardNumber;
private String cvv;
private String expirationDate;
public CreditCardStrategy(String cardNumber, String cvv, String expirationDate) {
this.cardNumber = cardNumber;
this.cvv = cvv;
this.expirationDate = expirationDate;
}
@Override
public void pay(double amount) {
System.out.println("Paying $" + amount + " with credit card.");
// 具体的支付逻辑
}
}
public class PaypalStrategy implements PaymentStrategy {
private String email;
private String password;
public PaypalStrategy(String email, String password) {
this.email = email;
this.password = password;
}
@Override
public void pay(double amount) {
System.out.println("Paying $" + amount + " with Paypal.");
// 具体的支付逻辑
}
}
public class AliPayStrategy implements PaymentStrategy {
private String account;
public AliPayStrategy(String account) {
this.account = account;
}
@Override
public void pay(double amount) {
System.out.println("Paying $" + amount + " with AliPay.");
// 具体的支付逻辑
}
}
```
最后,我们可以创建一个使用策略模式的客户端代码,通过传入不同的策略对象来执行支付操作:
```java
public class PaymentContext {
private PaymentStrategy strategy;
public PaymentContext(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void executePayment(double amount) {
strategy.pay(amount);
}
public static void main(String[] args) {
PaymentContext paymentContext = new PaymentContext(new CreditCardStrategy("123456789", "123", "12/2023"));
paymentContext.executePayment(100.0);
paymentContext = new PaymentContext(new PaypalStrategy("example@example.com", "password"));
paymentContext.executePayment(200.0);
paymentContext = new PaymentContext(new AliPayStrategy("example@example.com"));
paymentContext.executePayment(300.0);
}
}
```
以上代码演示了如何使用策略模式来实现不同的支付方式,并根据不同的策略执行不同的支付逻辑。客户端代码可以通过选择不同的策略对象来实现支付的可替换性。
java策略模式示例代码
以下是Java中策略模式的示例代码:
首先,我们定义一个策略接口`Strategy`,其中包含一个方法`doOperation`:
```java
public interface Strategy {
int doOperation(int num1, int num2);
}
```
然后,我们实现两个具体的策略类`OperationAdd`和`OperationSubtract`,分别实现了`Strategy`接口中的`doOperation`方法:
```java
public class OperationAdd implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 + num2;
}
}
public class OperationSubtract implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 - num2;
}
}
```
接下来,我们定义一个`Context`类,它包含一个`Strategy`接口类型的成员变量`strategy`,并提供了一个`executeStrategy`方法,用于执行具体的策略:
```java
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public int executeStrategy(int num1, int num2) {
return strategy.doOperation(num1, num2);
}
}
```
最后,我们可以使用`Context`类来执行具体的策略:
```java
public class StrategyPatternDemo {
public static void main(String[] args) {
Context context = new Context(new OperationAdd());
System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
context = new Context(new OperationSubtract());
System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
}
}
```
输出结果为:
```
10 + 5 = 15
10 - 5 = 5
```