Java Academy · Oppitunti

Metodiviittaukset tietyn instanssin metodeihin

Tallenna tietty olio ja viittaa yhteen sen instanssimetodeista callback-kutsuja ja kuuntelijoita varten.

Oppitunti 2/413 vaihetta

Metodiviittaukset tietyn instanssin metodeihin on ilmainen Java Academy-oppitunti CoddyKitissä. Tämä on oppitunti 2/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.

Tietyn olion metodiviittaus

Tietyn olion instanssimetodiviittaus tallentaa tietyn olion ja viittaa yhteen sen metodeista. Syntaksi: instance::methodName.

// System.out is a specific PrintStream instance
List<String> names = List.of("Alice","Bob","Carol");
names.forEach(System.out::println); // System.out is the captured instance

Mukautetun olion instanssin tallentaminen

Mikä tahansa olio voidaan tallentaa. Metodiviittaus käyttää instanssia luontihetkellä:

class Greeter {
    private String prefix;
    Greeter(String prefix) { this.prefix = prefix; }
    String greet(String name) { return prefix + ", " + name + "!"; }
}

Greeter g = new Greeter("Hello");
java.util.function.Function<String, String> greetFn = g::greet;

System.out.println(greetFn.apply("Alice")); // Hello, Alice!
System.out.println(greetFn.apply("Bob"));   // Hello, Bob!

Supplier-käyttö

Tiettyyn olioon sidottu parametriton instanssimetodi vastaa tyyppiä Supplier<T>:

StringBuilder sb = new StringBuilder("Hello World");
java.util.function.Supplier<String> toString = sb::toString;

System.out.println(toString.get()); // Hello World
sb.append(" !");
System.out.println(toString.get()); // Hello World ! (sb is live)

Predicate-käyttö

Totuusarvon palauttavat instanssimetodit vastaavat Predicate-rajapintaa, kun ne sidotaan tiettyyn instanssiin:

String prefix = "Java";
java.util.function.Predicate<String> startsWith = prefix::equals;
// Hmm, this checks if prefix.equals(candidate).
// More useful:
Predicate<String> startsWithJ = s -> s.startsWith("J");

// But a specific instance Predicate:
StringBuilder pattern = new StringBuilder("hello");
Predicate<String> equalsHello = ((CharSequence)"hello")::equals;
System.out.println(equalsHello.test("hello")); // true
System.out.println(equalsHello.test("world")); // false

Kuuntelija- ja callback-malli

Tietyn olion metodiviittaukset sopivat erinomaisesti tapahtumakuuntelijoihin ja callback-kutsuihin, koska ne tallentavat käsittelijäolion luontevasti:

class EventHandler {
    void onEvent(String event) {
        System.out.println("Handling: " + event);
    }
}

EventHandler handler = new EventHandler();
List<String> events = List.of("click","hover","submit");
events.forEach(handler::onEvent); // captures the specific handler instance

Käytännössä: luokkaan sidottu loggeri

Sido loggeri tiettyyn loggeri-instanssiin käytettäväksi Consumerina:

import java.util.logging.*;

Logger log = Logger.getLogger("MyApp");

List<String> messages = List.of("Starting","Processing","Done");
messages.stream()
    .map(String::toUpperCase)
    .forEach(log::info); // log is the specific Logger instance

Viite kaappaa tilan sidontahetkellä

Viitteen kautta näkyvä olion tila vastaa olion reaaliaikaista tilaa, ei viitteen luomishetkellä otettua tilannekuvaa:

List<String> list = new ArrayList<>(List.of("A","B"));
java.util.function.Supplier<Integer> sizeRef = list::size;

System.out.println(sizeRef.get()); // 2
list.add("C");
System.out.println(sizeRef.get()); // 3 (reflects live state)

Tietyn ja mielivaltaisen instanssin vertailu

Kaksi erilaista metodiviitteen muotoa näyttää samankaltaiselta — ymmärrä niiden ero:

// Specific instance: s is captured at binding
String s = "hello";
Predicate<String> p1 = s::equalsIgnoreCase; // String::equalsIgnoreCase bound to 'hello'

// Arbitrary instance: receiver is the stream element
Function<String, String> p2 = String::toUpperCase; // receiver IS the element

Käyttötapaus: säieturvallinen metodien delegointi

Sido palveluolion synkronoitu metodi funktionaaliseksi rajapinnaksi turvallista asynkronista käyttöä varten:

class Counter {
    private int count = 0;
    synchronized void increment(String ignored) { count++; }
    int get() { return count; }
}

Counter c = new Counter();
List<String> tasks = List.of("t1","t2","t3");
tasks.forEach(c::increment);
System.out.println(c.get()); // 3

Kun kaapattu instanssi on null

Jos kaapattu olio on null metodiviitettä luotaessa, NullPointerException heitetään kutsuhetkellä, ei sidontahetkellä:

StringBuilder sb = null;
// Reference is created without error:
java.util.function.Supplier<String> ref = sb::toString;
try {
    ref.get(); // NPE thrown here
} catch (NullPointerException e) {
    System.out.println("NPE at invocation");
}

Vertailun yhteenveto

Kolmen metodiviitteen muodon vertailu:

ClassName::staticMethod — staattinen, ei vastaanottajaa
instance::instanceMethod — sidottu tiettyyn olioon
ClassName::instanceMethod — vastaanottaja on stream-alkio (mielivaltainen instanssi)

Pikatarkistus

Kun käytössä on EventHandler h = new EventHandler(); list.forEach(h::handle); — mikä on handle-kutsun vastaanottaja kunkin alkion kohdalla?

Vastaa interaktiivisessa oppitunnissa

Kertaus: tietyn instanssin metodiviitteet

Tärkeimmät asiat:

syntaksi: instance::methodName — kaappaa tietyn olion
Kaapattu olio on jokaisen kutsun vastaanottaja
Sopii erityisesti takaisinsoittoihin, kuuntelijoihin ja lokitusmalleihin
Kaapatun instanssin reaaliaikainen tila näkyy viitteen kautta
NPE kutsuhetkellä, jos instanssi on null (ei sidontahetkellä)

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 ”Metodiviittaukset tietyn instanssin metodeihin” ilmainen?

Kyllä – oppitunnin ”Metodiviittaukset tietyn instanssin metodeihin” 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 ”Metodiviittaukset tietyn instanssin metodeihin”?

Tallenna tietty olio ja viittaa yhteen sen instanssimetodeista callback-kutsuja ja kuuntelijoita varten. 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 2/4.

Kuinka kauan ”Metodiviittaukset tietyn instanssin metodeihin”-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