341Lambda表达式有参数有返回值的练习(自定义接口)和342Lambda省略模式&Lambda使用前提

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

public interface Calculator {
    //定义一个计算两个int整数和的方法并返回结果
    public abstract int day01(int a,int b);

//测试
 public static void main(String[] args) {
        //调用Cacl方法，方法的参数是一个接口。可以使用匿名内部类
        Cacl(10, 20, new Calculator() {
            @Override
            public int day01(int a, int b) {
                return a+b;
            }
        });
        //使用Lambda表达式简化内部类的书写
        Cacl(120,130,(int a,int b)->{
            return a+b;
        });
    }
    public static void demo(int a, int b, Calculator c){
        int sum = c.cacl(a,b);
        System.out.println(sum);
    }

 

 

/*
    Lambda表达式有参数有返回值的练习
    需求:
        给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值
        使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算
 */
public class Demo01Calculator {
    public static void main(String[] args) {
        //调用invokeCalc方法,方法的参数是一个接口,可以使用匿名内部类
        invokeCalc(10, 50, new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a+b;
            }
        });
 
        //使用Lambda表达式简化匿名内部类的书写
        invokeCalc(100,160,(int a,int b)->{
            return a + b;
        });
 
        //优化省略Lambda
        invokeCalc(100,190,(a,b)-> 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表达式:是可推导,可以省略

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;
        });
    }
 

 

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

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

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

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

注意:

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

 public static void main(String[] args) {
        //使用Lambda方式实现多线程
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"新的线程创建了");
        }
        ).start();

        //优化省略Lambda表达式
        new Thread(()->
            System.out.println(Thread.currentThread().getName()+"新的线程创建了")).start();


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

 

使用前提

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意︰

　　1.使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。

　　　　无论是DK内置的 Runnable 、comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。

　　2.使用Lambda必须具有上下文推断。

　　　　也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

 

注意：Lambda表达式括号里面的内容其实就是本身创建实现类对象要输入的参数

public static void main(String[] args) {
    //使用Lambda方式实现多线程
new Thread(()->{
        System.out.println(Thread.currentThread().getName()+"新的线程创建了");
}
    ).start();

//优化省略Lambda表达式
new Thread(()->
        System.out.println(Thread.currentThread().getName()+"新的线程创建了")).start();

}

Lambda表达式：是可推导可省略的
凡是可以通过上下文推导出来的内容都可以省略书写
可以省略的内容：
1.（参数列表）：括号中参数列表的数据类型可以省略什么字符串  int啥的
2.（参数列表）：括号中的参数如果只有一个，呢么类型和（）都可以省略
3.{一些代码}： 如果大括号中的代码只有一行，无论是否有返回值都可以省略（{},return可以省略，分号）
  注意：3中要省略{},return可以省略，分号必须一起省略