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 in weitere 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.

Die Bearbeitung von Java-Elementen ähnelt der Bearbeitung von Ressourcenobjekten.   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 Kind des Elements 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 primär aus Informationen erstellt, die sich in den zu Grunde liegenden Ressourcendateien befinden.   Dieselben Elemente werden in der Navigator-Sicht 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 Java-Elemente entsprechen generischen 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 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 aus einem einfachen Projekt ein Java-Projekt erstellen, prüft die Klasse JavaCore, ob das Projekt mit der Gattung "Java" konfiguriert ist. Mit einer Projektgattung kennzeichnet das JDT-Plug-in ein Projekt als ein Projekt mit Java-Verhalten. Diese Gattung (org.eclipse.jdt.core.JavaCore#NATURE_ID) wird einem Projekt zugeordnet, wenn der Assistent "Neues Java-Projekt" ein Projekt erstellt. Ist die Gattung "Java" nicht für ein Projekt konfiguriert, gibt die Klasse JavaCore einen Nullwert zurück, wenn die Erstellung des Projekts angefordert wird.

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).

Copyright IBM Corporation und Andere 2000, 2003. Alle Rechte vorbehalten.