Pakketten in Java zijn een mechanisme dat een groep subpakketten en interfaces van klassen omvat. Pakketten worden gebruikt voor:

• Voorkom naamgevingsconflicten door toe te staan ​​dat klassen met dezelfde naam in verschillende pakketten voorkomen, zoals college.staff.cse.Employee en college.staff.ee.Employee.
• Maak het eenvoudiger om klasseninterfaces en andere componenten te ordenen en te gebruiken.
• Bied gecontroleerde toegang voor beveiligde leden die toegankelijk zijn binnen hetzelfde pakket en via subklassen. Standaardleden (geen toegangsspecificatie) zijn alleen toegankelijk binnen hetzelfde pakket.

Door gerelateerde klassen in pakketten te groeperen bevordert Java de inkapseling van gegevens, waardoor code herbruikbaar en gemakkelijker te beheren is. Importeer eenvoudigweg de gewenste klasse uit een pakket om deze in uw programma te gebruiken.

Aangepaste pakketten maken

Stap 1: Maak een map waarin we onze pakketten en Java-bestanden maken.

mkdir-PROGRAMMERING

netwerktopologieën

Stap 2: Wijzig nu de map en maak een andere map in de hoofdmap

cd-PROGRAMMERING
mkdir JavaProgramming
cd Java-programmering
mkdir-arrays

Stap 3: Maak nu een leeg tekstbestand en schrijf de onderstaande Java-code en vergeet niet deze op te slaan met dezelfde naam als de klasse met de .java-extensie (TwoPointers.java)

TwoPointers-klasse.

package JavaProgramming.arrays; // Main class present inside the package  public class TwoPointers {  public static void main(String[] args) {  System.out.println('Inside the package');  } } 

Opmerking: Vergeet niet de pakketnaam toe te voegen aan het programmabestand.

Stap 4: Voer nu het programma uit met het gedefinieerde mappad

javac srcJavaProgrammingarraysTwoPointers.java

java srcJavaProgrammingarraysTwoPointers.java

Uitgang:

Mappenstructuur:

Dit is de visuele weergave van een aangepast pakket in Java in de onderstaande afbeelding. Eerst maken we een map met de naam Progamming en daarin maken we een pakket Javaprogramming en maken vervolgens een ander subpakket met de naam arrays . Vervolgens maken we er een Java-klassebestand in, dat wordt weergegeven in de onderstaande afbeelding:

Werken met Java-pakketten

Directorystructuur: Pakketnamen en mapstructuren zijn nauw verwant. Als een pakketnaam bijvoorbeeld college.staff.cse is, dan zijn drie mappen college staff en cse, waarbij cse binnen staff staat en staff binnen het college.

Naamgevingsconventies : Pakketnamen worden in omgekeerde volgorde van domeinnamen geschreven, b.v. org.geeksforgeeks.practice. Op een universiteit zou de conventie kunnen zijn:

• college.tech.cse
• college.tech.ee
• college.kunstgeschiedenis

Voorbeeld:

java.util.* importeren;

Hier is util een subpakket dat in het Java-pakket is gemaakt.  

Toegang krijgen tot klassen binnen een pakket

In Java kunnen we klassen uit een pakket importeren met behulp van een van de volgende methoden:

1. Importeer een specifieke klasse :

java.util.Vector importeren;

Hiermee importeert u alleen de klasse Vector uit het pakket java.util.

2. Importeer alle klassen uit een pakket :

java.util.* importeren;

Hiermee worden alle klassen en interfaces uit het java.util-pakket geïmporteerd, maar geen subpakketten.

Voorbeeld: Importeer de Vector-klasse

import java.util.Vector; public class Geeks {    public Geeks() {    // java.util.Vector is imported We are able to access it directly in our code.  Vector v = new Vector();    java.util.ArrayList l = new java.util.ArrayList();  l.add(3);  l.add(5);  l.add(7);    System.out.println(l);  }  public static void main(String[] args) {      new Geeks();  } } 

[3 5 7] 

Opmerking:

• Importpakket gebruiken.*; importeert alle klassen in een pakket, maar niet de klassen uit de subpakketten ervan.
• Wanneer twee pakketten klassen met dezelfde naam hebben (bijvoorbeeld java.util.Date en my.package.Date), gebruik dan de volledig gekwalificeerde naam om conflicten te voorkomen:

java.util.Date importeren;

binaire boom java

importeer mijn.pakket.Datum;

Soorten Java-pakketten

• Ingebouwde pakketten
• Door de gebruiker gedefinieerde pakketten

1. Ingebouwde pakketten

Deze pakketten bestaan ​​uit een groot aantal klassen die deel uitmaken van Java API Enkele veelgebruikte ingebouwde pakketten zijn:

• java.lang : Bevat taalondersteuningsklassen (bijvoorbeeld klassen die wiskundige bewerkingen van primitieve gegevenstypen definiëren). Dit pakket wordt automatisch geïmporteerd.
• java.io: Bevat klassen voor het ondersteunen van invoer-/uitvoerbewerkingen.
• java.util : Bevat hulpprogrammaklassen die datastructuren zoals Linked List Dictionary implementeren en ondersteunen; voor datum-/tijdbewerkingen.
• java.applet: Bevat klassen voor het maken van applets.
• java.aut: Bevat klassen voor het implementeren van de componenten voor grafische gebruikersinterfaces (zoals knoppen, menu's enz.). 6)
• java.net: Bevat klassen voor het ondersteunen van netwerkbewerkingen.

2. Door de gebruiker gedefinieerde pakketten

Dit zijn de pakketten die door de gebruiker zijn gedefinieerd.

1. Maak het pakket:

Eerst maken we een directory myPackage aan (de naam moet hetzelfde zijn als de naam van het pakket). Maak vervolgens de MyClass in de map, waarbij de eerste instructie de pakketnamen zijn.

Voorbeeld:

package myPackage; public class MyClass {  public void getNames(String s)  {   System.out.println(s);   } } 

2. Gebruik het Class in-programma:

Nu zullen we gebruik maken van de MijnKlasse klasse in ons programma.

 import myPackage.MyClass; public class Geeks {  public static void main(String args[]) {     // Initializing the String variable with a value   String s = 'GeeksforGeeks';    // Creating an instance of class MyClass in the package.  MyClass o = new MyClass();    o.getNames(s);  } } 

Opmerking: MyClass.java moet worden opgeslagen in de map myPackage, aangezien het deel uitmaakt van het pakket.  

Statische import in Java

Statische import in Java gaat over het vereenvoudigen van de toegang tot statische leden en scheidt dit van de bredere discussie over door de gebruiker gedefinieerde pakketten.

Java-scannerklasse

Statische import is een functie geïntroduceerd in de Java-programmeertaal (versies 5 en hoger) waarmee leden (velden en methoden) in een klasse als openbaar kunnen worden gedefinieerd statisch te gebruiken in Java-code zonder de klasse op te geven waarin het veld is gedefinieerd.

Voorbeeld:

import static java.lang.System.*; class Geeks {  public static void main(String args[]) {    // We don't need to use 'System.out' as imported using static.  out.println('GeeksforGeeks');  } } 

GeeksforGeeks 

Naamconflicten afhandelen

Wanneer twee pakketten een klasse met dezelfde naam bevatten (bijvoorbeeld java.util.Date en java.sql.Date), specificeer dan de volledige pakketnaam om conflicten te voorkomen.

java.util.* importeren;
java.sql.* importeren;
//En gebruik dan de Date-klasse, dan krijgen we een compileerfout:
Datum vandaag; //ERROR-- java.util.Date of java.sql.Date?

De compiler kan er niet achter komen welke Date-klasse we willen. Dit probleem kan worden opgelost door een specifieke importinstructie te gebruiken:

java.util.Date importeren;
java.sql.* importeren;

Als we beide Date-klassen nodig hebben, moeten we elke keer dat we een nieuw object van die klasse declareren, een volledige pakketnaam gebruiken. Bijvoorbeeld:

java.util.Date deadLine = nieuwe java.util.Date();
java.sql.Date vandaag = nieuwe java.sql.Date();

voorbeelden van dfa-automaten

Directorystructuur en CLASSPATH

Pakketnamen komen overeen met een mapstructuur. Een klasse Circle in pakket com.zzz.project1.subproject2 wordt bijvoorbeeld opgeslagen als:

$BASE_DIR/com/zzz/project1/subproject2/Circle.class

• Hier $BASE_DIR vertegenwoordigt de basismap van het pakket.
• De 'punt' in de pakketnaam komt overeen met een submap van het bestandssysteem.
• De basismap ( $BASE_DIR ) kan zich overal in het bestandssysteem bevinden.
• Daarom moeten de Java-compiler en runtime worden geïnformeerd over de locatie van de $BASE_DIR om de klassen te kunnen lokaliseren.
• Dit wordt bereikt door een omgevingsvariabele genaamd KLASSPAD .
• CLASSPATH is vergelijkbaar met een andere omgevingsvariabele PATH die door de opdrachtshell wordt gebruikt om naar uitvoerbare programma's te zoeken.

CLASSPATH instellen

CLASSPATH kan op een van de volgende manieren worden ingesteld:

• CLASSPATH kan permanent worden ingesteld in de omgeving waarin de stappen in Windows zich bevinden

Ga naar Configuratiescherm -> Systeem -> Geavanceerd -> Omgevingsvariabelen.

• Selecteer 'Systeemvariabelen' om CLASSPATH toe te passen voor alle gebruikers op het systeem.
• Selecteer 'Gebruikersvariabelen' om dit alleen toe te passen voor de momenteel ingelogde gebruiker.
• CLASSPATH bewerken of maken: Als CLASSPATH al bestaat, selecteert u het en klikt u op 'Bewerken'. Als het niet bestaat, klikt u op 'Nieuw'
• Voer CLASSPATH-details in: Voer in het veld 'Variabelenaam' het volgende in: 'CLASSPATH'. Voer in het veld 'Variabelewaarde' de mappen en JAR-bestanden in, gescheiden door puntkomma's.
• Voer in het veld 'Variabele waarde' de mappen en JAR-bestanden in, gescheiden door puntkomma's. Voorbeeld:

.c:javaprojectclasses;d:tomcatlibservlet-api.jar

• De punt (.) vertegenwoordigt de huidige werkmap.
• Om de huidige instelling van CLASSPATH te controleren, voert u het volgende commando uit:

> KLASSPAD INSTELLEN

CLASSPATH kan tijdelijk worden ingesteld voor die specifieke CMD-shellsessie door de volgende opdracht te geven:

> SET CLASSPATH=.;c:javaprojectclasses;d:tomcatlibservlet-api.jar

In plaats van de omgevingsvariabele CLASSPATH te gebruiken, kunt u bijvoorbeeld ook de opdrachtregeloptie -classpath of -cp van de javac- en java-opdrachten gebruiken

> java – klassenpad c:javaprojectclasses com.abc.project1.subproject2.MyClass3

Illustratie van door de gebruiker gedefinieerde pakketten:  Ons eerste pakket maken: Bestandsnaam – ClassOne.java

package package_name; public class ClassOne {  public void methodClassOne()  {  System.out.println('Hello there its ClassOne');  } } 

Ons tweede pakket maken: Bestandsnaam – ClassTwo.java

package package_one; public class ClassTwo {  public void methodClassTwo()  {  System.out.println('Hello there i am ClassTwo');  } } 

Gebruik makend van beide gemaakte pakketten: Bestandsnaam – Testing.java

import package_name.ClassOne; import package_one.ClassTwo; public class Testing {  public static void main(String[] args)  {  ClassTwo a = new ClassTwo();  ClassOne b = new ClassOne();  a.methodClassTwo();  b.methodClassOne();  } } 

Kijk nu eens naar de mapstructuur van zowel de pakketten als het testklassebestand:

Toegang tot modifiers in de context van pakketten

• Openbaar: Leden met depublicmodifier zijn overal toegankelijk, ongeacht of de toegangsklasse zich in hetzelfde pakket bevindt of niet .
• Beschermd: Leden met de beschermde modifier zijn toegankelijk binnen hetzelfde pakket in subklassen
• Standaard: Leden zonder modifier zijn alleen toegankelijk binnen hetzelfde pakket
• Privé: Leden met deprivatemodifier zijn alleen toegankelijk binnen dezelfde klasse. Ze zijn niet toegankelijk voor klassen in dezelfde pakketsubklassen of verschillende pakketten.