静态代理及lambda表达式（线程创建补充）

2021-11-29 09:05:06 阅读：90 来源： 互联网

标签：void System public 线程 println class 表达式 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创建无参接口对象的方法

单独写接口的实现类之后，再在主程序中新建对象调用方法

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");
   }
}

静态内部类

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();
}

局部内部类

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();
}

匿名内部类

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的前提是函数式接口
多个参数也可以去掉参数类型，但是要去掉就都去掉，不能有些带类型有些不带，并且要括号包裹多个参数，用逗号隔开

标签：void,System,public,线程,println,class,表达式,lambda
来源： https://blog.csdn.net/weixin_42226721/article/details/121552870

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

静态代理及lambda表达式（线程创建补充）

1.静态代理

2.lambda表达式