Sammenligningstabel
| 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 er opprettet ved hjelp av "Pakke" søkeord. | Grensesnitt er opprettet ved hjelp av "Interface" søkeord. |
| syntax | pakke pakke navn; offentlig klasse klassenavn { . (kroppens klasse) . } | grensesnitt grensesnittnavn { variabel deklarasjon; metoden deklarasjon; } |
| Adgang | En pakke kan importeres | Et grensesnitt kan utvides med et annet grensesnitt og implementeres av klassen. |
| Få tilgang til søkeord | Pakker kan importeres ved hjelp av "import" søkeord. | Grensesnitt kan implementeres ved hjelp av "implementere" søkeord. |
Definisjon av pakker
Pakker er samling eller grupper av forskjellige klasser og grensesnitt. Klassene i pakker er knyttet til hverandre i noen omfang eller ved arv. Du kan også lage din pakke og bruke den til programmet.
Opprette en pakke
For å lage en pakke følger du bare de følgende trinnene.
- Åpne en fil, og oppgi navnet på pakken øverst i filen, for eksempel [pakke pakkenavn; ] Pakkenavnet er navnet du vil gi til pakken.
- Deretter definerer du en klasse som du vil legge inn i pakken, og husk at du erklærer den offentlig.
- Lagre filen som en .java-fil, og kompilér filen deretter, så får du ".class" for den filen.
- For å lage 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 gjeldende katalog. For å plassere den i foreldre katalog bruk "javac -d. . filen_name.java "-kommandoen.
- Du kan også lage en underpakke ved å erklære underpakke navn som [pakke pakke navn 1. package_name2; ] øverst på filen.
pakke Mypackage; offentlig klasse myclass {public void displayMypackage () {system.out.println ("metoden displayMypackage av klasse myclass av pakken Mypackage"); } Bruk av pakken
Pakken som er opprettet eller tilgjengelig i katalogen, kan brukes i programmet ved å bruke en importoppgave. Søkeordet som brukes til å importere en pakke i programmet, 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. Først, hvis du vil bruke en bestemt klasse fra en pakke, følger "Import" -ordet etterfulgt av pakkenavnet videre etterfulgt av prikkoperatøren og klassenavnet du vil bruke fra pakken. For det andre, hvis du vil bruke mange klasser som finnes i pakkene, følger importordet etterfølger av pakkenavnet videre etterfulgt av prikken og operatøren "*".
importer pakkenavn. klassenavn; eller importer pakkenavn. *;
I overkoden kan du se * -tegnet som indikerer at andre metode importerer alle klassene i pakken.
La oss nå se bruken av pakken med et eksempel.
importer Mypackage. myclass {class TestMypackage {public static void main (string args []) {myclass ob1 = new myclass (); ob1.displayMypackage (); }} // utgangsmetode displayMypackage av klasse myclass av pakken Mypackage. I overkoden har klassen TestMypackage importert pakken Mypackage og brukt sin displayMypackage () -metode.
Definisjon av grensesnitt
Grensesnitt er en slags en klasse, men er forskjellig på en måte at metodene som er oppgitt 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å tidspunktet for deklarasjonen. Metodene deklarert av grensesnittet er definert av klassen som implementerer det grensesnittet i henhold til kravet. Da metodene i grensesnittet ikke utfører noen funksjon, så er det ikke noe å skape noe objekt for grensesnittet. Derfor kan ingen objekt opprettes for grensesnittet.
Grensesnittet kan også arve det andre grensesnittet, men klassen som arver et slikt grensesnitt må også implementere alle metodene for det arvede grensesnittet. Som feltene initialiseres ved tidspunktet for deres erklæring i grensesnittet, så det er ikke behov for en konstruktør i grensesnittet, derfor inneholder grensesnittet ingen konstruktør. La oss se eksemplet på å opprette og bruke et grensesnitt.
grensesnitt område {float pi = 3, 14; float find_area (float a, float b) {} klasse Sirkelredskaper Area {float find_area (float a, float b) {retur (pi * a * a); } Klasseformer {offentlig statisk tomt hoved (streng args []) {Område A = nytt Område (); Sirkel C = Ny sirkel (); A = C; flyte F = Areal. find_area (10, 10); system.out.println ("Sirkelområde er:" + F); } I over kode, hadde vi opprettet et grensesnittområde, og klassen Circle har implementert grensesnittet. Feltet "pi" har blitt initialisert i grensesnittet på tidspunktet for dets erklæring. Klassesirkelen har definert abstraktmetoden til klasserommet i henhold til kravet.
Viktige forskjeller mellom pakker og grensesnitt i Java
- En pakke er en gruppe klasser og grensesnitt sammen, mens et grensesnitt er en gruppe abstrakte metoder.
- Pakken er opprettet ved hjelp av en søkeordpakke , mens et grensesnitt er opprettet ved hjelp av et søkeordgrensesnitt.
- Hvis en klasse eller et grensesnitt i en pakke skal brukes, skal pakker som skal importeres mens et grensesnitt skal implementeres.
Konklusjon:
Både pakker og grensesnitt er beholderne. Pakken reduserer størrelsen på koden som vi bare importerer klassen som skal brukes i stedet for å definere den igjen. Mens grensesnittet reduserer forvirringene oppstått under flere arv, fordi i arvelige klasser ikke i den arvelige klassen å bestemme hvilken definisjon av hvilken metode den skal arve i stedet definerer den sin egen.
