Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 43 - Reflection

## 43.2 Die Klassen Object und Class

- 43.2 Die Klassen Object und Class
  - 43.2.1 Die Klasse Object
  - 43.2.2 Die Klasse Class

### 43.2.1 Die Klasse Object

Die Klasse `Object` wurde bereits in Abschnitt 8.1.2 erläutert. Sie ist die Vaterklasse aller anderen Klassen und sorgt dafür, daß einige elementare Methoden wie `equals`, `toString`, `clone` oder `hashCode` in allen Klassen zur Verfügung stehen.

### 43.2.2 Die Klasse Class

Mit der Methode `getClass` der Klasse `Object` besitzt ein beliebiges Objekt die Fähigkeit, ein passendes Klassenobjekt zu liefern. Zu jeder Klasse, die das Laufzeitsystem verwendet, wird während des Ladevorgangs ein Klassenobjekt vom Typ `Class` erzeugt. Die Klasse `Class` stellt Methoden zur Abfrage von Eigenschaften der Klasse zur Verfügung und erlaubt es, Klassen dynamisch zu laden und Instanzen dynamisch zu erzeugen. Darüber hinaus ist sie der Schlüssel zur Funktionalität des Reflection-APIs.

Wir wollen uns zunächst an einem einfachen Beispiel das dynamische Laden und Instanzieren von Klassen ansehen. Das folgende Listing zeigt das Interface `HelloMeth` und die Klassen `CA`, `CB`, `CC` und `CD`. `HelloMeth` deklariert die Methode `hello`, die von den Klassen `CA` und `CB` implementiert wird. `CC` besitzt ebenfalls die Methode `hello`, allerdings ohne das Interface `HelloMeth` zu implementieren. `CD` schließlich implementiert nicht `hello`, sondern `hallo`.

Die Hauptklasse liest zunächst einen Klassennamen von der Standardeingabe ein. Mit der Klassenmethode `forName` der Klasse `Class` wird dann ein Klassenobjekt zu einer Klasse dieses Namens beschafft. Das wird verwendet, um mit der Methode `newInstance` der Klasse `Class` ein neues Objekt zu erzeugen. Dieses Objekt wird schließlich in das Interface `HelloMeth` konvertiert und dessen Methode `hello` aufgerufen.

Das Programm ist in der Lage, die beiden Klassen `CA` und `CB` ordnungsgemäß zu instanzieren und ihre Methode `hello` aufzurufen. Bei `CC` und `CD` gibt es eine Ausnahme des Typs `ClassCastException`, weil diese Klassen nicht das Interface `HelloMeth` implementieren. Alle anderen Klassennamen werden mit der Ausnahme `ClassNotFoundException` quittiert.

    001 /* Listing4301.java */
    002
    003 import java.io.*;
    004
    005 interface HelloMeth
    006 {
    007   public void hello();
    008 }
    009
    010 class CA
    011 implements HelloMeth
    012 {
    013   public void hello()
    014   {
    015     System.out.println("hello CA");
    016   }
    017 }
    018
    019 class CB
    020 implements HelloMeth
    021 {
    022   public void hello()
    023   {
    024     System.out.println("hello CB");
    025   }
    026 }
    027
    028 class CC
    029 {
    030   public void hello()
    031   {
    032     System.out.println("hello CC");
    033   }
    034 }
    035
    036 class CD
    037 {
    038   public void hallo()
    039   {
    040     System.out.println("hallo CD");
    041   }
    042 }
    043
    044 public class Listing4301
    045 {
    046   public static void main(String[] args)
    047   {
    048     String buf = "";
    049     BufferedReader in = new BufferedReader(
    050                         new InputStreamReader(
    051                         new DataInputStream(System.in)));
    052     while (true) {
    053     try {
    054         System.out.print("Klassenname oder ende eingeben: ");
    055         buf = in.readLine();
    056         if (buf.equals("ende")) {
    057           break;
    058         }
    059         Class c = Class.forName(buf);
    060         Object o = c.newInstance();
    061         ((HelloMeth)o).hello();
    062       } catch (IOException e) {
    063         System.out.println(e.toString());
    064       } catch (ClassNotFoundException e) {
    065         System.out.println("Klasse nicht gefunden");
    066       } catch (ClassCastException e) {
    067         System.out.println(e.toString());
    068       } catch (InstantiationException e) {
    069         System.out.println(e.toString());
    070       } catch (IllegalAccessException e) {
    071         System.out.println(e.toString());
    072       }
    073     }
    074   }
    075 }
| Listing4301.java

Listing 43.1: Dynamisches Laden von Klassen

Eine Beispielsitzung des Programms könnte so aussehen:

    CA
    hello CA
    CB
    hello CB
    CC
    java.lang.ClassCastException
    CD
    java.lang.ClassCastException
    CE
    Klasse nicht gefunden
    ende

An diesem Beispiel ist zu sehen, wie Klassen geladen und instanziert werden können, deren Name zur Compilezeit nicht bekannt ist. In allen anderen Beispielen in diesem Buch wurden Klassennamen als literale Konstanten im Sourcecode gehalten und der Compiler konnte den passenden Code erzeugen. Wir wollen die nötigen Schritte noch einmal zusammenfassen:

- Mit der statischen Methode `forName` wurde der Classloader beauftragt, eine Klasse des angegebenen Namens zu suchen und in die Java-Maschine zu laden. Die VM führt anschließend die statischen Initialisierungen aus (falls es nicht schon ein Klassenobjekt gibt) und liefert das zugehörige Klassenobjekt.
- Mit dem Klassenobjekt können nun verschiedene Aufgaben erledigt werden. Insbesondere ist es möglich, Informationen über Konstruktoren, Membervariablen oder Methoden der Klasse abzufragen.
- Zudem kann mit `newInstance` eine neue Instanz der Klasse angelegt werden. Ist der Typ der Klasse oder ihrer Basisklasse oder eines ihrer Interfaces bekannt, kann das Objekt auf eine Variable dieses Typs konvertiert und dessen Methoden aufgerufen werden.

Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de