希腊字母表中排序第十一位的字母,英语名称为Lambda
避免匿名内部类定义过多
其实质属于函数式编程的概念
(params)->expression[表达式]
(params)->statement[语句]
(params)->{statements}
为什么要使用Lambda表达式?
1.避免匿名内部类定义过多
2.可以让你的代码看起来很简洁
3.去掉了一堆没有意义的代码,只留下核心的逻辑
ctrl+shift+/为多行注释
理解Functional Interface(函数式接口)是学习Java8 lambda表达式的关键所在
函数式接口的定义:
任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口
如下所示:
public interface Runnable{
public abstract void run();
}
对于函数式接口,我们可以通过lambda表达式来创建该接口的对象。
实例一的代码如下所示:
package com.Lambda;
/*
推导lambda表达式,
*/
public class Demo1 {
//3.静态内部类
static class Like2 implements ILike {
@Override
public void lambda() {
System.out.println("I LIKE lambda2");
}
}
public static void main(String[] args) {
//用接口创建对象,父类引用子类对象,方法重载里面有提到这个
ILike like = new Like();
like.lambda();
like = new Like2();
like.lambda();
//4.局部内部类
class Like3 implements ILike {
@Override
public void lambda() {
System.out.println("I LIKE lambda3");
}
}
like = new Like3();
like.lambda();
//5.匿名内部类
like = new ILike() {
@Override
public void lambda() {
System.out.println("I LIKE lambda4");
}
};
like.lambda();
//6.用lambda简化
like = () -> {
System.out.println("I LIKE lambda5");
};
like.lambda();
}
//1.定义一个函数式接口,只有一个抽象类方法
interface ILike {
//隐式声明,自动就是抽象。
void lambda();
}
//2.实现类
static class Like implements ILike {
@Override
public void lambda() {
System.out.println("I LIKE lambda");
}
}
}
运行界面如下请所示:
我们通过更加详细的步骤去了解lambda表达式。
代码示例如下所示:
package com.Lambda;
import com.rgf.structure.O;
public class Demo2 {
public static void main(String[] args) {
Ilove love = new Love();
love.love(3);
}
//1.定义一个函数式接口,只有一个抽象类方法
interface Ilove{
//隐式声明,自动就是抽象
void love(int a);
}
//2.实现类
static class Love implements Ilove {
@Override
public void love(int a) {
System.out.println("I Love you,ypl-->"+a);
}
}
}
之后我们进行修改代码,将外部的类改到内部。
package com.Lambda;
import com.rgf.structure.O;
public class Demo2 {
//2.实现类
static class Love implements Ilove {
@Override
public void love(int a) {
System.out.println("I Love you,ypl-->"+a);
}
}
public static void main(String[] args) {
Ilove love = new Love();
love.love(3);
}
//1.定义一个函数式接口,只有一个抽象类方法
interface Ilove{
//隐式声明,自动就是抽象
void love(int a);
}
}
之后我们将内部类改为局部内部类
package com.Lambda;
import com.rgf.structure.O;
public class Demo2 {
public static void main(String[] args) {
//2.实现类
class Love implements Ilove {
@Override
public void love(int a) {
System.out.println("I Love you,ypl-->"+a);
}
}
Ilove love = new Love();
love.love(3);
}
//1.定义一个函数式接口,只有一个抽象类方法
interface Ilove{
//隐式声明,自动就是抽象
void love(int a);
}
}
之后将局部内部类改为匿名内部类
package com.Lambda;
import com.rgf.structure.O;
public class Demo2 {
public static void main(String[] args) {
//匿名内部类 new一个接口。
Ilove love = new Ilove() {
@Override
public void love(int a) {
System.out.println("I Love you ,ypl"+a);
}
};
love.love(3);
}
//1.定义一个函数式接口,只有一个抽象类方法
interface Ilove{
//隐式声明,自动就是抽象
void love(int a);
}
}
之后将匿名内部类改为lambda表达式。
package com.Lambda;
import com.rgf.structure.O;
public class Demo2 {
public static void main(String[] args) {
//匿名内部类 new一个接口。
Ilove love =(int a)-> {
System.out.println("I Love you ,ypl"+a);
};
love.love(520);
}
//1.定义一个函数式接口,只有一个抽象类方法
interface Ilove{
//隐式声明,自动就是抽象
void love(int a);
}
}
lambda简化:
package com.Lambda;
import com.rgf.structure.O;
public class Demo2 {
public static void main(String[] args) {
Ilove love=null;
/* //lambda表达式简化
Ilove love =(int a)-> {
System.out.println("I Love you ,ypl"+a);
};
//简化1.参数类型
love =(a)-> {
System.out.println("I Love you ,ypl"+a);
};
*/
/*//简化2.简化括号
love =a-> {
System.out.println("I Love you ,ypl"+a);
};*/
//简化3.去掉花括号
love =a-> System.out.println("I Love you ,ypl"+a);
//总结
//lambda表达式只能在有一行代码的情况下才能简化成为一行,如果有多行,那么就用代码块包裹。
//前提是接口必须为函数式接口,即接口里面只能有一个抽象类方法
//多个参数也可以去掉参数类型,要去掉就都去掉,必须加上括号
love.love(521);
}
//1.定义一个函数式接口,只有一个抽象类方法
interface Ilove{
//隐式声明,自动就是抽象
void love(int a);
}
//Runnable接口只有一个抽象类方法run方法,如果代码简单,可以用lambda表达式。
}
其中注释的代码可以去掉注释,看它们的运行效果从而可以更好的理解。
运行界面如下所示:
静态代理详解:
你:真实角色
婚庆公司:代理你,帮你处理结婚的事
结婚:实现都实现结婚接口即可
代码实现如下所示:
package com.Lambda;
import com.rgf.structure.W;
//静态代理模式总结:
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色
//好处:
//代理对象可以做很多真实对象做不了的事情
//真实对象就专注做自己的事情
public class StaticProxy {
public static void main(String[] args) {
You you = new You();//你要结婚
//lambda表达式
//多线程开始。
new Thread(() -> System.out.println("我爱你,蕾蕾")).start();
/*new Thread(new Runnable(){
@Override
public void run () {
}
})可以简化为上述写法。
*/
//原来的调法 you.HappyMarry();
new WeddingCompany(new You()).HappyMarry();
/* WeddingCompany weddingCompany=new WeddingCompany(you);//现在的调法
weddingCompany.HappyMarry();与上面一行代码相同*/
}
}
//1.写功能接口
interface Marry{
//人间四大喜事
//久旱逢甘露
//他乡遇故知
//洞房花烛夜
//金榜提名时
void HappyMarry();
}
//2.写实现类
//真实角色,你去结婚
class You implements Marry{
//实现接口方法,进行重写方法
@Override
public void HappyMarry() {
System.out.println("峰峰和蕾蕾要结婚了,超开心");
}
}
//代理角色,帮助你结婚
class WeddingCompany implements Marry{
//代理谁-->真实目标角色
private Marry target;//目标对象
//设置构造方法,传递参数
public WeddingCompany(Marry target) {
this.target = target;
}
//实现接口方法,进行重写方法
@Override
public void HappyMarry() {
before();
this.target.HappyMarry(); //这就是真实对象,
after();
}
//创建一个方法,alt+enter。
private void after() {
System.out.println("结婚之后,收尾款");
}
private void before() {
System.out.println("结婚之前,布置现场");
}
}
运行界面如下所示: