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