[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();*/
    }
}