1.19（设计模式）策略模式

策略模式，定义一组算法（代码），将它们封装起来，使其可以相互替换。

 

策略模式首先要针对不同的情况（算法、代码）定义不同的策略类。

 

首先看个一段代码

public class Test {
    public static void main(String[] args) {
        insertCode();
    }
    
    
    public static void insertCode() {
        System.out.println("start");
        //此处插入一段代码
        System.out.println("end");
    }
}

要想插入代码有什么方法呢，我们可以定义个Insert接口，在其中定义insertCode方法。

然后具体的类去实现它，并将该类作为参数传递给main中的inserCode方法。

 

插入接口

public interface Insert {
    void insertCode();
}

 

插入接口实现类

public class HelloWroldCode implements Insert {

    @Override
    public void insertCode() {
        // TODO Auto-generated method stub
        System.out.println("Hello World!");
    }

}

 

测试

public class Test {
    public static void main(String[] args) {
        insertCode(new HelloWroldCode());
    }
    
    
    public static void insertCode(Insert insertCode) {
        System.out.println("start");
        insertCode.insertCode();//此处插入一段代码
        System.out.println("end");
    }
}

需要变换插入代码，只需要将insertCode方法的参数修改即可，针对不同的代码都封装成一个类。

插入的那段代码可以看做是策略，策略可以是不同的代码，算法等。

策略模式需要策略对象，就是上述的Insert的实现类。

 

 

下面看下一个加减的例子，加减可以看做是两种策略。

我们把加减抽取出来，形成两种策略。

策略接口

public interface Strategy {
    public int doOperation(int num1, int num2);
}

 

加操作

public class OperationAdd implements Strategy{

    @Override
    public int doOperation(int num1, int num2) {
        // TODO Auto-generated method stub
        return num1 + num2;
    }

}

 

减操作

public class OperationSubstract implements Strategy{

    @Override
    public int doOperation(int num1, int num2) {
        // TODO Auto-generated method stub
        return num1 - num2;
    }

}

 

使用策略的Context类，根据策略的不同会执行不同的操作。

public class Context {
    private Strategy strategy;//策略对象决定最后操作
    
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    
    public int doOperation(int num1, int num2) {
        return strategy.doOperation(num1, num2);//调用策略对象的doOperation方法
    }
}

 

Main

public class Main {
    public static void main(String[] args) {
        //初始化context对象，并指定策略对象为加操作
        Context context = new Context(new OperationAdd());
        System.out.println("4 + 3 = " + context.doOperation(4, 3));
        //并指定策略对象为减操作
        context = new Context(new OperationSubstract());
        System.out.println("4 - 3 = " + context.doOperation(4, 3));
    }
}

运行结果：
4 + 3 = 7
4 - 3 = 1

 

 

参考资料：

https://www.runoob.com/design-pattern/strategy-pattern.html

https://www.cnblogs.com/zuoxiaolong/p/pattern8.html

 

转载于:https://www.cnblogs.com/huang-changfan/p/11057106.html