Java Academy · Les

Verwijzingen naar constructors

Gebruik ClassName::new om instanties te maken via functionele interfaces zoals Supplier en Function.

Les 4 van 413 stappen

Verwijzingen naar constructors is een gratis Java Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.

Wat zijn constructorreferenties?

Een constructorreferentie gebruikt ClassName::new om objecten te maken via een functionele interface. De parameters van de functionele interface komen overeen met de parameters van de constructor.

import java.util.function.*;

class Person {
    String name;
    Person(String name) { this.name = name; }
    public String toString() { return "Person(" + name + ")"; }
}

// Function<String, Person> — calls Person(String)
Function<String, Person> factory = Person::new;
Person p = factory.apply("Alice");
System.out.println(p); // Person(Alice)

Constructor zonder argumenten als Supplier

Een constructor zonder argumenten past bij Supplier<T>:

class Counter {
    int count = 0;
    void inc() { count++; }
}

Supplier<Counter> newCounter = Counter::new;
Counter c1 = newCounter.get();
Counter c2 = newCounter.get(); // independent instances
c1.inc();
System.out.println(c1.count); // 1
System.out.println(c2.count); // 0

Constructor met twee argumenten als BiFunction

Constructors met twee parameters passen bij BiFunction<T,U,R>:

record Point(int x, int y) {}

BiFunction<Integer, Integer, Point> makePoint = Point::new;
Point p = makePoint.apply(3, 4);
System.out.println(p); // Point[x=3, y=4]

Constructorreferentie in Stream.map

Converteer tekenreeksen naar objecten met een constructorreferentie:

import java.util.*;
import java.util.stream.*;

List<String> names = List.of("Alice","Bob","Carol");

List<Person> people = names.stream()
    .map(Person::new)  // calls new Person(name) for each
    .collect(Collectors.toList());

people.forEach(System.out::println);
// Person(Alice)
// Person(Bob)
// Person(Carol)

Constructorreferentie voor arrays

Maak dynamisch arrays met Type[]::new. Dit wordt gebruikt door Stream.toArray():

import java.util.stream.*;

String[] arr = Stream.of("a","b","c")
    .toArray(String[]::new);

for (String s : arr) System.out.print(s + " ");
// a b c

int[] sizes = {3, 5, 2};
String[][] matrix = Arrays.stream(sizes)
    .mapToObj(String[]::new)
    .toArray(String[][]::new);

Patroon voor een fabrieksinterface

Definieer een aangepaste functionele interface voor fabrieken en gebruik daarna constructorreferenties:

@FunctionalInterface
interface Factory<T> {
    T create(String config);
}

class DBConnection {
    String url;
    DBConnection(String url) { this.url = url; }
    public String toString() { return "DB(" + url + ")"; }
}

Factory<DBConnection> dbFactory = DBConnection::new;
DBConnection conn = dbFactory.create("jdbc:postgresql://localhost/mydb");
System.out.println(conn);

Afhankelijkheidsinjectie met constructorreferenties

Frameworks gebruiken vaak functionele fabrieken voor uitgestelde instantiecreatie. Constructorreferenties maken dit patroon overzichtelijk:

import java.util.function.*;

class ServiceLocator {
    private final Map<String, Supplier<?>> registry = new HashMap<>();
    
    <T> void register(String name, Supplier<T> factory) {
        registry.put(name, factory);
    }
    
    @SuppressWarnings("unchecked")
    <T> T get(String name) { return (T) registry.get(name).get(); }
}

ServiceLocator loc = new ServiceLocator();
loc.register("counter", Counter::new);
Counter c = loc.get("counter");

Kiezen tussen een lambda en een constructorreferentie

Gebruik een constructorreferentie wanneer de body van de lambda alleen new Type(args) is:

// Lambda:
Function<String, Person> f1 = name -> new Person(name);

// Constructor reference (preferred):
Function<String, Person> f2 = Person::new;

// When you need extra logic, stick with lambda:
Function<String, Person> f3 = name -> new Person(name.trim().toLowerCase());

Generieke typen en constructorreferenties

Generieke klassen werken ook — het type wordt afgeleid uit de context van de functionele interface:

import java.util.*;
import java.util.function.*;

// ArrayList::new matches Supplier<ArrayList<String>>
Supplier<List<String>> listFactory = ArrayList::new;
List<String> l1 = listFactory.get();
List<String> l2 = listFactory.get(); // independent lists
l1.add("hello");
System.out.println(l2.size()); // 0

Stream-verzamelaars met constructorreferenties

Gebruik constructorreferenties in verzamelaars om aangepaste resultaatcontainers te bouwen:

import java.util.stream.*;

// Collect into a LinkedList using a constructor reference supplier
LinkedList<String> linked = Stream.of("a","b","c")
    .collect(Collectors.toCollection(LinkedList::new));
System.out.println(linked.getFirst()); // a

Primitieve typen en autoboxing

Constructorreferenties voor wrappertypen verwerken autoboxing:

// Integer::new is deprecated in Java 9+, but illustrates the concept
// Use Integer.valueOf or just autoboxing in modern Java
Function<String, Integer> intParser = Integer::parseInt; // static method ref
System.out.println(intParser.apply("42")); // 42

Korte controle

Bij welke functionele interface past een constructorreferentie zonder argumenten zoals ArrayList::new?

Beantwoord dit in de interactieve les

Samenvatting: constructorreferenties

Belangrijkste punten:

Syntax: ClassName::new — delegeert naar de overeenkomende constructor
Zonder argumenten → Supplier<T>; één argument → Function<T,R>; twee argumenten → BiFunction
Arrayconstructor: Type[]::new — gebruikt met Stream.toArray()
Overzichtelijker dan een lambda wanneer de body alleen 'new Type(args)' is
Gebruik Collectors.toCollection(LinkedList::new) voor getypeerde verzamelingsresultaten

Gratis beginnen

Leer Java met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 104
Lessen: 374

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Verwijzingen naar constructors” gratis?

Ja — de volledige tekst van “Verwijzingen naar constructors” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.

Wat leer ik in “Verwijzingen naar constructors”?

Gebruik ClassName::new om instanties te maken via functionele interfaces zoals Supplier en Function. Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Java Academy te beginnen?

Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Verwijzingen naar constructors”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Java Academy?

Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Verwijzingen naar statische methoden
Verwijzingen naar instantiemethoden van een specifieke instantie
Verwijzingen naar instantiemethoden zonder specifieke instantie
Verwijzingen naar constructors

← Terug naar Java Academy