Page History

...

Sett utenifra kan en se på hovedprogramklasser som tjenesteorienterte, siden de ofte inneholder spesifikke metoder som aktivere kalles på bestemte tidspunkt, f.eks. ved oppstart og avslutning av applikasjonen og ved evt. andre vesentlige hendelser. Akkurat hvilke metoder dette er, er avhengig av typen applikasjon og rammeverket systemet som systemet applikasjonen er bygget med/ifor. Eksempler kan være:

• 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 Added

...

Poenget er ikke at en Java-programmerer må lære seg alle varianter, det vesentlige er å forstå men at en hovedprogramklassen som regel forstår at et hovedprogram inngår i et større system som styrer opprettelsen oppretter en instans av hovedprogramklassen og kaller forhåndsdefinerte metoder på bestemte tidspunkt i applikasjonens livssyklus, typisk oppstart, aktivering og avslutning. Et eksempel på en slik livssyklus er Android-aktiviteter (nummer tre i lista over):Image Removed

public class CalculatorProgram {

	private Calculator calculator;

	void init() {
		calculator = new Calculator();
	}

	void run() {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            String line = scanner.nextLine();
            if (line == null || line.trim().length() == 0) {
                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();
	}
}

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).

object "HovedprogramCalculatorProgram" as calculatorprogram0
object "CalculatorProgram" as calculatorprogram1
calculatorprogram0 .down.> calculatorprogram1: init()
object "Calculator" as hovedprogramcalculator1 {
   value = 0.0
}
calculatorprogram1 -right-> calculator1: calculator
object "KalkulatorCalculatorProgram" as calculatorprogram2
calculatorprogram1 .down.> calculatorprogram2: run()

object "Calculator" as kalkulatorcalculator2 {
   value = 0.0
}
calculatorprogram2 -right-> calculator2: calculator

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(13.0)
CalculatorProgram -> User: "


9.0"