In allen strukturierten Programmiersprachen werden vergleichbare
Grundstrukturen realisiert, die gebraucht werden, um eine
sog. strukturierte Programmierung zu ermöglichen.
1. Variablen
Um Daten im Arbeitsspeicher des Computers zu speichern, um sie wieder abrufen
zu können, können wir Variablen erzeugen. Diesen Variablen sichert der
Speichermanager des Betriebssystems dann einen bestimmten Speicherraum.
Um auf diesen bestimmten Speicherraum zugreifen zu können, geben wir der
Variablen einen eindeutigen Namen. In gehobenen Programmiersprachen werden
sog. typisierte Variablen verwendet. Wenn ich nämlich bloß einen
logischen (booleanschen) Wert speichern will, brauche ich nur 1 Bit.
Um einen Text zu speichern, brauche ich je Zeichen 16 Bit.
Um also den Speicher ökonomisch zu belegen, teile ich dem Betriebssystem
meinen erwarteten Speicherbedarf mit, indem ich Datentypen
erkläre (deklariere).
int i = 1;
double d = 10.2;
String s = "Hallo Welt";
char c = 'c';
boolean b = true;
2.1 Bedingungen (if)
Um innerhalb eines Programmablaufs Entscheidungen treffen zu können,
die auf unterschiedlichen Variablenwerten beruhen, brauche ich entsprechende
Abfragestrukturen. Die gebräuchlichste Abfrageform (Abfragesyntax) besteht
in einer einfachen oder erweiterten if-Struktur.
2.1.1 einfach
if (Vari==1){
tuwas();
}
2.1.2 einfache Erweiterung
if (Vari==1){
tuwas();
}else{
tuwasanderes();
}
2.1.3 verschachtelte Erweiterung
if (Vari==1){
tu1();
}else if (Vari==2){
tu2();
}else if (Vari==3){
tu3();
}else if (Vari==4){
tu4();
}else if (Vari==5){
tu5();
}else if (Vari==6){
tu6();
}else if (Vari==7){
tu7();
}else{
tuwasanderes();
}
Achtung: Java vergleicht Strings nicht mit dem Vergleichsoperastor '==',
sondern verwendet die Stringmethode equals:
if (s.equals(s1)){
tuwas();
}
2.2 Bedingungen (switch)
Will man, wie im vorigen Beispiel, nur einfache Zahlenwerte oder Charwerte
abfragen, kann man die switch-case-Struktur verwenden.
switch (Vari){
case 1:
tu1();
break;
case 2:
tu2();
break;
case 3:
tu3();
break;
case 4:
tu4();
break;
case 5:
tu5();
break;
default:
tuwasanderes();
break;
}
3. Schleifen
Um bestimmte Aufgaben, deren Struktur identisch ist, immer wieder, in Serie
also, ablaufen lassen zu können, bedienen wir uns einer sog. Schleifenstruktur.
3.1 for-Schleife
for(int i=0;i<10;i++){
if((i%2)==0){
System.out.println(i+" ist gerade");
}else{
System.out.println(i+" ist ungerade");
}
}
3.2 while-Schleife
int i = 0
while(true){
if((i%2)==0){
System.out.println(i+" ist gerade");
}else{
System.out.println(i+" ist ungerade");
}
i++;
if(i>10){
break;
}
}
4. Funktionen
Während Datenvariablen bloß geeignet sind, Werte zu speichern, können
Funktionen Prozessstrukturen speichern. Mehr noch, sie können Werte,
die ihnen übergeben wurden, lesen und verwenden. Darüber hinaus können
sie bei Bedarf Werte an die Aufrufinstanz (Aufrufebene) zurückgeben. In
einigen Sprachen, wie Java, können sie auch Wertlisten (Arrays) zurückgeben.
4.1 Prozedur ohne Wertrückgabe
String s = "Hallo Welt";
void MeineProzedur(String s){
System.out.println(s);
}
4.2 Funktion mit Wertrückgabe
String s = "Hallo Welt";
System.out.println(MeineFunktion(s));
String MeineFunktion(String s){
return s.toUpperCase();
}
5. Klassen
Sog. objektorientierte Sprachen kennen eine weitere, komplexere Form von
Variablen. Diese kombinieren die Eigenschaften von normalen Datenvariablen
und Funktionen und integrieren diese. Diese komplexen Variablen nennen sich
Klassen.
Die Sprache Java ist vollständig klassenorientiert. Das heißt, sie kennt
keine Programmstrukturen, die außerhalb von Klassen ablaufen.
Klassen werden in Java folgendermaßen deklariert:
class meineKlasse{
}
Klassen können die Eigenschaften (Variablen) und Fähigkeiten (Methoden)
vorhandener Klassen erben. In Java wird dafür das Wort extends verwendet.
class meineKlasse extends JFrame{
}
Jetzt enthält meine neue Klasse alle Fähigkeiten der Klasse JFrame,
d. h. sie verfügt über eine graphische Oberfläche, und kann alle möglichen
Swing-Komponenten darstellen.
Darüberhinaus kann ich meiner Klasse die Fähigkeiten einer weiteren Klasse
zur Verfügung stellen, indem ich die über das Wort implements einbaue.
class meineKlasse extends JFrame implements ActionListener{
}
Um eine Klasse aber ablauffähig zu machen, bedarf es nun einer
Einstiegs-, Startprozedur. Diese heißt in allen von C abgeleiteten Sprachen,
so auch in Java, main. Standardmäßig werden main sog. Startparameter
(Werte, die von der Aufrufinstanz, dem Betriebssystem, übergeben werden)
übergeben.
public static void main(String[] args) {
}
In der Startprozedur main ruft sich die Klasse über ihren Konstruktor
selbst auf.
public static void main(String[] args) {
new meineKlasse();
}
Der Konstruktor wird also von der Startprozedur aufgerufen.
class meineKlasse extends JFrame implements ActionListener{
public meineKlasse () {
}
public static void main(String[] args) {
new meineKlasse();
}
}
Dieses Skelett wird nun mit dem 'Fleisch' gespickt, das wir oben beschrieben
haben.
Eigenschaften und Methoden
Diejenigen Variablen, die innerhalb der Klasse öffentlich, global, klassenweit
sichtbar sind, können von außen als Eigenschaften der Klasse aufgerufen werden.
Wenn Funktionen als öffentlich deklariert werden, sind auch sie von außen
aufrufbar, werden dann aber nicht mehr Funktionen genannt, sondern Methoden
der Klasse.
Klasseneigenschaften beschreiben also den Zustand einer Klasse. Methoden sind
das, was eine Klasse kann. Methoden tuen also etwas. Eigenschaften nehmen
Werte auf.
Es ist guter Stil, Eigenschaftswerte mit Hilfe von speziellen
Wertzuweisungs- und -abfragemethoden auszustatten.
class Unterklasse{
private String Text = "";
public Unterklasse(){
}
public void setText(String s){
Text = s;
}
public String getText(){
return Text;
}
}
|
