Java Einführung - Michael Hahsler

Werbung
Java Einführung
Teil 1: Einfacher Java Code
Michael Hahsler
Java Einführung
SOFTWARE-ENTWICKLUNG
Kapitel 1
Inhalt dieser Einheit
• Phasen eines Softwareprojekts
• Algorithmus
• Überblick über (Programmier-)
Sprachen
• Wie funktioniert JAVA?
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
2
Software Engineering
Fachgebiet der Informatik stellt
• Methoden
• Werkzeuge
zur Herstellung und Anwendung von
Software bereit.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
3
Die Phasen eines Softwareprojekts
(klassisch sequentielles Software-Life-Cycle-Modell)
Problemstellung,
Idee
Betrieb und
Wartung
Problemanalyse
Systemtest
(Komponenten-)
Entwurf = Design
Implementierung und
Komponententest
Spezifikation
= Analyse
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
4
Problemanalyse und Planung
Was?
• Erhebung des Ist-Zustandes
• Abgrenzung des Problembereichs
• Skizzieren der Bestandteile des geplanten
Systems
• erste Abschätzung des Umfanges und der
Wirtschaftlichkeit
• Erstellung eines groben Projektplans
• Benutzeranalyse
• Aufgabenanalyse
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
5
Analyse: Spezifikation
Was?
• Genaue Festlegung des Leistungsumfanges des
geplanten Systems (Pflichtenheft)
• Umsetzung der Anforderungen in ein Modell,
welches die künftige Funktionalität des zu
entwickelnden Produktes vollständig beschreibt
• Funktionsmodelle, Datenmodelle,
Ereignismodelle, Interaktionsmodelle, WorkflowModelle
• noch unabhängig von der Implementierung
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
6
Design: System- und
Komponentenentwurf
Wie?
• Umsetzung, der in der Spezifikation erstellten
Modelle in eine formale Form
• Festlegung, welche Systemkomponenten die
vorgegebenen Anforderungen abdecken
werden
• Definition der Systemkomponenten
(Schnittstellen!)
• Entwurf der algorithmischen Struktur
(Pseudocode)
• Entwurf der Datenstrukturen
• unabhängig von der Implementierung!
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
7
Implementierung und
Komponententest
• Umsetzung der Ergebnisse der Entwurfsphase
in eine rechnerausführbare Form
• Verfeinerung der Komponenten und
Algorithmen
• Codierung in der gewählten
Programmiersprache
• Komponententests
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
8
Systemtest
• Wechselwirkungen der Systemkomponenten
unter realen Bedingungen prüfen
• Fehler aufdecken
• sicherstellen, dass die Systemspezifikation
erfüllt ist (aus Pflichtenheft)
• Freigabe der Software
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
9
Betrieb und Wartung
• Fehler, die erst während des tatsächlichen
Betriebs auftreten beheben
• Systemänderungen und
Systemerweiterungen durchführen
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
10
Andere SoftwareEngineering Modelle
•
•
•
•
•
Wasserfall-Modell
Spiral-Modell
Prototyping-orientiertes Life-Cycle-Modell
Objektorientiertes Life-Cycle-Modell
Objekt- und prototyping-orientiertes LifeCycle-Modell
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
11
Beschreibung von Abläufen
(Bsp. Kochrezept)
„Man nehme 2 dag Schmalz und erhitze es in
einer Pfanne. Inzwischen versprudelt man 3
Eier mit einer Brise Salz. Wenn das Fett heiß
ist, gieße man die Eier in die Pfanne. Mit einer
Gabel umrühren, bis die Eier stocken, sofort
heiß servieren...''
•
•
•
•
Kochrezepte
Gebrauchsanweisungen
Algorithmen
Programme
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
12
Algorithmus (Definition)
Ein Algorithmus ist ein
• Plan zur Lösung gleichartiger Probleme mit Hilfe
einer endlichen Folge eindeutiger,
ausführbarer Schritte
• bestehend aus
- elementaren Anweisungen
- in einer geeigneten Sprache
- die sequentiell (schrittweise) durchgeführt werden.
Ein Programm ist ein Algorithmus formuliert in
einer bestimmten Programmiersprache.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
13
Algorithmus
( Bsp. Telefonnummersuche)
"Suche die Telefonnummer zu einem gegebenen
Namen in einem beliebigen Adressbuch“
1. Gehe zum ersten Eintrag im
Adressbuch
2. Vergleiche den aktuellen Eintrag
mit dem gesuchten Namen
3. Bei Gleichheit: gib die zugehörige
Telefonnummer aus und halte an
sonst gehe zu Schritt 4
4. (Ungleichheit) Wenn noch
Einträge im Adressbuch
vorhanden sind: nimm‘ den
nächsten Eintrag und gehe zu (2)
sonst gehe zu Schritt 5
5. melde Misserfolg und halte an
Name
Tel.Nr.
Neumann, Gustaf 12235
Neumann, Gustav 13356
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
14
Definition einer Sprache
Wie definiert sich eine Sprache?
• Aus der Menge der Symbole (Worte) können Sätze
gebildet werden.
• Syntax: Die Regeln für das Bilden gültiger Sätze
aus diesen Symbolen (=''Grammatikregeln'').
• Semantik: Die Bedeutung der gültigen Sätze.
• Bsp: 2+4=7 ist in der Sprache der Mathematik
syntaktisch richtig, aber semantisch falsch.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
15
Bsp: Regelgramatik
Syntaxregeln (BNF)
<Ziffer> ::= 0|1|2|3|4|5|6|7|8|9
<Vorzeichen> ::= +|<Ziffernfolge> ::= <Ziffer> | <Ziffernfolge><Ziffer>
<Zahl> ::= <Ziffernfolge>| <Vorzeichen><Ziffernfolge>
• Terminale Symbole werden nicht mehr abgeleitet
{0,1,2,...,9}
• Nicht-terminale Symbole gekennzeichnet durch <...>
• | bedeutet eine Auswahl (oder)
• Alles was von <Zahl> (Startsymbol) abgeleitet werden
kann, ist eine gültige Zahl
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
16
Bsp: Syntaxdiagramm
Ziffer
Ziffernfolge
Ziffer
0
1
...
Ziffernfolge
Ziffer
9
Zahl
Vorzeichen
Ziffernfolge
+
-
Vorzeichen
Ziffernfolge
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
17
Natürliche versus formale
Sprache
• Natürliche Sprachen sind vielfach
syntaktisch und/oder semantisch
mehrdeutig.
(„Dings“ wird aus dem Kontext erkannt)
• Natürliche Sprachen sind fehlertolerant.
• Der vorgegebene Wortumfang natürlicher Sprachen ist
sehr groß.
(80000 Worte Langenscheidt vs. 51 Java)
• Eine Programmiersprache ist eindeutig und ist primitiv
genug, um in Maschinencode übersetzt werden zu
können.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
18
Java-Wortschatz
reservierte Worte
abstract
catch
do
final
implements
long
private
static
this
try
true
enum
boolean
char
double
finally
import
native
protected
super
throw
void
short
strictfp
break
class
else
float
instanceof
new
public
switch
throws
volatile
interface
byte
case
continue default
extends false
for
if
int
null
return
synchronized
transient
while
package assert
* derzeit ohne Verwendung
byvalue*
goto*
var*
cast*
inner*
const*
operator*
future*
outer*
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
generic*
rest*
19
Programmiersprachen Definition
Eine Programmiersprache
• ist eine Sprache zur Formulierung von
Rechenvorschriften bzw. Anweisungen
(Datenstrukturen und Algorithmen), die von einem
Computer ausgeführt werden können,
• hat eine eindeutig definierte
• Syntax (welche Zeichenfolgen sind erlaubt) und
• Semantik (was bewirken die Zeichenfolgen auf
dem Rechner),
• bildet die wichtigste Schnittstelle zwischen Rechner
und Programmierer.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
20
Wie kann ich eine Sprache lernen?
ÜBEN und ANWENDEN!
Wie beim Lernen eines Musikinstruments!
Notenkenntnis und
Erkennen der Tasten
ist zuwenig!
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
21
Programmiersprachen
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
22
Programmiersprachen
Übersicht
• Maschinensprache
Programme in Maschinensprache bestehen aus Maschinenbefehlen,
die als Folge von Nullen und Einsen im Rechner dargestellt werden. Nur
Maschinensprache kann vom Prozessor verarbeitet werden.
• Assembler Sprachen
Die Bitkombinationen der Maschinenbefehle werden durch ein leicht zu
merkendes Symbolwort ausgedrückt werden (MOV A L).
• Höhere/symbolische Programmiersprachen
Sind an die menschlichen Denkweisen angepasst (sie sind
problemorientiert und nicht mehr maschinenorientiert). Höhere
Programmiersprachen erlauben die Formulierung von Programmen in
einer vom Zielrechner unabhängigen Notation. Mit Hilfe eines
Übersetzungsprogramms (Compiler) werden Programme einer höherer
Programmiersprache in Maschinenprogramme übersetzt.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
23
Höhere Programmiersprachen
Übersicht
• Strukturierte Programmiersprachen
Höhere Programmiersprachen, die das Modulkonzept unterstützen
BASIC, PASCAL, C, Modula
• Objektorientierte Programmiersprachen
Höhere Programmiersprachen, welche Daten und Anweisungen nicht
trennen sondern zusammen als Objekte behandeln. Objekte stehen
miteinander in Beziehung und kommunizieren miteinander durch
Versenden von Nachrichten (Messages). Das Empfängerobjekt hat für
jede Nachricht, die es “versteht”, einen eingebauten Algorithmus
(Methode genannt). C++, C# und Java
• Deskriptive Programmiersprachen dient zur Beschreibung der
Eigenschaften gesuchter Informationen (üblicherweise Daten aus einer
Datenbank) SQL
• Logische Programmiersprachen
Die logische Programmierung beruht auf der Erkenntnis, dass einer
Untermenge der Prädikatenlogik eine prozedurale Interpretation
gegeben werden kann. PROLOG
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
24
Programmiersprachen
grafische Übersicht
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
25
Entwicklung von prozeduralen
Programmiersprachen
John v. Neumann: Programmierbare Rechenmaschine
IBM: PL/1
1964
General Purpose PL
Dahl: Simula
Simulation
N. Wirth: Pascal
Strukturierte Programmierung
D. Ritchie (AT&T): C
N. Wirth: Modula-2
Verbesserte Datenkapselung
1940
Systemprogrammierung
1967
1971
1974
1980
B. Stroustroup (AT&T): C++
Objektorientierte Erweiterung von C
Sun: Java
vereinfachte und gestutzte Weiterentwicklung von C++
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
1987
1995
26
Java-Geschichte
• 1991: Projekt ``Green`` (consumer electronics) bei Sun zunächst
basierend auf C++, das sich aber im Hinblick auf Sicherheit,
Portabilität und Zuverlässigkeit als unzureichend herausgestellt hatte
=> Entwicklung einer eigenen Sprache ``Oak``, später Java
• 1994: Entwicklung des HotJava-Browsers (Java Applets)
• 1995: offizielle Vorstellung von Java, Netscape lizenziert Java
• 1996: Gründung von JavaSoft bei Sun, Release 1.0 des Java
Development Kits (JDK)
• 1997: JDK 1.1
• 1999: JDK 1.2 = Java 2 Platform
• 2000: JDK 1.3
• 2001: SDK 1.4
• 2005: JDK 5.0 = Version 1.5
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
27
Was ist Java?
• Objektorientiert
• Einfach (keine Pointer, automatische
Garbage Collection, nur einfache Vererbung)
• Plattformunabhängig (durch Bytecode)
• Verteilt/Netzwerkfähig (Internet)
• Sicher (Sandbox)
• Multithreading-fähig (Parallelverarbeitung)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
28
Grundlagen: Ausführbare
Programme
• Der Quellcode beinhaltet Anweisungen, die noch
nicht direkt durch ein Computersystem ausgeführt
werden können. Für die Ausführung der
Anweisungen muss der Quellcode erst in
Maschinencode übersetzt werden.
• Es gibt zwei Möglichkeiten, Quellcode einer höherer
Programmiersprachen in Maschinencode zu übersetzen:
• Interpreter: Nach dem Start des Interpreters wird jeweils
eine Anweisung des Quellprogramms nach der anderen in
Maschinenbefehle übersetzt, geprüft und sofort ausgeführt.
• Compiler: Übersetzt das Quellprogramm vollständig in
Maschinencode, der zu einem beliebigen Zeitpunkt vom
Betriebssystem geladen und ausgeführt werden kann.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
29
Ausführen von Java
• Java kombiniert Compiler und Interpreter
• Zunächst wird die Quelldatei mit Hilfe des
Java Compilers in Bytecode übersetzt.
HelloWorld.java
Quellcode
javac
Java Compiler
HelloWorld.class
Java Bytecode
• Wichtig: Die Bytecode-Datei beinhaltet exakt
denselben Bytecode, egal von welchem
System sie erzeugt wird
(Plattformunabhängig!)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
30
Java Bytecode Interpreter
• Der Bytecode kann noch nicht direkt ausgeführt
werden. Dazu wird im zweiten Schritt ein Java
Bytecode Interpreter eingesetzt.
• Jedes System hat seinen eigenen Java Bytecode
Interpreter, die „Java Virtual Machine“ (JVM)
Betriebssystem
Prozessorarchitektur
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
31
Java - Übersetzung
Java
Quellcode
javac ProgramName.java
ProgramName.java
Java-Compiler javac
Java
ByteCode
java ProgramName
ProgramName.class
Java-Interpreter java
JVM-NT
Windows NT
JVM-Sol
Sun Solaris
JVM-Net
Netscape
Betriebssystem/
Browser/
Machinensprache
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
32
Programmcode
class HelloWorld {
public static void main (String[] args)
{
System.out.println(“Hello, world“);
}
}
“Quellcode”
Der Programmcode muss erst in die für den Computer
verständliche Sprache übersetzt werden!
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
33
Java Applikationen vs. Applets vs.
Java-Script
• Java-Applikationen: Anwendungen auf
Betriebssystemebene, z.B. wird unter Windows
gestartet und öffnet ein eigenes Fenster.
• Java-Applets: Java-Anwendungen, die in einem
WWW-Browser ablaufen. Sind in HTML-Seiten
eingebettet und werden automatisch über das
Internet heruntergeladen; z.B. im Internet Explorer.
• Java-Script: Scriptsprache zum Einbetten von
einfachen Programmen in HTML-Seiten.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
34
Selbstkontrolle
• In welchen Phasen läut ein Software-Projekt ab?
• Welche Klassen von Programmiersprachen gibt
es? Und zu welcher Klasse gehört Java?
• Was sind die Eigenschaften von Java?
• Erklären Sie die Schritte vom Java-Quellcode
zum ausführbaren Java-Programm.
• Was ist der Unterschied zwischen JavaApplikationen und Java-Applets?
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
35
Java Einführung
Programmcode
Inhalt dieser Einheit
• Programmelemente
• Der erste Programmcode
• Die Entwicklungsumgebung: Sun's Java
Software Development Kit (SDK)
• Vom Code zum Ausführen des Programms
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
2
Wiederholung: Java
• „Write once, run everywhere!“
(unabhängig von Hardware,
Betriebssystem etc.): der
Programmcode wird zu
unabhängigem Bytecode kompiliert,
der von der Java-Virtual Machine
(JVM) des Zielsystems interpretiert
und ausgeführt wird.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
3
Wiederholung: Algorithmus
Ein Algorithmus ist eine Arbeitsanleitung zur Lösung
eines Problems, die so präzise formuliert ist, dass sie von
einem Computer ausgeführt werden kann.
Er besteht aus
• elementaren Anweisungen
• in einer geeigneten Sprache
• die sequentiell (schrittweise) durchgeführt werden.
Der in einer für Menschen verständlichen Sprache
beschriebene Algorithmus wird dann in eine
Programmiersprache (hier: JAVA) transferiert.
Quelltext (auch Quellcode) bezeichnet einen in einer
Programmiersprache codierten Algorithmus.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
4
Programmelemente
• Anweisungen
• elementarste ausführbare Programmelemente
• werden mit Semikolon ('';'') beendet
• z.B.: Anweisung;
• Blöcke
•
•
•
•
Reihe von Anweisungen
wirkt nach außen hin wie eine Anweisung
werden von geschwungenen Klammern umgrenzt
{ Anweisung; Anweisung; ... }
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
5
Programmelemente / 2
• Klassendefinitionen
• Grundlegende Strukturierungseinheit eines objektorientierten Programms
• z.B. class Teacher {...}
• Methoden
•
•
•
•
Block, der über einen Namen aufrufbar ist
kann Aufrufparameter beinhalten
kann Rückgabewerte beinhalten
z.B. int grade (String[] student_name) {...}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
6
Programmelemente / 3
• Kommentare
Beschreibenden Text rund um Code verfassen und wird
nicht kompiliert
Arten:
// Kommentar bis zum Zeilenende
/* ... Kommentar bis zum nächsten */
/** ... JavaDoc Kom. bis zum nächsten */
- diese Form dient der Kennzeichnung von JavaDocKommentaren, die später elegant in HTML-Seiten
umgewandelt werden können.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
7
Das erste Programm
Klasse
Block
Methode
class HelloWorld {
public static void main (String[] args)
{
Kommentar
// Hello world ausgeben
System.out.println(“Hello world“);
}
Anweisung
}
Quellcode wird mit Hilfe eines Editors (WordPad) oder einer
Entwicklungsumgebung geschrieben.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
8
Java ist case-sensitiv!
Achtung!
In der Programmiersprache Java haben Worte, die bis
auf die Groß- und Kleinschreibung identisch sind, eine
unterschiedliche Bedeutung.
z.B.
HelloWorld <> helloworld <> Helloworld <>
helloWorld <> ...
Anmerkung:
Großbuchstabe (engl.: upper-case)
Kleinbuchstabe (engl.: lower-case)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
9
Untersuchung: HelloWorld
• class HelloWorld: Hauptklasse mit dem
Namen HelloWorld
• Methode main: Hauptmethode. Hier startet
die Applikation
• System.out.println("..."):
Anweisung an die Klasse System.out die
Methode println() (“print line“)
auszuführen. println() veranlasst die
Ausgabe einer Zeichenkette, die durch ein
Zeilensendezeichen abgeschlossen wird.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
10
Die Methode „main“
Die Methode „main“ ist jene Methode, die zum
Programmstart ausgeführt wird. Sie kann wiederum
andere Methoden aufrufen.
public static void main (String[] args){...}
Die Methode ''main'' ist
• public (=öffentlich, für alle verfügbar) und
static (=statisch, immer verfügbar und nicht
änderbar) definiert und hat
• Parameter (String[] args) und
• keinen Rückgabewert (void engl.: leer).
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
11
Blöcke
• In Java wird die Quellcode-Datei in Teile geteilt, die durch
öffnende und schließende geschwungene Klammern { }
getrennt sind.
• Alles zwischen { und } ist ein Block. Damit werden
zusammengehörige Anweisungen gruppiert.
• Blöcke können verschachtelt sein und andere Blöcke
beinhalten.
z.B: HelloWorld.java
- äußerer Block für die Klassendefinition, welcher einen
- inneren Block der Main-Methode beinhaltet.
• Ein Block sollte zur besseren Lesbarkeit eingerückt
werden. Durch diese Strukturierung wird der Code u.a.
leichter lesbar.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
12
Die Entwicklungsumgebung
von Sun
Das Java Software Development Kit (JDK)
beinhaltet die Software und Tools, die von
Entwicklern benötigt werden, um Quellcode zu
kompilieren, zu debuggen und auszuführen.
Die JDK Software und Dokumentation inkludiert
• grundlegende Entwicklungstools,
• eine große Menge an Klassen-Bibliotheken,
• und ist gratis verfügbar.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
13
Java 2 Plattform Standard
Edition
• Java 2 Plattform seit Ende 1998
(Version Java 1.2 und höher)
• Derzeit JDK 5.0 (Java 1.5)
• Download unter http://java.sun.com/
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
14
Bestandteile JDK
• Compiler (javac)
• Bytecode Interpreter
(java)
• jar, javadoc, etc.
Ausführbare Programme
Beispielprogramme und Applets
Java Runtime Environment
(Virtual Machine)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
15
Installation und
Konfiguration
• SDK herunterladen und installieren
• PATH auf das bin-Verzeichnis setzen:
Einstellungen->Systemsteuerung->System
Erweitert/Umgebungsvariablen/Path
• Ausführliche Information zur gerade aktuellen
Version liefern die Installationshinweise von Sun.
(http://java.sun.com/)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
16
Schritte vom Code zur
Programmausführung
• Abspeichern des Codes unter dem Namen der
Hauptklasse, Erweiterung “.java“. (HelloWorld.java)
• Kompilieren
> javac HelloWorld.java
Î Bytecode-Datei HelloWorld.class wird erzeugt
• Ausführen
> java HelloWorld
Î Ausgabe > HelloWorld
MS DOS-Fenster (Start->Ausführen->CMD)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
17
Aufgabe
• Installieren Sie JDK zuhause oder gehen Sie in den
Übungsraum.
• Suchen Sie das jdk-Verzeichnis (meist unter
C:\Programme\Java) und setzen Sie die “PATH“
Variable.
• Implementieren Sie das HelloWorld Beispiel,
kompilieren Sie es und führen es aus.
• Ändern Sie das Programm so ab, dass es
GoodNight heißt und auch Good Night! ausgibt.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
18
Nach dieser Einheit sollten
Sie wissen, ...
• welche Programmelemente ein Programm enthält
• was Anweisungen sind
• wie diese zu Blöcken zusammengefasst werden
können
• wie ein Programm strukturiert wird
• und wie Sie Ihr Programm HelloWorld erstellen,
kompilieren und ausführen können
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
19
Java Einführung
VARIABLEN und DATENTYPEN
Kapitel 2
Inhalt dieser Einheit
• Variablen (Sinn und Aufgabe)
• Bezeichner
• Datentypen, Deklaration und Operationen
• Typenumwandlung (implizit/explizit)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
2
Variablen
• Daten werden in Variablen gespeichert. Variablen sind aus der
Mathematik bekannt: y=5+x
• Variablen haben einen Namen (Bezeichner) und einen Wert.
Bsp. x kann den Wert 8 haben.
• Variablen sind Behälter, die jeweils nur einen Wert eines bestimmten
Datentyp beinhalten können.
Bsp. x ist vom Datentyp 'ganze Zahl' (Integer), die Variable kann daher keine
Zeichenkette enthalten.
• Variablen müssen vor der Verwendung deklariert werden, dabei wird
der Name und der Datentyp festgelegt.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
3
Bezeichner
• Bezeichner benennen Variablen, Klassen, Instanzen,
Methoden,
• beginnen mit Buchstaben, “_“ oder “$“,
• anschließend folgen Buchstaben, Ziffern, Unterstrich, Dollar
und/oder Unicode-Zeichen.
• Zur besseren Lesbarkeit wird eine einheitliche Form der
Benennung der Klassen, Objekte, Methoden und Variablen
empfohlen. Besteht ein Bezeichner aus mehreren Worten werden
Sie folgendermaßen zusammengeschrieben: nameOfTheUser
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
4
Bezeichner (forts.)
• Variablennamen (und Instanznamen): kleiner
Anfangsbuchstabe. z.B.: zaehler oder meinZaehler
• Konstantennamen: komplett groß z.B.: MAXINT
• Klassennamen: ein Hauptwort, den ersten Buchstaben einer
Klasse groß schreibt. z.B.: MeineErsteKlasse
• Methodennamen: sind Verben, beginnen mit Kleinbuchstaben.
z.B.: getNameFromUser()
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
5
Datentypen und Werte
•
•
Es gibt unterschiedliche Kategorien (Datentypen) von Werten:
•
Ganze Zahlen: 2, 4754, -50
•
Gleitkomma (Reelle-) Zahlen: -3.4, 34.98, 34.83945
•
Wahrheitswerte: Richtig/Falsch
•
Zeichen: ‘a‘, ‘b‘
•
Zeichenketten: “Hello World!“
Unterschiedliche Datentypen benötigen unterschiedlich viel Speicherplatz; z.B.
Wahrheitswerte 1 Bit oder ASCII-Zeichen 7 Bit
•
Grund für den Einsatz von Datentypen:
•
Überprüfung sinnvoller Operationen (verhindert Addition “hallo“+3)
•
Reservierung passenden Speicherplatzes
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
6
Primitive Datentypen
In Java eingebaute Datentypen:
• Ganze Zahlen: byte, short, int, long
• Gleitkomma (Reelle-) Zahlen: float, double
• Zeichen: char
• Wahrheitswerte: boolean (true/false)
Die Datentypen und ihre Eigenschaften (Größe, Genauigkeit)
hängen nicht (wie bei anderen Programmiersprachen) vom
jeweiligen Computersystem ab, sondern sind in Java einheitlich
festgelegt.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
7
Primitive Datentypen (forts.)
Typ
byte
short
int
long
char
von
bis
-128
127
-32768
32767
-2.147.483.648
2147483647
-9.223.372.036.854.770.000
9.223.372.036.854.770.000
0
Ganzzahlen
65535 Unicode
Wahrheits
werte
false
boolean true
+/-1,40239846 * 10^-45
+/-3,40282347 * 10^38
Gleitkomfloat
double +/-4,94065645841246544 * 10^-324+/-1,79769313486231570 * 10^308 mazahlen
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
8
Ganze Zahlen
(Primitive Datentypen)
• Datentypen byte, short, int, long
• Operationen (Operanden und Ergebniswert sind ganze
Zahlen)
+ Addition
- Subtraktion
* Multiplikation
/ Ganzzahldivision
% Restbildung (Modulo-Funktion)
• Beispiele: 1, -45
weitere Operatoren folgen...
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
9
Gleitkommazahlen
(Primitive Datentypen)
• Datentypen float, double
• Operationen: (Operanden und Ergebniswert sind
Gleitkommazahlen)
+ Addition
- Subtraktion
* Multiplikation
/ Division
• Beispiel: 2.77, 1.0 (Achtung . als Komma!)
weitere Operatoren folgen...
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
10
Zeichen
(Primitive Datentypen)
• Datentyp char
• Operationen: (Operanden und Ergebniswert sind Zeichen oder
Zeichenketten)
+ (Verkettung)
• Beispiel: ‘a‘, ‘z‘
(Achtung einfaches Anführungszeichen!)
weitere mögliche Werte für Character-Datentypen auf der nächsten
Folie...
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
11
Zeichen (forts.)
• Tastatur-, Unicode oder Oktal-Zeichen in einfachen
Hochkomma
• Tastaturzeichen ‘Z‘
• Unicode-Zeichen ‘\u005A‘
• Oktal-Zeichen ‘\132‘
• Sonderzeichen (Auswahl der Escapesequenzen)
•
•
•
•
•
•
•
‘\b‘ Backspace
‘\“‘ Doppeltes Hochkomma
‘\n‘ linefeed
‘\\‘ Backslash
‘\r‘ carriage return
‘\‘‘ Einfaches Hochkomma
‘\t‘ Tabulator
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
12
Wahrheitswerte
(Primitive Datentypen)
• Datentyp boolean
• Operationen: Ergebniswert sind wieder
Wahrheitswerte
a && b
a || b
!a
(logisches UND: a ist wahr und b ist wahr)
(logisches ODER: a ist wahr oder b ist wahr)
(logisches NICHT: ist wahr wenn a falsch ist)
• Mögliche Werte: true, false
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
13
Wahrheitswerte (forts.)
Folgende Operatoren ergeben Wahrheitswerte:
< (kleiner)
<= (kleiner oder gleich)
== (gleich)
!= (ungleich)
z.B.
z.B.Vergleich
Vergleichvon
vonzwei
zweiInteger-Variablen
Integer-Variablen
>= (größer oder gleich)
int
int
int
int
> (größer)
aa
bb
==
==
1;
1;
2;
2;
boolean
boolean bool
bool == aa <=
<= b;
b;
Ergebniswert bool: true
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
14
Variablendeklarationen
• Variablen haben einen Namen und sind Behälter für
Werte eines bestimmten Datentyps
• Damit Variablen verwendet werden können, müssen sie
zuerst deklariert werden.
z.B.:
int i;
short x, y;
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
15
Deklaration u. Initialisierung
• Deklaration: Datentyp
z.B.:
name;
int abgaben;
boolean an;
• mehrere Variable vom selben Typ:
Datentyp name1, name2, name3;
z.B.:
int gehalt, lohn, provision;
• Wertzuweisung: variable = wert;
z.B.:
gehalt = 3000; provision = 2000;
an = true;
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
16
Deklaration u. Initialisierung (forts.)
• Deklaration mit Initialisierung
int gehalt = 3000;
int provision = 100;
double x = 0.000001;
char zeichen = 'a';
boolean aus = false;
• Zugriff auf Variablenwerte
gehalt = gehalt + provision;
System.out.println(“Gehalt: “+gehalt);
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
17
Automatische Initialisierung
von primitiven Datentypen
• Wird eine Variable bei der Deklaration nicht
Initialisiert (Bsp. int i;), erhält sie automatisch
folgenden Wert:
• Zahlen: 0 bzw. 0.0
• Wahrheitswerte: false
• Zeichen/Referenzen*: null (bedeutet: leer)
• besser: explizite Initialisierung
•
int provision = 0;
*Referenzen werden erst später behandelt!
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
18
Datentypen-Beispiel
class ArithmeticDemo {
public static void main(String[] args) {
int i = 37;
int j = 42;
Variablendouble x = 27.475;
deklarationen
double y = 7.22;
System.out.println("Variablenwerte...");
System.out.println(" i = " + i);
System.out.println(" j = " + j);
System.out.println(" x = " + x);
System.out.println(" y = " + y);
Ausgabe der
Variablenwerte
System.out.println("Addieren...");
System.out.println(" i + j = " + (i + j));
System.out.println(" x + y = " + (x + y));
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
Addition
19
Datentypen-Beispiel Teil2
System.out.println("Subtrahieren...");
System.out.println(" i - j = " + (i - j));
System.out.println(" x - y = " + (x - y));
System.out.println("Multiplizieren...");
System.out.println(" i * j = " + (i * j));
System.out.println(" x * y = " + (x * y));
System.out.println("Dividieren...");
System.out.println(" i / j = " + (i / j));
System.out.println(" x / y = " + (x / y));
System.out.println(“Restwertbestimmung...");
System.out.println(" i % j = " + (i % j));
System.out.println(" j % i = " + (j % i));
System.out.println("Vermischte Typen...");
System.out.println(" j + y = " + (j + y));
System.out.println(" i * x = " + (i * x));
}}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
Subtraktion
Multiplikation
Division
Rest
gemischte
Datentypen
20
Ausgabe des Programms
Variablenwerte...
i = 37
j = 42
x = 27.475
y = 7.22
Addieren...
i + j = 79
x + y = 34.695
Subtrahieren...
i - j = -5
x - y = 20.255
Multiplizieren...
i * j = 1554
x * y = 198.37
Dividieren...
i / j = 0
x / y = 3.8054
Restwertbestimmung...
i % j = 37
j % i = 5
Vermischte Typen...
j + y = 49.22
i * x = 1016.58
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
21
Konstanten
• Werte sollen während des gesamten Programmablaufes gleich
bleiben.
• Konstante ist kein weiterer Datentyp.
• Deklaration: Sie werden mit dem Schlüsselwort final
deklariert.
final Datentyp NAME = Wert;
z.B.: final double PI = 3.1416;
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
22
Typumwandlungen
• Java ist streng typisiert, Variablen dürfen nur Werte vom
deklarierten Typ zugewiesen werden.
• Vergleichsoperatoren vergleichen nur Ausdrücke gleichen Typs.
• Es gibt implizite und explizite Typumwandlung
int ganz = 3;
double komma = ganz; //implizit
float komma2 = (float) ganz; //explizit
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
23
Implizite Typumwandlung
• In manchen Fällen wird automatisch vom Compiler umgewandelt
(implizite Typumwandlung)
• byte, short => int => long
• int => float
• float => double
• char => int
•
Beispiel:
short s = 3;
// s=3
int i = s;
float g = 3 + i;
int b = ‘a‘;
int i = ‘z‘-‘a‘;
//
//
//
//
i=3
g=6.0
b=97*
i=25*
*Ascii-Werte a=97, z=122
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
24
Implizite Typvergrößerungen
Java nimmt diese Konversionen, falls nötig, bei Zuweisungen,
Methoden- und Konstruktoraufrufen und bei der Auswertung von
Ausdrücken implizit vor.
Zuweisungskompartibilität:
byte -> short -> int -> long -> float -> double
Kein Informationsverlust!
Ausnahme beim Übergang zu den Gleitkommazahlen:
bei long -> float wird Genauigkeit verloren
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
25
Explizite Typumwandlung (Cast)
Explizite Angabe des umzuwandelnden Typs
double d = 7.99;
int i = (int) d; /*i =7, da keine
Nachkommastellen beim Datentyp int */
int zahl = 33000;
short s = (short)zahl; //s=-32536
/*Zahl außerhalb des Wertebereichs
33000 binär = 1000 0000 1110 1000
Die erste Ziffer wird nun als Minuszeichen
interpretiert und ergibt den Wert -32536
im 2er-Komplement (-32768 + 232)*/
ACHTUNG!
Die Typverkleinerung kann zu falschen Werten führen, wenn der Wertebereich des
Zieldatentyps nicht ausreicht, den Wert darzustellen.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
26
Exkurs: Zeichenketten (Strings)
• Achtung: Zeichenkette ist keine primitiven Datentyp
sondern ein Objekt-Datentyp*
• Operationen: Verkettung, Ergebniswert ist wieder eine Zeichenkette
+ (Verkettung)
• Mögliche Werte:
z.B. "Hallo World" = Kombinationen vom Typ char
• Initialisierung
String s = "A short way to initialize";
(oder* String id = new String( "The long way" ); )
* Wird später genau behandelt
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
27
Exkurs: Unicode
...
Entspricht im unteren Bereich ASCII
Bsp: char c = '\u0060';
...
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
28
Nach dieser Einheit sollten Sie ...
• Die verschiedenen Arten von Variablen
kennen.
• alle primitiven Datentypen deren Initialisierung
und gängigen Operationen.
• Variablen verschiedenen Typs definieren, deren
Typ umwandeln, und damit rechnen können.
• Die Konventionen zur Bezeichnung von Variablen,
Methoden und Klassen kennen.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
29
Java Einführung
Operatoren
Kapitel 2 und 3
Inhalt dieser Einheit
•
•
•
•
•
Operatoren (unär, binär, ternär)
Rangfolge der Operatoren
Zuweisungsoperatoren
Vergleichsoperatoren
Logische Operatoren
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
2
Operatoren
• Abhängig vom Datentyp können bestimmte Operationen
vorgenommen werden
• Operatoren haben ein oder mehrere Operanden
Operand
Operand
3+4
Operator
• Die Ausführung der Operationen erfolgt nach einer
festgelegten Reihenfolge (d.h. einige Operatoren haben
Vorrang vor andern)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
3
Operatoren
• unäre Operatoren (1 Operand):
Bsp. ++ (erhöht den Wert des Operanden um 1, var++) oder
logisches Nicht ( ! )
• binäre Operatoren (2 Operanden):
Bsp. + (Addition der beiden Operanden, var1 + var2)
• ternärer Operator (3 Operanden):
?: als einziger ternärer Operator in Java erlaubt die verkürzte
Implementierung einer if-else-Verzweigung
(i<j)?“true“:“false“
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
4
Operatoren im Überblick
(Auszug) 1
=
Zuweisung
+
-
Addition/
Subtraktion
*
/
Multiplikation/
Division
++
--
Inkrement/
Dekrement
Erhöht oder erniedrigt den Wert der
Variablen um 1
%
Modulo
Liefert den Rest einer ganzzahligen
Division
(i<j)?“ja“:“nein“
if-then-else
Einziger ternärer Operator in Java.
Kurzform der IF-Schleife
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
5
Operatoren im Überblick
(Auszug) 2
<= <
>= >
Vergleich
Der Vergleich zweier Werte liefert true
oder false zurück.
==
!=
Vergleich (gleich,
ungleich)
Der Vergleich zweier Werte liefert true
oder false zurück.
!
logisches NICHT
Negiert den Wahrheitswert einer Aussage
&&
logisches UND
Verknüpft zwei Aussagen. Liefert true,
wenn beide Aussagen true sind.
||
logisches ODER
Verknüpft zwei Aussagen. Liefert true,
wenn eine der beiden Aussagen true
sind.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
6
niedrig
hoch
Rangfolge der Operatoren in
Java
. [] ()
++ -- ! ~ instanceof
new (data type)
*/%
+<< >> >>>
<>
== !=
&
^
|
&&
||
?:
+= -= *= = &= ^=
&= = <<= >>= >>>=
• Die Operatoren oben in der Tabelle
werden zuerst ausgewertet.
• Operatoren in der gleichen Zeile
haben die gleiche Rangfolge und
werden von links nach rechts
ausgewertet.
Beim Ausdruck y = 6 + 4/2 wissen
Sie jetzt anhand der Tabelle, dass
die Division vor der Addition
ausgewertet wird, deshalb ergibt
sich für y ein Wert von 8.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
7
Verkürzte Schreibweise
•
•
•
•
x+=4;
// x=x+4;
x*=10;
// x=x*10;
++a;
// a=a+1;
--a;
// a=a-1;
Achtung: a++ hat eine andere Funktionsweise als ++a
• m=n++; ist wie m=n; n++;
• m=++n; ist wie n++; m=n;
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
8
Der Zuweisungsoperator
(primitive Datentypen) 1
• Operator: =
• Syntax:
Operand1 = Operand2
Weist dem Operanden auf der linken Seite den
Wert des Operanden auf der rechten Seite zu.
• Beispiele:
• Variableninitialisierung: int i = 2;
• Arithmetische Operationen: i = i + 2;
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
9
Der Zuweisungsoperator
(primitive Datentypen) 2
Primitive Datentypen:
Zuweisung des Wertes
entspricht der Kopie des
Wertes in die neue
Variable.
var1
5
kopiere 5
var2
var2 = var1;
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
5
10
Der Zuweisungsoperator
(primitive Datentypen) 3
...
int i1 = 19; // i1 = 19
int i2 = 47;
// i2 = 47
i1 = i2;
// i1 = 47
i1 = 27+13;
// i1 = 40
i2 = 88;
// i2 = 88
...
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
11
Der Vergleichsoperator
(Primitive Datentypen)
...
int i1 = 19;
int i2 = 19;
boolean b = i1 == i2;// b ist true
boolean c = i1 <= 9; // c ist false
...
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
12
Logische Operatoren
(Primitive Datentypen)
Logisches UND &&
Logischen ODER ||
Negation
!
(2x AltGr <)
int x = 10;
boolean norm = (x >= 9 && x <= 11);
boolean result = (0<= x && x <= 10
|| 100 <= x && x <= 110);
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
13
Logische Operatoren
b1
true
OR
NOT
AND
!b1 b1 && b2 b1 || b2
b2
true false
true
true
false
true
true
false
true
false false true
false
false
true false false
false true
Wahrheitstabelle
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
14
Nach dieser Einheit sollten Sie ...
• Zuweisungsoperator, Vergleichsoperator und logische
Operatoren kennen.
• Die Reihenfolge ihrer Ausführung kennen.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
15
Java Einführung
ABLAUFSTEUERUNG
Kapitel 3 und 4
Inhalt dieser Einheit
Merkmale und Syntax der
verschiedenen Kontrollstrukturen:
• if else
• switch
• while
• do while
• for
• break, continue
EXKURS: Rekursion
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
2
Kontrollstrukturen
• Alle Kontrollstrukturen eines Programms basieren auf
Zustandsüberprüfungen, die die Werte true oder
false liefern.
z.B. PIN-Überprüfung des ATM:
Wenn der richtige PIN eingegeben wurde, dann wird
die Abhebung erlaubt, andernfalls verweigert.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
3
Kontrollstrukturen
Verschiedene Arten von Kontrollstrukturen
•
•
•
•
Verzweigungen: if else, switch
Iterationen: while, do while, for
Sprunganweisungen: continue, break
Exception Handling*:
(try | catch |finally) throw
*wird später behandelt!
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
4
if
TRUE
statements
block 1
In der hier dargestellten
Anwendung wird eine
FALSE Bedingung überprüft (boolbool-expr
expr). Ist diese erfüllt (true),
dann wird der unter statement1
beschriebene Programmcode
ausgeführt, anschließend wird
das Programm mit statement
fortgesetzt. Ist die Bedingung
nicht erfüllt (false), dann wird
statements
das Programm sofort mit
statement fortgesetzt.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
5
if
Syntax und Beispiel
TRUE
Balance>100000
reicheKunden++
statements
FALSE
JavaSyntax:
if (bool-expr) {
statements1;
}
z.B:
if (balance>100000){
reicheKunden++;
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
6
if-else
In der hier dargestellten
Anwendung wird eine Bedingung
überprüft (bool-expr). Ist diese
erfüllt (true), dann wird der unter
TRUE
FALSE
statement1 beschriebene
bool-expr
Programmcode ausgeführt,
anschließend wird das Programm
statements1
statements2 mit statement fortgesetzt. Ist die
Bedingung nicht erfüllt (false),
wird der unter statement2
beschriebene Programmcode
statements
ausgeführt, anschließend wird das
Programm mit statement
fortgesetzt.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
7
if-else
Syntax und Beispiel
FALSE
TRUE
Pin==inputPin
Stimmt=true
Fehlversuche++
statements
JavaSyntax:
if (bool-expr) {
statements1;
} else {
statements2;
}
z.B:
if (pin==inputPin){
stimmt = true;
} else {
fehlversuch++;
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
8
if-else
Beispiel
In der hier dargestellten Anwendung wird eine Bedingung überprüft (bool-expr1).
Ist diese erfüllt (true), dann wird der unter statement1 beschriebene
Programmcode ausgeführt, anschließend wird das Programm mit statement
fortgesetzt. Ist die Bedingung bool-expr1 nicht erfüllt (false), dann wird eine
weitere Bedingung (bool-expr2) überprüft.
FALSE
TRUE
bool-expr1
FALSE
TRUE
bool-expr2
statement1
statement2
statement3
Ist diese Bedingung erfüllt, dann wird
der unter statement2 beschriebene
Programmcode ausgeführt,
anschließend wird das Programm mit
statement fortgesetzt. Andern-falls wird
der unter statement3 beschriebene
Programmcode ausgeführt und das
Programm mit statement fortgesetzt.
statement
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
9
if-else
Beispiel
if-else kann beliebig tief
verschachtelt werden.
FALSE
TRUE
bool-expr1
TRUE
bool-expr2
statement1
statement2
statement
FALSE
statement3
...
if (bool-expr1) {
statement1;
} else if (bool-expr2) {
statement2;
} else {
statement3;
}
statement;
...
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
10
switch
switch
TRUE
case 1
statement1
FALSE
TRUE
case 2
FALSE
statement2
...
default
statement
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
11
switch (forts.)
1. An die switch – Anweisung wird eine Variable (integral selector)
übergeben (z.B. int)
2. case1 überprüft ob der Wert der Variable mit dem angegebenen
Wert übereinstimmt.
3. Ist dies der Fall, dann wird die Anweisung in statement1
ausgeführt.
4. Dann überprüft case2 ob der Wert der Variable mit dem
angegebenen Wert übereinstimmt.
5. Ist dies der Fall, dann wird die Anweisung in statement2
ausgeführt.
6. Dann wird der Vergleich der Variablen in case3 analog fortgesetzt.
7. Ist keine der angegebenen Bedingungen erfüllt, dann werden die
Anweisungen vom Default-Zweig ausgeführt. (Der Default-Zweig ist
optional)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
12
switch - Syntax
switch
TRUE
case 1
statement1
FALSE
case 2
TRUE
statement2
FALSE
...
default
statement
switch(integral-selector){
case integral-value1:
statement1; break;
case integral-value2:
statement2; break;
...
default: statement;
}
(break verhindert, dass alle
restlichen Statements
ausgeführt werden.)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
13
switch (Bsp.)
int month = 12;
switch (month) {
case 1: System.out.println("Jan"); break;
case 2: System.out.println("Feb"); break;
…
case 12: System.out.println("Dec"); break;
default: System.out.println("error"); break;
}
(implizit: Wenn month == 1, dann gibt „Jan“ aus!)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
14
Iterationen
• Mit Iterationen (=Schleifen) kann der Programmfluss von
Anweisungen, die mehrmals hintereinander durchgeführt
werden sollen, gesteuert werden.
• Die Schleifen werden solange durchlaufen, bis ein
Abbruchkriterium erfüllt ist.
• Das Abbruchkriterium befindet sich am Kopf oder am Fuß
der Schleife.
z.B. PIN-Eingabe des Kunden:
Fordere den Kunden zur Eingabe der PIN auf, bis die richtige PIN bzw.
3* eine falsche PIN eingegeben wurden.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
15
while
While-Schleife
bool-expr
FALSE
Die Anweisungen der while-Schleife
werden ausgeführt, solange die boolexpr erfüllt (=true) ist. Die
Überprüfung der Bedingung findet am
Anfang der Schleife statt.
TRUE
statements 1
statements
JavaSyntax:
while (bool-expr){
statements1;
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
16
while
Beispiel
FALSE
i<zielWert
int zielWert = 100;
int i = 1;
while (i < zielWert) {
System.out.print("i="+i+“,“);
i++;
}
TRUE
Print; i++
Ausgabe: i=1,i=2,i=3,…,i=99
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
17
do-while
Die Anweisungen der do-while-Schleife
werden ausgeführt, bis die bool-expr
nicht mehr erfüllt ist. Die Überprüfung
der Bedingung findet am Ende der
Schleife statt. Sie wird somit mindestens
einmal durchlaufen.
statement1
TRUE
bool-expr
FALSE
JavaSyntax:
do {
statement1;
} while (bool-expr)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
18
do-while
Beispiel
int zielWert = 1000;
int i = 1;
do {
System.out.println("i="+i+“,“);
i++;
} while (i < zielWert);
Print; i++
TRUE
Ausgabe: i=1,
i=2,
i=3, …
i=999,
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
i<zielWert
FALSE
19
for
initialization
step
statements
bool-expr
FALSE
Die Anweisungen der
for-Schleife werden aus-geführt,
solange die bool-expr erfüllt ist. Sie
wird idR eingesetzt, um eine
bekannte, d.h. im vorhinein
festgelegte Anzahl von Schritten mit
einem Zähler durchzuführen.
TRUE
JavaSyntax:
for (initialization; bool-expr; step){
statements;
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
20
for
Beispiel
int zielWert = 4;
for (int i = 1; i < zielWert; i++) {
System.out.println(i+“,“);
}
i=1
step
Ausgabe: 1,
2,
3,
print
i<zielWert
TRUE
FALSE
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
21
For (Ergänzung)
Java Syntax bei Verwendung von mehreren Zählvariablen
(gleichen Typs!):
for (initialization; bool-expr; step) {
statements; }
for (int i=0, j=10; i<=10; i++,j--) {
System.out.println(“i=“ + i + “ i inkrementiert“);
System.out.println(“j=“ + j + “ j dekrementiert“);
}
Ausgabe:
i=0 i inkrementiert
j=10 j dekrementiert
i=1 i inkrementiert
i=9 j dekrementiert
…
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
22
Endlosschleifen
Problemfall: Endlosschleifen
(Abbruchbedingung kann nie erfüllt werden!)
for (int i=2; i>=1; i = i + 2) {
System.out.println(i);
}
i = 10
while (i >= 1){
System.out.println(i);
i++;
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
23
Endlosschleifen 2
Soll eine Endlosschleife programmiert werden:
while (true) {
// Code
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
24
Iterationen Überblick
Abfrage
Durchlauf
Anzahl der
Durchläufe
while
zu Beginn
0, 1 oder
mehrmals
unbestimmt
do-while
am Ende
1 oder
mehrmals
unbestimmt
for
zu Beginn
0, 1 oder
mehrmals
festgelegt
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
25
for
Beispiel Fakultät
Berechnen der Fakultät n! = 1*2*3*…*n einer Zahl
mittels For-Schleife:
class Fakultaet{
public static void main(String[] arg){
int n = 20;
long f = 1;
for(long i = 2; i<=n; i++){
f = f * i;
}
System.out.println(n + "! = "+ f);
}
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
26
Sprunganweisungen
Sprunganweisungen können in allen Schleifen
verwendet werden:
break
bricht die Schleife ab
continue setzt die Schleife mit dem nächsten
Durchgang fort, d.h. der Rest dieses einen Durchgangs
wird übersprungen.
Um Lesbarkeit und Nachvollziehbarkeit des Codes zu
gewährleisten empfehlen wir, Sprunganweisungen nicht
einzusetzen!
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
27
Sprunganweisungen Beispiel
class Sprung {
public static void main (String[] args) {
int i=0,j=0;
while(i<10){
i++;
System.out.println("1. "+ i);
if(i==7) break;
}
while(j<10){
j++;
if(j<7) continue;
System.out.println("2. "+j);
}
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
Ausgabe:
1. 1
1. 2
1. 3
1. 4
1. 5
1. 6
1. 7
2. 7
2. 8
2. 9
2. 10
28
Nach dieser Einheit sollten Sie ...
• die Möglichkeiten bedingter Anweisungen
kennen,
• die verschiedenen Schleifen kennen,
• ihre Eignung für spezielle Anforderung
kennen,
• und alle Konstrukte in eigenen Programmen
anwenden können.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
29
Lernkontrolle
Schreiben Sie ein kleines Programm, dass zu
arabischen Zahlen die entsprechende römische Zahl
ausgibt. Verwenden Sie dazu verschiedenartige
Kontrollstrukturen.
Anleitung: Beginnen Sie zuerst mit einer vereinfachten
Problemstellung (I, V, X) und erweitern Sie diese
später.
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
30
Lernkontrolle
Fibonacci Sequence
Versuchen Sie die Ausgabe dieses Programms zu ermitteln.
class Fibonacci {
public static void main (String[] args) {
/** Ausgeben der Fibonacci Zahlen kleiner 50 */
int lo = 1;
int hi = 1;
System.out.println(lo);
while (hi < 50) {
System.out.println(hi);
hi = lo + hi;
lo = hi - lo;
}
}
}
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
31
Exkurs: Rekursion*
* benötigt Methoden, die später durchgenommen werden
Methode
bool-expr
FALSE
TRUE
Die Rekursion stellt eine Alternative
zur Verwendung von Schleifen dar.
Rekursion bezeichnet den Aufruf der
eigenen Methode mit anderem
Parameter. Analog zu den Schleifen
darf dieser Aufruf nur dann
durchgeführt werden, wenn eine
bestimmte Bedingung erfüllt ist.
Methodenaufruf
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
32
Rekursion-Beispiel
Berechnen der Fakultät einer Zahl mittels Rekursion
(siehe Fakultaet.java):
static int fakulRekursiv(int i){
if (i > 1) return i * fakulRekursiv(i-1);
else return 1;
}
(Kapitel 14 in „Sprechen Sie Java“)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
33
Rekursion-Beispiel (forts.)
Aufruf
Rückgabe: 6
fakulRekursiv(3)
Aufruf
Rückgabe: 2
fakulRekursiv(3-1)
Aufruf
Rückgabe: 1
fakulRekursiv(2-1)
Grundzüge der Programmierung - Hahsler, Guth, Kaukal, Klimesch
34
Java Einführung
Methoden
Kapitel 6
Inhalt
• Deklaration und Aufruf von Methoden
• Lokale und globale Namen (Bezeichner)
• Sichtbarkeit und Lebensdauer von Variablen in
Methoden
• Überladen von Methoden
Grundzüge der Programmierung - Hahsler
2
Methoden
• Methoden gehören logisch zusammen und lösen
einen bestimmte Teilaufgabe.
• Methoden werden zur Lösung der Teilaufgabe
aufgerufen.
• In Klassen werden Methoden
eingesetzt um das Verhalten der
Klasse abzubilden.
Grundzüge der Programmierung - Hahsler
KlassenName
-Variablen
+Methoden()
3
Deklaration von Methoden
• Methoden haben eine Namen (Bezeichner) wie
Variablen.
• Methoden haben Parameter. Das sind Werte, die beim
Aufruf einer Methode übergeben werden.
static void printMax (int x, int y) {
if (x>y) {
System.out.print(x)
} else {
System.out.print(y)
}
Signatur
}
Grundzüge der Programmierung - Hahsler
4
Aufruf von Methoden
Durch Angabe von Name und Parameter der Methode:
public static void main (String[] arg) {
int a=5;
printMax (a, 9);
}
void printMax (int x, int y){
if(x>y) {
...
}
Beim Aufruf wird den formellen Parametern (x, y) der Wert der
aktuellen Parametern (a, 9) zugewiesen. x und y können nur in
der Methode printMax verwendet werden.
Grundzüge der Programmierung - Hahsler
5
Deklaration von Methoden mit
Rückgabewert
static int max (int x, int y) {
if (x>y) {
return(x);
} else {
return(y);
}
}
• Der Rückgabewert ist hier als int definiert.
• return legt den Rückgabewert fest und verlässt die
Funktion.
• Es kommen alle Datentypen für den Rückgabewert in
Frage. Das Schlüsselwort void bedeutet: kein
Rückgabewert
Grundzüge der Programmierung - Hahsler
6
Aufruf von Methoden mit
Rückgabewert
Durch Angabe von Name und Parameter der Methode:
public static void main (String[] arg) {
int a=15; int maximum;
maximum = max(a, 9);
System.out.println(maximum);
}
int max (int x, int y){
if(x>y) { return(x); }
else { return(y); }
}
Bei der Rückgabe wird der Rückgabewert (Wert von x, 15) als Ergebnis
der Funktion max(15,9) der Variable maximum zugewiesen.
Grundzüge der Programmierung - Hahsler
7
Beispiele: Aufrufen von
Methoden
// Def. der Methode max von der vorherigen Folie
int a=15; int m;
m = max(a/5,9);
m = max(a,7) + 19
if (max(-a,23) == 35) { ... }
Grundzüge der Programmierung - Hahsler
8
Rückgabewerte
• Als Rückgabewert ist ein einzelnes Element
eines Datentyps (auch eine Instanz) möglich.
z.B.:
int addiere(int a, int b) {...}
• Hat die Methode keinen Rückgabewert, wird das
Schlüsselwort void verwendet.
z.B.:
void ausgeben(String text) { ...}
Grundzüge der Programmierung - Hahsler
9
Lokale Namen
• Lokale Namen (Methoden, Variablen) sind nur in
der Methode (im Block) verfügbar, in der sie
deklariert wurden
static void macheWas(int x) {
int y;
// x und y sind nur in dieser Methode verfügbar
...
}
Grundzüge der Programmierung - Hahsler
10
Gültigkeitsbereich von
Variablen
•
Gültigkeitsbereich: ist jener Bereich im
Programm, in dem auf eine Variable über den
Namen zugegriffen werden kann
1. Sichtbarkeit: Block (+ Unterblöcke), in dem die
Variable deklariert wurde.
2. Lebensdauer: werden bei betreten des Blocks
angelegt und bei Verlassen wieder freigegeben.
Grundzüge der Programmierung - Hahsler
11
Bsp: Sichtbarkeit und Lebensdauer
class Prog {
static int x;
static int y;
...
static void machen(){
int x;
while(...) {
int z;
}
}
}
„Global“
x in Klasse
Verdeckt
(Sichtbarkeit)
y
Grundzüge der Programmierung - Hahsler
x
lokal
z
Lebensdauer
12
Überladen von Methoden
• Allgemein gilt: In einem Block deklarierte Namen müssen
unterschiedlich sein. Bei Methoden gibt es eine
Ausnahme:
Zwei Methoden dürfen den gleichen Namen haben, wenn
sich durch ihre Parameterliste (Art und Anzahl)
unterscheidet. Rückgabewert und Name der
Parametervariablen sind egal beim Überladen egal!
static void print (int x) { ... }
static void print (double x) { ... }
static void print (int x, int y) { ... }
Grundzüge der Programmierung - Hahsler
13
Bsp: Aufruf überladener Methoden
class MaxProgramm {
static int max (int x, int y) {
if (x>y) { return(x); } else { return(y); }
}
static int max (int x, int y, int z) {
int max;
max = max(z, max(x,y));
return max;
}
public static void main (String[] arg) {
System.out.println(max(45,13,98));
}
}
Die richtige Methode wird beim Aufruf über die Signatur automatisch
ausgewählt.
Grundzüge der Programmierung - Hahsler
14
Fehler beim Überladen von Methoden
1.
2.
3.
4.
static
static
static
static
int addiere (int a, int b) {...}
int addiere (int a, int b, int c) {...}
double addiere (double a, double b) {...}
double addiere (int x, int y) { ... }
Die Methoden in Zeile 1 und 4 können nicht gemeinsam
deklariert werden, da beide die gleiche Signatur
addiere(int,int) haben. Der Compiler bricht die
Übersetzung mit einer Fehlermeldung ab.
Grundzüge der Programmierung - Hahsler
15
Nach dieser Einheit sollten Sie ...
• Methoden deklarieren und aufrufen können
• Über die Sichtbarkeit und Lebensdauer von
Variablen bescheid wissen
• Das überladene von Methoden kennen
Grundzüge der Programmierung - Hahsler
16
Java Einführung
Arrays
Kapitel 7
Inhalt
• Eindimensionale Arrays
•
•
•
•
Erzeugung
Benutzung
Zuweisung
Beispiel
• Mehrdimensionale Arrays
Grundzüge der Programmierung - Hahsler
2
Arrays
• Oft benötigt man nicht nur Einzelwerte (eine
Variable) sondern eine Wertemenge, die
gemeinsam verarbeitet werden
• Wertmengen werden oft in Tabellen oder Listen
angeordnet
• Ein Array ist eine Tabelle von gleichartigen
Elementen (Zahlen, Zeichen,...)
Grundzüge der Programmierung - Hahsler
3
Eindimensionales Array
a[0] a[1] a[2] a[3]
...
a[9]
...
a
• Ein Array hat einen Namen (a)
• Die einzelnen Elemente können durch den Index
([0],[1],...) angesprochen werden
• Die einzelnen Elemente verhalten sich wie
namenlose Variablen
• Die Größe wird einmal festgelegt und ist dann fix.
Grundzüge der Programmierung - Hahsler
4
Erzeugung eines Arrays
• Deklaration des Namens (Arrayvariable, Zeiger)
int[] a;
float[] vector;
• Erzeugung des Arrays
a = new int[5]; // Array mit Index 0...4
a
Name
a[0] a[1] a[2] a[3] a[4]
Array
Grundzüge der Programmierung - Hahsler
5
Benutzung eines Arrays
• Arrayelemente werden durch den Index angesprochen
und können wie normale Variablen verwendet werden
int i=1, j=3;
a[3]=0;
a[2*i+1]=a[j]; // i und j sind int
a[max(i,j)]=100; // max ist eine Fkt.
• Zur Laufzeit wird geprüft ob der verwendete Index gültig
ist (ob es das Element gibt)
• a.length enthält die Länge des Arrays
Grundzüge der Programmierung - Hahsler
6
Zuweisung eines Arrays
• Einer Arrayvariable (Name des Arrays) dürfen alle
Arrays des passenden Typs zugewiesen werden
a
int[] a;
a=new int[5];
int[] b;
a[0] a[1] a[2] a[3] a[4]
0
0
0
0
b
null
a
a[0] a[1] a[2] a[3] a[4]
0
b=a;
0
b
0
0
0
0
b[0] b[1] b[2] b[3] b[4]
a und b sind zeigen auf
(referenzieren) das gleiche Array!
Grundzüge der Programmierung - Hahsler
7
Freigabe von Arrays
• Java verwendet zur Freigabe von Speicher eine
automatische Speicherbereinigung (Garbage
Collection)
• Wenn kein Zeiger (Arrayvariable) mehr auf das
Array zeigt, wird das Array gelöscht
• die Arrayvariable wird verändert a=null; oder a=b;
• die Arrayvariable verlässt den Bereich ihrer Lebensdauer
Grundzüge der Programmierung - Hahsler
8
Initialisierung von Arrays
• Arrays können schon bei der Deklaration
initialisiert werden
int[] primes = {2, 3, 5, 7, 11};
• Später können die Elemente nur noch einzeln
(über den Index) zugewiesen werden
Grundzüge der Programmierung - Hahsler
9
Typische Schleife für Arrays
class Primes {
public static void main (String[] args) {
int[] primes = {2, 3, 5, 7, 11};
for (int i = 0; i < primes.length; i++) {
System.out.print(primes[i] + " ");
}
}
}
Grundzüge der Programmierung - Hahsler
10
Bsp: Sequentielle Suche
• Bei der sequentiellen Suche werden alle Elemente
durchgegangen, bis das richtige Element gefunden wird
static int search(int[] a, int x) {
int pos = a.length-1;
while (pos>=0 && a[pos]!=x) { pos--;}
return pos;
}
static void main (String[] args) {
int[] b= { 27, 11, 19};
Achtung: das Array wird nicht kopiert,
int c= search(b,11);
es wird nur eine "Referenz" auf das
Array übergeben!
}
11
Grundzüge der Programmierung - Hahsler
Mehrdimensionales Array
• Mehrdimensionale Arrays sind Arrays von
Arrays
• Bsp: Zweidimensionales Array (Matrix)
int[][] a = new int[2][3];
a[0][0] a[0][1] a[0][2]
a
a[0]
a[1][0] a[1][1] a[1][2]
a[1]
Grundzüge der Programmierung - Hahsler
12
Benutzung Mehrdimensionaler Array
• Initialisierung
int[][] a = {
{1, 2, 3}
{4, 5, 6}
};
• Länge
a.length
// Zeilen
a[0].length // Spalten
Grundzüge der Programmierung - Hahsler
13
Nach dieser Einheit sollten Sie ...
• Arrays erzeugen und über den Index benutzen
können
• Wissen was der Arrayname ist und was bei der
Zuweisung von Arraynamen passiert
Grundzüge der Programmierung - Hahsler
14
Herunterladen
Explore flashcards
Study collections