Java学习Day26

特点：

真实对象和代理对象都要实现同一个接口

代理对象要代理真实对象

好处：

代理对象可以做很对真实对象做不了的事情真实对象可以做很多自己的事情

//静态代理
public class StaticProxy {
    public static void main(String[] args) {
        //Thread类代理执行Runnable接口的run方法
        new Thread(()-> System.out.println("I love you.")).start();

        Person person = new Person();//new一个真实对象
        new WeddingCompany(person).HappyMarry();//代理对象执行真实对象的方法

    }
}

interface Marry{
    //开心地结婚
    void HappyMarry();
}

//结婚的真实角色
class Person implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("Jack will 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 after() {
        System.out.println("After marry, get money.");
    }

    private void before() {
        System.out.println("Before marry, decorate many.");
    }
}

为了避免匿名内部类定义过多，lambda表达式用于简化编程的过程，其实质属于函数式编程的概念。

new Thread(()->System.out.println(“多线程学习”)).start();

避免匿名内部类定义过多可以让你的代码看起来很简洁去掉了一堆没有意义的代码 函数式接口的定义

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口（相当于用接口包装了一个方法，使其规范化）。对于函数式接口，我们可以用lambda表达式来创建该接口的对象（即只有一个抽象方法的函数式接口才可以用lambda表达式简化）。

public class TestLambda1 {
    //3.静态内部类
     static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like you2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();
        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like you3");
            }
        }
        like = new Like3();
        like.lambda();

        //5.匿名内部类
        //没有类的名称，必须借助接口或者父类去实现
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like you4");
            }
        };
        like.lambda();
        //6.用lambda简化
        like = ()->{
            System.out.println("I like you5");
        };
        like.lambda();

    }
}


//1.定义一个函数式接口
interface ILike{
    void lambda();
}
//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like you");
    }
}

基本格式：变量 = （参数类型 参数）->{重写的代码块}

简化1:去掉参数类型（如果有多个参数，则参数类型都要去掉，不可以只去一部分）简化2:去掉参数的括号（只能在只有一个参数的情况下使用，如果有多个参数则要用括号包裹，没有参数的情况下括号也不能省略，而需要作为一种lambda表达式的形式存在）简化3:去掉代码块外面的花括号（当代码块只有一行时，才可以使用，这一规则在其他从属关系的语句中也适用，如if语句）

public class TestLambda2 {
    public static void main(String[] args) {
        //lambda表达式 （参数）->{重写的代码块}
        ILove love = null;
        love = (int a, int b) -> {
            System.out.println("I love you "+a+" times");
        };
        love.love(520,520);
        //简化1：去掉参数类型(如果有多个参数，则必须都去掉参数类型，不可以只去掉一部分)
        love = (a,b)->{
            System.out.println("I love you "+a+" times");
        };
        love.love(521,521);
        //简化2：去掉参数的括号(只有一个参数)
        love = (a,b)->{
            System.out.println("I love you "+a+" times");
            System.out.println(b);
        };
        love.love(522,522);
        //简化3：去掉花括号(代码只有一行)
        love = (a,b)-> System.out.println("I love you "+a+" times");
        love.love(523,523);

        

    }
}
//函数式接口
interface ILove{
    void love(int a, int b);
}
//有多个方法的不是函数式接口，不可以用lambda表达式
interface Do{
    void run();
    void walk();
}