Telematik 1 - Labor SS2002

LB3: Interfaces, innere Klassen, wrapper Klassen

Interfaces:

Über Interfaces wird in Java die Schnittstellenvererbung umgesetzt. Eine Klasse kann beliebig viele Interfaces implementieren, jedoch nur von einer Klasse erben. Über Interfaces kann die in C++ verfügbare Mehrfachvererbung simuliert werden. Um die C++ Klasse Hausboot, aus den Klassen Haus und Boot, zu simulieren müsste man in Java diese Klaase entweder von Haus ableiten und das Interface Boot implementieren oder von Boot ableiten und das Interface Haus implementieren. In beiden Fällen würde man aber nur die Implementierung jener Klasse erben von der man abgeleitet hat und die Schnittstelle des Interfaces selbst implementieren müsste, während man in C++ die Implementation von beiden Klassen erben würde.
Als Schlüsselwort für die Implementierung von Interfaces verwendet Java implements.

  class Base {
    //implementation
  {
  
  interface viewable{
     public boolean isRed();
  }

  class Sub extends Base implements viewable{
    
    public boolean isRed(){
      //implementation
    }
    // some inherited implementations
    // some new implementations
  }

Da Interfaces nur die Schnittstelle von Objekten definieren und nicht deren Implementierung eignen sich Interfaces sehr gut dazu Funktionalitäten festzuschreiben. Jedes Objekt welches ein Interface implementiert "verpflichtet" sich dazu, den "Kontrakt" des Interfaces zu erfüllen. Die Implementierung kann jedoch von beliebigen Objekten erfolgen. Daher sind Interfaces in der Kommunikation zwischen beliebigen Objekten sehr wichtig und deren genaue Dokumentation wesentlich.
Ebenso wie Objekte können Interfaces voneinander erben. Dies ist möglich, da Interfaces keine Implementationen enthalten und so bei gleich lautenden Methoden in den super-Interfaces keine Konflikte mit verschiedenen Implementationen auftreten können.

Hinweis:
Alle Methoden in einem Interface sind per Definition public . Die Definition von static Methoden in Interfaces ist nicht erlaubt, da Interfaces keine Informationen über die implementierenden Klassen besitzt. Es können ausschließlich public static final Variablen in Interfaces definiert werden.

Abstrakte Klassen:

Abstrakte Klassen werden in Java gleich behandelt wie in C++. Sobald eine Methode in einer Klasse als abstract markiert ist, kann keine Instanz dieser Klasse angelegt werden. Wenn man von einer abstrakten Klasse ableitet, so muß man alle absrakten Methoden der super-Klasse implementieren oder die Klaase erneut als abstract deklarieren. 
  abstract class Base {
    //implementation
    public abstract void someMethod();
  {

  class Sub extends Base {
    public void someMethod(){
      // Implementation
    }
    // some overwritten implementations
    // some new implementations
  }

Innere Klassen

Java erlaubt die Definition von inneren Klassen. Diese können public , protected oder private definiert sein. Die Sichtbarkeit ist gleich wie bei Membervariablen geregelt. Auch die deklaration als static ist zulässig. Verwendung finden innere Klassen vor allem bei der GUI-Programmierung. Nicht statische innere Klassen haben vollen Zugriff auf die Membervariablen der "umgebenden" Instanz. 
  abstract class Base {
    //implementation
    public abstract void someMethod(){
      InnerBase iBase = new InnerBase();
      //some implementation
    }

    protected class InnerBase {
      //implementation
    } 
  }

Wrapper Klassen

Java definiert für alle primitiven Datentypen(byte, short, char, int, long, float, double, boolean) entsprechende wrapper Klassen( Byte , Short , Character , Integer , Long , Float , Double , Boolean ). Diese Klassen werden hauptsächlich dann verwendet, wenn die Übergabe eines Objektes erforderlich ist. Als Beispiel für einen solchen Fall kann die Klasse Vector im Package java.util angeführt werden.
In einem Vector können nur Objects abgelegt werden. Will man also daten eines primitiven Types darin ablegen so muß man eine Wrapper Klasse benutzen. Zusätzlich definieren Wrapper Klassen auch nützliche Methoden zur Manipulation des darunterliegenden primitiven Wertes (z.B. Integer.valueOf(String s)). 

 import java.util.Vector;
 ...
 int i = 1;
 Vector integerList = new Vector();
 integerList.add(new Integer(i));
 ...
 int j = ((Integer)integerList.elementAt(0)).intValue();

Aufgabenstellung:

Ziel dieser Übung ist es, den Umgang mit Interfaces in Java anhand eines Beispiel zu üben.

  • Implementierung des Interfaces Moveable in der Klasse ComicCharacter aus Übung 2 (achten Sie auf die Packages).
  • Implementierung einer Klasse tmk1.Car (Hersteller, Model und Baujahr) implements Moveable .
    • Methode  getInto(Moveable moveableObject)und implementierung der Methode, daß beim Zusteigen des moveableObject die Position auf der des Autos gesetzt wir.
    • Implemtation des Moveable Interfaces in der Art und Weise, daß alle moveableObject die sich im Auto befinden mitbewegt werden.
    • Überschreiben der toString() Methode sodass diese Hersteller.Model.Baujahr und alle Insassen mit deren Position ausgibt.
  • Die Implementierung soll die sinnvolle Anwendung der oben genannten Konzepte beinhalten.
  • Die Klassen sollen dem vorgegebenen Testprogram genügen.
Dieses Beispiel zeigt:
  • Verschiedene Implementationen für ein und das selbe Interface
  • Übergabe verschiedener Klassen an eine Methode(über das moveable Intervace)
  • dynamisches Binden der toString() Methode bei den Insassen des Wagens
Fragen:
  • Was passiert, wenn man car2 in car1 einsteigen lässt und welche Probleme ergeben sich daraus? - Wie können sie umgangen werden.