1.静态代理

public interface Marry {
    void HappyMarry();
}
//真实对象
public class You implements Marry {
    @Override
    public void HappyMarry() {
        System.out.println("***结婚了，超开心");
    }
}
//代理对象
public class MarryCompany implements Marry {
    //代理谁---->真实目标角色
    private Marry target;
    public MarryCompany(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) {
        //you的代理是MarryCompany，代理对象可以做真实对象以外的事情，真实对象专注于自己的事情就好
//        You you = new You();
//        MarryCompany marryCompany = new MarryCompany(you);
//        marryCompany.HappyMarry();
        new MarryCompany(new You()).HappyMarry();

    }
}

总结：

真实对象和代理对象实现同一个接口
代理对象代理真实的角色
优点：

代理对象可以做很多真实对象做不了的事情
真实对象只需要专注自己的事情就行

2.lambda表达式

2.1函数式接口

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口

public interface Runn{
public abstract void run();
}

2.2创建无参接口对象的方法

1. 单独写接口的实现类之后，再在主程序中新建对象调用方法

public class LambdaTest01 {
    public static void main(String[] args) {
       Ilike like = new Like();
       like.lambda();
}


//1.定义一个函数式接口，也就是只有一个抽象方法的接口
interface Ilike{
    void lambda();
}

//2.实现类
class Like implements Ilike{
    @Override
    public void lambda() {
        System.out.println("I Like lambda");
   }
}

2. 静态内部类

public class TestLambda {
 public static void main(String[] args) {
   //2.使用静态内部类
   Ilike ilike2=new like2();
   ilike2.lambda();
 }
 //静态内部类
 static class like2 implements Ilike{
   @Override
   public void lambda() {
       System.out.println("i like lambda2");
   }
 }
}
//1.定义一个函数式接口
interface Ilike{
 void lambda();
}

3. 局部内部类

public class TestLambda {
  public static void main(String[] args) {
      //3.局部内部类
      class Like3 implements Ilike{
          @Override
          public void lambda() {
              System.out.println("i like lambda3");
          }
      }
      Ilike ilike3=new Like3();
      ilike3.lambda();
  }
}
//1.定义一个函数式接口
interface Ilike{
  void lambda();
}

4. 匿名内部类

public class TestLambda {
  public static void main(String[] args) {
      //2.匿名内部类,没有类的名称，必须借助父类或者接口
      Ilike ilike4=new Ilike() {
          @Override
          public void lambda() {
              System.out.println("i like lambda4");
          }
      };
      ilike4.lambda();
  }
}
//1.定义一个函数式接口
interface Ilike{
  void lambda();
}

5.lambda简化

/*
* 推导lambda表达式
* */
public class TestLambda {
    public static void main(String[] args) {
        //2.用lambda简化
        Ilike ilike5=()->{
            System.out.println("i like lambda5");
        };
        ilike5.lambda();
    }
}
//1.定义一个函数式接口
interface Ilike{
    void lambda();
}

2.3创建有参接口对象的方法
1.

public class LambdaTest02 {
    public static void main(String[] args) {
        Ilove ilove = new love();
        ilove.lambda(2);
    }
}
interface Ilove{
    void lambda(int a);
}
class love implements Ilove{
    @Override
    public void lambda(int a) {
        System.out.println("I love " + a);
    }
}

public class LambdaTest02 {
    static class love implements Ilove{
        @Override
        public void lambda(int a) {
            System.out.println("I love " + a);
        }
    }
    public static void main(String[] args) {
        Ilove ilove = new love();
        ilove.lambda(3);
    }
}
interface Ilove{
    void lambda(int a);
}

public class LambdaTest02 {
    public static void main(String[] args) {
        class love implements Ilove{
            @Override
            public void lambda(int a) {
                System.out.println("I love " + a);
            }
        }
        Ilove ilove = new love();
        ilove.lambda(4);
    }
}

interface Ilove{
    void lambda(int a);
}

public class LambdaTest02 {
    public static void main(String[] args) {
       new Ilove(){
            @Override
            public void lambda(int a) {
                System.out.println("I love " + a);
            }
        }.lambda(5);
    }
}

interface Ilove{
    void lambda(int a);
}

5.lambda方式

public class LambdaTest02 {
    public static void main(String[] args) {
       Ilove ilove = (int a) -> {
            System.out.println("I love " + a);
        };
       //还可以继续简化，1.简化参数类型
        ilove = (a) -> {
            System.out.println("I love " + a);
        };
        //2.简化括号
        ilove = a -> {
            System.out.println("I love " + a);
        };
        //3.简化花括号(必须只能有一行代码，如果多行则无法简化花括号！)
        ilove = a -> System.out.println("I love " + a);
       ilove.lambda(6);
    }
}

interface Ilove{
    void lambda(int a);
}

总结：

• .lambda表达式只有一行代码的情况下才能简化为一行，如果有多行，就需要花括号包裹
• 使用lambda的前提是函数式接口
• 多个参数也可以去掉参数类型，但是要去掉就都去掉，不能有些带类型有些不带，并且要括号包裹多个参数，用逗号隔开