JAVA入门学习（八）—— lambda表达式

JAVA入门学习（七）——抽象类、接口、内部类详解

一、lambda表达式

在学习lambda表达式之前，最好先学习内部类，特别是匿名内部类

1.函数实接口编程：接口中只有一个抽象方法，把方法通过匿名内部类实现的方法简化成一个表达式的写法 lambda表达式
2.() -> {}
（）表示形参列表
-> 符号 goes to
{} 表示方法体 如果方法体中只有一条语句，“{}”可以省略

直接上代码！ ⬇
代码详解：

interface IA{
	//方法无返回值无参数类型测试
	//在控制台上完成打印输出的功能
	void f();
	
}

public class Test01 {

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

			@Override
			public void f() {
				// TODO Auto-generated method stub
				System.out.println("hello");
			}
			
		};
		
		IA a2 = ()->{
			System.out.println("hello 11");
		};
		//如果方法体中只有一条语句，“{}”可以省略
		//IA a2 = ()-> System.out.println("hello 11");
		
		//通过匿名内部类的方式实现
		a.f();
		//通过 lambda 表达式的方式实现
		a2.f();
	}
}

interface IA2{
	//方法有参数无返回值
	//打印输出x,y的和
	void test(int x, int y);
}

public class Test02 {

	public static void main(String[] args) {
		IA2 a = new IA2(){

			@Override
			public void test(int x, int y) {
				System.out.println(x+y);
			}

		};
		
		IA2 a2 = (int x, int y)->{
			System.out.println(x+y);
		};
		//如果方法体中只有一条语句，“{}”可以省略
		//数据类型可以省略
		//IA2 a2 = (x, y)->System.out.println(x+y);
		//如果只有一个参数，“（）”可以省略
		//IA2 a3 = x->syso(x);
		
		//通过匿名内部类
		a.test(1, 2);
		//通过 lambda 表达式 
		a2.test(1, 2);
	}
}

interface IA3{
	//方法有参数有返回值
	//返回两个数的和
	int f(int x, int y);
	
}

public class Test03 {

	public static void main(String[] args) {
		IA3 a = (int x, int y)->{
			return x+y;
		};
		//如果方法体中只有一条语句，“{}”可以省略
		//数据类型可以省略
		//如果方法体中只有一条语句,return可省略
		//IA3 a2 = (x, y)-> x+y;
		
		System.out.println(a.f(1, 2));
	}
}

---

🔺小测试：1

public class Test04 {
	
	public static void main(String[] args) {
		
		//通过匿名内部类的方式，实现调用invokeCook方法
		
		//使用lambda 表达式，实现调用invokeCook方法
	
	}
	
	public static void invokeCook(Cook cook) {
		cook.makeFood();
	}
}

interface Cook{
	void makeFood();
}

答案：
		//通过匿名内部类的方式，实现调用invokeCook方法
		Test04.invokeCook(new Cook() {
			@Override
			public void makeFood() {
				// TODO Auto-generated method stub
				System.out.println("hello");
			}
		});
	
		//使用lambda 表达式，实现调用invokeCook方法
		Test04.invokeCook(()->{
			System.out.println("hello");
		});

🔺小测试：2

interface Calculator{
	//定义一个计算两个int整数的方法并返回结果
	int calc(int x, int y);
}

public class Test05 {

	public static void main(String[] args) {
		//使用匿名内部类的方式实现
		
		//使用 lambda 表达式的方式
		
	}
	
	public static void invokerCalc(int x, int y, Calculator calculator) {
		int sum = calculator.calc(x, y);
		System.out.println(sum);
		
	}
}

答案：
		//使用匿名内部类的方式实现
		Test05.invokerCalc(2, 3, new Calculator() {
			
			@Override
			public int calc(int x, int y) {
				// TODO Auto-generated method stub
				return x+y;
			}
		});
		
		//使用 lambda 表达式的方式
		Test05.invokerCalc(2, 3, (x, y)->{return x+y;});
		
		//简化表达式
		Test05.invokerCalc(2, 3, (x, y)-> x+y);

---

如果接口中的方法，已经在测试类里面实现了（方法名可以不同，但参数列表和方法的返回值类型必须一样），那么就不必使用匿名内部类再实现一次了 使用
“ 方法的归属者：：方法名 ”的方式实现

例如：

interface A{
	int a1(int x, int y);
}
interface B{
	int b1(int x, int y);
}

public class Test06 {

	public static void main(String[] args) {
		/* 匿名内部类的方式
		A a = new A() {

			@Override
			public int a1(int x, int y) {
				// TODO Auto-generated method stub
				return 0;
			}};
		A a = (x, y)-> {
			return x;	
		};
		 */	
		Test06 test06 = new Test06();
		A a = (x , y) -> test06.test1(x, y);
		/*
			A a = (x , y) -> test06.test1(x, y);
			其实这句话可以这样写：
			A a = (x, y)-> {
				return test06.test1(x, y);
			};
			这样看的话，稍微号理解点
		*/
		System.out.println(a.a1(1, 2));
		A a1 = test06::test1;
		System.out.println(a1.a1(2, 3));
		
		B b = (x, y) -> Test06.test2(x, y);
		System.out.println(b.b1(3, 4));
		B b2 = Test06::test2;
		System.out.println(b2.b1(5, 6));
		
	}
	
	//与接口方法的参数列表相同，返回值相同
	public int test1(int x, int y) {
		return x+y;
	}
	
	public static int test2(int x, int y) {
		return x+y;
	}
}

🔺例题1：

interface E{
	//控制输出syso()
	void showMessage(String message);
}

interface F{
	//返回两个数的最大值 Math.max()
	int max(int x, int y);
}

public class Test07 {

	public static void main(String[] args) {
		//实现接口中的方法
		//要求使用 ：：的形式实现
	}
}

//实现接口中的方法
//要求使用 ：：的形式实现
		Test07 test07 = new Test07();
		//E e = i-> test07.show(i);
		E e = test07 :: show;
		e.showMessage("aaa");
		
		//F f = (x, y)-> test07.max(x, y);
		F f = test07 :: max;
		f.max(2, 4);
----------------------------------------------------------
	//在Test类里面实现接口的方法
	//（注意，不是implements， 方法名可以不同，但参数列表和返回值必须相同）
	public void show(String a) {
		System.out.println(a);
	}
	
	public int max(int x, int y) {
		if(x >= y) {
			return x;
		}
		else {
			return y;
		}
	}

使用 lambda表达式 调用构造方法：

public class Student {

	private String name;
	private String age;
	
	public Student() {
		System.out.println("aaaa");
	}
	
	public Student(String name, String age) {
		this.name = name;
		this.age = age;
		System.out.println("name:" + name + ", age:" + age);
	}
}


interface A8{
	
	//用无参的构造方法 创建对象,返回
	void getStudent();
	
}

interface B8{
	
	//用有参的构造方法 创建对象，返回
	void getStudent(String name, String age);
}

public class Test08 {

	public static void main(String[] args) {
		
		A8 a = ()->new Student();
		a.getStudent();
		A8 a2 = Student::new;
		a2.getStudent();
		
		B8 b = (name, age)->new Student(name, age);
		b.getStudent("Tao", "19");
		B8 b1 = Student::new;
		b1.getStudent("Tao", "18");
		
	}
}