Java Academy · leksjon

Konstruktørreferanser

Bruk ClassName::new til å opprette instanser via funksjonelle grensesnitt som Supplier og Function.

Leksjon 4 av 413 trinn

Konstruktørreferanser er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva er konstruktørreferanser?

En konstruktørreferanse bruker ClassName::new til å opprette objekter via et funksjonelt grensesnitt. Parameterne i det funksjonelle grensesnittet samsvarer med konstruktørens parametere.

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)

Konstruktør uten argumenter som Supplier

En konstruktør uten argumenter samsvarer med 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

Konstruktør med to argumenter som BiFunction

Konstruktører med to parametere samsvarer med 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]

Konstruktørreferanse i Stream.map

Konverter strenger til objekter ved hjelp av en konstruktørreferanse:

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)

Konstruktørreferanse for array

Opprett arrayer dynamisk med Type[]::new. Dette brukes av 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);

Mønster for fabrikkgrensesnitt

Definer et egendefinert funksjonelt grensesnitt for fabrikker, og bruk deretter konstruktørreferanser:

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

Avhengighetsinjeksjon med konstruktørreferanser

Rammeverk bruker ofte funksjonelle fabrikker for lat instansiering. Konstruktørreferanser gjør dette mønsteret ryddig:

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

Valg mellom lambda og konstruktørreferanse

Bruk en konstruktørreferanse når lambda-kroppen bare er new Type(args):

// 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());

Generiske typer og konstruktørreferanser

Generiske klasser fungerer også – typen utledes fra konteksten til det funksjonelle grensesnittet:

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

Strømsamlere med konstruktørreferanser

Bruk konstruktørreferanser i samlere for å bygge egendefinerte resultatbeholdere:

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

Primitive typer og autoboxing

Konstruktørreferanser for wrapper-typer håndterer 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

Hurtigsjekk

Hvilket funksjonelt grensesnitt samsvarer en konstruktørreferanse uten argumenter, som ArrayList::new, med?

Besvar den i den interaktive leksjonen

Oppsummering: Konstruktørreferanser

Viktigste punkter:

Syntaks: ClassName::new – delegerer til den samsvarende konstruktøren
Uten argumenter → Supplier<T>; ett argument → Function<T,R>; to argumenter → BiFunction
Arraykonstruktør: Type[]::new – brukes med Stream.toArray()
Ryddigere enn lambda når lambda-kroppen bare er 'new Type(args)'
Bruk Collectors.toCollection(LinkedList::new) for typede samlingsresultater

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 104
Leksjoner: 374

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Konstruktørreferanser» gratis?

Ja – hele teksten i «Konstruktørreferanser» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Konstruktørreferanser»?

Bruk ClassName::new til å opprette instanser via funksjonelle grensesnitt som Supplier og Function. Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Konstruktørreferanser»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Referanser til statiske metoder
Metodereferanser til instansmetoder på en bestemt instans
Metodereferanser til vilkårlige instanser
Konstruktørreferanser

← Tilbake til Java Academy