2022.8.20 Lamda表达式与静态代理
作者：互联网
3、Lamda表达式
-
λ 希腊字母表中排序第十一位的字母，英语名称为 Lambda
-
避免匿名内部类定义过多
-
其实质属于函数式编程的概念
-
去掉了一堆没有意义的代码,只留下核心逻辑
(params)-> expression[表达式]
(params) -> statement[语句]
[(params)-> {statements}
为什么要使用lambda表达式
-
避免匿名内部类定义过多
-
可以让你的代码看起来很简洁
-
去掉了一·堆没有意义的代码，只留下核心的逻辑。
也许你会说，我看了Lambda表达式，不但不觉得简洁，反而觉得更乱，看不懂了。那是因为我们还没有习惯，用的多了，看习惯了，就好了。
函数式接口
-
理解Functional Interface (函数式接口) 是学习Java8 lamda表达式的关键
-
函数式接口的定义
-
任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口.
public interface Runnable{
public abstract void run();
} -
对于函数式接口,我们可以通过Lambda表达式来创建该接口的对象.
案例
package com.xing.lambda;
/**
* 推导lamda表达式
*/
public class TestLambda {
public static void main(String[] args) {
ILike like = new Like();
like.lamda();
}
}
// 1.定义一个函数式接口
interface ILike {
void lamda();
}
// 2.实现类
class Like implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda");
}
}
优化步骤1：
package com.xing.lambda;
/**
* 推导lamda表达式
*/
public class TestLambda {
//3. 静态内部类
static class Like1 implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda1");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lamda();
like = new Like1();
like.lamda();
}
}
// 1.定义一个函数式接口
interface ILike {
void lamda();
}
// 2.实现类
class Like implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda");
}
}
优化步骤2：
package com.xing.lambda;
/**
* 推导lamda表达式
*/
public class TestLambda {
//3. 静态内部类
static class Like1 implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda1");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lamda();
like = new Like1();
like.lamda();
//4.局部内部类
class Like2 implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda2");
}
}
like = new Like2();
like.lamda();
}
}
// 1.定义一个函数式接口
interface ILike {
void lamda();
}
// 2.实现类
class Like implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda");
}
}
优化步骤3：
package com.xing.lambda;
/**
* 推导lamda表达式
*/
public class TestLambda {
//3. 静态内部类
static class Like1 implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda1");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lamda();
like = new Like1();
like.lamda();
//4.局部内部类
class Like2 implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda2");
}
}
like = new Like2();
like.lamda();
//5.匿名内部类,没有类的名称,必须借助接口或者父类
like = new ILike () {
@Override
public void lamda() {
System.out.println("I like lamda3");
}
};
like.lamda();
}
}
// 1.定义一个函数式接口
interface ILike {
void lamda();
}
// 2.实现类
class Like implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda");
}
}
最终版：
package com.xing.lambda;
/**
* 推导lamda表达式
*/
public class TestLambda {
//3. 静态内部类
static class Like1 implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda1");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lamda();
like = new Like1();
like.lamda();
//4.局部内部类
class Like2 implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda2");
}
}
like = new Like2();
like.lamda();
//5.匿名内部类,没有类的名称,必须借助接口或者父类
like = new ILike () {
@Override
public void lamda() {
System.out.println("I like lamda3");
}
};
like.lamda();
//6.lamda简化
like = () ->{
System.out.println("I like lamda4");
};
like.lamda();
}
}
// 1.定义一个函数式接口
interface ILike {
void lamda();
}
// 2.实现类
class Like implements ILike {
@Override
public void lamda() {
System.out.println("I like lamda");
}
}
案例2:
package com.xing.lambda;
public class TestLambda2 {
public static void main(String[] args) {
// 1.lamda
ILove love = (int a) -> {
System.out.println("I love you -->" + a);
};
love.love(520);
// 2.lamda简化 去掉参数类型
love = (a) -> {
System.out.println("I love you -->" + a);
};
love.love(1314);
// 3.lamda简化 去掉小括号
love = a -> {
System.out.println("I love you -->" + a);
};
love.love(1111);
// 3.lamda简化 去掉大括号
love = a -> System.out.println("I love you -->" + a);
love.love(9999);
/**总结:
* {}简略的条件是只能有一行代码,多行{}就不能简略了
* 前提是接口为函数式接口(只能有一个方法)
* 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上()
*/
}
}
// 接口
interface ILove {
void love(int a);
}
4、静态代理
结婚案例
package com.xing.proxy;
/**
* 静态代理:结婚案例
* 静态代理模式总结
* 真实对象和代理对象都要实现同一个接口
* 代理对象要代理真实角色
*/
public class StaticProxy {
public static void main(String[] args) {
WeddingCompany weddingCompany = new WeddingCompany(new You());
weddingCompany.happyMarry();
}
}
//结婚
interface Marry {
void happyMarry();
}
//真实角色:你去结婚
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();
}
private void before() {
System.out.println("结婚之前,布置现场");
}
private void after() {
System.out.println("结婚之后,收尾款");
}
}
对比 静态代理与Thread
/**
* 线程中的代理模式
*/
public class StaticProxy {
public static void main(String[] args) {
//代理Runnable接口
new Thread(()-> System.out.println("我爱你")).start();
new WeddingCompany(new You()).happyMarry();
}
}
//WeddingCompany...上一个文件定义过了这里就直接使用了
总结
真实对象和代理对象都要实现一个接口 代理对象要代理真实角色
好处
代理对象可以做很多真实对象做不了的事情 真实对象专注做自己的事
标签：Lamda,20,like,void,lamda,ILike,2022.8,println,public 来源： https://www.cnblogs.com/shanzha/p/16609107.html