java成神之路——Lamda表达式推导

Lamda表达式

• λ希腊字母表中排名第11位的字母，英文名称位Lamda。
• 使用lamda表达式避免内部内定义过多
• 其实质属于函数式编程

为什么要使用Lamda表达式

• 避免内部内定义过多
• 可以让代码看起来更加简洁
• 去掉了没有意义的代码，保留了核心的代码

学习lamda前需要明白

1. 理解Funcation Interface（函数式接口）是学习java8 lamda表达式的关键所在。
2. 函数式接口的定义
   任何接口如果只包含唯一一个抽象方法，那么它就是一个函数式接口
   public Interface Runnable{
   public abstract void run();
   }
3. 对于函数式接口，我们可以通过lamda表达式来创建该接口的对象

*** 现在我们用代码来推导Lamda公式**

1. 定义一个函数式接口

interface ILike{
    void  lambda();
}

1. 实现类

package lamda;

public class TestLamda {
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
    }
}


interface ILike{
    void  lambda();
}
class  Like implements  ILike{
    @Override
    public void lambda() {
        System.out.println("I Like Lambda");
    }
}

3. 这里使用外部类我们会觉得比较麻烦，于是我们变把外部类放入静态内部类

package lamda;

public class TestLamda {
//静态内部类
   static class  Like implements  ILike{
        @Override
        public void lambda() {
            System.out.println("I Like Lambda1");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
        Like like1 = new Like();
        like1.lambda();
    }
}


interface ILike{
    void  lambda();
}
class  Like implements  ILike{
    @Override
    public void lambda() {
        System.out.println("I Like Lambda");
    }
}

4. 这里我们使用局部内部类再一次简化

package lamda;

public class TestLamda {
   static class  Like2 implements  ILike{
        @Override
        public void lambda() {
            System.out.println("I Like Lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();
		//局部内部类
           class  Like3 implements  ILike{
            @Override
            public void lambda() {
                System.out.println("I Like Lambda3");
            }
        }
       like = new Like3();
           like.lambda();
    }
}


interface ILike{
    void  lambda();
}
class  Like implements  ILike{
    @Override
    public void lambda() {
        System.out.println("I Like Lambda1");
    }
}

5. 使用匿名内部类简化

package lamda;

public class TestLamda {
   static class  Like2 implements  ILike{
        @Override
        public void lambda() {
            System.out.println("I Like Lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();

           class  Like3 implements  ILike{
            @Override
            public void lambda() {
                System.out.println("I Like Lambda3");
            }
        }
       like = new Like3();
           like.lambda();

           //匿名内部类，没有类的名称，必须借助接口或者父类
           like = new ILike() {
               @Override
               public void lambda() {
                   System.out.println("I Like Lambda4");
               }
           };
           like.lambda();
           
           //
    }
}


interface ILike{
    void  lambda();
}
class  Like implements  ILike{
    @Override
    public void lambda() {
        System.out.println("I Like Lambda1");
    }
}

6. 现在已经没有名字了，我们又该怎样简化呢？Jdk1.8 用lambda简化

package lamda;

public class TestLamda {
   static class  Like2 implements  ILike{
        @Override
        public void lambda() {
            System.out.println("I Like Lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();

           class  Like3 implements  ILike{
            @Override
            public void lambda() {
                System.out.println("I Like Lambda3");
            }
        }
       like = new Like3();
           like.lambda();

           ~~~~//匿名内部类，没有类的名称，必须借助接口或者父类
           like = new ILike() {
               @Override
               public void lambda() {
                   System.out.println("I Like Lambda4");
               }
           };~~~~  
           
           like.lambda();
            ***//用LAmbda简化 ,去掉接口和方法，因为只有一个方法；
        like = ()->{
                System.out.println("I Like Lambda5");
        };
        like.lambda();***

    }
}


interface ILike{
    void  lambda();
}
class  Like implements  ILike{
    @Override
    public void lambda() {
        System.out.println("I Like Lambda1");
    }
}

这里再给大家举例一个带参数的简化过程，就不一步步说明了，直接把简化好的代码送上

package lamda;

public class TeatLambda2 {
    // 2 .使用静态内部类简化

   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 Love();
        love.love(2);
        love = new Love2();
        love.love(3);
        // 3. 使用局部内部类简化
         class Love3 implements  Ilove{
            @Override
            public void love(int a) {
                System.out.println("I Love YOu"+a);
            }
        }
        love = new Love3();
         love.love(4);
         // 4. 使用匿名内部类简化
         love = new Ilove() {
             @Override
             public void love(int a) {
                 System.out.println("I Love You"+a);
             }
         };
         love.love(5);
        //5. 使用lamda表示简化
         love = (int a) ->{
             System.out.println("I Love You"+a);
         };
         love.love(6);
         //简化5.1 去掉参数类型
        love = (a) ->{
            System.out.println("I Love You"+a);
        };
        love.love(7);
        //简化5.2 去掉括号
        love = a ->{
            System.out.println("I Love You"+a);
        };
        
        love.love(8);
        //简化5.3 去掉花括号
        love = a -> System.out.println("I Love You"+a);
        love.love(9);
       
}
}

interface  Ilove{
    void love(int a);
}
// 1.使用外部类
class Love implements  Ilove{
    @Override
    public void love(int a) {
        System.out.println("I Love YOu"+a);
    }
}

总结

        * lamda表达式只有一行代码的情况才能简化成一行，如果有多行那么用代码块包裹
        *  前提是接口为函数式接口
       * 多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号