Day37

静态代理

Runnable接口实现多线程时，需要调用Tread类下的start方法命令cpu调用，这里Thread是代理接口，代理分为静态代理和动态道理

静态代理和动态代理的区别：静态代理的类是别人写好的拿来就可以用，动态代理是在运行过程中这个类是动态构建出来的

有记录日志，监控等等作用

真实对象和代理对象都要重写接口下的方法

代理对象里也要扔进真实对象在构造器里实现

package com.sxt.thread;

/**
 * 静态代理
 * 公共接口：
 * 1、真实对象
 * 2、代理对象
 */
public class StaticProxy {
    public static void main(String[] args) {
        new WeddingCompany(new You()).happyMary();
        //new 代理对象(new 真实对象()).接口方法
        //new Thread(线程对象).start();
    }
}
interface  Mary{
    void happyMary();
}
//真实对象
 class You implements Mary{
     @Override
     public void happyMary() {
         System.out.println("you and 嫦娥终于奔月了");
     }
 }
 //代理对象
 class WeddingCompany implements Mary{
    //真实对象
     private Mary target;
     public WeddingCompany(Mary target) {
         this.target = target;
     }

     @Override
     public void happyMary() {
         ready();
         this.target.happyMary();
         after();
     }
     private void ready(){
         System.out.println("布置主卧");
     }
     private void after(){
         System.out.println("闹玉兔");
     }
 }

lambda

JDK1.8以后出现的

作用：简化多线程

用于简单的代码只用一次的，复杂的不建议使用

只用一次就可以将线程接口放在内部类里

跟着外部类，外部类被调用，内部类跟着一起运行，外部类没有被调用就不动

匿名内部类可以直接把类名省了

//匿名内部类 必须借用接口或者父类
new Thread(new Runnable()

Lambda简化可以把方法名也省了，留下实现方法系统自己推导

但这个推导有个特点，必须存在类型 ，接口内部只能有一个方法系统才能推导

new Thread(() -> {
System.out.println(“一起蹦迪”);
}
).start();

package com.sxt.thread;

/**
 * Lambda表达式  简化线程的使用（用一次 比较简单的线程）
 */
public class LambdaThread {
    //静态内部类
    static class Test implements Runnable {
        public void run() {
            for (int i = 0; i < 20; i++) {
                System.out.println("一边唱歌");
            }
        }
    }


    public static void main(String[] args) {
        // new Thread(new Test()).start();//对象只用一次 可以使用匿名

        //局部内部类
        class Test1 implements Runnable {
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println("一边耍");
                }
            }
        }
        new Thread(new Test1()).start();

        //匿名内部类 必须借用接口或者父类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("一起蹦迪");
            }
        }).start();

        //JDK8 简化 lamda
        new Thread(() -> {
            System.out.println("一起蹦迪");
        }
        ).start();
    }
}

自己写个接口

静态外部类->静态内部类->方法内部类->匿名内部类->lambda表达式

package com.sxt.thread;

/**
 * Lambda推导
 */
public class LambdaTest01 {
    //静态内部类
    static class Like1 implements lLike {
        public void lambda() {
            System.out.println("i like lambda1");
        }
    }

    public static void main(String[] args) {
        lLike like = new Like();
        like.lambda();
        like = new Like1();
        like.lambda();
        //方法内部类
       class Like2 implements lLike {
            public void lambda() {
                System.out.println("i like lambda4");
            }
        }
        like=new Like2();
        like.lambda();
        //匿名内部类
        like = new lLike(){
            public void lambda() {
                System.out.println("i like lambda2");
            }
        };
        like.lambda();
        //lambda
        like=()->{
            System.out.println("i like lambda3");
        };
        like.lambda();
    }
}
interface lLike{
    void lambda();
}
//外部类
class Like implements lLike{
    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}

加参数

简化

如果只有一个参数可以省去类型和括号，系统会自己匹配

只有一行代码可以省去花括号+；表示语句结束

package com.sxt.thread;

/**
 * Lambda推导+参数
 */
public class LambdaTest02 {

    public static void main(String[] args) {
     lLove love=(int a)->{
            System.out.println("i like lambda" + "--->" + a);
        };
     love.lambda(100);

     //简化
        //如果只有一个参数可以省去类型和括号，系统会自己匹配
        love= a->{
            System.out.println("i like lambda" + "--->" + a);
        };
        love.lambda(5);

        //只有一行代码可以省去花括号+；表示语句结束
        love= a-> System.out.println("i like lambda" + "--->" + a);
        love.lambda(66);
    }
}

    interface lLove {
        void lambda(int a);
    }

    //外部类
    class Like implements lLove {
        @Override
        public void lambda(int a) {
            System.out.println("i like lambda" + "--->" + a);
        }
    }

Lambda推导+参数+返回值

不断简化

package com.sxt.thread;
/**
 * Lambda推导+参数+返回值
 */
    public class LambdaTest03 {
    public static void main(String[] args) {
        lInterest interest = (int a, int c) -> {
            System.out.println("i like lambda" + "--->" + (a + c));
            return a + c;
        };
        interest.lambda(100, 200);
        //简化
        interest = (a, c) -> {
            System.out.println("i like lambda" + "--->" + (a + c));
            return a + c;
        };
        interest.lambda(10, 210);

        interest = (a, c) -> a + c;

        interest = (a, c) -> 100;//返回值就是100

        System.out.println(interest.lambda(10, 20));
    }
}
interface lInterest {
   int lambda(int a,int b);
}
//外部类
class Interest implements lInterest {
    @Override
    public int lambda(int a,int c) {
        System.out.println("i like lambda" + "--->" + (a+c));
        return a+c;
    }
}

简化多线程 避免匿名内部类定义过多

其实质属于函数式编程

有些省略需要条件

package com.sxt.thread;

/**
 * lambda推导+使用
 */
public class LambdaTest04 {
    public static void main(String[] args) {
        new Thread(()->{
            for (int i = 0; i <100 ; i++) {
                System.out.println("一边学习lambda"+i);
            }

        }).start();
        new Thread(()-> System.out.println("一边学习奔溃中")
        ).start();
    }
}