Java-model

Het Java-model is de reeks klassen die de objecten voor het maken, bewerken en bouwen van Java-programma's modelleren. De klassen van het Java-model zijn gedefinieerd in org.eclipse.jdt.core. Met deze klassen worden Java-gedragspatronen voor resources geïmplementeerd en worden Java-resources in modelementen ontbonden.

Java-elementen

Het pakket org.eclipse.jdt.core definieert de klassen die de elementen modelleren waaruit een Java-programma is opgebouwd. In JDT wordt een objectmodel in het geheugen gebruikt voor het afbeelden van de structuur van een Java-programma. De structuur wordt afgeleid uit het klassenpad van het project. Het model is hiërarchisch. De elementen van een programma kunnen in onderliggende elementen worden ontbonden.

Het manipuleren van Java-elementen is vergelijkbaar met het manipuleren van resource-objecten. Als u met een Java-element werkt, doet u dat in feite met een koppeling naar een onderliggend modelobject. U moet het protocol exists() gebruiken om vast te stellen of een element zich in het werkgebied bevindt.  

In de volgende tabel worden de verschillende typen Java-elementen samengevat.

Element Beschrijving
IJavaModel Het hoofd-Java-element ten opzichte van het werkgebied. Dit element is het bovenliggende element van alle projecten van de Java-soort. Ook hebt u met dit element toegang tot alle projecten die niet van de Java-soort zijn.
IJavaProject Een Java-project in het werkgebied. (Onderliggend item van IJavaModel)
IPackageFragmentRoot Een reeks pakketfragmenten. De fragmenten worden toegewezen aan een onderliggende resource (map of JAR- of ZIP-bestand). (Onderliggend item van IJavaProject)
IPackageFragment Het deel van het werkgebied dat bij een volledig pakket of een gedeelte van het pakket hoort. (Onderliggend item van IPackageFragmentRoot)
ICompilationUnit Een JAVA-bronbestand. (Onderliggend item van IPackageFragment)
IPackageDeclaration Een pakketdeclaratie in een compilatie-eenheid. (Onderliggend item van ICompilationUnit)
IImportContainer De verzameling importinstructies van pakketten in een compilatie-eenheid. (Onderliggend item van ICompilationUnit)
IImportDeclaration Een importdeclaratie voor één pakket. (Onderliggend item van IImportContainer)
IType Een brontype in een compilatie-eenheid of een binair type in een klassenbestand.
IField Een veld in een type. (Onderliggend item van IType)
IMethod Een methode of constructor in een type. (Onderliggend item van IType)
IInitializer Een statische of instance-initiator in een type. (Onderliggend item van IType)
IClassFile Een gecompileerd (binair) type. (Onderliggend item van IPackageFragment)
ITypeParameter Aanduiding van een typeparameter. (Dit is niet een onderliggend element van een Java-element en kan worden opgehaald met IType.getTypeParameter(String) of IMethod.getTypeParameter(String).)
ILocalVariable Aanduiding van een lokale variabele in een methode of een initializer. (Dit is niet een onderliggend element van een Java-element en kan worden opgehaald met ICodeAssist.codeSelect(int, int).)

De interface IJavaElement worden door alle Java-elementen ondersteund.

Bepaalde elementen worden in de view Pakketten afgebeeld. De interface IOpenable wordt door deze elementen geïmplementeerd, omdat ze pas in de navigatiestructuur kunnen worden opgenomen nadat ze zijn geopend. In de onderstaande afbeelding ziet u hoe deze elementen worden aangeduid in de view Pakketten.

View Pakketten met implementerende elementen van interface IOpenable

De Java-elementen die IOpenable implementeren, worden hoofdzakelijk gemaakt op basis van gegevens uit de onderliggende resourcebestanden. Dezelfde elementen worden generiek afgebeeld in de view Resourcenavigator.

Resourcenavigator met implementerende elementen van interface IOpenable

Andere elementen horen bij de items waaruit een Java-compilatie-eenheid is opgebouwd. In de onderstaande afbeelding ziet u een Java-compilatie-eenheid en een overzicht waarmee de bronelementen in de compilatie-eenheid worden afgebeeld.

Een editor en een overzicht waarmee de relatie tussen bijbehorende bronelementen wordt aangeduid.

De interface ISourceReference wordt door deze elementen geïmplementeerd, omdat ze bijbehorende broncode kunnen bevatten. (Als u een Java-element selecteert in het overzicht, wordt de broncode ervan afgebeeld in de Java-editor.

Java-elementen en bijbehorende resources

Veel Java-elementen horen bij generieke resources in het werkgebied. Voor het maken van Java-elementen op basis van generieke resources, kunt u het beste met de klasse JavaCore beginnen. In het onderstaande codefragment worden Java-elementen opgehaald op basis van de bijbehorende resources.

    
private void createJavaElementsFrom(IProject myProject, IFolder myFolder, IFile myFile) {
        IJavaProject myJavaProject= JavaCore.create(myProject);
        if (myJavaProject == null)
            // Het project is niet geconfigureerd voor Java (is niet van het type Java).
            return;
            
        // Een pakketfragment of het hoofditem van een pakketfragment ophalen.
        IJavaElement myPackageFragment= JavaCore.create(myFolder);
        
        // Een bestand van het type JAVA (compilatie-eenheid), CLASS (klasse) of
        // JAR (hoofdbestand van pakketfragment) ophalen.
        IJavaElement myJavaFile = JavaCore.create(myFile);
    }

Zodra u een Java-element hebt, kunt u de JDT-API gebruiken om het model te onderzoeken en in combinatie met query's te gebruiken. U kunt ook query's uitvoeren op de resources in een Java-element die niet van het type Java zijn.  

         private void createJavaElementsFrom(IProject myProject, IFolder myFolder, IFile myFile) {
        ...
        // De resources in myProject ophalen die niet van het type Java zijn
        Object[] nonJavaChildren = myJavaProject.getNonJavaResources();
        ...
            

Java-projecten

Als u een eenvoudig project naar een Java-project converteert, kunt u met JavaCore controleren of het project met het type Java is geconfigureerd. De JDT-plugin gebruikt een projectsoort om aan te geven dat het project Java-gedragspatronen bevat. Deze soort (org.eclipse.jdt.core.JavaCore#NATURE_ID) wordt aan projecten toegewezen die met de wizard 'Nieuw Java-project' zijn gemaakt. Als projecten niet met het type Java zijn geconfigureerd, geeft JavaCore null als resultaat bij het maken van het project.

JavaCore kunt u ook gebruiken om het Java-klassenpad te onderhouden, met inbegrip van locaties voor het zoeken van broncode en bibliotheken en uitvoerlocaties voor het genereren van binaire CLASS-bestanden.

Wat zijn de unieke kenmerken van Java-projecten? Het klassenpad wordt opgeslagen in een CLASSPATH-bestand en het incrementele Java-projectbouwprogramma wordt toegevoegd aan de bouwspecificatie van het project. Anders zijn ze normale projecten, die u met behulp van plugins kunt configureren met andere typen (en andere incrementele bouwprogramma's). Plugins voor het configureren van projecten met een Java-gedrag en het standaard ingebouwde plugingedrag maken normaal gesproken gebruik van NewJavaProjectWizardPage om het type Java en het standaard ingebouwde type of gedrag toe te wijzen aan het project.

U kunt IJavaModel als bovenliggend item van alle projecten in het werkgebied met het type Java opvatten. Deze projecten kunnen vervolgens worden behandeld als IJavaProject).