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

一、静态代理

【代码示例】

 1 /***
 2  * 静态代理：记录日志等，类是写好的，直接拿来用。 动态代理：随用随构建，临时抱佛脚
 3  * 婚庆公司：代理角色，帮你搞婚庆的一切，布置房间等等
 4  * 自己：真实角色，结婚是自己去结婚，不是婚庆公司去结婚
 5  * 
 6  * 结婚礼仪：代理相同的接口，不管谁搞流程是确定的
 7  * 
 8  */
 9 package cn.sxt.thread;
10 
11 public class Test_0406_StaticProxy {
12     public static void main(String[] args) {
13         new ProxyObject( new RealityObject() ).buy(); //代理对象里面传入一个真实的结婚对象
14         //new Thread(new Racer()).start(); 类似于这个 
15         
16     }
17     
18 }
19 //接口:结婚流程
20 interface MarryProcess{
21     void buy();//买东西
22 }
23 
24 class RealityObject implements MarryProcess{
25 
26     public void buy() { //重写buy方法
27         System.out.println("自己去采买结婚物品");
28     }
29     
30 }
31 
32 class ProxyObject implements MarryProcess{
33 
34     private MarryProcess target;//代理谁，就是放一个真实角色
35     
36     
37     public ProxyObject(MarryProcess target) {
38         super();
39         this.target = target;        
40     }
41 
42     public void buy() {//重写buy方法
43         ready();//这里可以写登录日志呀等等
44         this.target.buy(); //this.target指的是真实的角色，这里的buy()是接口中的buy()方法
45         after();//这里可以用作释放资源呀
46     }
47     private void ready() {
48         System.out.println("买烟酒");
49         
50     }
51     private void after() {
52         System.out.println("收拾桌子");
53         
54     }
55     
56 }

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

 

转载于:https://www.cnblogs.com/ID-qingxin/p/10668213.html