lambda表达式

lambda表达式
1.函数式接口编程：接口中只有一个抽象方法，把方法通过匿名类实现的方式
简化一个表达式的写法 lambda表达式
2.() -> {}
()表示形参列表
->符号 goes to
{}表示方法体

   //参数列表的数据类型可省,方法体有一条语句{}可以省略
   IA2 a2 = (x,y)->System.out.println(x+y);
   //如果参数列表是一个参数，()可以省略
   IA2 a2 = x->System.out.println(x);
   //如果方法体中有一条语句，return可以省略
   IA3 a = (x,y)-> x+y;		
   System.out.println(a.test(1, 2));

---

练习：

1. 给定一个厨师接口Cook，内含唯一的抽象方法makeFood，且无参数，
   无返回值.
   使用Lambda的标准格式调用invokeCook方法，打印"吃饭啦！"
   public class TestLambda {
   public static void main(String[] args) {
   //调用invokeCook方法，匿名内部类方法实现
   //使用lambda表达式
   }
   public static void invokeCook(Cook cook){
   cook.makeFood();
   }
   }

interface Cook{
	void makeFood();
}
public class TestLambda {
	public static void main(String[] args) {
		TestLambda.invokeCook(new Cook() {

			@Override
			public void makeFood() {
				// TODO Auto-generated method stub
				System.out.println("吃饭啦");
			}
		
		});
		//静态方法内可直接访问静态方法
		invokeCook(()->System.out.println("吃饭啦")
		);
	}
	public static void invokeCook(Cook cook) {
		cook.makeFood();
	}

}  

2.定义接口
public interface Calculator {
//定义一个计算两个int整数和的方法并返回结果
int calc(int a,int b);
定义测试类
public class Demo01Calculator {
public static void main(String[] args) {
//调用invokeCalc方法，方法的参数使用匿名内部类
实现
//使用Lambda表达式简化匿名内部类的书写
}
public static void invokeCalc(int a,int b,Calculator c){
int sum = c.calc(a,b);
System.out.println(sum);
}
}

public static void main(String[] args) {
		// TODO Auto-generated method stub
		invokeCalc(1,2,new Calculator() {

			@Override
			public int calc(int a, int b) {
				// TODO Auto-generated method stub
				return a+b;
			}
			
		});
		invokeCalc(1,2,( a, b)->a+b
		);

	}

---

lambda表达式使用已定义方法

方法的归属者::方法名

interface Demo4_1{
	int f1(int x,int y);
}
interface Demo4_2{
	int f2(int x,int y);
}
public class Demo4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Demo4 d=new Demo4();
		Demo4_1 demo=(x,y)->d.test1(x, y);
		System.out.println(demo.f1(1, 2));
		
		Demo4_1 demo2=d::test1;
		System.out.println(demo2.f1(1, 2));
		
		Demo4_2 demo3=Demo4::test2;
		System.out.println(demo3.f2(1, 2));
		Demo4_2 demo4=(x,y)->Demo4.test2(x, y);
		System.out.println(demo4.f2(1, 2));
	}
	 //方法的参数相同，返回类型相同
	public int test1(int x,int y) {
		return x+y;
	}
	public static int test2(int x,int y) {
		return x+y;
	}

}

3.定义接口

interface IDemo{

//控制输出System.out.println()
void showMessage(String msg);
 }
 interface IDemo2{	
//返回两数的最大值：Math.max()
int max11(int x,int y);	
 }

public class Demo8 {

public static void main(String[] args) {
	//实现接口中的方法
	//要求是::的形式实现
	IDemo demo = System.out::println;
	demo.showMessage("hello");
	IDemo2 demo2 = Math::max;
	System.out.println(demo2.max11(1,2));
}
}

---

lambda对构造方法的引用

public class Student {
	 String name;
	 int age;
	public Student() {
		System.out.println("无参");
	}
    public Student(String name,int age) {
		this.name=name;
		this.age=age;
		System.out.println(name+","+age);
		
	}

}

interface Demo5_1{
	//用无参的构造方法 创建对象，返回
	Student getStudent();
}
interface Demo5_2{
	//用带参的构造方法 创建对象，返回
	Student getStudent(String name,int age);
}

	Demo5_1 demo1 = ()-> new Student();
	Demo5_1 demo2 = Student::new;
	//demo1.getStudent();
	//demo2.getStudent();
	
	Demo5_2 demo3 = (name,age)->new Student(name,age);
	Demo5_2 demo4 = Student::new;
	demo3.getStudent("张三", 18);
	demo4.getStudent("张三", 18);