Kotlin “Lateinit”

Noen ganger vil du kanskje ikke initialisere en variabel i Kotlin på tidspunktet for erklæringen. I stedet vil du initialisere den senere når det er nødvendig, men i det vesentlige før den er tilgjengelig. Det er her "Lateinit" nøkkelordet til Kotlin kommer i spill, og denne artikkelen vil hovedsakelig kaste lys over bruken av denne variabelen i Kotlin -programmeringsspråket i Ubuntu 20.04.

Hva gjør "Lateinit" nøkkelordet i Kotlin?

Med introduksjonens hjelp, vil du vite at "LateInit" nøkkelordet brukes med en variabel i Kotlin bare når du ønsker å initialisere den variabelen et sted senere i skriptet ditt. Du kan imidlertid vurdere å lage den variabelen "null" hvis du ikke vil initialisere den i utgangspunktet. Likevel kan det fremdeles være noen situasjoner der du ikke engang vil gjøre disse variablene til å være null. Du kan bruke nøkkelordet "Lateinit" mens du erklærer en variabel for lignende situasjoner. Den viktigste fordelen med å bruke dette nøkkelordet er at det ikke tildeler noe minne til variabelen før det initialiseres. Du må imidlertid sørge for at du initialiserer den variabelen senere i koden din før den er tilgjengelig. Hvis du ikke klarer det, vil kompilatoren din generere noen feil. Dermed vil du ikke få lov til å utføre Kotlin -skriptet ditt.

Advarsler med bruken av "Lateinit" nøkkelordet i Kotlin:

Etter å ha kjent det grunnleggende formålet med "lateinit" nøkkelordet til Kotlin -programmeringsspråket, bør du også være klar over forsiktighetene du må ta før du begynner å bruke nøkkelordet "Lateinit" i Kotlin. Disse advarslene er oppsummert nedenfor:

• Nøkkelordet “Lateinit” må alltid brukes med "VAR" -tnøkkelordet og ikke med "Val" nøkkelordet.
• "Lateinit" -variablene kan ikke være av "null" -typen.
• Før du får tilgang til den, bør du initialisere en "LateInit" -variabel fordi du ikke vil gjøre det, vil føre til unntak og feil.

Eksempler på å bruke nøkkelordet "Lateinit" i Kotlin:

For å fremheve "Lateinit" nøkkelordbruk i Kotlin -programmeringsspråket i Ubuntu 20.04, vi har implementert følgende to eksempler for deg:

Eksempel 1: Deklarerer og bruker en Kotlin -variabel som "Lateinit":

Dette eksemplet vil lære deg den enkleste metoden for å erklære en Kotlin -variabel som "Lateinit" og deretter bruke den for å oppnå noen ønsket funksjonalitet. Du kan se på Kotlin -programmet vist på bildet nedenfor for å forstå dette:

I dette Kotlin -programmet har vi først brukt nøkkelordet "Lateinit" for å erklære et objekt "EMP" i "ansatt" -klassen som "Lateinit". Du kan få at vi ikke har implementert denne klassen ennå. Derfor må vi gjøre det senere i skriptet vårt slik at kompilatoren vår ikke gir feil. Vi har laget en forekomst "EMP" i "ansatt" -klassen i vår "Main ()" -funksjon. Deretter har vi gitt det navnet på den ansatte som en streng og hans erfaring i år som et heltall. Deretter brukte vi de to "println" -uttalelsene for å skrive ut begge disse parametrene på terminalen. Til slutt har vi erklært en dataklasse som heter "ansatt" som er i stand til å akseptere to parametere, henholdsvis "navn" og "erfaring" av henholdsvis streng- og heltalltyper. Det er her vårt "lateinit" -objekt endelig blir initialisert.

Etter å ha implementert dette Kotlin -skriptet, samlet vi det med følgende kommando:

$ Kotlinc Lateinit.Kt

Deretter brukte vi kommandoen vist nedenfor for å utføre dette skriptet:

$ KOTLIN LATEINITKT

Følgende bilde representerer utgangen fra dette Kotlin -programmet. Du kan se hvordan vi har klart å bruke nøkkelordet "Lateinit" i Kotlin for å skrive ut navnet og opplevelsen til en ansatt.

Eksempel nr. 2: Å finne ut om en "lateinit" -variabel er blitt initialisert eller ikke:

Vi har allerede nevnt at hvis du glemmer å initialisere "lateinit" -variabelen i Kotlin-skriptet ditt, så fører det til å kompilere tidsfeil. Derfor bør det være en måte du kan oppdage om en "lateinit" -variabel er blitt initialisert eller ikke. Vi vil lede deg gjennom denne metoden i Kotlin -skriptet vist på bildet nedenfor:

I dette Kotlin -manuset har vi først definert en klasse som heter "kurs". Innenfor denne klassen har vi erklært en variabel som heter "CourSename" av String Type som "Lateinit". Deretter har vi laget en funksjon av denne klassen som heter “Initializename ()”. Inne i denne funksjonen ønsket vi først å sjekke om vår "lateinit" -variabel er blitt initialisert eller ikke. For det har vi brukt “dette :: kursnavnet.isinitialisert ”notasjon.

Her tilsvarer "dette" nøkkelordet den nåværende tilstanden til vår "lateinit" -variabel, som for øyeblikket er uinitialisert. Deretter har vi brukt omfangsoppløsningsoperatøren for å få tilgang til den nåværende verdien av "CoursName" -variabelen etterfulgt av "Isinitialized" -funksjonen. Deretter har vi initialisert "CoursName" -variabelen med navnet på et kurs. Etter det brukte vi "isinitialisert" -funksjonen igjen for å sjekke gjeldende tilstand for "lateinit" -variabelen. Inne i vår "Main ()" -funksjon har vi laget en forekomst av "kurs" -klassen "C1". Ved hjelp av dette tilfellet har vi kalt "Initializename ()" -funksjonen.

Det påfølgende bildet viser utgangen fra dette Kotlin -skriptet. Til å begynne med, når vår "lateinit" -variabel ble uinitialisert, var utgangen som ble returnert av "isinitialisert" funksjonen "falsk". Mens vi initialiserte "lateinit" -variabelen, viste utgangen av den samme funksjonen å være "sann".

Konklusjon:

I denne guiden introduserte vi deg først for begrepet sen initialisering, etterfulgt av formålet med dens eksistens i Kotlin. Etter å ha gitt deg en kort oversikt over det. Ved å gå gjennom denne guiden, vil du ha en god ide om begrepet sen initialisering i Kotlin i Ubuntu 20.04. Vi håper du fant denne artikkelen nyttig. Sjekk de andre Linux -hint -artiklene for flere tips og opplæringsprogrammer.