Java Academy · Lektion

Konstruktorreferenser

Använd ClassName::new för att skapa instanser via funktionella gränssnitt som Supplier och Function.

Lektion 4 av 413 steg

Konstruktorreferenser är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad är konstruktorreferenser?

En konstruktorreferens använder ClassName::new för att skapa objekt via ett funktionellt gränssnitt. Det funktionella gränssnittets parametrar motsvarar konstruktorns parametrar.

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)

Konstruktor utan argument som Supplier

En konstruktor utan argument motsvarar 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

Konstruktor med två argument som BiFunction

Konstruktorer med två parametrar motsvarar 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]

Konstruktorreferens i Stream.map

Konvertera strängar till objekt med hjälp av en konstruktorreferens:

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)

Arraykonstruktorreferens

Skapa arrayer dynamiskt med Type[]::new. Detta används 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önstret med fabriksgränssnitt

Definiera ett eget funktionellt gränssnitt för fabriker och använd sedan konstruktorreferenser:

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

Beroendeinjektion med konstruktorreferenser

Ramverk använder ofta funktionella fabriker för fördröjd instansiering. Konstruktorreferenser gör mönstret lätt att använda:

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

Välja mellan lambda och konstruktorreferens

Använd en konstruktorreferens när lambdans kropp endast är 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());

Generiska typer och konstruktorreferenser

Generiska klasser fungerar också – typen härleds från det funktionella gränssnittets kontext:

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 collectors med konstruktorreferenser

Använd konstruktorreferenser i collectors för att skapa anpassade resultatbehållare:

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

Primitiva typer och autoboxning

Konstruktorreferenser för wrappertyper hanterar autoboxning:

// 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

Snabb kontroll

Vilket funktionellt gränssnitt motsvarar en konstruktorreferens utan argument, till exempel ArrayList::new?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Konstruktorreferenser

Viktiga punkter:

Syntax: ClassName::new – delegerar till den motsvarande konstruktorn
Utan argument → Supplier<T>; ett argument → Function<T,R>; två argument → BiFunction
Arraykonstruktor: Type[]::new – används med Stream.toArray()
Renare än en lambda när lambdans kropp endast är 'new Type(args)'
Använd Collectors.toCollection(LinkedList::new) för typade samlingsresultat

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Konstruktorreferenser” gratis?

Ja – hela texten till ”Konstruktorreferenser” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Konstruktorreferenser”?

Använd ClassName::new för att skapa instanser via funktionella gränssnitt som Supplier och Function. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Konstruktorreferenser”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Referenser till statiska metoder
Metodreferenser till en specifik instans
Metodreferenser till godtyckliga instanser
Konstruktorreferenser

← Tillbaka till Java Academy