Java中Lambda表达式的进化之路详解

public class tt1 {
    public static void main(String[] args) {
        //用外部类来实现接口，首先需要在主类外定义另外一个类，之后再在内部类中创建对象
        //这样对于那些只需要使用一次的接口来说比较的麻烦，而且也会使整个代码变得臃肿，给其他开发人员带来阅读困难
        lover l1 = new lover();
        l1.love();
    }
}
//定义接口
interface ILove {
    void love();
}
//外部实现类
class lover implements ILove{
    @Override
    public void love() {
        System.out.println("I love you my lover ---> 1");
    }
}

public class tt1 {
    //静态内部类
    static class lover2 implements ILove{
        @Override
        public void love() {
            System.out.println("I love you my lover ---> 2");
        }
    }
    public static void main(String[] args) {
        //用外部类来实现接口，首先需要在主类外定义另外一个类，之后再在内部类中创建对象
        //这样对于那些只需要使用一次的接口来说比较的麻烦，而且也会使整个代码变得臃肿，给其他开发人员带来阅读困难
        ILove l1 = new lover1();
        l1.love();
        //使用静态内部类来实现，由于实现类和main方法位于相同主类中，方便了开发人员阅读，但是实现过程还是比较麻烦
        ILove l2 = new lover2();
        l2.love();
    }
}
//定义一个函数式接口
interface ILove {
    void love();
}
//外部实现类
class lover1 implements ILove{
    @Override
    public void love() {
        System.out.println("I love you my lover ---> 1");
    }
}

public class tt1 {
    //静态内部类
    static class lover2 implements ILove{
        @Override
        public void love() {
            System.out.println("I love you my lover ---> 2");
        }
    }
    public static void main(String[] args) {
        //用外部类来实现接口，首先需要在主类外定义另外一个类，之后再在内部类中创建对象
        //这样对于那些只需要使用一次的接口来说比较的麻烦，而且也会使整个代码变得臃肿，给其他开发人员带来阅读困难
        ILove l1 = new lover1();
        l1.love();
        //使用静态内部类来实现，由于实现类和main方法位于相同主类中，方便了开发人员阅读，但是实现过程还是比较麻烦
        ILove l2 = new lover2();
        l2.love();
        //局部内部类
        class lover3 implements ILove{
            @Override
            public void love() {
                System.out.println("I love you my lover ---> 3");
            }
        }
        ILove l3 = new lover3();
        l3.love();
    }
}
//定义一个函数式接口
interface ILove {
    void love();
}
//外部实现类
class lover1 implements ILove{
    @Override
    public void love() {
        System.out.println("I love you my lover ---> 1");
    }
}

public class tt1 {
    //静态内部类
    static class lover2 implements ILove{
        @Override
        public void love() {
            System.out.println("I love you my lover ---> 2");
        }
    }
    public static void main(String[] args) {
        //用外部类来实现接口，首先需要在主类外定义另外一个类，之后再在内部类中创建对象
        //这样对于那些只需要使用一次的接口来说比较的麻烦，而且也会使整个代码变得臃肿，给其他开发人员带来阅读困难
        ILove l1 = new lover1();
        l1.love();
        //使用静态内部类来实现，由于实现类和main方法位于相同主类中，方便了开发人员阅读，但是实现过程还是比较麻烦
        ILove l2 = new lover2();
        l2.love();
        //局部内部类
        class lover3 implements ILove{
            @Override
            public void love() {
                System.out.println("I love you my lover ---> 3");
            }
        }
        ILove l3 = new lover3();
        l3.love();
        //使用内部匿名类
        ILove l4 = new ILove() {
            @Override
            public void love() {
                System.out.println("I love you my lover ---> 4");
            }
        };
    }
}
//定义一个函数式接口
interface ILove {
    void love();
}
//外部实现类
class lover1 implements ILove{
    @Override
    public void love() {
        System.out.println("I love you my lover ---> 1");
    }
}

public class tt1 {
    //静态内部类
    static class lover2 implements ILove{
        @Override
        public void love() {
            System.out.println("I love you my lover ---> 2");
        }
    }
    public static void main(String[] args) {
        //用外部类来实现接口，首先需要在主类外定义另外一个类，之后再在内部类中创建对象
        //这样对于那些只需要使用一次的接口来说比较的麻烦，而且也会使整个代码变得臃肿，给其他开发人员带来阅读困难
        ILove l1 = new lover1();
        l1.love();
        //使用静态内部类来实现，由于实现类和main方法位于相同主类中，方便了开发人员阅读，但是实现过程还是比较麻烦
        ILove l2 = new lover2();
        l2.love();
        //局部内部类
        class lover3 implements ILove{
            @Override
            public void love() {
                System.out.println("I love you my lover ---> 3");
            }
        }
        ILove l3 = new lover3();
        l3.love();
        //使用内部匿名类
        ILove l4 = new ILove() {
            @Override
            public void love() {
                System.out.println("I love you my lover ---> 4");
            }
        };
        l4.love();
        //使用Lambda表达式实现接口
        ILove l5 = () ->{
            System.out.println("I love you my lover ---> 5");
        };
        l5.love();
    }
}
//定义一个函数式接口
interface ILove {
    void love();
}
//外部实现类
class lover1 implements ILove{
    @Override
    public void love() {
        System.out.println("I love you my lover ---> 1");
    }
}