Java Academy · Lektion

Konstruktørreferencer

Brug ClassName::new til at oprette instanser via funktionelle interfaces som Supplier og Function.

Lektion 4 af 413 trin

Konstruktørreferencer er en gratis Java Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Java Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Java Academy-kurset indeholder 4 lektioner i alt.

Hvad er konstruktørreferencer?

En konstruktørreference bruger ClassName::new til at oprette objekter via en funktionel grænseflade. Den funktionelle grænseflades parametre svarer til konstruktørens parametre.

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 uden argumenter som Supplier

En konstruktør uden argumenter passer til 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 parametre passer til 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ørreference i Stream.map

Konvertér strenge til objekter ved hjælp af en konstruktørreference:

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)

Array-konstruktørreference

Opret arrays dynamisk med Type[]::new. Dette bruges af 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ønsteret med fabriksgrænseflade

Definér en brugerdefineret funktionel grænseflade til fabrikker, og brug derefter konstruktørreferencer:

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

Afhængighedsinjektion med konstruktørreferencer

Frameworks bruger ofte funktionelle fabrikker til forsinket oprettelse. Konstruktørreferencer gør dette mønster enkelt:

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 mellem lambda og konstruktørreference

Brug en konstruktørreference, når lambdaens krop kun 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ørreferencer

Generiske klasser fungerer også — typen udledes ud fra konteksten for den funktionelle grænseflade:

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ørreferencer

Brug konstruktørreferencer i samlere til at opbygge brugerdefinerede 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ørreferencer til 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

Hurtig kontrol

Hvilken funktionel grænseflade passer en konstruktørreference uden argumenter som ArrayList::new til?

Besvar den i den interaktive lektion

Opsummering: Konstruktørreferencer

Vigtige pointer:

Syntaks: ClassName::new — delegerer til den matchende konstruktør
Uden argumenter → Supplier<T>; ét argument → Function<T,R>; to argumenter → BiFunction
Array-konstruktør: Type[]::new — bruges sammen med Stream.toArray()
Renere end en lambda, når lambdaens krop blot er 'new Type(args)'
Brug Collectors.toCollection(LinkedList::new) til resultatet af en typesikker samling

Gratis at komme i gang

Lær Java med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 104
Lektioner: 374

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Konstruktørreferencer” gratis?

Ja — hele teksten til “Konstruktørreferencer” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Java Academy-kurset, skal du opgradere til CoddyKit PRO. Java Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Konstruktørreferencer”?

Brug ClassName::new til at oprette instanser via funktionelle interfaces som Supplier og Function. Du øver dig i Java Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Java Academy?

Der kræves ingen tidligere erfaring. Java Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Konstruktørreferencer”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Java Academy-lektion?

Ja. Alle Java Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Referencer til statiske metoder
Referencer til instansmetoder på en bestemt instans
Referencer til instansmetoder uden bestemt instans
Konstruktørreferencer

← Tilbage til Java Academy