JDK1.8新特性-Lambda表达式（程序员必备教程）

内部类：lambda表达式

1、内部类

2、lambda表达式

1.2.1、lambda表达式是什么？

Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，
尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。

JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。

1.2.2、接口实现的不同方式？

我们先定义两个测试接口

package interfacer;

interface A {
    public abstract int test(int num1,int num2);
}
interface B {
    public void test(int a);
}

传统的实现接口的方式：

package interfacer;

public class Test implements A{
    @Override
    public int test(int num1, int num2) {
        return 0;
    }
}

用lambda表达式实现接口的方式

（）-> {   //代码块;  }

优点：大幅降低代码量，简单易懂，同时实现一个接口，可以使用实现类，匿名内部类，lambda表达式，复杂程度也越来越低

1.2.3、lambda表达式对接口的要求

并不是所有的接口都用lambda表达式实现的
lambda表达式本质就是一个匿名函数，使用lambda表达式的接口中，必须有且仅有一个方法的实现类必须实现的
即是函数式接口（即只有一个方法实现的接口）

函数式接口：如果一个接口中，有且只有一个方法，是实现类不需要在实现类中重写实现的，这种接口叫函数式接口

1.2.4、lambda表达式的基本语法

在lambda表达式中，没有方法的名字，在写lambda表达式的时候，只需要关注参数和方法体两个部分（核心部分）

接口：

package interfacer;

interface A {
    public abstract int test(int num1,int num2);
}
interface B {
    public void test();
}

实现类：

package interfacer;

import interfacer.A;

public class Impl {
    public static void main(String[] args) {
        //无参，无返回
        B lambda2 = ()->{
            System.out.println("this is my first lambda method!!!");
        };
        lambda2.test();
        //有参，有返回
        A lambda1 = (int a,int b) -> { return a + b; };
        System.out.println(lambda1.test(1,2));
    }
}

1.2.5、lambda表达式的语法进阶

所谓的语法进阶，指的更多的是语法的精简
参数精简：
1、lambda表达式的参数，可以省略类型，只写参数名即可
2、如果参数列表中，参数的数量有且仅有一个，则小括号可以省略。

package interfacer;

import interfacer.A;

public class Impl {
    public static void main(String[] args) {
        B lambda2 = a -> { //或者(a)
            System.out.println("this is my first lambda method!!!");
        };
        lambda2.test(1);
        A lambda1 = (a,b) -> { return a + b; };
        System.out.println(lambda1.test(1,2));
    }
}

方法体：

//1、如果方法体中只有一句代码，则此时大括号可以省略
B lambda2 = a ->  //或者(a)
{System.out.println("this is my first lambda method!!!");};
lambda2.test();
----->
B lambda2 = a ->  //或者(a)
        System.out.println("this is my first lambda method!!!");
lambda2.test
//2、如果方法体中唯一的一句话是返回语句，大括号在省略的同时，return也必须省略
A lambda1 = (a,b) ->{ return a + b; }; --可变为--> A lambda1 = (a,b) -> a + b;

1.2.6、lambda表达式的函数引用

//将一个接口的实现，引用到一个已经存在的方法上。此时，使用这个已经存在的方法，实现接口中的抽象方法。
package interfacer;

import interfacer.A;

public class Impl {
   	//注意事项：一定要注意引用的方法，参数和返回值类型，必须和接口中定义的一致
    public static void main(String[] args) {
        /*
        A lambda1 = (a,b) ->
        { return Impl.Mather(10,2); };
        System.out.println(lambda1.test(10,2));
    	*/
        A lambda1 = Impl::Mather;		//
        System.out.println(lambda1.test(10,2));
    }
    public static int Mather(int a,int b){
        if (a >= b){
            return a-b;
        }
        return b-a;
    }
}

（1）方法的引用：

可以引用任何的已经存在的方法，在引用的时候只需要注意方法是静态的还是非静态即可，静态方法，需要使用类引用，非静态方法需要使用对象来引用。

package interfacer;

import interfacer.A;

public class Impl {
    public static void main(String[] args) {
        
        A lambda1 = Impl::Mather;
        System.out.println(lambda1.test(10,2));
        
        B lambda2 = new Impl()::show;
        lambda2.test(1);
        
    }

     public static int Mather(int a,int b){
        if (a >= b){
            return a-b;
        }
        return b-a;
    }
    
    public void show(int i) {
        System.out.println(i*i);
    }

（2）getter，setter的引用

package interfacer;

public class Program {
    public static void main(String[] args) {
        Dog dog = new Dog("yimi","中华田园犬");
        GetName lambda = x -> x.getName();
        GetName lambda1 = Dog::getType;
        System.out.println(lambda.get(dog)+","+lambda1.get(dog));
    }
}
interface GetName{
    String get(Dog dog);
}
class Dog{
    private String name;
    private String type;

    public Dog() {
    }

    public Dog(String name, String type) {
        this.name = name;
        this.type = type;
    }

    public String getName() {
        return name;
    }

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

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}