java多线程 02 静态代理 lambda表达式

静态代理

真实对象（目标对象）和代理对象要实现同一个接口

代理对象要代理真实角色

好处：代理对象可以做很多真实对象做不了的事情 真实对象专注做自己的事情

package basic;


public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();
        new Thread(()-> System.out.println("i love you")).start();
        new WeddingCompany(new You()).HappyMarry(); // proxy
    }
}

interface Marry{

    void HappyMarry();
}

// 真实角色，你去结婚
class You implements Marry{

    @Override
    public void HappyMarry(){
        System.out.println("happy marry");
    }
}

// 代理角色，帮助你结婚
class WeddingCompany implements Marry{
    private Marry target;
    public WeddingCompany(Marry target){
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }

    private void before() {
        System.out.println("before marry, set stage");
    }

    private void after() {
        System.out.println("after marriage, receive money");
    }

}

lambda表达式

new Thread(()->System.out.println("study hard")).start;

函数式接口：任何借口，如果只包含唯一一个抽象方法，则为函数式接口，可以通过 lambda 表达式来创建该接口的对象

public interface Runnable{
  public abstract void run();
}

举例推导

package basic;
// derive lambda expression
// simplify step by step
public class LambdaTest01 {

    // 3. static inner calss
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like lambda2");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like(); // implementation new a implement class
        like.lambda();
        like = new Like2();
        like.lambda();

        // 4. local inner class
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like lambda3");
            }
        }
        like = new Like3();
        like.lambda();

        // 5. anonymous inner class; without class title, must
        // with implementation or father
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like lambda4");
            }
        };
        like.lambda();

        // 6. lambda
        like = ()->System.out.println("I like lambda5");
        like.lambda();


    }
}

// 1. define a functional implementation
interface ILike{
    void lambda(); // only one abstract function in interface
}
// 2. implement class
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like lambda");
    }
}

• lambda表达式只能有一行代码的情况下才能简化成一行，如果有多行，那么就用代码块包裹

• 前提：必须为函数式接口

• 多个参数也可以去掉参数类型（要去掉就都去掉）必须加上括号

package basic;

public class LambdaTest02 {
    public static void main(String[] args) {
        ILove love = null;
//        ILove love = (int a) -> {
//                System.out.println("i love you "+a);
//        };

        // simplify 1
//        ILove love = (a)-> {
//            System.out.println("i love you "+a);
//        };

        // simplify 2
        //love = a -> {System.out.println("i love you "+a);};

        // simplify 3
        love = a-> System.out.println("i love you "+a);

        love.love(521);
    }
}

interface ILove{
    void love(int a);
}