Java8中引入的“新功能”，用起来确实很方便，它的关键是
**

  1. 允许将“方法”作为参数来进行传递
  2. “方法”的定义分成两部分

**
紧抓这两个点，就能很好的使用Lambda表达式了

演变

在程序编写过程中，我们总会 多态 这种情况，比如：

  1. public class LearnLambdaNormal {
  3.     // 动物
  4.     interface Animal {
  5.         void eat(String food);
  6.     }
  8.     public static void main(String[] args) {
  10.         // 猫
  11.         Animal cat = new Animal() {
  12.             public void eat(String food) {
  13.                 System.out.println(String.format("猫要吃：%s", food));
  14.             }
  15.         };
  17.         // 狗
  18.         Animal dog = new Animal() {
  19.             public void eat(String food) {
  20.                 System.out.println(String.format("狗要吃: %s", food));
  21.             }
  22.         };
  24.         // 人
  25.         class Person {
  26.             public void feed(Animal animal, String food) {
  27.                 animal.eat(food);
  28.             }
  29.         }
  31.         Person person = new Person();
  33.         // 喂小动物
  34.         person.feed(cat, "鱼干");
  35.         person.feed(dog, "骨头");
  36.     }
  37. }

在 34、35 行，我们最终的目的，其实是想要执行一个方法而已，但我们却额外的定义了一个接口 Animal 和两个类 cat 、 dog ，而 Animal 接口就一个方法，只是方法的内部实现不一样而已，那能不能提供一种机制，让我们

传递要执行的方法 呢？

这时候就需要用到 Lambda表达式了，如果用 Lambda表达式改写上面的代码，就简化成了

  1. public class LearnLambdaExpress {
  3.     public static void main(String[] args) {
  4.         // 人
  5.         class Person {
  6.             public void feed(Consumer<String> animal, String food) {
  7.                 animal.accept(food);
  8.             }
  9.         }
  11.         Person person = new Person();
  13.         // 喂小动物
  14.         person.feed(x -> System.out.println(String.format("猫吃: %s", x)), "鱼干");
  15.         person.feed(x -> System.out.println(String.format("够吃: %s", x)), "骨头");
  16.     }
  17. }

在第 14 、 15 行，直接实现了我们的目的，执行不同的方法，是不是简单很多

抽象

Java8提供的抽象

定义自己的抽象

特点

限制

不可变

并行