Java Design Patterns: Detailed explanation of strategy patterns and implementation methods

1. What is the Strategy Pattern

Define a series of algorithms, encapsulate them one by one, and make them interchangeable.

In layman’s terms, there are multiple methods or strategies to achieve the same function. These methods or strategies can be extracted and encapsulated. Whichever method needs to be used, just pass in the corresponding object.

2. How to implement

1) Define a strategy interface, which defines several abstract methods.

2) Specific strategies, implement the strategy interface, and implement the methods defined in the interface.

3) Encapsulate the calling class and hold a reference to the strategy interface. When the user needs to complete a certain function, he only needs to pass the corresponding strategy object to this class and call the method.

3. Code implementation

Take file encryption and decryption as an example.

1) Strategy interface, define the strategy name

/**
 * 策略接口
 */
public interface EncodeStrategy {
    /**
     * 加密算法
     * @param file
     */
    public abstract void encryptFile(File file);
    /**
     * 解密算法
     * @param file
     * @return
     */
    public abstract String decryptFile(File file);
}

2) Specific strategy class 1

/**
 * 具体策略
 */
public class AESEncode implements EncodeStrategy {
    @Override
    public void encryptFile(File file) {
        //省略具体细节
    }
    @Override
    public String decryptFile(File file) {
        //省略具体细节
        return null;
    }
}

Specific strategy class 2

public class Base64Encode implements EncodeStrategy {
    @Override
    public void encryptFile(File file) {
        //省略具体细节
    }
    @Override
    public String decryptFile(File file) {
        //省略具体细节
        return null;
    }
}

3) Encapsulation calling class

/**
 * 封装调用类，需要用到具体策略，只需传入其对象即可
 */
public class FileEncode{
    /**
     * 策略接口的引用
     */
    EncodeStrategy strategy;
    public FileEncode(EncodeStrategy strategy){
        this.strategy = strategy;
    }
    //根据传入的具体策略对象，调用其方法
    public void encryptFile(File file) {
        strategy.encryptFile(file);
    }
    //根据传入的具体策略对象，调用其方法
    public String decryptFile(File file) {
        return strategy.decryptFile(file);
    }
}

4) Test code

public class TestStrategy {
    public static void main(String args []){
        File file = new File("d:\test.txt");
        //调用策略1 实现加密
        FileEncode fileEncode = new FileEncode(new AESEncode());
        fileEncode.encryptFile(file);
        //调用策略2 实现加密
        fileEncode = new FileEncode(new Base64Encode());
        fileEncode.encryptFile(file);
    }
}

The above is the detailed content of Java Design Patterns: Detailed explanation of strategy patterns and implementation methods. For more information, please follow other related articles on the PHP Chinese website!