Gids voor Java-pakketten

1. Inleiding

In deze korte tutorial behandelen we de basisprincipes van pakketten in Java. We zullen zien hoe we pakketten kunnen maken en toegang krijgen tot de typen die we erin plaatsen.

We zullen ook de naamgevingsconventies bespreken en hoe dat zich verhoudt tot de onderliggende directorystructuur.

Ten slotte zullen we onze verpakte Java-klassen compileren en uitvoeren.

2. Overzicht van Java-pakketten

In Java hebben we gebruik pakketten om gerelateerde klassen, interfaces en subpakketten te groeperen.

De belangrijkste voordelen hiervan zijn:

  • Het gemakkelijker maken om verwante typen te vinden - pakketten bevatten meestal typen die logisch verwant zijn
  • Het vermijden van naamconflicten - een pakket helpt ons om een ​​klasse uniek te identificeren; we zouden bijvoorbeeld een com.baeldung.Application, net zoals com.example.Application klassen
  • Toegang beheren - we kunnen de zichtbaarheid en toegang tot typen regelen door pakketten en toegangsmodificatoren te combineren

Laten we vervolgens kijken hoe we Java-pakketten kunnen maken en gebruiken.

3. Een pakket maken

Om een ​​pakket te maken, we moeten de pakket statement door het toe te voegen als de allereerste regel code in een bestand.

Laten we een type in een pakket plaatsen met de naam com.baeldung.packages:

pakket com.baeldung.packages;

Het wordt ten zeerste aanbevolen om elk nieuw type in een pakket te plaatsen. Als we typen definiëren en ze niet in een pakket plaatsen, gaan ze in de standaard of naamloos pakket. Het gebruik van standaardpakketten heeft een aantal nadelen:

  • We verliezen de voordelen van een pakketstructuur en we kunnen geen subpakketten hebben
  • We kunnen de typen in het standaardpakket niet uit andere pakketten importeren
  • De beschermd en pakket-privé toegangsbereik zou zinloos zijn

Zoals de Java-taalspecificatie aangeeft, worden pakketten zonder naam door het Java SE-platform voornamelijk voor het gemak geleverd bij het ontwikkelen van kleine of tijdelijke applicaties of bij het begin van de ontwikkeling.

Daarom we moeten het gebruik van naamloze of standaardpakketten in real-world applicaties vermijden.

3.1. Naamgevingsconventies

Om pakketten met dezelfde naam te vermijden, volgen we enkele naamgevingsconventies:

  • we definiëren ons pakket namen in kleine letters
  • pakketnamen zijn door punten gescheiden
  • namen worden ook bepaald door het bedrijf of de organisatie die ze heeft gemaakt

Om de pakketnaam te bepalen op basis van een organisatie, beginnen we meestal met het omkeren van de bedrijfs-URL. Daarna wordt de naamgevingsconventie bepaald door het bedrijf en kan deze divisienamen en projectnamen bevatten.

Bijvoorbeeld om er een pakketje van te maken www.baeldung.com, laten we het omdraaien:

com.baeldung

We kunnen dan subpakketten hiervan verder definiëren, zoals com.baeldung.packages of com.baeldung.packages.domain.

3.2. Directory-structuur

Pakketten in Java komen overeen met een directorystructuur.

Elk pakket en subpakket heeft zijn eigen directory. Dus voor het pakket com.baeldung.packages, zouden we een directorystructuur moeten hebben van com -> baeldung -> pakketten.

De meeste IDE's zullen helpen bij het maken van deze directorystructuur op basis van onze pakketnamen, dus we hoeven deze niet met de hand te maken.

4. Pakketleden gebruiken

Laten we beginnen met het definiëren van een klasse TodoItem in een subpakket met de naam domein:

pakket com.baeldung.packages.domain; openbare klasse TodoItem {privé Lange id; private String beschrijving; // standaard getters en setters}

4.1. Invoer

Om onze TodoItem class uit een class in een ander pakket, we moeten het importeren. Nadat het is geïmporteerd, hebben we er toegang toe op naam.

We kunnen een enkel type uit een pakket importeren of een asterisk gebruiken om alle typen in een pakket te importeren.

Laten we het hele domein subpakket:

importeer com.baeldung.packages.domain. *;

Laten we nu alleen het TodoItem klasse:

importeer com.baeldung.packages.domain.TodoItem;

De JDK en andere Java-bibliotheken hebben ook hun eigen pakketten. We kunnen reeds bestaande klassen importeren die we op dezelfde manier in ons project willen gebruiken.

Laten we bijvoorbeeld de Java-kern importeren Lijst interface en ArrayList klasse:

importeer java.util.ArrayList; importeer java.util.List;

We kunnen deze typen dan in onze applicatie gebruiken door simpelweg hun naam te gebruiken:

openbare klasse TodoList {privélijst todoItems; openbare ongeldige addTodoItem (TodoItem todoItem) {if (todoItems == null) {todoItems = nieuwe ArrayList (); } todoItems.add (todoItem); }}

Hier hebben we onze nieuwe klassen samen met Java-kernklassen gebruikt om een Lijst van ToDoItems.

4.2. Volledig gekwalificeerde naam

Soms gebruiken we twee klassen met dezelfde naam uit verschillende pakketten. We kunnen bijvoorbeeld beide gebruiken java.sql.Datum en java.util.Date. Wanneer we naamconflicten tegenkomen, moeten we een volledig gekwalificeerde klassenaam gebruiken voor ten minste één van de klassen.

Laten we gebruiken TodoItem met een volledig gekwalificeerde naam:

openbare klasse TodoList {privélijst todoItems; openbare ongeldige addTodoItem (com.baeldung.packages.domain.TodoItem todoItem) {if (todoItems == null) {todoItems = nieuwe ArrayList (); } todoItems.add (todoItem); } // standaard getters en setters}

5. Compileren met Javac

Als het tijd is om onze verpakte klassen te compileren, moeten we onze directorystructuur onthouden. Beginnend in de bronmap, moeten we het vertellen Javac waar u onze bestanden kunt vinden.

We moeten onze TodoItem klasse eerst omdat onze Te doen lijst klasse hangt ervan af.

Laten we beginnen met het openen van een opdrachtregel of terminal en navigeren naar onze brondirectory.

Laten we nu onze com.baeldung.packages.domain.TodoItem klasse:

> javac com / baeldung / pakketten / domein / TodoItem.java

Als onze klas netjes compileert, zien we geen foutmeldingen en een bestand TodoItem.class zou moeten verschijnen in onze com / baeldung / pakketten / domein directory.

Voor typen die verwijzen naar typen in andere pakketten, moeten we de -klassenpad vlag om de Javac opdracht waar de andere gecompileerde klassen te vinden zijn.

Nu dat onze TodoItem klasse is gecompileerd, kunnen we onze Te doen lijst en TodoApp klassen:

> javac -classpath. com / baeldung / pakketten / *. java

Nogmaals, we zouden geen foutmeldingen moeten zien en we zouden twee klassebestanden moeten vinden in onze com / baeldung / pakketten directory.

Laten we onze applicatie uitvoeren met de volledig gekwalificeerde naam van onze TodoApp klasse:

> java com.baeldung.packages.TodoApp

Onze output zou er als volgt uit moeten zien:

6. Conclusie

In dit korte artikel hebben we geleerd wat een pakket is en waarom we ze zouden moeten gebruiken.

We hebben de naamgevingsconventies besproken en hoe pakketten zich verhouden tot de directorystructuur. We hebben ook gezien hoe u pakketten kunt maken en gebruiken.

Ten slotte hebben we besproken hoe we een applicatie kunnen compileren en uitvoeren met pakketten die de Javac en Java commando's.

De volledige voorbeeldcode is beschikbaar op GitHub.