Sveip for å vise menyen

Det er på tide å gå i dybden på hvordan lambdas opprettes i Java og hvilken rolle funksjonelle grensesnitt spiller i denne sammenhengen.

Et funksjonelt grensesnitt kan brukes til å representere en handling eller operasjon som kan utføres. I stedet for å lage en hel klasse for en enkel oppgave, kan du definere et grensesnitt med én metode som beskriver handlingen.

Eksempel på et funksjonelt grensesnitt:

@FunctionalInterface
public interface MyFunctionalInterface {
    void myMethod();  // The only abstract method
}

Annotasjonen @FunctionalInterface er valgfri, men den hjelper kompilatoren og utviklere ved å sikre at grensesnittet forblir funksjonelt og forhindrer at det legges til flere abstrakte metoder.

Hvorfor trenger vi dem?

I Stream API brukes funksjonelle grensesnitt til å overføre ulike oppførsler til metoder som arbeider med datasamlinger.

For eksempel kan du sende en filtreringsbetingelse til en metode som velger bestemte elementer fra en liste, eller angi en operasjon for å transformere hvert element, slik det gjøres i metoder som filter() og map().

Main.java


              1234567891011121314151617
            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

        // Using `filter()` to extract even numbers
        List<Integer> evenNumbers = numbers.stream()
                                           .filter(n -> n % 2 == 0)  // Predicate: keeps only even numbers
                                           .collect(Collectors.toList());
        System.out.println(evenNumbers);
    }
}

Metoden filter() tar et spesielt funksjonelt grensesnitt kalt Predicate<T> (som du vil lære mer om senere), som sjekker om et element oppfyller en bestemt betingelse. I dette tilfellet avgjør lambda-uttrykket n -> n % 2 == 0 om et tall er partall. Hvis tallet er delelig med 2 uten rest, forblir det i strømmen.

Lage et egendefinert funksjonelt grensesnitt

Anta at du trenger et grensesnitt for å utføre aritmetiske operasjoner som addisjon eller subtraksjon. Du kan lage et funksjonelt grensesnitt kalt ArithmeticOperation med en metode apply som utfører en operasjon på to tall, a og b.

@FunctionalInterface
public interface ArithmeticOperation {
    int apply(int a, int b);  // Method to perform an operation on two numbers
}

Nå som du har interface, kan du bruke lambda-uttrykk for å definere ulike operasjoner som addisjon og subtraksjon:

Main.java


              1234567891011
            
public class Main {
    public static void main(String[] args) {
        // Addition
        ArithmeticOperation add = (a, b) -> a + b;
        System.out.println("Sum: " + add.apply(5, 3));  // 8

        // Subtraction
        ArithmeticOperation subtract = (a, b) -> a - b;
        System.out.println("Difference: " + subtract.apply(5, 3));  // 2
    }
}

Lambda-uttrykkene (a, b) -> a + b og (a, b) -> a - b implementerer metoden apply i grensesnittet, og utfører henholdsvis addisjon og subtraksjon. Det første lambda-uttrykket returnerer summen av to tall, mens det andre returnerer differansen.

Denne tilnærmingen gir en fleksibel måte å bruke ulike aritmetiske operasjoner uten behov for å opprette egne klasser for hver enkelt.

1. Hva er et funksjonelt grensesnitt i Java?

2. Hvilket lambda-uttrykk implementerer følgende funksjonelle grensesnitt korrekt?

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 3

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår