Sett utenifra kan en se på hovedprogramklasser som tjenesteorienterte, siden de ofte inneholder spesifikke metoder som kalles på bestemte tidspunkt, f.eks. ved oppstart og avslutning av applikasjonen og ved andre vesentlige hendelser. Akkurat hvilke metoder dette er, er avhengig av typen applikasjon og systemet som applikasjonen er bygget for. 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:

Poenget er ikke at en Java-programmerer må lære seg alle varianter, men at en forstår at et hovedprogram inngår i et større system som oppretter en instans av hovedprogramklassen og kaller forhåndsdefinerte metoder på bestemte tidspunkt i applikasjonens livssyklus, typisk oppstart, aktivering og avslutning.

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.

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 "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

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"