Java基础（26）之Lambda表达式

1. Lambda表达式

Java8新特征之Lambda表达式

1.1 函数式编程思想概述

1.2 体验Lambda表达式

代码示例：

方式一就不演示了，可以去看Java基础24

方式2：
匿名内部类的方式改进

public class LambdaDemo {
	public static void main(String[] args) {
		// 匿名内部类的方式改进
		new Thread(new Runnable() {

			@Override
			public void run() {
				System.out.println("多线程启动了！");
			}
		}).start();
	}
}

运行结果：

方式3：
Lambda表达式的方式改进

public class LambdaDemo {
	public static void main(String[] args) {
		// Lambda表达式的方式改进
		new Thread(() -> {
			System.out.println("多线程启动了！");
		}).start();
	}
}

运行结果：

1.3 Lambda表达式的标准格式

两个方式做的是相同的事情，只不过Lambda表达式更加的简洁只做了我们要做的事情。

使用该方式更加关注的是要做的事情。

1.4 Lambda表达式的练习

1.4.1 练习1（ 抽象方法无参）

代码示例：

这里采用的是Lambda表达式接口的方式，还可以使用常规的方式实现接口中的方法，也可以使用匿名内部类，但是这是三种方式Lambda表达式是最简洁的。

定义接口：

//1:定义一个接口(Eatable)，里面定义一个抽象方法: void eat();
public interface Eatable {
	void eat();
}

创建实现类：

//2:定义一一个测试类(EatableDemo),在测试类中提供两个方法
public class EatableDemo {
	// 一个方法是主方法，在主方法中调用useEatable方法
	public static void main(String[] args) {
		// 调用useEatable方法
		// 使用Lambda表达式
		useEatable(() -> {
			System.out.println("一天一苹果，医生远离我");
		});
	}

	// 一个方法是: useEatable(Eatable e)
	public static void useEatable(Eatable e) {
		e.eat();
	}
}

运行结果：

1.4.2 练习2（抽象方法有参）

代码示例：

定义接口：

//1:定义一个接口(Flyable)，里面定义一个抽象方法: void fly(String s);
public interface Flyable {
	void fly(String s);
}

创建实现类：
使用了匿名内部类和Lambda方式，两个方法。

//2:定义一个测试类(FLyableDemo)，在测试类中提供两个方法
//一个方法是: useFlyable(Flyable f)
//一个方法是主方法，在主方法中调用useFlyable方法
public class FlyableDemo {
	public static void useFlyable(Flyable f) {
		f.fly("风和日丽，晴空万里");
	}

	private static void main(String[] args) {
		// 匿名内部类
		useFlyable(new Flyable() {

			@Override
			public void fly(String s) {	//这里的s是useFlyable方法定义的
				System.out.println(s);
				System.out.println("飞机自驾游");
			}
		});
		System.out.println("-------------------");
		// Lambda表达式
		useFlyable((String s) -> {
			System.out.println(s);
			System.out.println("飞机自驾游");
		});
	}

}

1.4.3 练习3（抽象方法有参有返回值）

代码示例：

定义接口：

//1:定义一个接口(Addable)，里面定义一个抽象方法: int add(int x, int y);
public interface Addable {
	int add(int x, int y);
}

创建测试类：

//2:定义一个测试类(AddableDemo)，在测试类中提供两个方法
//	一个方法是: useAddable(Addable a)
//	一个方法是主方法，在主方法中调用useAddable方法
public class AddableDemo {

	public static void main(String[] args) {
		useAddable((int x, int y) -> {
			return x + y;
		});
	}

	private static void useAddable(Addable a) {
		int add = a.add(10, 20);
		System.out.println(add);
	}

}

运行结果：

1.5 Lambda表达式的省略模式

代码示例：

Addable接口，int类型有参有返回值

public interface Addable {
	int add(int x, int y);
}

Flyable接口，String类型有参无返回值

public interface Flyable {
	void fly(String s);
}

测试类：

public class LambdaDemo {
	public static void main(String[] args) {
		// 在这里只使用Lambda方式

		// useAddable(Addable a)方法
		// 常规方式
		useAddable((int x, int y) -> {
			return x + y;
		});
		// 参数的类型可以省略，但是有多个参数的情况下不能就省略一个
		useAddable((x, y) -> {
			return x + y;
		});
		System.out.println("----------------------");
		// useFlyable(Flyable f)方法
		// 常规方法
		useFlyable((String s) -> {
			System.out.println(s);
		});
		// 省略参数类型
		useFlyable((s) -> {
			System.out.println(s);
		});
		// 如果代码块的语句只有一条，可以省略大括号和分号
		useFlyable(s -> System.out.println(s));
		// 如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
		useAddable((x, y) -> x + y);
	}

	private static void useFlyable(Flyable f) {
		f.fly("风和日丽，晴天万里");
	}

	private static void useAddable(Addable a) {
		int i = a.add(10, 20);
		System.out.println(i);
	}
}

运行结果：
方法都可以正常运行

1.6 Lambda表达式的注意事项

public class LambdaDemo01 {
	public static void main(String[] args) {

		// 这样写是会报错的，因为没有上下文环境
//		() -> System.out.println("Lambda表达式");

		// 必须有上下文环境，才能推导出Lambda对应的接口
		// 根据局部变量的赋值得知L ambda对应的接口:
		Runnable r = () -> System.out.println("Lambda表达式");
		// 根据调用方法的参数得知L ambda对应的接口:
		new Thread(() -> System.out.println("Lambda表达式")).start();
	}
}

1.7 Lambda表达式和匿名内部类的区别