java函数编程 原理 java 函数式编程 教程

1.函数式编程有三个部分：

第一个部分是：Lambda表达式

第二个部分是：方法引用

第三个部分是：函数式接口

刚接触Lambda表达式的我，觉得它很神奇，能够用简短的代码，代替传统的编程方式

举一个简单的栗子：

我们要实现一个接口中的方法：第一种方式是：先定义一个类实现接口，重写其方法，然后实例化这个类的对象，调用这个方法；

 

 

第二种方式是：通过内部类的方式实现

 

现在就到Lambda闪亮登场了：

 

 先定义一个静态的方法，形参是那个接口，然后在静态方法中调用接口的方法

Lambda表达式的使用前提是：要有一个接口，接口中有且仅有一个方法

如果Lambda中只有一条执行语句的时候，可以将{}和;省略

 

 

代码内容：

public interface Eatable {
    void eat();
 }public class Eattest implements Eatable{
    @Override
     public void eat() {
         System.out.println("我很喜欢吃烤鸡");
         
     }public class Test2 {
    public static void main(String[] args) {
         //通过实例化类，多态来实现
         Eatable e=new Eattest();
         eatdemo(e);
         
         //通过内部类实现
         eatdemo(new Eatable() {
             
             @Override
             public void eat() {
                 System.out.println("我喜欢吃炸鸡");
             }
         });
         
         //通过Lambda实现
         eatdemo(() ->{
             System.out.println("我好喜欢吃炸鸡");
         });
         //等同于
         eatdemo(()->System.out.println("我好喜欢吃炸鸡"));
     }
     
     private static void eatdemo(Eatable e) {
         e.eat();
     }
 }

Lambda的第二部分：书写的省略

1.1可以省略参数类型 比如：

flytest((String s) ->{
             System.out.println(s);
         });
         //可以省略参数类型
         flytest((s) ->{
             System.out.println(s);
         });

1.2如果要省略参数类型，必须所有的参数类型都省略

比如：        

addtest((x,int y) ->{
             return x+y;
         });

这种写法是错误的，会报错的

必须都省略：

addtest((x,y) ->{
             return x+y;
         });

2.1如果只有一个参数的时候，可以省略()

flytest(s->{
             System.out.println(s);
         });

2.2如果代码块的语句只有一条，可以省略{}和;

flytest(s->System.out.println(s));

3.如果代码块的语句只有一条，可以省略{}和;如果有return,可以将其省去

addtest((x,y) ->x+y);

代码演示：

//加法接口
public interface Add {
    int add(int x,int y);
 }//行为动作接口
public interface Flyable {
    void fly(String s);
 }

在main方法中实现

public class Show {
    public static void main(String[] args) {
         flytest((String s) ->{
             System.out.println(s);
         });
         //可以省略参数类型
         flytest((s) ->{
             System.out.println(s);
         });
         
         //如果要省略参数类型，必须所有的参数类型都省略
 //        错误的
 //        addtest((x,int y) ->{
 //            return x+y;
 //        });
         
         //如果只有一个参数的时候，可以省略()
         flytest(s->{
             System.out.println(s);
         });
         
         //如果代码块的语句只有一条，可以省略{}和;
         flytest(s->System.out.println(s));
         
         //如果代码块的语句只有一条，可以省略{}和;如果有return,可以将其省去
         addtest((x,y) ->x+y);
         
     }
     
     private static void flytest(Flyable f) {
         f.fly("那种小鸟在天上飞！");
     }
     private static void addtest(Add a) {
         int sum=a.add(50, 100);
         System.out.println(sum);
     }
 }

谢谢你的观看！