本文共 3265 字，大约阅读时间需要 10 分钟。

函数式接口就是一个接口中只有一个方法体

1.什么是lamda表达式？ 2.什么是函数式接口？ 一个接口只包含一个方法就叫做函数式接口。

3.为什么要用lamda表达式？

4.匿名内部类： 5.正常接口实现步骤： 通常我们实现一个接口中的一个方法的步骤，1.定义一个接口中有一个方法。2.创建一个类实现这个接口，并重写该类中的方法。3，在主函数非静态函数，则创建对象通过对象名.方法名来调用该方法。不用把一个类分成3个写，因为我们只用一次，因此可以简化步骤。在类的外面十分麻烦，因此我们将其简化，加上static关键字，放到类的里面，可以写成并列main函数的静态内部类；也可以去掉static关键字，直接复制粘贴静态内部类放到main函数内部写成局部内部类 6，匿名内部类，new后直接跟的是接口，前面也用接口类型的变量名去承接接口new出的对象，后面方法体自动生成让人重写。 7。lamda表达式 like是一个接口类型的变量名，且该接口中只有一个方法，因此只需直接like为接口类型的变量名直接后跟（）-》{}，其中{}内是需要实现的代码体。

package Lamdashizi;//推导lamda表达式，是如何一步步推导出来的public class TestLamda {
       // 3.静态内部类，在外部类的基础上加一个关键字static,内部类main函数为并列关系    static class Like2 implements  Ilike{
           @Override        public void lamda() {
               System.out.println("I Like lamda2");        }    };    public static void main(String[] args) {
           //此处定义了like为Ilike接口类型的变量,通过接口类型的变量名去承接实现接口的类new出的对象        Ilike like=new Like1();        //一般类的实现方法        like.lamda();        //2，静态内部类的实现方法        like=new Like2();        like.lamda();        //3,局部内部类，就是将静态内部类的static关键字去掉，然后复制粘贴        class Like3 implements  Ilike{
               @Override            public void lamda() {
                   System.out.println("I Like lamda3");            }        };        like=new Like3();        like.lamda();        //4,匿名内部类,没有类的名称，必须借助接口或者父类,直接自己生成重写方法,且是一个语句需要分号        like=new Ilike() {
      //此处就是ILike like=new Ilike() 直接new后跟的是接口            @Override            public void lamda() {
                   System.out.println("I Like lamda4");            }        };        like.lamda();//直接接口类型的变量名来调用重写后的方法        //5,用lamda简化,此处like为接口类型的变量名直接后跟（）-》{}，其中{}内是需要实现的代码体        like=()->{
     //like为接口类型的变量名            System.out.println("I like lamda5");        };        like.lamda();    }}//1.定义一个函数式接口interface Ilike{
       void lamda();}class Like1 implements  Ilike{
       @Override    public void lamda() {
           System.out.println("I Like lamda1");    }}

lamda表达式只适用于接口中只有一个方法的情况，该方法也可以有参数存在。

带参数的匿名内部类（直接借用接口new出对象，并用接口类型的变量名去承接new出的接口类型的对象）

package Lamdashizi;public class Testlamda01 {
       static class Love2 implements Ilove{
           @Override        public void Love(int a) {
               System.out.println("I love you--->"+a);        }    }    public static void main(String[] args) {
           Ilove love=new Love1() ;        //一般用三个类来实现一个接口        love.Love(1);        //通过静态内部类来实现接口        love=new Love2();        love.Love(2);        //通过局部内部类来实现接口        class Love3 implements Ilove{
               @Override            public void Love(int a) {
                   System.out.println("I love you--->"+a);            }        }        love=new Love3();        love.Love(3);        //匿名内部类        love=new Ilove() {
               @Override            public void Love(int a) {
                   System.out.println("I love you--->"+a);            }        };        love.Love(4);        //用lamda表达式来实现接口        love=(a)->{
     //参数放在括号内            System.out.println("I love you--->"+a);        };        love.Love(5);    }} interface Ilove{
    //接口隐含的是抽象关键字    void Love(int a);//抽象的接口中只能有抽象的方法，不能有方法体的实现 } class Love1 implements Ilove{
        @Override     public void Love(int a) {
            System.out.println("I love you--->"+a);     } }

简化lamda表达式，以及要注意的点

转载地址：http://rwnwi.baihongyu.com/