文章目录
lambda 概述
函数式编程思想
面向对象思想在乎的是,一切的动作通过对象的形式去完成
而函数式编程思想,更在乎做什么,而不是通过什么形式去做
demo: 简单的应用 - 使用lambda实现线程
定义一个MyThread类 - 继承Thread类
/**
* @Classname : MyThread
* @Description : TODO
* @Author : lin_refuel@qq.com
*/
public class MyThread extends Thread{
// 重写run方法
@Override
public void run() {
System.out.println("通过继承Thread类实现线程");
}
}
定义一个MyRunable的接口作为Runnable接口的实现类
/**
* @Classname : MyRunnable
* @Description : TODO
* @Author : lin_refuel@qq.com
*/
public class MyRunnable implements Runnable {
@Override
//重新run方法
public void run() {
System.out.println("通过Runnable接口方式实现线程");
}
}
demo01测试类
/**
* @Classname : demo01
* @Description : TODO Lambda - 简单应用
* @Author : lin_refuel@qq.com
*/
public class demo01 {
public static void main(String[] args) {
// 实现线程的几种方式
// 1. 通过继承Thread类实现线程
MyThread mt = new MyThread();
mt.start();
// 通过Runnable接口方式实现线程
MyRunnable myRunnable = new MyRunnable();
new Thread(myRunnable).start();
// 通过匿名内部类实现线程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类实现多线程");
}
}).start();
// TODO*****************************************
// 通过Lambda方式实现线程
// 直接告诉线程需要做那些事情
new Thread(()->{
System.out.println("通过Lambda方式实现多线程");
}).start();
}
}
运行结果:
lambda的演变过程
lambda 表达式的基本格式
-
啦么大 表达式使用的前提
-
有一个接口
-
并且接口中有且仅有一个抽象方法
-
==========================================
-
()
:形参列表 - 要实现的接口中唯一的抽象方法所对应的形参列表 -
->
:要做的事情 - 固定格式 -
{}
:方法体 - 被重写的方法体的固定格式
案例:调用接口里面的方法几种方式
demo:
定义一个名字为eat的接口
package com.itxs.demo02;
/**
* @Classname : eat
* @Description : TODO 吃 - 接口
* @Author : lin_refuel@qq.com
*/
public interface eat {
// 吃的抽象方法, food:吃的食物
void eats(String food);
}
创建一个eat接口的实现类eatTest
package com.itxs.demo02;
/**
* @Classname : eatTest
* @Description : TODO
* @Author : lin_refuel@qq.com
*/
public class eatTest implements eat{
// 对接口eat里面的抽象方法eats进行重写
@Override
public void eats(String food) {
System.out.println("我中午想吃" + food);
}
}
测试类demo01
package com.itxs.demo02;
/**
* @Classname : demo01
* @Description : TODO 测试类
* @Author : lin_refuel@qq.com
*/
public class demo01 {
public static void main(String[] args) {
// 第一种方式:接口存储实现类的方式
eats(new eatTest());
// 第二种方式:匿名内部类的方式进行调用
eats(new eat() {
@Override
public void eats(String food) {
System.out.println("小肆中午想吃" + food);
}
});
// 第三种lambda方式
eats((String food)->{
System.out.println("哥们中午吃啥?吃"+food);
});
System.out.println("================================");
// 第四种方式,lambda的实现过程
eat s = (String food)->{
System.out.println("哥们中午吃啥?吃"+food);
};
s.eats("烤鸡");
}
/**
* 接口测试方法,调用接口里面的抽象放法eats
* @param e 不同方式创建的eat类型的空间
*/
private static void eats(eat e){
e.eats("烧鹅");
}
}
运行结果:
lambda省略写法
参数的类型可以省略
如果参数有且仅有一个,小括号可以省略不写
如果代码块的语句只有一条,可以省略大括号和分号(如果有 return 则 return 需要一同删掉)
案例一:抽象方法一个参数
demo:
创建一个eat接口
package com.itxs.demo03;
/**
* @Classname : eat
* @Description : TODO 吃的接口
* @Author : lin_refuel@qq.com
*/
public interface eat {
// 吃饭的抽象方法
// food:食物
void dine(String food);
}
demo01:调用上面接口,测试lambda写法
package com.itxs.demo03;
/**
* @Classname : demo01
* @Description : TODO
* @Author : lin_refuel@qq.com
*/
public class demo01 {
public static void main(String[] args) {
// 3种方式实现接口
// 通过匿名内部类方式实现
eatTest(new eat() {
@Override
public void dine(String food) {
System.out.println("小三中午吃的是" + food);
}
});
// 3. 完整的lambda
eatTest((String food)->{
System.out.println("小六中午吃的的是" + food);
});
// 4. lambda简写
eatTest(food -> System.out.println("小八中午吃的是" + food));
}
private static void eatTest(eat e){
e.dine("苹果");
}
}
运行结果:
抽象方法两个参数
创建一个名字为ADD的接口
package com.itxs.demo03;
/**
* @Classname : ADD
* @Description : TODO 计算两个数相加的接口
* @Author : lin_refuel@qq.com
*/
public interface ADD {
Integer addition(Integer a,Integer b);
}
demo02:测试类,调用上面的接口
package com.itxs.demo03;
/**
* @Classname : demo02
* @Description : TODO
* @Author : lin_refuel@qq.com
*/
public class demo02 {
public static void main(String[] args) {
// 3种方式调用接口ADD里面的方法
// 通过匿名内部类
red(new ADD() {
@Override
public Integer addition(Integer a, Integer b) {
return a + b;
}
});
//通过lambda方式进行实现
red((Integer a, Integer b) -> {
return a - b;
});
//lambda简写
//省去形参的类型 里面只有一行代码省去大括号,
red((a, b) -> a * b);
}
private static void red(ADD a) {
Integer res = a.addition(7, 8);
System.out.println("res = "+ res);
}
}
运行结果:
啦么大 使用的注意事项
-
要实现的接口中保证:有且仅有一个抽象方法 (叫做函数式接口)
-
必须有类型指向,才能确定 啦么大 对应的接口(传参 或者 多态)
啦么大 与 匿名内部类
-
内部类 - 万能,接口、抽象类、普通的类均可
-
啦么大 - 接口!只能针对于接口,其他类则不可以,而且接口中要求有且仅有一个抽象方法
-
匿名内部类在编译运行的时候会生成可见的 字节码文件(.class),啦么大 则不会