[19/04/06-星期六] 多线程_静态代理(StaticProxy)和 lamda (简化代码，jdk8新增)

一、静态代理

【代码示例】

 /***
  * 静态代理：记录日志等，类是写好的，直接拿来用。 动态代理：随用随构建，临时抱佛脚
  * 婚庆公司：代理角色，帮你搞婚庆的一切，布置房间等等
  * 自己：真实角色，结婚是自己去结婚，不是婚庆公司去结婚
  *
  * 结婚礼仪：代理相同的接口，不管谁搞流程是确定的
  *
  */
 package cn.sxt.thread;

 public class Test_0406_StaticProxy {
     public static void main(String[] args) {
         new ProxyObject( new RealityObject() ).buy(); //代理对象里面传入一个真实的结婚对象
         //new Thread(new Racer()).start(); 类似于这个 

     }

 }
 //接口:结婚流程
 interface MarryProcess{
     void buy();//买东西
 }

 class RealityObject implements MarryProcess{

     public void buy() { //重写buy方法
         System.out.println("自己去采买结婚物品");
     }

 }

 class ProxyObject implements MarryProcess{

     private MarryProcess target;//代理谁，就是放一个真实角色

     public ProxyObject(MarryProcess target) {
         super();
         this.target = target;
     }

     public void buy() {//重写buy方法
         ready();//这里可以写登录日志呀等等
         this.target.buy(); //this.target指的是真实的角色，这里的buy()是接口中的buy()方法
         after();//这里可以用作释放资源呀
     }
     private void ready() {
         System.out.println("买烟酒");

     }
     private void after() {
         System.out.println("收拾桌子");

     }

 }

二、lamda表达式

/**jdk8新增
 * lambda表达式
 * 1、避免匿名内部类定义过多
 * 2、实质属于函数式编程
 * 3、简化线程(一般是只用一次的线程)的使用
 *
 */
package cn.sxt.thread;

public class Test_0406_Lambda {
    //知识点1：类放在类中，静态内部类Test01，不使用它，编译器不会编译
    static class Test01 implements Runnable{
        //线程入口入口点
        public void run() {
            for (int i = 0; i <5; i++) {
                System.out.println("爱你呦！");
            }
        }
    } 

    public static void main(String[] args) {//主方法，代码从这里开始
        //new Thread(new Test01()).start(); //new Test01()类仅用一次

        //知识点2：类放在方法里边 称之为局部内部类
        class Test02 implements Runnable{
            //线程入口入口点
            public void run() {
                for (int i = 0; i <5; i++) {
                    System.out.println("爱你一万年！");
                }
            }
        } 

        new Thread(new Test02()).start();//new Test02()类仅用一次

        //知识点3、匿名内部类，必须借助接口或者父类。与上边相比没有一个具体的类名
        new Thread(new Runnable(){ //Runnable()是个接口不可示例化，所以加上{。。。}，里边是类体，且重写run()方法
            public void run() {
                for (int i = 0; i<5; i++) {
                    System.out.println("love you ");
                }
            }                

        } ).start();

        //知识点4、lambda表达式，由上边3点演化过来，省去了new Runnable(){public void run()
        //}和更加简化 ,仅限于里边有一个方法，本机安装的版本是jdk1.7的，不支持
/*
        new Thread( ()-> {
            for (int i = 0; i<5; i++) {
                System.out.println("喜欢你 ");
            }
        } ).start();*/
    }
}