java复习（三）

静态代理

注意与Thread对比
代理：不改变实现类的情况下，对实现类进行功能的增加
静态 所谓的静态就是在创建代理类的时候，接口和被代理类都已经被固定了，无法改变，代理类就只能这一种类

1.真实对象和代理对象实现同一个接口
2.代理对象要代理真实角色

静态代理的步骤

1.定义共同的主题接口（以找工作为例）

interface Find_work {
    void findwork();
}

2。定义该接口的实现类，被代理对象

class Person implements Find_work{
    @Override
    public void findwork() {
        System.out.println("投简历");
    }
}

3.创建上述实现类的代理类（两个类需要实现共同的主题接口，这样才能对原有功能进行增强）

class share implements  Find_work{
    private Find_work find_work;
    public share(Find_work find_work) {
        this.find_work = find_work;
    }
    //需要传入被代理的对象，才可以new
    @Override
    public void findwork() {
        System.out.println("before。。。");
        System.out.println("投简历");
        System.out.println("HR审查");
        System.out.println("面试通知");
        System.out.println("after。。。");
        //进行功能增强
    }
}

测试及返回结果

 @Test
    public void test(){
        Find_work find_work=new Person();//多态，接口new实现类
        share share = new share(find_work);
        share.findwork();
    }

Lambda表达式

函数式接口

任何一个接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口
函数式接口是jdk1.8Lambda表达式的关键；
对于函数式接口，我们可以通过Lambda创建该接口的对象

为什么使用Lambda

1.避免匿名内部类 过多
2.去掉无意义代码，只留核心代码
3.使代码 更简洁

Lambda演化

//lambda表达式的演化过程
public class TestLambda {
    //2.静态内部类
     static class LambdaDaoImpl02 implements LambdaDao{
        @Override
        public void print() {
            System.out.println("Lambda02");
        }
    }
    public static void main(String[] args) {
        //1.正常调用
        LambdaDao lambdaDao=new LambdaDaoImpl();
        lambdaDao.print();
        //2.静态内部类
        lambdaDao = new LambdaDaoImpl02();
        lambdaDao.print();
        //3.局部内部类
        class LambdaDaoImpl03 implements LambdaDao{
            @Override
            public void print() {
                System.out.println("Lambda03");
            }
        }
        lambdaDao = new LambdaDaoImpl03();
        lambdaDao.print();
        //4.匿名内部类  ----没有类的名称，必须借助接口和父类
        lambdaDao=new LambdaDao() {
            @Override
            public void print() {
                System.out.println("Lambda04");
            }
        };
        lambdaDao.print();
        //5.简化为Lambda表达式----因为只有接口内的一个方法，可将4的接口和方法名省略，只要方法体
        lambdaDao = ()->{
            System.out.println("Lambda05");
        };
    }
}
//定义函数式接口
interface LambdaDao{
    public abstract void print();
}
//定义接口实现类
class LambdaDaoImpl implements LambdaDao{
    @Override
    public void print() {
        System.out.println("Lambda01");
    }
}

lanmbda表达式简化

public class TestLambda01 {

    public static void main(String[] args) {
        //1.Lanbda
        LambdaDao01 lambdaDao01 = new LambdaDaoImpl01();
        lambdaDao01 =(int a)->{
            System.out.println("Lambda"+a);
        };
        lambdaDao01.print(0);
        //1 简化参数类型
        lambdaDao01 =(a)->{
            System.out.println("Lambda"+a);
        };
        lambdaDao01.print(1);
        //2 简化括号----如果有多个参数，可以去掉参数类型（顺序要对应），但不能省略括号  如（a，b）
        lambdaDao01 =a->{
            System.out.println("Lambda"+a);
        };
        lambdaDao01.print(2);
        //3 渠道花括号----如果方法体有多行，不能简化花括号
        lambdaDao01 =a-> System.out.println("Lambda"+a);
        lambdaDao01.print(3);


    }
}
//定义函数式接口
interface LambdaDao01{
    public abstract void print(int a);
}

//定义接口实现类
 class LambdaDaoImpl01 implements LambdaDao01{
    @Override
    public void print(int a) {
        System.out.println("Lambda"+a);
    }
}