Eine kurze Diskussion zur funktionalen Programmierung in Java 8

Es wurde viel über „Java 8 bringt funktionale Programmierung nach Java“ diskutiert, aber was bedeutet diese Aussage wirklich?

In diesem Artikel wird der Funktionalismus und seine Bedeutung als Sprache oder Programmiermethode erörtert. Bevor wir auf die Frage „Wie ist funktionale Programmierung in Java 8?“ antworten, werfen wir einen Blick auf die Entwicklung von Java, insbesondere auf sein Typsystem. Wir werden sehen, wie die neuen Funktionen von Java 8, insbesondere Lambda-Ausdrücke, die Landschaft von Java verändert haben. Und bietet die Hauptvorteile des funktionalen Programmierstils.

Was ist eine funktionale Programmiersprache?

Der Kern einer funktionalen Programmiersprache besteht darin, dass sie Code auf die gleiche Weise verarbeitet wie Daten. Das bedeutet, dass Funktionen erstklassige Werte sein sollten und sich Variablen zuweisen, an Funktionen übergeben lassen usw.

Tatsächlich gehen viele funktionale Sprachen darüber hinaus und behandeln Berechnungen und Algorithmen als wichtiger als die Daten, mit denen sie arbeiten. Einige dieser Sprachen möchten Programmstatus und Funktionen trennen (auf eine Art und Weise, die ein wenig im Gegensatz zu objektorientierten Sprachen erscheint, die sie normalerweise enger miteinander verbinden).

Die Programmiersprache Clojure ist ein solches Beispiel. Obwohl Clojure auf einer klassenbasierten virtuellen Java-Maschine läuft, ist Clojure im Wesentlichen eine funktionale Sprache und stellt Klassen und Objekte in Hochsprachen-Quellprogrammen nicht direkt zur Verfügung (obwohl). es bietet eine gute Interoperabilität mit Java).

Unten ist eine Clojure-Funktion dargestellt, die zum Verarbeiten von Protokollen verwendet wird. Es handelt sich um einen Bürger erster Klasse und muss nicht an eine Klasse gebunden sein, um zu existieren.

(defn build-map-http-entries [log-file]
 (group-by :uri (scan-log-for-http-entries log-file)))

Wenn ein Programm in einer Funktion geschrieben wird, gibt es für eine bestimmte Eingabe immer die gleiche Ausgabe zurück (unabhängig von anderen Zuständen im Programm) und hat keine anderen Auswirkungen oder ändert den Programmzustand. In diesem Fall ist funktionale Programmierung am nützlichsten. Sie verhalten sich wie mathematische Funktionen, und Funktionen, die diesem Kriterium folgen, werden manchmal als „reine“ Funktionen bezeichnet.

Der große Vorteil reiner Funktionen besteht darin, dass sie leichter zu begründen sind, da ihre Operationen nicht vom externen Zustand abhängen. Funktionen können problemlos miteinander kombiniert werden, was in Entwickler-Workflow-Stilen üblich ist, wie beispielsweise dem REPL-Stil (Read, Execute, Print, Loop), der in Lisp-Dialekten und anderen Sprachen mit einer starken funktionalen Tradition üblich ist.

Funktionale Programmierung in nicht-funktionalen Programmiersprachen

Ob eine Sprache funktional ist oder nicht, ist keine Entweder-Oder-Situation. Tatsächlich existieren Sprachen in einem Diagramm. Ganz am Ende wird grundsätzlich die funktionale Programmierung erzwungen, die häufig veränderbare Datenstrukturen verbietet. Clojure ist eine Sprache, die keine veränderlichen Daten akzeptiert.

Es gibt jedoch auch einige andere Sprachen, die normalerweise funktional programmieren, die Sprache erzwingt dies jedoch nicht. Scala ist ein Beispiel für eine hybride objektorientierte und funktionale Sprache. Ermöglicht Funktionen als Werte, zum Beispiel:

val sqFn = (x: Int) => x * x

unter Beibehaltung der Klassen- und Objektsyntax, die der von Java sehr nahe kommt.

Im anderen Extrem ist es natürlich möglich, funktionale Programmierung in einer völlig nicht-funktionalen Sprache wie C durchzuführen, solange entsprechende Programmierrichtlinien und -konventionen eingehalten werden.

Vor diesem Hintergrund sollte funktionale Programmierung als Funktion zweier Faktoren betrachtet werden, von denen einer mit der Programmiersprache zusammenhängt und der andere das in dieser Sprache geschriebene Programm ist:

1 ) Inwieweit unterstützt oder erzwingt die zugrunde liegende Programmiersprache die funktionale Programmierung?

2) Wie nutzt dieses spezielle Programm die von der Sprache bereitgestellten Funktionsmerkmale? Werden nichtfunktionale Funktionen wie der veränderliche Zustand vermieden?

Einige Geschichte von Java

Java ist eine eigensinnige Sprache, die sehr gut lesbar, für junge Programmierer leicht zu erlernen ist und über langfristige Stabilität und Unterstützbarkeit verfügt. Aber diese Designentscheidungen haben ihren Preis: ausführlichen Code und ein Typsystem, das weniger flexibel ist als andere Sprachen.

Das Typsystem von Java hat sich jedoch im Laufe der Geschichte der Sprache weiterentwickelt, wenn auch relativ langsam. Werfen wir einen Blick auf einige der Formen, die es im Laufe der Jahre angenommen hat.

Javas ursprüngliches Typsystem

Javas ursprüngliches Typsystem ist mehr als 15 Jahre alt. Es ist einfach und klar und die Typen umfassen Referenztypen und Basistypen. Klassen, Schnittstellen oder Arrays sind Referenztypen.

类是Java平台的核心，类是Java平台将会加载、或链接的功能的基本单位，所有要执行的代码都必须驻留于一个类中。

接口不能直接实例化，而是要通过一个实现了接口API的类。

数组可以包含基本类型、类的实例或者其它数组。

基本类型全部由平台定义，程序员不能定义新的基本类型。

从最早开始，Java的类型系统一直坚持很重要的一点，每一种类型都必须有一个可以被引用的名字。这被称为“标明类型（Nominative typing）”，Java是一种强标明类型语言。

即使是所谓的“匿名内部类”也仍然有类型，程序员必须能引用它们，才能实现那些接口类型：

Runnable r = new Runnable() { public void run() { System.out.println("Hello World!"); } };

换种说法，Java中的每个值要么是基本类型，要么是某个类的实例。

命名类型（Named Type）的其它选择

其它语言没有这么迷恋命名类型。例如，Java没有这样的Scala概念，一个实现（特定签名的）特定方法的类型。在Scala中，可以这样写：

x : {def bar : String}

记住，Scala在右侧标示变量类型（冒号后面），所以这读起来像是“x是一种类型，它有一个方法bar返回String”。我们能用它来定义类似这样的Scala方法：

def showRefine(x : {def bar : String}) = { print(x.bar) }

然后，如果我们定义一个合适的Scala对象：

object barBell { def bar = "Bell" }

然后调用showRefine(barBell)，这就是我们期待的事：

showRefine(barBell) Bell

这是一个精化类型（Refinement typing）的例子。从动态语言转过来的程序员可能熟悉“鸭子类型（Duck typing）”。结构精化类型（Structural refinement typing）是类似的，除了鸭子类型（如果它走起来像鸭子，叫起来像鸭子，就可以把它当作鸭子）是运行时类型，而这些结构精化类型作用于编译时。

在完全支持结构精化类型的语言中，这些精化类型可以用在程序员可能期望的任何地方，例如方法参数的类型。而Java，相反地，不支持这样的类型（除了几个稍微怪异的边缘例子）。

Java 5类型系统

Java 5的发布为类型系统带来了三个主要新特性，枚举、注解和泛型。

枚举类型（Enum）在某些方面与类相似，但是它的属性只能是指定数量的实例，每个实例都不同并且在类描述中指定。主要用于“类型安全的常量”，而不是当时普遍使用的小整数常量，枚举构造同时还允许附加的模式，有时候这非常有用。

注解（Annotation）与接口相关，声明注解的关键字是@interface，以@开始表示这是个注解类型。正如名字所建议的，它们用于给Java代码元素做注释，提供附加信息，但不影响其行为。此前，Java曾使用“标记接口（Marker interface）”来提供这种元数据的有限形式，但注解被认为更有灵活性。

Java泛型提供了参数化类型，其想法是一种类型能扮演其它类型对象的“容器”，无需关心被包含类型的具体细节。装配到容器中的类型通常称为类型参数。

Java 5引入的特性中，枚举和注解为引用类型提供了新的形式，这需要编译器特殊处理，并且有效地从现有类型层级结构分离。

泛型为Java的类型系统增加了显著额外的复杂性，不仅仅因为它们是纯粹的编译时特性，还要求Java开发人员应注意，编译时和运行时的类型系统彼此略有不同。

尽管有这些变化，Java仍然保持标明类型。类型名称现在包括List（读作：“List-of-String”）和Map, CachedObject>（“Map-of-Class-of-Unknown-Type-to-CachedObject”），但这些仍然是命名的类型，并且每个非基本类型的值仍是某个类的实例。

Java 6和7引入的特性

Java 6基本上是一个性能优化和类库增强的版本。类型系统的唯一变化是扩大注解角色，发布可插拔注解处理功能。这对大多数开发者没有任何影响，Java 6中也没有真正提供可插拔类型系统。

Java 7的类型系统没有重大改变。仅有的一些新特性，看起来都很相似：

javac编译器中类型推断的小改进。

签名多态性分派（Signature polymorphic dispatch），用于方法句柄（Method handle）的实现细节，而这在Java 8中又反过来用于实现Lambda表达式。

Multi-catch提供了一些“代数数据类型”的小跟踪信息，但这些完全是javac内部的，对最终用户程序员没有任何影响。

Java 8的类型系统

纵观其历史，Java基本上已经由其类型系统所定义。它是语言的核心，并且严格遵守着标明类型。从实际情况来看，Java类型系统在Java 5和7之间没有太大变化。

乍一看，我们可能期望Java 8改变这种状况。毕竟，一个简单的Lambda表达式似乎让我们移除了标明类型：

() -> { System.out.println("Hello World!"); }

这是个没有名字、没有参数的方法，返回void。它仍然是完全静态类型的，但现在是匿名的。

我们逃脱了名词的王国？这真的是Java的一种新的类型形式？

也许不幸的是，答案是否定的。JVM上运行的Java和其它语言，非常严格地限制在类的概念中。类加载是Java平台的安全和验证模式的中心。简单地说，不通过类来表示一种类型，这是非常非常难的。

Java 8没有创建新的类型，而是通过编译器将Lambda表达式自动转换成一个类的实例。这个类由类型推断来决定。例如：

Runnable r = () -> { System.out.println("Hello World!"); };

右侧的Lambda表达式是个有效的Java 8的值，但其类型是根据左侧值推断的，因此它实际上是Runnable类型的值。需要注意的是，如果没有正确地使用Lambda表达式，可能会导致编译器错误。即使是引入了Lambda，Java也没有改变这一点，仍然遵守着标明类型。

Java 8的函数式编程怎么样？

最后，让我们回到本文开头提出的问题，“Java 8的函数式编程怎么样？”

Java 8之前，如果开发者想以函数式风格编程，他或她只能使用嵌套类型（通常是匿名内部类）作为函数代码的替代。默认的Collection类库不会为这些代码提供任何方便，可变性的魔咒也始终存在。

Java 8的Lambda表达式没有神奇地转变成函数式语言。相反，它的作用仍是创建强制的强命名类型语言，但有更好的语法支持Lambda表达式函数文本。与此同时，Collection类库也得到了增强，允许Java开发人员开始采用简单的函数式风格（例如filter和map）简化笨重的代码。

Java 8需要引入一些新的类型来表示函数管道的基本构造块，如java.util.function中的Predicate、Function和Consumer接口。这些新增的功能使Java 8能够“稍微函数式编程”，但Java需要用类型来表示它们（并且它们位于工具类包，而不是语言核心），这说明标明类型仍然束缚着Java语言，它离纯粹的Lisp方言或者其它函数式语言是多么的遥远。

除了以上这些，这个函数式语言能量的小集合很可能是所有大多数开发者日常开发所真正需要的。对于高级用户，还有（JVM或其它平台）其它语言，并且毫无疑问，将继续蓬勃发展。