Lambda表达式的有参数有返回值的练习(自定义接口)以及Lambda省略格式和使用前提

Lambda表达式的有参数有返回值的练习(自定义接口)

需求;

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

　　使用L ambda的标准格式调用invokeCalc方法，完成120和130的相加计算

/**
 * 给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
 */
public interface Calculator {
    public abstract int Calculator(int a,int b);
}

public class Demo01Calculator {
    public static void main(String[] args) {
        //调用invokeCalc方法，方法的参数是一个接口，可以使用匿名内部类
        invokeCalc(10, 20, new Calculator() {
            @Override
            public int Calculator(int a, int b) {
                return a+b;
            }
        });
        //使用Lambda表达式简化匿名内部类的书写
        invokeCalc(120,130,(int a,int b)->{
            return a+b;
        });
    }
    /**
     * 定义一个方法
     * 参数传读两个int类型的整数参数传递calculator接口
     * 方法内部调用calculator中的方法calc计算两个整数的和
     */
    public static void invokeCalc(int a,int b,Calculator c){
        int i = c.Calculator(a, b);
        System.out.println(i);
    }
}

运行结果：

 

 

 

 

 

 

 

Lambda省略格式

Lombdo表达式:是可推导,可以省略

凡是根据上下文推导出来的内容,都可以省略书写可以省略的内容:

1.(参数列表)括号中参数列表的数据类型,可以省略不写

2.(参数列表):括号中的参数如果只有一个,那么类型和()都可以省略

3.{一些代码}:如果{中的代码只有一行,无论是否有返回值,都可以省略({}, return,分号)

注意:要省略{},return,分号必须一起省略

    public static void main(String[] args) {
        //调用invokeCalc方法，方法的参数是一个接口，可以使用匿名内部类
        invokeCalc(10, 20, new Calculator() {
            @Override
            public int Calculator(int a, int b) {
                return a+b;
            }
        });
        //使用Lambda表达式简化匿名内部类的书写
        invokeCalc(120,130,(int a,int b)->{
            return a+b;
        });
        //优化省略Lambda
        invokeCalc(120,130,(a,b)->a+b);
    }
    /**
     * 定义一个方法
     * 参数传读两个int类型的整数参数传递calculator接口
     * 方法内部调用calculator中的方法calc计算两个整数的和
     */
    public static void invokeCalc(int a,int b,Calculator c){
        int i = c.Calculator(a, b);
        System.out.println(i);
    }

public class Demo01Arrays {
    public static void main(String[] args) {
        Person[] arr = {
                new Person("张三",28),
                new Person("李四",26),
                new Person("王五",20),
        };
        //对数组中的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();
        });
        //优化省略Lambda
        Arrays.sort(arr,(o1,o2)->o1.getAge()-o2.getAge());
        //遍历数组
        for (Person person : arr) {
            System.out.println(person);
        }
    }
}

public class DemoCook {
    public static void main(String[] args) {
        //调用invokeCook方法，参数是Cook接口，传递Cook接口的匿名内部类对象
        invokeCook(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭了！");
            }
        });
        //使用Lambda表达式，简化匿名内部类的书写
        invokeCook(()->{
            System.out.println("吃饭了！");
        });
        //优化省略Lambda
        invokeCook(()->System.out.println("吃饭了！"));
    }
    //定义一个接口参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
    public static void invokeCook(Cook cook){
        cook.makeFood();
    }
}

 

Lambda使用前提

1.使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
　　无论是JDK内置的Runnable 、comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
2.使用Lambda必须具有上下文推断。
　　也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。