Java Packages: Naamruimtes, Toegangscontrole en Code-organisatie

Wat zijn Packages?

Packages worden in Java gebruikt om naamconflicten te voorkomen, toegang te controleren, en het zoeken/lokaliseren en gebruiken van klassen, interfaces, enumeraties en annotaties te vergemakkelijken.

Een Package kan worden gedefinieerd als een groepering van gerelateerde typen (klassen, interfaces, enumeraties en annotaties) die toegangsbeveiliging en naamruimtebeheer bieden.

Enkele bestaande packages in Java zijn:

• java.lang – bundelt de fundamentele klassen
• java.io – klassen voor input/output functies zijn gebundeld in dit pakket

Programmeurs kunnen hun eigen packages definiëren om groepen klassen/interfaces te bundelen. Het is een goede praktijk om gerelateerde klassen die je implementeert te groeperen, zodat een programmeur gemakkelijk kan bepalen dat de klassen, interfaces, enumeraties en annotaties gerelateerd zijn.

Omdat het pakket een nieuwe naamruimte creëert, zal er geen naamconflicten zijn met namen in andere pakketten. Door pakketten te gebruiken, is het makkelijker om toegangscontrole te bieden en is het ook makkelijker om gerelateerde klassen te lokaliseren.

Een Package Maken

Bij het maken van een pakket kies je een naam en voeg je een package-statement met die naam bovenaan elk bronbestand toe dat de klassen, interfaces, enumeraties en annotatietypes bevat die je in het pakket wilt opnemen.

De package-statement moet de eerste regel in het bronbestand zijn. Er kan maar één package-statement per bronbestand zijn, en het geldt voor alle typen in het bestand.

Als er geen package-statement wordt gebruikt, worden de klasse, interfaces, enumeraties en annotatietypes in het huidige standaardpakket geplaatst.

Om Java-programma's met package-statements te compileren, moet je de -d optie gebruiken:

javac -d Doel_map bestandsnaam.java

Er wordt dan een map met de gegeven pakketnaam aangemaakt in de opgegeven bestemming, en de gecompileerde class-bestanden worden in die map geplaatst.

Voorbeeld: animals package

Laten we een pakket genaamd animals maken. Het is een goede praktijk om pakketnamen met kleine letters te schrijven om conflicten met klassenaam en interfaces te vermijden.

/* Bestandsnaam: Animal.java */
package animals;
interface Animal {
    public void eat();
    public void travel();
}

Nu implementeren we de bovenstaande interface in hetzelfde pakket animals:

package animals;
/* Bestandsnaam: MammalInt.java */
public class MammalInt implements Animal {
    public void eat() {
        System.out.println("Zoogdier eet");
    }
    public void travel() {
        System.out.println("Zoogdier reist");
    }
    public int noOfLegs() { return 0; }
    public static void main(String args[]) {
        MammalInt m = new MammalInt();
        m.eat();
        m.travel();
    }
}

Compileer de Java-bestanden:

$ javac -d . Animal.java
$ javac -d . MammalInt.java

Nu wordt een pakket/map met de naam animals aangemaakt in de huidige directory en worden de class-bestanden erin geplaatst.

Je kunt het class-bestand binnen het pakket uitvoeren en het resultaat krijgen:

Zoogdier eet
Zoogdier reist

Het import-sleutelwoord

Als een klasse een andere klasse in hetzelfde pakket wil gebruiken, hoeft de pakketnaam niet gebruikt te worden. Klassen in hetzelfde pakket vinden elkaar zonder speciale syntaxis.

Voorbeeld

Hier wordt een klasse genaamd Boss toegevoegd aan het payroll-pakket dat al Employee bevat. De Boss kan dan naar de Employee-klasse verwijzen zonder de payroll-prefix te gebruiken:

package payroll;
public class Boss {
    public void payEmployee(Employee e) {
        e.mailCheck();
    }
}

Wat als de Employee-klasse niet in het payroll-pakket zit? De Boss-klasse moet dan een van de volgende technieken gebruiken om te verwijzen naar een klasse in een ander pakket:

• De volledig gekwalificeerde naam van de klasse gebruiken. Bijvoorbeeld:

  payroll.Employee

• Het pakket importeren met het import-sleutelwoord en de wildcard (*). Bijvoorbeeld:

  import payroll.*;

• De klasse zelf importeren met het import-sleutelwoord. Bijvoorbeeld:

  import payroll.Employee;

Let op: Een class-bestand kan elk aantal import-statements bevatten. De import-statements moeten na de package-statement en vóór de klassedeclaratie verschijnen.

Directorystructuur van Packages

Twee belangrijke dingen gebeuren wanneer een klasse in een pakket wordt geplaatst:

• De naam van het pakket wordt onderdeel van de naam van de klasse.
• De naam van het pakket moet overeenkomen met de directorystructuur waar de bijbehorende bytecode zich bevindt.

Eenvoudige manier om bestanden te beheren

Plaats de broncode voor een klasse, interface, enumeratie of annotatietype in een tekstbestand met de naam van het type en extensie .java.

// Bestandsnaam: Car.java
package vehicle;
public class Car {
    // Klassimplementatie
}

Plaats nu het bronbestand in een directory wiens naam de pakketnaam weerspiegelt:

....\vehicle\Car.java

De gekwalificeerde klassenaam en padnaam zijn dan:

• Klassenaam → vehicle.Car
• Padnaam → vehicle\Car.java (in Windows)

Over het algemeen gebruikt een bedrijf zijn omgekeerde internetdomeinnaam voor zijn pakketnamen.

Voorbeeld: Een bedrijf heeft domeinnaam apple.com, dan zouden alle pakketnamen beginnen met com.apple. Elk onderdeel van de pakketnaam correspondeert met een subdirectory.

Voorbeeld: Als het bedrijf een com.apple.computers-pakket had met een Dell.java bronbestand, zou dit in een reeks subdirectories zitten:

....\com\apple\computers\Dell.java

Bij compilatie maakt de compiler een apart uitvoerbestand voor elke klasse, interface en enumeratie die erin gedefinieerd is. De basenaam van het uitvoerbestand is de naam van het type, en de extensie is .class.

Voorbeeld

// Bestandsnaam: Dell.java
package com.apple.computers;
public class Dell { }
class Ups { }

Compileer met -d optie:

$javac -d . Dell.java

De bestanden worden gecompileerd als:

.\com\apple\computers\Dell.class
.\com\apple\computers\Ups.class

Je kunt alle klassen of interfaces importeren die gedefinieerd zijn in \com\apple\computers\:

import com.apple.computers.*;

Net als .java bronbestanden, moeten de gecompileerde .class-bestanden in een reeks directories staan die de pakketnaam weerspiegelen. Het pad naar de .class-bestanden hoeft niet hetzelfde te zijn als het pad naar de .java bronbestanden. Je kunt bron- en class-directories apart rangschikken:

<pad-een>\sources\com\apple\computers\Dell.java
<pad-twee>\classes\com\apple\computers\Dell.class

Dadurch kun je toegang geven tot de classes-directory aan andere programmeurs zonder je bronnen te onthullen. Je moet ook bron- en class-bestanden op deze manier beheren zodat de compiler en de JVM alle typen kunnen vinden die je programma gebruikt.

Het volledige pad naar de classes-directory, <pad-twee>\classes, heet de class path, en wordt ingesteld met de CLASSPATH-systeemvariabele. Zowel de compiler als de JVM construeren het pad naar je .class-bestanden door de pakketnaam toe te voegen aan de class path.

Stel <pad-twee>\classes is de class path, en de pakketnaam is com.apple.computers, dan zoeken de compiler en JVM naar .class-bestanden in <pad-twee>\classes\com\apple\computers.

Een class path kan meerdere paden bevatten. Meerdere paden moeten gescheiden worden door een puntkomma (Windows) of dubbele punt (Unix). Standaard zoeken de compiler en JVM de huidige directory en het JAR-bestand met de Java-platformklassen, zodat deze directories automatisch in de class path zitten.

CLASSPATH Systeemvariabele Instellen

Om de huidige CLASSPATH-variabele weer te geven, gebruik de volgende commando's in Windows en UNIX (Bourne shell):

• In Windows → C:\> set CLASSPATH
• In UNIX → % echo $CLASSPATH

Om de huidige inhoud van de CLASSPATH-variabele te verwijderen:

• In Windows → C:\> set CLASSPATH =
• In UNIX → % unset CLASSPATH; export CLASSPATH

Om de CLASSPATH-variabele in te stellen:

• In Windows → set CLASSPATH = C:\users\jack\java\classes
• In UNIX → % CLASSPATH = /home/jack/java/classes; export CLASSPATH