```pythonimport tensorflow as tfprint(tf.version)```
```java
import interfaces.Book;
import interfaces.Car;
import interfaces.Impl.English;
import interfaces.Impl.Math;
import interfaces.People;
/**
* 匿名内部类
* 1.无需要过多的创建实现类
*/
public class AnonymousAndLambda01 {
public static void main(String[] args) {
Book b1 =new Math();
b1.read();
Book b2 =new English();
b2.read();
// 改进1
//上述比较麻烦的是，每次都要重写一个实现类来重写read方法
//使用匿名内部类比较方便,无需Math和English实现类就可以
Book b3 =new Book() {
@Override
public void read() {
System.out.println("阅读语文");
}
};
b3.read();
// 匿名内部类中的抽象方法可以有多个
People p =new People() {
@Override
public void shout() {
}
@Override
public void eat() {
}
};
// 改进2
// 使用Lambda表达式，比匿名内部类更加简洁
Book b4 = () -> {
System.out.println("Lambda表达式");
};
b4.read();
// 改进3
// 可以实现参数的类型，如果实现方法中参数只有一个，可以省略(),如果方法体中只有一条语句，可以省略return和{}
Car c1 =new Car() {
@Override
public Stringride(String name) {
return name +"摔倒了"; //只能有一条语句才能转换
}
};
c1.ride("骑自行车");
Car c2 = name -> name +"摔倒了"; //转换后的结果
}
//匿名内部类的本质
//匿名内部类的本质是在编译时生成一个Class 文件。XXXXX$1.class
//系统给我们自动创建了一个实现类，并且在调用类中生成一个lambda$main$0()方法
// private static String lambda$main$0(String name){
// return name + "摔倒了" ; //只能有一条语句才能转换
// }
// 在实现类中调用lambda$main$0(String name)方法
// XXXXX$1.class{
// public String ride(String name) {
// lambda$main$0(name);
// }
// }
// Car car = new XXXXX$1.class();
// car.ride("骑摩托");
//Lambda和匿名内部类的对比
// 1. 所需类型不一样
// 匿名内部类的类型可以是 类，抽象类，接口
// Lambda表达式需要的类型必须是接口
// 2. 抽象方法的数量不一样
// 匿名内部类所需的接口中的抽象方法的数量是随意的
// Lambda表达式所需的接口中只能有一个抽象方法
// 3. 实现原理不一样
// 匿名内部类是在编译后形成一个class
// Lambda表达式是在程序运行的时候动态生成class
}
````
