Java多线程——静态代理(代理模式）& Lambda表达式

静态代理

代理模式

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。

在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。

介绍

**意图：**为其他对象提供一种代理以控制对这个对象的访问。

**主要解决：**在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

• 案例：结婚 — > 婚庆公司（代理）

package com.thread.demo;

public class Demo6 {

    public static void main(String[] args) {
        MarryCompany marryCompany = new MarryCompany(new You("张三"));
        marryCompany.marry();
    }
}

interface Marry {
    void marry();
}
// 要结婚的人（真实的对象）
class You implements Marry{

    private String name;
    @Override
    public void marry() {
        System.out.println(this.name+":我要结婚啦~");
    }

    public You(String name) {
        this.name = name;
    }
}

// 婚庆公司（代理对象）
class MarryCompany implements Marry {
    private Marry target;

    public MarryCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void marry() {
        before();
        this.target.marry();
        after();
    }

    private void after() {
        System.out.println("婚庆公司--婚礼结束，收取尾款");
    }

    private void before() {
        System.out.println("婚庆公司--布置婚礼现场");
    }
}

• 好处：

  1. 代理对象可以做很多真实对象做不了的事情

2. 真是对象可以专注做自己的事情

Lambda表达式

• 理解Functional interface (函数式接口) ，是学习Java8 lmabda表达式的关键所在。

• 函数式接口的定义：

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

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

  • 对于函数接口我们可以通过lmabda表达式来创建该接口对象

• Lambda演化过程：

  package com.thread.demo;
  
  
  // 1.只有一个抽象方法的接口
  interface Like{
      void lambda();
  }
  
  //2.实现接口的类
  
  class ILike implements Like{
  
      @Override
      public void lambda() {
          System.out.println("lambda1");
      }
  }
  
  public class Demo7 {
  //    3.静态内部类
      static class ILike2 implements Like{
          @Override
          public void lambda() {
              System.out.println("lambda2");
          }
      }
  
      public static void main(String[] args) {
          ILike iLike1 = new ILike();
          iLike1.lambda();
  
          ILike2 iLike2 = new ILike2();
          iLike2.lambda();
  
  //        4.局部内部类
          class ILike3 implements Like{
              @Override
              public void lambda() {
                  System.out.println("lambda3");
              }
          }
          ILike3 iLike3 = new ILike3();
          iLike3.lambda();
  
  //        5.匿名内部类
          Like lambda4 = new Like() {
              @Override
              public void lambda() {
                  System.out.println("lambda4");
              }
          };
          lambda4.lambda();
  
  //        6.Lambda 简化
           Like lambda5 = ()->{System.out.println("lambda5");};
           lambda5.lambda();
      }
  }
  

• Lambda简化

  package com.thread.demo;
  
  interface Lambda {
      void showNum(int i);
  }
  
  public class Demo8 {
      public static void main(String[] args) {
          Lambda lambda = null;
  //       第一代lambda
          lambda = (int i) -> {System.out.println("第一代-->" + i);};
          lambda.showNum(1);
  //       第二代lambda【常用】
          lambda = (i) -> {System.out.println("第二代-->" + i);};
          lambda.showNum(2);
  //       第三代lambda 【只有一个参数时可用】
          lambda = i-> {System.out.println("第三代-->" + i);};
          lambda.showNum(3);
  //       第四代lambda【当只有一条语句时可用】
          lambda = i-> System.out.println("第四代-->" + i);
          lambda.showNum(4);
      }
  }