...
| Anchor |
|---|
| mainprogramklasse |
|---|
| mainprogramklasse |
|---|
|
Dersom en lager enkle Java-applikasjoner av den første typen, så har ingen så klare regler som følger dette mønsteret, men det er en god idé fordi det gjør applikasjonen ryddigere og lettere å gjøre om til andre typer senere. Anta f.eks. at en skal lage en enkel kalkulator som skal styres med enkel tekstinput. Kalkulator-logikken håndteres av et
tjenesteorientert objekt som brukes av hovedprogrammet på ulike måter avhengig av hva brukeren gjør. Vi velger å la hovedprogrammet ha to metoder,
init() har ansvaret for initialisering dvs. å opprette kalkulator-objektet, og
run() har ansvaret for hovedløkka som leser inn input fra brukeren og kaller riktig metode på kalkulator-objektet.
Koden til CalculatorProgram er vist under til venstre, med et klassediagram til høyre, hvor også Calculator-klassen er vist.| Code Block |
|---|
| public class CalculatorProgram {
private Calculator calculator;
void init() {
calculator = new Calculator();
}
void run() {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
while (true) {
String line = reader.readLine();
if (line == null || line.trim().length() == 0) {
break;
}
double arg = 0.0, result = 0.0;
char firstChar = line.charAt(0);
if (Character.isDigit(firstChar)) {
arg = Double.valueOf(line);
else {
arg = Double.valueOf(line.substring(1)));
}
if (Character.isDigit(firstChar)) {
result = calculator.setValue(arg);
} else if (firstChar == '+') {
result = calculator.add(arg);
} else if (firstChar == '-') {
result = calculator.subtract(arg);
} else if (firstChar == '*') {
result = calculator.multiply(arg);
} else if (firstChar == '/') {
result = calculator.divide(arg);
}
}
System.out.println(result);
}
public static void main(String[] args) {
CalculatorProgram calculatorProgram = new CalculatorProgram();
calculatorProgram.init();
calculatorProgram.run();
}
} |
|
...
Som utforming av hovedprogramklasse har koden to viktige poeng:
...
| Klassediagram | Objekttilstandsdiagram | Sekvensdiagram |
|---|
|
I tabellen under er klassene vist som et klassediagram, objektstrukturen med disse to objektene vist som et objektdiagram, samspillet vist som et sekvensdiagram og tilstanden til kalkulatorobjektet som et objekttilstandsdiagram .
| PlantUML Macro |
|---|
class "CalculatorProgram" as hovedprogram {
init()
run()
}
class "Calculator" as kalkulator {
-double value
+double getValue()
+void setValue(double)
+double add(double)
+double subtract(double)
+double multiply(double)
+double divide(double)
}
hovedprogram --> kalkulator: calculator |
|
Som utforming av hovedprogramklasse har koden to viktige poeng:
- Koden forutsetter at init() kalles før run(), og dette kan sies å være hovedprogramobjektets livssyklus.
- En trenger strengt tatt ikke en egen init()-metode, men det er ryddig med en tydelig oppdeling i initialisering og utførelse.
I tabellen under er livssyklusen illustrert med et objekt-tilstandsdiagram, hvor vi ser at etter at init()-metoden er kalt, så er CalculatorProgram-objektet initialisert med (en referanse til) et Calculator-objekt. Sekvensdiagrammet viser hvordan CalculatorProgram-objektet samspiller med Calculator-objekt for et tenkt tilfelle, etter først å ha blitt initialisert (av et hypotetisk main-objekt).
| Objekttilstandsdiagram | Sekvensdiagram |
|---|
| PlantUML Macro |
|---|
object "CalculatorProgram" as calculatorprogram0
object "CalculatorProgram" as calculatorprogram1
calculatorprogram0 -down-> calculatorprogram1: init()
object "Calculator" as calculator1 {
value = 0.0
}
calculatorprogram1 -right-> calculator1: calculator
object "CalculatorProgram" as calculatorprogram2
calculatorprogram1 -down-> calculatorprogram2: run()
object "Calculator" as calculator2 {
value = 0.0
}
calculatorprogram2 -right-> calculator2: calculator
|
| | PlantUML Macro |
|---|
control main
actor User
main -> CalculatorProgram : init()
main -> CalculatorProgram : run()
User -> CalculatorProgram : "1.0"
CalculatorProgram -> Calculator: setValue(1.0)
CalculatorProgram -> User: "1.0"
User -> CalculatorProgram: "+2.0"
CalculatorProgram -> Calculator: add(2.0)
CalculatorProgram -> User: "3.0"
User -> CalculatorProgram: "*3.0"
CalculatorProgram -> Calculator: multiply(3.0)
CalculatorProgram -> User: "9.0"
|
|
...
