Java Academy · Oppitunti

Konstruktoriviittaukset

Luo olioita ClassName::new-viittauksella funktionaalisten rajapintojen, kuten Supplierin ja Functionin, kautta.

Oppitunti 4/413 vaihetta

Konstruktoriviittaukset on ilmainen Java Academy-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Java Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Java Academy-kurssilla on yhteensä 4 oppituntia.

Mitä ovat konstruktoriviitteet?

Konstruktoriviite käyttää muotoa ClassName::new olioiden luomiseen funktionaalisen rajapinnan avulla. Funktionaalisen rajapinnan parametrit vastaavat konstruktorin parametreja.

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)

Parametriton konstruktori Supplierina

Parametriton konstruktori vastaa muotoa 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

Kaksiparametrinen konstruktori BiFunctionina

Kaksiparametriset konstruktorit vastaavat muotoa 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]

Konstruktoriviite Stream.map-metodissa

Muunna merkkijonoja olioiksi konstruktoriviitteen avulla:

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)

Taulukon konstruktoriviite

Luo taulukoita dynaamisesti muodolla Type[]::new. Tätä käyttää 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);

Tehdasrajapinnan malli

Määritä tehtaille oma funktionaalinen rajapinta ja käytä sitten konstruktoriviitteitä:

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

Riippuvuuksien injektointi konstruktoriviitteillä

Ohjelmistokehykset käyttävät usein funktionaalisia tehtaita olioiden laiskaan luomiseen. Konstruktoriviitteet tekevät tästä mallista selkeän:

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

Lambdan ja konstruktoriviitteen valinta

Käytä konstruktoriviitettä, kun lambdan runko on vain 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());

Geneeriset tyypit ja konstruktoriviitteet

Myös geneeriset luokat toimivat — tyyppi päätellään funktionaalisen rajapinnan kontekstista:

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-kerääjät konstruktoriviitteillä

Käytä konstruktoriviitteitä kerääjissä mukautettujen tulossäiliöiden rakentamiseen:

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

Primitiivit ja autoboxing

Kääreluokkien konstruktoriviitteet käsittelevät automaattisen paketoinnin:

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

Pikatarkistus

Mitä funktionaalista rajapintaa vastaa parametriton konstruktoriviite, kuten ArrayList::new?

Vastaa interaktiivisessa oppitunnissa

Kertaus: konstruktoriviitteet

Tärkeimmät asiat:

Syntaksi: ClassName::new — delegoi vastaavalle konstruktorille
Parametriton → Supplier<T>; yksiparametrinen → Function<T,R>; kaksiparametrinen → BiFunction
Taulukon konstruktori: Type[]::new — käytetään Stream.toArray()-metodin kanssa
Selkeämpi kuin lambda, kun lambdan runko on vain 'new Type(args)'
Käytä Collectors.toCollection(LinkedList::new) -kutsua tyypitettyihin kokoelmatuloksiin

Aloita maksutta

Opi Java tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 104
Oppitunnit: 374

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Konstruktoriviittaukset” ilmainen?

Kyllä – oppitunnin ”Konstruktoriviittaukset” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Java Academy-kurssin, päivitä CoddyKit PROhon. Java Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Konstruktoriviittaukset”?

Luo olioita ClassName::new-viittauksella funktionaalisten rajapintojen, kuten Supplierin ja Functionin, kautta. Harjoittelet Java Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Java Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Java Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.

Kuinka kauan ”Konstruktoriviittaukset”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Java Academy-oppitunnilla?

Kyllä. Jokainen Java Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Staattiset metodiviittaukset
Metodiviittaukset tietyn instanssin metodeihin
Mielivaltaisen instanssin metodiviittaukset
Konstruktoriviittaukset

← Takaisin: Java Academy