目录：
1.面向对象的思想和函数式编程思想的概述
2.解决冗余的Runnable代码问题
3.Lambda标准格式及使用
4.对于Lambda表达式例子的解释
1.面向对象的思想和函数式编程思想的概述
面向对象的思想：找一个能解决事情的对象，然后靠调用对象的方法解决事情
函数式编程的思想：只要能获取到结果，谁做的怎么做的都不重要，只重视结果不重视过程
2.解决冗余的Runnable代码问题
1.冗余的Runnable代码问题
用Runnable创建多线程的例子：
package untl1;
public class MyLambda {
public static void main(String[] args) {
A a=new A();
Thread myThread=new Thread(a);
myThread.start();
}
}
class A implements Runnable{
public void run() {
System.out.println("我创建了一个新的线程");
}
}
正常情况下我们都会用上面代码的格式来使用Runnable接口，但是有的时候我们还可以用匿名内部类的形式来代替上边的代码：
对java内部类不是很了解的兄弟过来补补课
java内部类详解
package untl1;
public class MyLambda {
public static void main(String[] args) {
new Thread(new Runnable() {
public void run() {
System.out.println("我创建了一个多线程");
}
}).start();;
}
}
总结上边的两个例子我们可以总结以下几点：
1.Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心；
2.为了指定 run 的方法体，不得不需要 Runnable 接口的实现类；
3.为了省去定义一个 RunnableImpl 实现类的麻烦，不得不使用匿名内部类；
4.必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
5.而实际上，只有方法体才是关键所在。
2.对于以上的问题我们真的希望创建一个匿名内部类对象吗？不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做 的事情是：将 run 方法体内的代码传递给 Thread 类知晓。，lambda表达式给了我们更加简答的方式来run方法体内的代码传递给Thread知晓
我们先来感受以下lambda表达式的魅力，就以上代码我们使用Lambda表达式写试试：
package untl1;
public class MyLambda {
public static void main(String[] args) {
new Thread(()->System.out.println("我创建了一个多线程")).start();
}
}
我当时看到这么写的时候我心里在想
卧槽这是个什么**玩意
别急，咱一步一步来
3.Lambda标准格式及使用
1.Lambda表达式的使用前提:
1.使用Lambda必须具有接口，且要求接口中
有且仅有一个抽象方法
2.使用Lambda必须具有上下文推断。 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
2.Lambda的标准格式：
格式由三个部分组成:
1.一些参数
2.一个箭头
3.一段代码
标准格式:
(参数类型 参数名称) ‐> { 代码语句 }
对格式的解释说明:
小括号:接口中抽象方法的参数列表,没有参数就空着,有参数就写出参数,多个参数用逗号分隔开
箭头:传递的意思,把参数传递给方法体
大括号:重写接口的抽象方法的方法体
3.在Lambda标准格式的基础上，使用省略写法的规则为：
1.小括号内参数的类型可以省略(这就是方法的参数是Lambda对应的接口类型的意义)；
2.如果小括号内有且仅有一个参数，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号这里注意要省略三者要必须一起省略
4.对于省略写法的举例:
(1)对于无参数无返回值的就可以按照上边冗余的Runnable代码来看
(2)对于有一个参数，一个语句是return语句
比如我们写一个一个参数加上100并打印返回值的例子：
我们不用Lambda表达式可以这么写：
package untl1;
public class MyLambda {
public static void main(String[] args) {
A(10,new Add() {//这里的10就会赋值给a
public int add(int a) {
return a+100;
}
});
}
public static void A(int b,Add a)
{
System.out.println(a.add(b));
}
}
interface Add{
abstract int add(int a);
}
运行结果：
110
那么用Lambda表达式就如下：
package untl1;
public class MyLambda {
public static void main(String[] args) {
A(10, m->m+ 100);
}
public static void A(int b,Add a)
{
System.out.println(a.add(b));
}
}
interface Add{
abstract int add(int a);
}
运行结果：
110
如果运算两个参数的和并且输出结果：
正常写法：
package untl1;
public class MyLambda {
public static void main(String[] args) {
int m=2;
int n=5;
A(m, n, new Add() {
public int add(int a, int b) {
return a+b;
}
});
}
public static void A(int a,int b,Add c)
{
System.out.println(c.add(a,b));
}
}
interface Add{
abstract int add(int a,int b);
}
运算结果：
7
使用Lambda表达式：
package untl1;
public class MyLambda {
public static void main(String[] args) {
int m=3;
int n=4;
A(m, n, (x,y)->{return x+y;});
}
public static void A(int a,int b,Add c)
{
System.out.println(c.add(a,b));
}
}
interface Add{
abstract int add(int a,int b);
}
4. 对于Lambda表达式例子的解释
拿这个例子来说
package untl1;
public class MyLambda {
public static void main(String[] args) {
int m=3;
int n=4;
A(m, n, (x,y)->{return x+y;});
}
public static void A(int a,int b,Add c)
{
System.out.println(c.add(a,b));
}
}
interface Add{
abstract int add(int a,int b);
}
注意Lambda的格式,由于有两个参数所以不能省略大括号分号和参数的小括号,但是参数类型还是可以省略的,这里可能会有疑问的x,y是哪里来的卧槽连一个参数类型都没有,来来来拖出去乱棍打死,由于我们强大的Lambda所以我们的变量类型不用说明编译器自动匹配,然后这里的x,y所代表的值在A函数体的内部就会被当作m,n,因为x,y代表a和b而且m,n也代表a和b,所以x,y就代表m,n