# DesignProblem - Tipp?



## ersterVersuch (27. Okt 2009)

Hallo,

studier im 3. Semester Informatik, und versuche mich im Rahmen eines Praktikums an einem ersten Software-Projekt, in dem ich alleiniger Entwickler bin. Programmiervorlesungen zu Java habe ich 2 gehört, jedoch vermisse ich gerade jetzt in der Designphase die Theorie zu SoftwareEngineering. Hilft nix, ich hab den Job jetzt.

Ich bitte euch um Lösungstipps zu folgendem Problem:

Ich muss viele Objekte - bezeichnen wir sie als von der Klasse "Anweisung" - die sich sehr ähnlich sind auf eine möglichst einfache und allgemeine Klassenstruktur abbilden.
Als Attribute haben alle Anweisungen einen Namen vom Typ String, außerdem haben alle ein Attribut namens "Parametertyp" jedoch viele mit unterschiedlichen Werten. Viele haben float (in ExponentialSchreibweise), viele Boolean, manche String, noch weniger bestimmte Strings aus einer definierten (und zur Laufzeit erweiterbaren) Menge von Strings.
Meine Frage: Zu jedem Parametertyp-Datentyp eine eigene Klasse, also StringAnweisung, BoolAnweisung, ExpFloatAnweisung, usw... ? Wie das Design gestalten, falls in Zukunft neue Objekte mit Parametertyp-Datentypen benötigt werden, die im Moment und während der Entwicklungszeit noch garnicht bekannt sind - was durchaus sein kann?
Des weiteren sind diese Anweisungen Attribute von Objekten der Klasse Messung. Eine Messung HAT also eine bis mehrere Anweisungen. Nun ist bei 2 konkreten Anweisungen der Parameter-Datentyp auch noch von dem Messungsobjekt abhängig, zu dem sie gerade gehören... also in MessungA ist der Parametertyp ein String aus der ListeA, in MessungB ist der Parametertyp ein String aus B usw...
Wie bekomm ich das abgebildet?
Zerbrech mir da schon ne Weile den Kopf. Wär nett wenn jemand hilft, bzw. nachfrägt, wenn was nicht klar ist, um helfen zu können. Danke für's Lesen!


----------



## Marco13 (27. Okt 2009)

Klingt erstmal schwierig nachzuvollziehen ... Bei solchen sachen wie 
_"...ein Attribut namens "Parametertyp" jedoch viele mit unterschiedlichen *Werten*. Viele haben *float*..."_
klingt es, als wären Begriffe wie "Typ" und "Wert" auf verständniserschwerende Weise vermischt (die fließende Grenze bei einem Class-Objekt mal außen vor gelassen  )

Aber insgesamt klingt es auch, als könnte das teilweise durch Generics gelöst werden:

```
class Attribut<T>
{
    private String name;
    private T parametertyp;
}

Attribut<Integer> a0 = ...
Attribut<String> a1 = ...
```

Die Sache, dass diese Typen manchmal vordefinierte Strings sein können, macht das ganze nicht übersichtlicher. Dort kann man praktisch keine "Typsicherheit" erreichen. Ein String ist ein String ist ein String, und wenn es etwas spezielleres sein soll, muss es etwas spezielleres sein. Eine Option dafür wären vielleicht Enums...

```
class MessungA
{
    public static enum TypMessungA
    {
        BLA,
        BLUBB;
    }

    private Attribut<TypMessungA> attribut;
...
```


----------



## ersterVersuch (28. Okt 2009)

Vielen Dank schonmal für die prompte Antwort! Zunächst mal will ich die Spec mal grob erläutern und diesem Punkt ins Detail gehn - das vom ersten Post versteht ja echt keiner - sorry!

Also, das zu entwickelnde Programm ist ein Text-Generator bzw -Editor dessen Output Messprogramme (in Plain Text) für technische Anlagen sind.
Diese Messprogramme haben 2 Kommentarfelder: in einem sind Versionierungsinfos für dieses File abgelegt, im anderen Infos darüber, für welche Werkstücke dieses Messprogramm gültig ist.
Weiterhin sind Messprogramme eine Komposition von Textblöcken. Ein Block beginnt mit seinem Namen in eckigen Klammern und darunter folgen Zeilen mit je einer Anweisung, alle der gleichen Struktur: NAME=WERT.
(Natürlich gibts da noch einen Haufen Abhängigkeiten Block-zu-Block(s), Anweisung-zu-Block(s), Anw.-zu-Anw. usw., soll im Moment nicht das Thema sein.)
Nachdem ich einige vorhandene Messprogramme analysiert habe, konnte ich die Menge aller momentan vorhandenen Anweisungen ausmachen.

Das Programm soll außerdem den Anweisungspool, sowie den Block-Pool (ein Block ist eine definierte Zusammenstellung von Anweisungen) in einem zentralen ini-File verwalten - dieser Pool ist jederzeit um neue Anweisungen und Blöcke erweiterbar und dient beim Generieren von Messprogrammen dazu, dem User die Auswahl aus den vorhandenen Anweisungen und Blöcken zu ermöglichen, anstatt wie bisher, dass neue Messprogramme händisch per Copy&Paste aus anderen Messpr. zusammen kopiert wurden.

Wegen der gemeinsamen Struktur, Name=Wert dachte ich also daran, eine Klasse Anweisung zu erstellen, u.A. mit den Attributen name, und value. Das Problem ist nun, dass sich die Anweisungen im Datentyp von value unterscheiden: es gibt welche mit Strings, unsigned int, float (in exp-Notation), ... - oftmals ist dieser eingeschränkt (nur def. Strings, nur Werte bis 10, nur Werte >1.0E-9, ...).
Gegen enums zur Mengen-Def von Strings spricht wohl, dass die enum vom User veränderbar sein soll?
Sind jetzt da wirklich Generics geeignet, um den von Anweisung zu Anweisung verschiedenen Datentyp von value zu handhaben? Ich dachte, die werden zur Compilezeit ohnehin durch was konkretes ersetzt.

Ich hoffe es ist jetzt einiges Klarer. Für Tipps bin ich sehr dankbar!


----------



## Marco13 (28. Okt 2009)

Die werden zur Kompilezeit durch etwas SEHR konkretes ersetzt - nämlich durch "Object"  
"Klarer" ist es nicht direkt. Du hast dich eine Weile mit dem Thema beschäftigt, und redest jetzt von Messprogrammen, Blöcken, Aweisungen, Attributen, Pools... Mich interessiert das im Moment nicht die Bohne. Welche Punkte für deine eigentliche Frage relevant sind, weiß ich nicht. Aber... "unsigned" gibt's in Java nicht, und die "wissenschaftliche Schreibweise" von float kann sich ja nur auf die Eingabedaten beziehen. Wo die Menge der zulässigen Werte definiert wird, ist auch nicht klar.   

Pragmatisch: Du hast sowas wie

```
[TEMPERATUR]
celsius=-1.34
sprachlich="scheißkalt"
```
und willst sowas wie

```
Block temperaturBlock = new Block("temperaturFile.txt");
Anweisung anweisung = temperaturBlock.getAnweisung(0);
System.out.println(anweisung.getName()); // Gibt "celsius" aus
System.out.println(anweisung.getValue()); // Gibt "-1.34" aus

anweisung.setValue(2.34);
anweisung.setValue(1000000); // Wirft exception weil zu großer Wert
```

Die Schwierigkeit ist dann eher, in einem Block Anweisungen mit beliebigen Datentypen zu mischen. Es KANN sein, dass man um sowas wie einen "Typ-Identifier" in der Anweisung-Klasse kaum drumrumkommt....


----------



## bygones (28. Okt 2009)

sorry hab den beitrag nicht ganz gelesen, mir ist nur das aufgefallen :


Marco13 hat gesagt.:


> ```
> Block temperaturBlock = new Block("temperaturFile.txt");
> ```


:autsch: der Konstruktor von Block liest dann das File aus ? oder wie... nicht gut


----------



## Marco13 (28. Okt 2009)

_:autsch: der Konstruktor von Block liest dann das File aus ? oder wie... _

Pseudocode... Ich will ja nur den Raum der möglichen Antworten eingrenzen...


----------



## bygones (28. Okt 2009)

aso


----------



## Marco13 (28. Okt 2009)

Selber Aso!  ueh:
:joke:


----------

