Weshalb ist Java heute so wichtig - weil es eine Fourth Generation Language ist und wir immerzu das Allerneueste wollen? Oder weil man damit Gründungsparteitage und atomare Erstschläge abbilden kann? Nein, viel elementarer: wie in der modernen Gesellschaft auch geht es bei Java um Objekt-Orientierung und Vererbung. Widmen wir uns also heute ein wenig der Vererbung.

Dazu legen wir uns ein neues Projekt mit dem Namen "Vererbung" an und erzeugen eine abstrakte Klasse "Ahnen". Abstract deshalb, weil sie nur zur Vererbung dienen und keine eigenn Instanzen haben soll (was interessieren uns die Urgroßeltern?!). Wir statten die Klasse mit dem Attribut "Vermögen" aus:

private double vermögen; // private signalisiert: die Öffentlichkeit hat keinen Zugriff!

sowie einer Methode: getErbschaft()

die benötigt wird, um eine Erbschaft antreten zu können. So weit so gut. Nun leiten wir von "Ahnen" eine Klasse "Großvater" ab (der Einfachheit halber beschränke ich mich auf die männliche Linie):

public class Grossvater extends Ahnen

Und siehe da: von Geburt an ist der Großvater mit Vermögen und der Fähigkeit zu erben ausgestattet. Das Vermögen soll aber auch wachsen, und deshalb fügen wir der Klasse eine weitere Methode hinzu:

public double mehreGeld()
{
vermögen = vermögen * zinssatz;
}

Zu Großvaters Zeiten war dieses eher konservative Modell recht populär und wir wollen es erst einmal dabei belassen. Auf Großvater folgt Vater, auf Vater Sohn:

public class Vater extends Grossvater
public class Sohn extends Vater

Geht das nun immer so weiter, wird all das schöne Geld nur vererbt und vererbt und vererbt? Keineswegs! Wir verfeinern die Definition von "Sohn" ein kleines bißchen:

public final class Sohn extends Vater

final bedeutet nämlich, daß hier die Vererbung endet, das Vermögen steht zur Verfügung, was ich hab, geb ich nicht wieder her; ein Leben in Saus, vielleicht sogar in Braus winkt.

Mit dieser - wie ich hoffe - eindrucksvollen Demonstration der Lebensnähe von Java endet der erste Teil meiner kleinen Einführung in die objekt-orientierte Programmierung mit Java. Ein zweiter Teil ist bereits in Vorbereitung und trägt den Arbeitstitel "Java bis der Arzt kommt".

Heute basteln wir uns einen Erstschlag. Das ist einfacher, als gemeinhin angenommen wird; entscheidend ist eine effiziente Programmierung. Wir legen uns ein neues Projekt mit dem Namen Kampagne an, darin die Hauptklasse Kampagne, die die main-Methode enthält. Diese benutzen wir dazu, den statischen Kontext zu verlassen, damit unserem dynamischem Vorhaben nicht aus falschverstandener Zimperlichkeit Hindernisse in den Weg gelegt werden.

public static void main (String [] args)
{
new Kampagne.losschlagen();
}
// Dies nennt man im Fachjargon eine anonyme Instanz erzeugen

In der Methode losschlagen werden die Details der Kampagne festgelegt, deren Durchführung im Einzelnen natürlich den persönlichen Vorlieben überlassen bleibt. Neben einer neuen Instanz der Basis-Klasse "Al Quaida" kann auch ein weiteres Obkjekt des Typs "Geheimdienstaufklärung" zum Einsatz kommen, und vieles Andere mehr.

Kommen wir nun zum Kern der Sache. Wir leiten von der Klasse Bomberbesatzung eine Klasse B2Crew ab und instanziieren sie. Diese enthält alle erforderlichen Handler, um ein Objekt vom Typ B2 zu steuern. Wir erinnern uns, daß für die Super-Klasse Bomber (von der B2 erbt), diverse Interfaces zur Verfügung stehen und implementieren lenkbareAtomwaffe.

public class B2 extends Bomber implements lenkbareAtomwaffe

Nun müssen wir nur noch den Trigger (in Kampagne) auslösen:

onFlightEvent (Teheran t) {
try {
lenkbareAtomwaffe.einsetzen();
} catch (öffentlicheEmpörungException ö) {
B2.abdrehen();
Kampagne neuerAnlauf = new Kampagne();
}
}

Damit sind wir auch im Störungsfall auf der sicheren Seite. Wenn der Erstschlag im ersten Anlauf nicht gelingt, dann vielleicht im zweiten. Es wird trotzdem ein Erstschlag sein.

Wenn man sieht, wie mit ein wenig wohldurchdachter Programmierung viel erreicht werden kann, wird der Zauber von Java und der Objekt-Orientierung spürbar.

Heute gründen wir eine neue Volkspartei . Das ist saueinfach und gibt uns außerdem die Möglichkeit, alles, aber auch wirklich alles, als "mein" zu deklarieren. Klingt gut, oder? Ja, dann wollen wir mal loslegen.

Wichtig ist nicht so sehr das Programm - dafür gab es eine Programmkommission, die wir hier nicht näher betrachten wollen - als vielmehr eine hohe Mitgliederzahl ("Volkspartei"!), um schnell Einfluß zu gewinnen und an die Fleischtöpfe zu gelangen. Das ist aber vorläufig noch Zukunftsmusik, und deshalb konzentrieren wir uns auf die Gründungsveranstaltung. Wir haben eine Halle mit 5000 Sitzplätzen gemietet; mit seiner Eintrittskarte erhält jeder Besucher auch sein Parteibuch. Es sollen aber nur vertrauenswürdige Parteigänger hereingelassen werden - Hinz und Kunz, mit denen kennen wir uns aus - , andere müssen leider draußen bleiben, wie etwa Krethi und Plethi, deren Schreibweise uns schon mißfällt, kurzum, wir brauchen eine Einlaßkontrolle. Wer schon mal mit einem Programmierer gesprochen hat, der weiß, daß es Events gibt, hat vielleicht auch von Exceptions gehört, eventuell sogar von Listener>n. Klingt, als könnten wir etwas davon brauchen.

public class Volkspartei extends Partei implements OpinionListener
// Volkspartei erbt alle Eigenschaften und Methoden
// der Klasse Partei und bekommt einen Listener
{

public Volkspartei(meineLeute) // sogenannter Konstruktor
{
int meineMitgliederZahl = 0; // wichtig, nur integre Mitglieder zu haben
boolean meinProgramm = true; // ein wahres Programm, behaupten wir jedenfalls
this.meineParteiGenossen = meineLeute;
// nur damit es keine Verwechslungen gibt
}

Das genügt für den Anfang. Bei der Gründung von Ortsgruppen wird man mehr ins Detail gehen. Nun zur Gründung:

boolean meineTuerIst Offen = true;
String meinKandidat;
meinKandidat.addOpinionListener; // jedem Kandidaten wird ein "Meinungsforscher" assoziiert
Volkspartei meinePartei = new Volkspartei(HinzUndKunz); // die Gründung beginnt
meinKandidat.drawOpinion(); // wollen mal sehen, was da für Leute kommen

public void drawOpinion()
{
while (meineTuerIst Offen) // die Tür wird erst beim 5000ten Mitglied geschlossen
{
try // Einlaßkontrolle durch Saalordner
{
if (meineParteiGenossen.indexOf(meinKandidat) != -1 );
// wenn der Kandidat ein HinzUndKunz ist
meineMitgliederZahl++;
else programmVerkaufen(meinKandidat); // sonst mit AgitProp-Material beeinflussen
} catch (divergentOpinionException d)) { // kritische Kandidaten abfangen
einlassVerweigern(meinKandidat);
}
if (meineMitgliederZahl == 5000)
{ meineTuerIst Offen = false; } // der Sall ist voll, Tür zu
}
}

public void programmVerkaufen(unsichererKantonist)
{
// hier nach Vorhandensein politisches Material für teures Geld
// verkaufen, als Lockmittel Werbegeschenke o.ä. verteilen
// z.B. unsichererKantonist.getMoney();
}

public void einlassVerweigern(unterMensch)
{
// hier können nach Belieben Maßnahmen gegen unerwünschte
// Kandidaten festgelegt werden, je nach Gemüt und Stimmung
// z.B unterMensch.set Executable(true) oder ähnliches
}
}

}

Und das war's schon, fertig ist die Parteigründung. Jetzt kann die politische Karriere beginnen. Ist es nicht ganz wunderbar, wie einfach Java-Programmierung komplexe gesellschaftliche Vorgänge macht?