Le modèle Java est l'ensemble de classes qui modélisent les objets associés à la création, l'édition et la génération d'un programme Java. Les classes du modèle Java sont définies dans les packages org.eclipse.jdt.core.*. Elles implémentent des comportements Java spécifiques pour les ressources et décomposent ces dernières en éléments du modèle.
Le package org.eclipse.jdt.core définit les classes qui modélisent les éléments dont un programme Java est constitué. JDT utilise un modèle objet "en mémoire" pour représenter la structure d'un programme Java. Ce modèle est hiérarchique. Les éléments d'un programme peuvent être décomposés en éléments enfants.
Les éléments Java s'apparentent beaucoup aux objets ressources. Lorsque vous travaillez sur un élément Java, vous manipulez en réalité un descripteur (ou "handle") désignant un objet sous-jacent du modèle. Vous devez utiliser le protocole exists() pour déterminer si l'élément est réellement présent dans l'espace de travail.
Le tableau suivant répertorie les différentes sortes d'éléments Java.
Elément |
Description |
---|---|
Représente l'élément Java racine, qui correspond à l'espace de travail. C'est l'élément parent de tous les projets Java. |
|
Représente un projet Java dans l'espace de travail. (Elément enfant de IJavaModel.) |
|
Représente un ensemble de fragments de package et établit le lien entre ces fragments et une ressource sous-jacente qui peut être un dossier, un fichier JAR ou un fichier ZIP. (Elément enfant de IJavaProject.) |
|
Représente la partie de l'espace de travail qui correspond à un package entier ou à une portion de ce package. (Elément enfant de IPackageFragmentRoot.) |
|
Représente un fichier source Java (.java) |
|
Représente une déclaration de package dans une unité de compilation. (Elément enfant de ICompilationUnit.) |
|
Représente l'ensemble de déclarations d'importation de packages dans une unité de compilation. (Elément enfant de ICompilationUnit.) |
|
Représente une déclaration d'importation de package particulière. (Elément enfant de IImportContainer.) |
|
Représente soit un type source à l'intérieur d'une unité de compilation, soit un type binaire à l'intérieur d'un fichier classe. |
|
Représente un champ à l'intérieur d'un type. (Elément enfant de IType.) |
|
Représente une méthode ou un constructeur à l'intérieur d'un type. (Elément enfant de IType.) |
|
Représente un initialiseur statique ou d'instance à l'intérieur d'un type. (Elément enfant de IType.) |
|
Représente un type compilé (binaire). (Elément enfant de IPackageFragment.) |
Tous les éléments Java supportent l'interface IJavaElement.
Certains des éléments sont visibles dans la vue Packages. Ils implémentent l'interface IOpenable, puisqu'ils doivent être ouverts avant de pouvoir être parcourus. La figure ci-dessous montre comment ces éléments sont représentés dans la vue Packages.
Les éléments Java qui implémentent l'interface IOpenable sont créés essentiellement à partir des informations trouvées dans les fichiers ressources sous-jacents. On en retrouve une représentation générique dans la vue Navigateur de ressources.
D'autres éléments correspondent aux composants qui constituent une unité de compilation Java (fichier .java). La figure ci-dessous montre une unité de compilation Java et un "décomposeur de contenu" qui affiche les éléments source de cette unité.
Ces éléments implémentent l'interface ISourceReference, puisqu'ils possèdent un code source. (Lorsqu'ils sont sélectionnés dans le décomposeur de contenu, leur code source s'affiche dans l'éditeur Java.)
Nombre d'éléments Java correspondent à des ressources génériques dans l'espace de travail. La classe JavaCore constitue le point de départ à utiliser lorsque vous souhaitez créer des éléments Java à partir d'une ressource générique. Le fragment de code suivant montre comment obtenir des éléments Java à partir des ressources qui leur correspondent.
private void createJavaElementsFrom(IProject myProject,
IFolder myFolder, IFile myFile) {
IJavaProject myJavaProject = JavaCore.create(myProject);
if (myJavaProject == null)
// Le projet n'est pas configuré pour
Java (il n'a pas de nature Java)
return;
// obtenir un fragment de package ou une racine de fragments de package
IJavaElement myPackageFragment = JavaCore.create(myFolder);
// obtenir un fichier .java (unité de compilation), .class (fichier classe) ou
// .jar (racine de fragments de package)
IJavaElement myJavaFile = JavaCore.create(myFile);
}
JavaCore sert aussi à gérer les chemins de classes (classpath) Java, y compris les endroits où trouver les codes source et les bibliothèques et les endroits où placer les fichiers binaires (.class) générés.
Lorsque vous créez un projet Java à partir d'un projet classique, JavaCore vérifie si ce projet est configuré avec la nature Java. Le plug-in JDT utilise une nature de projet pour spécifier qu'un projet possède un comportement Java. Cette nature (org.eclipse.jdt.core.javanature) est affectée au projet lorsque celui-ci est créé par l'assistant "Nouveau projet Java". Si la nature Java n'est pas configurée pour un projet, JavaCore renvoie "null" lorsqu'il lui est demandé de créer le projet.
En quoi un projet Java se distingue-t-il d'un projet classique ? Le chemin de classes d'un projet Java est enregistré dans un fichier ".classpath" et le générateur de projet incrémentiel Java est ajouté à la spécification de génération du projet. Mis à part ces points particuliers, il s'agit juste d'un projet classique qui peut être configuré avec d'autres natures (et d'autres générateurs incrémentiels) par les plug-ins. Les plug-ins qui doivent configurer un projet avec un comportement Java en complément de leur propre comportement utilisent généralement la page d'assistant "Nouveau projet Java" pour affecter la nature Java au projet en plus de leur propre nature ou comportement personnalisé.
IJavaModel peut être considéré comme l'élément parent de tous les projets qui, dans l'espace de travail, possèdent la nature de projet Java (et qui, par conséquent, peuvent être traités comme des éléments IJavaProject).