设计模式之策略模式

什么是【策略模式】

• 【策略模式】，是面向对象编程中利用多态特性抽象出来的一种行为型的设计模式 在 【策略模式】中，我们可以整体的替换算法的实现部分
  能够整体的替换算法，能够让我们轻松的以不同的算法解决同一个问题 下面通过实际的例子来看看策略模式的设计方式给代码带来的强大优势
• 【策略模式】案例

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);
    }
    }