Java JDK1.8 核心特性详解------行为参数化

红太狼 2022-03-22 10:08 219阅读 0赞

行为参数化是一个很重要的概念。它代表着我们可以事先准备好可以实现不同功能的代码块，当需要时，将这个代码块作为参数传递给某个方法。通过行为参数化可以帮助我们应对需求不断变化的代码。下面将会通过很多代码解释行为参数化。

--------------------

# **将代码作为参数传递** #

例如，你要实现一个在很多人中筛选符合条件的功能。这些人都具有名字（name），年龄（age），性别（sex ）这三个属性。当要求按性别筛选人时，你可能会这么实现这个功能：

public List<People> filterPeople(List<People> peopleList,String sex) {
    
            List<People> result = new ArrayList<>();
            for (People people : peopleList) {
                if (people.getSex().equals(sex)) {
                    result.add(people);
                }
            }
            return result;
        }

当需求变化时，要求筛选大于指定年龄的人，于是，你又实现了一个新功能：

public List<People> filterPeople(List<People> peopleList, Integer age) {
    
            List<People> result = new ArrayList<>();
            for (People people : peopleList) {
                if (people.getAge() >= age) {
                    result.add(people);
                }
            }
            return result;
        }

但事情没有结束，如果需求一个同时筛选性别和年龄的方法，你可能要再添加一个新的方法：

public List<People> filterPeople(List<People> peopleList, Integer age, String sex) {
    
            List<People> result = new ArrayList<>();
            for (People people : peopleList) {
                if (people.getAge() >= age && people.getSex().equals(sex)) {
                    result.add(people);
                }
            }
            return result;
        }

这看起来好像很不错，但是又觉得很麻烦，因为你复制了很多重复的代码。这个时候，部分有经验的工程师可能会想到使用“策略设计模式”来应对需求不断变化的功能。定义一个接口，对筛选标准建模。

/**
     * 筛选标准建模
     */
    public interface FilterPeople {
    
        boolean test(People people);
    }

通过实现这个接口，将不同的策略传给筛选方法，达到根据不同要求筛选人的要求。

/**
         * 根据不同策略筛选人功能
         * @param peopleList 被筛选的人
         * @param filterPeople 筛选策略
         * @return 筛选结果
         */  
        public List<People> filterPeople(List<People> peopleList, FilterPeople filterPeople) {
    
            List<People> result = new ArrayList<>();
            for (People people : peopleList) {
                if (filterPeople.test(people)) {
                    result.add(people);
                }
            }
            return result;
        }

当要求筛选性别为男性时：

public class FilterPeopleBySex implements FilterPeople {
    
        @Override
        public boolean test(People people) {
    
            return "男".equals(people.getName());
        }
    }

当要求筛选年龄大于20时：

public class FilterPeopleByAge implements FilterPeople {
        
        @Override
        public boolean test(People people) {
            return people.getAge() >= 20;
        }
    }

在需要的地方调用筛选方法：

//查询男性
            List<People> man = filterPeople(peopleList, new FilterPeopleBySex());
            //查询大于20岁的人
            List<People> result = filterPeople(peopleList, new FilterPeopleByAge());

正如我们前面展示的，行为参数化能让我们把迭代的代码和不需要迭代的代码分开。这样我们可以重复使用同一个方法，然后给他不同的行为来达到不同的目的。跟之前的代码相比，现在只需要改变传入的策略就可以实现不同的功能。现在，filterPeople方法的功能取决于FilterPeople对象传递的代码（test方法中的代码）。换句话说，你把filterPeople方法的行为参数化了。但是，每次更换策略都要创建新的FilterPeople实现类，这真的很麻烦。我们需要改进一下上面的代码。我们想到可以使用匿名类，这样就可以不用创建新的类。

//查询大于20岁的人
            List<People> result = filterPeople(peopleList, new FilterPeople() {
    
                @Override
                public boolean test(People people) {
                    return people.getAge() >= 20;
                }
            });
    
            //查询男性
            List<People> man = filterPeople(peopleList, new FilterPeople() {
    
                @Override
                public boolean test(People people) {
                    return "男".equals(people.getName());
                }
            });

//查询男性
    List<People> man = filterPeople(peopleList, (People people)-> "男".equals(people.getName()));
    //查询大于20岁的人
    List<People> result = filterPeople(peopleList, (People people)-> people.getAge() >= 20);

Java API中很多方法都可以使用行为参数化，这些方法往往和匿名类一起使用，下面使用Comparator和Runnable进行演示。

例如对集合进行排序，在Java8 中，List自带了一个sort方法，通过传入不同的Comparator的实现来完成不通的排序：

//通过年龄排序
    peopleList.sort(new Comparator<People>() {
         @Override
         public int compare(People p1, People p2) {
             return p1.getAge().compareTo(p2.getAge());
         }
    });    
    
    //通过名称排序
    peopleList.sort(new Comparator<People>() {
         @Override
         public int compare(People p1, People p2) {
             return p1.getName().compareTo(p2.getName());
         }
    });

这样子我们就可以简洁的根据需求编写排序代码。

对于Runnable，我们可以通过实现不同的run方法，执行不同的行为：

//创建一个打印1的线程
            
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(1);
                }
            });

这样就不需要创建新的类，但是发现还是有一些重复的代码。而且你是通过传入不同FilterPeople对象来实实现，这有点类似于内联“代码传递”。在JDK1.8中，加入了Lambda表达式，可以将上面的代码简化为下面代码，这个跟前面的代码是完全等效的：

//查询男性
            List<People> man = filterPeople(peopleList, new FilterPeopleBySex());
            //查询大于20岁的人
            List<People> result = filterPeople(peopleList, new FilterPeopleByAge());
            //按年龄排序
            peopleList.sort((p1, p2) -> p1.getAge().compareTo(p2.getAge()));
            //按姓名排序
            peopleList.sort((p1, p2) -> p1.getName().compareTo(p2.getName()));
            //创建线程
            Thread thread = new Thread(() -> System.out.println(1));

你会发现代码一下子就简洁了很多。现在只提出Lambda表达式，将会在下一篇详细的介绍Lambda的使用方法。

--------------------

更多与JDK1.8相关的文章请看：[Java JDK1.8 核心特性详解----(总目录篇)][Java JDK1.8 _----]

[Java JDK1.8 _----]: https://blog.csdn.net/chenzz2560/article/details/86671293