Interfaces in JAVA

Interfaces
Interfaces in JAVA
Henrik von Coler
HAW-SS08
Henrik von Coler
Interfaces
Gliederung
1. Einleitung
2.
Deklaration einer Schnittstelle
3.
Implementierung einer Schnittstelle
4. Polymorphie mit Schnittstellen
5. (Mehrfach)Vererbung mit Schnittstellen
6.
Ableiten von Interfaces
7.
Konstanten in Interfaces
8. Instanceof ?
9. Vergleich: Abstrakte Klassen
10.
Interfaces als Funktionszeiger
11.
Spezielle Interfaces
Henrik von Coler
Interfaces
Einleitung
• Interface = Schnittstelle:
– Generell:
• „Stellt eine Verbindung her“
– In der OOP:
• Definiert Zugriffsmöglichkeiten auf Objekte
– In der Softwaretechnik seit 25 Jahren bekannt
Henrik von Coler
Interfaces
Die Schnittstelle in C++ und Smalltalk
• Klassen besitzen nur eine Schnittstelle
– Fest verbunden mit der Klasse / Objekt
– Wird immer sofort implementiert
Henrik von Coler
Interfaces
Die Schnittstelle in Java
– Schnittstellen sind Datentypen (wie Klassen,Felder)
– Schnittstellen können ohne Implementierung
definiert werden (vergl. abstrakte Klasse)
– Eine Klasse kann mehrere Schnittstellen besitzen
– Effekt:
• Wenige Schnittstellen deklarieren und
diese an vielen Stellen verwenden
• Mehrfachvererbung möglich
Henrik von Coler
Interfaces
Prinzip der Schnittstelle in Java
Schnittstelle
Schnittstelle
Schnittstelle
Klasse
Henrik von Coler
Interfaces
Prinzip der Schnittstelle in Java
Klasse
Schnittstelle
Schnittstelle
Schnittstelle
Server
client
Klasse
Henrik von Coler
Interfaces
Prinzip der Schnittstelle in Java
1:
Deklaration
der
Schnittstelle
2:
Implementierung
Der
Schnittstelle
Henrik von Coler
Interfaces
Deklaration einer Schnittstelle
Henrik von Coler
Interfaces
Deklaration einer Schnittstelle
interface KontoInfo
{
double Stand();
}
In Schnittstellen
dürfen Methoden nur
deklariert werden.
-Keine Rümpfe
-abstrakt
Henrik von Coler
Interfaces
Deklaration einer Schnittstelle
interface KontoInfo
{
double Stand();
}
Oft werden aus
Gründen der
Erkennbarkeit
Namen wie
buyableIF
Ibuyable
Verwendet.
Henrik von Coler
Interfaces
Deklaration einer Schnittstelle
Es dürfen auch
Konstanten deklariert
werden !
interface KontoInfo
{
double Stand();
public static final double DISPO = -1000;
}
Henrik von Coler
Interfaces
Deklaration einer Schnittstelle
interface KontoInfo
{
private double Stand();
}
Das geht nicht !
Dann wäre keine
Implementierung
möglich.
Henrik von Coler
Interfaces
Implementieren von Schnittstellen
Implementieren :
Gegenteil von Abstrahieren
Henrik von Coler
Interfaces
Implementieren von Schnittstellen
Es wird hier
Implementiert.
public class Sparbuch implements KontoInfo
{
public double kontostand ;
public double Stand()
{
return kontostand;
}
}
Das Implementieren
gleicht der Vererbung !
Henrik von Coler
Interfaces
Implementieren von Schnittstellen
Die Klasse muss ALLE Methoden
bereitstellen, die die
implementierte Schnittestelle
Bereitstellt.
public class Sparbuch implements KontoInfo
{
public double kontostand ;
public double Stand()
{
return kontostand;
interface KontoInfo
}
{
}
double Stand();
}
Henrik von Coler
Interfaces
Implementieren von Schnittstellen
public class Giro extends Konto implements KontoInfo
Giro
erbt von Konto
und
implementiert KontoInfo
Henrik von Coler
Interfaces
Implementieren von Schnittstellen
• Verschiedene Klassen können ein Interface auf
verschiedene Weisen implementieren.
Henrik von Coler
Interfaces
Implementieren von Schnittstellen
• Verschiedene Klassen können ein Interface auf
verschiedene Weisen implementieren.
interface
methode()
Klasse1
Klasse2
methode()
methode()
Attribut1
Attribut2
Henrik von Coler
Interfaces
Implementieren von Schnittstellen
• Problem:
– Was tun, wenn Methoden eines Interfaces bei einer
Klasse nicht benötigt werden ?
Henrik von Coler
Interfaces
Implementieren von Schnittstellen
• Problem:
– Was tun, wenn Methoden eines Interfaces bei einer
Klasse nicht benötigt werden ?
• Lösung: Leere Imlementierung
interface Interface1
{
public void fahren()
{}
public void fliegen()
{}
}
Henrik von Coler
Interfaces
Implementieren von Schnittstellen
• Problem:
– Was tun, wenn Methoden eines Interfaces bei einer
Klasse nicht benötigt werden ?
• Lösung: Leere Imlementierung
class Auto implements Interface1
{
public void fliegen()
{ // LEER
}
public void fliegen()
{………….
}
}
Die Funktion wird ohne
Rumpf implementiert
Henrik von Coler
Interfaces
Implementieren von Schnittstellen
• „Gegen“-Beispiel: Adapterklassen
public class Auto
{
public void
{}
public void
{}
public void
{}
public void
{}
}
VerdeckOeffnen()
AllradAntrieb()
Automatik()
AllradAntrieb()
Die Funktionen sind in
leerer Form
(nicht abstrakt)
bereitgestellt.
Henrik von Coler
Interfaces
Implementieren von Schnittstellen
• „Gegen“-Beispiel: Adapterklassen
public class SeatMarbella extends Auto
{
public void VerdeckOeffnen()
{
// FUNKTIONSRUMPF
}
public void Automatik()
{
// FUNKTIONSRUMPF
}
}
Die erbende Klasse
überschreibt nur die
benötigten Funktionen.
Henrik von Coler
Interfaces
Frage:
Welchen Sinn haben Schnittstellen ?
Frage erinnert an Pointer in C !
Henrik von Coler
Interfaces
Polymorphie mit Schnittstellen
Polymorphie = Vielgestaltigkeit
Hier: Für einen Funktionsaufruf mit VarArg !
Eclipse Beispiel: Beispiel_3.java
Henrik von Coler
Interfaces
Polymorphie mit Schnittstellen
Interface wird
interface Buyable
{
double price();
}
deklariert.
Henrik von Coler
Interfaces
Polymorphie mit Schnittstellen
public class Chocolate implements Buyable
{
public double price()
{
return 0.69;
}
}
Interface wird
implementiert.
Henrik von Coler
Interfaces
Polymorphie mit Schnittstellen
abstract class GameObject
{
abstract boolean useOn( GameObject object );
}
public class Magazine extends GameObject
implements Buyable
{
double price;
public double price()
{
return price;
}
}
Interface wird
implementiert.
In einer Anderen Klasse.
Mit einer anderen
Funktion.
Henrik von Coler
Interfaces
Polymorphie mit Schnittstellen
Buyable b1 = new Magazine();
Buyable b2 = new Chocolate();
System.out.println( b1.price() );
System.out.println( b2.price() );
2 Objekte, die buyable
implementieren werden
instanziert.
Henrik von Coler
Interfaces
Polymorphie mit Schnittstellen
Vararg
static double calculateSum( Buyable price1, Buyable...
prices )
{
double result = price1.price();
Hier tritt die Polymorphie
auf.
for ( Buyable price : prices )
result += price.price();
Vararg
return result;
}
Henrik von Coler
Interfaces
Polymorphie mit Schnittstellen
Magazine madMag = new Magazine();
madMag.price = 2.50;
Buyable schoki = new Chocolate();
Magazine maxim = new Magazine();
maxim.price = 3.00;
System.out.printf( "%.2f", PriceUtils.calculateSum
( madMag, maxim, schoki ) );
// 6,19
Polymorphie hier:
Über eine Schnittstelle werden verschiede
Argumente an eine Funktion übergeben.
Henrik von Coler
Interfaces
Mehrfachvererbung bei Schnittstellen
Henrik von Coler
Interfaces
Mehrfachvererbung bei Schnittstellen
• Bei Klassen in Java gilt:
– Es darf nur von einer direkten Objektklasse direkt
abgeleitet werden. (Ziel: mehr Übersicht)
• Eine Klasse kann aber mehrere Schnittstellen
implementieren ! („Mehrfachvererbung“)
Henrik von Coler
Interfaces
Mehrfachvererbung bei Schnittstellen
Klasse
Klasse
Schnittstelle
Schnittstelle
VERERBUNG
Klasse
Klasse
Henrik von Coler
Interfaces
Mehrfachvererbung bei Schnittstellen
Kollisionsgefahr
public class beine
public class nase
{
{
public void laufen()
public void laufen()
{…
{…
}
}
}
}
public class mensch extends beine, nase
{
}
Henrik von Coler
Interfaces
Mehrfachvererbung bei Schnittstellen
keine Kollisionsgefahr
interface beine
interface nase
{
{
public void laufen();
}
public void laufen();
}
public class mensch implements beine , nase
{
public void laufen()
{…
}
}
Henrik von Coler
Interfaces
Mehrfachvererbung bei Schnittstellen
Schnittstellen werden weitervererbt !
Henrik von Coler
Interfaces
Mehrfachvererbung bei Schnittstellen
interface Fahrzeug {
public int plaetze();
public int verbrauch();
}
Henrik von Coler
Interfaces
Mehrfachvererbung bei Schnittstellen
interface Fahrzeug {
public int plaetze();
public int verbrauch();
}
class Auto implements Fahrzeug {
pubic string name;
pubic int sitzplaetze;
private double spritverbrauch;
public int plaetze()
{return sitzplaetze;}
public int verbrauch()
{return spritverbrauch;}
}
Henrik von Coler
Interfaces
Mehrfachvererbung bei Schnittstellen
interface Fahrzeug {
public int plaetze();
public int verbrauch();
}
interface Sammlerstueck {
public double wert();
public int jahr();
}
class Auto implements Fahrzeug {
pubic string name;
pubic int sitzplaetze;
private double spritverbrauch;
public int plaetze()
{return sitzplaetze;}
public int verbrauch()
{return spritverbrauch;}
}
Henrik von Coler
Interfaces
Mehrfachvererbung bei Schnittstellen
interface Fahrzeug {
public int plaetze();
public int verbrauch();
}
class Auto implements Fahrzeug {
pubic string name;
pubic int sitzplaetze;
private double spritverbrauch;
public int plaetze()
{return sitzplaetze;}
public int verbrauch()
{return spritverbrauch;}
}
interface Sammlerstueck {
public double wert();
public int jahr();
}
class VWPolo extends Auto
implements Sammlerstück {
pubic int baujahr;
private double sammlerwert;
public int wert()
{return sammlerwert;}
public int jahr()
{return baujahr;}
}
Das Interface Fahrzeug wird automatisch
mitvererbt !
Henrik von Coler
Interfaces
Mehrfachvererbung bei Schnittstellen
Oder auch direkt !
Henrik von Coler
Interfaces
Mehrfachvererbung bei Schnittstellen
interface Fahrzeug {
public int plaetze();
public int verbrauch();
}
interface Sammlerstueck {
public double wert();
public int jahr();
}
class FiatPanda implements Fahrzeug , Sammlerstück
{
// einige Funktionen
}
Henrik von Coler
Interfaces
Ableiten von Interfaces (Subinterfaces)
Henrik von Coler
Interfaces
Ableiten von Interfaces (Subinterfaces)
Interfaces können eine Vererbungshierarchie
bilden und voneinander abgeleitet werden.
Beispiel in Eclipse:
(Beispiel_1.java)
Henrik von Coler
Interfaces
Ableiten von Interfaces (Subinterfaces)
5
Ausgabe:
Text1
Text2
Henrik von Coler
Interfaces
Konstanten in Interfaces
Henrik von Coler
Interfaces
Konstanten in Interfaces
Alle Konstanten sind immer:
public final static Typ Variable = Wert;
Auch wenn sie nur so deklariert werden:
static Typ Variable = Wert;
Henrik von Coler
Interfaces
Konstanten in Interfaces
Bei Anwendungen mit vielen Konstanten werden
reine Konstanten-Interfaces angelegt:
interface Kiste
{
public static final int laenge = 100;
public static final int breite = 200;
public static final int hoehe = 120;
}
Henrik von Coler
Interfaces
Instanceof ?
Manchmal ist es nötig, zu wissen, ob ein Objekt ein
bestimmtes Interface implementiert.
(bei Mehrfachvererbung)
Mit – instanceof - kann das überprüft
werden.
Henrik von Coler
Interfaces
Instanceof ?
interface inter1
{}
class superclass implements inter1
{}
public main class23
{
public class main(String[] args)
{
superclass object1 = new superclass();
system.out.print(object instanceof inter1);
}
}
Henrik von Coler
Interfaces
Instanceof ?
interface inter1
{}
class superclass implements inter1
{}
public main class23
{
public class main(String[] args)
{
superclass object1 = new superclass();
system.out.print(object instanceof inter1);
}
}
Ausgabe : true
Henrik von Coler
Interfaces
Vergleich mit abstrakten Klassen
Henrik von Coler
Interfaces
Vergleich mit abstrakten Klassen
Teildefinition „abstrakt“:
Es fehlt die Möglichkeit, Objekte zu
erzeugen.
Henrik von Coler
Interfaces
Vergleich mit abstrakten Klassen
abstrakte Klasse
und
Interface
Sind sich sehr ähnlich.
Es gibt aber wichtige Unterschiede.
Henrik von Coler
Interfaces
Vergleich mit abstrakten Klassen
abstrakte Klasse
Interface
abstract class Konto
{
public abstract Stand();
public abstract Dispo();
}
interface Konto
{
public Stand();
public Dispo();
}
class giro extends konto
{
public Stand()
{};
public Dispo()
{};
}
class giro inplements konto
{
public Stand()
{};
public Dispo()
{};
}
Henrik von Coler
Interfaces
Vergleich mit abstrakten Klassen
abstrakte Klasse
Interface
keine Mehrfachvererbung
Mehrfachvererbung
Methoden können konkretisiert
werden
immer neue Implementierung
Henrik von Coler
Interfaces
Interfaces als Funktionszeiger
Henrik von Coler
Interfaces
Interfaces als Funktionszeiger
Funktionszeiger (C, C++) sind in Java nicht vorhanden !
- Notwendig, wenn eine Funktion als Argument mehr
als Variablen erwartet (Funktionsplotter, Callback. )
In Eclipse:Beispiel_2.java
Henrik von Coler
Interfaces
Interfaces als Funktionszeiger
Beispiel:
1
public interface DoubleMethod
{
public double compute(double value);
}
Das Interface wird deklariert
class MathExp implements DoubleMethod
{
public double compute(double value)
{
return Math.exp(value);
}
}
Das Interface wird implementiert
Henrik von Coler
Interfaces
Interfaces als Funktionszeiger
Beispiel:
class MathSqrt implements DoubleMethod
{
public double compute(double value)
{
return Math.sqrt(value);
}
}
class Times2 implements DoubleMethod
{
public double compute(double value)
{
return 2 * value;
}
}
2
Das Interface wird implementiert
Das Interface wird implementiert
Henrik von Coler
Interfaces
Interfaces als Funktionszeiger
Beispiel:
3
public class listing0914
Die Methode printTable wird bereitgestellt
{
public static void printTable(DoubleMethod meth)
{
System.out.println(„Wertetabelle“ + meth.toString());
for(double x = 0.0: x<= 5.0 : x += 1)
{
System.out.println(„ “ + x + „->“ + meth.compute(x));
}
}
}
Henrik von Coler
Interfaces
Interfaces als Funktionszeiger
Beispiel:
public static void main(String[] args)
{
printTable(new Times2());
printTable(new MathExp());
printTable(new Sqr());
printTable(new MathSqr());
}
4
Die Klassen werden instanziert
und an printTable übergeben.
Die Wertetabelle wird erzeugt.
Henrik von Coler
Interfaces
Spezielle Interfaces
Henrik von Coler
Interfaces
Spezielle Interfaces
• In Bibliotheken sind bereits einige Interfaces
enthalten – zwei Beispiele :
Henrik von Coler
Interfaces
Das Interface „Compareable“
• Ist enthalten in java.lang
• Kann von Klassen implementiert werden, deren Objekte
paarweise vergleichbar sind.
– String
– Character
• Zum Sortieren geeignet
Henrik von Coler
Interfaces
Das Interface „Serializable“
• Wird benötigt, um Objekte zu speichern
public object OB1 implements Serializable
{
. . . . .
}
Ist enthalten in java.io.*;
Henrik von Coler
Interfaces
Zusammenfassung
Zweck von Interfaces in Java
– Kompatibilitaät zwischen Objekten verschiedener
Klassen
– Erhöhte Übersichtlichkeit
– Macht Mehrfachvererbung möglich
– Nutzung als Zeiger
– Threads
Henrik von Coler
Interfaces
Quellen
•
•
•
•
„Handbuch der Java Programmierung“ [G. Krüger]
„Java ist auch eine Insel“ [C. Ullenboom]
„Programmieren in Java“ [Fritz Jobst]
„Java“ [H. Erlenkötter]
Henrik von Coler