1. 函数式编程思想

面向对象的思想:

  • 做—件事情,找一个能解决这个事情的对象,调用对象的方法完成函数式编程思想:
  • 只要能获取到想要的结果,谁去做的怎么做的都不重要,重视的是结果不重视过程

2. Lambda表达式引入

为什么要使用Lambda表达式?

  • 避免匿名内部类定义过多
  • 让代码实现相同的逻辑看起来更加简洁

函数式接口: 接口中只包含唯一一个抽象方法,那么就是函数式接口

例如:

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

Lambda是JDK8引入的新特性函数式接口是Lambda表达式的关键所在

有了函数式接口,我们就可以通过 lambda表达式来创建该接口的对象。

通常情况下,对于一个接口及实现类,我们都会这么写:

interface Lambda {
    void lambda();
}class MyLambda implements Lambda {
    @Override
    public void lambda() {
        System.out.println("学习lambda表达式...");
    }}public class LambdaLearn {
    public static void main(String[] args) {
        Lambda lb = new MyLambda();
        lb.lambda();      }}

 

学习lambda表达式…

我们需要写三个类来实现接口,用函数式编程来看待带的话就会显得很繁琐。于是,我们可以通过内部类来改进:

还好面试官还没问,赶紧把【内部类】的知识点补上

改进一:静态内部类

将MyLambda类中的代码放到LambdaLeadn中,变为静态内部类
interface Lambda {
    void lambda();
}public class LambdaLearn {
    //静态内部类
    static class MyLambda implements Lambda {
        @Override
        public void lambda() {
            System.out.println("学习lambda表达式...");
        }
    }
    
    public static void main(String[] args) {
        Lambda lb = new MyLambda();
        lb.lambda();
      }
}

 

学习lambda表达式…

然后,继续简化

改进二:成员内部类

将MyLambda变为成员内部类
interface Lambda {
    void lambda();
}public class LambdaLearn {
    public static void main(String[] args) {
        //成员内部类
        class MyLambda implements Lambda {
            @Override
            public void lambda() {
                System.out.println("学习lambda表达式...");
            }
        }
        Lambda lb = new MyLambda();
        lb.lambda();
    }
}

 

再试试,还能简化?

改进三:匿名内部类

直接通过匿名内部类来实现接口

interface Lambda {
    void lambda();
}public class LambdaLearn {
    public static void main(String[] args) {
        //成员内部类
        new Lambda() {
            @Override
            public void lambda() {
                System.out.println("学习lambda表达式...");
            }
        }.lambda();
    }
}

通过内部类的三次改进,实现同样的功能我们简化了代码。但是,如果匿名内部类定义了很多,功能实现了,但是代码读不懂了。于是,我们在此基础上引入了lambda表达式

lambda表达式推倒

interface Lambda {
    void lambda();
}public class LambdaLearn {
    public static void main(String[] args) {
        Lambda lb = () -> {            System.out.println("学习lambda表达式...");
        };        lb.lambda();    }}

语义分析

  • 前面的一对小括号即lambda方法的参数(无),代表不需要任何条件;
  • 中间的一个箭头->代表将前面的参数传递给后面的代码;
  • 后面{}中的代码为重写接口中抽象方法的方法体

那,lambda还能不能再简化了?

3. lambda表达式简化

简化参数类型

定义一个有参的lambda表达式来简化

interface Lambda {
    void lambda(String str);
}public class Simplify {
    public static void main(String[] args) {
        Lambda lb = (String str) -> {            System.out.println(str);
        };        lb.lambda("lambda表达式");
    }}
  • 简化参数类型
  • 简化括号
  • 简化代码块{ }

 

如果是多个参数则不能简化

 

Lambda表达式实现Runnable接口

public class LThread {
    public static void main(String[] args) {
        //使用匿名内部类实现多线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程" + Thread.currentThread().getName() + "创建了");
            }
        }).start();
        //lambda实现多线程
        new Thread(()-> {
                System.out.println("线程" + Thread.currentThread().getName() + "创建了");
            }
        ).start();
    }
}

 

线程Thread-0创建了

线程Thread-1创建了

原文链接:https://blog.csdn.net/weixin_43232955/article/details/106385986