内部类和lambda表达式

如果有一个接口A，A里有eat(）抽象方法，想要调用这个抽象方法，用传统模式就要写一个实现类B并重写eat()方法，再创建B对象调用这个方法

如果用内部类可以简化代码量

先定义两个接口和一个方法

//接口A
interface A{
public void eat();
}
//接口B
interface B{

public void eat1();

public void eat2();

}
//定义方法f
public void f(A a){
a.eat();
}

用内部类调用接口A的方法

new A(){
@Override
public void eat(){
System.out.print("eat方法正在执行")
}
}.eat()
相当于创建了实现对象并调用了方法

当接口中有多个方法需要调用怎么办？

 B b = newB(){
@Override
public void eat1(){xxxx}
@Override
public void eat2(){xxxx}
};
b.eat1();
b.eat2();

以上只是为了说明什么是内部类，并不是常用的场景，用的最多的情况是把内部类当作实参，当一个方法需要抽象类或接口的对象做实参时，可以不用创建实现类并

重写抽象方法再new对象的方式传参，用内部类一步到位，可以把内部类看作是接口的实现对象，比如调用方法f

f( new A(){
@Override
public void eat(){
System.out.print("内部类常用场景")
}
}

)

 

lambda表达式：

 员工类：

public class Employee{
private int id;
private String name;
private int age;
//构造方法，get,set方法
}

public class Dem01{
//创建员工对象
private static List<Employee> emps = Arrays.asList(
new Employee(1,"员工1",15);
new Employee(2,"员工2",25);
new Employee(3,"员工3",35);
new Employee(4,"员工4",45);
);
//只有一个抽象方法的接口
interface DataPredicate<T>{
boolean test(T t);
}
//定义一个方法，方法的参数是接口实例，这样才能用内部类或lambda
public static List<Employee> filterEmployee(List<Employee> emps,DataPredicate<Employee> dataPredicate){
List<Empoyee> list = new ArrayList<>();
for(Employee emp:emps){
if(datapredicate.test(emp)){
list.add(emp);
}
}
return list;
}
public static void main(String[] args){
//找出员工年龄<=28的员工
//内部类写法：
List<Employee> listInner = filterEmployee(emps,new DataPredicat<Employee>(){
@Override
public boolean test(Employee employee){
return employee.getAge<=28
}
});
for(Employee emp:listInner){
System.out.print(emp);
}
//lambda写法
List<Employee> listLambda = filterEmployee(emps,(e)->e.getAge<=28);
//(e)->e.getAge<=28分析：这个实参位置要给一个DataPredicate接口的实例对象，这个接口又只有一个test一个抽象方法，
所以（）里的参数就是test的参数，
//所以不写e的类型也可以确定是Employee，->右边是test的方法实现。

for(Employee emp:listInner){
System.out.print(emp);
}

}
}

 用Thread类创建一个新线程并启动:

Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("aaa");
System.out.println("bbb");
}
});
t1.start();

Runnable接口只有run()一个方法,可以用lambda表达式:

Thread t1 = new Thread(() -> {
System.out.println("aaa");
System.out.println("bbb");
});