【金秋打卡】第七天+Lmabda方法引用

课程名称：一课掌握Lambda表达式语法及应用

课程章节：第四章第一节

主讲老师：大牧莫邪

课程内容：

1. 2变量捕获

   public class APP2 {
       String s1 = "全局变量";
   
       //匿名内部类对于变量的访问
       public void testInnerClass(){
           String s2 = "局部变量";
   
           new Thread(new Runnable() {
               String s3 = "内部变量";
               @Override
               public void run() {
                   //访问全局变量
                   System.out.println(s1); //不能用this，this表示当前内部类的对象；
                   //局部变量的访问
                   System.out.println(s2); // 不能对局部变量进行数据的修改[final]
                   //内部变量的访问
                   System.out.println(s3);
                   System.out.println(this.s3);
               }
           }).start();
       }
   
       //Lambda表达式捕获变量
       public void testLambda(){
           String s2 = "局部变量Lmabda";
   
           new Thread(() -> {
               String s3 = "内部变量Lmabda";
   
               //访问全局变量
               System.out.println(this.s1);  //this~表示的就是所属方法所在类型的对象
               //访问局部变量
               System.out.println(s2);  //不能修改s2，默认推到为修饰符为final
               //访问内部变量
               System.out.println(s3); //可以直接访问，可以直接修改
           }).start();
       }
   
       public static void main(String[] args) {
           APP2 app2 = new APP2();
           app2.testInnerClass();
   
           app2.testLambda();
       }
   }

   3Lambda表达式类型检查

   public class APP3 {
   
       public static void test(MyInterface<String, List > inter) {
           List<String> list = inter.strange("hello", new ArrayList());
           System.out.println(list);
       }
   
       public static void main(String[] args) {
           //普通模式
           test(new MyInterface<String, List>() {
               @Override
               public List strange(String s, List list) {
                   list.add(s);
                   return list;
               }
           });
   
           //Lambda模式
           test((x, y) -> {
               y.add(x);
               return y;
           });
       }
   
   }
   
   /**
    * (x ,y)->{..}  --> test(param) --> param == MyInterface --> lambda表达式 -> MyInterface类型
    * 这个就是对lambda表达式的类型检查，MyInterface接口就是lambda表达式的目标类型(target typing)
    *
    * (x,y) -> {..} --> MyInterface.strange(T t, R r) -->MyInterface<String, List> inter -->
    *  T == String , R == List -->lambda --> (x,y) == strange(T t, R r) --> x==T==String y==R==List
    *
    *  以上就是lambda表达式的类型检查
    */
   
   @FunctionalInterface
   interface MyInterface<T, R>{
       R strange(T t, R r);
   }
   

   
   

   1. 匿名内部类的变量捕获

   2. Lambdab表达式中的变量捕获

   3. 看两者的区别，更好理解Lambda的优势

4方法重载和Lambda表达式

1. javal类型系统中重载的实现

2. 方法重载的实现

3. 当方法重载遇上Lambdab表达式

   public class APP4 {
       interface param1{
           void outInfo(String info);
       }
       interface param2{
           void outInfo(String info);
       }
   
       //定义重载方法
       public void lambdaMethod(param1 param1){
           param1.outInfo("hello one");
       }
       public void lambdaMethod(param2 param2){
           param2.outInfo("hello two");
       }
   
       public static void main(String[] args) {
           APP4 app4 = new APP4();
           app4.lambdaMethod(new param1() {
               @Override
               public void outInfo(String info) {
                   System.out.println(info);
               }
           });
   
           app4.lambdaMethod(new param2() {
               @Override
               public void outInfo(String info) {
                   System.out.println("--------------------");
                   System.out.println(info);
               }
           });
   
           /**
            * lambda表达式存在类型检查 -> 自动推导lambda表达式的目标类型
            * lambdaMehtod() -> 方法 ->重载方法
            *                -> param1 函数式接口
            *                -> param2 函数式接口
            *                调用方法 -> 传递lambda表达式 -> 自动推导
            *                -> param1 | param2
            */
           app4.lambdaMethod((String info) ->{
               System.out.println(info);
           });
       }
   }

5:Lambda表达式方法引用

1. 方法引用是Lambda表达式的一种语法特性

2. 静态方法引用

3. 实例方法引用

4. 构造方法引用

5. @Data                  // get和set方法
   @AllArgsConstructor    //有参构造方法
   @NoArgsConstructor     //无参构造方法
   class person{
       private String name;
       private String sex;
       private int age;
   
       public static int compareByAge(person p1, person p2){
           return p1.age - p2.age;
       }
   }
   
   class PersonUtil{
       //增加一个实例方法
       public int compareByName(person p1, person p2){
           return p1.getName().hashCode() - p2.getName().hashCode();
       }
   }
   
   /**
    * 1:静态方法的引用
    * 类型名称、方法名称() --> 类型名称：：方法名称
    *
    * 2：实例方法引用的使用
    * 创建类型对应的一个对象  -->  对象应用::实例方法名称
    */
   public class Test {
       public static void main(String[] args) {
           //存储person对象列表
           List<person> personList = new ArrayList<person>();
           personList.add(new person("tom", "man", 17));
           personList.add(new person("tom", "man", 18));
           personList.add(new person("tom", "man", 19));
           personList.add(new person("tom", "man", 20));
   
           // 1:匿名内部类的实现方式
           Collections.sort(personList, new Comparator<person>() {
               public int compare(person o1, person o2) {
                   return o1.getAge() - o2.getAge();
               }
           });
   //        System.out.println(personList);
           //2：Lambda表达式的实现方式
           Collections.sort(personList, (p1,p2) -> p1.getAge() - p2.getAge());
   //        System.out.println(personList);
           //3：静态方法的引用
           Collections.sort(personList, person::compareByAge);
           System.out.println(personList);
           //4：实例方法引用
           PersonUtil pu = new PersonUtil();
           Collections.sort(personList, pu::compareByName);
           System.out.println("tom".hashCode());
           System.out.println("jerry".hashCode());
           System.out.println(personList);
           //5：构造方法引用
           IPerson ip = person::new;
           person person = ip.initPerson("jerry","man",18);
           System.out.println(person);
       }
   }
   
   interface IPerson{
       //抽象方法：通过类型的构造方法初始化对象数据
       person initPerson(String name,String gender, int age);
   }

课程收获：

Lambda表达式要学的东西太多了，全程光剩下记载了，在这正好做个笔记，这样以后也方便我查询浏览复习，Lambda对于初学者太不友好了，门道真多啊！，不过学东西的感觉，真爽！

革命还未成功，同志还需努力啊！