Lambda（中）常规应用

parm —> overrideMethod 是一个整体

匿名内部类
        Comparator<Apple> appleWeight = new Comparator<Apple>() {
            public int compare(Apple a1, Apple a2){
                 Integer diffWeight = a1.getWeight().compareTo(a2.getWeight());
                 return diffWeight；
            }
        };
        
Lambda表达式
    Comparator<Apple> appleWeight =
    (Apple a1, Apple a2) -> {
    Integer diffWeight = a1.getWeight().compareTo(a2.getWeight())；
    return diffWeight；
   }
    
说明：
    1：Comparator里面有且仅有compare的抽象方法，因此可以使用Lambda式 
    2：参数       放在括号里面  —>  左边的括号   
    3：重写方法  放在            —>  指向的地方

Lambda可省略的部分：
    1：入参的类型
    2：方法体的大括号  以及  Return
    

    public class OmitLambda {    
    
        public static void main(String[] args) {       
            //请在此使用Lambda【标准格式】
            //调用invokeCalc方法来计算120+130的结果        
             invokeCalc(120, 130, (Integer a, Integer b) -> {  return a + b;  });        
       
            //省略写法       
             invokeCalc(120, 130, (a, b) -> a + b); 
        }   
        
        private static void invokeCalc(Integer a, Integer b, Calculator calculator) {        
            Integer result = calculator.calc(a, b);        
             System.out.println("结果是：" + result);    
        }
  }

   //函数式接口注解 一旦使用该注解 在进行编译时会进行检查  
        @FunctionalInterfacepublic 
        interface Calculator {    
            Integer calc(Integer a, Integer b);
            }
            
         由于Calculator里面有且仅有一个抽象方法，
         那么（a,b）会直接对应   calculator这个对象    的唯一抽象方法的入参       
         同时  a+b    直接作为      calculator这个对象   的重写方法

    public class MethedIntroductionLambda {    
    
        public static void main(String[] args) {   
        
        //匿名内部写法
        printString(new Printable() {    
        @Override    
        public void print(String str) {       
             System.out.println(str);   
            }
        });

        // str作为接口里面唯一抽象方法的data.print的入参        
        // System.out.println(str)作为里面唯一抽象方法的data.print的代码块            
        
        //        显示入参类型
        printString((String str) -> System.out.println(str));
        //        隐藏入参类型
        printString(str -> System.out.println(str));  
        //        方法里面的str去哪里了
        printString(str-> System.out.println());
        
        
        //方法引用//方法只管调用 Printable 接口的 print 方法，
        //而并不管 print 方法的具体实现逻辑会将字符串 打印到什么地方去
        //注意System.out 代表这该类（若有继承关系可以用super调用父类 若调用本类可用this）
        printString(System.out::println);
       }
       
        private static void printString(Printable printable) {                       
            printable.print("Hello, World!");   
       }          
   
}

        @FunctionalInterface
         public interface Printable {  
             void print(String str);
    }
    
    str作为printable这个对象  的唯一抽象方法的入参
    System.out.println(str) 作为printable这个对象 的重写方法变成
    printable.print(String str){
        System.out.println(str)
    }
    
   print("Hello, World!")中的"Hello, World!"    作为参数传入