# Spezifikation von Schnittstellen für einen Netzplan



## Claudia78 (25. Jul 2005)

*Hallo*,

kann mir jemand weiterhelfen bei einer Spezfiaktion von Schnittstellen und Testfällen für ein Netzplan?

Die Aufgabe lautet.
- Es soll ein Netzplan implemeniert werden welcher zeitliche Informationen über Vorgänge speichert. Unter anderem 
  (frühester und spätester Anfangs- und Endzeitpunkt, globlae / freie/ unabhängige Pufferzeiten...). 

- Es soll im späteren Verlauf verschiedene Graphen auf den Netzplan implementiert werden. ( Für meine Frage hier 
  irrelevant)

- Vorab sollen die benötigten Schnittstellen für den Netzplan und die Netzplanberechnung spezifiziert werden und 
  Testfälle aufgestellt werden. Es muss berücksichtigt werden der Fall, dass eine Netzplanung fehlschlagen kann. 
  Diese Fehler sind ebenfalls abzufangen.


Da ich noch nicht soviel in Java programmiert habe und auch noch nicht soviel objektorientiert programmiert habe, wäre es super wenn jemand mal über meine bisherige Lösung rüber schauen würde und mir Tipps geben würde.

Ich habe drei Schnittstellen spezifiziert:

Das erste Interface für die Knoten:

```
public interface IKnoten {
	
	public void aendernKnoten(int faz, int fez, int saz, int sez, LinkedList vorgaenger,
			LinkedList nachfolger, int dauer, int gp, int fp, int up, int frp,
			String name);
	
	// Es werden die gespeicherten Daten, also alle Termine des Knoten geandert
	
	public void loeschenKnoten(LinkedList l);
	// Es wird der ausgewählte Knoten aus der Netzplanliste gelöscht und danach 
	// die Instanz des Knotens gelöscht
	
	public void einfuegenKnoten(LinkedList l);
	// es wird der ausgewählte Knoten in die Netzplanliste eingetragen
	
}
```

Für das Erzeugen eins Knoten habe ich in der Objektklasse Knoten eine Factory Methode erzeugeKnoten()
implementiert. Ist dies eine gute Lösung? Oder sollte ich das anders machen ?
Kann ich diese Methode in das Interface übernehmen ?


```
public static Knoten erzeugeKnoten(int faz, int fez, int saz, int sez, LinkedList vorgaenger,
			LinkedList nachfolger, int dauer, int gp, int fp, int up, int frp,
			String name){
		
		return new Knoten(faz,fez, frp, frp, nachfolger, nachfolger, frp, frp, frp, frp, frp, name);
	}
```

Mein zweites Interface ist für den Netplan

```
public interface INetz {
	
	
	public LinkedList createNetzplan();
	// Es wird eine Liste erzeugt wo sämtliche Knoten eingeordnet
	// werden. Diese Liste wird zurückgegeben 

	public void deleteNetzplan(LinkedList l);
	// Es wird der ganze Netzplan also die ganze verkettete Liste gelöscht
	
	public boolean existiertNetzplan(LinkedList l);
	// Es wird mit der Funktion geprüft ob eine Liste bereits angelegt ist
	
}
```

Die dritte Interface Klasse Berechnung muss ich noch implemetieren. Denke aber das diese nicht so schwer würd.
Welche Testfälle kann ich auf den Netzplan anwenden? 


Wäre nett wenn jemand mal sich meine Spezifikation anschauen würde und mir Verbesserungsvorschläge machen würde! Z.B. sind 3 Interfaces zuviel und soll ich alle Methoden in ein Interface stecken ??

mfg Claudia


----------



## Beni (25. Jul 2005)

```
public void aendernKnoten(int faz, int fez, int saz, int sez, LinkedList vorgaenger,
         LinkedList nachfolger, int dauer, int gp, int fp, int up, int frp,
         String name);
```
Was um himmelswillen soll diese Methode machen, was soll "fp", "up" etc sein... ?
Eine Methode mit mehr als 4 Parametern ist meistens :bloed: , unterteile die Methode doch in mehrere. "setDauer( int dauer )", etc... Und: nimm weniger kryptische Namen :wink:

Dann: du benutzt oft LinkedList. Ist es wichtig, dass es eine LinkedList ist, oder reicht die Angabe, dass es eine Liste ist? Wahrscheinlich reicht "List", also schreib auch nur "List" hin.

Eine "KnotenFactory" ist eine gute Idee, aber das "static" nicht. Der Sinn von Factories ist ja gerade, dass man sie (sogar während das Programm läuft) austauschen kann. Also, lass das static weg, initialisier die Factory(oder Factories) an einem zentralen Ort, und reiche sie dorthin weiter, wo sie benötigt wird.
Und nein, static-Methoden können nicht in Interfaces sein. Deshalb sind sie auch 'bääh'.

3 Interfaces finde ich hier schon passend (ok, ob sich INetz noch lohnt, oder ob man da nicht besser gleich eine Klasse Netz implementiert... kommt auf die Anwendung draufan).
Alles in eines stopfen: nein. Die Methoden sind zu unabhängig, als dass das Sinn machen würde.


----------



## Claudia78 (25. Jul 2005)

Die Methode aendernKnoten(......) soll im späteren Verlauf des Programmes die Attribute des Knoten ändern. 
Es soll dem Anwender später in der graphischen Oberfläche möglich sein, neue Knoten per Mouseclick anzulegen und
Knotendaten zu ändern. 
Für das neue Anlegen von Knoten will ich die Factorymethode erzeugeKnoten() verwenden und für das Ändern eines 
Knoten die Methode aendernKnoten(......) .

faz <=> frühster anfangszeitpunkt
sez <=> spätester anfangszeitpunkt
gp <=> globaler puffer .....usw. 

Du sagst ich soll besser die Methode aendernKnoten() in setdauer(int ..) usw.. aufteilen!
Wie meinst du das ?? Soll ich aus der Methode aendernKnoten() zwei oder drei Methoden machen ?? Oder in den Übergabeparametern die von dir als Beispiel angegebene Funktion setdauer() aufrufen??

- Weswegen soll ich aus den LinkedList nur List machen ?? Hängt das mit der Performace zusammen ??

- Mit der Factory Methode erzeugeKnoten() bekomme ich nicht hin. Im Java Core 2 Buch steht drin, dass Factorymethoden statische Funktionen sind. Wenn ich also das "static" wegnehme tritt in der Zeile ein Fehler auf.

Wie bekomme ich das static weg damit ich die Funktion ebenfalls im Interface spezifizieren kann und wie rufe ich die 
Funktion in der main Methode richtig auf ?



```
public static void main(String[] args) {
		
		Netz netz = new Netz();
		LinkedList netzplan = netz.createNetzplan();
		for(int i = 0;i<10;i++)
		{   		
			Knoten k1 = Knoten.erzeugeKnoten(i, 5, i, 1, null, null, 5, 6, 6, 6, 6, "A");
			k1.einfuegenKnoten(netzplan);
			System.out.println(k1.getName());
		}	
			
		for( int i = 0; i<netzplan.size();i++)
		{  		
			Knoten k = (Knoten) netzplan.get(i);
			if (i==5)
			{		
				k.loeschenKnoten(netzplan);	
				
			}
		 
		}
		Knoten k1 = Knoten.erzeugeKnoten(3, 5, 3, 1, null, null, 6, 6, 6, 6, 6, "A");
		k1.einfuegenKnoten(netzplan);
		
	
	}
```

hoffe mir kann nochmal jemand weiterhelfen.

mfg Claudia


----------



## Beni (25. Jul 2005)

Claudia78 hat gesagt.:
			
		

> Die Methode aendernKnoten(......) soll im späteren Verlauf des Programmes die Attribute des Knoten ändern.
> Es soll dem Anwender später in der graphischen Oberfläche möglich sein, neue Knoten per Mouseclick anzulegen und
> Knotendaten zu ändern.
> Für das neue Anlegen von Knoten will ich die Factorymethode erzeugeKnoten() verwenden und für das Ändern eines
> ...


Ich dachte an sowas:

```
public interface IKnoten{
  public void setDauer( int dauer );
  public void setFAZ( int faz );
  public void setSEZ( int set );
  ... und so weiter
}
```



> - Weswegen soll ich aus den LinkedList nur List machen ?? Hängt das mit der Performace zusammen ??


Nein. Benötigst du die Information, dass es eine LinkedList ist? Was nützt dir das Wissen, dass es eine LinkedList ist? Eigentlich ist das nur Ballast. Dir reicht es doch, wenn du weisst, dass da irgendeine Liste mit den Methoden "add" "get" und "remove" daherkommt.
Es ist ein nicht unwichtiges Konzept, dass man immer nur soviel fordert, wie man tatsächlich benötigt. Wenn du nämlich nur "List" hinschreibst, kannst du auch plötzlich mal eine ArrayList verwenden, _ohne_ den ganzen Code über den Haufen zu werfen.



> - Mit der Factory Methode erzeugeKnoten() bekomme ich nicht hin. Im Java Core 2 Buch steht drin, dass Factorymethoden statische Funktionen sind. Wenn ich also das "static" wegnehme tritt in der Zeile ein Fehler auf.


Dann sagt das Buch nur die halbe Wahrheit :wink:

Du könntest etwas in die Richtung bauen (der letzte Codeteile ist nur, damit du siehst, wie du die Factory zusammen mit Methoden benutzen kannst.)

```
public interface KnotenFactory{
  public IKnoten erzeuge( int xyz ); // jaja, was du da halt alles benötigst, bin zu faul alles abzuschreiben ;-)
}
```


```
public class VerySpezialKnotenFactory implements KnotenFactory{
  public IKnoten erzeuge( int xyz ){
    return new VerySpezialKnoten( xyz );
  }
}
```


```
public static void main( String[] args ){
  KnotenFactory factory;

  // noch im Programm kann man die Factories wählen
  if( args[0].equals( "debug" ) )
    factory = new DebugKnotenFactory();
  else
    factory = new VerySpezialKnotenFactory();

  List line1 = makeLine1( factory );
  List line2 = makeLine2( factory );
}

public static List makeLine1( KnotenFactory factory ){
  List list = new ArrayList();
  list.add( factory.erzeuge( 123 ));
  list.add( factory.erzeuge( 456 ));
  return list;
}

public static List makeLine2( KnotenFactory factory ){
  List list = new LinkedList();
  list.add( factory.erzeuge( 654 ));
  list.add( factory.erzeuge( 321 ));
  return list;
}
```


----------



## Claudia78 (27. Jul 2005)

Viel Dank für deine Mühen. Du hast mir sehr weiter geholfen!!

mfg Claudia


----------

