Java接口的函数式接口----Lanbda函数

接口是不是函数式接口，即是不是有且仅有一个抽象方法

package jieKou;
@FunctionalInterface//注解，帮助检查接口是不是函数式接口，即是不是有且仅有一个抽象方法
interface Animals{//无返回值无参数形式
 void eat();//就这一个抽象方法，所以函数式接口
}


public class Use_Lambda {
  public static void main(String[] args) {
   tryIt(()->{//方法的实现用Lambda进行实现，而且本类中的静态方法直接调用
    System.out.println("Lambda函数实现");
   });//此时语句体中只有一条语句，可以将{}省略不写

//另一种方法
   Master st = new Master();
   st.tryIt2(()->System.out.println("另一种方法的实现"));


//最简单的方法
   Animals mal = ()->System.out.println("简单方法的实现");
   mal.eat();
}

public static void tryIt (Animals m){
   m.eat();
  }  
}
//针对上面将方法tryIt写在同一个类中进行调用，看一下另一种方法
//即通过创建一个类，通过类的对象进行引用
class Master{
 public  void tryIt2(Animals mm){
  mm.eat();
 }
}

无返回值的函数式接口：

package jieKou;
@FunctionalInterface//注解，帮助检查接口是不是函数式接口，即是不是有且仅有一个抽象方法
interface Animalsss{//无返回值无参数形式
 void eat();
}
interface AA{//无返回值有一个参数形式
 void a(int ab);
}
interface BB{//无返回值有多个参数形式
 void b(int a,int b);
}


public class Use_Lambda3 {
  public static void main(String[] args) {
   tryIt(()->System.out.println("Lambda函数实现"));

   AA aa = ab->System.out.println(ab);
   aa.a(50);//ab=50;

   BB bb = (a,b)->System.out.println(a+b);
   bb.b(10,34);

   tryIt2(aa,88);
  }

public static void tryIt (Animalsss m1){
   m1.eat();
  }
  public static void tryIt2 (AA aa,int abc){//利用方法直接传参         
   aa.a(abc);
  }
}

有返回值的函数式接口：

//实现Lanbda函数的第一种形式
package jieKou;
@FunctionalInterface//注解，帮助检查接口是不是函数式接口，即是不是有且仅有一个抽象方法
interface QQQ{//有返回值无参数形式
 int q();
}
interface AAA{//有返回值有一个参数形式
 int a(int a);
}
interface BBB{//有返回值有多个参数形式
 int b(int a,int b);
}


public class Use_Lambda4 {
  public static void main(String[] args) {
   System.out.println(tryIt(()->100));//当语句体只有一条的时候可以删除{}，当这个语句体是return语句时，可省略return

   AAA aa = ab->ab;
   System.out.println(aa.a(50));//ab=50;

   BBB bb = (ab,bc)->ab+bc;
   System.out.println(bb.b(10,34));//ab=10;bc=34;

   System.out.println(tryIt2(aa,88));
  }

  public static int tryIt (QQQ m1){
   return m1.q();
  }
  public static int tryIt2 (AAA am,int ad){//利用方法直接传参         
   return am.a(ad);
  }
}

接口中书写构造方法：

package jieKou;

interface A{
 Person pp();
}
interface B{
 Person pp(String name, int age);
}


class Person{
 private String name;
 private int age;
 public Person() {
  System.out.println("无参构造方法执行了");
 }
 public Person(String name, int age) {
  this.name = name;
  this.age = age;
  System.out.println(getName()+getAge());
 }
 public String getName() {
  return name;
 }
 public int getAge() {
  return age;
 }
}



public class Use_Lambda5 {
  public static void main(String[] args) {
   //Lambda表达式
   A aa = ()->new Person();//调用Person类无参的构造方法
   aa.pp();
   //构造方法引用
   A aaa = Person::new;
   aaa.pp();

   B bb = (a,b)->new Person(a,b);
   bb.pp("杨过",22);
   B bbb = Person::new;
   bbb.pp("王博", 21);
  } 
}