Forskjellen mellom pakker og grensesnitt i Java
Innhold
Pakker og grensesnitt fungerer begge som en container. Innholdet i pakker og grensesnitt kan brukes av klassene ved å importere og implementere det tilsvarende. Den grunnleggende forskjellen mellom pakker og grensesnitt er at en pakke inneholder en gruppe klasser og grensesnitt, mens et grensesnitt inneholder metoder og felt. La oss studere noen andre forskjeller ved hjelp av sammenligningskart.
- Sammenligningstabell
- Definisjon
- Viktige forskjeller
- Konklusjon
Sammenligningstabell
| Grunnlag for sammenligning | pakker | grensesnitt |
|---|---|---|
| grunn~~POS=TRUNC | Pakker er en gruppe klasser og / eller grensesnitt sammen. | Grensesnitt er en gruppe abstrakte metoder og konstante felt. |
| søkeord | Pakker opprettes ved hjelp av "Pakke" nøkkelord. | Grensesnitt opprettes ved hjelp av "Grensesnitt" nøkkelord. |
| syntax | pakke pakkenavn; public class class_name { . (klasse av klasse) . } | grensesnitt grensesnittnavn { variabel erklæring; metodedeklarasjon; } |
| Adgang | En pakke kan importeres | Et grensesnitt kan utvides med et annet grensesnitt og implementeres av klassen. |
| Få tilgang til nøkkelord | Pakker kan importeres ved hjelp av "import" nøkkelord. | Grensesnitt kan implementeres ved hjelp av "implementer" nøkkelord. |
Definisjon av pakker
Pakker er samling eller grupper av forskjellige klasser og grensesnitt. Klassene i pakker er relatert til hverandre i et visst omfang eller etter arv. Du kan også opprette pakken og bruke den til programmet ditt.
Lage en pakke
Følg trinnene nedenfor for å lage en pakke.
- Åpne en fil og erklær deretter navnet på pakken øverst i filen, som at pakkenavnet er navnet du vil gi pakken.
- Deretter definerer du en klasse du vil legge i pakken, og husk at du erklærer den for offentlig.
- Lagre filen som en .java-fil og kompiler deretter filen, da er ".class" skaffet for den filen.
- For å opprette en pakke for denne filen er kommandoen som brukes “javac -d. file_name.java. Du kan se at pakken er opprettet som inneholder en ”.class” -fil i den gjeldende katalogen. Bruk "javac -d for å plassere den i foreldrekatalogen. . file_name.java ”-kommando.
- Du kan også opprette en underpakke ved å oppgi navnet på pakken som øverst i filen.
pakke Mypackage; public class myclass {public void displayMypackage () {system.out.ln ("metodevisningMypackage of class myclass of package Mypackage"); }
Bruke pakken
Pakkene som er opprettet eller tilgjengelige i katalogen, kan brukes i programmet ved å bruke en importerklæring. Nøkkelordet som brukes til å importere en hvilken som helst pakke i programmet ditt er "import". Importoppgaven kan skrives på to måter, eller du kan si at det er to måter å få tilgang til hvilken som helst pakke. For det første, hvis du vil bruke en bestemt klasse fra en pakke, blir "import" nøkkelordet fulgt av pakkenavnet videre etterfulgt av prikkoperatøren og klassens navn som du vil bruke fra pakken. For det andre, hvis du vil bruke mange klasser som er inneholdt i pakkene, følges importnøkkelordet av pakkenavnet videre etterfulgt av prikken og operatøren "*".
importer pakkenavn. klassenavn; eller importer pakkenavn. *;
I koden over kan du se * -tegnet som indikerer at den andre metoden importerer alle klassene i pakkene.
La oss se bruken av pakken med et eksempel.
importer Mypackage. myclass {class TestMypackage {public static void main (string args) {myclass ob1 = new myclass (); ob1.displayMypackage (); }} // output method displayMypackage of class myclass of package Mypackage.
I koden over har klassen TestMypackage importert pakken Mypackage og brukt sin displayMypackage () -metode.
Definisjon av grensesnitt
Grensesnitt er en slags klasse, men skiller seg ut i en forstand at metodene som er erklært i grensesnittet er abstrakte, noe som betyr at metodene bare er deklarert, men ikke definert. Feltene i grensesnittet er alltid offentlige, statiske, endelige. Feltene må initialiseres på erklæringstidspunktet. Metodene deklarert av grensesnittet er definert av klassen som implementerer det grensesnittet i samsvar med dets krav. Ettersom metodene i grensesnittet ikke utfører noen funksjon, så det ikke nytter å lage noe objekt i grensesnittet. Derfor kan ingen objekter opprettes for grensesnittet.
Grensesnittet kan også arve det andre grensesnittet, men klassen som arver et slikt grensesnitt må også implementere alle metodene til det arvede grensesnittet. Siden feltene initialiseres på tidspunktet for deres erklæring i grensesnittet, så det ikke er behov for konstruktør i grensesnittet, inneholder grensesnittet ingen konstruktører. La oss se eksemplet på å lage og bruke et grensesnitt.
grensesnitt Areal {float pi = 3,14; float find_area (float a, float b) {} class Circle implementerer Areal {float find_area (float a, float b) {return (pi * a * a); } Klasseformer {public static void main (string args) {Area A = new Area (); Sirkel C = ny sirkel (); A = C; float F = Areal. find_area (10,10); system.out.ln ("Område i sirkelen er:" + F); }
I koden over hadde vi opprettet et grensesnittområde, og klassen Circle har implementert grensesnittområdet. Feltet "pi" er initialisert i grensesnittet på tidspunktet for erklæringen. Klassen Circle har definert den abstrakte metoden for klasseområdet i henhold til kravet.
- En pakke er en gruppe klasser og grensesnitt sammen, mens grensesnittet er en gruppe av abstrakte metoder.
- Pakken opprettes ved hjelp av et nøkkelord pakke mens et grensesnitt opprettes ved hjelp av et nøkkelord grensesnitt.
- Hvis en klasse eller et grensesnitt i en pakke skal brukes, er pakken som skal importeres mens et grensesnitt må implementeres.
Konklusjon:
Både pakker og grensesnitt er containerne. Pakken reduserer størrelsen på koden da vi bare importerer klassen som skal brukes i stedet for å definere den igjen.Mens grensesnittet reduserer forvirringene som skjedde mens flere arv fordi i tilfelle av flere arver, arver klassen ikke har til å bestemme den definisjonen av hvilken metode den skal arve i stedet for den definerer sin egen.
