多线程扩展

静态代理 模式

线程的 Runnable 接口使用的就是静态代理。

写一个接口类

//人 有一个需要租房的方法
public interface People {
    //租房 的 方法
    public void  renting();
}

真实对象

//真实对象 租客 需要租房
public class You implements People{

    @Override
    public void renting() {
        System.out.println("我要租房子。");
    }
}

代理对象

//代理对象 帮助你租房
public class intermediary implements People{

    //代理 的真实对象
    private You you;

    //通过构造器来创建代理对象
    public intermediary(You you) {
        this.you = you;
    }

    @Override
    public void renting() {
        //可在帮助 真实对象 执行前做一些其他的操作
        af();
        this.you.renting();
        bf();
    }


    private void af(){
        System.out.println("我找中介帮忙找房子。");
    }

    private void bf(){
        System.out.println("中介帮我找到了，我入住后交付押金。");
    }

}

main 方法测试

    public static void main(String[] args) {
        You you = new You();
        intermediary intermediary = new intermediary(you);
        intermediary.renting();

        //上面三行和下面的结果是一样的。
        //new intermediary(new You()).renting();
    }

• 静态代理中介
  1. 真实对象和代理对象要实现同一个接口
  2. 代理对象要代理真实对象 private You you;
• 好处
  1. 代理对象可以邦 真实对象 做很多他自身做不了的事情。
  2. 真实对象 只需要关注与自己的事情

Lamdba 表达式

为什么使用 Lamdba

1. 避免匿名内部类定义过多。
2. 可以让代码看起来很简洁。
3. 去掉一堆没意义的代码，只留下核心的代码。

• 理解 函数式接口 是学习Java8 lambda 表达式的关键所在。

• 函数式接口的定义：

  1. 任何接口。只要只有一个抽象方法，那么他就是一个函数式接口。
  2. 对于函数式接口， 我们可以通过lamdba表达式的老创建该接口的对象

  // 函数式接口
  public interface People {
      public abstract void  renting();
  }
  

测试的类

public class LambaTest02{
    //3.静态内部类
    static class  Love2 implements ILove{
        @Override
        public void love() {
            System.out.println("I Love You Love2");
        }
    }

    public static void main(String[] args) {
        ILove love = null;

        love = new Love();
        love.love();

        love = new Love2();
        love.love();

        //4. 局部内部类
        class Love3 implements ILove{

            @Override
            public void love() {
                System.out.println("I Love You Love3");
            }
        }
        love = new Love3();
        love.love();

        //5.匿名内部类 没有类的名称，必须借助就扣或者其父类
        love  = new ILove() {
            @Override
            public void love() {
                System.out.println("I Love You Love4");
            }
        };
        love.love();
    }
}

//1.定义一个函数式接口
interface ILove {
    void  love();
}
//2.实现类
class  Love implements ILove{

    @Override
    public void love() {
        System.out.println("I Love You Love1");
    }
}

优化成 **Lamdba **表达式方式

public class LambaTest02{

    public static void main(String[] args) {
        ILove love = null;
        //3. 实现 lambda 方式
        love = (a,b)-> {
            System.out.println("测试");
        };
        love.love(1,2);
    }

}

//1.定义一个函数式接口
interface ILove {
    void  love(int a,int b);
}
//2.实现类
class  Love implements ILove{
    @Override
    public void love(int a,int b) {
        System.out.println("I Love You Love1 : " + a+ b);
    }
}

Lamdba 注意项

lambda 表达式只能在只有一行代码的情况下省去｛｝；
前提是接口为函数式接口
多个参数也可以去掉参数类型，要去掉都去掉，要不去就都不去。