函数式编程

函数式编程

目录

• 函数式编程
  • 1.1 函数式编程的演变
  • 1.3 方法引用
    • 1.3.1 Runable

为什么要引入函数式编程：

• 并行编程
• 代码可靠性
• 代码创建和库复用

可以这么理解，面向对象编程抽象数据，函数式编程抽象行为。

简而言之，函数式编程就是将代码作为参数，传递给代码。

1.1 函数式编程的演变

函数式接口：表示只包含一个抽象方法的接口。

Lambda表达式的目标类型是函数式接口。

这里使用一个对数组进行操作的例子，演示了如何使用一段代码，调用了另外一段代码。

涉及到三个阶段：

• 使用函数式接口的具体实现类
• 使用匿名内部类实现的函数式接口
• 使用Lambda表达式

从而演示函数式编程的演变过程。

interface Description {
    String desc();
}

interface Square {
    int square(int a);
}

interface Add {
    int add(int a, int b);
}

public class LambdaExpressions {
    /**
     * 没有参数的情况下，必须使用括号来指示空的参数列表
     */
    static Description desc1 = () -> "No param.";

    /**
     * 单个参数的情况下，可以只写这个参数，不写括号
     */
    static Square square1 = a -> a * a;

    /**
     * 单个参数的情况下，为了保持一致性，也加上括号
     */
    static Square square2 = (a) -> a * a;

    /**
     * 多个参数的情况下，参数列表需要用括号括起来
     */
    static Add add = (a, b) -> a + b;

    /**
     * 如果Lambda表达式需要多行代码，则必须将这些代码放到花括号中
     */
    static Description desc2 = () -> {
        System.out.println("This is a simple description.");
        return "simple description.";
    };
}

任何Lambda表达式的基本语法如下所示：
* 参数列表
* 后面跟->
* ->后面是方法体

还有以下约定：

• 没有参数的情况下，必须使用括号来指示空的参数列表
• 单个参数的情况下，可以只写这个参数，不写括号
• 单个参数的情况下，为了保持一致性，也加上括号
• 多个参数的情况下，参数列表需要用括号括起来
• 如果Lambda表达式需要多行代码，则必须将这些代码放到花括号中
• 如果Lambda表达式只包含一条语句，可以省略花括号和return语句

1.3 方法引用

方法引用指向的是方法。

方法引用是用类名或者对象名，后面跟::，然后跟方法名。

/**
 * 只包含一个方法的接口
 */
interface Callable {
    void call(String s);
}


class Describe {
    void show(String msg) {
        System.out.println(msg);
    }
}


public class MethodReferences {
    static void hello(String name) {
        System.out.println("Hello, " + name);
    }

    static class Description {
        String about;

        Description(String desc) {
            about = desc;
        }

        void help(String msg) {
            System.out.println(about + " " + msg);
        }
    }

    static class Helper {
        static void assist(String msg) {
            System.out.println(msg);
        }
    }

    public static void main(String[] args) {
        Describe d = new Describe();

        /** 调用其他类、相同方法签名的实例方法 */
        Callable c = d::show;
        c.call("Call()");

        /** 调用其他类、相同方法签名的静态方法 */
        c = MethodReferences::hello;
        c.call("Bob");

        /** 调用静态内部类、相同方法签名的实例方法  */
        c = new Description("valuable")::help;
        c.call("information");

        /** 调用静态内部类、相同方法签名的静态方法 */
        c = Helper::assist;
        c.call("help");
    }
}

1.3.1 Runable

可以把Lambda表达式或者方法引用用作Runnable。

/**
 * 作为Runnable接口的方法引用
 */

class Go {
    static void go() {
        System.out.println("Go:go()");
    }
}

public class RunnableMethodReference {
    public static void main(String[] args) {

        /* 使用匿名内部类 */
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Anonymous");
            }
        }).start();

        /* 使用Lambda表达式 */
        new Thread(
                () -> System.out.println("Lambda")
        ).start();

        /* 使用方法引用 */
        new Thread(Go::go).start();
    }
}