Aanbevolen, 2024

Editor'S Choice

Verschil tussen pakketten en interfaces in Java

Pakketten en interfaces werken beide als een container. De inhoud in pakketten en interfaces kan door de klassen worden gebruikt door deze overeenkomstig 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 een aantal andere verschillen bestuderen met behulp van een vergelijkingstabel.

Vergelijkingstabel

Basis voor vergelijkingPakketjesinterfaces
basis-Pakketten is een groep klassen en / of interfaces samen.Interfaces is een groep abstracte methoden en constante velden.
keywordPakketten worden gemaakt met het sleutelwoord "Pakket".Interface wordt gemaakt met het sleutelwoord "Interface".
Syntaxispakket package_name;
public class class_name {
.
(lichaam van klasse)
.
}
interface interface_naam {
variabele verklaring;
methode verklaring;
}
ToegangEen pakket kan worden geïmporteerdEen interface kan worden uitgebreid met een andere interface en door de klas worden geïmplementeerd.
Toegang sleutelwoordPakketten kunnen worden geïmporteerd met behulp van het sleutelwoord "Importeren".Interfaces kunnen worden geïmplementeerd met behulp van het sleutelwoord "implementeren".

Definitie van pakketten

Pakketten zijn verzameling of groepen van de verscheidenheid aan klassen en interfaces. De klassen in pakketten zijn in een bepaald bereik of door overerving aan elkaar gerelateerd. U kunt uw pakket ook maken en gebruiken voor uw programma.

Een pakket maken

Volg de volgende stappen om een ​​pakket te maken.

  1. Open een bestand en declareer vervolgens de naam van het pakket bovenaan het bestand, zoals [package package_name; ] de pakketnaam is de naam die u aan het pakket wilt geven.
  2. Vervolgens definieert u een klasse die u in het pakket wilt plaatsen en onthoudt dat u deze openbaar verklaart.
  3. Sla het bestand op als een .java-bestand en compileer het bestand, dan wordt ".class" verkregen voor dat bestand.
  4. 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. . file_name.java "commando.
  5. U kunt ook een subverpakking maken door subpackage-naam te declareren als [pakket package_name1. package_name2; ] bovenaan het bestand.
 pakket Mypackage; public class myclass {public void displayMypackage () {system.out.println ("method displayMypackage of class myclass of package Mypackage"); } 

Het pakket gebruiken

De pakketten die zijn gemaakt of beschikbaar zijn in de map, kunnen in het programma worden gebruikt met behulp van een importinstructie. Het sleutelwoord dat wordt gebruikt om elk pakket in uw programma te importeren, is "importeren". De importinstructie kan op twee manieren worden geschreven, of u kunt zeggen dat er op twee manieren toegang kan worden verkregen tot elk pakket. Ten eerste, als u een bepaalde klasse uit een pakket wilt gebruiken, wordt het sleutelwoord "import" gevolgd door de pakketnaam gevolgd door de puntoperator en de klassenaam die u uit het pakket wilt gebruiken. Ten tweede, als u veel klassen wilt gebruiken die in de pakketten zitten, wordt het trefwoord voor importeren gevolgd door de pakketnaam gevolgd door de punt en de operator "*".

 import pakketnaam. naam van de klasse; of importeer pakketnaam. *; 

In de bovenstaande code ziet u het * -teken dat aangeeft dat de tweede methode alle klassen in de pakketten importeert.

Laten we nu eens kijken naar het gebruik van het pakket met een voorbeeld.

 Mypackage importeren. myclass {class TestMypackage {public static void main (string args []) {myclass ob1 = new myclass (); ob1.displayMypackage (); }} // weergave uitvoermethodeMapackage 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 van het feit dat de in de interface gedeclareerde methoden abstract zijn, wat betekent dat de methoden alleen worden gedeclareerd maar niet gedefinieerd. De velden in de interface zijn altijd openbaar, statisch, definitief. De velden moeten worden geïnitialiseerd op het moment van aangifte. De methoden die door de interface worden gedeclareerd, worden gedefinieerd door de klasse die die interface implementeert overeenkomstig de vereiste. Omdat de methoden in de interface geen functie uitvoeren, is het niet nodig om een ​​object van de interface te maken. Daarom kan er geen object voor de interface worden gemaakt.

De interface kan ook de andere interface overnemen, maar de klasse die een dergelijke interface overerft, moet ook alle methoden van de overgeërfde interface implementeren. Omdat de velden worden geïnitialiseerd op het moment van hun declaratie in de interface, is er dus geen constructor nodig in de interface en daarom bevat de interface geen constructor. Laten we eens kijken naar het voorbeeld van het maken en gebruiken van een interface.

 interface Area {float pi = 3.14; float find_area (float a, float b) {} class Circle implementeert gebied {float find_area (float a, float b) {return (pi * a * a); } Klasse Shapes {public static void main (string args []) {Area A = new Area (); Cirkel C = nieuwe cirkel (); A = C; zweven F = Gebied. find_area (10, 10); system.out.println ("Gebied van de cirkel is:" + F); } 

In de bovenstaande code hadden we een interface Area gemaakt en de klasse Circle heeft de interface Area geïmplementeerd. Het veld "pi" is geïnitialiseerd in de interface ten tijde van de declaratie. De klasse Circle heeft de abstracte methode van het klasgebied gedefinieerd op basis van zijn vereiste.

Belangrijkste verschillen tussen pakketten en interfaces in Java

  1. Een pakket is een groep klassen en interfaces samen, terwijl een interface een groep abstracte methoden is.
  2. Pakket wordt gemaakt met behulp van een trefwoordpakket , terwijl een interface wordt gemaakt met behulp van een sleutelwoordinterface.
  3. Als een klasse of interface in een pakket wordt gebruikt, kan het pakket worden geïmporteerd terwijl een interface moet worden geïmplementeerd.

Conclusie:

Beide pakketten en interface zijn de containers. Pakket verkleint de grootte van de code, we importeren gewoon de klasse die moet worden gebruikt in plaats van deze opnieuw te definiëren. Terwijl de interface de verwarringen vermindert die zich voordoen terwijl meerdere overervingen plaatsvinden, omdat in het geval van meerdere erfenissen de overervingsklasse niet hoeft te beslissen welke definitie van welke methode moet overerven, maar dat deze de eigen methode definieert.

Top