Dart grensesnitt

Et grensesnitt i DART -programmeringsspråket anses som en måte å lage abstraksjon i koden din. Dart -grensesnittet fungerer som en blåkopi for alle klassene som ønsker å implementere dette grensesnittet. Etterpå er disse klassene pålagt å gi sine egne implementeringer for alle grensesnittmetodene. I denne artikkelen vil vi lære deg bruken av grensesnittene i DART -programmeringsspråket i Ubuntu 20.04.

Hovedegenskapene til grensesnittene i pilen:

Følgende er de viktigste egenskapene til grensesnittene i DART -programmeringsspråket:

• Det er ingen direkte metode for å erklære et grensesnitt i DART. Imidlertid kan den enkle klasseerklæringen tjene som et middel til å erklære et DART -grensesnitt.
• En DART -klasse kan implementere flere grensesnitt om gangen.
• Bruken av grensesnittene i DART -programmeringsspråket kan hjelpe oss med å oppnå flere arv.

Hvordan bruke grensesnittene i Dart i Ubuntu 20.04?

For å lære bruken av grensesnittene i DART -programmeringsspråket, må du forstå eksemplene som er forklart nedenfor:

Eksempel 1: En Dart -klasse som implementerer en annen DART -klasse:

Siden vi vet at DART -programmeringsspråket ikke har en direkte måte å erklære grensesnittene, vil vi derfor i dette eksemplet lage en klasse som implementerer en annen klasse for å etterligne funksjonaliteten til et grensesnitt. Følgende Dart -skript er skrevet i denne forbindelse:

I dette DART -skriptet har vi definert en klasse som heter "Organisasjon" som vil fungere som et grensesnitt. Denne klassen har en enkelt medlemsfunksjon som heter “Orgname ()”. Det vil ikke returnere noen verdi og vil heller ikke godta noen inngangsparametere. Imidlertid har denne funksjonen bare en "trykte" uttalelse inni den. Etter å ha designet denne klassen, har vi definert en annen klasse som heter "ansatt" som implementerer "organisasjon" -klassen. Det betyr at "ansatt" -klassen må implementere alle metodene i "organisasjon" -klassen sammen med resten av funksjonaliteten.

Inne. Deretter har vi en funksjon som heter “Empinfo ()” som brukes til å skrive ut navnet på den ansatte på konsollen. Etter det har vi implementert grensesnittmetoden “Orgname ()” i "ansatt" -klassen. Deretter, inne i vår "Main ()" -funksjon, har vi laget en forekomst av "ansattes" -klassen som heter "E1" og har initialisert "empname" -variabelen ved å bruke denne forekomsten. Til slutt har vi kalt både metodene i denne klassen eller sin egen medlemsfunksjon, så vel som metoden for grensesnittet implementert i denne klassen ved å bruke objektet.

For å utføre dette Dart -skriptet har vi brukt kommandoen gitt nedenfor:

$ dart kjører grensesnitt.Dart

Utgangen fra vårt første eksempel Dart -skript vises i følgende bilde. Det viktigste å bli lagt merke til i denne utgangen er at meldingen som er definert i "Orgname ()" -funksjonen til "Employee" -klassen, er skrevet ut på terminalen i stedet for nåtiden i grensesnittklassen. Det betyr at "ansattes" -klassen har implementert grensesnittklassen eller "organisasjon" -klassen.

Eksempel 2: Den manglende implementeringen av grensesnittmetoden i en DART -klasse:

Dette eksemplet er bare en litt modifisert versjon av vårt første eksempel. Gjennom dette eksemplet ønsker vi å lære deg hva som skjer når du hopper over implementeringen av noen av grensesnittmetodene i klassen som implementerer dette grensesnittet. For å gjøre dette har vi brukt det samme Dart -skriptet som vi har designet for eksemplet over. Denne gangen har vi imidlertid kommentert implementeringen av "Orgname ()" -funksjonen i "ansattes" -klassen som vist på bildet nedenfor:

Resten av skriptet er intakt. Etter å ha gjort denne modifiseringen, da vi prøvde å utføre DART -skriptet, mottok vi den runtime -feilen som ble vist i følgende bilde:

Denne feilmeldingen sier eksplisitt at vi har hoppet over implantasjonen av en grensesnittmetode i en klasse som implementerer dette grensesnittet. Det betyr at vi ikke kan utføre dette DART -skriptet med mindre vi gir en implementering av denne grensesnittmetoden i klassen som implementerer dette grensesnittet. Derfor er det obligatorisk å gi implementeringer av alle grensesnittmetodene i klassen som implementerer et spesifikt grensesnitt.

Eksempel 3: Implementering av flere grensesnitt i en enkelt DART -klasse:

Konseptet med å bruke grensesnittet i DART -programmeringsspråket kan også utvides til flere grensesnitt. En DART -klasse kan enkelt implementere flere grensesnitt om gangen. Dart -skriptet vist på bildet nedenfor er skrevet for å demonstrere dette:

I dette eksemplet har vi definert to grensesnitt i Dart: Organisasjon og leder, mens klassen "ansatt" implementerer begge disse grensesnittene. "Organisasjon" -klassen har bare en medlemsfunksjon som heter "Orgname ()". Tilsvarende har "Manager" -klassen bare en medlemsfunksjon som heter "Betegnelse ()". "Ansatt" -klassen som implementerer disse to grensesnittene har sin egen medlemsvariabel og en medlemsfunksjon.

Bortsett fra dette implementerer det også de to metodene til grensesnittet "organisasjon" og "manager". Deretter, i "Main ()" -funksjonen, har vi nettopp opprettet et objekt i "ansattes" -klassen og har fått tilgang til alle medlemsvariablene og funksjonene med dette objektet.

Utgangen fra dette Dart -skriptet vises i følgende bilde. Det innebærer at vi har implementert flere grensesnitt mens vi bruker DART -programmeringsspråket i Ubuntu 20.04.

Konklusjon:

Ved hjelp av denne opplæringen ønsket vi å forklare deg bruken av grensesnittene i DART -programmeringsspråket. Vi begynte først med en kort introduksjon til grensesnittene i Dart etterfulgt av noen få hovedegenskaper som er assosiert med DART -grensesnitt. Etter det delte vi deg tre forskjellige eksempler som implementerte DART -grensesnittene. Ved å gå gjennom disse eksemplene, vil du raskt kunne forstå bruken av grensesnittene i Dart.