Lambda表达式及练习

Lambda表达式的标准格式

匿名内部类中重写swim()方法的代码分析
	1.方法形式参数为空，说明调用方法时不需要传递参数
	2.方法返回值类型为void，说明方法执行没有结果返回
	3.方法体中的内容，是我们具体要做的事情

goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("游泳去吗");
            }
        });

Lambda表达式的代码分析
1.():里面没有内容，可以看成是方法形式参数为空
2.->：用箭头指向后面要做的事情
3.{}：包含一段代码，我们称之为代码块，可以看成是方法中的内容。
组成Lambda表达式的三要素：形式参数，箭头，代码块

goSwimming(()->{
            System.out.println("游泳啊");
        });

Lambda表达式的标准格式

Lambda表达式的格式
格式：（形式参数）->{代码块}
形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
->:由英文中画线和大于符号组成，固定写法。代表指向动作
代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

Lambda表达式练习1 无参无返回值

Lambda表达式的使用前提

有一个接口
接口中有且仅有一个抽象方法

练习1：
1.编写一个接口(ShowHandler)
2.在该接口中存在一个抽象方法（show），该方法时无参数无返回值
3.在测试类（ShowHandlerDemo)中存在一个方法(useShowHandler)，方法的参数是ShowHandler类型的，在方法内部调用了ShowHandler的show方法

package com.shengda.test2;

public class TestLambda {
    public static void main(String[] args) {
        // 匿名内部类
        useShowHandler(new ShowHandler() {
            @Override
            public void show() {
                System.out.println("我是匿名内部类的show方法");
            }
        });
        // Lambda实现
        useShowHandler(()->{
            System.out.println("我是Lambda的show方法");
        });
    }

    public static void useShowHandler (ShowHandler showHandler) {
        showHandler.show();
    }
}

interface ShowHandler{
    void show();
}

Lambda表达式2 有参无返回值

1.首先存在一个接口（StringHandler)
2.在该接口中存在一个抽象方法（print Message），该方法是有参数无返回值
3.在测试类（String Handler Demo）中存在一个方法（use String Handler），方法的参数是StringHandler类型的，在方法内部调用了StringHandler的printMessage方法

package com.shengda.test3;

public class StringHandlerDemo {
    public static void main(String[] args) {
        // 匿名内部类
        useStringHandler(new StringHandler() {
            @Override
            public void printMessage(String msg) {
                System.out.println("我是匿名内部类"+msg);
            }
        });

        // Lambda实现
        useStringHandler((String msg)->{
            System.out.println("我是Lambda表达式"+msg);
        });
    }

    public static void useStringHandler(StringHandler stringHandler){
        stringHandler.printMessage("shengda");
    }
}

interface StringHandler{
    void printMessage (String msg);
}

Lambda表达式的练习3 无参有返回值

1.首先存在一个接口（RandomNumHandler）
2.在该接口中存在一个抽象的方法（getNumber），该方法时无参数但是有返回值。
3.在测试类（RandomNuumHandlerdemo）中存在一个方法（useRandomNumHandler），方法的参数是RandomNumHandler类型的，在方法内部调用了RandomNumHandler的getNumber方法

package com.shengda.test4;

import java.util.Random;

public class RandomNumHandlerDemo {
    public static void main(String[] args) {
        // 匿名内部类
        useRandomNumHandler(new RandomNumHandler() {
            @Override
            public int getNumber() {
                Random r = new Random();
                int num = r.nextInt(10)+1;
                return num;
            }
        });

        // Lambda表达类
        useRandomNumHandler(()->{
            Random r = new Random();
            int num = r.nextInt(10)+1;
            return num;
            // 注意：如果lambda所操作的接口中的方法，有返回值，一定要通过return语句，将结果返回
            // 否则会出现编译错误
        });
    }

    public static void useRandomNumHandler(RandomNumHandler randomNumHandler){
        int result = randomNumHandler.getNumber();
        System.out.println(result);
    }
}

interface RandomNumHandler{
    int getNumber();
}

Lambda表达式的练习4

1.首先存在一个接口（Calculator）
2.在该接口中存在一个抽象方法（calc），该方法是有参数也有返回值
3.在测试类（CalculatorDemo）中存在一个方法（useCalculator），方法的参数值Calculator类型的，在方法内部调用了Calculator的calc方法。

package com.shengda.test5;

public class CalulatorDemo {
    public static void main(String[] args) {
        // 匿名函数类
        useCalculator(new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a+b;
            }
        });

        // Lambda表达式
        useCalculator((int a,int b)-> {
            return a+b;
        });
    }

    public static void useCalculator(Calculator calculator){
        int result = calculator.calc(10,20);
        System.out.println(result);
    }
}

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