I Java er ' Forbruker ”-grensesnittet representerer en operasjon som mottar en enkelt inngang og utfører en handling på den uten å returnere et resultat. Det tilbyr også en fleksibel måte å definere tilpassede operasjoner som kan brukes i funksjonell programmering som lambda-uttrykk. Denne bloggen illustrerer implementeringen av et forbrukergrensesnitt i Java.
Hvordan bruke forbrukergrensesnitt i Java?
« Forbruker ”-grensesnittet tilbyr innkapslingen eller atferden som kan sendes rundt og utføres på forskjellige steder i programmet. Det fremmer gjenbrukbar atferd som kan brukes på forskjellige innganger uten å duplisere kode. Forbrukergrensesnittet består av to metoder, nemlig ' og så() ' og ' aksepterer() '.
Besøk eksemplene nedenfor for å forstå begge funksjonene sammen med kodekeksempler:
Eksempel 1: Bruk av «andThen()»-metoden
Utvikleren kan kjede flere ' Forbruker ' operasjoner helt ved å bruke ' og så() 'metoden. Den returnerer en ny ' Forbruker ' som utfører operasjonen til gjeldende ' Forbruker ' forekomst. Etter det, oppfyller operasjonene til den kommende/etter ' Forbruker ' forekomst. Det er standardmetoden som er mye brukt for prosessen med ' Komposisjon '.
Syntaksen for ' og så() '-metoden er satt inn nedenfor:
og så ( Forbruker < ? super T > etter )
« og så() 'metoden kombinerer den nåværende forbrukeren' super ' med en annen forbruker ' etter '. Og den utfører den gjeldende forbrukerens operasjon først, etterfulgt av operasjonen til den oppgitte forbrukeren.
La oss gå gjennom et program for en bedre forståelse:
import java.util.ArrayList;import java.util.LinkedList;
import java.util.List;
import java.util.function.Consumer;
offentlig klasse Root {
offentlig statisk tomrom hoved ( String args [ ] )
{
// opprettelse av hovedmetode
Forbruker < Liste < Heltall > > multiplisere = dataEle - >
{
til ( int j = 0 ; j < dataEle.size ( ) ; j++ ) {
dataEle.sett ( j, 5 * dataEle.get ( j ) ) ;
}
} ;
// Forbruker for å vise en liste over heltall
Forbruker < Liste < Heltall > >
utskrifter = dataEle - > dataEle.stream ( ) .for hver ( k - > System.ut.utskrift ( k + ' ' ) ) ;
Liste < Heltall > dataEle = ny ArrayList < Heltall > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
multiplisere.og deretter ( utskrifter ) .aksepterer ( dataEle ) ;
}
}
Forklaring av koden ovenfor:
- Først, ' Forbruker ', ' LinkedList ” og relaterte verktøy importeres til Java-filen. Etter det, hovedklassen med navnet ' Rot ' er skapt.
- Deretter oppretter du et 'Forbruker'-grensesnitt av typen Liste kalt ' multiplisere ' og sett den lik ' ArrayList ' som kommer til å bli opprettet nedenfor.
- Den bruker en ' til ' løkke som itererer til lengden på ' ArrayList 'navngitt' dataEle ', og multipliserer hvert dataelement i ' dataEle ' med ' 5 '.
- Etter det, et sekund ' Forbruker ”-grensesnittet opprettes som skriver ut hvert element på konsollen som hentes etter prosessen med multiplikasjon fra en strøm.
- Nå, opprett og legg til dummy-dataelementer i ' dataEle ' ArrayList.
- Til slutt, ' og så() '-metoden kalles med ' aksepterer() ' metode som aksepterer ' dataEle ' ArrayList og returnerer resultatet av ' multiplisere ' i rekkefølge.
Etter slutten av utførelsesfasen:
Øyeblikksbildet viser at multiplikasjonsoppgaven er fullført ved å bruke ' og så() ' metoden for ' Forbruker ' grensesnitt.
Eksempel 2: Bruk av 'accept()'-metoden
« aksepterer() '-metoden er en funksjonell metode for ' Forbruker ' grensesnitt. Den godtar et enkelt argument av typen ' T ” og utfører de spesifiserte/nødvendige operasjonene på den. Verdien av ' Null ' må ikke gis til den siden den ikke godtar ' Null ”-verdier og generere et unntak.
Syntaksen er gitt nedenfor:
ugyldig akseptere ( < sterk > T sterk > t )
I syntaksen ovenfor, ' t ” er det eneste argumentet som enkelte operasjoner blir operert på.
La oss besøke kodeblokken nedenfor for en bedre forståelse:
import java.util.ArrayList;import java.util.LinkedList;
import java.util.List;
importer java.util.function.Consumer;
// importere verktøy i Java fil
offentlig klasse Root {
offentlig statisk tomrom hoved ( String args [ ] ) // opprettelse av hovedmetode
{
Forbruker < Heltall > disp = k - > System.out.println ( k ) ;
disp.accept ( 255 ) ;
Forbruker < Liste < Heltall > > multiplisere = dataEle - >
{
til ( int k = 0 ; k < dataEle.size ( ) ; k++ )
dataEle.sett ( k, 5 * dataEle.get ( k ) ) ;
} ;
Forbruker < Liste < Heltall > >
utskrifter = dataEle - > dataEle.stream ( ) .for hver ( j - > System.ut.utskrift ( j + '
' ) ) ;
Liste < Heltall > dataEle = ny ArrayList < Heltall > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
// Implementer endre ved å bruke aksept ( )
multiplisere.godta ( dataEle ) ;
// Implementer dispList ved å bruke aksept ( )
utskrifter.godta ( dataEle ) ;
}
}
Forklaring av koden ovenfor:
- Først, ' Forbruker ' grensesnitt kalt ' disp ” opprettes som viser oppgitte parametere på konsollen, uten å utføre noen operasjon.
- Nå, ' aksepterer() '-metoden kalles av ' disp ' Forbruker, og verdien av ' 255 ' er overført til denne metoden.
- Deretter en annen ' Forbruker '-grensesnittet er opprettet som bruker ' til ”-løkke for å bruke multiplikasjon på hvert gjenværende element i ArrayList kalt “ dataEle '.
- Etter det, lag en til ' Forbruker ' grensesnitt for å vise ' dataEle ”-elementer oppstår etter å ha brukt multiplikasjonen som kommer fra strømmen.
- Deretter initialiser ArrayList ' dataEle ' med dummy-dataelementer og bruk ' aksepterer() '-metoden med ' multiplisere ' grensesnitt.
- Til slutt ringer du ' aksepterer() '-metoden ved å bruke ' utskrifter ”-grensesnitt for å vise resultatet etter bruk av multiplikasjon på konsollloggen.
Etter endt utførelse:
Øyeblikksbildet ovenfor viser at flere forbrukergrensesnitt har blitt kalt ett om gangen ved å bruke ' aksepterer() 'metoden.
Eksempel 3: Håndtering av unntak for etterfunksjon
Unntaket oppstår når ' etter ' funksjonen til ' og så() '-metoden inneholder en ' aksepterer() 'metoden. Dette lager et grensesnitt som inneholder data som skal behandles av grensesnitt som bruker forbrukergrensesnittmetoder som vist nedenfor:
import java.util.ArrayList;import java.util.LinkedList;
import java.util.List;
import java.util.function.Consumer;
offentlig klasse Root {
offentlig statisk tomrom hoved ( String args [ ] )
{
Forbruker < Liste < Heltall > > multiplisere = dataEle - >
{
til ( int j = 0 ; j < = dataEle.størrelse ( ) ; j++ )
dataEle.sett ( j, 5 * dataEle.get ( j ) ) ;
} ;
// Forbruker for å vise en liste over heltall
Forbruker < Liste < Heltall > >
skrive ut = dataEle - > dataEle.stream ( ) .for hver ( Jeg - > System.ut.utskrift ( jeg + ' ' ) ) ;
Liste < Heltall > dataEle = ny ArrayList < Heltall > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
prøve {
skriv ut.og deretter ( multiplisere ) .aksepterer ( dataEle ) ;
}
å fange ( Unntak e ) {
System.out.println ( 'Unntak: ' + og ) ;
}
}
}
Forklaring av kodeblokken ovenfor:
- Først, ' Forbruker 'grensesnittet er opprettet som bare flere ' 5 ” heltall med dataelementene som ligger i den oppgitte ArrayList.
- Neste, den andre ' Forbruker ”-grensesnittet er opprettet for å vise hvert dataelement i ArrayList som mottas av strømmen.
- Etter det blir ArrayList opprettet og initialisert med dummy heltallstypeverdier.
- Og så ' prøve '-blokken brukes der ' og så() '-metoden kalles av ' skrive ut ' grensesnitt.
- Det forårsaker ' IndexOutOfBoundsException ' fordi det ' til ' loop iteration limit er overskredet, noe som løses av ' å fange ' blokk.
Etter slutten av utførelsesfasen:
Øyeblikksbildet viser at IndexOutOfBoundsException har blitt generert av kompilatoren.
Konklusjon
« Forbruker ”-grensesnittet gir en måte å definere gjenbrukbar atferd og utføre handlinger på inndata uten å returnere et resultat. Det består av ' aksepterer() ' og ' og så() 'metoder. Det brukes ofte til databehandlingsoppgaver, der brukere må utføre en handling på hvert element i en samling eller strøm. Det handler om bruken og implementeringen av forbrukergrensesnittet i Java.