政策設計模式

文章目錄

• 什麼是政策設計模式
• 政策設計模式的作用
• 政策設計模式的實作方式
• • 實作方式一：使用接口實作類
  • 實作方式二：使用内部類
  • 實作方式三：使用Lambda表達式
• 政策設計模式實作代碼：過濾器執行個體
• • 代碼執行個體：控制台輸出

什麼是政策設計模式

建立一個能夠根據所傳遞的參數對象的不同而具有不同行為的方法，這就是政策設計模式。

這類的方法所包含要執行的算法中固定不變的部分，而政策包含變化的部分，政策就是傳遞進去的參數對象，它包含要執行的代碼。

政策設計模式的作用

在接口中常見的用法就是政策設計模式，在之指定的接口裡面編寫執行的方法，你可以用任何的對象來調用我的方法，隻要你的對象遵循我的接口，實作我的方法，增加了靈活性和複用性。

政策設計模式的實作方式

基本實作需要一個泛型接口，實體類，接口抽象方法的實作。

實作方式一：使用接口實作類

通過具體類實作接口的抽象方法，泛型參數可以用不同的實體類傳參，缺點就是多個不同接口實作需要建立多個接口實作類。

實作方式二：使用内部類

通過内部類直接實作接口的抽象方法，缺點還是存在部分備援代碼

實作方式三：使用Lambda表達式

通過Lambda表達式，簡潔優雅。

政策設計模式實作代碼：過濾器執行個體

以下代碼執行個體包含上面三種實作方式，根據員工的不同資訊進行過濾。

1.接口

/**
 * 政策模式之接口
 */

public interface StrategyInterface<T> {

    //将滿足條件的傳回true
    public boolean isReal(T t);

}

           

2.實體類

/**
 * 政策模式之實體bean
 */
public class Employee {
    private int age;
    private String name;
    private double salary;

    //無參構造器,含有有參構造器，那必須先聲明一個無參構造器，否則編譯器會報錯
    public Employee() {

    }

    //重寫toString()方法
    @Override
    public String toString() {
        return "Employee{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", salary=" + salary +
                '}';
    }
    //重寫equals()方法，用于判斷兩個對象是否相等，通過hashcode計算，是以重寫equals方法是，也必須重寫hashcode方法，
    // 為了避免hashSet\hashTable\hashMap比較時出現不可預期的結果，
    // 比如通過hashcode計算出相同的key值，在Map中。
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age &&
                Double.compare(employee.salary, salary) == 0 &&
                Objects.equals(name, employee.name);
    }

    //重寫hashCode()方法，用于散列集合的查找
    @Override
    public int hashCode() {
        return Objects.hash(age, name, salary);
    }

    //全參數構造器，主要用于初始化指派，若參數多，不建議使用這種方式
    public Employee(int age, String name, double salary) {
        this.age = age;
        this.name = name;
        this.salary = salary;
    }

    //set和get方法

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

           

3.接口實作類（實作方式一使用到）

/**
 * 政策接口的具體實作類，實作接口的抽象方法
 */
public class StrategyImpl_1 implements StrategyInterface<Employee>{

    @Override
    public boolean isReal(Employee e) {
        return e.getAge()>18;
    }
}

           

4.執行個體調用

/**
 * 政策模式之過濾執行個體
 */
public class StrategyDemo {

    public static void main(String[] args) {
        StrategyDemo strategyDemo=new StrategyDemo();
        //構造原資料
        List<Employee> listEmp= Arrays.asList(
                new Employee(18,"zhangsan",555),
                new Employee(17,"lisi",666),
                new Employee(16,"huangwu",777),
                new Employee(19,"liuliu",888)
        );
        /**
         * 使用方法一：需要建立接口對應的實作類，及實作接口的抽象方法
         */
        System.out.println("--------接口實作類方式：------------------");
        //1.1 調用接口的具體實作方法，傳入具體實作類，具體過濾作用在具體實作類

        List<Employee> listEmp_result= strategyDemo.filterEmp(listEmp,new StrategyImpl_1());
        //1.2 周遊結果
/*        for (Employee ee:listEmp_result
             ) {
            System.out.println(ee.getAge()+","+ee.getName()+","+ee.getSalary());
        }*/
        listEmp_result.forEach(System.out::println);

        /**
         * 使用方法二：使用匿名内部類實作接口，不需要建立接口的具體實作類，具體實作方法直接在内部類方法裡面實作
         *
         */
        System.out.println("--------匿名内部類方式：------------------");
        //2.1 使用匿名内部類建立接口對象，并實作接口的抽象方法，供過濾方法調用
        List<Employee> employeeList= strategyDemo.filterEmp(listEmp, new StrategyInterface<Employee>() {
            @Override
            public boolean isReal(Employee employee) {
                return employee.getSalary()<=666;//實作的過濾功能，可以自定義
            }
        });
        //2.2周遊
/*        for (Employee ee:employeeList
             ) {
            System.out.println(ee.getAge()+","+ee.getSalary()+","+ee.getName());
        }*/
        employeeList.forEach(System.out::println);
        /**
         * 使用方式三：使用Lambda表達式，去除備援代碼，精簡代碼
         *
         */
        System.out.println("------使用lamba表達式方法：-------------");
        List<Employee> list_lambda= strategyDemo.filterEmp(employeeList,(e)->e.getAge()>15);
        list_lambda.forEach(System.out::println);
/*        for (Employee ee:list_lambda
             ) {
            System.out.println(ee.getAge()+","+ee.getSalary()+","+ee.getName());
        }*/
    }

    /**
     * 政策模式之過濾器執行個體，通過接口的泛型參數作用，調用接口方法判斷是否符合要求，實作過濾的功能；
     * 使用時隻要傳入該接口的具體實作類即可
     * @param list，需要過濾的原資料
     * @param semp，過濾經過的接口，需要指定具體的泛型參數類型，調用具體的接口實作類的方法進行判斷。
     * @return
     */
    public List<Employee> filterEmp(List<Employee> list,StrategyInterface<Employee> semp){
        List<Employee> resultList=new ArrayList<>();
        for (Employee ee: list
             ) {
            if(semp.isReal(ee)){
                resultList.add(ee);
            }

        }
        return resultList;
    }
}

           

代碼執行個體：控制台輸出