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.