接口，创建三个类实现一个接口，静态内部类，局部内部类，匿名内部类，lamda表达式,各种实现接口的方式，函数式接口

函数式接口就是一个接口中只有一个方法体
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表达式，以及要注意的点