JAVA高级特性（二）Lambda表达式

Lambda表达式允许使用更简洁的代码来创建只有一个抽象方法的接口(函数式接口)的实例

匿名内部类

public class Banana{
   public static void main(String[] args){
     Banada ban = new Banana();
     //匿名内部类
     ban.sell(new Produce(){
        public String getName(){
          return "香蕉";
        }
     });
     //lambda有三部分组成
     //1:形参列表，可以省略形参类型，如果形参只有一个参数，那么可以省略括号
     //2:箭头
     //3:代码块，如果代码块里面只有一条语句，省略花括号，如果只有一条reutrn语句，可以省略return
     ban.sell(() -> 
         return "香蕉";
     );
　   ban.sell(() -> "香蕉");
   }
}

Lambda表达式

interface Swim{
   public void swim();
}

interface Fly{
  public void fly(String str);
}

interface Addable{
  public int add(int a,int b);
}

public class Duck{
   public void swim(Swim s){
     s.swim();
   }
   public void fly(Fly f){
     f.fly("天空");
   }
   public void add(Addable a){
     System.out.println("鸭子会计算1+2= "+a.add(1,2));
   }
   public static void main(String[] args){
      Duck ck = new Duck();
      //lambda表达式只有一条语句，可以省略花括号
      ck.swim(() -> System.out.println("鸭子在游泳"));
      //lambda表达式的形参只有一个，可以省略圆括号
      ck.fly(f -> {
         System.out.println("鸭子在"+f+"飞的很嗨");
     System.out.println(f+"的景色很美");
      });
      //代码块只有一条语句，可以省略花括号
      //只有一条语句，即使需要返回值，可以省略return
      ck.add((a,b) -> a + b);
   }
}

 

Lambda表达式与函数式接口

Lambda表达式的类型称为“目标类型”----该类型必须是“函数式接口”。函数式接口是可以包含多个默认方法、类方法，但只能声明一个抽象方法的接口。

Lambda表达式只能实现一个方法，因此它只能为只有一个抽象方法的接口（函数式接口）创建对象。

//将Lambda表达式赋值给函数式接口类型的变量
FKTest fk = () -> {
  for(int i = 0 ; i < 100 ; i ++){
     System.out.println();
  }
};
//使用函数式接口对Lambda表达式进行强制类型转换
Object obj2 = (FKTest)() -> {
  for(int i = 0 ; i < 100 ; i ++){
     System.out.println();
  }
};
//将Lambda表达式作为函数式接口类型的参数传给某个方法
lq.eat(()-> System.out.println());

 @FunctionalInterface注解，检查该接口必须是函数式接口，否则编译器会报错

 

方法引用与构造器引用

Lambda表达式的代码块只有一条语句时，还可以在代码块中使用方法引用和构造器引用。

1.引用类方法：

@FunctionalInterface
public interface Converter{
   Integer convert(String from);
   public static void main(String[] args){
     //Converter converter1 = from -> Integer.valueOf(from);//①
     //引用类方法，函数式接口中被实现方法的全部参数传给该类方法作为参数
     //Converter converter1 = Integer::valueOf;//②
     Integer val = converter1.convert("22");
     System.out.println(val);
   }
}

2.引用特定对象的实例方法：

@FunctionalInterface
public interface Converter{
   Integer convert(String from);
   public static void main(String[] args){
     //Converter converter1 = from -> "fkit.org".indexOf(from);//①
     //引用特定对象的实例方法，函数式接口中被实现方法的全部参数传给该方法作为参数
     //Converter converter1 = "fkit.org"::indexOf;//②
     Integer val = converter1.convert("it");
     System.out.println(val);
   }
}

3.引用某类对象的实例方法：

@FunctionalInterface
public interface MyTest{
   String test(String a,int b,int c);
   public static void main(String[] args){
     //MyTest mt = (a,b,c) -> a.substring(b,c);//①
     //引用某类对象的实例方法，函数式接口中被实现方法的第一个参数作为调用者，后面的参数全部传给该方法作为参数
     //MyTest mt = String::substring;//②
     String str = mt.test("abc qwe",2,5);
     System.out.println(str);
   }
}

3.引用构造器：

import javax.swing.JFrame;

@FunctionalInterface
public interface MyTest{
   JFrame win(String title);
   public static void main(String[] args){
     //MyTest mt = (title)-> new JFrame(title);//①
     //引用构造器，函数式接口中被实现方法的全部参数传给该构造器作为参数
     //MyTest mt = JFrame::new;//②
     JFrame jf = mt.win("我的窗口");
     System.out.println(jf);
   }
}