0Pricing
Java Academy · Lezione

Riferimenti a costruttori

Utilizzi ClassName::new per creare istanze tramite interfacce funzionali come Supplier e Function.

Riferimenti a costruttori è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Che cosa sono i riferimenti a costruttori?

Un riferimento a un costruttore utilizza ClassName::new per creare oggetti tramite un'interfaccia funzionale. I parametri dell'interfaccia funzionale corrispondono ai parametri del costruttore.

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)

Costruttore senza argomenti come Supplier

Un costruttore senza argomenti corrisponde a 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

Costruttore a due argomenti come BiFunction

I costruttori con due parametri corrispondono a 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]

Riferimento a un costruttore in Stream.map

Converta le stringhe in oggetti utilizzando un riferimento a un costruttore:

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)

Riferimento al costruttore di un array

Crei array dinamicamente con Type[]::new. Questa sintassi viene utilizzata da 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);

Pattern dell'interfaccia factory

Definisca un'interfaccia funzionale personalizzata per le factory, quindi utilizzi i riferimenti ai costruttori:

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

Dependency injection con riferimenti ai costruttori

I framework utilizzano spesso factory funzionali per l'istanziazione lazy. I riferimenti ai costruttori rendono questo pattern chiaro:

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

Scelta tra lambda e riferimento al costruttore

Utilizzi un riferimento al costruttore quando il corpo della lambda è semplicemente 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());

Tipi generici e riferimenti ai costruttori

Funziona anche con le classi generiche: il tipo viene inferito dal contesto dell'interfaccia funzionale:

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

Collector di stream con riferimenti ai costruttori

Utilizzi i riferimenti ai costruttori nei collector per creare contenitori di risultati personalizzati:

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

Tipi primitivi e autoboxing

I riferimenti ai costruttori dei tipi wrapper gestiscono l'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

Verifica rapida

A quale interfaccia funzionale corrisponde un riferimento a un costruttore senza argomenti come ArrayList::new?

Riepilogo: riferimenti ai costruttori

Punti chiave:

  • Sintassi: ClassName::new — delega al costruttore corrispondente
  • Senza argomenti → Supplier<T>; un argomento → Function<T,R>; due argomenti → BiFunction
  • Costruttore di array: Type[]::new — utilizzato con Stream.toArray()
  • Più chiaro di una lambda quando il corpo della lambda è semplicemente 'new Type(args)'
  • Utilizzi Collectors.toCollection(LinkedList::new) per ottenere risultati di raccolte tipizzate

Domande Frequenti

La lezione «Riferimenti a costruttori» è gratuita?

Sì — il testo completo di «Riferimenti a costruttori» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Riferimenti a costruttori»?

Utilizzi ClassName::new per creare istanze tramite interfacce funzionali come Supplier e Function. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Riferimenti a costruttori»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Riferimenti a metodi statici
  2. Riferimenti a metodi di istanza su un'istanza specifica
  3. Riferimenti a metodi di istanza arbitraria
  4. Riferimenti a costruttori
← Torna a Java Academy