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

谢谢你的观看！