Lambda学习笔记

1.函数式编程思想：有输入得到输出的一套计算思想 即：拿数据做操作，忽略对象的复杂语法，强调做什么，而不是以什么形式去做
2.面向对象思想则是：必须通过对象的形式做操作
3.Lambda就是函数思想
  eg:  new Thread(()->{
                 System.out.println("Lambda方式:多线程方式起动了。。。。");
             }).start();
       ():形式参数：表示方法的传参为空
       ->:箭头：指向后面要做的事
       {}：代码块：方法体，要做的事， 体现函数编程思想，着重体现要做什么事
       即：（形式参数）->{代码块}
       Lanbda使用前提：有一个接口  and  接口中有且仅有一个抽象方法
4.Lambda省略模式：
  a.省略类型： useAddAble((int x,int y)->{
                     return x+y;
                 });
          -->useAddAble((x,y)->{
                     return x+y;
                 });
          注意 x , y, int 要同时省略
  b. 如果有且仅有一个参数，小括号也可能省略
     eg: useEatAbleB((String b) -> {
                    System.out.println("Lambda说今天吃" + b);
                });
         --->useEatAbleB((b) -> {
                      System.out.println("Lambda说今天吃" + b);
             });
  c.如果代码块有且仅有一条语句，{}和; 也可省略,如果有return ,return也要一起省略
    eg:  useEatAbleB(s -> System.out.println("Lambda说吃：" + s));
         useAddAble((x, y) -> x + y);
5.Lambda 和内部类的区别：
  1.Lambda:所需要对象只能是接品，而内部类可以是对象，接口，和抽象类
  2.Lambda 使用的接口里，只能用一个抽象方法，有多个就报错，但内部类可以使用接口中有多个抽象方法
  3.Lambda 编译时只产生一个.class文件，内部类编译时除本身还会多产生一个.class文件

学习code:

package ten;

import org.w3c.dom.ls.LSOutput;

/**
 * @author KuKaFei.Hai
 * @date 2020/4/17 : 14:52
 * @Email : 383232084@qq.com
 */
public class EatTestDemo {
    public static void main(String[] args) {
        //多态的方式生成对象
        EatAble eatA = new EatAbleImp();
        useEatAble(eatA);  // A
        System.out.println("----匿名内部类实现-------");
        useEatAble(new EatAble() {
            @Override
            public void eat() {
                System.out.println("一天一苹果，医生远离我2");
            }
        });
        System.out.println("--------无参测试Lambda---------");
        useEatAble(() -> {
            System.out.println("Lambda:一天一苹果，医生远离我");
        });
        System.out.println("//传参且无返回值的//");
        System.out.println("----传参的 匿名内部类---------");
        EatAbleB eatAbleB = new EatAbleBImp();
        useEatAbleB(new EatAbleB() {
            @Override
            public void eat(String s) {
                System.out.println("今天吃：" + s);
            }
        });
        System.out.println("----传参且无返回值的 Lambda测试-----");
        useEatAbleB((String b) -> {
            System.out.println("Lambda说今天吃" + b);
        });
        System.out.println("传两参数，且带返回值的/");
        // 1.通过实现addAble接口实现对象，略
        // 匿名内部类形式
        int temp = useAddAble(new addAble() {
            @Override
            public int add(int a, int b) {
                return a + b;
            }
        });
        System.out.println("匿名内部类返回：" + temp);
        System.out.println("---------有两参数，带返回值 Lambda测试----------------");
        System.out.println("Lambda返回：" + useAddAble((int x, int y) -> {
            return x + y;
        }));
        useAddAble((x, y) -> {
            return x + y;
        });
        useEatAbleB(s -> {
            System.out.println("Lambda说吃：" + s);
        });
        useEatAbleB(s -> System.out.println("Lambda说吃：" + s));
        useAddAble((x, y) -> x + y);
    }

    private static int useAddAble(addAble a) {
        return a.add(10, 20);
    }

    /**
     * 方法中要传一个参数
     *
     * @param b 传一个实现对象
     */
    private static void useEatAbleB(EatAbleB b) {
        b.eat("苹果");
    }

    /**
     * @param e 这里，EatAble 虽然是接口，但是当接口做为参数时，
     *          实际是要传要传一个EatAble的实现类  eg: A处
     */
    private static void useEatAble(EatAble e) {
        e.eat();
    }


}