19:异常与多线程---Lambda表达式

一：函数式编程思想概述：

面向对象的思想：
做一件事情，找一个能解决这个事情的对象，调用对象的方法，完成事情。

函数式编程思想:
只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程。
在2014年3月Oracle所发布的Java8(JDK1.8）中，加入了Lambda表达式的重量级新特性。
Lambda更优写法

package Demo01.ONE;

public class Demo1 {
    public static void main(String[] args) {
        //使用匿名内部类的方式，实现多线程。
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"新线程被创建了");
            }
        }).start();

        //使用Lambda表达式，实现多线程。
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"新线程被创建了");
        }).start();
    }
}

二:Lambda标准格式:

Lambda省去面向对象的条条框框，格式由3部分组成：
.一些参数
.一个箭头
.一段代码
Lambda表达式的标准格式为:

（参数类型 参数名称） -> {代码语句}

格式说明：
.小括号内的语法与传统方法参数列表一致:无参数则流空；多个参数则用逗号分隔。
.-.>是新引入的语法格式，代表执行动作。。
.大括号内的语法与传统方法要求基本一致。

三：Lambda表达式的无参数无返回值的

题目：
给定一个厨子cook接口，内含唯一的抽象方法makeFood，且无参数，无返回值，如下：

public interface cook{
	void makeFood();
}

在下面的代码下，请使用Lambda的标准格式调用invokeCook方法，打印输出“吃饭啦1”字样；

public class Demo05InvokeCook{
	public static void main(String[] args){
		//TODO  请在此使用Lambda。[标准格式】调用invokeCook方法
    }
    private static void invokeCook(Cook cook){
    	cook.makeFood()
    }
}

解答：
Cook接口

package Demo01.ONE;
/*
    定义一个厨子Cook接口，内含唯一的抽象方法makeFood
*/
public interface Cook {
    //定义无参数无返回值的方法makeFood
    public abstract void makeFood();
}

Demo01Cook类

package Demo01.ONE;
/*
    在下面的代码下，请使用Lambda的标准格式调用invokeCook方法，打印输出“吃饭啦1”字样；
*/
public class Demo01Cook {
    public static void main(String[] args) {
        //调用incokeCook方法，参数是Cook接口，传递Cook接口的匿名内部类对象。、
        invokeCook(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭了");
            }
        });
        //使用Lambda表达式，简化匿名内部类的书写
        invokeCook(() ->{
            System.out.println("吃饭了");
        });
    }
    //定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
    public static void invokeCook(Cook ccok){
        ccok.makeFood();
    }
}

四:Lambda表达式有参数有返回值的

需求：
	使用数组存储多个Person对象
	对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序

package Demo2;

import java.util.Arrays;
import java.util.Comparator;

/*
    Lambda表达式有参数有返回值的练习：
    需求:
        使用数组存储多个Person对象
        对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序
*/
public class Demo01Arrays {
    public static void main(String[] args) {
        //使用数组存储多个Person对象
        Person[] arr={
          new Person("一",2),
          new Person("二",3),
          new Person("三",4)
        };

        // 对数组中的Person对象使用Arrays的sort方法通过年龄进行升序{前面-后面)排序
      /*  Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });*/

      //使用Lambda表达式，简化匿名内部类
        Arrays.sort(arr,(Person o1,Person o2) ->{
            return o1.getAge()-o2.getAge();
        });

        //遍历数组
        for (Person p:arr){
            System.out.println(p);
        }

    }
}

五:练习:使用Lambda标准格式(有参数有返回值)

给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值。

public interface Calculator{
	int calc(int a,int b);
}

在下面的代码中，请使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算

public class Demo08IncokeCalc{
	public static void main(String[] args){
	//TODO 请在此使用Lambda[标准格式]调用invokeCalc方法计算120+130的结果
	}
	private static void invokeCalc(int a,int b,Calculator calcuator){
	int result =calculator.calc(a,b);
	System.out.println("结果是:"+result);
}

解答：

package Demo2;

import java.util.Calendar;

/*
    Lambda表达式有参数有返回值的练习
    需求:
        给定一个计算器Calculator接口，内含抽象方法calc将两个int数字相加得到和
        使用Lambda的标准格式调用invokeCalc方法，完成120和130相加计算。
*/
public class Demo01Calculator {
    public static void main(String[] args) {
        //调用invokeCalc方法，方法的参数是一个接口，可以使用匿名内部类
        invokeCalc(10, 20, new Calculator(){
            @Override
            public int calc(int a,int b){
                return a+b;
            }
        });
        //使用Lambda表达式简化匿名内部类的书写
        invokeCalc(10, 20,(int a,int b) ->{
            return  a+b;
        });
    }
    /*
        定义一个方法
        参数传递两个int类型的整数
        参数传递Calculator接口
        方法内部调用Calculator中方法calc计算两个整数的和
    */
    public static void invokeCalc(int a, int b, Calculator c){
        int sum =c.calc(a,b);
        System.out.println(sum);
    }
}

六:Lambda省略格式&Lambda使用前

package Demo03;

import java.util.ArrayList;

/*
    Lambda表达式，是可以推导的，可以省略
    凡是根据上下文推导出来的内容，都可以省略书写
    可以省略的内容：
        1:(参数列表）;括号中参数列表的数据类型，可以省略不写
        2:（参数列表);括号中的参数如果只有一个，那么类型和()都可以省略
        3:(一些代码):如果()中的代码只有一行，无论是否有返回值，都可以省略（{},return,分号}
            注意：要省略{},return，分号必须一起省略，
*/
public class Demo01ArrayList {
    public static void main(String[] args) {
        //JDK1.7版主之前，创建集合对象必须把前后的泛型都写上。
        ArrayList<String> list01 =new ArrayList<String>();
        
        //JDK1.7版本之后，=号后边的泛型可以省略，后面的泛型可以根据前边的泛型推导出来。
        ArrayList<String> list02 = new ArrayList<>();
    }
}

七：Lambda的使用前提

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意:
1:使用Lambda必须具有接口，且要求“接口中有且仅有一个抽象方法”。
无论是JDK内置的Runnable，Compartor接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才能使用Lambda。
2:使用Lambda必须具有上下文推断。
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型,才能使用Lambda作为该接口的实例。
备注：有且仅有一个抽象方法的接口，称为“函数式接口"