Erweiterungen in Java

In Java  kann eine Typ als Erweiterungen  eines Typs gekennzeichnet werden.

Wenn eine Klasse als Erweiterung einer Klasse gekennzeichnet ist, so ist damit durch Java  sichergestellt, daß die Erweiterung alle Signaturen der Oberklasse implementiert, also ein formaler Untertyp  ist. Damit die Erweiterung auch ein semantischer Untertyp  ist, müßte jedoch noch zusätzlich sichergestellt sein, daß die Implementation der Erweiterung auch die Spezifikationen der Operationen der Basisklasse erfüllen. Das ist aber durch Java nicht  garantiert und muß deswegen vom Programmierer der Erweiterung selber sichergestellt werden.

Die Klasse "java.io.PrintStream" ist in Java  als Erweiterung der Klasse "Object" gekennzeichnet.

Eine Erweiterung in der Programmiersprache Java  entspricht einer Unterklasse in UML, daher wird eine Erweiterungsbeziehung in UML  auch durch einen Unterklassen-Pfeil dargestellt.

Object und java.io.PrintStream [UML class diagram]

.------------------------. 
|                        | 
|        Object          | 
|                        | 
|------------------------| 
|------------------------| 
| + hashCode() : int     | 
'------------------------' 
            ^ 
           /_\ 
            | 
.------------------------. 
|                        | 
|  java.io.PrintStream   | 
|                        | 
|------------------------| 
|------------------------| 
| + println() : void     | 
'------------------------'

Die Klasse "java.io.PrintStream" enthält also auch eine Operation "hashCode() : int", auch wenn diese in dem Rechteck dieser Klasse nicht extra aufgeführt wird. Wie gesagt, Java stellt nur sicher, daß es eine solche Operation irgendwie  gibt, nicht daß sie auch das Richtige macht, also die Spezifikation der Signatur "hashCode() : int" der Klasse "Object" erfüllt—das ist die Aufgabe des Autors der Klasse "java.io.PrintStream".

Man kann auch sagen, die Klasse "java.io.PrintStream" sei eine Object -Klasse, d.h. eine Unterklasse der Klasse "Object".

Mehrere Erweiterungen

Eine Klasse kann auch mehrere Erweiterungen  haben. So sind die Klasse "java.io.PrintStream" und die Klasse "String" beide  Erweiterungen des Typs "Object". Daher implementieren sie die Signaturen der Klasse "Object", wie z.B. die Operation "hashCode()". Jede Erweiterung kann dann noch weitere Operationen implementieren, die es nur in dieser Erweiterung gibt, wie beispielsweise die Operation "println()" oder die Operation "length()".

Eine Klasse und zwei Erweiterungen [UML class diagram]

                 .------------------------. 
                 |                        | 
                 |        Object          | 
                 |                        | 
                 |------------------------| 
                 |------------------------| 
                 | + hashCode() : int     | 
                 '------------------------' 
                             ^ 
                            /_\ 
                             | 
            .----------------'----------------. 
            |                                 | 
.------------------------.       .------------------------. 
|                        |       |                        | 
|  java.io.PrintStream   |       |          String        | 
|                        |       |                        | 
|------------------------|       |------------------------| 
|------------------------|       |------------------------| 
| + println() : void     |       | + length() : void      | 
'------------------------'       '------------------------'