• 静态代理模式

总结:

真实对象和代理对象都要实现同一个接口

代理对象要代理真实角色(传递一个真实角色类型的实参)

好处:代理对象可以做很多真实对象做不了的事情

        真实对象专注做自己的事情

实现方法类似多线程new Thread(...).start();

package 静态代理;

public class StaticProxy{
    public static void main(String[] args) {
//       Wedding wedding = new Wedding(new You());
//       wedding.HappyMarry();
         new Wedding(new You()).HappyMarry();//与上述等价
    }
}
interface Marry{
    void HappyMarry();
}
//真实角色，我去结婚
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("我要结婚了");
    }
}
//代理角色，帮助我结婚
class Wedding implements Marry{
    private Marry target;//代理真实角色
    public Wedding(Marry target){
        this.target = target;
    }
    @Override
    public void HappyMarry() {
        after();
        this.target.HappyMarry();//真实对象
        before();
    }
    private void before() {
        System.out.println("结婚之后，收尾款");
    }
    private void after() {
        System.out.println("结婚之前，布置现场");
    }
}
/*
结婚之前，布置现场
我要结婚了
结婚之后，收尾款
*/

• Lamda表达式

 主要作用为简化程序，避免匿名内部类定义过多，去掉没有意义的代码，只留下核心的逻辑

函数式接口的定义:任何接口，若只包含唯一一个抽象方法，那么他就是函数式接口。

package Lamda;
/*
推导Lamda表达式
*/
public class TestLamda1 {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lamda() {
            System.out.println("I like lamda2");
        }
    }
    public static void main(String[] args) {
        new Like().lamda();
        Like2 like2 = new Like2();
        like2.lamda();
        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lamda() {
                System.out.println("I like lamda3");
            }
        }
        Like3 like3 = new Like3();
        like3.lamda();
        //5.匿名内部类,没有类的名称，必须借助接口或者父类
        new ILike(){
            @Override
            public void lamda() {
                System.out.println("I like lamda4");
            }
        }.lamda();
        //6.用Lamda简化 必须要函数式接口才能实现
        ILike iLike = new Like();
        iLike = ()->{
            System.out.println("I like lamda5");
        };
        iLike.lamda();
    }
}
//1.定义函数式接口
interface ILike{
    void lamda();
}
//2.实现类
class Like implements ILike{
    @Override
    public void lamda() {
        System.out.println("I like lamda");
    }
}
/*I like lamda
  I like lamda2
  I like lamda3
  I like lamda4
  I like lamda5*/

• Lamda表达式的简化

package Lamda;

public class TestLamba2 {
    public static void main(String[] args){
        lamba ll = (int a)->{
            System.out.println("new lamda表达式" + a);
        };
        ll.l(521);
        //简化1.去掉参数类型
        ll = (a)->{
            System.out.println("Lamda简化1");
        };
        ll.l(1);
        //简化2.简化括号
        ll = a->{
            System.out.println("Lamda简化2");
        };
        ll.l(2);
        //简化3.去掉花括号
        ll = a-> System.out.println("终极简化3");
        ll.l(3);
        //总结:简化3.Lamda表达式只能有一行代码的情况下才能简化成为一行，如果有多行就用代码块包裹即带上花括号
        //接口必须是函数式
        //多参数就要带上括号
    }
}
interface lamba{
    void l(int a);
}
/*new lamda表达式521
Lamda简化1
Lamda简化2
终极简化3
*/