lambda的使用

一、参数化概念：

开闭原则：对扩展开发，对修改关闭

在使用代码时，新需求可以扩展，但是不可以修改；
要满足开闭原则，就没有废代码，写出来就可以被通用，顶多是过时代码（新技术添加进去）
eg:比如计算两个数的和只需要修改两个数但是就违背了开闭原则不同的问题，有相同的部分，也有差异部分，
写一段通用的代码，将差异部分定义为参数参数代表了代码中可能变化的部分，运行时，参数接收到确切的值，保证代码的正常运行
这两个参数实际上就是占位，给代码中不能确定的占位，定义时不能确定没关系，代码运行时，代码就可以接收到确切的值，那么代码就可以征程运行。

public class Test1 {
    public static void main(String[] args) {
        A.sum();
        B.sum(1,2);
        B.sum(3,4);
    }
}


class A{
    /**
     * 比如计算两个数的和
     * 只需要修改两个数
     * 但是就违背了开闭原则
     * @return
     */
    public static int sum(){
        //return 1+2;
        return 3+4;
    }
}

class B{
    /**
     *不同的问题，有相同的部分，也有差异部分，写一段通用的代码，将差异部分定义为参数
     * 参数代表了代码中可能变化的部分，运行时，参数接收到确切的值，保证代码的正常运行
     * @param i
     * @param j
     * @return
     */
    public static int sum(int i , int j){
        return i+j;
    }
}

二、行为参数

代码中差异部分可能又是一段代码，需要使用参数标识差异部分的代码，在Java中，只能通过接口定义代码参数（行为参数）；
行为参数化：进一步提升了代码的可重用性
```java
public class Test2Student {
    public static void main(String[] args) {
        //创建学生数组
        Student [] ss = {
                new Student ("s1",18,true,99.0),
                new Student ("s2",17,true,88.0),
                new Student ("s3",16,true,77.0),
                new Student ("s4",15,true,66.0),
                new Student ("s5",14,true,55.0),
                new Student ("s6",13,true,44.0)
        };

        //filterStudent1(ss);
        filterStudent4(ss, new StudentAgePro());
        filterStudent4(ss,new StudentCorePro());
    }
    //创建函数 接受学生数组 打印年龄超过15的学生
    public static void filterStudent1 (Student[] ss){
        for (int i = 0; i < ss.length; i++) {
            if(ss[i].getAge()>15){
                System.out.println(ss[i]);
            }
        }
    }
    //创建函数 接受学生数组 打印年龄超过16的学生
    public static void filterStudent2 (Student[] ss){
        for (int i = 0; i < ss.length; i++) {
            if(ss[i].getAge()>16){
                System.out.println(ss[i]);
            }
        }
    }
    //创建函数 接受学生数组 打印年龄超过某一个值
    public static void filterStudent3 (Student[] ss,int age){
        for (int i = 0; i < ss.length; i++) {
            if(ss[i].getAge()>age){
                System.out.println(ss[i]);
            }
        }
    }

    //创建函数 接受学生数组  并且成绩超过某个值的学生
    public static void filterStudent3 (Student[] ss,double core){
        for (int i = 0; i < ss.length; i++) {
            if(ss[i].getAge()>core){
                System.out.println(ss[i]);
            }
        }
    }

    //创建函数 接受学生数组 打印年龄超过某一个值 并且成绩超过某个值的学生
    public static void filterStudent4 (Student[] ss,StudentPro studentPro){
        for (int i = 0; i < ss.length; i++) {
            if(studentPro.test(ss[i])){
                System.out.println(ss[i]);
            }
        }
    }
}



//创建接口 返回值为布尔值
interface StudentPro{
    boolean test(Student s);
}
//接口的实现类  age条件
class StudentAgePro implements StudentPro{

    @Override
    public boolean test(Student s) {
        return s.getAge()>15;
    }
}

//接口的实现类  core 条件
class StudentCorePro implements StudentPro{

    @Override
    public boolean test(Student s) {
        return s.getCore()>70;
    }
}

class Student{
    private String name;
    private int age;
    private boolean sex;
    private double core;

    public Student() {
    }

    public Student(String name, int age, boolean sex, double core) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.core = core;
    }

    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 boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    public double getCore() {
        return core;
    }

    public void setCore(double core) {
        this.core = core;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                ", core=" + core +
                '}';
    }
}

三、lambda表达式

我们以上为了传参 主要是为了传函数的实现，为了传代码，要写个接口，再创建接口的实现类，所以我们可以写匿名内部类。这个在jdk1.8之前，已经很不错了。就像以前的人说能每顿饭吃白面馒头，没有菜都能吃很多，现在呢，吃包子、饺子、山珍海味也满足不了。。。
//调用函数  第二个参数为接口  创建匿名内部类
        filterStudent4(ss, new StudentPro() {
            @Override
            public boolean test(Student s) {
                return s.getAge() > 15;
            }
        });

        filterStudent4(ss, new StudentPro() {
            @Override
            public boolean test(Student s) {
                return s.getCore() >70;
            }
        });