lambda对构造方法的引用，使用已定义方法（方法的归属者：：方法名）、lambda表达式

lambda：

lambda表达式：简化匿名类实现接口中的方法
使用的时候必须是函数式接口（函数式接口：接口中只能有一个抽象方法）
检查函数式接口的注解：@FunctionalInterface
格式：()->{}
简化：

() -> {}
   ()表示形参列表 
    ->符号 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));

省略方法的参数列表的数据类型；如果一个参数，（）可以省略；{}如果只有一条语句，可以省略，return也可以省略；
引用已实现的方法：
如果实现的方法的参数列表，返回类型和接口相同；
方法的归属者：：方法名（如果方法是静态方法使用类名，是列方法使用对象名）
引用构造方法：
类名：：new

lambda表达式——无参数

package cn_tedu_demo;

interface IA{
	//在控制台上打印输出hello
	void test();
}

public class Demo {
	public static void main(String[] args) {
		IA a =new IA(){

			@Override
			public void test() {
				System.out.println("hello");
				
			}
			
		};
		//lambda表达式
		/*IA a1 =()->{
		System.out.println("hello~~~");
	};*/
		//如果方法体中只有一条语句，可以省{}
		IA a1 =()->System.out.println("hello~~~");
		a.test();
		a1.test();
	}

}

lambda表达式——练习：

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

package cn_tedu_demo;
interface Cook{
	void makeFood();
}

public class TestLambda {

	public static void main(String[] args) {
		//调用invokeCook方法，匿名类内部方法实现
		invokeCook(new Cook(){

			@Override
			public void makeFood() {
				System.out.println("吃饭啦！");
			}
		});
		//使用lambda表达式
		invokeCook(()->System.out.println("吃饭啦"));
	}
	static void f(int x){
		
	}
	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);
       } }
 

package cn_tedu_demo;
interface Calculator{
	int calc(int a,int b);
}

public class Demo01Calculator {

	public static void main(String[] args) {
		//调用invokeCalc方法。方法的参数使用匿名内部类实现
		invokeCalc(1,1,new Calculator(){
			@Override
			public int calc(int a, int b) {
				return a+b;
			}
		});
		//lambda表达式
		invokeCalc(1,2,(a,b)->a+b);

	}
	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) {
		Demo4 demo = new Demo4();
		IDemo4_1 demo1 = (x,y)->demo.test1(x, y);
		IDemo4_1 demo2 = demo::test1;
		System.out.println(demo1.f1(1, 2));
		System.out.println(demo2.f1(1, 2));
		
		IDemo4_2 demo3 = (x,y)->Demo4.test2(x,y);
		IDemo4_2 demo4 = Demo4::test2;
		System.out.println(demo3.f2(1, 2));
		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;
	}

lambda对构造方法的使用

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);