Verschil tussen pakketten en interfaces in Java
Inhoud
Pakketten en interfaces fungeren beide als een container. De inhoud in pakketten en interfaces kan door de klassen worden gebruikt door het dienovereenkomstig te importeren en te implementeren. Het fundamentele verschil tussen pakketten en interfaces is dat een pakket een groep klassen en interfaces bevat, terwijl een interface methoden en velden bevat. Laten we enkele andere verschillen bestuderen met behulp van een vergelijkingstabel.
- Vergelijkingstabel
- Definitie
- Belangrijkste verschillen
- Gevolgtrekking
Vergelijkingstabel
| Basis voor vergelijking | Pakketjes | interfaces |
|---|---|---|
| basis- | Pakketten is een groep klassen en / of interfaces samen. | Interfaces is een groep abstracte methoden en constante velden. |
| keyword | Pakketten worden gemaakt met behulp van het trefwoord "Pakket". | Interface wordt gemaakt met behulp van het trefwoord "Interface". |
| Syntaxis | pakket pakketnaam; public class class_name { . (lichaam van klasse) . } | interface interface_name { variabele aangifte; methode verklaring; } |
| Toegang | Een pakket kan worden geïmporteerd | Een interface kan door een andere interface worden uitgebreid en door de klasse worden geïmplementeerd. |
| Toegang trefwoord | Pakketten kunnen worden geïmporteerd met het trefwoord "import". | Interfaces kunnen worden geïmplementeerd met het trefwoord 'implement'. |
Definitie van pakketten
Pakketten zijn een verzameling of groepen van verschillende klassen en interfaces. De klassen in pakketten zijn in zekere zin of door overerving aan elkaar gerelateerd. U kunt ook uw pakket maken en gebruiken voor uw programma.
Een pakket maken
Volg de volgende stappen om een pakket te maken.
- Open een bestand en geef vervolgens de naam van het pakket boven aan het bestand op, net zoals de pakketnaam de naam is die u aan het pakket wilt geven.
- Vervolgens definieert u een klasse die u in het pakket wilt opnemen en onthoudt u dat u deze openbaar maakt.
- Sla het bestand op als een .java-bestand en compileer het bestand. Vervolgens wordt ".class" voor dat bestand verkregen.
- Om een pakket voor dit bestand te maken, is de gebruikte opdracht "javac -d. file_name.java. U kunt zien dat het pakket is gemaakt met een ".class" -bestand in de huidige map. Gebruik “javac -d om het in de bovenliggende map te plaatsen. . opdracht bestandsnaam.java ”.
- U kunt ook een subpakket maken door de naam van het subpakket bovenaan het bestand aan te geven.
pakket Mypackage; public class myclass {public void displayMypackage () {system.out.ln ("methode displayMypackage van class myclass van pakket Mypackage"); }
Het pakket gebruiken
De pakketten die in de map zijn gemaakt of beschikbaar zijn, kunnen in het programma worden gebruikt met behulp van een import-instructie. De importverklaring kan op twee manieren worden geschreven, of u kunt zeggen dat er twee manieren zijn om toegang te krijgen tot elk pakket. Als u eerst een bepaalde klasse uit een pakket wilt gebruiken, wordt het sleutelwoord "importeren" gevolgd door de pakketnaam, gevolgd door de puntoperator en de klassennaam die u uit het pakket wilt gebruiken. Ten tweede, als u veel klassen wilt gebruiken die zich in de pakketten bevinden, dan wordt het importwoord gevolgd door de pakketnaam, gevolgd door de punt en de operator "*".
pakketnaam importeren. naam van de klasse; of import pakketnaam. *;
In bovenstaande code ziet u het * -teken dat aangeeft dat de tweede methode alle klassen in de pakketten importeert.
Laten we nu het gebruik van het pakket met een voorbeeld bekijken.
import Mypackage. myclass {class TestMypackage {public static void main (string args) {myclass ob1 = new myclass (); ob1.displayMypackage (); }} // outputmethode displayMypackage van klasse myclass van pakket Mypackage.
In bovenstaande code heeft de klasse TestMypackage het pakket Mypackage geïmporteerd en de methode displayMypackage () gebruikt.
Definitie van interface
Interface is een soort klasse, maar verschilt in zekere zin dat de in de interface gedeclareerde methoden abstract zijn, wat betekent dat de methoden alleen worden gedeclareerd, maar niet worden gedefinieerd. De velden in de interface zijn altijd openbaar, statisch, definitief. De velden moeten worden geïnitialiseerd op het moment van aangifte. De door de interface aangegeven methoden worden bepaald door de klasse die die interface implementeert volgens de vereiste. Omdat de methoden in de interface geen functie uitvoeren, heeft het geen zin om een object van de interface te maken. Daarom kan er geen object worden gemaakt voor de interface.
De interface kan ook de andere interface erven, maar de klasse die een dergelijke interface overneemt, moet ook alle methoden van de overgenomen interface implementeren. Omdat de velden worden geïnitialiseerd op het moment van hun verklaring in de interface, is er dus geen constructor nodig in de interface, daarom bevat de interface geen constructor. Laten we het voorbeeld bekijken van het maken en gebruiken van een interface.
interface Gebied {float pi = 3.14; float find_area (float a, float b) {} klasse Circle implementeert gebied {float find_area (float a, float b) {return (pi * a * a); } Class Shapes {public static void main (string args) {Area A = new Area (); Cirkel C = nieuwe cirkel (); A = C; float F = Gebied. find_area (10,10); system.out.ln ("Cirkelgebied is:" + F); }
In bovenstaande code hadden we een interface Area gemaakt en de klasse Circle heeft de interface Area geïmplementeerd. Het veld "pi" is op het moment van aangifte in de interface geïnitialiseerd. De klassencirkel heeft de abstracte methode van het klassengebied gedefinieerd volgens de vereiste.
- Een pakket is een groep klassen en interfaces samen, terwijl een interface een groep abstracte methoden is.
- Pakket wordt gemaakt met behulp van een trefwoord pakket terwijl een interface wordt gemaakt met behulp van een trefwoord koppel.
- Als een klasse of een interface binnen een pakket moet worden gebruikt, moet het pakket worden geïmporteerd terwijl een interface moet worden geïmplementeerd.
Gevolgtrekking:
Beide pakketten en interface zijn de containers. Pakket verkleint de code, omdat we de te gebruiken klasse importeren en niet opnieuw definiëren.Terwijl de interface de verwarring vermindert die zich heeft voorgedaan bij meerdere overervingen, omdat in het geval van meerdere overervingen de overervende klasse niet hoeft te beslissen welke definitie hij in plaats daarvan moet overnemen, deze zelf definieert.
