Java-Modell

Das Java-Modell ist die Gruppe der Klassen, die Modelle für die Objekte darstellen, welche an der Erzeugung, Bearbeitung und Erstellung eines Java-Programms beteiligt sind. Die Klassen des Java-Modells sind in org.eclipse.jdt.core definiert.  Diese Klassen implementieren Java-spezifisches Verhalten für Ressourcen und zerlegen Java-Ressourcen weiter in Modellelemente.

Java-Elemente

Das Paket org.eclipse.jdt.core definiert die Klassen, die Modelle für die Elemente darstellen, aus denen ein Java-Programm besteht. JDT verwendet ein speicherinternes Objektmodell, um die Struktur eines Java-Programms darzustellen. Diese Struktur wird aus dem Klassenpfad des Projektes abgeleitet. Das Modell ist hierarchisch aufgebaut. Elemente eines Programms können in untergeordnete Elemente zerlegt werden.

Java-Elemente werden ähnlich bearbeitet wie Ressourcenobjekte.  Wenn Sie mit einem Java-Element arbeiten, arbeiten Sie eigentlich mit einer Kennung für eine Art zu Grunde liegendes Modellobjekt.  Sie müssen das Protokoll exists() verwenden, um festzustellen, ob das Element im Arbeitsbereich tatsächlich vorhanden ist. 

Die folgende Tabelle fasst die unterschiedlichen Typen von Java-Elementen zusammen:

Element Beschreibung
IJavaModel Stellt das Java-Stammelement dar, das dem Arbeitsbereich entspricht. Es ist das übergeordnete Element aller Projekte mit der Gattung "Java". Außerdem ermöglicht es den Zugriff auf Projekte ohne die Gattung "Java".
IJavaProject Stellt ein Java-Projekt im Arbeitsbereich dar. (Dieses Element ist ein Kind des Elements IJavaModel)
IPackageFragmentRoot Stellt eine Gruppe von Paketfragmenten dar und ordnet die Fragmente einer zu Grunde liegenden Ressource zu, die entweder ein Ordner, eine JAR-Datei oder eine komprimierte Datei (ZIP) ist. (Dieses Element ist ein Kind des Elements IJavaProject.)
IPackageFragment Stellt den Teil des Arbeitsbereichs dar, der einem vollständigen Paket entspricht, oder einen Teil des Pakets. (Dieses Element ist ein Kind des Elements IPackageFragmentRoot.)
ICompilationUnit Stellt eine Java-Quellendatei (.java) dar. (Dieses Element ist ein Kind des Elements IPackageFragment.)
IPackageDeclaration Stellt eine Paketdeklaration in einer Kompiliereinheit dar. (Dieses Element ist ein Kind des Elements ICompilationUnit.)
IImportContainer Stellt die Objektgruppe von Paketimportdeklarationen in einer Kompiliereinheit dar. (Dieses Element ist ein Kind des Elements ICompilationUnit.)
IImportDeclaration Stellt eine einzelne Paketimportdeklaration dar. (Dieses Element ist ein Kind des Elements IImportContainer.)
IType Stellt entweder einen Quellentyp innerhalb einer Kompiliereinheit oder einen Binärtyp innerhalb einer Klassendatei dar.
IField Stellt ein Feld innerhalb eines Typs dar. (Dieses Element ist ein Kind des Elements IType.)
IMethod Stellt eine Methode oder einen Konstruktor innerhalb eines Typs dar. (Dieses Element ist ein Kind des Elements IType.)
IInitializer Stellt einen statischen Initialisierungsoperator oder einen Initialisierungsoperator für ein Exemplar innerhalb eines Typs dar. (Dieses Element ist ein Kind des Elements IType.)
IClassFile Stellt einen kompilierten (binären) Typ dar.  (Dieses Element ist ein untergeordnetes Element (Kind) von IPackageFragment. )

Alle Java-Elemente unterstützen die Schnittstelle IJavaElement.

Einige der Elemente werden in der Sicht 'Pakete' angezeigt.  Diese Elemente implementieren die Schnittstelle IOpenable, da sie geöffnet werden müssen, bevor eine Navigation in ihnen möglich ist. Die unten gezeigte Abbildung veranschaulicht, wie diese Elemente in der Sicht "Pakete" dargestellt werden.

Sicht 'Pakete' mit Elementen, die die Schnittstelle 'IOpenable' implementieren

Die Java-Elemente, die die Schnittstelle IOpenable implementieren, werden hauptsächlich aus Informationen erstellt, die sich in den zu Grunde liegenden Ressourcendateien befinden.  Dieselben Elemente werden in der Sicht 'Navigator' für Ressourcen generisch dargestellt.

Ressourcennavigator mit Elementen, die die Schnittstelle 'IOpenable' implementieren

Andere Elemente entsprechen den Bestandteilen, die eine Java-Kompiliereinheit bilden. In der folgenden Abbildung ist eine Java-Kompiliereinheit sowie eine Inhaltsgliederung dargestellt, die die Quellenelemente in der Kompiliereinheit sichtbar macht.

Editor und Inhaltsgliederung zur Darstellung der Beziehung zwischen sich entsprechenden Quellenelementen

Diese Elemente implementieren die Schnittstelle ISourceReference, da sie entsprechenden Quellcode zur Verfügung stellen können. (Wenn diese Elemente in der Inhaltsgliederung ausgewählt werden, wird der entsprechende Quellcode im Java-Editor angezeigt.)

Java-Elemente und ihre Ressourcen

Viele der Java-Elemente entsprechen generische Ressourcen im Arbeitsbereich.  Wenn Sie Java-Elemente aus einer generischen Ressource erstellen möchten, ist die Klasse JavaCore der beste Ausgangspunkt. Der folgende Codeausschnitt zeigt, wie Java-Elemente aus ihren entsprechenden Ressourcen abgerufen werden können.

    
        private void createJavaElementsFrom(IProject myProject, IFolder myFolder, IFile myFile) {
        IJavaProject myJavaProject = JavaCore.create(myProject);
        if (myJavaProject == null)
            // the project is not configured for Java (has no Java nature)
            return;
            
        // get a package fragment or package fragment root
        IJavaElement myPackageFragment = JavaCore.create(myFolder);
        
        // get a .java (compilation unit), .class (class file), or
        // .jar (package fragment root)
        IJavaElement myJavaFile = JavaCore.create(myFile);
    }

Sobald ein Java-Element erstellt wurde, können Sie mit der JDT-API das Modell durchqueren und abfragen.  Sie können auch die Nicht-Java-Ressourcen abfragen, die in einem Java-Element enthalten sind. 

         private void createJavaElementsFrom(IProject myProject, IFolder myFolder, IFile myFile) {
        ...
        // get the non Java resources contained in my project.
        Object[] nonJavaChildren = myJavaProject.getNonJavaResources();
        ...
            

Java-Projekte

Wenn Sie ein Java-Projekt aus einem einfachen Projekt erstellen, überprüft JavaCore, ob das Projekt mit der Java-Gattung konfiguriert ist.  Das JDT-Plug-in verwendet eine Projektgattung, um für ein Projekt auszuweisen, dass es über Java-Verhalten verfügt.  Diese Gattung (org.eclipse.jdt.core.JavaCore#NATURE_ID) wird einem Projekt zugeordnet, wenn der Assistent 'Neues Java-Projekt' ein Projekt erstellt.  Ist die Java-Gattung für ein Projekt nicht konfiguriert, gibt JavaCore bei der Aufforderung, das Projekt zu erstellen, den Wert Null zurück.

Die Klasse JavaCore wird außerdem zur Verwaltung des Java-Klassenpfades verwendet. Dies schließt auch Positionen für die Suche nach Quellcode und Bibliotheken sowie für die Generierung von binären Ausgabedateien (.class) ein.

Worin bestehen die eindeutigen Kenndaten von Java-Projekten? Sie zeichnen ihren Klassenpfad in einer Datei ".classpath" auf und fügen das Programm zur schrittweisen Erstellung von Java-Projekten zur Erstellungsspezifikation des Projekts hinzu.  Ansonsten handelt es sich einfach um normale Projekte, die mit anderen Gattungen (und anderen Programmen zur schrittweisen Erstellung) durch Plug-ins konfiguriert werden können. Plug-ins, die Projekte zusätzlich zu ihrem eigenen Verhalten mit Java-Verhalten konfigurieren wollen, verwenden in der Regel NewJavaProjectWizardPage , um dem Projekt zusätzlich zu ihrer eigenen Gattung oder ihrem eigenen Verhalten die Gattung "Java" zuzuordnen.

IJavaModel kann als übergeordnetes Element aller Projekte im Arbeitsbereich betrachtet werden, die die Projektgattung "Java" haben (und somit als ein Element IJavaProject behandelt werden können).