静态代理模式总结：
- 1.真实对象和代理对象都要实现同一个接口；
- 2.代理对象要代理真实角色
这样做的好处：
- 1.代理对象可以做很多真实对象做不了的事情
- 2.真实对象可以专注做自己喜欢的事情
举例：（Tom 结婚的案例）
- 定义一个 Marry的接口
//Marry 接口
interface Marry{
void HappyMarry();
}
- 被代理对象
// 真实角色-Tom，Tom去结婚
class Tom implements Marry {
@Override
public void HappyMarry() {
System.out.println("Tom 结婚了了，他很开心");
}
}
- 代理对象-婚庆公司
// 代理角色-婚庆公司。帮助 Tom结婚
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 after() {
System.out.println("婚礼后，结尾款");
}
private void before() {
System.out.println("婚礼前，准备婚礼现场");
}
}
- 主方法
public class StaticProxy {
public static void main(String[] args) {
Tom tom = new Tom();//Tom 要结婚
//用 lambda表达式对比
new Thread(()-> System.out.println("I Love You")).start();
new WeddingCompany(tom).HappyMarry();
}
}
2.4. Lambda表达式，
Lambda表达式的实质是函数式编程
函数式接口的定义：
- 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。比如 Runable接口：
public interface Runnable {
public abstract void run();
}
- 对于函数式接口，我们可以通过 lambda表达式来创建该接口的对象。
(params) -> expression [ 表达式 ]
(params) -> statement [ 单个语句 ]
(params) -> { statements }
为什么要使用 lambda表达式
- 1.避免匿名内部类定义过多
- 2.可以让代码看起来很简洁
- 3.去掉了一些没有意义的代码，只保留核心逻辑
推导 Lambda表达式
- 普通方法
使用一个类去实现他的接口,重写它的方法
再 创建它的对象，调用它的方法
public class TestLambda9_1 {
public static void main(String[] args) {
MyAddress address = new MyHome();
address.lambdaAddress();
}
}
//1.定义一个函数式接口
interface MyAddress {
void lambdaAddress();
}
//2.实现类
class MyHome implements MyAddress {
@Override
public void lambdaAddress() {
System.out.println("我的老家 就是那个屯");
}
}
- 使用 静态内部类 来简化
把实现类放到方法外面
public class TestLambda9_1 {
//3.使用静态内部类代替
static class MyHome2 implements MyAddress {
@Override
public void lambdaAddress() {
System.out.println("我的老家 就是那个屯 那个屯");
}
}
public static void main(String[] args) {
MyAddress address = new MyHome2();
address.lambdaAddress();
}
}
//1.定义一个函数式接口
interface MyAddress {
void lambdaAddress();
}
- 使用 局部内部类 来代替
把实现类放到方法中，
public class TestLambda9_1 {
public static void main(String[] args) {
//4.局部内部类
class MyHome3 implements MyAddress {
@Override
public void lambdaAddress() {
System.out.println("我的老家 就是那个屯 那个屯里 有土生土长的人");
}
}
//局部内部类
MyAddress address = new MyHome3();
address.lambdaAddress();
}
}
//1.定义一个函数式接口
interface MyAddress {
void lambdaAddress();
}
- 使用 匿名内部类 来代替
public class TestLambda9_1 {
public static void main(String[] args) {
//5.匿名内部类，没有类的名称，必须借助接口或父类
address = new MyAddress() {
@Override
public void lambdaAddress() {
System.out.println("匿名内部类");
}
};
address.lambdaAddress();
}
}
//1.定义一个函数式接口
interface MyAddress {
void lambdaAddress();
}
- 使用 Lambda表达式 来简化，（JDK1.8）
因为这个接口只有一个方法，所以可以进一步简化
简化后可以只关注于 业务的实现
public class TestLambda9_1 {
public static void main(String[] args) {
//6.用 lambda表达式简化
address = ()-> {
System.out.println("用 lambda表达式简化");
};
address.lambdaAddress();
}
}
//1.定义一个函数式接口
interface MyAddress {
void lambdaAddress();
}
- 最后再来一个示例
public class TestLambda9_2 {
public static void main(String[] args) {
ILove lo = null;
lo = (int year) -> {
System.out.println("Tom, I Love you " + year + " year");
};
lo.loveYou(4);
}
}
interface ILove {
void loveYou(int year);
}
