Java高级编程–动态代理–day10

1.什么是动态代理？

动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象

interface Human{
    String getBelief();
    void eat(String food);
}
class SuperMan implements  Human{
    @Override
    public String getBelief() {
        System.out.println("处理getBelief");
        return "I believe I can fly!";
    }
    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃"+food);
    }
}
class ProxyFactory{
    public static Object getProxyInstance(Object obj){
        MyInvocationHandler handler=new MyInvocationHandler();
        handler.bind(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }
}
class MyInvocationHandler implements InvocationHandler{
    private Object obj;
    public void bind(Object obj){
        this.obj=obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object returnValue=method.invoke(obj,args);
        System.out.println("代理方法");
        return returnValue;
    }
}
public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan=new SuperMan();
        Human proxyInstance=(Human)ProxyFactory.getProxyInstance(superMan);
        proxyInstance.getBelief();
        proxyInstance.eat("四川麻辣烫");
    }
}

2. AOP

样例代码：

interface Human{
    String getBelief();
    void eat(String food);
}
class SuperMan implements  Human{
    @Override
    public String getBelief() {
        System.out.println("处理getBelief");
        return "I believe I can fly!";
    }
    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃"+food);
    }
}
class HumanUtil{
    public void method1(){
        System.out.println("=============通用方法一================");
    }
    public void method2(){
        System.out.println("=============通用方法二================");
    }
}
class ProxyFactory{
    public static Object getProxyInstance(Object obj){
        MyInvocationHandler handler=new MyInvocationHandler();
        handler.bind(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }
}
class MyInvocationHandler implements InvocationHandler{
    private Object obj;
    public void bind(Object obj){
        this.obj=obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        HumanUtil humanUtil=new HumanUtil();
        humanUtil.method1();
        Object returnValue=method.invoke(obj,args);
        humanUtil.method2();
        return returnValue;
    }
}
public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan=new SuperMan();
        Human proxyInstance=(Human)ProxyFactory.getProxyInstance(superMan);
        proxyInstance.getBelief();
        proxyInstance.eat("四川麻辣烫");
    }
}

3.Lambda表达式

1.匿名类接口

@Test
    public void test1(){
        Runnable r1=new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();
        Runnable r2=()-> System.out.println("这是测试");
        r2.run();
    }

2.方法引用

 @Test
    public void test2(){
        Comparator<Integer> comparable=(o1, o2)->Integer.compare(o1,o2);
        int compare2=comparable.compare(32,21);
        System.out.println(compare2);
        Comparator<Integer> c2=Integer::compare;
        int c3=c2.compare(22,12);
        System.out.println(c3);
    }

4.Lambda表达式

格式：->:Lambda操作符或箭头操作符
(形参列表)->方法体
形参列表：类型可以省略(类型推断)，如果只有一个参数，其一对()也可以省略
方法体：如果方法体只有一条执行语句(可能是return语句)，可以省略这一对括号{}和return关键字
1.不需要参数，但需要返回值
Runnable r2=()-> System.out.println(“这是测试”);
r2.run();
2.需要参数，但是没有返回值

   @Test
    public void test3(){
        Consumer<String> con=new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("test");
        Consumer<String> con1=(String s)->{ System.out.println(s); };
        con1.accept("test");
    }

3.类型推断

   @Test
    public void test4(){
        Consumer<String> con1=(s)->{ System.out.println(s); };
        con1.accept("test");
    }

4.若只需要一个参数时，参数的小括号可以省略

   Consumer<String> con2=s->{ System.out.println(s); };
    con2.accept("test"); 

5.需要两个或以上的参数，多条执行语句，并且可以有返回值

@Test
public void test5(){
    Comparator<Integer> com2=(o1,o2)->{
        System.out.println(o1);
        System.out.println(o2);
        return o1.compareTo(o2);
    };
} 

6.当Lambda体只有一条语句时，return 与大括号若有，都可以省略

@Test
public void test5(){
    Comparator<Integer> com2=(o1,o2)->o1.compareTo(o2);
}

5.什么是函数式接口？

如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口
自定义样例类：

@FunctionalInterface
public interface MyInterface {
    void info();
}

在java.util.function包下定义了Java8的丰富的函数式接口

6.Java中的Lambda表达式和其他面向函数编程的函数式编程有什么不一样？

在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。
 简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。

7.Java内置四大核心函数式接口有哪些？

1.Consumer
void accept(T var1);

  @Test
    public void test1(){
        happyTime(500,momey-> System.out.println("学习值得"+momey));
    }
    public void happyTime(double momey, Consumer<Double> con){
        con.accept(momey);
    } 

2.Supplier
T get()
3.Function<T, R>
R apply(T t)
4.Predicate

 boolean test(T t)
      @Test
    public void test2(){
        List<String> list= Arrays.asList("北京","南京","天津","东京","西京");
        List list2=filterString(list, s->s.contains("京"));
        System.out.println(list2);
    }
    public List<String> filterString(List<String> list, Predicate<String> pre){
        ArrayList<String> filterList=new ArrayList<>();
        for(String s:list){
            if(pre.test(s)){
                filterList.add(s);
            }
        }
        return filterList;
    }