...
- Enkle java-programmer: Metoden som kalles er ikke en vanlig instansmetode som trenger et objekt, men en metode med signaturen public static void main(String[] args). Denne instansierer det egentlige hovedprogramobjektet og kaller metoder som init() og run() (se eksempel nedenfor).
- Applets (Java-app'er integrert i nettsider): Klassen er en Applet og metodene som kalles er init() (én gang ved lasting av siden), start() (ved oppstart) og stop() (ved avslutning).
- Nettapplikasjoner: Klassen er av typen (arver fra) Servlet og metodene som kalles er init() (én gang ved initialisering), service(...) (kalles for hvert anrop, f.eks. get eller post) og destroy() (én gang ved avslutning). Standard-implementasjonen av service(...) kaller metoder som doGet(...) og doPost(...).
- Eclipse-panel: Klassen er av typen IViewPart og metodene som kalles er init(...) (ved opprettelse), createPartControl(...) (lager panel-innholdet), setFocus() (når panelet er vist frem) og dispose() (når panelet lukkes).
- Android-app'er:
Image Modified
Poenget er ikke at en Java-programmerer må lære seg alle varianter, det vesentlige er å forstå men at en hovedprogramklass som regel forstår at et hovedprogram inngår i et større system som oppretter en instans av klassen hovedprogramklassen og kaller forhåndsdefinerte metoder på bestemte tidspunkt i applikasjonens livssyklus, typisk oppstart, aktivering og avslutning.
| 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 med.| Code Block |
|---|
| public class CalculatorProgram {
private Calculator calculator;
void init() {
calculator = new Calculator();
}
void run() {
|
|
...
...
...
...
while (scanner.hasNextLine( |
|
...
...
...
...
...
if (line == null || line.trim().length() == 0) { |
|
...
| Klassediagram | Objektdiagram | Sekvensdiagram | Objekttilstandsdiagram |
|---|
System.err.println(calc1);
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:
- Koden forutsetter at init() kalles før run() og dette kan sies å være objektets 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 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 |
|---|
| PlantUML Macro |
|---|
object "CalculatorProgram" as calculatorprogram1calculatorprogram0
object "CalculatorProgram" as calculatorprogram2calculatorprogram1
calculatorprogram1calculatorprogram0 -.down-.> calculatorprogram2calculatorprogram1: init()
object "Calculator" as calculator1 {
value = 0.0
}
calculatorprogram1 -right-> calculator1: calculator
object "CalculatorProgram" as calculatorprogram3calculatorprogram2
calculatorprogram2calculatorprogram1 -.down-.> calculatorprogram3calculatorprogram2: 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"
|
| | PlantUML Macro |
|---|
object "Calculator" as calculator1 {
value = 0.0
}
object "Calculator" as calculator2 {
value = 1.0
}
calculator1 -down-> calculator2: setValue(1.0)
object "Calculator" as calculator3 {
value = 3.0
}
calculator2 -down-> calculator3: add(2.0)
object "Calculator" as calculator4 {
value = 9.0
}
calculator3 -down-> calculator4: multiply(3.0) |
