Unterschiede von Java zu C++

Java ist eine Programmiersprache mit einem durchgängigen objektorientierten Konzept, im
Gegensatz zu C++, das eher ein gewachsenes Konzept verwendet.

Java bietet

- Objektorientierung
- Exception Handling
- Multithreading
- Polymorphie
- Containerklassen - dynamische Speicherverwaltung, kein delete, dafür Garbage - Collection
- frühe Bindung der Variablen
- späte Bindung der Funktionen
Statt der Mehrfachvererbung von Klassen
gibt es die Mehrfachvererbung von Interfaces

Bis auf die vollautomatische Garbage - Collection gibt es das alles auch in C++.
Andererseits enthält C++ einige Konzepte, die sehr leicht zu Fehlern führen, oder
die aus dem prozeduralen C historisch gewachsen sind.
Diese sind in Java nicht enthalten. Dazu gehören:

- Templates,
- Mehrfachvererbung
- Funktionen außerhalb von Klassen
- Strukturen, Unions
- explizite Zeiger, damit auch Dereferenzierungsoperator, Adressoperator, Pfeiloperator...
- Typedefs
- Überladung von Operatoren

Unterschiedliche Schreibweisen sind selten, kommen aber vor:
- so heißt in Java der Destruktor finalize( )
- das Schlüsselwort zur Klassen - Vererbung ist "extends",
- bei der Interface - (bzw. Schnittstellen - ) Vererbung heißt es "implements".
- Arrays: Java      char[10] Name;
              C++       char Name[10];

Der Standardzeiger auf die Basisklasse heißt in Java "super", er entspricht für die Basisklasse etwa "this".
Bemerkenswert ist außerdem, dass es sich bei der Deklaration von Variablen vom Typ einer Klasse
bei Java implizit grundsätzlich um Zeiger handelt und nicht um Objekte! Das führt dazu, dass es in Java
praktisch keine benamten Objekte gibt, sondern nur Zeiger auf Objekte!
Deswegen ist es auch erforderlich, um mit einem Objekt arbeiten zu können, ein neues namenloses
Objekt mit new zu generieren.

Bsp.:

Klasse zeiger;
zeiger = new Klasse;
Mit     zeiger . Methode     kann man nun recht zwanglos auf die Methoden der Klasse zugreifen,
auf deren namenloses Objekt    zeiger    zeigt.

Wie hier schon anklingt, ist es kein Problem, mit Java verkettete Listen zu erstellen,
das geht auch sehr komfortabel mit der entsprechenden Containerklasse, LinkedList.

Beispielprogramm 'Musencus'

Als Beispielprogramm möchte ich nun ein kleines Programm entwickeln, das Gedichte ausgibt, die
"zufällig" entstehen. Meine Vorüberlegung war, dass eine einfache sprachliche Syntax, bsp.
"Peter ist Schrankenwaerter" aus 3 Komponenten besteht, nämlich SUBJEKT, PRAEDIKAT, OBJEKT.
Ich könnte nun also hingehen und direkt 3 Arrays aus Strings deklarieren:

String sub[]={"Peter"};
String prae[]={"ist"};
String obj[]={"Schrankenwaerter"};

um bereits einen Einstieg zu haben. Wenn ich will, kann ich differenzieren, ob das Subjekt ein
Name, oder ein Substantiv sein soll. Bei der gegebenen Satzstruktur bleibt das Prädikat erstmal
3. Person Singular - auch hier gibt es Erweiterungsmöglichkeiten. Das Objekt, hier im Nominativ
könnte auch ein Akkusativ- oder Dativobjekt sein. Man sieht, wie hier die Analyse sprachlicher
Strukturen direkt zur Synthese von Algorithmen und damit zur Implementierung meines Gedichtprogramms
führen wird.
Ich brauche als nächstes einen Rahmen, um mein Programm lauffähig zu machen:

class gedicht
{
        public static void main(String args[ ])
        {
        String sub[]={"Peter"};
        String prae[]={"ist"};
        String obj[]={"Schrankenwaerter"};

            Hier passierts!
        }
}

Um was passieren zu lassen, schlage ich Folgendes vor:

System.out.print(sub[0]+" "+prae[0]+" "+obj[0]);

Dieser Eintrag führt zu der Ausgabe "Peter ist Schrankenwaerter".
Ganz klar! - uns fehlt hier noch das Moment der Aleatorik!
Ein Zufallsgenerator muss her!
Wir haben einen, der noch dazu viel pflegeleichter als in C direkt in der Standardklasse
Random untergebracht ist. Wir instanzieren also von Random:

Random erzaehler=new Random( );

Um die Klasse Random verwenden zu dürfen, müssen wir java.util einbinden.
Also setzen wir über unseren bisherigen Quellcode:

import java.util.*;

Unser Objekt vom Typ "Zufall", der erzaehler, hat eine Methode namens nextInt( ), die wir
gleich brauchen werden. nextInt gibt die jeweils neu ermittelte zufällige Zahl aus.
Zunächst ergänze ich mal meine Variablen:

String sub[]={" Peter ", " ein entrüsteter Passant "};
String prae[]={" ist ", " war frueher mal "};
String obj[]={" Schrankenwaerter ", " Philanthrop "};

Ich ergänze vor und nach jedem Inhaltsstring ein Leerzeichen, um mich nachher in der Ausgabeformatierung
nicht mehr um Leerzeichen kümmern zu müssen.
Außerdem brauche ich dringend noch 3 Integers:

int a, b, c;

je einen für den Index meiner Stringvariablen, denn über den Index soll nun das Zufallsprinzip
zuschlagen. Die Methode nextInt erhält einen Parameter, der angibt, von 0 bis wieviel die neue
Zufallszahl gehen darf(ausschließlich). Das bedeutet, wenn ich jetzt in meinem Fall -
meine Arrays habe ja erst 2 Elemente! - eine sinnvolle Obergrenze angeben will, so lautet diese
2, im Klartext sind das die Zahlen 0 und 1(2 wird ja ausgeschlossen) - genau mein Array - Index!
Ich füge also ein:

a = erzaehler.nextInt(2);
b = erzaehler.nextInt(2);
c = erzaehler.nextInt(2);

Dann ersetze ich die Nullen bei meiner System.out... - Anweisung durch a, b und c und
erhalte meine erste Zufallszeile.
Als nächstes verfeinert man das Programm durch eine For - Schleife, die mir idealerweise
genau die Versblöcke für ein Gedicht auswerfen sollte usw.
Ich brauche wohl kaum zu erwähnen, dass das Programm sehr ausbaufähig ist!
Die einfachste Erweiterung ist der Aufbau des Vokabulars. Wenn ich z.B. zu sub[ ] hinzufüge
" Yilmaz " , zu prae[ ] " wäre gerne " und zu obj[ ] " ein Skinhead ", so darf ich andererseits
nicht vergessen, bei nextInt die Anzahl um 1 zu erhöhen!

Beispiel für ein Gedichtprogramm