文章目录
- 体验Lambda表达式
- Lambda表达式的标准格式
- Lambda表达式的练习
- 抽象方法无参无返回值
- 抽象方法带参无返回值
- 抽象方法带参带返回值
- Lambda表达式的省略模式
- Lambda表达式的注意事项
- Lambda表达式和匿名内部类的区别
体验Lambda表达式
package heima.Lambda;
import heima.多线程.other.MyRunnable;
public class FirstFeel {
public static void main(String[] args) {
//实现类的方式实现需求
// MyRunnable my = new MyRunnable();
// Thread t = new Thread(my);
// t.start();
//匿名内部类的方式改进
// new Thread(new Runnable() {
// @Override
// public void run() {
// System.out.println("多线程程序启动了");
// }
// }).start();
//Lambda表达式的方式改进
new Thread(()->{
System.out.println("多线程程序启动了");
}).start();
}
}
Lambda表达式的标准格式
Lambda表达式的练习
抽象方法无参无返回值
package heima.Lambda.表达式的练习;
public interface Eatable {
void eat();
}
package heima.Lambda.表达式的练习;
public class EatableImpl implements Eatable{
@Override
public void eat() {
System.out.println("一天一苹果,医生远离我");
}
}
package heima.Lambda.表达式的练习;
public class EatableDemo {
public static void main(String[] args) {
//在主方法中调用useEatable方法 1
Eatable e = new EatableImpl();
useEatable(e);
//匿名内部类 2
useEatable(new Eatable() {
@Override
public void eat() {
System.out.println("一天一苹果,医生远离我");
}
});
//lambda表达式 3
useEatable(()->{
System.out.println("一天一苹果,医生远离我");
});
}
private static void useEatable(Eatable e){
e.eat();
}
}
输出:
抽象方法带参无返回值
package heima.Lambda.表达式的练习.练习2;
public class FlyableDemo {
public static void main(String[] args) {
//在主方法中调用useFlyable方法
//匿名内部类
useFlyable(new Flyable() {
@Override
public void fly(String s) {
System.out.println(s);
System.out.println("飞机自驾游");
}
});
System.out.println("-------------");
//lambda
useFlyable((String s)->{
System.out.println(s);
System.out.println("飞机自驾游");
});
}
private static void useFlyable(Flyable f){
f.fly("风和日丽,晴空万里");
}
}
package heima.Lambda.表达式的练习.练习2;
public interface Flyable {
void fly(String s);
}
抽象方法带参带返回值
package heima.Lambda.表达式的练习.练习3;
public interface Addable {
int add(int x,int y);
}
package heima.Lambda.表达式的练习.练习3;
public class AddableDemo {
public static void main(String[] args) {
//在主方法中调用useAddable方法
useAddable((int x,int y)->{
return x-y;
});
}
private static void useAddable(Addable a){
int sum = a.add(10,20);
System.out.println(sum);
}
}
Lambda表达式的省略模式
package heima.Lambda.表达式的省略;
public interface Flyable {
void fly(String s);
}
package heima.Lambda.表达式的省略;
public interface Addable {
int add(int x,int y);
}
package heima.Lambda.表达式的省略;
public class LambdaDemo {
public static void main(String[] args) {
//普通表达式
useAddable((int x,int y)->{
return x+y;
});
//参数的类型可以省略
useAddable((x,y)->{
return x+y;
});
//但是有多个参数的情况下,不能只省略一个 err
// useAddable((x,int y)->{
// return x+y;
// });
useFlyable((String s)->{
System.out.println(s);
});
}
private static void useFlyable(Flyable f){
f.fly("风和日丽,晴空万里");
}
private static void useAddable(Addable a){
int sum = a.add(10,20);
System.out.println(sum);
}
}
Lambda表达式的注意事项
package heima.Lambda.表达式的注意事项;
public interface Inter {
void show();
}
package heima.Lambda.表达式的注意事项;
public class LambdaDemo {
public static void main(String[] args) {
useInter(()->{
System.out.println("好好学习,天天向上");
});
//使用Lambda必须要有接口,并且要求接口中有且仅有一个抽象方法
// useInter(()-> System.out.println("好好学习天天向上"));
//必须有上下文环境,才能推导出Lambda对应的接口
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类");
}
}).start();
// Runnable r = ()-> System.out.println("Lambda表达式");
// new Thread(r).start();
new Thread(()-> System.out.println("Lambda表达式")).start();
}
public static void useInter(Inter i){
i.show();
}
}
Lambda表达式和匿名内部类的区别
- 首先准备好三个不同的类
package heima.Lambda.Lambda表达式和匿名内部类区别;
public interface Inter {
void show();
}
package heima.Lambda.Lambda表达式和匿名内部类区别;
public class Student {
public void study(){
System.out.println("爱生活,爱java");
}
}
package heima.Lambda.Lambda表达式和匿名内部类区别;
public abstract class Animal {
public abstract void method();
}
- 初始版
package heima.Lambda.Lambda表达式和匿名内部类区别;
public class LambdaDemo {
public static void main(String[] args) {
//匿名内部类
useInter(new Inter() {
@Override
public void show() {
System.out.println("接口");
}
});
useAnimal(new Animal() {
@Override
public void method() {
System.out.println("抽象类");
}
});
useStudent(new Student(){
@Override
public void study() {
System.out.println("具体类");
}
});
System.out.println("=====================");
//Lambda
useInter(()-> System.out.println("接口"));
}
private static void useStudent(Student s){
s.study();
}
private static void useAnimal(Animal a){
a.method();
}
private static void useInter(Inter i){
i.show();
}
}
- 当接口内部有两个方法时
只有匿名内部类可以使用其中的方法
- 注:两者的构造方法不同
匿名内部类创建时,会另开一个classs文件