`

3. 行为型模式 (1) 策略模式

阅读更多
3. 行为型模式 (1) 策略模式

在策略模式(Strategy Pattern)中,一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

在策略模式中,我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

优点:
1. 算法可以自由切换。
2. 避免使用多重条件判断。
3. 扩展性良好。

缺点:
1. 策略类会增多。
2. 所有策略类都需要对外暴露。


1. 策略模式

package com.andrew.pattern0301.strategy.model01;
public interface Strategy {
    public int doOperation(int num1, int num2);
}


package com.andrew.pattern0301.strategy.model01;
public class OperationAdd implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

package com.andrew.pattern0301.strategy.model01;
public class OperationMultiply implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}

package com.andrew.pattern0301.strategy.model01;
public class OperationSubstract implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 * num2;
    }
}


package com.andrew.pattern0301.strategy.model01;
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);
    }
}


package com.andrew.pattern0301.strategy.model01;
/**
 * 1. 策略模式
 * 
 * @author andrew
 * @date 2018/08/01
 */
public class Client {
    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 OperationSubstract());
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
        context = new Context(new OperationMultiply());
        System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
    }
}
运行结果:
10 + 5 = 15
10 - 5 = 50
10 * 5 = 5


2. 策略模式

package com.andrew.pattern0301.strategy.model02;
public interface Strategy {
    public int calculate(int a, int b);
}


package com.andrew.pattern0301.strategy.model02;
public class AddStrategy implements Strategy {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
}

package com.andrew.pattern0301.strategy.model02;
public class DivideStrategy implements Strategy {
    @Override
    public int calculate(int a, int b) {
        return a / b;
    }
}

package com.andrew.pattern0301.strategy.model02;
public class MultiplyStrategy implements Strategy {
    @Override
    public int calculate(int a, int b) {
        return a * b;
    }
}

package com.andrew.pattern0301.strategy.model02;
public class SubtractStrategy implements Strategy {
    @Override
    public int calculate(int a, int b) {
        return a - b;
    }
}


package com.andrew.pattern0301.strategy.model02;
public class Environment {
    private Strategy strategy;
    public Environment(Strategy strategy) {
        this.strategy = strategy;
    }
    public Strategy getStrategy() {
        return strategy;
    }
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    public int calculate(int a ,int b) {
        return strategy.calculate(a , b);
    }
}


package com.andrew.pattern0301.strategy.model02;
/**
 * 2. 策略模式
 * 
 * @author andrew
 * @date 2018/08/01
 */
public class Client {
    public static void main(String[] args) {
        AddStrategy addStrategy = new AddStrategy();
        Environment environment = new Environment(addStrategy);
        System.out.println(environment.calculate(3, 4));
        SubtractStrategy subtractStrategy = new SubtractStrategy();
        environment.setStrategy(subtractStrategy);
        System.out.println(environment.calculate(3, 4));
        MultiplyStrategy multiplyStrategy = new MultiplyStrategy();
        environment.setStrategy(multiplyStrategy);
        System.out.println(environment.calculate(3, 4));
        DivideStrategy divideStrategy = new DivideStrategy();
        environment.setStrategy(divideStrategy);
        System.out.println(environment.calculate(3, 4));
    }
}
运行结果:
7
-1
12
0
分享到:
评论

相关推荐

    java 23种设计模式.zip

    设计模式主要分为三大类: 1.创建型模式:工厂模式、抽象...4.行为型模式:模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

    (行为型模式) Strategy 策略模式

    C#面向对象设计模式 (行为型模式) Strategy 策略模式 视频讲座下载

    7.java模板模式与8.策略模式示例

    模板模式是一种行为设计模式,而策略模式则属于结构型设计模式。这两种模式都是用来处理算法和行为的,但它们的核心理念和使用场景有所不同。 ### 模板模式 模板模式定义了一个操作中的算法骨架,而将一些步骤延迟...

    c++设计模式-行为型模式-策略模式

    c++设计模式-行为型模式-策略模式;qt工程;c++简单源码; 策略(Strategy)模式的定义:该模式定义了一系列算法,并将每个算法封装起来,使它们可以相互替换,且算法的变化不会影响使用算法的客户。策略模式属于...

    23种设计模式,创建型模式共5种,结构型模式7种,行为型模式11种

    4. **策略模式**:定义一组可互换的算法,并封装起来,使得它们可以相互替换,提高了算法的可扩展性。 5. **中介者模式**:用一个中介对象来封装一系列对象间的交互,降低它们之间的耦合。 6. **观察者模式**:定义...

    23种设计模式 (创建型,结构型,行为型)

    创建型: 1. 单件模式(Singleton Pattern) 2. 抽象工厂(Abstract Factory) 3.... 4.... 5....结构型: ... 策略模式(Strategy Pattern) 22. 访问者模式(Visitor Pattern) 23. 状态模式(State Pattern)

    设计模式_行为型_策略模式.md

    策略模式(Strategy Pattern)属于设计模式中行为型模式的一种。它的目的是定义一系列算法,并将每一个算法封装起来,使它们之间可以互换,且算法的变化不会影响使用算法的客户。策略模式让算法独立于使用它的客户端...

    C#面向对象设计模式纵横谈\23 行为型模式Strategy策略模式.zip

    在这里与各位分享本人从网络上下载的C#面向对象设计模式纵横谈系列视频,共有25节,除了第一节需要各位贡献一点资源分以作为对本人上传资源的回馈,后面的其他资源均不需要... 这是第23节:行为型模式Strategy策略模式

    策略模式.rar策略模式.rarjava设计模式

    策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。在软件工程中,我们经常遇到需要根据不同的条件或时间点执行不同算法的情况。策略模式提供了一种将算法族封装到各自独立的类中,并让它们之间可以互相...

    JAVA-设计模式-行为型模式-策略模式

    JAVA-设计模式-行为型模式-策略模式

    C#面向对象设计模式纵横谈(23):(行为型模式) Strategy 策略模式

    策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。在C#中,策略模式经常被用来解决复杂的问题,特别是在需要动态切换算法或行为的场景下。它通过将算法封装到具有独立接口的类中,使得算法可以互相替换...

    c#设计模式 行为型模式 实验报告+源代码

    c#设计模式 行为型模式 包括8个设计模式的实验报告+源代码。实验报告包括实验类图和个人总结的一些小技巧,源代码...包括:职责链模式、命令模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式

    10.设计模式-策略模式1

    策略模式是一种设计模式,它允许程序在运行时选择不同的算法或行为,而不是在编译时就固定下来。这种模式的核心思想是将算法封装在独立的策略类中,使得算法的变化不会影响到使用算法的客户端代码。通过这种方式,...

    设计模式(创建型、结构型、行为型)

    设计模式(创建型、结构型、行为型) 设计模式是软件设计中的一种重要概念,它们可以帮助开发者更好地设计和实现软件系统。根据GoF(Gang of Four)的分类,设计模式可以分为三大类:创建型、结构型和行为型。 ...

    新版设计模式手册 通俗的例子讲述设计的方法 1创建型模式 2结构型模式 3 行为模式 详细的设计说明

    这个“新版设计模式手册”深入浅出地介绍了设计模式的三大类:创建型模式、结构型模式和行为模式,为开发者提供了一套详细的设计说明。 一、创建型模式 创建型模式主要关注对象的创建过程,它们的目标是使得对象的...

    23种设计模式-行为型模式.docx

    在给定的文档中,提到了23种设计模式中的几种行为型模式,包括责任链模式、迭代器模式、中介者模式、命令模式、解释器模式、访问者模式、策略模式、模板方法模式、状态模式、观察者模式以及备忘录模式。下面将对这些...

    [行为型模式] 策略模式的理解

    策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。在软件工程中,我们经常遇到需要根据不同的条件或场景来执行不同算法的情况。策略模式提供了一种将算法族封装到各自独立的类中,并让它们之间可以互相...

    设计模式之行为型模式代码.zip

    1. **策略模式**: 策略模式定义了一系列算法,并将每个算法封装起来,使它们可以相互替换。这样做的好处是让算法的变化独立于使用它的客户。例如,在一个游戏项目中,不同的角色可能有不同的移动策略,通过策略...

    Head.First设计模式

    3. 行为型模式:如策略模式(Strategy)、模板方法模式(Template Method)、观察者模式(Observer)、命令模式(Command)、迭代器模式(Iterator)、访问者模式(Visitor)、备忘录模式(Memento)、状态模式...

Global site tag (gtag.js) - Google Analytics