静态代理及lambda表达式(线程创建补充)

1.静态代理

public interface Marry {
    void HappyMarry();
}
//真实对象
public class You implements Marry {
    @Override
    public void HappyMarry() {
        System.out.println("***结婚了,超开心");
    }
}
//代理对象
public class MarryCompany implements Marry {
    //代理谁---->真实目标角色
    private Marry target;
    public MarryCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {

        before();
        this.target.HappyMarry();//真实对象结婚
        after();
    }

    private void after() {
        System.out.println("给婚庆公司清算费用");
    }

    private void before() {
        System.out.println("拍婚纱照,布置婚礼现场");
    }
}
public class staticProxy {
    public static void main(String[] args) {
        //you的代理是MarryCompany,代理对象可以做真实对象以外的事情,真实对象专注于自己的事情就好
//        You you = new You();
//        MarryCompany marryCompany = new MarryCompany(you);
//        marryCompany.HappyMarry();
        new MarryCompany(new You()).HappyMarry();

    }
}

总结:

真实对象和代理对象实现同一个接口
代理对象代理真实的角色
优点:

代理对象可以做很多真实对象做不了的事情
真实对象只需要专注自己的事情就行

2.lambda表达式

2.1函数式接口

任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口

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

2.2创建无参接口对象的方法

  1. 单独写接口的实现类之后,再在主程序中新建对象调用方法
public class LambdaTest01 {
    public static void main(String[] args) {
       Ilike like = new Like();
       like.lambda();
}


//1.定义一个函数式接口,也就是只有一个抽象方法的接口
interface Ilike{
    void lambda();
}

//2.实现类
class Like implements Ilike{
    @Override
    public void lambda() {
        System.out.println("I Like lambda");
   }
}

  1. 静态内部类
public class TestLambda {
 public static void main(String[] args) {
   //2.使用静态内部类
   Ilike ilike2=new like2();
   ilike2.lambda();
 }
 //静态内部类
 static class like2 implements Ilike{
   @Override
   public void lambda() {
       System.out.println("i like lambda2");
   }
 }
}
//1.定义一个函数式接口
interface Ilike{
 void lambda();
}
  1. 局部内部类
public class TestLambda {
  public static void main(String[] args) {
      //3.局部内部类
      class Like3 implements Ilike{
          @Override
          public void lambda() {
              System.out.println("i like lambda3");
          }
      }
      Ilike ilike3=new Like3();
      ilike3.lambda();
  }
}
//1.定义一个函数式接口
interface Ilike{
  void lambda();
}
  1. 匿名内部类
public class TestLambda {
  public static void main(String[] args) {
      //2.匿名内部类,没有类的名称,必须借助父类或者接口
      Ilike ilike4=new Ilike() {
          @Override
          public void lambda() {
              System.out.println("i like lambda4");
          }
      };
      ilike4.lambda();
  }
}
//1.定义一个函数式接口
interface Ilike{
  void lambda();
}

5.lambda简化

/*
* 推导lambda表达式
* */
public class TestLambda {
    public static void main(String[] args) {
        //2.用lambda简化
        Ilike ilike5=()->{
            System.out.println("i like lambda5");
        };
        ilike5.lambda();
    }
}
//1.定义一个函数式接口
interface Ilike{
    void lambda();
}

2.3创建有参接口对象的方法
1.

public class LambdaTest02 {
    public static void main(String[] args) {
        Ilove ilove = new love();
        ilove.lambda(2);
    }
}
interface Ilove{
    void lambda(int a);
}
class love implements Ilove{
    @Override
    public void lambda(int a) {
        System.out.println("I love " + a);
    }
}
public class LambdaTest02 {
    static class love implements Ilove{
        @Override
        public void lambda(int a) {
            System.out.println("I love " + a);
        }
    }
    public static void main(String[] args) {
        Ilove ilove = new love();
        ilove.lambda(3);
    }
}
interface Ilove{
    void lambda(int a);
}

public class LambdaTest02 {
    public static void main(String[] args) {
        class love implements Ilove{
            @Override
            public void lambda(int a) {
                System.out.println("I love " + a);
            }
        }
        Ilove ilove = new love();
        ilove.lambda(4);
    }
}

interface Ilove{
    void lambda(int a);
}
public class LambdaTest02 {
    public static void main(String[] args) {
       new Ilove(){
            @Override
            public void lambda(int a) {
                System.out.println("I love " + a);
            }
        }.lambda(5);
    }
}

interface Ilove{
    void lambda(int a);
}

5.lambda方式

public class LambdaTest02 {
    public static void main(String[] args) {
       Ilove ilove = (int a) -> {
            System.out.println("I love " + a);
        };
       //还可以继续简化,1.简化参数类型
        ilove = (a) -> {
            System.out.println("I love " + a);
        };
        //2.简化括号
        ilove = a -> {
            System.out.println("I love " + a);
        };
        //3.简化花括号(必须只能有一行代码,如果多行则无法简化花括号!)
        ilove = a -> System.out.println("I love " + a);
       ilove.lambda(6);
    }
}

interface Ilove{
    void lambda(int a);
}

总结:

  • .lambda表达式只有一行代码的情况下才能简化为一行,如果有多行,就需要花括号包裹
  • 使用lambda的前提是函数式接口
  • 多个参数也可以去掉参数类型,但是要去掉就都去掉,不能有些带类型有些不带,并且要括号包裹多个参数,用逗号隔开
上一篇:没有语言是完美的


下一篇:lambda矩阵的等价标准型(Smith标准型)