Programmier-sprache

Java

Das einfachste Programm:

public class MainProgAufbau1 { public static void main (String[] args){

}}

HauptprogrammKopf

Rumpf

Begrenzer (Block)

Zwischen der öffnenden und der schließenden geschweiften Klammer kommen die

Anweisungen, hier keine. Diese müssen mit Semikolon beendet werden.

Das ganze Programm muss innnerhalb einer sogenannten Klasse stehen (Näheres dazu später).

public static void main (String[] args){ in eine Zeile schreiben. Aus Platzgründen wurden hier 2 Zeilen benötigt.

public class MainProgAufbau1 { public static void main (String[] args){

}}

Reservierte Worte; sollen nicht vom Programmierer für Variablennamen

vergeben werden

Ein reines Ausgabe - Programm:

public class MainProgAufbau1 { public static void main (String[] args){

System.out.println("Hallo Welt"); }}

Der auf dem Bildschirm ausgegebene Text ist eine Zeichenkette. Diese steht immer zwischen Anführungszeichen. Auf dem Bildschirm erscheint also:Hallo Welt

Anweisungen einrücken

Semikolon am Ende einer jeden Anweisung

public class MainProgAufbau1 { public static void main (String[] args){

System.out.println("Hallo Welt"); }}println bedeutet, dass nach der Ausgabe auf dem Bildschirm der Kursor einen Zeilenvorschub macht, d.h der Kursor steht auf der nächsten Zeile in der ersten Spalte.

public static void main (String[] args){ in eine Zeile schreiben. Aus Platzgründen wurden hier 2 Zeilen benötigt.

public class MainProgAufbau1 { public static void main (String[] args){

System.out.println("Hallo Welt"); }}Den Parameter können wird für unsere Zwecke auch weglassen und nur schreiben:public static void main()

Ein Ein /Ausgabe - Programm:

import java.io.*;

public class MainEingabe1 { public static void main(String[] args)

throws IOException{ String mystr; BufferedReader myinput = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Bitte Text eingeben"); mystr = myinput.readLine(); System.out.println("Der Text heisst:"+mystr); }}

Alles jeweils in eine Zeile. Hier ist es aus Platzgründen nicht möglich.

import java.io.*;

public class MainEingabe1 { public static void main(String[] args)

throws IOException{ String mystr; BufferedReader myinput = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Bitte Text eingeben"); mystr = myinput.readLine(); System.out.println("Der Text heisst:"+mystr); }}

Einige Bezeichnungen werden erst sehr viel später erklärt und müssen jetzt einfach so hingenommen und akzeptiert werden.Ein paar Bezeichnungen werden allerdings hier jetzt schon geklärt...

import java.io.*;

public class MainEingabe1 { public static void main(String[] args)

throws IOException{ String mystr; BufferedReader myinput = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Bitte Text eingeben"); mystr = myinput.readLine(); System.out.println("Der Text heisst:"+mystr); }}

Deklarationsteil = Zutaten

Typ

Variablenname

Variable

Anweisungsteil = Zubereitung

Einzelne Anweisungen im Anweisungsteil (enden mit einem Semikolon)

import java.io.*;

public class MainEingabe1 { public static void main(String[] args)

throws IOException{ String mystr; BufferedReader myinput = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Bitte Text eingeben"); mystr = myinput.readLine(); System.out.println("Der Text heisst:"+mystr); }}

Der Typ String bedeutet, dass die Variable Zeichenketten speichert.

import java.io.*;

public class MainEingabe1 { public static void main(String args[]) throws IOException{ String mystr; BufferedReader myinput = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Bitte Text eingeben"); mystr = myinput.readLine(); System.out.println("Der Text heisst:"+mystr); }}

Kurz (näheres viel später):Im Anweisungsteil wird ein sogenanntes Objekt (mit dem vom Programmierer frei gewählten Namen myinput) des

Typs BufferedReader erzeugt. Da dieser Typ dem Compiler unbekannt ist, muss er "importiert" werden.

Die Methode (Unterprogramm) readline speichert die über Tastatur eingegebene Zeichenkette in der Variablen mystr.

Es wird auf dem Bildschirm die Zeichenkette Der Text heisst: ausgegeben UND der Wert der Variablen mystr

Elemente des

Rumpfs:

... int z; String mystr; int b,c,d; ...

Variable

Typ: int int ist Abkürzung für integer

(bedeutet ganze Zahl)

Der Variablenname soll selbstsprechend bzw. selbsterklärend sein. Also sollte man z.B. eine Variable, die die Breite eines Rechtecks speichert auch breite nennen und NICHT wie hier (aus Platzgründen) nur mit einem Buchstaben benennen !

mehrere Variablen können auch durch Kommata getrennt werden.

Aber am Ende muss ein Semikolon kommen.

Der Typ gibt an, welche Werte (z.B. ganze Zahlen) eine Variable annehmen kann.

... int z; String mystr; int b,c,d; ...

Primitiver Datentyp

Klassentyp

Es gibt verschiedene Typen:- primitive (elementare) Datentypen (z.B. ganze Zahlen), - Klassentypen (z.B. String)

näheres später

... int z=123; int a; int b,c,d; ...

z wird mit dem Wert 123 initialisiert.

Eine Variable kann deklariert und gleichzeitig auch initialisiert (vorbelegt) werden

Eine Variable kann während des Programmlaufs unterschiedliche Werte annehmen.

Eine Variable muss vor ihrer Verwendung im Deklarationsteil vereinbart werden.Eine Variable hat einen Namen und einen Typ.

Variable sind Daten mit folgenden Eigenschaften:

Unter einer Variablen kann man sich einen Behälter vorstellen.In diesem Behälter wird ein Wert gespeichert (z.B. eine bestimmte Menge Flüssigkeit). Diese Menge bleibt solange konstant in diesem Behälter, solange sie nicht verändert wird. Diese Eigenschaft nennt man speichern. Es "verdunstet" deshalb auch nichts.

Bitte folgende Regel einhalten:Anfangsbuchstabe eines Variablennamens immer klein schreiben. Dies ist dem Compiler zwar egal, doch an diese Regel halten sich alle Programmierer.

Ein weiteres Ein /Ausgabe -

Programm:

import java.io.*;

public class MainEingabe1 { public static void main(String args[]) throws IOException{ String mystr; int z; BufferedReader myinput = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Bitte Zahl eingeben"); mystr = myinput.readLine(); // gleich geht es weiter

Hier wird noch die Variable z deklariert.

Dies ist ein Kommentar, der vom Compiler ignoriert wird und nur für den Programmierer wichtig ist. Er beginnt mit // und gilt für die

ganze Zeile

import java.io.*;

public class MainEingabe1 { public static void main(String args[]) throws IOException{ String mystr; int z; BufferedReader myinput = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Bitte Zahl eingeben"); mystr = myinput.readLine(); // gleich geht es weiter

z ist nicht selbsterklärend. Bitte einen selbstsprechenden Variablennamen wie z.B. zahl verwenden (hier fehlt leider der Platz!).

z=Integer.parseInt(mystr); z=z*z; System.out.println("Das Quadrat ist" +z); }}

Die Methode parseInt macht aus der Zeichenkette mystr eine ganze Zahl. Diese wird in z gespeichert.

Es wird auf dem Bildschirm die Zeichenkette "Das Quadrat ist" ausgegeben UND der Wert der Variablen z

Zuweisungsoperation (Näheres in der übernächsten Folie)

System.out.println("z=+z");

z=+z

Frage:Was gibt die folgende Anweisung auf dem Bildschirm aus ?

Der Compiler erkennt das z nicht als eine Variable, sondern als einen “normalen“ Buchstaben !

Er gibt die komplette Zeichenkette (also alles was sich zwischen den Anführungszeichen befindet) auf dem

Bildschirm aus.

Zuweisungsoperation:

Der Variablen links des Gleichheitszeichens = wird der Wert rechts des Gleichheitszeichens zugewiesen. LEIDER benutzt der Entwickler der Programmiersprache Java statt des Zeichens := das Gleichheitszeichen, obwohl es sich ...

um eine Zuweisung und nicht um eine Gleichheit handelt. Dem Entwickler der Programmiersprache Java ist dies offensichtlich egal. Die Syntax gibt er vor und das Gleichheitszeichen hat bei ihm die Semantik von :=

Beispiele:

y=10;z=y;z=y+2;y=z;z=z+1;

Dynamische Entwicklung der Inhalte der Variablen y und z:

10 ?y z

10 1010 1212 1212 13

Die Ausführung der Anweisungen des letzten Ein- bzw. Ausgabeprogramms detailliert erklärt:

Was bewirken die einzelnen Anweisungen des gerade vorgestellten Programms ?System.out.println("Bitte Zahl eingeben");

mystr = myinput.readLine();

z = z * z;

System.out.println ("Das Quadrat ist:"+z);

z=Integer.parseInt(mystr);

Was bewirkt also:

Es wird auf dem Bildschirm der Text "Bitte ganze Zahl eingeben" ausgegeben und dann ein Zeilenumbruch gemacht.

System.out.println("Bitte Zahl eingeben");

Was bewirkt also:

Das Programm hält an und der Benutzer muss über Tastatur eine ganze Zahl eingeben und mit dem Drücken der Return-Taste diese Eingabe beenden (erst dann macht das Programm weiter). Die eingegebene Zahl wird in der Variablen z gespeichert.Wir nehmen hier an, dass der Benutzer die Zahl 5 eingegeben hat.

mystr = myinput.readLine();

Was bewirkt also:

Die über Tastatur eingegebene Zeichenkette (z.B. 1234) wird in die dazugehörige Zahl 1234 umgewandelt und in der Variable z mit dem Datentyp integer gespeichert.

z=Integer.parseInt(mystr);

Was bewirkt also:

z = z * z;

Der Wert der Variablen z (hier also 5) wird mit sich selbst multipliziert (ergibt hier also 25) und wiederum in der Variablen z abgespeichert. Der Wert der Variablen z ist hier also vor der Ausführung der Anweisung 5 und nach der Ausführung 25.

Was bewirkt also:

Es wird folgendes auf dem Bildschirm ausgegeben:

System.out.println ("Das Quadrat ist:"+z);

Das Quadrat ist: 25

Aufgabe:Ein Schreiner will von einer rechteckigen Holzplatte den Flächeninhalt und den Umfang (für die Umleimer) bestimmen.Schreiben Sie dazu ein Programm.

import java.io.*;public class Maintest1{ public static void main(String args[])

throws IOException{ int l; // Länge int b; // Breite // nicht so gut (keine Dokumentation):  int u,f; String mystr; BufferedReader myinput = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Bitte Länge eingeben");

alles in der gleichen Zeile rechts von // wird als Kommentar aufgefasst und vom Compiler nicht berücksichtigt.

mystr = myinput.readLine(); l=Integer.parseInt(mystr); System.out.println("Bitte Breite eingeben"); mystr = myinput.readLine(); b=Integer.parseInt(mystr); u=2*(l+b); f=l*b; System.out.println("Umfang="+u+ "Fläche="+f); }}

Angenomen, der Anwender gibt für die Breite den Wert 3 und für die Länge den Wert 4 ein. Wie sieht dann die Bildschirmausgabe aus?

Umfang=14Fläche=12

mystr = myinput.readLine(); l=Integer.parseInt(mystr); System.out.println("Bitte Breite eingeben"); mystr = myinput.readLine(); b=Integer.parseInt(mystr); u=2*(l+b); f=l*b; System.out.println("Umfang="+u+ "Fläche="+f); }}

Was müsste man an der Anweisung ändern, damit die folgende, optisch ansprechendere

Bildschirmausgabe erzeugt wird?

Umfang=14 Fläche=12

mystr = myinput.readLine(); l=Integer.parseInt(mystr); System.out.println("Bitte Breite eingeben"); mystr = myinput.readLine(); b=Integer.parseInt(mystr); u=2*(l+b); f=l*b;

}}

mystr = myinput.readLine(); l=Integer.parseInt(mystr); System.out.println("Bitte Breite eingeben"); mystr = myinput.readLine(); b=Integer.parseInt(mystr); u=2*(l+b); f=l*b; System.out.println("Umfang="+u+ " Fläche="+f); }}

Hier werden noch 2 Leerzeichen ausgegeben.

mystr = myinput.readLine(); l=Integer.parseInt(mystr); System.out.println("Bitte Breite eingeben"); mystr = myinput.readLine(); b=Integer.parseInt(mystr); u=2*(l+b); f=l*b;

}}

Was würden alternativ diese 2 Anweisungen ausgeben?

Umfang=14Fläche=12

Begründung: Nach jeder Ausgabe kommt ein Zeilenumbruch (println)

System.out.println("Umfang="+u");System.out.println("Fläche="+f");

Bei neueren Java-Versionen wird die Eingabe (mit Hilfe der Klasse Scanner) einfacher:

import java.io.*;import java.util.Scanner;public class MainEingabeScanner1{ public static void main() { int i1, i2; String s1, s2; Scanner tastatur = new Scanner(System.in); s1 = tastatur.next(); s2 = tastatur.next(); i1 = tastatur.nextInt(); i2 = tastatur.nextInt(); }}

Mit der Methode next kann man eine Zeichenkette über

Tastatur eingeben.

Mit der Methode nextInt kann man eine ganze Zahl

über Tastatur eingeben

In eine Zeile schreiben (hier aus Platzmangel

unmöglich)

Programmieren Sie das Schreinerei-Programm mit Hilfe der Klasse Scanner.

import java.io.*;import java.util.Scanner;

public class MainSchreinerei2{ public static void main(String[] args){ int breite; int laenge; int umfang; int flaeche; Scanner tastatur = new Scanner(System.in); System.out.println("Breite eingeben"); breite = tastatur.nextInt();

In eine Zeile schreiben (hier aus Platzmangel

unmöglich)

In eine Zeile schreiben (hier aus Platzmangel

unmöglich)

System.out.println("Länge eingeben"); laenge = tastatur.nextInt();

umfang = 2*(laenge+breite); flaeche = laenge*breite;

System.out.println("Umfange=" +umfang); System.out.println("Fläche= " +flaeche); }}In eine Zeile schreiben (hier aus Platzmangel

unmöglich)

In eine Zeile schreiben (hier aus Platzmangel

unmöglich)

Frage:Was ist der Nachteil dieser zweier Programme ?

Antwort:Es können nur ganzzahlige Werte eingegeben werden.

Wir machen deshalb einen kleinen Ausflug:

1 Byte = 8 Bit

Wie viele Zustände kann man mit 1 Byte

darstellen ?

Wie viele Zustände kann man mit 1 Byte darstellen ?

Zu schwierig ?Also beginnen wir mit

einem Bit

Wie viele Zustände kann man mit 1 Bit darstellen ?

1

0

und

also, Anzahl der Zustände: 2 * 1 = 2

Wie viele Zustände kann man mit 2 Bit darstellen ?

0

0

und

1

0

11

also, Anzahl der Zustände: 2 * 2 = 4

Also insgesamt

0 00 11 01 1

Wie viele Zustände kann man mit 3 Bit darstellen ?

0

0

und

0

also, Anzahl der Zustände: 2 * 4 =

...

1 1

4 Möglichkeiten

01

0...

1 1

4 Möglichkeiten

2 * 2 * 2 = 8

Also insgesamt0 0 00 0 10 1 00 1 11 0 01 0 11 1 01 1 1

Wie viele Zustände kann man mit 8 Bit darstellen ?

2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 = 28 = 256

Wie viele Zustände kann man mit 2 Byte darstellen ?

216 = 65536

2 Byte = 16 Bit

also:

Wie viele Zustände kann man mit 4 Byte darstellen ?

232 = 4294967296

4 Byte = 32 Bit

also:

Wie kann man dies schnell näherungsweise

ausrechnen ?

210 = 1024 1000 = 103 , also also: 210 103 220 = 210 · 2 = (210)2 (103)2 = 106

also: 220 106

230 = 210 · 3 = (210)3 (103)3 = 109

also: 230 109

240 = 210 · 4 = (210)4 (103)4 = 1012

also: 240 1012

Weitere Maßeinheiten für (große) Datenmengen:

103 Byte = 1 Kilobyte = 1 KB106 Byte = 1 Megabyte = 1 MB109 Byte = 1 Gigabyte = 1 GB1012 Byte = 1 Terabyte = 1 TB1015 Byte = 1 Petabyte = 1 PB1018 Byte = 1 Exabyte = 1 EB1021 Byte = 1 Zettabyte = 1 ZB1024 Byte = 1 Yottabyte = 1 YB

Wie kann man schnell näherungsweise

ausrechnen, wie viele Zustände man mit 2 Byte

bzw. 4 Byte darstellen kann, d.h. wie gross ist

216 und 232 ?

216 = 26+10 = 26 · 210= 64 · 210

64 · 103

also: 216 64103

232 = 22+30 = 22 · 230= 4 · 230 4 · 109

also: 232 4 109

Zurück zum primitiven (elementaren,

einfachen) Datentyp:

import java.io.*;

public class MainTest {

public static void main(){

int z; ... }}

Primitiver (elementarer) Datentyp

Der primitive (einfach, elementar) Datentyp einer Variablen legt fest, welche Werte eine Variable annehmen darf und in welchem Wertebereich sich diese Werte befinden dürfen.

Dieser Wertebereich hängt von der Anzahl der Bytes ab, in denen die Variable gespeichert wird.

Ganzzahlige

Datentypen

Diese können dargestellt werden durch:

Datentyp byte

Länge: 1 Byte

Wertebereich:-2^7...+2^7-1, also

-128...+127256 Zahlen auf positiven und negativen Bereich aufgeteilt

^ bedeutet hoch

Datentyp short

Länge: 2 Byte

Wertebereich:-2^16...+2^16-1, also

-32768...+32767

65536 Zahlen auf positiven und negativen Bereich aufgeteilt

Datentyp int

Länge: 4 Byte

Wertebereich:-2^32...+2^32-1, also

-2147483648...+2147483647

4294967296 Zahlen auf positiven und negativen Bereich aufgeteilt

Datentyp long

Länge: 8 Byte

Wertebereich:-2^63...+2^63-1, also

-9223372036854775808 ... 9223372036854775807

Datentyp char

Länge: 2 Byte

Wertebereich:0...2^16-1, also

0...+65535

Alle Unicode-Zeichen, z.B:A <---> 0041 (hexadezimal)Die ersten 128 Zeichen des Unicode entsprechen den ersten 128 Zeichen des ASCII-Zeichensatzes.

Warum braucht man Unicode bzw. ASCII-Code?

Zeichen

Ein Computer kann nur Zahlen speichern, keine Zeichen. Damit ein Zeichen gespeichert werden kann, wird ihm eine Zahl (ASCII-Wert) zugeordnet.

Da verschiedene Sprachen (z.B. chinesisch) sehr viele

Zeichen besitzen und nicht im ASCII-Zeichensatz

berücksichtigt werden, wurde ein neuer Zeichensatz definiert,

der sogenannte Unicode.

Die ersten 256 Plätze im Unicode entsprechen dem

Zeichensatz ISO Latein 1, wo auch der ASCII-Zeichensatz

untergebracht ist.

Beispiele für Zeichen

...

char x;

char y;

x = 'c';

y = 'A';

y = '\u0041';

...

Was würde der Compiler sagen, wenn die zwei Hochkommata

fehlen würden?

Er würde c als Variable auffassen. Da diese aber nicht deklariert (angemeldet) wurde, gibt er eine Fehlermeldung aus.

u steht für Unicode und die nachfolgende Zahl muss eine

Hexadezimalzahl sein.

Beispiele für Zeichen

...

char x;

char y;

x = 'c';

y = 'A';

y = '\u0041';

...

Diese zwei Anweisungen machren also genau das Gleiche!

Das ASCII-Zeichen des ASCII-Codes 41Hex ist nämlich A.

Bitte nachschauen

Mit Hilfe des Backslash (Gegenschrägstrich) kann man solche

Ersatzdarstellungen realisieren.

Manchmal braucht man diese Ersatzdarstellungen (Fluchtzeichenfolgen oder Escape-Sequenzen), weil man damit Steuerzeichen, oder Zeichen, die nicht auf dem Eingabegerät (Tastatur) vorhanden sind, darstellen, kann, wie zum Beispiel...

\n führt Zeilenvorschub durch (new line)\t setzt Horizontaltabulator\v setzt Vertikaltaltabulator\b geht Mit dem Kursor ein Zeichen zurück (backspace)\r führt Wagenrücklauf durch (carriage return)\f führt Seitenvorschub durch (form feed)\a löst Klingelzeichen aus (Alarm)\' Hochkomma\" Anführungszeichen\\ Gegenschrägstrich (Backslash)\u.. Mit u wird eine Unicode-Ersatzdarstellung eingeleitet.

Gleitpunkt

Datentypen

Können dargestellt werden durch:

Fließkommazahlen

(oder auch Gleitkommazahlen

genannt)

Können dargestellt werden durch:

Datentyp float

Länge: 4 Byte

Wertebereich:

-10^38...+10^38

Genauigkeit:

7 Stellen

Datentyp double

Länge: 8 Byte

Wertebereich:

-10^308...+10^308

Genauigkeit:

15 Stellen

Java wurde in den USA entwickelt.

Im amerikanischen Sprachraum schreibt man in

Kommazahlen statt des Kommas einen Punkt.

Deshalb gilt für die Syntax...

Beispiele für Gleitkommazahlen:

...double x;x = 3.1415;x = -4.67;x = 7.5e-23;x = E-45;...

7,5·10-23

10-45

3,1415

-4,67

Funktioniert genauso für float:

...float x;x = 3.1415;x = -4.67;x = -3.14e23;x = -E17;...

-3,14·1023

-1017

3,1415

-4,67

Boolescher Datentyp

wird dargestellt durch:

Datentyp boolean

Länge: ?

Wertebereich:

true, false

wird in der Logik verwendet (true – wahr, false – falsch)

Beispiele für boolsche Werte

...

boolean b1;

boolean b2;

b1 = true;

b2 = false;

...

Das

EVA

Prinzip

import java.io.*;

public class MainEingabe1 { public static void main(String args[]) throws IOException{ String mystr; int z; BufferedReader myinput = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Bitte Zahl eingeben"); mystr = myinput.readLine(); z=Integer.parseInt(mystr);

Eingabe

Verarbeitung

Ausgabe

// ... z=z*z; System.out.println("z="+z);

}}

Aufgabe:

Ersatzwiderstand von 2 parallel geschalteten

Widerständen berechnen.

import java.io.*;public class Maintest2{ public static void main(String args[]) throws IOException{ double R1; double R2; double ersatz; String mystr; BufferedReader myinput = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Bitte 1. Widerstand eingeben"); // gleich geht es weiter ...

Variablennamen normalerweise groß schreiben. Da R1 und R2 aus

Bezeichnungen aus der Physik sind, kann man es hier erlauben. Dem Compiler ist es zwar egal, doch sagt die Java-Community:

Variablennamen groß schreiben.

mystr = myinput.readLine(); R1=Double.parseDouble(mystr);

System.out.println("Bitte 2. Widerstand eingeben"); mystr = myinput.readLine(); R2=Double.parseDouble(mystr); ersatz=1/(1/R1+1/R2); System.out.println("Ers.widerstand=" +ersatz); }}

Weitere Lösung

import java.io.*;public class Maintest2{ public static void main(String args[]) throws IOException{ double R1; double R2; double ersatz; String mystr; BufferedReader myinput = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Bitte 1. Widerstand eingeben"); // gleich geht es weiter ...

Alles ist gleich wie in der letzten Lösung.

mystr = myinput.readLine(); R1=Double.parseDouble(mystr);

System.out.println("Bitte 2. Widerstand eingeben"); mystr = myinput.readLine(); R2=Double.parseDouble(mystr); ersatz=1/R1+1/R2;

System.out.println("Ers.widerstand=" +ersatz); }}

Alles ist immer noch gleich (bis auf eine Anweisung) wie in der letzten Lösung. Was fehlt aber noch ?

ersatz = 1 / ersatz;

Frage:Wäre folgende Anweisung auch korrekt ?

1/ersatz = 1/R1 + 1/R2

Nein ! Links des Gleichheitszeichens darf nur genau eine Variable stehen !

Weiter mit:

Aufgaben aus dem Übungsblatt lösen.