目录

为什么要使用这个表达式

总之就是为了简化我们的代码

什么叫做函数式接口

定义


记住：必须是一个接口里面只有一个抽象方法

推到出lamda表达式

必须是函数式接口 才可以使用这个表达式

最开始写代码

之前我们写代码，是先写一个接口，写一个类实现这个接口，重写里面的方法。
在主函数里面创建这个类的对象，执行里面的方法

public class TestLambda {
   
    public static void main(String[] args) {
   
        lambdaclass lambdaclass = new lambdaclass();
        lambdaclass.lambda();
    }
}


interface like{
   
    void lambda();
}

class lambdaclass implements like{
   
    @Override
    public void lambda() {
   
        System.out.println("jjjjjjjjj");
    }
}

静态内部类

现在我们直接在主函数的类里面写一个静态内部类

也就是直接在类里面再创建一个类

public class TestLambda {
   

    static class like2 implements like{
   
        @Override
        public void lambda() {
   
            System.out.println("pppppppp");
        }
    }


    public static void main(String[] args) {
   

        like2 like2 = new like2();
        like2.lambda();
    }
}


interface like{
   
    void lambda();
}

局部的内部类

我们还可以在主函数方法里面 写一个局部的内部类

public class TestLambda {
   

    public static void main(String[] args) {
   
         class like2 implements like{
   
            @Override
            public void lambda() {
   
                System.out.println("pppppppp");
            }
        }
        like2 like2 = new like2();
        like2.lambda();
    }
}


interface like{
   
    void lambda();
}

匿名内部类

匿名内部类 也就是借助接口 或者 父类

public class TestLambda {
   

    public static void main(String[] args) {
   

       like yuyu =new like(){
   
            @Override
            public void lambda() {
   
                System.out.println("与");
            }
        };

        yuyu.lambda();


    }
}


interface like{
   
    void lambda();
}

lambda

也就是对象不要了，方法名字不要了，只要方法里面的具体实现
接口 接一下这个

public class TestLambda {
   
    public static void main(String[] args) {
   
       like yuyu =()->{
   
                System.out.println("与");
        };
        yuyu.lambda();
    }
}

interface like{
   
    void lambda();
}

将参数类型简化掉

如果接口里面的方法有参数，那么我们可以简化掉参数类型

有参数类型的代码是：

public class TestLambda {
   

    public static void main(String[] args) {
   

       like yuyu =(int a) ->{
   
                System.out.println(a);
        };

        yuyu.lambda(2);


    }
}


interface like{
   
    void lambda(int a);
}

简化掉的参数类型是：

public class TestLambda {
   

    public static void main(String[] args) {
   

去掉参数里面的参数类型
       like yuyu =( a) ->{
   
                System.out.println(a);
        };

        yuyu.lambda(2);


    }
}


interface like{
   
    void lambda(int a);
}

将括号也去掉

前提是有一个参数，如果多个参数，不可以将括号去掉

public class TestLambda {
   

    public static void main(String[] args) {
   

       like yuyu = a ->{
   
                System.out.println(a);
        };

        yuyu.lambda(2);


    }
}


interface like{
   
    void lambda(int a);
}

将花括号去掉

前提是方法里面只有一句话输出

public class TestLambda {
   

    public static void main(String[] args) {
   

       like yuyu = (a,b) -> System.out.println(a+b);
        yuyu.lambda(2,5);
    }
}


interface like{
   
    void lambda(int a,int b);
}