Kapitel 1

Einführung in die Programmierung - 1 -
Einführung in die Programmierung
WS 2002/2003
Werner Pohlmann
Technisches:
Termin:
Proseminar:
Vorlesung – Klausur:
Skriptum:
Di 10 15 – 12 45 , 15 min Pause
Einschreibung auf Aushang
Beginn: Mi alle Teilnehmer 14 15 T01
am Semesterende
Kopien der Folien im Sekretariat zum Ausleihen
Programmierbeispiel online unter:
http://student.cosy.sbg.ac.at/project/tutorien/prog-einf/
§ 1 Einführung
1.1 Zweck der Vorlesung
Grundelemente der
Imperativen Programmierung
zB.: Datentypen, Programmvariable, Zuweisungen,
Kontrollstrukturen,...
Objektorientierten Programmierung
zB.: Klassen, Objekte,...
Mit Java als Arbeitssprache
Beispiel 1:
Aufgabe: Stelle fest, wie oft der Buchstabe „e“ oder „E“ in einem Text vorkommt.
Lösungsansatz:
setze Zähler auf 0;
solange Text nicht erschöpft:
lies nächstes Zeichen an, Text;
falls (Zeichen = ’e’ oder Zeichen = ’E’)
erhöhe Zähler um 1;
gib aus Zähler;

Einführung in die Programmierung - 2 -
So etwas ist ein Algorithmus (= vollständige und eindeutige Festlegung einer Folge
elementarer Operationen),
Typische Beispiele für Algorithmen im Alltag (?) sind „schriftliche“ Rechnungsarten,
wie zB.: 47 . 12
47
94
564
Objektorientiertes Vorgehen dient der Gliederung von Software in Teile mit je
spezifischen Aufgaben/Verantwortlichkeiten
ähnliche wichtige technische Gebilde:
Auto besteht aus,...
Objekt
Gebilde mit Eigenschaften (Zustand, Arten,...)
Mit „Methoden“ (= Operationen, Handlungsmöglichkeiten)
Klasse Schema für gleichartige Objekte
(oder aus: Sammlung von Methoden)
Beispiel:
Tabellenkalkulation
Tabelle besteht aus Zellen
Hat Methoden wie „belegen“, „auswerten“
Eigenschaften wie Inhalt (ausgewählt ja/nein)
Inhalt ist
Zeichenreihe
Zahl
Formel
Hat Methoden wie „auswerten“
Hat Eigenschaften wie „Bezug auf andere Zelle“
1.2 Literatur (siehe Angaben in VL)
1.3 Mein erstes Programm
Die folgende Seite (8) zeigt Programmtext plus Protokoll einer Sitzung mit
Kompilieren: javac Kreis.java
Ausführen: java Kreis
, mit Variation der Eingabe
! Programm braucht zur Eingabe die Klassen SavitchIn (aus dem Buch von W.
Savitch); wir nehmen hier an, dass diese Klasse im aktuellen
Arbeitsverzeichnis kompiliert vorliegt.

Einführung in die Programmierung - 3 -
Für die Ausgabe benutzt das Programm das Objekt System.out, das über die Klasse
System der Standardumgebung ( wir müssen uns nicht darum kümmern) zur
Verfügung steht.
/***************************************************
*Programm berechnet Umfang & Flaeche eines Kreises
*dessen Radius der Benutzer (auf Aufforderung) gibt.
*beachte:
*Zahl und "return" erwartet!
*SavitchIn.class im selben Verzeichnis!
***************************************************/
public class Kreis{
public static void main(String[] args){
double radius, umfang, flaeche;
final double PI = 3.14159;
System.out.println();
System.out.println("Gib Radius!");
radius = SavitchIn.readLineDouble();
umfang = 2*PI*radius;
flaeche = PI*radius*radius;
}
}
System.out.println("Umfang = " + umfang);
System.out.println("Flaeche = " + flaeche);
System.out.println();
/*-----------------------------------------------
12 pohlmann@drache:javac Kreis.java
13 pohlmann@drache:java Kreis
Gib Radius!
3
Umfang = 18.849539999999998
Flaeche = 28.274309999999996
14 pohlmann@drache:java Kreis
Gib Radius!
3.0
Umfang = 18.849539999999998
Flaeche = 28.274309999999996
15 pohlmann@drache:java Kreis
Gib Radius!
drei
Your input number is not correct.
Your input number must be
an ordinary number either with
or without a decimal point,
such as 42 or 9.99
Please, try again.
Enter the number:
3
Umfang = 18.849539999999998

Einführung in die Programmierung - 4 -
Flaeche = 28.274309999999996
---------------------------------------------------*/
Programmtext des Beispiels enthält:
Buchstaben, Ziffern, Satzzeichen, math. Symbole, Zwischensumme
(Leerzeichen, blanks), ...
Daraus gebildet:
Kommentare
= Text, der vom Rechner ignoriert wird, der für menschliche Leser bestimmt
ist.
/* ............. */
Anfang Ende
oder
// .......................
Anfang Ende = Zeichenende!
Bezeichner (identifier) wie public, class, Kreis, radius, ...
dabei gibt es:
o Reservierte Wörter mit vorgegebener Bedeutung zB.: public, class,
double,...
o Durch Kontext erklärte Wörter zB.: System.out, Println, SavitchIn.
ReadlineDouble
o Vom Programmierer frei gewählte und mit Bedeutung verknüpfte
(deklarierte, vereinbarte) Namen
zB.: Kreis: Name des „Programms“ (Klasse)
radius: Name einer Programmvariablen für Werte vom Typ
„double“
PI: Name für eine Konstante vom Typ double mit dem Wert 3.14..
o Zusammengesetzte Bezeichnung (dot )
zB.: System.out.println (....)
= Auswahl von Diensten einer Klasse oder eines Objekts;
Literale (Notationen für bestimmte feste Wert)
zB.: 3.14159 - Zahl
“Umfang =“ - Zeichenreihe
Ausdrücke (Kompositen)
zB.:
2*PI*radius
“Umfang =“ + umfang
- arithmetischer Ausdruck („Formel“)
* ... bedeutet „mal“
- Zeichenreihen
Ausdruck + bedeutet hier: aneinanderfügen
SavitchIn.readLineDouble() - Aufruf einer Methode, die einen Wert vom Typ
double zurückgibt.
Operationszeichen in Ausdrücken haben feste vorgegebene aber womöglich
vom Kontext abhängige Bedeutung, zB.: „+“ überladen

Einführung in die Programmierung - 5 -
Anweisungen („statements“, Befehle)
zB.:
Umfang = 2*PI*radius; - Wertzuweisung
println (....);
- Ausgabeanweisung
Vereinbarungen (declarations)
zB.:
double radius, umfang, flaeche;
- radius, umfang, flaeche werden als Programmvariable für reelle Zahlen
(double) eingeführt.
Syntaktische Struktur im Großen
wie
public class ... {...} - Klassendefinition
public static void main (String[ ]args) {...} - Definition der main-Methode
…..;
…..; Aneinanderreihung von Deklarationen und Anweisungen
…..;
! Syntax = Regelwerk (Grammatik) für formale Zulässigkeit sprachlicher
Gebilde
zB.: öffnende Klammer “(“
erfordert
schließende Klammer “)“
Semantik = Bedeutung, Wirkung bei Ausführung durch den Rechner
Semantik ist abgestützt auf Syntax und Vereinbarungen
! einstweilen (aber nur einstweilen) schreiben wir einfache Programme der Form
public class ... {
}
public static void main (String [ ] args) {
.
.
.
}
Diesen Rahmen erklären wir später und gehen über zu komplexen und sinnvollen
Strukturen!
1.4 Fehlerhafte Programme
sind an der Tagesordnung!
Unterscheide:
a) Verstoß gegen Regeln der Sprache, technische Schranken,
usw.
b) Falscher Lösungsweg für Problem („Denkfehler“)
Unterscheide weiter:
Wann wird Fehler des Typs a) manifest?

Einführung in die Programmierung - 6 -
a1) zur Laufzeit (runtime): zB.: benötigte Datei fehlt,
Speicherkapazität erschöpft
a2) zur Übersetzungszeit (compile time); zB.: fehlende Klammer,
Variable nicht deklariert, ...
Fehlermeldungen des Compilers sind oft nicht genau zutreffend, schwer verständlich
oder auch unvollständig;
Also: es hat schon einen Grund ... genau hinschauen!
/***************************************************
*Programm berechnet Umfang & Flaeche eines Kreises
*dessen Radius der Benutzer (auf Aufforderung) gibt.
*beachte:
*Zahl und "return" erwartet!
*SavitchIn.class im selben Verzeichnis!
***************************************************/
public class KreisCompileTimeError{
public static void main(String[] args){
double radius, umfang, flaeche
final double PI = 3.14159;
System.out.println();
System.out.println("Gib Radius!");
radius = "drei";
umfang = 2.PI*radius;
Flaeche = PI*radius*radius;
}
}
System.out.println("Umfang = + umfang);
System.out.println("Flaeche = " + flaeche);
System.out.println();
/*-------------------------------------------------------------------
18 pohlmann@drache: javac KreisCompileError.java
KreisCompileTimeError.java:13: ; expected.
Double radius, umfang, flaeche
^
KreisCompileTimeError.java:20: Invalid character in number.
Umfang = 2.PI*radius;
^
KreisCompileTimeError.java:23: String not terminated at end of line.
System.out.println(“Umfang = + umfang);
^
KreisCompileTimeError.java:30: Unbalanced parentheses.
^
KreisCompileTimeError.java:30: } expected.
^
5 errors
--------------------------------------------------------------------*/

Einführung in die Programmierung - 7 -
! akzeptiert der Compiler das Programm, so muss man es
testen (systematisch ausprobieren)
debuggen (Fehler finden und beheben)
Mehr dazu später!
1.5 Jetzt alles genauer:
Bezeichner
o Bestehen aus Buchstaben, Ziffern, Unterstrich
o Dürfen nicht mit Ziffer anfangen
o ! Groß- und Kleinbuchstaben sind verschiedenen Buchstaben!
Konvention: Bezeichner für
o Klasse: beginnen mit Großbuchstaben,
o Variablen, Methoden, Objekte: Beginnen mit Kleinbuchstaben
o Konstanten: enthalten nur Großbuchstaben
! Lesbarkeit von Programmen
Suggestive Bezeichner zB.: natürliche Sprache, übliche Namen und
Abkürzungen
! Komposita mit inneren Großbuchstaben: KreisFlaeche, ersteAbleitung, ...
Layout ist in Java frei, aber für menschliche Leser ist etwas Mühe angesagt:
o Einrückungen verdeutlichen Struktur (Schachtelung):
public class ... {
public static void main ....{
}
}
Leerzeichen/Kommentarzeilen können Folgen von Anweisungen sinnvoll
gliedern.
/***************************************************
*Programm berechnet Umfang & Flaeche eines Kreises
*dessen Radius der Benutzer (auf Aufforderung) gibt.
*beachte:
*Zahl und "return" erwartet!
*SavitchIn.class im selben Verzeichnis!
***************************************************/
public class KreisUnlesbar{public static void main(String[]
args){double rmpflstxx, rnpflstxx;final double x4711 = 3.14159;
System.out.println();System.out.println("Gib Radius!");rmpflstxx
=SavitchIn.readLineDouble();double Rmpflstxx=2*x4711*rmpflstxx;rnpflstxx
=x4711*rmpflstxx*rmpflstxx;
System.
out.println("Umfang = "+Rmpflstxx);
out.println("Flaeche = "
+rnpflstxx);
System.out
.println();}
}
System.

Einführung in die Programmierung - 8 -
/*-------------------------------------------------------------------
55 pohlmann@drache:javac KreisUnlesbar.java
56 pohlmann@drache:java KreisUnlesbar
Gib Radius!
3
Umfang = 18.849539999999998
Flaeche = 28.274309999999996
--------------------------------------------------------------------*/
Programmvariable
o Werden im Programm zur Speicherung von Daten benutzt
(Zwischenergebnisse, Eingabewerte u. ä. )
also: änderbarer Wert mit festem Bezeichner, (Zeichnung
Behältermodell fehlt)
o Werden zusammen mit Typ vor dem ersten Gebrauch vereinbart
Behälter spezifisch für Inhalt (Zeichnung spezifische Behälter fehlt)
o Typfestlegung wesentlich für
Maschine: erforderlicher Speicherplatz, Codierung
Programmierer: Einschränkung des sinnvollen Gebrauchs -
nicht Äpfel und Birnen addieren;
Compiler kann Fehler finden
Zuweisung
setzt Wert einer Variablen (früherer Wert futsch!) ✮
allgemeine Form:
Variable = Ausdruck
zB.: umfang = 2*PI*radius;
Wirkung:
1. rechte Seite auswerten
2. Ergebnis wird neuer Wert der Variablen auf der linken Seite
zB.: x = 3.0;
x = x+x; // x hat jetzt Wert 6.0, Ausrechnung der rechten Seite
// benutzt alten Wert
o Zuweisungssymbol „=“ (sprich: ergibt sich zu)
nicht verwechseln mit Gleichheit:
Java
Mathematik
x=x+1 x wird um 1 erhöht Gleichung, die
keine Lösung hat
Rechte und linke Seite müssen in ihrem Typ zueinander passen; (oft gleicher
Typ; aber auch einige weitergehende Verträglichkeitsregeln, s. u.)

Einführung in die Programmierung - 9 -
Variablen müssen vor dem ersten (lesenden) Gebrauch durch eine
Wertzuweisung initialisiert werden!
zB.: double eins; eins = 1.0;
oder: double eins = 1.0;
! bei fehlender Initialisierung kann Compiler
o Default-Wert einsetzten, oder
o Fehler melden
✮Verhalten von Java-Implementierungen ist nicht einheitlich und verlässlich!
/***************************************************
*Programm vertauscht die Belegung von zwei int Variablen,
*die vorher der Benutzer (auf Aufforderungen) eingibt.
*Zum Vertauschen wird eine Hilfsvariable benutzt.
*beachte:
*jeweils ganze Zahl und "return" erwartet!
*SavitchIn.class im selben Verzeichnis!
***************************************************/
public class Vertausche{
public static void main(String[] args){
int ersteZahl, zweiteZahl, hilf;
System.out.println();
System.out.println("Gib ersteZahl!");
ersteZahl = SavitchIn.readLineInt();
System.out.println("Gib zweiteZahl!");
zweiteZahl = SavitchIn.readLineInt();
hilf = ersteZahl;
ersteZahl = zweiteZahl;
zweiteZahl = hilf;
}
}
System.out.println("ersteZahl = " + ersteZahl);
System.out.println("zweiteZahl = " + zweiteZahl);
System.out.println();
/*-------------------------------------------------------------------
65 pohlmann@drache:javac Vertausche.java
66 pohlmann@drache:java Vertausche
Gib ersteZahl!
1
Gib zweiteZahl!
2
ersteZahl = 2
zweiteZahl = 1
--------------------------------------------------------------------*/