Java Design Pattern Strategy Pattern Example Analysis

1. Basic introduction

1) In Strategy Pattern, algorithm families (strategy groups) are defined and encapsulated separately so that they can be replaced with each other. This mode allows algorithm changes to be independent For customers who use the algorithm

2) This algorithm embodies several design principles. First, it separates changing code from unchanged code; second, it targets interface programming rather than concrete classes (definition (policy interface); third, use combination/aggregation more and inheritance less (customers use strategies through combination)

For example: for environmental energy saving, three energy saving methods are proposed: baseband board energy saving, SPC energy saving, Product energy saving, different energy saving methods, different specific processing procedures for environmental equipment

2. Traditional method

(1) Class diagram

(2) Coding implementation

1) Define an EsPolicy abstract class and define the esPolicyHandler method

public abstract class EsPolicy {
    public void esPolicyHandler() {
    }
}

2) BbEsPolicy inherits EsPolicy and overrides the esPolicyHandler method

public class BbEsPolicy extends EsPolicy {
    @Override
    public void esPolicyHandler() {
        System.out.println("===处理基带板节能策略===");
    }
}

3) SpcEsPolicy inherits EsPolicy and overrides the esPolicyHandler method

public class SpcEsPolicy extends EsPolicy {
    @Override
    public void esPolicyHandler() {
        System.out.println("===Spc节能策略处理===");
    }
}

4) ProdEsPolicy inherits EsPolicy and overrides the esPolicyHandler method

public class ProdEsPolicy extends EsPolicy {
    @Override
    public void esPolicyHandler() {
        System.out.println("===产品节能策略处理===");
    }
}

5) Test

public class EsPolicyTest {
    public static void main(String[] args) {
        EsPolicy bbEsPolicy = new BbEsPolicy();
        bbEsPolicy.esPolicyHandler();
        SpcEsPolicy spcEsPolicy = new SpcEsPolicy();
        spcEsPolicy.esPolicyHandler();
        ProdEsPolicy prodPolicy = new ProdEsPolicy();
        prodPolicy.esPolicyHandler();
    }
}

Execution results

===Processing baseband board energy-saving strategy===
===Processing Spc energy-saving strategy===
===Processing product energy-saving strategy===

problem : The traditional method is to achieve different behaviors of different subclasses through subclasses inheriting the parent class and overriding the parent class methods. Local changes to the class, especially the local changes to the super class, will affect other parts and have spillover effects

3. Adopt strategy pattern

(1) Class diagram

(2) Coding implementation

1) Define strategy interface And define abstract methods

public interface EsPolicyHandler {
    void esPolicyHandler();
}

2) BbEsPolicyHandler implements the policy interface and implements the esPolicyHandler method

public class BbEsPolicyHandler implements EsPolicyHandler {
    @Override
    public void esPolicyHandler() {
        System.out.println("===基带板节能策略处理===");
    }
}

3) SpcEsPolicyHandler implements the policy interface and implements the esPolicyHandler method

public class SpcEsPolicyHandler implements EsPolicyHandler {
    @Override
    public void esPolicyHandler() {
        System.out.println("===Spc节能策略处理===");
    }
}

4) ProdEsPolicyHandler Implement the policy interface and implement the esPolicyHandler method

public class ProdEsPolicyHandler implements EsPolicyHandler {
    @Override
    public void esPolicyHandler() {
        System.out.println("===产品节能策略处理===");
    }
}

5) Define the EsPolicy abstract class and inject EsPolicyHandler as its attribute

public abstract class EsPolicy {
    EsPolicyHandler esPolicyHandler;
    public void setEsPolicyHandler(EsPolicyHandler esPolicyHandler) {
        this.esPolicyHandler = esPolicyHandler;
    }
    public void esPolicyHandler() {
        if (null != esPolicyHandler) {
            esPolicyHandler.esPolicyHandler();
        }
    }
}

6) BbEsPolicy inherits EsPolicy and instantiates the esPolicyHandler interface attribute in the constructor

public class BbEsPolicy extends EsPolicy {
    public BbEsPolicy() {
        esPolicyHandler = new BbEsPolicyHandler();
    }
}

7) SpcEsPolicy inherits EsPolicy and instantiates the esPolicyHandler interface property in the constructor

public class SpcEsPolicy extends EsPolicy {
    public SpcEsPolicy() {
        esPolicyHandler = new SpcEsPolicyHandler();
    }
}

8) ProdEsPolicy inherits EsPolicy and instantiates the esPolicyHandler interface property in the constructor

public class ProdEsPolicy extends EsPolicy {
    public ProdEsPolicy() {
        esPolicyHandler = new ProdEsPolicyHandler();
    }
}

9) Test

public class EsPolicyTest {
    public static void main(String[] args) {
        BbEsPolicy bbEsPolicy = new BbEsPolicy();
        bbEsPolicy.esPolicyHandler();
        SpcEsPolicy spcEsPolicy = new SpcEsPolicy();
        spcEsPolicy.esPolicyHandler();
        ProdEsPolicy prodEsPolicy = new ProdEsPolicy();
        prodEsPolicy.esPolicyHandler();
    }
}

10) Execution results

===Processing baseband board energy-saving strategy===
===Spc energy-saving strategy processing===
===Product energy-saving strategy processing===

4. Precautions and details of the strategy model

1) The key to the strategy model is: analyze the changing parts and unchanged parts of the project Part

2) The core idea of ​​the strategy pattern is: use combination/aggregation more and inheritance less; use behavior class combination instead of inheritance of behavior, which is more flexible;

3) embodies "Close to modification, open to extension" principle, the client adds behavior without modifying the original code. It only needs to add a strategy (or behavior), avoiding the use of multiple transfer statements (if...else if...else)

4) Provides a way to replace the inheritance relationship: the strategy pattern encapsulates the algorithm in an independent Strategy class so that you can change it independently of its Context, making it easy to switch, easy to understand, and easy to extend

5) It should be noted that each time a strategy is added, a class will be added. If there are too many strategies, it will lead to a huge number of classes

The above is the detailed content of Java Design Pattern Strategy Pattern Example Analysis. For more information, please follow other related articles on the PHP Chinese website!