Pakketten in Java: hoe pakketten in Java maken en gebruiken?

Een van de meest innovatieve is het concept van pakketten.Pakketten in Java zijn een manier om een ​​groep klassen, interfaces, opsommingen, annotaties en subpakketten in te kapselen. Conceptueel kunt u Java-pakketten zien als vergelijkbaar met verschillende mappen op uw computer. In deze zelfstudie behandelen we de basisprincipes van pakketten in

Hieronder staan ​​de onderwerpen die in dit artikel aan bod komen:

• Wat is pakket in Java?
• Ingebouwde pakketten
• Door de gebruiker gedefinieerde pakketten
  • Een pakket maken in Java
  • Inclusief een Class in Java-pakket
  • Een klasse binnen een pakket maken tijdens het importeren van een ander pakket
  • Gebruik een volledig gekwalificeerde naam tijdens het importeren van een klas
• Statische import in Java
• Toegangsbeveiliging in Java-pakketten
• Punten om te onthouden

Wat is pakket in Java?

Java-pakket is een mechanisme voor het groeperen van vergelijkbare typen klassen, interfaces en subklassen gezamenlijk op basis van functionaliteit. Als software is geschreven in het , kan het bestaan ​​uit honderden of zelfs duizenden individuele klassen. ikHet is logisch om dingen georganiseerd te houden door gerelateerde klassen en interfaces in pakketten te plaatsen.

Het gebruik van pakketten tijdens het coderen biedt veel voordelen, zoals:

• • Herbruikbaarheid: De klassen in de pakketten van een ander programma kunnen eenvoudig worden hergebruikt
  • Naamconflicten: Pakketjeshelpen ons om een ​​unieke klasse te identificeren die we bijvoorbeeld kunnen hebben company.sales.Employee en company.marketing.Employee klassen
  • Gecontroleerde toegang: Aanbiedingen toegangsbeveiliging zoals pgeroteerde klassen, standaardklassen en privéklassen
  • Data-inkapseling : Ze pzoek een manier om klassen te verbergen, waardoor andere programma's geen toegang krijgen tot klassen die alleen voor intern gebruik bedoeld zijn
  • Onderhoud: Met pakketten,u kunt uw project beter organiseren en gemakkelijk gerelateerde klassen vinden

Het is een goede gewoonte om pakketten te gebruiken tijdens het coderen in Java. Als programmeur kan datgemakkelijk de , interfaces, opsommingen en annotaties die gerelateerd zijn. We hebben twee soorten pakketten in java.

Soorten pakketten in Java

Afhankelijk van het feit of het pakket door de gebruiker is gedefinieerd of niet, worden pakketten onderverdeeld in twee categorieën:

1. Ingebouwde pakketten
2. Door de gebruiker gedefinieerde pakketten

Ingebouwde pakketten

Ingebouwde pakketten of voorgedefinieerde pakketten zijn pakketten die als onderdeel van (Java Development Kit) om de taak van Java-programmeur te vereenvoudigen. Ze bestaan ​​uit een groot aantal voorgedefinieerde klassen en interfaces die deel uitmaken van Java API's. Enkele van de veelgebruikte ingebouwde pakketten zijn java.lang, java.io, java.util, java.applet, enz. Hier is een eenvoudig programma dat een ingebouwd pakket gebruikt.

pakket Edureka import java.util.ArrayList klasse BuiltInPackage {public static void main (String [] args) {ArrayList myList = nieuwe ArrayList (3) myList.add (3) myList.add (2) myList.add (1) System. out.println ('De elementen van de lijst zijn:' + myList)}}

Uitgang:

De elementen van de lijst zijn: [3, 2, 1]

De klasse ArrayList behoort tot het pakket java.util. Om het te gebruiken, moeten we het pakket importeren met behulp van de importverklaring. De eerste regel van de code importeer java.util.ArrayList importeert het pakket java.util en gebruikt die aanwezig is in het subpakket util.

Door de gebruiker gedefinieerde pakketten

Door de gebruiker gedefinieerde pakketten zijn pakketten die door gebruikers zijn ontwikkeld om gerelateerde klassen, interfaces en subpakketten te groeperen. Laten we met behulp van een voorbeeldprogramma kijken hoe we pakketten kunnen maken, Java-programma's in de pakketten kunnen compileren en ze kunnen uitvoeren.

Een pakket maken in Java

Het maken van een pakket in Java is een zeer gemakkelijke taak. Kies een naam voor het pakket en voeg een pakket commando als de eerste instructie in het Java-bronbestand. Het Java-bronbestand kan de klassen, interfaces, opsommingen en annotatietypen bevatten die u in het pakket wilt opnemen.Met de volgende instructie wordt bijvoorbeeld een pakket gemaakt met de naam Mijn pakketje.

pakket MyPackage

De pakketinstructie specificeert eenvoudig tot welk pakket de gedefinieerde klassen behoren.

Opmerking: Als u de pakketinstructie weglaat, worden de klassenamen in het standaardpakket geplaatst, dat geen naam heeft. Hoewel het standaardpakket prima is voor korte programma's, is het onvoldoende voor echte toepassingen.

Inclusief een Class in Java-pakket

Naarmaak een klasse in een pakket, dat zou je moeten doendeclareer de pakketnaam als de eerste instructie van uw programma. Voeg dan de les toe als onderdeel van het pakket. Maar onthoud dat een klasse slechts één pakketverklaring kan hebben. Hier is een eenvoudig programma om het concept te begrijpen.

pakket MyPackage public class Compare {int num1, num2 Compare (int n, int m) {num1 = n num2 = m} public void getmax () {if (num1> num2) {System.out.println ('Maximale waarde van twee nummers is '+ num1)} else {System.out.println (' Maximale waarde van twee nummers is '+ num2)}} public static void main (String args []) {Compare current [] = new Compare [3] current [1] = nieuwe vergelijking (5, 10) huidig ​​[2] = nieuwe vergelijking (123, 120) voor (int i = 1 i<3 i++) { current[i].getmax() } } } 

Uitgang:

Maximale waarde van twee nummers is 10 Maximale waarde van twee nummers is 123

Zoals je kunt zien, heb ik een pakket met de naam MyPackage gedeclareerd en een klasse Compare binnen dat pakket gemaakt. Java gebruikt bestandssysteemmappen om pakketten op te slaan. Dit programma wordt dus in een bestand opgeslagen als Compare.java en wordt opgeslagen in de map genaamd MyPackage. Wanneer het bestand wordt gecompileerd, maakt Java een .klasse bestand en sla het op in dezelfde map. Onthoud dat de naam van het pakket hetzelfde moet zijn als de directory waarin dit bestand is opgeslagen.

Je vraagt ​​je misschien af ​​hoe je deze Compare-klasse uit een klas in een ander pakket kunt gebruiken?

Een klasse binnen een pakket maken tijdens het importeren van een ander pakket

Nou, het is heel simpel. U hoeft het alleen maar te importeren. Als het eenmaal is geïmporteerd, kunt u het openen met de naam. Hier is een voorbeeldprogramma dat het concept demonstreert.

pakket Edureka import MyPackage.Compare public class Demo {public static void main (String args []) {int n = 10, m = 10 Compare current = new Compare (n, m) if (n! = m) {current.getmax ()} else {System.out.println ('Beide waarden zijn hetzelfde')}}}

Uitgang:

Beide waarden zijn hetzelfde

Ik heb eerst het pakket aangegeven Edureka , en vervolgens de klasse geïmporteerd Vergelijken uit het pakket MyPackage. Dus de volgordewanneer we een klasse binnen een pakket maken terwijl we een ander pakket importeren,

• Pakketverklaring
• Pakket importeren

Als u de importinstructie niet wilt gebruiken, is er nog een alternatief om toegang te krijgen tot een klassebestand van het pakket vanuit een ander pakket. U kunt gewoon de volledig gekwalificeerde naam gebruiken tijdens het importeren van een .

Gebruik een volledig gekwalificeerde naam tijdens het importeren van een klas

Hier is een voorbeeld om het concept te begrijpen. Ik ga hetzelfde pakket gebruiken dat ik eerder in de blog heb aangegeven, Mijn pakketje .

pakket Edureka public class Demo {public static void main (String args []) {int n = 10, m = 11 // Volledig gekwalificeerde naam gebruiken in plaats van MyPackage.Compare huidige = nieuwe MyPackage.Compare (n, m) if ( n! = m) {current.getmax ()} anders {System.out.println ('Beide waarden zijn hetzelfde')}}}

Uitgang:

De maximale waarde van twee getallen is 11

In de Demo-klasse heb ik in plaats van het pakket te importeren de volledig gekwalificeerde naam gebruikt, zoals MyPackage.Compare om het object ervan te creëren. Omdat we het hebben over het importeren van pakketten, kun je net zo goed het concept van statische import in Java bekijken.

Statische import in Java

Statische importfunctie is geïntroduceerd in vanaf versie 5. Het vergemakkelijkt de Java-programmeur om toegang te krijgen tot alle statische gegevensrechtstreeks lid van een klas zonder de volledig gekwalificeerde naam te gebruiken.

pakket MyPackage import statische java.lang.Math. * // statische import import statische java.lang.System. * // statische import public class StaticImportDemo {public static void main (String args []) {double val = 64.0 double sqroot = sqrt (val) // Toegang tot de sqrt () methode direct out.println ('Sq. root van' + val + 'is' + sqroot) // We hoeven 'System.out}} niet te gebruiken

 Uitgang: 

Sq. root van 64.0 is 8.0

Hoewel het gebruik van statische import minder codering met zich meebrengt, kan overmatig gebruik het programma onleesbaar en ononderhoudbaar maken. Laten we nu naar het volgende onderwerp gaan, toegangscontrole in pakketten.

Toegangsbeveiliging in Java-pakketten

U kent mogelijk verschillende aspecten van het toegangscontrolemechanisme van Java en de bijbehorende toegangsspecificaties . Pakketten in Java voegen een extra dimensie toe aan toegangscontrole. Zowel lessen als pakketten zijn een middel van data inkapseling . Terwijl pakketten fungeren als containers voor klassen en andere ondergeschikte pakketten, fungeren klassen als containers voor gegevens en code. Vanwege dit samenspel tussen pakketten en klassen, behandelen Java-pakketten vier categorieën van zichtbaarheid voor klasleden:

• Subklassen in hetzelfde pakket
• Niet-subklassen in hetzelfde pakket
• Subklassen in verschillende pakketten
• Klassen die niet in hetzelfde pakket of subklassen zitten

De onderstaande tabel geeft eenecht beeld van welk type toegang mogelijk is en welke niet bij het gebruik van pakketten in Java:

We kunnen de gegevens in de bovenstaande tabel als volgt vereenvoudigen:

1. Alles wat openbaar wordt verklaard, is overal toegankelijk
2. Alles dat privé is verklaard, kan alleen binnen die klasse worden bekeken
3. Als er geen toegangsspecificatie wordt vermeld, is een element zowel zichtbaar voor subklassen als voor andere klassen in hetzelfde pakket
4. Ten slotte kan alles wat als beschermd element wordt verklaard, buiten uw huidige pakket worden gezien, maar alleen voor klassen die uw klasse rechtstreeks onderklassen

Op deze manier bieden Java-pakketten toegangscontrole tot de klassen. Welnu, hiermee is het concept van pakketten in Java afgerond. Hier zijn enkele punten waarmee u rekening moet houden bij het gebruik van pakketten in .

Punten om te onthouden

• Elke les maakt deel uit van een pakket. Als u de pakketinstructie weglaat, worden de klassenamen in het standaardpakket geplaatst
• Een klasse kan slechts één pakketinstructie hebben, maar het kan meer dan één importpakketinstructie hebben
• De naam van het pakket moet hetzelfde zijn als de directory waarin het bestand is opgeslagen
• Bij het importeren van een ander pakket moet de pakketverklaring de eerste instructie zijn, gevolgd door de pakketimport

Dit brengt ons bij het einde van dit ‘Pakketten in Java’ artikel. We leerdenwat een pakket is en waarom we ze zouden moeten gebruiken. Het lijdt geen twijfel dat het Java-pakket een van de belangrijkste onderdelen is voor efficiënte java-programmeurs. Het verbetert niet alleen de coderingsstijl van de programmeur, maar vermindert ook veel extra werk.

Als je dit artikel over 'Pakketten in Java' hebt gevonden, bekijk dan het door Edureka, een vertrouwd online leerbedrijf met een netwerk van meer dan 250.000 tevreden leerlingen verspreid over de hele wereld. We zijn hier om je te helpen bij elke stap op je reis, om naast deze Java-interviewvragen ook een curriculum te bedenken dat is ontworpen voor studenten en professionals die een Java-ontwikkelaar willen worden.