从函数式接口谈Java Lambda表达式写法的产生

不念不忘少年蓝@ 2024-03-26 12:43 31阅读 0赞

#### 文章目录 ####

*   *  为什么要使用lambda表达式?
     *  函数式接口
     *  用静态内部类实现呢
     *  用局部内部类实现呢?
     *  用匿名内部类实现呢?
     *  这个时候Lambda闪亮登场, 用Lambda简化之后...
     *  如果有参数

λ希腊字母表中排序第十一位的字母，英语名称为Lambda  
避免匿名内部类定义过多  
其实质属于函数式编程的概念

![af13524c43544e41b50a8a0ff236d702.png][]

a-> System.out.println("牛啊牛啊 "+a);
    new Thread(()-> System.out.println("牛啊牛啊 ")).start();

### 为什么要使用lambda表达式? ###

◆避免匿名内部类定义过多  
◆可以让你的代码看起来很简洁  
◆去掉了一堆没有意义的代码，只留下核心的逻辑。

也许你会说，我看了Lambda表达式，不但不觉得简洁，反而觉得更乱，看不懂了。那是因为我们还没有习惯，用的多了，看习惯了，就好了。

理解Functional Interface (函数式接口)是学习Java8 lambda表达式的关键所在。

函数式接口的定义: 任何接口，如果只包含唯一一个抽象方法, 那么它就是一个函数式接口。

public interface Runnable{
        
        public abstract void run();
    }

### 函数式接口 ###

对于**函数式接口**，我们可以通过Lambda表达式来创建该接口的对象。

public class LamdaTest {
        
    
        public static void main(String[] args) {
        
            Like like = new Like();
            like.lambda();
        }
    }
    
    // 1 定义一个函数式接口
    interface ILike{
        
        void lambda();
    }
    
    // 2 实现类
    class Like implements ILike{
        
    
        @Override
        public void lambda() {
        
            System.out.println("i like lambda.");
        }
    }

### 用静态内部类实现呢 ###

public class LamdaTest {
        
        // 3 静态内部类
        static class Like implements ILike{
        
    
            @Override
            public void lambda() {
        
                System.out.println("i like lambda.");
            }
        }
    
        public static void main(String[] args) {
        
            Like like = new Like();
            like.lambda();
        }
    }
    
    // 1 定义一个函数式接口
    interface ILike{
        
        void lambda();
    }

### 用局部内部类实现呢? ###

public class LamdaTest {
        
    
        public static void main(String[] args) {
        
    
            // 4 局部内部类
            class Like implements ILike{
        
    
                @Override
                public void lambda() {
        
                    System.out.println("i like lambda.");
                }
            }
            Like like = new Like();
            like.lambda();
    
        }
    }
    
    // 1 定义一个函数式接口
    interface ILike{
        
        void lambda();
    }

### 用匿名内部类实现呢? ###

public class LamdaTest {
        
    
        public static void main(String[] args) {
        
    
            // 5 匿名内部类, 没有类的名称, 必须借助接口或者父类
            ILike like=new ILike(){
        
                @Override
                public void lambda() {
        
                    System.out.println("i like lambda.");
                }
            };
    
            like.lambda();
    
        }
    }
    
    // 1 定义一个函数式接口
    interface ILike{
        
        void lambda();
    }

### 这个时候Lambda闪亮登场, 用Lambda简化之后… ###

public class LamdaTest {
        
    
    
        public static void main(String[] args) {
        
    
            // 6 Lambda简化之后
            ILike like=() ->{
        
                System.out.println("i like lambda.");
            };
    
            like.lambda();
    
        }
    }
    
    // 1 定义一个函数式接口
    interface ILike{
        
        void lambda();
    }

### 如果有参数 ###

public class LambdaTest2 {
        
        public static void main(String[] args) {
        
            ILove love =(a) -> {
        
                System.out.println("爱你"+a+"次");
            };
            love.love(1000);
        }
    
    }
    
    interface ILove{
        
        void love(int a);
    }

[af13524c43544e41b50a8a0ff236d702.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/e99119fd8b904cdea3f783785df7c454.png