---
title: Konstruktorreferenzen
url: 'https://tutego.de/blog/javainsel/2017/08/konstruktorreferenzen'
markdown: 'https://tutego.de/blog/javainsel/2017/08/konstruktorreferenzen.md'
date: '2017-08-10'
description: 'Um ein Objekt aufzubauen, nutzen wir das Schlüsselwort new. Das führt zum Aufruf eines Konstruktors, dem sich optional Argumente übergeben lassen. Die Java-API deklariert aber auch Typen, von denen sich keine direkten Exemplare mit new aufbauen lassen. Stattdessen gibt es Erzeuger, deren Aufgabe es…'
taxonomy:
  category:
    - 'Java 8'
---

# Konstruktorreferenzen

![Illustration einer tropischen Insel mit Palmen und einem hohen Berg](https://tutego.de/blog/javainsel/user/themes/tutego/images/insel-cover.jpg)# Java Blog für Programmierer

[Java Blog für Programmierer](https://tutego.de/blog/javainsel/)

## Konstruktorreferenzen

10.08.2017 · [Christian Ullenboom](https://tutego.de/blog/javainsel/author/admin/)

Um ein Objekt aufzubauen, nutzen wir das Schlüsselwort new. Das führt zum Aufruf eines Konstruktors, dem sich optional Argumente übergeben lassen. Die Java-API deklariert aber auch Typen, von denen sich keine direkten Exemplare mit new aufbauen lassen. Stattdessen gibt es Erzeuger, deren Aufgabe es ist, Objekte aufzubauen. Die Erzeuger können statische oder auch nichtstatische Methoden sein:

```java
Konstruktor ...... erzeugt:Erzeuger ...... baut:new Integer( "1" )IntegerInteger.valueOf( "1" )Integernew File( "dir" )FilePaths.get( "dir" )Pathnew BigInteger( val )BigIntegerBigInteger.valueOf( val )BigInteger
```

Tabelle 1.4: Beispiele für Konstruktoren und Erzeuger-Methoden

Beide, Konstruktoren und Erzeuger, lassen sich als spezielle Funktionen sehen, die von einem Typ in einen anderen Typ konvertieren. Damit eignen sie sich perfekt für Transformationen, und in einem Beispiel haben wir das schon eingesetzt:

```java
Arrays.stream( words )
       . ...
       .map( Integer::parseInt )
       . ...
```

`Integer.parseInt(string)` ist eine Methode, die sich einfach mit einer Methodenreferenz fassen lässt, und zwar als `Integer`::`parseInt`. Aber was ist mit Konstruktoren? Auch sie transformieren! Statt `Integer.parseInt(string)` hätte ja auch new `Integer`(string) eingesetzt werden können.

Wo Methodenreferenzen statische Methoden und Objektmethoden angeben können, bieten Konstruktorreferenzen die Möglichkeit, Konstruktoren anzugeben, sodass diese als Erzeuger an anderer Stelle übergeben werden können. Damit lassen sich elegant Konstruktoren als Erzeuger angeben, und zwar auch von einer Klasse, die nicht über Erzeugermethoden verfügt. Wie auch bei Methodenreferenzen spielt eine funktionale Schnittstelle eine entscheidende Rolle, doch dieses Mal ist es die Methode der funktionalen Schnittstelle, die mit ihrem Aufruf zum Konstruktoraufruf führt. Wo syntaktisch bei Methodenreferenzen rechts vom Doppelpunkt ein Methodenname steht, ist dies bei Konstruktorreferenzen ein new.[\[1\]](#_ftn1) Also ergibt sich alternativ zu

```java
      .map( Integer::parseInt )       // Methode Integer.parseInt(String)
```

in unserem Beispiel das Ergebnis mittels:

```java
      .map( Integer::new )            // Konstruktor Integer(String)
```

Mit der Konstruktorreferenz gibt es vier Möglichkeiten, funktionale Schnittstellen zu implementieren; die drei verbleibenden Varianten sind Lambda-Ausdrücke, Methodenreferenzen und klassische Implementierung über eine Klasse.

**Beispiel:** Die funktionale Schnittstelle sei:

```java
interface DateFactory { Date create(); }
```

Die folgende Konstruktorreferenz bindet den Konstruktor an die Methode `create()` der funktionalen Schnittstelle:

```java
DateFactory factory = Date::new;
 System.out.print( factory.create() ); // zum Beispiel Sat Dec 29 09:56:35 CET 2012
```

Beziehungsweise die letzten beiden Zeilen zusammengefasst:

```java
System.out.println( ((DateFactory)Date::new).create() );
```

Soll nur der Standard-Konstruktor aufgerufen werden, muss die funktionale Schnittstelle nur eine Methode besitzen, die keinen Parameter besitzt und etwas zurückliefert. Der Rückgabetyp der Methode muss natürlich mit dem Klassentyp zusammenpassen. Das gilt für den Typ `DateFactory` aus unserem Beispiel. Doch es geht noch etwas generischer, zum Beispiel mit der vorhandenen funktionalen Schnittstelle `Supplier`, wie wir gleich sehen werden.

In der API finden sich oftmals Parameter vom Typ `Class`, die als Typangabe dazu verwendet werden, dass über den Constructor der `Class` mit der Methode `newInstance()` Exemplare gebilder werden. Der Einsatz von `Class` lässt sich durch eine funktionale Schnittstelle ersetzen, und Konstruktorreferenzen lassen sich an Stelle von `Class`-Objekten übergeben.

### Standard- und parametrisierte Konstruktoren

Beim Standard-Konstruktor hat die Methode nur eine Rückgabe, bei einem parametrisierten Konstruktor muss die Methode der funktionalen Schnittstelle natürlich über eine kompatible Parameterliste verfügen:

```java
KonstruktorDate()Date(long t)Kompatible funktionale Schnittstelleinterface DateFactory {
Date create();
}interface DateFactory {
Date create(long t);
```

}**Konstruktorreferenz**`DateFactory` factory = Date::new;`DateFactory` factory =

```java
Date::new;Aufruffactory.create();factory.create(1);
```

Tabelle 1.5: Standard- und parametrisierter Konstruktor mit korrespondierenden funktionalen Schnittstellen

**Hinweis:** Kommt die Typ-Inferenz des Compilers an ihre Grenzen, sind zusätzliche Typinformationen gefordert. In diesem Fall werden hinter dem Doppelpunkt in eckigen Klammen weitere Angaben gemacht, etwa Klasse::<Typ1, Typ2>new.

### Nützliche vordefinierte Schnittstellen für Konstruktorreferenzen

Die für einen Standard-Konstruktor passende funktionale Schnittstelle muss eine Rückgabe besitzen und keinen Parameter annehmen; die funktionale Schnittstelle für einen parametrisierten Konstruktor muss eine entsprechende Parameterliste haben. Es kommt nun häufig vor, dass der Konstruktor ein Standard-Konstruktor ist oder genau einen Parameter annimmt. Hier ist es vorteilhaft, dass für diese beiden Fälle die Java-API zwei praktische (generisch deklarierte) funktionale Schnittstellen mitbringt:

Funktionale SchnittstelleFunktions- DeskriptorAbbildungPasst `aufSupplier`<T>T `get()`() → TStandard-KonstruktorFunction<T,R>R `apply(T t)`(T) → Reinfacher parametrisierter Konstruktor

Tabelle 1.6: Vorhandene funktionale Schnittstellen als Erzeuger

**Beispiel:** Die funktionale Schnittstelle `Supplier`<T> hat eine T `get()`-Methode, die wir mit dem Standard-Konstruktor von Date verbinden können:

```java
Supplier factory = Date::new;
 System.out.print( factory.get() );
```

Wir nutzen `Supplier` mit dem Typparameter Date, was den parametrisierten Typ `Supplier`<Date> ergibt, und `get()` liefert folglich den Typ Date. Der Aufruf `factory.get()` führt zum Aufruf des Konstruktors.

#### Ausblick \*

Besonders interessant werden die Konstruktorreferenzen mit den neuen Bibliotheksmethoden der `Stream`-API. Nehmen wir eine Liste vom Typ Zeitstempel an. Der Konstruktor Date(long) nimmt einen solchen Zeitstempel entgegen, und mit einem Date-Objekt können wir Vergleiche vornehmen, etwa ob ein Datum hinter einem anderen Datum liegt. Folgendes Beispiel listet alle Datumswerte auf, die nach dem 1.1.2012 liegen:

```java
Long[] timestamps = { 2432558632L, 1455872986345L };
 Date thisYear = new GregorianCalendar( 2012, Calendar.JANUARY, 1 ).getTime();
 Arrays.stream( timestamps )
       .map( Date::new )
       .filter( thisYear::before )
       .forEach( System.out::println );  // Fri Feb 19 10:09:46 CET 2016
```

Die Konstruktorreferenz Date::new hilft dabei, das long mit dem Zeitstempel in ein Date-Objekt zu konvertieren.

**Denksportaufgabe**: Ein Konstruktor kann als `Supplier` oder `Function` gelten. Problematisch sind mal wieder geprüfte Ausnahmen. Der Leser soll überlegen, ob der Konstruktor `URI`(`String` str) throws `URISyntaxException` über `URI`::new angesprochen werden kann.

[\[1\]](#_ftnref1) Da new ein Schlüsselwort ist, kann keine Methode so heißen; der Identifizierer ist also sicher.

Kategorien: [Java 8](https://tutego.de/blog/javainsel/category/java-8/)

[← Alle Beiträge](https://tutego.de/blog/javainsel/)

---

## Navigation

- Previous: [Was Eclipse bisher bei Java 9 unterstützt](https://tutego.de/blog/javainsel/2017/08/was-eclipse-bisher-bei-java-9-untersttzt.md)
- Next: [java.util.Optional ist keine Nullnummer](https://tutego.de/blog/javainsel/2017/08/java-util-optional-ist-keine-nullnummer.md)
