Design Ein Interface (=Schnittstelle / Definition) beschreibt, welche

Interface
So werden Interfaces gemacht
Design
Ein Interface (=Schnittstelle / Definition) beschreibt, welche
Funktionalität eine Implementation nach Aussen anzubieten hat.
Die dahinter liegende Algorithmik wird aber der Implementation
überlassen.
Interface
So werden Interfaces gemacht
Design
Ein Interface (=Schnittstelle / Definition) beschreibt, welche
Funktionalität eine Implementation nach Aussen anzubieten hat.
Die dahinter liegende Algorithmik wird aber der Implementation
überlassen.
Analog
Ein Interface ist die Formale (in Java geschrieben) Beschreibung
des UseCase.
Interface
So werden Interfaces gemacht
Design
Ein Interface (=Schnittstelle / Definition) beschreibt, welche
Funktionalität eine Implementation nach Aussen anzubieten hat.
Die dahinter liegende Algorithmik wird aber der Implementation
überlassen.
Analog
Ein Interface ist die Formale (in Java geschrieben) Beschreibung
des UseCase.
Es ist nicht das ’Wie’, sondern das ’Was’, welches interessiert.
Interface
So werden Interfaces gemacht
Example
Für unser Beispiel soll eine Definition für ein Behältnis (=Box)
entstehen:
Goal
Was muss eine Box können, damit sie eine Box ist?
etwas in sie hineintun können (=insert)
Interface
So werden Interfaces gemacht
Example
Für unser Beispiel soll eine Definition für ein Behältnis (=Box)
entstehen:
Goal
Was muss eine Box können, damit sie eine Box ist?
etwas in sie hineintun können (=insert)
etwas aus ihr herausholen können (=remove)
Interface
So werden Interfaces gemacht
Example
Für unser Beispiel soll eine Definition für ein Behältnis (=Box)
entstehen:
Goal
Was muss eine Box können, damit sie eine Box ist?
etwas in sie hineintun können (=insert)
etwas aus ihr herausholen können (=remove)
schauen, ob die Box leer ist (=isEmpty)
Interface
So werden Interfaces gemacht
Interface Boxable
3 public interface Boxable {
25 }
Interface
So werden Interfaces gemacht
Interface Boxable
3 public interface Boxable {
4
/* *
5
* Diese Methode erlaubt das Hinzufuegen Kopie der
Referenz auf ein Exemplar einer beliebigen
Klasse (= Object ) .
6
*
7
* @param item Diese Variable erhaelt eine
Referenzkopie auf ein beliebiges Object
8
* @throws Exception Falls die ( Vor -) Bedingungen
nicht so sind , wie wir sie brauchen .
9
*/
10
public void insert ( Object item ) throws Exception ;
25 }
Interface
So werden Interfaces gemacht
Interface Boxable
3 public interface Boxable {
10
public void insert ( Object item ) throws Exception ;
12
/* *
13
* Diese Methode gibt eine Kopie der Referenz eines
Exemplares einer beliebigen Klasse (= Object )
zurueck , welches vorher mit { @link # put () }
bekanntgegeben wurde
14
*
15
* @return die Referenz auf das Object .
16
* @throws Exception Falls die ( Vor -) Bedingungen
nicht so sind , wie wir sie brauchen .
17
*/
18
public Object remove () throws Exception ;
25 }
Interface
So werden Interfaces gemacht
Interface Boxable
3 public interface Boxable {
10
public void insert ( Object item ) throws Exception ;
18
public Object remove () throws Exception ;
20
/* *
21
* Diese Methode gibt an , ob das Boxable keine
Referenz traegt (= frei ist )
22
* @return false falls eine Referenz vorhanden ist ,
sonst true
23
*/
24
public boolean isEmpty () ;
25 }
Interface
So werden Interfaces gemacht
Implementation von Boxable (SimpleBox)
3 /* *
4 * Diese Auspraegung (= Implementierung ) von { @link
Boxable } kann genau ein
5 * Element verwalten . Falls versucht wird mehrere
Elemente aufzunehmen , wird
6 * eine Exception geworfen . Falls versucht wird KEIN
Element (=
7 * < code > null </ code >) aufzunehmen , wird eine Exception
geworfen .
8 *
9 * Falls versucht wird ein Element abzugeben , obwohl
kein Element vorhanden ist ,
10 * wird eine Exception geworfen .
11 */
12 public class SimpleBox implements Boxable {
39 }
Interface
So werden Interfaces gemacht
Implementation von Boxable (SimpleBox)
12 public class SimpleBox implements Boxable {
14
/* * An diesem Ort wird das Item verwaltet */
15
private Object item ;
17
@Override
18
public Object remove () throws Exception {
24
}
26
@Override
27
public void insert ( Object item ) throws Exception {
34
}
35
@Override
36
public boolean isEmpty () {
38
}
39 }
Interface
So werden Interfaces gemacht
Implementation von Boxable (SimpleBox)
12 public class SimpleBox implements Boxable {
14
/* * An diesem Ort wird das Item verwaltet */
15
private Object item ;
17
@Override
18
public Object remove () throws Exception {
19
if ( isEmpty () )
20
throw new Exception ( " SimpleBox ist leer " ) ;
21
Object item = this . item ;
22
this . item = null ;
23
return item ;
24
}
27
public void insert ( Object item ) throws Exception {
34
}
36
public boolean isEmpty () {
38
}
39 }
Interface
So werden Interfaces gemacht
Implementation von Boxable (SimpleBox)
12 public class SimpleBox implements Boxable {
14
/* * An diesem Ort wird das Item verwaltet */
15
private Object item ;
18
public Object remove () throws Exception {
24
}
26
@Override
27
public void insert ( Object item ) throws Exception {
28
if (! isEmpty () )
29
throw new Exception (
30
" Es ist nicht moeglich KEIN Element in die
SimpleBox zu legen " ) ;
31
if ( this . item != null )
32
throw new Exception ( " SimpleBox ist bereits voll "
);
33
this . item = item ;
34
}
36
public boolean isEmpty () {
38
}
39 }
Interface
So werden Interfaces gemacht
Implementation von Boxable (SimpleBox)
12 public class SimpleBox implements Boxable {
14
/* * An diesem Ort wird das Item verwaltet */
15
private Object item ;
18
public Object remove () throws Exception {
24
}
27
public void insert ( Object item ) throws Exception {
34
}
35
@Override
36
public boolean isEmpty () {
37
return item == null ;
38
}
39 }
Interface
So werden Interfaces gemacht
Organisation in Packages
Ein Package dient zur logischen Ordnung von Java-Einheiten. Das
Arbeiten mit Packages entspricht dem Arbeiten mit einer
Verzeichnisstrucktur.
Interface
So werden Interfaces gemacht
Organisation in Packages
Eine mögliche Package Struktur in einem Projekt sieht wie folgt
aus:
ch.bfh.sws.java.mas2009
+-box
| +-api
| | +-Box.java
| +-implementation
|
+-SimpleBox.java
|
+-ShuffleBox.java
|
+-StackBox.java
|
+-QueueBox.java
+-TestBox.java
Interface
So werden Interfaces gemacht
Classname
Bei einer solchen Struktur wird jeder Klassenname ein-eindeutig:
1 package ch . bfh . sws . java . mas2009 . box . implementation ;
5 public class SimpleBox implements Box {
7 }
Interface
So werden Interfaces gemacht
Classname
Bei einer solchen Struktur wird jeder Klassenname ein-eindeutig:
1 package ch . bfh . sws . java . mas2009 . box . implementation ;
5 public class SimpleBox implements Box {
7 }
Fully Qualified Name
ch.bfh.sws.java.mas2009.box.implementation.SimpleBox.java
Interface
So werden Interfaces gemacht
Developping by Interface
Es ist üblich, dass nicht anhand einer Klasse programmiert wird,
sondern anhand eines Interfaces. Dies ermöglicht es dem
Programm mit jder beliebigen Implementation des Interfaces
umzugehen (=late binding)
Interface
So werden Interfaces gemacht
7 /* *
8 * Der BoxManager hat die Faehigkeit , mit einer
beliebigen Box zu arbeiten
9 *
10 */
11 public class BoxManager {
13
/* *
14
* Eine Box wird mit maximal 5 Elementen bestueckt .
15
* @param box Eine Referenz auf ein beliebiges
Exemplar , dessen Plan das Interface Box
implementiert .
16
* @throws Exception Falls keine Box mitgegeben wird
.
17
*/
18
public void fill ( Box box ) throws Exception {
20
...
30
}
54 }
Interface
So werden Interfaces gemacht
11 public class BoxManager {
18
public void fill ( Box box ) throws Exception {
22
if ( box == null ) throw new Exception ( " Es wurde keine
Box mitgegeben " ) ;
23
try {
24
for ( int i = 0; i < 5; i ++) {
25
box . insert ( new String ( " Item : " + i ) ) ;
26
}
27
} catch ( Exception e ) {
28
System . out . println ( e . getMessage () ) ;
29
}
30
}
54 }
Interface
So werden Interfaces gemacht
11 public class BoxManager {
18
public void fill ( Box box ) throws Exception {
20
...
30
}
31
/* *
32
* Eine Box wird komplett entleert und deren Inhalt
als String auf der Konsole angezeigt .
34
* @param box Eine Referenz auf ein beliebiges
Exemplar , dessen Plan das Interface Box
implementiert .
35
* @throws Exception Falls keine Box mitgegeben wird
.
36
*/
37
public void empty ( Box box ) throws Exception {
39
...
53
}
54 }
Interface
So werden Interfaces gemacht
11 public class BoxManager {
18
public void fill ( Box box ) throws Exception {
20
...
30
}
37
public void empty ( Box box ) throws Exception {
41
if ( box == null ) throw new Exception ( " Es wurde keine
Box mitgegeben " ) ;
42
while (! box . isEmpty () ) {
43
try {
44
System . out . println ( box . remove () ) ;
45
} catch ( Exception e ) {
46
System . out . println ( " Das darf aber nicht
passieren !: " + e . getMessage () ) ;
47
}
48
}
53
}
54 }
Interface
So werden Interfaces gemacht
Developping by Interface
Und was, wenn doch mal etwas genau von einer speziellen
Implementierung verlangt wird?
Interface
So werden Interfaces gemacht
17 public class SimpleBox implements Box {
20
...
49
/* *
50
* Spezielle Methode von SimpleBox
51
*/
52
public void mightyMethod () {
53
System . out . println ( " I am the mightiest ! " ) ;
54
}
55 }
Interface
So werden Interfaces gemacht
11 public class BoxManager {
20
...
31
/* *
32
* Eine Box wird komplett entleert und deren Inhalt
als String auf der Konsole angezeigt .
33
* Falls die Box eine SimpleBox ist , wird deren
spezielle Methode noch ausgefuehrt .
34
* @param box Eine Referenz auf ein beliebiges
Exemplar , dessen Plan das Interface Box
implementiert .
35
* @throws Exception Falls keine Box mitgegeben wird
.
36
*/
37
public void empty ( Box box ) throws Exception {
39
...
49
if ( box instanceof SimpleBox ) {
50
SimpleBox sb = ( SimpleBox ) box ;
51
sb . mightyMethod () ;
52
}
53
}
54 }
Interface
So werden Interfaces gemacht
Test by simplicity
3 /* *
4 * Definition eines beliebigen Schlosses
5 */
6 public interface Lock {
19
public void lock ( String secretKey ) throws Exception ;
33
public void unlock ( String secretKey ) throws
Exception ;
41
public boolean isLocked () ;
42 }
Interface
So werden Interfaces gemacht
Test by simplicity
6 public interface Lock {
7
/* *
8
* Fuer das Locking wird ein Schluessel in Form
eines Strings benutzt .
9
*
10
* @param secretKey
11
*
Der Schluessel mit dem das { @link Lock }
verschlossen wird .
12
* @throws Exception
13
*
<ul >
14
*
<li > Falls KEIN Schluessel (= < code > null </ code >)
mitgegeben wurde </ li >
15
*
<li > Falls das { @link Lock } bereits anderweitig
geschlossen wurde .
16
*
</ li >
17
*
</ ul >
18
*/
19
public void lock ( String secretKey ) throws Exception ;
42 }
Interface
So werden Interfaces gemacht
Test by simplicity
6 public interface Lock {
21
/* *
22
* Fuer das Unlocking wird der Schluessel benoetigt ,
welcher beim { @link Lock # lock ( String ) } zum
Zuge kam .
23
*
24
* @param secretKey
25
*
Der Schluessel mit dem das { @link Lock }
geoeffnet wird .
26
* @throws Exception
27
*
<ul >
28
*
<li > Falls das { @link Lock } bereits anderweitig
geoeffnet wurde .
29
*
<li > Falls der Schluessel falsch ist </ li >
30
*
</ li >
31
*
</ ul >
32
*/
33
public void unlock ( String secretKey ) throws
Exception ;
Interface
So werden Interfaces gemacht
Test by simplicity
6 public interface Lock {
35
/* *
36
* Statusabfrage
37
*
38
* @return < code > true </ code > , falls das { @link Lock }
verschlossen ist , sonst
39
*
< code > false </ code >
40
*/
41
public boolean isLocked () ;
42 }
Interface
So werden Interfaces gemacht
Test by simplicity
Implementation zum Testen (Der Kryptogloge ist in den Ferien)
Interface
So werden Interfaces gemacht
Interfaces defined by Interfaces
Es ist auch möglich, eine Beziehung zwischen mehreren Interfaces
zu erstellen:
6 /* *
7 * A { @link Safe } can do the things a { @link Box } can
and is able to
8 * protect itself with the abilities of a { @link Lock }
9 */
10 public interface Safe extends Box , Lock {
11 }
Interface
So werden Interfaces gemacht
Use Interfaces
Die Implementation kann dann ausschliesslich auf Interfaces
basieren:
Interface
So werden Interfaces gemacht
Use Interfaces
7
8
9
11
12
13
14
15
16
52
54
public class DefaultSafe implements Safe {
private Lock lock ;
private Box box ;
public DefaultSafe ( Lock lock , Box box ) throws
Exception
{
if ( lock == null || box == null ) throw new Exception ( " Not
all composits provided " ) ;
this . lock = lock ;
this . box = box ;
}
...
}
Interface
So werden Interfaces gemacht
Use Interfaces
7
8
9
18
19
20
21
22
52
54
public class DefaultSafe implements Safe {
private Lock lock ;
private Box box ;
@Override
public Object remove () throws Exception {
if ( this . lock . isLocked () ) throw new Exception ( " Safe
locked " ) ;
return this . box . remove () ;
}
...
}