Vejledning til Java-pakker

1. Introduktion

I denne hurtige vejledning dækker vi det grundlæggende i pakker i Java. Vi får se, hvordan du opretter pakker og får adgang til de typer, vi placerer inde i dem.

Vi diskuterer også navngivningskonventioner, og hvordan det relaterer til den underliggende katalogstruktur.

Endelig kompilerer vi og kører vores pakkede Java-klasser.

2. Oversigt over Java-pakker

I Java, vi bruge pakker til at gruppere relaterede klasser, grænseflader og underpakker.

De største fordele ved at gøre dette er:

  • Gør relaterede typer lettere at finde - pakker indeholder normalt typer, der er logisk relaterede
  • Undgå navngivningskonflikter - en pakke hjælper os med at identificere en klasse entydigt; for eksempel kunne vi have en com.baeldung.Applikation, såvel som com.example.Application klasser
  • Styring af adgang - vi kan kontrollere synlighed og adgang til typer ved at kombinere pakker og adgangsmodifikatorer

Lad os derefter se, hvordan vi kan oprette og bruge Java-pakker.

3. Oprettelse af en pakke

For at oprette en pakke, vi er nødt til at bruge pakke erklæring ved at tilføje den som den allerførste linje med kode i en fil.

Lad os placere en type i en pakke med navnet com.baeldung.packages:

pakke com.baeldung.packages;

Det anbefales stærkt at placere hver ny type i en pakke. Hvis vi definerer typer og ikke placerer dem i en pakke, går de i Standard eller unavngiven pakke. Brug af standardpakker har nogle få ulemper:

  • Vi mister fordelene ved at have en pakkestruktur, og vi kan ikke have underpakker
  • Vi kan ikke importere typerne i standardpakken fra andre pakker
  • Det beskyttet og pakke-privat adgangsomfang ville være meningsløst

Som det fremgår af Java-sprogspecifikationen, leveres unavngivne pakker af Java SE-platformen hovedsageligt for nemheds skyld, når man udvikler små eller midlertidige applikationer eller når man lige begynder udvikling.

Derfor, vi bør undgå at bruge unavngivne eller standardpakker i virkelige applikationer.

3.1. Navngivningskonventioner

For at undgå pakker med samme navn følger vi nogle navngivningskonventioner:

  • vi definerer vores pakke navne i små bogstaver
  • pakkenavne er periodeafgrænset
  • navne bestemmes også af den virksomhed eller organisation, der opretter dem

For at bestemme pakkenavnet baseret på en organisation starter vi typisk med at vende firmaets URL. Derefter defineres navngivningskonventionen af ​​virksomheden og kan omfatte divisionsnavne og projektnavne.

For eksempel at lave en pakke af www.baeldung.com, lad os vende om det:

com.baeldung

Vi kan derefter yderligere definere underpakker af dette, ligesom com.baeldung.packages eller com.baeldung.packages.domæne.

3.2. Katalogstruktur

Pakker i Java svarer til en bibliotekstruktur.

Hver pakke og underpakning har sin egen mappe. Så for pakken com.baeldung.packages, skal vi have en katalogstruktur på com -> baeldung -> pakker.

De fleste IDE'er hjælper med at oprette denne katalogstruktur baseret på vores pakkenavne, så vi behøver ikke oprette disse manuelt.

4. Brug af pakkemedlemmer

Lad os starte med at definere en klasse TodoItem i en underpakke navngivet domæne:

pakke com.baeldung.packages.domain; offentlig klasse TodoItem {privat Lang id; privat streng beskrivelse; // standard getters og setter}

4.1. Import

For at bruge vores TodoItem klasse fra en klasse i en anden pakke, skal vi importere den. Når den er importeret, kan vi få adgang til den ved navn.

Vi kan importere en enkelt type fra en pakke eller bruge en stjerne til at importere alle typerne i en pakke.

Lad os importere det hele domæne underpakke:

import com.baeldung.packages.domain. *;

Lad os nu kun importere TodoItem klasse:

import com.baeldung.packages.domain.TodoItem;

JDK og andre Java-biblioteker leveres også med deres egne pakker. Vi kan importere allerede eksisterende klasser, som vi vil bruge i vores projekt på samme måde.

Lad os for eksempel importere Java-kernen Liste interface og ArrayList klasse:

import java.util.ArrayList; import java.util.List;

Vi kan derefter bruge disse typer i vores applikation ved blot at bruge deres navn:

offentlig klasse TodoList {privat liste todoItems; public void addTodoItem (TodoItem todoItem) {if (todoItems == null) {todoItems = new ArrayList (); } todoItems.add (todoItem); }}

Her har vi brugt vores nye klasser sammen med Java-kerneklasser til at skabe en Liste af ToDoItems.

4.2. Fuldt kvalificeret navn

Nogle gange bruger vi muligvis to klasser med samme navn fra forskellige pakker. For eksempel bruger vi muligvis begge dele java.sql.dato og java.util.Date. Når vi løber ind i navngivningskonflikter, skal vi bruge et fuldt kvalificeret klassenavn til mindst en af ​​klasserne.

Lad os bruge TodoItem med et fuldt kvalificeret navn:

offentlig klasse TodoList {privat liste todoItems; offentlig ugyldig addTodoItem (com.baeldung.packages.domain.TodoItem todoItem) {if (todoItems == null) {todoItems = ny ArrayList (); } todoItems.add (todoItem); } // standard getters og setters}

5. Kompilering med javac

Når det er tid til at kompilere vores pakkede klasser, skal vi huske vores katalogstruktur. Startende i kildemappen skal vi fortælle javac hvor vi kan finde vores filer.

Vi er nødt til at kompilere vores TodoItem klasse først, fordi vores TodoList klasse afhænger af det.

Lad os starte med at åbne en kommandolinje eller terminal og navigere til vores kildekatalog.

Lad os nu sammensætte vores com.baeldung.packages.domain.TodoItem klasse:

> javac com / baeldung / packages / domain / TodoItem.java

Hvis vores klasse kompileres rent, ser vi ingen fejlmeddelelser og en fil TodoItem.class skal vises i vores com / baeldung / pakker / domæne vejviser.

For typer, der refererer til typer i andre pakker, skal vi bruge -klassesti flag for at fortælle javac kommando, hvor de andre kompilerede klasser skal findes.

Nu hvor vores TodoItem klasse er samlet, kan vi kompilere vores TodoList og TodoApp klasser:

> javac-klassesti. com / baeldung / pakker / *. java

Igen skal vi ikke se nogen fejlmeddelelser, og vi skal finde to klassefiler i vores com / baeldung / pakker vejviser.

Lad os køre vores ansøgning ved hjælp af vores fuldt kvalificerede navn TodoApp klasse:

> java com.baeldung.packages.TodoApp

Vores output skal se sådan ud:

6. Konklusion

I denne korte artikel lærte vi, hvad en pakke er, og hvorfor vi skal bruge dem.

Vi diskuterede navngivningskonventioner og hvordan pakker relaterer sig til bibliotekstrukturen. Vi så også, hvordan man opretter og bruger pakker.

Endelig gik vi over, hvordan man kompilerer og kører en applikation med pakker ved hjælp af javac og java kommandoer.

Den fulde eksempelkode er tilgængelig på GitHub.