Programmierkurs Kapitel 3 3.1 Was sind Anweisungen? Arten von

Kapitel 3
Programmierkurs
Anweisungen, Variablen
Arten von Anweisungen
Variablen
Konstanten
Höchste Zeit für ein Programm
Gültigkeitsbereich von Variablen
Birgit Engels, Anna Schulze
ZAIK
Universität zu Köln
WS 07/08
1 / 39
3.1 Was sind Anweisungen?
2
Arten von Anweisungen
Wir haben verschiedene (semantische) Bestandteile von
Programmen genauer kennengelernt:
Anweisungen kommen vor allem innerhalb von Methoden vor und
sind unterteilt in:
Einfache Klassendefinition:
class <Klassenname>
Deklaration
Methodendefinition am Beispiel:
public static void main(String agrs[])
Zuweisung
Kontrollstruktur (Auswahl, Wiederholung)
(Rest) Anweisungen, z.B.:
System.out.println(); import java.io.*;
Aufruf
Der Grossteil des Programmtextes besteht aus verschiedenen Arten
von Anweisungen oder Befehlen (Java ist eine
imperative=befehlsorientierte Programmiersprache).
Import-Anweisung (Später)
Exceptions/Ausnahmen (Später)
Erinnerung: Anweisungen werden immer mit Semikolon ;
abgeschlossen.
3 / 39
4
Arten von Anweisungen
Arten von Anweisungen
Deklaration:
“Bekanntmachung” einer Variablen (und ihre Typs).
Deklaration:
“Bekanntmachung” einer Variablen (und ihres Typs).
Zuweisung:
Wertänderung einer Variablen, oft aufgrund der Auswertung
arithmetischer Ausdrücke.
Zuweisung:
Wertänderung einer Variablen, oft aufgrund der Auswertung
arithmetischer Ausdrücke.
Kontrollstruktur (Auswahl, Wiederholung):
Veränderungen von Variablen, abhängig vom Wert anderer
Variablen.
Kontrollstruktur (Auswahl, Wiederholung):
Veränderungen von Variablen, abhängig vom Wert anderer
Variablen.
Aufruf:
Benutzen vordefinierter oder eigener Methoden, mit variablen
Parametern.
Aufruf:
Benutzen vordefinierter oder eingener Methoden, mit
variablen Parametern.
Anweisungen enthalten Variablen, verändern Variablen, benötigen
Variablen: Beschäftigen uns mit Variablen.
5 / 39
3.2 Variablen
6
Erinnerung: Namensgebung
Namen
Variablen
Zeichenkette (Buchstaben, Ziffern, Unterstrich “ ”)
haben Namen (zeigt auf reservierten Hauptspeicherbereich).
Dürfen nicht mit Ziffer anfangen
haben Datentyp (legt bestimmte Parameter fest, s.u.).
Unterscheidet zwischen Groß- und Kleinschreibung
müssen deklariert werden (Angabe von Typ und Name).
Tipp: Aussagekräftige Namen benutzen
Tipp: Variablennamen einheitlich
belegen Speicher ( Platz durch Datentyp festgelegt, Zugriff
über Namen).
I
haben Wertebereich (durch Datentyp festgelegt).
I
haben Wert.
haben Geltungsbereich (Später).
I
7 / 39
Groß- und Kleinschreibung für alle Variablennamen einheitlich
verwenden
Benutzte Fremdsprache (Deutsch, Englisch) durchgehend
verwenden
Immer bedenken, dass das Programm auch noch nach einiger
Zeit bzw. für andere Programmierer lesbar sein soll
8
Deklaration
Initialisierung
int ganzeZahl;
Der Variablenname ganzeZahl zeigt auf einen Bereich des
Hauptspeichers.
int : Datentyp.
Dieser Bereich enthält noch “zufällige” Daten
(→ Übung), die “irgendwann” dort abgelegt wurden.
ganzeZahl : Variablenname.
; : Deklaration ist spezielle Anweisung, daher Abschluss mit
Semikolon.
Die Variable ganzeZahl muss mit einem sinnvollen Wert, hier z.B.
“0” initialisiert werden:
Nach der Deklaration ist (im Geltungsbereich) bekannt:
ganzeZahl = 0;
Wo der Wert von ganzeZahl im Speicher zu finden ist.
Wieviel Speicher die Variable ganzeZahl belegen darf.
ganzeZahl : Variable
Welche Werte ganzeZahl annehmen kann.
= : Zuweisungsoperator
; : Initialisierung ist spezielle Anweisung, eine Zuweisung,
daher Abschluss mit Semikolon.
Achtung: Die Variable ganzeZahl besitzt noch keinen verlässlichen
Wert.
9 / 39
Deklaration und Initialisierung
10
3.3 Konstanten
Da fehlende Initialisierung eine Fehlerquelle ist, sollten (falls
möglich) Deklaration und Initialisierung zusammengefasst werden:
int ganzeZahl = 0;
Im Gegensatz zu Variablen, können Konstanten nicht durch
Zuweisungen im Verlauf eines Programms andere Werte annehmen.
Variablen kann ein neuer Wert zugewiesen werden (→
variabel):
ganzeZahl = 1000;
Konstanten wird nur einmal, direkt durch kombinierte Deklaration
und Initialisierung ein Wert zugewiesen:
static final double PI=3.1415;
Wenn neuer Wert in Variable gespeichert wird, wird alter
Wert überschrieben.
final int TEMPOLIMIT;
Auslesen von Variablen ist nicht destruktiv, d.h. der Wert
bleibt nach Auslesen erhalten.
11 / 39
12
Konstanten mit und ohne static
Konstanten mit und ohne static
static final double PI=3.1415;
static final double PI=3.1415;
final int TEMPOLIMIT;
final int TEMPOLIMIT;
static: Konstanten gehören immer zu einer Klasse bzw.
einem Objekt, nicht zu einer einzelnen Methode.
Durch das Attribut static wird angezeigt, dass die
Konstante PI zu Klasse gehört. Die Konstante TEMPOLIMIT
ohne static gehört zu einem Objekt (Instanz einer Klasse).
TEMPOLIMIT wird daher erst im Konstruktor (Später!)
(mittels Übergabeparameter) initialisiert. Andernfalls hätte die
Konstante für jedes Objekt der Klasse den gleichen Wert und
könnte damit gleich als static deklariert werden.
Das Attribut final Macht die folgende
“Variablen-”Deklaration zu einer Konstanten-Deklaration, d.h.
der (bei Deklaration oder im Konstruktor festgelegte)
Initialwert ist unveränderbar.
double PI=3.1415 / int TEMPOLIMIT: Normale
Deklaration (und Initialisierung). Bei Verwendung von static
muss Deklaration und Initialisierung direkt erfolgen!
Konvention: Konstantennamen komplett in Grossbuchstaben.
13 / 39
Warum Konstanten ?
14
3.4 Ein Programm mit Variablen und Konstanten
Besonders bei oft benutzten Werten, ist es sinnvoll eine Konstante
mit aussagekräftigem Namen, anstelle des Wertes selbst zu
benutzen:
Übersicht (z.B. math. Konstante PI ) :
Kreisumfang=2 ∗ PI ∗ r leichter lesbar als 2 ∗ 3, 1415 ∗ r
Lernziele
Tippfehler:
Compiler erkennt 2 ∗ iP ∗ r als falsch (falls es keine
Variable/Konstante iP gibt), aber nicht 2 ∗ 1, 3415 ∗ r
I
I
I
Schreibaufwand, Wartbarkeit:
Anpassung des Tempolimits nur einmal bei
Konstantendeklaration, nicht bei jeder Verwendung im
Programm.
I
Deklaration/Initialisierung von Variablen
Deklaration/Initialisierung von Konstanten
Ein Eingabeproblem: Motivation Datentypen
Einfache Anweisung: Motivation Operatoren
Schutz:
Einer als Konstante deklarierten Variablen kann nicht
“versehentlich” ein neuer Wert zugewiesen werden.
15 / 39
16
Altersberechnung I: Age.java
Altersberechnung I: Age.java
1. /* Programmierkurs WS0708 AFS RS, BE, AS */
1. /* Programmierkurs WS0708 AFS RS, BE, AS */
2. import java.io.*;
2. import java.io.*;
3. public class Age
3. public class Age
4. {
4. {
5.
static final int CURRENTYEAR = 2007;
5.
static final int CURRENTYEAR = 2007;
6.
public static void main(String[] args)
6.
public static void main(String[] args)
7.
throws IOException
7.
throws IOException
Deklaration und Initialisie{
String yearString; rung der Konstanten
CURRENTYEAR.
int yearInt, age;
8.
8.
{
9.
String yearString;
9.
10.
int yearInt, age;
10.
11.
BufferedReader in = new BufferedReader
11.
12.
13.
12.
( new InputStreamReader(System.in) );
13.
System.out.println(‘‘Eingabe Geburtsjahr:’’);
BufferedReader in = new BufferedReader
( new InputStreamReader(System.in) );
System.out.println(‘‘Eingabe Geburtsjahr:’’);
17 / 39
Altersberechnung I: Age.java
18
Altersberechnung II
1. /* Programmierkurs WS0708 AFS RS, BE, AS */
2. import java.io.*;
3. public class Age
1.
// Tastatureingabe als String einlesen!
4. {
2.
yearString = in.readLine();
3.
// String in ganze Zahl umwandeln
4.
yearInt = Integer.parseInt(yearString);
5.
age = CURRENTYEAR - yearInt;
6.
System.out.println(‘‘ \ n Sie sind ’’ +
5.
6.
7.
8.
static final int CURRENTYEAR = 2007;
Deklaration der Variablen
public static void main(String[]
args)
yearString vom
Typ String
throws IOException
und 2 int Variablen yearInt,
age gemeinsam.
{
9.
String yearString;
7.
10.
int yearInt, age;
8. }
11.
BufferedReader in = new BufferedReader
9. }
12.
13.
age + ‘‘ Jahr(e) alt.’’);
( new InputStreamReader(System.in) );
System.out.println(‘‘Eingabe Geburtsjahr:’’);
19 / 39
20
Altersberechnung II
Altersberechnung II
1.
// Tastatureingabe als String einlesen!
1.
// Tastatureingabe als String einlesen!
2.
yearString = in.readLine();
2.
yearString = in.readLine();
3.
// String in ganze Zahl umwandeln
3.
// String in ganze Zahl umwandeln
4.
yearInt = Integer.parseInt(yearString);
4.
yearInt = Integer.parseInt(yearString);
5.
age = CURRENTYEAR - yearInt;
5.
age = CURRENTYEAR - yearInt;
6.
System.out.println(‘‘ \ n Sie sind ’’ +
6.
System.out.println(‘‘ \ n Sie sind ’’ +
7.
7.
age + ‘‘ Jahr(e) alt.’’);
8. }
9. }
age + ‘‘ Jahr(e) alt.’’);
8. }
Einfache arithmetische An9. }
weisung
Typproblematik: Später.
Für praktische Anwendung
an Beispiel merken.
21 / 39
Altersberechnung - Ausgabe
22
3.5 Gültigkeitsbereich von Variablen
Wir haben gesehen, dass Konstanten in der Klassendefinition
und Variablen (bisher) innerhalb des Methodenkörpers
definiert werden.
Eingabe Geburtsjahr:
1980
Sie sind 27 Jahr(e) alt.
Dies hat in Java strukturelle Gründe (später: OO), beeinflusst
aber auch den Gültigkeitsbereich der Variablen.
Der Gültigkeitsbereich der Variablen ist der Bereich, in dem
die Variable bekannt ist:
Gültigkeitsbereich: Eine Variable ist im kleinsten Block
gültig, der ihre Deklaration einschließt.
23 / 39
24
Blöcke
Verlassen eines Blocks
Ein Block besteht aus einem ein Paar geschweifter Klammern
und den darin eingeschlossenen Anweisungen.
{
...
}
Beim Verlassen eines Blocks wird der für darin deklarierte
Variablen reservierte Speicherplatz wieder freigegeben:
Alle im Block deklarierten Variablen sind “vergessen”.
Ein Block wird “von außen” als einzelne Anweisung
betrachtet.
Variablen müssen vor erneuter Verwendung erst neu deklariert
werden.
Daher können auch Blöcke verschachtelt sein, d.h. ein Block
umfasst Anweisungen, die wieder Blöcke sind.
{
{ ...}
}
Der frühere Wert bleibt dann aber verloren.
25 / 39
Betreten eines Blocks
26
Globale und lokale Variablen
Variablen, die direkt in der Klassendefinition deklariert werden
(wie Konstanten) sind in der ganzen Klasse gültig. Zugriff
kann (→ später) auch von außerhalb der Klasse (mit voll
qualifiziertem Namen und Punktnotation) erfolgen.
Beim Betreten eines Blocks, kann eine neue Deklaration einer
Variable, eine bereits ausserhalb des Blocks deklarierte
Variable mit gleichem Namen “verdecken”.
Solche Variablen haben als Teil des durch die Klasse
beschriebenen Objektes aber eine besondere Stellung
(Membervariablen, später).
Man spricht von Sichtbarkeit einer Variablen.
Ist eine Variable in einem Block nicht sichtbar, so kann ihr
Wert weder ausgelesen noch verändert werden.
Beim Verlassen des Blocks wird die “innere” (lokalere)
Variable vergessen, die äußere (globalere) wieder sichtbar.
Andere Variablen, die innerhalb von Methoden oder darin
enthaltenen Blöcken deklariert sind, nennt man lokal.
Auf diese Variablen kann nicht von außerhalb des Blockes
zugegriffen werden.
27 / 39
28
Tipp:
Eindeutige Benennung
Es ist immer günstig, keine Variablen
innerhalb einer Klasse gleich zu
benennen!
Klassen und Methoden sind “Blöcke mit Namen”, der als
Kommentar der schliessenden Klammer zur Übersicht beiträgt:
public static void
class XYZ
main(String args[])
{
{
{ ...}
{ ...}
} //XYZ
} // main()
Ausnahme: Sogenannte Laufvariablen → Kontrollstrukturen
Hinweis: Oft, aber nicht immer, führen Mehrfachdeklarationen zu
Kompilerfehlern (Daher: Beispiel mit Trick).
29 / 39
Sichtbarkeit : OldAge.java
30
Sichtbarkeit : OldAge.java
1. /* Programmierkurs WS0708 AFS RS, BE, AS */
1. /* Programmierkurs WS0708 AFS RS, BE, AS */
2. import java.io.*;
2. import java.io.*;
3. public class Age
3. public class Age
4. {// Spezieller Block: Klasse
4. {// Spezieller Block: Klasse
5.
static final int CURRENTYEAR = 2007;
5.
static final int CURRENTYEAR = 2007;
6.
static int age = 1000;
6.
static int age = 1000;
7.
public static void main(String[] args)
7.
public static void main(String[] args)
8.
throws IOException
8.
throws IOException
Deklaration und Initialisie{// Spezieller Block: Methode
rung der Variablen age auf
System.out.println(‘‘Klassenebene
\ n Sie sind ’’ +
age + ‘‘ Jahr(e) alt.’’);
9.
10.
11.
9.
{// Spezieller Block: Methode
10.
System.out.println(‘‘ \ n Sie sind ’’ +
11.
age + ‘‘ Jahr(e) alt.’’);
31 / 39
32
Sichtbarkeit : OldAge.java
Sichtbarkeit : OldAge.java
1.
{// Ein Extra-Block
1.
{// Ein Extra-Block
2.
String yearString;
2.
String yearString;
3.
int yearInt, age;
3.
int yearInt, age;
4.
BufferedReader in = new BufferedReader
4.
BufferedReader in = new BufferedReader
5.
5.
( new InputStreamReader(System.in) );
( new InputStreamReader(System.in) );
6.
System.out.println(‘‘Eingabe Geburtsjahr:’’);
6.
System.out.println(‘‘Eingabe Geburtsjahr:’’);
7.
// Tastatureingabe als String einlesen!
7.
// Tastatureingabe als String einlesen!
8.
yearString = in.readLine();
8.
yearString = in.readLine();
9.
// String in ganze Zahl umwandeln
9.
// String in ganze Zahl umwandeln
Erneute (lokale) DeklaratiyearInt = Integer.parseInt(yearString);
on von age
10.
10.
yearInt = Integer.parseInt(yearString);
33 / 39
Sichtbarkeit : OldAge.java
34
Sichtbarkeit : OldAge.java
1.
age = CURRENTYEAR - yearInt;
1.
age = CURRENTYEAR - yearInt;
2.
System.out.println(‘‘ \ n Sie sind ’’ +
2.
System.out.println(‘‘ \ n Sie sind ’’ +
3.
3.
age + ‘‘ Jahr(e) alt.’’);
4. }// Block zu Ende
4. }// Block zu Ende
5.
5.
System.out.println(‘‘ \ n Sie sind ’’ +
6.
age + ‘‘ Jahr(e) alt.’’);
System.out.println(‘‘ \ n Sie sind ’’ +
6.
age + ‘‘ Jahr(e) alt.’’);
7. }// main()
7. }// main()
8. }// Age
8. }// Age
35 / 39
age + ‘‘ Jahr(e) alt.’’);
Benutzung der lokal sichtbaren Variable age.
36
Sichtbarkeit : OldAge.java
1.
age = CURRENTYEAR - yearInt;
2.
System.out.println(‘‘ \ n Sie sind ’’ +
3.
Altersberechnung - Ausgabe
Sie sind 1000 Jahr(e) alt.
Eingabe Geburtsjahr:
1980
Sie sind 27 Jahr(e) alt.
Sie sind 1000 Jahr(e) alt.
age + ‘‘ Jahr(e) alt.’’);
4. }// Block zu Ende
5.
System.out.println(‘‘ \ n Sie sind ’’ +
6.
age + ‘‘ Jahr(e) alt.’’);
Variable age auf Klassenebene
sichtbar.
Variable age auf Klassenebene
von lokaler Variable überdeckt.
Variable age auf Klassenebene
wieder sichtbar.
7. }// main()
Blockende: Welches age ist
8. }// Age
sichtbar ?
37 / 39
Vereinbarung
Haben gesehen, dass kleine Beispiele schon mehrere Folien füllen.
Reduzieren ab jetzt Beispielprogramme meist auf die
Hauptmethode.
Beachte: Jede Methode liegt aber weiterhin innerhalb einer
(gedachten) Klassendefinition (siehe Angabe des
Java-Programmes)!
39 / 39
38