設計模式之策略模式

什麼是【策略模式】

• 【策略模式】，是面向對象編程中利用多態特性抽象出來的一種行爲型的設計模式 在 【策略模式】中，我們可以整體的替換算法的實現部分
  能夠整體的替換算法，能夠讓我們輕鬆的以不同的算法解決同一個問題 下面通過實際的例子來看看策略模式的設計方式給代碼帶來的強大優勢
• 【策略模式】案例

package java8;

/**
 * User: qi
 * Date: 2019/9/11   11:33
 */
public class Employee {

    private int id;
    private String name;
    private int age;
    private double salary;
    private int workHoursForYears;


    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public double getSalary() {
        return salary;
    }

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

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                ", workHoursForYears=" + workHoursForYears +
                '}';
    }

    public int getId() {
        return id;
    }

    public int getWorkHoursForYears() {
        return workHoursForYears;
    }

    public void setWorkHoursForYears(int workHoursForYears) {
        this.workHoursForYears = workHoursForYears;
    }

    public Employee(int id, String name, int age, double salary, int workHoursForYears) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.workHoursForYears = workHoursForYears;
    }
}

package java8;

/**
 * User: qi
 * Date: 2019/9/11   11:43
 */
public class FilterOlderThan30EmployeeStrategy implements IEmployeeStrategy {
    @Override
    public boolean test(Employee employee) {
        return employee.getAge() > 30;
    }
}

package java8;

public class FilterWorkHourLg900AndSalaryLg10kEmployeeStrategy implements IEmployeeStrategy{
    @Override
    public boolean test(Employee employee) {
        return employee.getWorkHoursForYears() < 900 && employee.getSalary() > 10000;
    }
}

package java8;

public interface IEmployeeStrategy {
    boolean test(Employee employee);
}

package java8;

import org.junit.Before;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Stream;

import static java.util.Locale.filter;

/**
 * User: qi
 * Date: 2019/9/11   11:36
 */
public class TestMain {

    private List<Employee> employees = new ArrayList<>(6);

    @Before
    public void before() {

        employees.add(new Employee(0001, "張三", 26, 6500, 822));
        employees.add(new Employee(0002, "李四", 29, 8500, 881));
        employees.add(new Employee(0003, "王五", 24, 3500, 839));
        employees.add(new Employee(0004, "趙六", 32, 11300, 803));
        employees.add(new Employee(0005, "胡七", 32, 13100, 946));
        employees.add(new Employee(0006, "劉八", 28, 7500, 866));
    } //打印列表工具方法

   private void print(List<Employee> list) {
        for (Employee employee : list) {
            System.out.println(employee);
        }
    }
  public static List<Employee> filterEmployee(List<Employee> employees, IEmployeeStrategy strategy) {
                List<Employee> result = new ArrayList<>();
                for (Employee employee : employees) {
                    if (strategy.test(employee)) {
                        result.add(employee);
                    }
        }
        return result;
    }

   @Test
    public void testStrategyMode() {
        System.out.println("篩選出小於28歲的員工：");
        print(filterEmployee(employees, new FilterOlderThan30EmployeeStrategy()));
        System.out.println("篩選工資大於10000且年平均工時小於900的員工：");
        print(filterEmployee(employees, new

                FilterWorkHourLg900AndSalaryLg10kEmployeeStrategy()));
    }
    
    //1.從該列表中篩選出年齡大於30歲的員工
    @Test
    public void test1() {
         employees.stream().filter(employee -> employee.getAge() > 30).forEach(System.out::println);
    }


    //篩選工資大於10000且年平均工時小於900的員工
    @Test
    public void tes3() {
    List<Employee> result = filterEmployee(employees, employee -> employee.getSalary() > 10000 && employee.getWorkHoursForYears() < 900);
        print(result);   
    }


    //篩選25-30歲的
    @Test
    public void test2() {

       List<Employee> result = filterEmployee(employees, employee -> employee.getAge() > 25 && employee.getAge() < 30);
        print(result);
    
    }
    //lambda表達式
//        List<Employee> result2 = filterVersion2(this.employees,
//                e -> e.getWorkHourForYear() > 900);
//
//        print(result2);
    //根據工資排序lambda寫法
    @Test
    public void  test4(){
       /* employees.sort((Employee e1, Employee e2) -> {
            return (int)(e1.getSalary() - e2.getSalary());
        });*/

       employees.sort((Employee e1,Employee e2) ->{
           return (int) (e1.getSalary()-e2.getSalary());
       });
        //print(employees);


    }

}

---

lambda表達式的簡單實用 ， 流式編程

//1.從該列表中篩選出年齡大於30歲的員工
    @Test
    public void test1() {
         employees.stream().filter(employee -> employee.getAge() > 30).forEach(System.out::println);
    }


    //篩選工資大於10000且年平均工時小於900的員工
    @Test
    public void tes3() {
      employees.stream().filter(employee -> employee.getSalary() > 10000 && employee.getWorkHoursForYears() < 900).forEach(System.out::println);

    }


    //篩選25-30歲的
    @Test
    public void test2() {
       employees.stream().filter(employee ->  employee.getAge() > 25 && employee.getAge() < 30 ).forEach(System.out::println);
    }
    }