https://projekte.zum.de/api.php?action=feedcontributions&feedformat=atom&user=12jojo08ZUM Projektwiki - Benutzerbeiträge [de]2026-10-12T03:44:31ZBenutzerbeiträgeMediaWiki 1.43.11https://projekte.zum.de/index.php?title=Informatik_am_Johanneum/Java&diff=41441Informatik am Johanneum/Java2021-01-16T15:20:21Z<p>12jojo08: </p>
<hr />
<div>===Offene Aufgaben===<br />
<br />
Bitte tragt in die Tabellen ein, welches Thema ihr bearbeiten wollt. Erst wenn ihr euch in der Tabelle für ein Thema eingetragen habt, könnt ihr mit der Bearbeitung beginnen. Ihr könnt Themen auch zu zweit erstellen.<br />
<br />
{| class="wikitable"<br />
|+offene Aufgaben<br />
!offene Aufgabe!!Verantwortlicher<br />
|-<br />
|Klassen in Eclipse anlegen||Erik<br />
|-<br />
|Variablentypen<br />
|Vinzent/J-P<br />
|-<br />
|eigene Methoden schreiben, Syntax der Signatur, return Statement<br />
|<br />
|-<br />
|typische Fehlermeldungen, IndexOutOfBoundsExcecption<br />
|<br />
|-<br />
|Arithmetische Operatoren<br />
|Niklas<br />
|-<br />
|Verzweigungen<br />
|Finn, Nikita<br />
|-<br />
|Schleifen (For-Schleife, While Schleife)<br />
|Vinzent/J-P<br />
|-<br />
|Reihungen (Initialisierung, ...)<br />
|Arian, Dharam<br />
|-<br />
|<br />
|<br />
|}<br />
<br />
Tipps zur Erstellung eines Eintrags: <br />
<br />
*jedes Thema hat eine Überschrift von Typ Unterüberschrift1<br />
*Verwende danach für die einzelnen Teilthemen Unterüberschrift2 oder weitere Unterüberschriften. So erscheinen diese Felder im Inhaltsverzeichnis.<br />
*Quellcode kann eingefügt werden, indem die Zeile im Modus Quelltextbearbeitung mit einem Leerzeichen begonnen wird.<br />
<br />
public void quellcodeSchreiben(){<br />
// dies ist ein Beispiel, wie Quellcode dargestellt werden kann.<br />
// wechsele dazu in den Modus Quelltextbearbeitung (oben rechts bei dem Stft)<br />
// beginne dann jede Quelltextzeile mit einem Leerzeichen.<br />
}<br />
<br /><br />
===Klassen in Eclipse anlegen===<br />
<br /><br />
===Variablentypen===<br />
In Java gibt es verschiedene Typen von Variablen. Einige davon werden im Folgenden erläutert.<br />
<br />
===='''Syntax einer Variable:'''====<br />
Erste Erstellung: Typ + Name = Wert -> Beispiel: int number = 3 / boolean correct = false<br />
<br />
Spätere Bearbeitung: Name = Wert -> Beispiel: number = 1 / correct = true<br />
<br />
Abfrage (z.B. in IF/ELSE Anfragen oder WHILE-Schleifen): Name == Wert -> number == 1 / correct == true<br />
<br />
===='''Ganzzahl-Typen:'''====<br />
integer (int): alle Zahlen zwischen -2147483648 und 2147483647.<br />
<br />
long: alle Zahlen zwischen -9223372036854775808 und 9223372036854775807.<br />
<br />
===='''Kommazahl-Typen:'''====<br />
double: Zahlen mit Kommastellen, aber auch ohne. Double wird verwendet, da die Ganzzahl-Typen keine Kommastellen speichern können.<br />
<br />
===='''Boolean:'''====<br />
boolean: kann zwei Werte annehmen, entweder true oder false, also wahr oder falsch.<br />
<br />
===='''Char'''====<br />
char: kann den Wert eines Unicodezeichens annehmen, also beispielsweise einen Buchstaben oder eine Zahl von 0-9.<br />
<br />
<u>Syntax</u> <br />
<br />
char i = 'J'<br />
<br />
===='''String'''====<br />
String: kann die Werte einer Zeichenkette annehmen<br />
<br />
ACHTUNG: Der Typ String muss in Java mit einem großen 'S' geschrieben werden.<br />
<br />
<u>Syntax</u> <br />
<br />
String java = "Hello World!"<br />
<br />
===='''Array'''====<br />
array[]: eine Reihung von Zahlen: man kann jeder Stelle eines Arrays eine bestimmte Zahl zuweisen.<br />
<br />
<u>''Syntax''</u> <br />
<br />
<u>Erstellen eines Arrays mit der Länge u</u><br />
<br />
int[] example = new int[u]<br />
<br />
<u>Erstellen eines Arrays mit bestimmten vorgegebenen Werten</u><br />
<br />
int example[] = {0, 3, 5, 10, 20, 25}<br />
<br />
<u>Die Ausgaben kann folgendermaßen aussehen</u><br />
<br />
example[3] == 10;<br />
<br />
example[4] == 20;<br />
<br />
<u>Zuweisung eines Wertes für eine Arraystelle:</u><br />
<br />
example[1] = 4;<br />
<br />
Die abgeänderte Reihung besitzt nun folgende Werte: {0, 4, 5, 10, 20, 25}<br />
<br />
<br /><br />
===Arithmetische Operatoren===<br />
=====Grundlagen=====<br />
In der Programmiersprache Java sind arithmetische Operatoren implementiert. Dabei müssen immer numerische Operanten (int, long, float, double) verwendet werden.<br />
=====Operatoren=====<br />
======Addition======<br />
Der Operator der Addition (a+b) addiert einen numerischen Operanden mit einem weiteren numerischen Operanden.<br />
<br />
public class Addition {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a + b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 10<br />
======Subtraktion======<br />
Der Operator der Subtraktion (a-b) subtrahiert einen numerischen Operanden von einem anderen numerischen Operator.<br />
<br />
public class Subtraktion {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a - b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 4 <br />
======Multiplikation======<br />
Der Operator der Multiplikation (a*b) multipliziert einen numerischen Operanden mit einem anderen numerischen Operanden.<br />
<br />
public class Multiplikation {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a * b;<br />
System.out.print(ergebnis);<br />
}<br />
} <br />
<br />
Ausgabe = 21<br />
======Division======<br />
Der Operator der Division (a/b) dividiert einen numerischen Operanden durch einen anderen numerischen Operanden. <br />
<u>Division zweier numerischer Operanden gleichen Typs:</u><br />
In diesem Fall sind die beiden numerischen Operanden ganzzahlig, daher ist auch das Ergebnis ganzzahlig:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 2<br />
<br />
<u> Division zweier numerischer Operanden unterschiedlichen Typs </u><br />
Es ist möglich numerische Operanden unterschiedlichen Typs zu dividieren. Ist einer der numerischen Operanden als Gleitkommazahl definiert, so ist auch das Ergebnis eine Gleitkommazahl:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
float b = 3;<br />
<br />
errgebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe: 2.3333333<br />
<br />
======Division mit Rest======<br />
Bei der Division mit Rest (modulo) dividiert einen numerischen Operanden durch einen zweiten numerischen Operanden (a%b). Dabei wird der ganzzahlige Rest als Ergebnis ausgegeben:<br />
<br />
public class Modulodivision {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a % b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 1<br />
===Verzweigungen===<br />
<br />
====Einführung====<br />
Verzweigungen gehören zu den Kontrollstrukturen Javas, die einen flexiblen und ereignisgesteuerten Ablauf eines Programmes ermöglichen. Für die Verzweigungen braucht man festgelegte Bedingungen. Beim Durchlauf des Programmes wird dann an den Verzweigungen überprüft, ob die Bedingung erfüllt wird oder nicht. Je nachdem welcher Fall zutrifft, wird ein bestimmter Bereich des Programmes ausgeführt. Im Folgenden unterscheiden wir in drei Verzweigungen: ''if''-Anweisung, ''if''-''else''-Anweisung und ''else-if''-Anweisung.<br /><br />
<br />
====''if''-''Anweisung''====<br />
Bei der ''if''-Anweisung wird als erstes überprüft, ob die gestellte Bedingung erfüllt wird oder nicht. Wird die Bedingung erfüllt, werden die danach folgenden Anweisungen ausgeführt. Wird die Bedingung nicht erfüllt, werden die danach folgenden Anweisungen übersprungen. In Java sieht die ''if''-Anweisung so aus:<br />
<br />
if (Bedingung){<br />
Anweisung;<br />
}<br />
<br /><br />
====''if-else''-Anweisung====<br />
Die ''if-else''-Anweisung ist im Prinzip nur eine Erweiterung der ''if''-Anweisung, bei der festgelegt wird, welche Anweisungen ausgeführt werden sollen, wenn die Bedingung nicht erfüllt wird. Man hat also zwei mögliche Fälle. In Java sieht die ''if-else''-Anweisung so aus:<br />
<br />
if (Bedingung) {<br />
Anweisung1;<br />
} <br />
else {<br />
Anweisung2;<br />
}<br />
<br /><br />
<br />
====''else-if''-Anweisung====<br />
Wenn man eine Verzweigung in drei verschiedene Programmbereiche braucht, kann man die ''else-if''-Anweisung verwenden. Bei der''else-if''-Anweisung wird erstmal überprüft, ob die erste Bedingung zutrifft. Wenn diese Bedingung zutrifft, wird der erste Programmbereich durchlaufen. Wenn diese Bedingung nicht zutrifft, wird zur nächsten Prüfung einer Bedingung gesprungen. Wenn diese zweite Bedingung zutrifft, dann werden die dazugehörigen Anweisungen ausgeführt. Wenn diese zweite Bedingung nicht zutrifft, dann wird zum letzten Teil der ''else-if''-Anweisung gesprungen und der letzte Programmbereich ausgeführt. In Java sieht die ''else-if''-Anweisung so aus: <br />
<br />
if (Bedingung1) {<br />
Anweisung1;<br />
} else if (Bedingung2) {<br />
Anweisung2;<br />
} else {<br />
Anweisung3;<br />
}<br />
<br />
<br /><br />
===Schleifen===<br />
'''FOR-Schleife'''<br />
<br />
Die sogenannte FOR-Scheife wird verwendet, wenn man die benötigten Schleifendurchläufe bereits im Voraus kennt. Man benötigt die folgenden drei Parameter: Initialisierung/Startwert, Zielwert und Schrittweite<br />
<br />
<u>Syntax</u><br />
<br />
for(Startwert; Zielwert; Schrittweite)<br />
<br />
<u>Beispiel</u><br />
<br />
for(int i = 1; i < 3; i++) {<br />
gehe 10 Schritte;<br />
}<br />
<br />
Mit dieser Schleife wird bei i == 1 10 Schritte gegangen und bei i == 2 ebenfalls, bei i == 3 nicht mehr, da der Zielwert erreicht ist.<br />
<br />
'''WHILE-Schleife'''<br />
<br />Die sogenannte WHILE-Schleife wird solange ausgeführt, bis eine bestimmte Bedingung nicht erfüllt ist. Diese Bedingung steht am Anfang der Schleife. Sofern die Bedingung anfangs nicht erfüllt wird, wird die Schleife übersprungen.<br />
<br />
<u>Syntax</u><br />
<br />
while(Bedingung) {<br />
Anweisung;<br />
}<br />
<u>Beispiel</u><br />
<br />
boolean correct = true;<br />
while(correct) {<br />
gehe 10 Schritte;<br />
correct = false;<br />
}<br />
Die Schleife wird einmal ausgeführt, da die Bedingung anfangs korrekt und danach nicht mehr korrekt ist.<br />
<br />
<br />
'''DO-WHILE-Schleife'''<br />
<br />
Die sogenannte DO-WHILE-Schleife ist eine WHILE-SCHLEIFE mit dem Unterschied, dass die Anweisung mindestens einmal ausgeführt wird, hierbei ist es anfangs egal, ob die Bedingung erfüllt ist oder nicht.<br />
<br />
<u>Syntax</u><br />
<br />
do {<br />
Anweisung;<br />
} while(Bedingung);<br />
<u>Beispiel</u><br />
<br />
int o = 1;<br />
do {<br />
gehe 10 Schritte;<br />
} while(o == 2);<br />
Diese Schleife wird einmal ausgeführt, danach nicht mehr, da die Bedingung nicht erfüllt wird.<br />
<br />
<br /><br />
<br />
===Reihungen===<br />
<br>'''Definition'''<p><br />
Eine Reihung besteht aus einer Anzahl von Werten des gleichen Datentyps. Sie alle werden unter einem Namen geführt und unterscheiden sich nur in den Feldnummern, welche die Position in der Reihung bestimmt.<p><br />
<p><br />
'''Arten von Reihungen'''<p><br />
Es gibt verschiedene Arten von Reihungen. Diese unterscheiden sich in dem Datentyp der Variablen, die in ihnen gespeichert sind.<br />
<br />
*<p> int[] a; Reihung aus ganzen Zahlen<br />
*<p> char[] b; Reihungen aus Zeichen<br />
*<p> boolean[] c; Reihung aus Wahrheitswerten<br />
*<p> int[][] d; Mehrdimensionale Reihung, dabei ist in jedem Element ein eigenes Array enthalten. Jede Dimension wird durch ein paar eckige Klammern dargestellt.<p> <p>'''Deklaration von Reihungen'''<br />
<p><br />
Reihungen werden grundsätzlich mit dem Operator <b> new </b>deklariert.<br />
<p><br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = new int[5]<br />
<br />
oder<br />
<br />
int[] b;<br />
a = new int[5]<br />
</syntaxhighlight><p><br />
In diesen Beispielen erzeugen wir zwei Reihungen mit je 5 Elementen, welche jedoch noch keine Werte enthalten.<br />
<P><p><br />
'''Initialisierung von Reihungen'''<p><br />
Bei der Initialisierung werden die im vorigen Kapitel erstellten Reihungen mit Werten gefüllt. Dafür gibt es verschiedene Möglichkeiten:<br /><br />
<br />
#Möchte man eine Reihung mit bereits bekannten Werten initialisieren, fällt der Operator <b> new </b> weg. Die eckigen Klammern werden durch geschwungene ersetzt innerhalb welcher alle Werte, durch ein Komma getrennt, eingetragen werden. Hier wird die Reihung also gleichzeitig '''deklariert''' und '''initialisiert'''. Beispiel:<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
</syntaxhighlight>In diesem Beispiel erzeugen wir eine Reihungen mit einer Länge von 5 Elementen mit den Werten 1, 2, 3, 4 und 5. <br /><br />
#Man kann eine Reihung auch initialisieren, indem man die Positionen einzeln mit Werten befüllt. Beispiel:<syntaxhighlight lang="java"><br />
b[0] = 1;<br />
b[1] = 2;<br />
b[2] = 3;<br />
b[3] = 4;<br />
b[4] = 5; <br />
</syntaxhighlight>Hier werden die verschiedenen Positionen der Reihung einzeln mit Werten gefüllt. '''Achtung:''' Dabei wird die Position bei 0 beginnend gezählt. Also befindet sich die erste Zahl in der Reihung auf Position 0, die zweite Zahl in der Reihung auf Position 2 und so weiter<br />
<br />
<br />
'''Auslesen von Reihungen'''<br />
<br />
Um Werte aus einer Reihung auszulesen, muss man den Namen der Reihung, sowie die Position des Elements in der Reihung auswählen.<br />
<br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
<br />
Dann gilt:<br />
a[3] = 4<br />
</syntaxhighlight></div>12jojo08https://projekte.zum.de/index.php?title=Informatik_am_Johanneum/Java&diff=41440Informatik am Johanneum/Java2021-01-16T15:19:07Z<p>12jojo08: </p>
<hr />
<div>===Offene Aufgaben===<br />
<br />
Bitte tragt in die Tabellen ein, welches Thema ihr bearbeiten wollt. Erst wenn ihr euch in der Tabelle für ein Thema eingetragen habt, könnt ihr mit der Bearbeitung beginnen. Ihr könnt Themen auch zu zweit erstellen.<br />
<br />
{| class="wikitable"<br />
|+offene Aufgaben<br />
!offene Aufgabe!!Verantwortlicher<br />
|-<br />
|Klassen in Eclipse anlegen||Erik<br />
|-<br />
|Variablentypen<br />
|Vinzent/J-P<br />
|-<br />
|eigene Methoden schreiben, Syntax der Signatur, return Statement<br />
|<br />
|-<br />
|typische Fehlermeldungen, IndexOutOfBoundsExcecption<br />
|<br />
|-<br />
|Arithmetische Operatoren<br />
|Niklas<br />
|-<br />
|Verzweigungen<br />
|Finn, Nikita<br />
|-<br />
|Schleifen (For-Schleife, While Schleife)<br />
|Vinzent/J-P<br />
|-<br />
|Reihungen (Initialisierung, ...)<br />
|Arian, Dharam<br />
|-<br />
|<br />
|<br />
|}<br />
<br />
Tipps zur Erstellung eines Eintrags: <br />
<br />
*jedes Thema hat eine Überschrift von Typ Unterüberschrift1<br />
*Verwende danach für die einzelnen Teilthemen Unterüberschrift2 oder weitere Unterüberschriften. So erscheinen diese Felder im Inhaltsverzeichnis.<br />
*Quellcode kann eingefügt werden, indem die Zeile im Modus Quelltextbearbeitung mit einem Leerzeichen begonnen wird.<br />
<br />
public void quellcodeSchreiben(){<br />
// dies ist ein Beispiel, wie Quellcode dargestellt werden kann.<br />
// wechsele dazu in den Modus Quelltextbearbeitung (oben rechts bei dem Stft)<br />
// beginne dann jede Quelltextzeile mit einem Leerzeichen.<br />
}<br />
<br /><br />
===Klassen in Eclipse anlegen===<br />
<br /><br />
===Variablentypen===<br />
In Java gibt es verschiedene Typen von Variablen. Einige davon werden im Folgenden erläutert.<br />
<br />
===='''Syntax einer Variable:'''====<br />
Erste Erstellung: Typ + Name = Wert -> Beispiel: int number = 3 / boolean correct = false<br />
<br />
Spätere Bearbeitung: Name = Wert -> Beispiel: number = 1 / correct = true<br />
<br />
Abfrage (z.B. in IF/ELSE Anfragen oder WHILE-Schleifen): Name == Wert -> number == 1 / correct == true<br />
<br />
===='''Ganzzahl-Typen:'''====<br />
integer (int): alle Zahlen zwischen -2147483648 und 2147483647.<br />
<br />
long: alle Zahlen zwischen -9223372036854775808 und 9223372036854775807.<br />
<br />
===='''Kommazahl-Typen:'''====<br />
double: Zahlen mit Kommastellen, aber auch ohne. Double wird verwendet, da die Ganzzahl-Typen keine Kommastellen speichern können.<br />
<br />
===='''Boolean:'''====<br />
boolean: kann zwei Werte annehmen, entweder true oder false, also wahr oder falsch.<br />
<br />
===='''Char'''====<br />
char: kann den Wert eines Unicodezeichens annehmen, also beispielsweise einen Buchstaben oder eine Zahl von 0-9.<br />
<br />
<u>Syntax</u> <br />
<br />
char i = 'J'<br />
<br />
===='''String'''====<br />
String: kann die Werte einer Zeichenkette annehmen<br />
<br />
ACHTUNG: Der Typ String muss in Java mit einem großen 'S' geschrieben werden.<br />
<br />
<u>Syntax</u> <br />
<br />
String java = "Hello World!"<br />
<br />
===='''Array'''====<br />
array[]: eine Reihung von Zahlen: man kann jeder Stelle eines Arrays eine bestimmte Zahl zuweisen.<br />
<br />
<u>''Syntax''</u> <br />
<br />
<u>Erstellen eines Arrays mit der Länge u</u><br />
<br />
int[] example = new int[u]<br />
<br />
<u>Erstellen eines Arrays mit bestimmten vorgegebenen Werten</u><br />
<br />
int example[] = {0, 3, 5, 10, 20, 25}<br />
<br />
<u>Die Ausgaben kann folgendermaßen aussehen</u><br />
<br />
example[3] == 10;<br />
<br />
example[4] == 20;<br />
<br />
<u>Zuweisung eines Wertes für eine Arraystelle:</u><br />
<br />
example[1] = 4;<br />
<br />
Die abgeänderte Reihung besitzt nun folgende Werte: {0, 4, 5, 10, 20, 25}<br />
<br />
<br /><br />
===Arithmetische Operatoren===<br />
=====Grundlagen=====<br />
In der Programmiersprache Java sind arithmetische Operatoren implementiert. Dabei müssen immer numerische Operanten (int, long, float, double) verwendet werden.<br />
=====Operatoren=====<br />
======Addition======<br />
Der Operator der Addition (a+b) addiert einen numerischen Operanden mit einem weiteren numerischen Operanden.<br />
<br />
public class Addition {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a + b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 10<br />
======Subtraktion======<br />
Der Operator der Subtraktion (a-b) subtrahiert einen numerischen Operanden von einem anderen numerischen Operator.<br />
<br />
public class Subtraktion {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a - b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 4 <br />
======Multiplikation======<br />
Der Operator der Multiplikation (a*b) multipliziert einen numerischen Operanden mit einem anderen numerischen Operanden.<br />
<br />
public class Multiplikation {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a * b;<br />
System.out.print(ergebnis);<br />
}<br />
} <br />
<br />
Ausgabe = 21<br />
======Division======<br />
Der Operator der Division (a/b) dividiert einen numerischen Operanden durch einen anderen numerischen Operanden. <br />
<u>Division zweier numerischer Operanden gleichen Typs:</u><br />
In diesem Fall sind die beiden numerischen Operanden ganzzahlig, daher ist auch das Ergebnis ganzzahlig:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 2<br />
<br />
<u> Division zweier numerischer Operanden unterschiedlichen Typs </u><br />
Es ist möglich numerische Operanden unterschiedlichen Typs zu dividieren. Ist einer der numerischen Operanden als Gleitkommazahl definiert, so ist auch das Ergebnis eine Gleitkommazahl:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
float b = 3;<br />
<br />
errgebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe: 2.3333333<br />
<br />
======Division mit Rest======<br />
Bei der Division mit Rest (modulo) dividiert einen numerischen Operanden durch einen zweiten numerischen Operanden (a%b). Dabei wird der ganzzahlige Rest als Ergebnis ausgegeben:<br />
<br />
public class Modulodivision {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a % b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 1<br />
===Verzweigungen===<br />
<br />
====Einführung====<br />
Verzweigungen gehören zu den Kontrollstrukturen Javas, die einen flexiblen und ereignisgesteuerten Ablauf eines Programmes ermöglichen. Für die Verzweigungen braucht man festgelegte Bedingungen. Beim Durchlauf des Programmes wird dann an den Verzweigungen überprüft, ob die Bedingung erfüllt wird oder nicht. Je nachdem welcher Fall zutrifft, wird ein bestimmter Bereich des Programmes ausgeführt. Im Folgenden unterscheiden wir in drei Verzweigungen: ''if''-Anweisung, ''if''-''else''-Anweisung und ''else-if''-Anweisung.<br /><br />
<br />
====''if''-''Anweisung''====<br />
Bei der ''if''-Anweisung wird als erstes überprüft, ob die gestellte Bedingung erfüllt wird oder nicht. Wird die Bedingung erfüllt, werden die danach folgenden Anweisungen ausgeführt. Wird die Bedingung nicht erfüllt, werden die danach folgenden Anweisungen übersprungen. In Java sieht die ''if''-Anweisung so aus:<br />
<br />
if (Bedingung){<br />
Anweisung;<br />
}<br />
<br /><br />
====''if-else''-Anweisung====<br />
Die ''if-else''-Anweisung ist im Prinzip nur eine Erweiterung der ''if''-Anweisung, bei der festgelegt wird, welche Anweisungen ausgeführt werden sollen, wenn die Bedingung nicht erfüllt wird. Man hat also zwei mögliche Fälle. In Java sieht die ''if-else''-Anweisung so aus:<br />
<br />
if (Bedingung) {<br />
Anweisung1;<br />
} <br />
else {<br />
Anweisung2;<br />
}<br />
<br /><br />
<br />
====''else-if''-Anweisung====<br />
Wenn man eine Verzweigung in drei verschiedene Programmbereiche braucht, kann man die ''else-if''-Anweisung verwenden. Bei der''else-if''-Anweisung wird erstmal überprüft, ob die erste Bedingung zutrifft. Wenn diese Bedingung zutrifft, wird der erste Programmbereich durchlaufen. Wenn diese Bedingung nicht zutrifft, wird zur nächsten Prüfung einer Bedingung gesprungen. Wenn diese zweite Bedingung zutrifft, dann werden die dazugehörigen Anweisungen ausgeführt. Wenn diese zweite Bedingung nicht zutrifft, dann wird zum letzten Teil der ''else-if''-Anweisung gesprungen und der letzte Programmbereich ausgeführt. In Java sieht die ''else-if''-Anweisung so aus: <br />
<br />
if (Bedingung1) {<br />
Anweisung1;<br />
} else if (Bedingung2) {<br />
Anweisung2;<br />
} else {<br />
Anweisung3;<br />
}<br />
<br />
<br /><br />
===Schleifen===<br />
'''FOR-Schleife'''<br />
<br />
Die sogenannte FOR-Scheife wird verwendet, wenn man die benötigten Schleifendurchläufe bereits im Voraus kennt. Man benötigt die folgenden drei Parameter: Initialisierung/Startwert, Zielwert und Schrittweite<br />
<br />
<u>Syntax</u><br />
<br />
for(Startwert; Zielwert; Schrittweite)<br />
<br />
<u>Beispiel</u><br />
<br />
for(int i = 1; i < 3; i++) {<br />
gehe 10 Schritte;<br />
}<br />
<br />
Mit dieser Schleife wird bei i == 1 10 Schritte gegangen und bei i == 2 ebenfalls, bei i == 3 nicht mehr, da der Zielwert erreicht ist.<br />
<br />
'''WHILE-Schleife'''<br />
<br />Die sogenannte WHILE-Schleife wird solange ausgeführt, bis eine bestimmte Bedingung nicht erfüllt ist. Diese Bedingung steht am Anfang der Schleife. Sofern die Bedingung anfangs nicht erfüllt wird, wird die Schleife übersprungen.<br />
<br />
<u>Syntax</u><br />
<br />
while(Bedingung) {<br />
Anweisung;<br />
}<br />
<u>Beispiel</u><br />
<br />
boolean correct = true;<br />
while(correct) {<br />
gehe 10 Schritte;<br />
correct = false;<br />
}<br />
Die Schleife wird einmal ausgeführt, da die Bedingung anfangs korrekt und danach nicht mehr korrekt ist.<br />
<br />
<br />
'''DO-WHILE-Schleife'''<br />
<br />
Die sogenannte DO-WHILE-Schleife ist eine WHILE-SCHLEIFE mit dem Unterschied, dass die Anweisung mindestens einmal ausgeführt wird, hierbei ist es anfangs egal, ob die Bedingung erfüllt ist oder nicht.<br />
<br />
<u>Syntax</u><br />
<br />
do {<br />
Anweisung;<br />
} while(Bedingung);<br />
<u>Beispiel</u><br />
<br />
int o = 1;<br />
do {<br />
gehe 10 Schritte;<br />
} while(o == 2);<br />
Diese Schleife wird einmal ausgeführt, danach nicht mehr, da die Bedingung nicht erfüllt wird.<br />
<br />
<br /><br />
<br />
===Reihungen===<br />
<br>'''Definition'''<p><br />
Eine Reihung besteht aus einer Anzahl von Werten des gleichen Datentyps. Sie alle werden unter einem Namen geführt und unterscheiden sich nur in den Feldnummern, welche die Position in der Reihung bestimmt.<p><br />
<p><br />
'''Arten von Reihungen'''<p><br />
Es gibt verschiedene Arten von Reihungen. Diese unterscheiden sich in dem Datentyp der Variablen, die in ihnen gespeichert sind.<br />
<br />
*<p> int[] a; Reihung aus ganzen Zahlen<br />
*<p> char[] b; Reihungen aus Zeichen<br />
*<p> boolean[] c; Reihung aus Wahrheitswerten<br />
*<p> int[][] d; Mehrdimensionale Reihung, dabei ist in jedem Element ein eigenes Array enthalten. Jede Dimension wird durch ein paar eckige Klammern dargestellt.<p> <p>'''Deklaration von Reihungen'''<br />
<p><br />
Reihungen werden grundsätzlich mit dem Operator <b> new </b>deklariert.<br />
<p><br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = new int[5]<br />
<br />
oder<br />
<br />
int[] b;<br />
a = new int[5]<br />
</syntaxhighlight><p><br />
In diesen Beispielen erzeugen wir zwei Reihungen mit je 5 Elementen, welche jedoch noch keine Werte enthalten.<br />
<P><p><br />
'''Initialisierung von Reihungen'''<p><br />
Bei der Initialisierung werden die im vorigen Kapitel erstellten Reihungen mit Werten gefüllt. Dafür gibt es verschiedene Möglichkeiten:<br /><br />
<br />
#Möchte man eine Reihung mit bereits bekannten Werten initialisieren, fällt der Operator <b> new </b> weg. Die eckigen Klammern werden durch geschwungene ersetzt innerhalb welcher alle Werte, durch ein Komma getrennt, eingetragen werden. Hier wird die Reihung also gleichzeitig '''deklariert''' und '''initialisiert'''. Beispiel:<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
</syntaxhighlight>In diesem Beispiel erzeugen wir eine Reihungen mit einer Länge von 5 Elementen mit den Werten 1, 2, 3, 4 und 5. <br /><br />
#Man kann eine Reihung auch initialisieren, indem man die Positionen einzeln mit Werten befüllt. Beispiel:<syntaxhighlight lang="java"><br />
b[0] = 1;<br />
b[1] = 2;<br />
b[2] = 3;<br />
b[3] = 4;<br />
b[4] = 5; <br />
</syntaxhighlight>Hier werden die verschiedenen Positionen der Reihung einzeln mit Werten gefüllt. '''Achtung:''' Dabei wird die Position bei 0 beginnend gezählt. Also befindet sich die erste Zahl in der Reihung auf Position 0, die zweite Zahl in der Reihung auf Position 2 und so weiter<br />
<br />
Auslesen von Reihungen<br />
<br />
Um Werte aus einer Reihung auszulesen, muss man den Namen der Reihung, sowie die Position des Elements in der Reihung auswählen. <br />
<br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
<br />
Dann gilt:<br />
a[3] = 4<br />
</syntaxhighlight></div>12jojo08https://projekte.zum.de/index.php?title=Informatik_am_Johanneum/Java&diff=41439Informatik am Johanneum/Java2021-01-16T15:18:03Z<p>12jojo08: </p>
<hr />
<div>===Offene Aufgaben===<br />
<br />
Bitte tragt in die Tabellen ein, welches Thema ihr bearbeiten wollt. Erst wenn ihr euch in der Tabelle für ein Thema eingetragen habt, könnt ihr mit der Bearbeitung beginnen. Ihr könnt Themen auch zu zweit erstellen.<br />
<br />
{| class="wikitable"<br />
|+offene Aufgaben<br />
!offene Aufgabe!!Verantwortlicher<br />
|-<br />
|Klassen in Eclipse anlegen||Erik<br />
|-<br />
|Variablentypen<br />
|Vinzent/J-P<br />
|-<br />
|eigene Methoden schreiben, Syntax der Signatur, return Statement<br />
|<br />
|-<br />
|typische Fehlermeldungen, IndexOutOfBoundsExcecption<br />
|<br />
|-<br />
|Arithmetische Operatoren<br />
|Niklas<br />
|-<br />
|Verzweigungen<br />
|Finn, Nikita<br />
|-<br />
|Schleifen (For-Schleife, While Schleife)<br />
|Vinzent/J-P<br />
|-<br />
|Reihungen (Initialisierung, ...)<br />
|Arian, Dharam<br />
|-<br />
|<br />
|<br />
|}<br />
<br />
Tipps zur Erstellung eines Eintrags: <br />
<br />
*jedes Thema hat eine Überschrift von Typ Unterüberschrift1<br />
*Verwende danach für die einzelnen Teilthemen Unterüberschrift2 oder weitere Unterüberschriften. So erscheinen diese Felder im Inhaltsverzeichnis.<br />
*Quellcode kann eingefügt werden, indem die Zeile im Modus Quelltextbearbeitung mit einem Leerzeichen begonnen wird.<br />
<br />
public void quellcodeSchreiben(){<br />
// dies ist ein Beispiel, wie Quellcode dargestellt werden kann.<br />
// wechsele dazu in den Modus Quelltextbearbeitung (oben rechts bei dem Stft)<br />
// beginne dann jede Quelltextzeile mit einem Leerzeichen.<br />
}<br />
<br /><br />
===Klassen in Eclipse anlegen===<br />
<br /><br />
===Variablentypen===<br />
In Java gibt es verschiedene Typen von Variablen. Einige davon werden im Folgenden erläutert.<br />
<br />
===='''Syntax einer Variable:'''====<br />
Erste Erstellung: Typ + Name = Wert -> Beispiel: int number = 3 / boolean correct = false<br />
<br />
Spätere Bearbeitung: Name = Wert -> Beispiel: number = 1 / correct = true<br />
<br />
Abfrage (z.B. in IF/ELSE Anfragen oder WHILE-Schleifen): Name == Wert -> number == 1 / correct == true<br />
<br />
===='''Ganzzahl-Typen:'''====<br />
integer (int): alle Zahlen zwischen -2147483648 und 2147483647.<br />
<br />
long: alle Zahlen zwischen -9223372036854775808 und 9223372036854775807.<br />
<br />
===='''Kommazahl-Typen:'''====<br />
double: Zahlen mit Kommastellen, aber auch ohne. Double wird verwendet, da die Ganzzahl-Typen keine Kommastellen speichern können.<br />
<br />
===='''Boolean:'''====<br />
boolean: kann zwei Werte annehmen, entweder true oder false, also wahr oder falsch.<br />
<br />
===='''Char'''====<br />
char: kann den Wert eines Unicodezeichens annehmen, also beispielsweise einen Buchstaben oder eine Zahl von 0-9.<br />
<br />
<u>Syntax</u> <br />
<br />
char i = 'J'<br />
<br />
===='''String'''====<br />
String: kann die Werte einer Zeichenkette annehmen<br />
<br />
ACHTUNG: Der Typ String muss in Java mit einem großen 'S' geschrieben werden.<br />
<br />
<u>Syntax</u> <br />
<br />
String java = "Hello World!"<br />
<br />
===='''Array'''====<br />
array[]: eine Reihung von Zahlen: man kann jeder Stelle eines Arrays eine bestimmte Zahl zuweisen.<br />
<br />
<u>''Syntax''</u> <br />
<br />
<u>Erstellen eines Arrays mit der Länge u</u><br />
<br />
int[] example = new int[u]<br />
<br />
<u>Erstellen eines Arrays mit bestimmten vorgegebenen Werten</u><br />
<br />
int example[] = {0, 3, 5, 10, 20, 25}<br />
<br />
<u>Die Ausgaben kann folgendermaßen aussehen</u><br />
<br />
example[3] == 10;<br />
<br />
example[4] == 20;<br />
<br />
<u>Zuweisung eines Wertes für eine Arraystelle:</u><br />
<br />
example[1] = 4;<br />
<br />
Die abgeänderte Reihung besitzt nun folgende Werte: {0, 4, 5, 10, 20, 25}<br />
<br />
<br /><br />
===Arithmetische Operatoren===<br />
=====Grundlagen=====<br />
In der Programmiersprache Java sind arithmetische Operatoren implementiert. Dabei müssen immer numerische Operanten (int, long, float, double) verwendet werden.<br />
=====Operatoren=====<br />
======Addition======<br />
Der Operator der Addition (a+b) addiert einen numerischen Operanden mit einem weiteren numerischen Operanden.<br />
<br />
public class Addition {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a + b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 10<br />
======Subtraktion======<br />
Der Operator der Subtraktion (a-b) subtrahiert einen numerischen Operanden von einem anderen numerischen Operator.<br />
<br />
public class Subtraktion {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a - b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 4 <br />
======Multiplikation======<br />
Der Operator der Multiplikation (a*b) multipliziert einen numerischen Operanden mit einem anderen numerischen Operanden.<br />
<br />
public class Multiplikation {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a * b;<br />
System.out.print(ergebnis);<br />
}<br />
} <br />
<br />
Ausgabe = 21<br />
======Division======<br />
Der Operator der Division (a/b) dividiert einen numerischen Operanden durch einen anderen numerischen Operanden. <br />
<u>Division zweier numerischer Operanden gleichen Typs:</u><br />
In diesem Fall sind die beiden numerischen Operanden ganzzahlig, daher ist auch das Ergebnis ganzzahlig:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 2<br />
<br />
<u> Division zweier numerischer Operanden unterschiedlichen Typs </u><br />
Es ist möglich numerische Operanden unterschiedlichen Typs zu dividieren. Ist einer der numerischen Operanden als Gleitkommazahl definiert, so ist auch das Ergebnis eine Gleitkommazahl:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
float b = 3;<br />
<br />
errgebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe: 2.3333333<br />
<br />
======Division mit Rest======<br />
Bei der Division mit Rest (modulo) dividiert einen numerischen Operanden durch einen zweiten numerischen Operanden (a%b). Dabei wird der ganzzahlige Rest als Ergebnis ausgegeben:<br />
<br />
public class Modulodivision {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a % b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 1<br />
===Verzweigungen===<br />
<br />
====Einführung====<br />
Verzweigungen gehören zu den Kontrollstrukturen Javas, die einen flexiblen und ereignisgesteuerten Ablauf eines Programmes ermöglichen. Für die Verzweigungen braucht man festgelegte Bedingungen. Beim Durchlauf des Programmes wird dann an den Verzweigungen überprüft, ob die Bedingung erfüllt wird oder nicht. Je nachdem welcher Fall zutrifft, wird ein bestimmter Bereich des Programmes ausgeführt. Im Folgenden unterscheiden wir in drei Verzweigungen: ''if''-Anweisung, ''if''-''else''-Anweisung und ''else-if''-Anweisung.<br /><br />
<br />
====''if''-''Anweisung''====<br />
Bei der ''if''-Anweisung wird als erstes überprüft, ob die gestellte Bedingung erfüllt wird oder nicht. Wird die Bedingung erfüllt, werden die danach folgenden Anweisungen ausgeführt. Wird die Bedingung nicht erfüllt, werden die danach folgenden Anweisungen übersprungen. In Java sieht die ''if''-Anweisung so aus:<br />
<br />
if (Bedingung){<br />
Anweisung;<br />
}<br />
<br /><br />
====''if-else''-Anweisung====<br />
Die ''if-else''-Anweisung ist im Prinzip nur eine Erweiterung der ''if''-Anweisung, bei der festgelegt wird, welche Anweisungen ausgeführt werden sollen, wenn die Bedingung nicht erfüllt wird. Man hat also zwei mögliche Fälle. In Java sieht die ''if-else''-Anweisung so aus:<br />
<br />
if (Bedingung) {<br />
Anweisung1;<br />
} <br />
else {<br />
Anweisung2;<br />
}<br />
<br /><br />
<br />
====''else-if''-Anweisung====<br />
Wenn man eine Verzweigung in drei verschiedene Programmbereiche braucht, kann man die ''else-if''-Anweisung verwenden. Bei der''else-if''-Anweisung wird erstmal überprüft, ob die erste Bedingung zutrifft. Wenn diese Bedingung zutrifft, wird der erste Programmbereich durchlaufen. Wenn diese Bedingung nicht zutrifft, wird zur nächsten Prüfung einer Bedingung gesprungen. Wenn diese zweite Bedingung zutrifft, dann werden die dazugehörigen Anweisungen ausgeführt. Wenn diese zweite Bedingung nicht zutrifft, dann wird zum letzten Teil der ''else-if''-Anweisung gesprungen und der letzte Programmbereich ausgeführt. In Java sieht die ''else-if''-Anweisung so aus: <br />
<br />
if (Bedingung1) {<br />
Anweisung1;<br />
} else if (Bedingung2) {<br />
Anweisung2;<br />
} else {<br />
Anweisung3;<br />
}<br />
<br />
<br /><br />
===Schleifen===<br />
'''FOR-Schleife'''<br />
<br />
Die sogenannte FOR-Scheife wird verwendet, wenn man die benötigten Schleifendurchläufe bereits im Voraus kennt. Man benötigt die folgenden drei Parameter: Initialisierung/Startwert, Zielwert und Schrittweite<br />
<br />
<u>Syntax</u><br />
<br />
for(Startwert; Zielwert; Schrittweite)<br />
<br />
<u>Beispiel</u><br />
<br />
for(int i = 1; i < 3; i++) {<br />
gehe 10 Schritte;<br />
}<br />
<br />
Mit dieser Schleife wird bei i == 1 10 Schritte gegangen und bei i == 2 ebenfalls, bei i == 3 nicht mehr, da der Zielwert erreicht ist.<br />
<br />
'''WHILE-Schleife'''<br />
<br />Die sogenannte WHILE-Schleife wird solange ausgeführt, bis eine bestimmte Bedingung nicht erfüllt ist. Diese Bedingung steht am Anfang der Schleife. Sofern die Bedingung anfangs nicht erfüllt wird, wird die Schleife übersprungen.<br />
<br />
<u>Syntax</u><br />
<br />
while(Bedingung) {<br />
Anweisung;<br />
}<br />
<u>Beispiel</u><br />
<br />
boolean correct = true;<br />
while(correct) {<br />
gehe 10 Schritte;<br />
correct = false;<br />
}<br />
Die Schleife wird einmal ausgeführt, da die Bedingung anfangs korrekt und danach nicht mehr korrekt ist.<br />
<br />
<br />
'''DO-WHILE-Schleife'''<br />
<br />
Die sogenannte DO-WHILE-Schleife ist eine WHILE-SCHLEIFE mit dem Unterschied, dass die Anweisung mindestens einmal ausgeführt wird, hierbei ist es anfangs egal, ob die Bedingung erfüllt ist oder nicht.<br />
<br />
<u>Syntax</u><br />
<br />
do {<br />
Anweisung;<br />
} while(Bedingung);<br />
<u>Beispiel</u><br />
<br />
int o = 1;<br />
do {<br />
gehe 10 Schritte;<br />
} while(o == 2);<br />
Diese Schleife wird einmal ausgeführt, danach nicht mehr, da die Bedingung nicht erfüllt wird.<br />
<br />
<br /><br />
<br />
===Reihungen===<br />
<br>'''Definition'''<p><br />
Eine Reihung besteht aus einer Anzahl von Werten des gleichen Datentyps. Sie alle werden unter einem Namen geführt und unterscheiden sich nur in den Feldnummern, welche die Position in der Reihung bestimmt.<p><br />
<p><br />
'''Arten von Reihungen'''<p><br />
Es gibt verschiedene Arten von Reihungen. Diese unterscheiden sich in dem Datentyp der Variablen, die in ihnen gespeichert sind.<br />
<br />
*<p> int[] a; Reihung aus ganzen Zahlen<br />
*<p> char[] b; Reihungen aus Zeichen<br />
*<p> boolean[] c; Reihung aus Wahrheitswerten<br />
*<p> int[][] d; Mehrdimensionale Reihung, dabei ist in jedem Element ein eigenes Array enthalten. Jede Dimension wird durch ein paar eckige Klammern dargestellt.<p> <p>'''Deklaration von Reihungen'''<br />
<p><br />
Reihungen werden grundsätzlich mit dem Operator <b> new </b>deklariert.<br />
<p><br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = new int[5]<br />
<br />
oder<br />
<br />
int[] b;<br />
a = new int[5]<br />
</syntaxhighlight><p><br />
In diesen Beispielen erzeugen wir zwei Reihungen mit je 5 Elementen, welche jedoch noch keine Werte enthalten.<br />
<P><p><br />
'''Initialisierung von Reihungen'''<p><br />
Bei der Initialisierung werden die im vorigen Kapitel erstellten Reihungen mit Werten gefüllt. Dafür gibt es verschiedene Möglichkeiten:<br /><br />
<br />
#Möchte man eine Reihung mit bereits bekannten Werten initialisieren, fällt der Operator <b> new </b> weg. Die eckigen Klammern werden durch geschwungene ersetzt innerhalb welcher alle Werte, durch ein Komma getrennt, eingetragen werden. Hier wird die Reihung also gleichzeitig '''deklariert''' und '''initialisiert'''. Beispiel:<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
</syntaxhighlight>In diesem Beispiel erzeugen wir eine Reihungen mit einer Länge von 5 Elementen mit den Werten 1, 2, 3, 4 und 5. <br /><br />
#Man kann eine Reihung auch initialisieren, indem man die Positionen einzeln mit Werten befüllt. Beispiel:<syntaxhighlight lang="java"><br />
b[0] = 1;<br />
b[1] = 2;<br />
b[2] = 3;<br />
b[3] = 4;<br />
b[4] = 5; <br />
</syntaxhighlight>Hier werden die verschiedenen Positionen der Reihung einzeln mit Werten gefüllt.<br />
<br />
'''Achtung:''' Dabei wird die Position bei 0 beginnend gezählt. Also befindet sich die erste Zahl in der Reihung auf Position 0, die zweite Zahl in der Reihung auf Position 2 und so weiter<br />
<br />
<br />
'''Auslesen von Werten'''<br />
<br />
Um Werte aus einer Reihung auszulesen, muss man den Namen der Reihung, sowie die Position des Elements in der Reihung auswählen. <br />
<br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
<br />
Dann gilt:<br />
a[3] = 4<br />
</syntaxhighlight></div>12jojo08https://projekte.zum.de/index.php?title=Informatik_am_Johanneum/Java&diff=41438Informatik am Johanneum/Java2021-01-16T15:16:29Z<p>12jojo08: </p>
<hr />
<div>===Offene Aufgaben===<br />
<br />
Bitte tragt in die Tabellen ein, welches Thema ihr bearbeiten wollt. Erst wenn ihr euch in der Tabelle für ein Thema eingetragen habt, könnt ihr mit der Bearbeitung beginnen. Ihr könnt Themen auch zu zweit erstellen.<br />
<br />
{| class="wikitable"<br />
|+offene Aufgaben<br />
!offene Aufgabe!!Verantwortlicher<br />
|-<br />
|Klassen in Eclipse anlegen||Erik<br />
|-<br />
|Variablentypen<br />
|Vinzent/J-P<br />
|-<br />
|eigene Methoden schreiben, Syntax der Signatur, return Statement<br />
|<br />
|-<br />
|typische Fehlermeldungen, IndexOutOfBoundsExcecption<br />
|<br />
|-<br />
|Arithmetische Operatoren<br />
|Niklas<br />
|-<br />
|Verzweigungen<br />
|Finn, Nikita<br />
|-<br />
|Schleifen (For-Schleife, While Schleife)<br />
|Vinzent/J-P<br />
|-<br />
|Reihungen (Initialisierung, ...)<br />
|Arian, Dharam<br />
|-<br />
|<br />
|<br />
|}<br />
<br />
Tipps zur Erstellung eines Eintrags: <br />
<br />
*jedes Thema hat eine Überschrift von Typ Unterüberschrift1<br />
*Verwende danach für die einzelnen Teilthemen Unterüberschrift2 oder weitere Unterüberschriften. So erscheinen diese Felder im Inhaltsverzeichnis.<br />
*Quellcode kann eingefügt werden, indem die Zeile im Modus Quelltextbearbeitung mit einem Leerzeichen begonnen wird.<br />
<br />
public void quellcodeSchreiben(){<br />
// dies ist ein Beispiel, wie Quellcode dargestellt werden kann.<br />
// wechsele dazu in den Modus Quelltextbearbeitung (oben rechts bei dem Stft)<br />
// beginne dann jede Quelltextzeile mit einem Leerzeichen.<br />
}<br />
<br /><br />
===Klassen in Eclipse anlegen===<br />
<br /><br />
===Variablentypen===<br />
In Java gibt es verschiedene Typen von Variablen. Einige davon werden im Folgenden erläutert.<br />
<br />
===='''Syntax einer Variable:'''====<br />
Erste Erstellung: Typ + Name = Wert -> Beispiel: int number = 3 / boolean correct = false<br />
<br />
Spätere Bearbeitung: Name = Wert -> Beispiel: number = 1 / correct = true<br />
<br />
Abfrage (z.B. in IF/ELSE Anfragen oder WHILE-Schleifen): Name == Wert -> number == 1 / correct == true<br />
<br />
===='''Ganzzahl-Typen:'''====<br />
integer (int): alle Zahlen zwischen -2147483648 und 2147483647.<br />
<br />
long: alle Zahlen zwischen -9223372036854775808 und 9223372036854775807.<br />
<br />
===='''Kommazahl-Typen:'''====<br />
double: Zahlen mit Kommastellen, aber auch ohne. Double wird verwendet, da die Ganzzahl-Typen keine Kommastellen speichern können.<br />
<br />
===='''Boolean:'''====<br />
boolean: kann zwei Werte annehmen, entweder true oder false, also wahr oder falsch.<br />
<br />
===='''Char'''====<br />
char: kann den Wert eines Unicodezeichens annehmen, also beispielsweise einen Buchstaben oder eine Zahl von 0-9.<br />
<br />
<u>Syntax</u> <br />
<br />
char i = 'J'<br />
<br />
===='''String'''====<br />
String: kann die Werte einer Zeichenkette annehmen<br />
<br />
ACHTUNG: Der Typ String muss in Java mit einem großen 'S' geschrieben werden.<br />
<br />
<u>Syntax</u> <br />
<br />
String java = "Hello World!"<br />
<br />
===='''Array'''====<br />
array[]: eine Reihung von Zahlen: man kann jeder Stelle eines Arrays eine bestimmte Zahl zuweisen.<br />
<br />
<u>''Syntax''</u> <br />
<br />
<u>Erstellen eines Arrays mit der Länge u</u><br />
<br />
int[] example = new int[u]<br />
<br />
<u>Erstellen eines Arrays mit bestimmten vorgegebenen Werten</u><br />
<br />
int example[] = {0, 3, 5, 10, 20, 25}<br />
<br />
<u>Die Ausgaben kann folgendermaßen aussehen</u><br />
<br />
example[3] == 10;<br />
<br />
example[4] == 20;<br />
<br />
<u>Zuweisung eines Wertes für eine Arraystelle:</u><br />
<br />
example[1] = 4;<br />
<br />
Die abgeänderte Reihung besitzt nun folgende Werte: {0, 4, 5, 10, 20, 25}<br />
<br />
<br /><br />
===Arithmetische Operatoren===<br />
=====Grundlagen=====<br />
In der Programmiersprache Java sind arithmetische Operatoren implementiert. Dabei müssen immer numerische Operanten (int, long, float, double) verwendet werden.<br />
=====Operatoren=====<br />
======Addition======<br />
Der Operator der Addition (a+b) addiert einen numerischen Operanden mit einem weiteren numerischen Operanden.<br />
<br />
public class Addition {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a + b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 10<br />
======Subtraktion======<br />
Der Operator der Subtraktion (a-b) subtrahiert einen numerischen Operanden von einem anderen numerischen Operator.<br />
<br />
public class Subtraktion {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a - b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 4 <br />
======Multiplikation======<br />
Der Operator der Multiplikation (a*b) multipliziert einen numerischen Operanden mit einem anderen numerischen Operanden.<br />
<br />
public class Multiplikation {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a * b;<br />
System.out.print(ergebnis);<br />
}<br />
} <br />
<br />
Ausgabe = 21<br />
======Division======<br />
Der Operator der Division (a/b) dividiert einen numerischen Operanden durch einen anderen numerischen Operanden. <br />
<u>Division zweier numerischer Operanden gleichen Typs:</u><br />
In diesem Fall sind die beiden numerischen Operanden ganzzahlig, daher ist auch das Ergebnis ganzzahlig:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 2<br />
<br />
<u> Division zweier numerischer Operanden unterschiedlichen Typs </u><br />
Es ist möglich numerische Operanden unterschiedlichen Typs zu dividieren. Ist einer der numerischen Operanden als Gleitkommazahl definiert, so ist auch das Ergebnis eine Gleitkommazahl:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
float b = 3;<br />
<br />
errgebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe: 2.3333333<br />
<br />
======Division mit Rest======<br />
Bei der Division mit Rest (modulo) dividiert einen numerischen Operanden durch einen zweiten numerischen Operanden (a%b). Dabei wird der ganzzahlige Rest als Ergebnis ausgegeben:<br />
<br />
public class Modulodivision {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a % b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 1<br />
===Verzweigungen===<br />
<br />
====Einführung====<br />
Verzweigungen gehören zu den Kontrollstrukturen Javas, die einen flexiblen und ereignisgesteuerten Ablauf eines Programmes ermöglichen. Für die Verzweigungen braucht man festgelegte Bedingungen. Beim Durchlauf des Programmes wird dann an den Verzweigungen überprüft, ob die Bedingung erfüllt wird oder nicht. Je nachdem welcher Fall zutrifft, wird ein bestimmter Bereich des Programmes ausgeführt. Im Folgenden unterscheiden wir in drei Verzweigungen: ''if''-Anweisung, ''if''-''else''-Anweisung und ''else-if''-Anweisung.<br /><br />
<br />
====''if''-''Anweisung''====<br />
Bei der ''if''-Anweisung wird als erstes überprüft, ob die gestellte Bedingung erfüllt wird oder nicht. Wird die Bedingung erfüllt, werden die danach folgenden Anweisungen ausgeführt. Wird die Bedingung nicht erfüllt, werden die danach folgenden Anweisungen übersprungen. In Java sieht die ''if''-Anweisung so aus:<br />
<br />
if (Bedingung){<br />
Anweisung;<br />
}<br />
<br /><br />
====''if-else''-Anweisung====<br />
Die ''if-else''-Anweisung ist im Prinzip nur eine Erweiterung der ''if''-Anweisung, bei der festgelegt wird, welche Anweisungen ausgeführt werden sollen, wenn die Bedingung nicht erfüllt wird. Man hat also zwei mögliche Fälle. In Java sieht die ''if-else''-Anweisung so aus:<br />
<br />
if (Bedingung) {<br />
Anweisung1;<br />
} <br />
else {<br />
Anweisung2;<br />
}<br />
<br /><br />
<br />
====''else-if''-Anweisung====<br />
Wenn man eine Verzweigung in drei verschiedene Programmbereiche braucht, kann man die ''else-if''-Anweisung verwenden. Bei der''else-if''-Anweisung wird erstmal überprüft, ob die erste Bedingung zutrifft. Wenn diese Bedingung zutrifft, wird der erste Programmbereich durchlaufen. Wenn diese Bedingung nicht zutrifft, wird zur nächsten Prüfung einer Bedingung gesprungen. Wenn diese zweite Bedingung zutrifft, dann werden die dazugehörigen Anweisungen ausgeführt. Wenn diese zweite Bedingung nicht zutrifft, dann wird zum letzten Teil der ''else-if''-Anweisung gesprungen und der letzte Programmbereich ausgeführt. In Java sieht die ''else-if''-Anweisung so aus: <br />
<br />
if (Bedingung1) {<br />
Anweisung1;<br />
} else if (Bedingung2) {<br />
Anweisung2;<br />
} else {<br />
Anweisung3;<br />
}<br />
<br />
<br /><br />
===Schleifen===<br />
'''FOR-Schleife'''<br />
<br />
Die sogenannte FOR-Scheife wird verwendet, wenn man die benötigten Schleifendurchläufe bereits im Voraus kennt. Man benötigt die folgenden drei Parameter: Initialisierung/Startwert, Zielwert und Schrittweite<br />
<br />
<u>Syntax</u><br />
<br />
for(Startwert; Zielwert; Schrittweite)<br />
<br />
<u>Beispiel</u><br />
<br />
for(int i = 1; i < 3; i++) {<br />
gehe 10 Schritte;<br />
}<br />
<br />
Mit dieser Schleife wird bei i == 1 10 Schritte gegangen und bei i == 2 ebenfalls, bei i == 3 nicht mehr, da der Zielwert erreicht ist.<br />
<br />
'''WHILE-Schleife'''<br />
<br />Die sogenannte WHILE-Schleife wird solange ausgeführt, bis eine bestimmte Bedingung nicht erfüllt ist. Diese Bedingung steht am Anfang der Schleife. Sofern die Bedingung anfangs nicht erfüllt wird, wird die Schleife übersprungen.<br />
<br />
<u>Syntax</u><br />
<br />
while(Bedingung) {<br />
Anweisung;<br />
}<br />
<u>Beispiel</u><br />
<br />
boolean correct = true;<br />
while(correct) {<br />
gehe 10 Schritte;<br />
correct = false;<br />
}<br />
Die Schleife wird einmal ausgeführt, da die Bedingung anfangs korrekt und danach nicht mehr korrekt ist.<br />
<br />
<br />
'''DO-WHILE-Schleife'''<br />
<br />
Die sogenannte DO-WHILE-Schleife ist eine WHILE-SCHLEIFE mit dem Unterschied, dass die Anweisung mindestens einmal ausgeführt wird, hierbei ist es anfangs egal, ob die Bedingung erfüllt ist oder nicht.<br />
<br />
<u>Syntax</u><br />
<br />
do {<br />
Anweisung;<br />
} while(Bedingung);<br />
<u>Beispiel</u><br />
<br />
int o = 1;<br />
do {<br />
gehe 10 Schritte;<br />
} while(o == 2);<br />
Diese Schleife wird einmal ausgeführt, danach nicht mehr, da die Bedingung nicht erfüllt wird.<br />
<br />
<br /><br />
<br />
===Reihungen===<br />
<br>'''Definition'''<p><br />
Eine Reihung besteht aus einer Anzahl von Werten des gleichen Datentyps. Sie alle werden unter einem Namen geführt und unterscheiden sich nur in den Feldnummern, welche die Position in der Reihung bestimmt.<p><br />
<p><br />
'''Arten von Reihungen'''<p><br />
Es gibt verschiedene Arten von Reihungen. Diese unterscheiden sich in dem Datentyp der Variablen, die in ihnen gespeichert sind.<br />
<br />
*<p> int[] a; Reihung aus ganzen Zahlen<br />
*<p> char[] b; Reihungen aus Zeichen<br />
*<p> boolean[] c; Reihung aus Wahrheitswerten<br />
*<p> int[][] d; Mehrdimensionale Reihung, dabei ist in jedem Element ein eigenes Array enthalten. Jede Dimension wird durch ein paar eckige Klammern dargestellt.<p> <p>'''Deklaration von Reihungen'''<br />
<p><br />
Reihungen werden grundsätzlich mit dem Operator <b> new </b>deklariert.<br />
<p><br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = new int[5]<br />
<br />
oder<br />
<br />
int[] b;<br />
a = new int[5]<br />
</syntaxhighlight><p><br />
In diesen Beispielen erzeugen wir zwei Reihungen mit je 5 Elementen, welche jedoch noch keine Werte enthalten.<br />
<P><p><br />
'''Initialisierung von Reihungen'''<p><br />
Bei der Initialisierung werden die im vorigen Kapitel erstellten Reihungen mit Werten gefüllt. Dafür gibt es verschiedene Möglichkeiten:<br /><br />
<br />
#Möchte man eine Reihung mit bereits bekannten Werten initialisieren, fällt der Operator <b> new </b> weg. Die eckigen Klammern werden durch geschwungene ersetzt innerhalb welcher alle Werte, durch ein Komma getrennt, eingetragen werden. Hier wird die Reihung also gleichzeitig '''deklariert''' und '''initialisiert'''. Beispiel:<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
</syntaxhighlight>In diesem Beispiel erzeugen wir eine Reihungen mit einer Länge von 5 Elementen mit den Werten 1, 2, 3, 4 und 5. <br /><br />
#Man kann eine Reihung auch initialisieren, indem man die Positionen einzeln mit Werten befüllt. Beispiel:<syntaxhighlight lang="java"><br />
b[0] = 1;<br />
b[1] = 2;<br />
b[2] = 3;<br />
b[3] = 4;<br />
b[4] = 5; <br />
</syntaxhighlight>Hier werden die verschiedenen Positionen der Reihung einzeln mit Werten gefüllt.<br />
<br />
'''Achtung:''' Dabei wird die Position bei 0 beginnend gezählt. Also befindet sich die erste Zahl in der Reihung auf Position 0, die zweite Zahl in der Reihung auf Position 2 und so weiter...<br />
<br />
<br />
'''Auslesen von Werten'''<br />
<br />
Um Werte aus einer Reihung auszulesen, muss man den Namen der Reihung, sowie die Position des Elements in der Reihung auswählen. <br />
<br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
<br />
Dann gilt:<br />
a[3] = 4<br />
</syntaxhighlight></div>12jojo08https://projekte.zum.de/index.php?title=Informatik_am_Johanneum/Java&diff=41437Informatik am Johanneum/Java2021-01-16T15:15:44Z<p>12jojo08: </p>
<hr />
<div>===Offene Aufgaben===<br />
<br />
Bitte tragt in die Tabellen ein, welches Thema ihr bearbeiten wollt. Erst wenn ihr euch in der Tabelle für ein Thema eingetragen habt, könnt ihr mit der Bearbeitung beginnen. Ihr könnt Themen auch zu zweit erstellen.<br />
<br />
{| class="wikitable"<br />
|+offene Aufgaben<br />
!offene Aufgabe!!Verantwortlicher<br />
|-<br />
|Klassen in Eclipse anlegen||Erik<br />
|-<br />
|Variablentypen<br />
|Vinzent/J-P<br />
|-<br />
|eigene Methoden schreiben, Syntax der Signatur, return Statement<br />
|<br />
|-<br />
|typische Fehlermeldungen, IndexOutOfBoundsExcecption<br />
|<br />
|-<br />
|Arithmetische Operatoren<br />
|Niklas<br />
|-<br />
|Verzweigungen<br />
|Finn, Nikita<br />
|-<br />
|Schleifen (For-Schleife, While Schleife)<br />
|Vinzent/J-P<br />
|-<br />
|Reihungen (Initialisierung, ...)<br />
|Arian, Dharam<br />
|-<br />
|<br />
|<br />
|}<br />
<br />
Tipps zur Erstellung eines Eintrags: <br />
<br />
*jedes Thema hat eine Überschrift von Typ Unterüberschrift1<br />
*Verwende danach für die einzelnen Teilthemen Unterüberschrift2 oder weitere Unterüberschriften. So erscheinen diese Felder im Inhaltsverzeichnis.<br />
*Quellcode kann eingefügt werden, indem die Zeile im Modus Quelltextbearbeitung mit einem Leerzeichen begonnen wird.<br />
<br />
public void quellcodeSchreiben(){<br />
// dies ist ein Beispiel, wie Quellcode dargestellt werden kann.<br />
// wechsele dazu in den Modus Quelltextbearbeitung (oben rechts bei dem Stft)<br />
// beginne dann jede Quelltextzeile mit einem Leerzeichen.<br />
}<br />
<br /><br />
===Klassen in Eclipse anlegen===<br />
<br /><br />
===Variablentypen===<br />
In Java gibt es verschiedene Typen von Variablen. Einige davon werden im Folgenden erläutert.<br />
<br />
===='''Syntax einer Variable:'''====<br />
Erste Erstellung: Typ + Name = Wert -> Beispiel: int number = 3 / boolean correct = false<br />
<br />
Spätere Bearbeitung: Name = Wert -> Beispiel: number = 1 / correct = true<br />
<br />
Abfrage (z.B. in IF/ELSE Anfragen oder WHILE-Schleifen): Name == Wert -> number == 1 / correct == true<br />
<br />
===='''Ganzzahl-Typen:'''====<br />
integer (int): alle Zahlen zwischen -2147483648 und 2147483647.<br />
<br />
long: alle Zahlen zwischen -9223372036854775808 und 9223372036854775807.<br />
<br />
===='''Kommazahl-Typen:'''====<br />
double: Zahlen mit Kommastellen, aber auch ohne. Double wird verwendet, da die Ganzzahl-Typen keine Kommastellen speichern können.<br />
<br />
===='''Boolean:'''====<br />
boolean: kann zwei Werte annehmen, entweder true oder false, also wahr oder falsch.<br />
<br />
===='''Char'''====<br />
char: kann den Wert eines Unicodezeichens annehmen, also beispielsweise einen Buchstaben oder eine Zahl von 0-9.<br />
<br />
<u>Syntax</u> <br />
<br />
char i = 'J'<br />
<br />
===='''String'''====<br />
String: kann die Werte einer Zeichenkette annehmen<br />
<br />
ACHTUNG: Der Typ String muss in Java mit einem großen 'S' geschrieben werden.<br />
<br />
<u>Syntax</u> <br />
<br />
String java = "Hello World!"<br />
<br />
===='''Array'''====<br />
array[]: eine Reihung von Zahlen: man kann jeder Stelle eines Arrays eine bestimmte Zahl zuweisen.<br />
<br />
<u>''Syntax''</u> <br />
<br />
<u>Erstellen eines Arrays mit der Länge u</u><br />
<br />
int[] example = new int[u]<br />
<br />
<u>Erstellen eines Arrays mit bestimmten vorgegebenen Werten</u><br />
<br />
int example[] = {0, 3, 5, 10, 20, 25}<br />
<br />
<u>Die Ausgaben kann folgendermaßen aussehen</u><br />
<br />
example[3] == 10;<br />
<br />
example[4] == 20;<br />
<br />
<u>Zuweisung eines Wertes für eine Arraystelle:</u><br />
<br />
example[1] = 4;<br />
<br />
Die abgeänderte Reihung besitzt nun folgende Werte: {0, 4, 5, 10, 20, 25}<br />
<br />
<br /><br />
===Arithmetische Operatoren===<br />
=====Grundlagen=====<br />
In der Programmiersprache Java sind arithmetische Operatoren implementiert. Dabei müssen immer numerische Operanten (int, long, float, double) verwendet werden.<br />
=====Operatoren=====<br />
======Addition======<br />
Der Operator der Addition (a+b) addiert einen numerischen Operanden mit einem weiteren numerischen Operanden.<br />
<br />
public class Addition {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a + b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 10<br />
======Subtraktion======<br />
Der Operator der Subtraktion (a-b) subtrahiert einen numerischen Operanden von einem anderen numerischen Operator.<br />
<br />
public class Subtraktion {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a - b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 4 <br />
======Multiplikation======<br />
Der Operator der Multiplikation (a*b) multipliziert einen numerischen Operanden mit einem anderen numerischen Operanden.<br />
<br />
public class Multiplikation {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a * b;<br />
System.out.print(ergebnis);<br />
}<br />
} <br />
<br />
Ausgabe = 21<br />
======Division======<br />
Der Operator der Division (a/b) dividiert einen numerischen Operanden durch einen anderen numerischen Operanden. <br />
<u>Division zweier numerischer Operanden gleichen Typs:</u><br />
In diesem Fall sind die beiden numerischen Operanden ganzzahlig, daher ist auch das Ergebnis ganzzahlig:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 2<br />
<br />
<u> Division zweier numerischer Operanden unterschiedlichen Typs </u><br />
Es ist möglich numerische Operanden unterschiedlichen Typs zu dividieren. Ist einer der numerischen Operanden als Gleitkommazahl definiert, so ist auch das Ergebnis eine Gleitkommazahl:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
float b = 3;<br />
<br />
errgebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe: 2.3333333<br />
<br />
======Division mit Rest======<br />
Bei der Division mit Rest (modulo) dividiert einen numerischen Operanden durch einen zweiten numerischen Operanden (a%b). Dabei wird der ganzzahlige Rest als Ergebnis ausgegeben:<br />
<br />
public class Modulodivision {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a % b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 1<br />
===Verzweigungen===<br />
<br />
====Einführung====<br />
Verzweigungen gehören zu den Kontrollstrukturen Javas, die einen flexiblen und ereignisgesteuerten Ablauf eines Programmes ermöglichen. Für die Verzweigungen braucht man festgelegte Bedingungen. Beim Durchlauf des Programmes wird dann an den Verzweigungen überprüft, ob die Bedingung erfüllt wird oder nicht. Je nachdem welcher Fall zutrifft, wird ein bestimmter Bereich des Programmes ausgeführt. Im Folgenden unterscheiden wir in drei Verzweigungen: ''if''-Anweisung, ''if''-''else''-Anweisung und ''else-if''-Anweisung.<br /><br />
<br />
====''if''-''Anweisung''====<br />
Bei der ''if''-Anweisung wird als erstes überprüft, ob die gestellte Bedingung erfüllt wird oder nicht. Wird die Bedingung erfüllt, werden die danach folgenden Anweisungen ausgeführt. Wird die Bedingung nicht erfüllt, werden die danach folgenden Anweisungen übersprungen. In Java sieht die ''if''-Anweisung so aus:<br />
<br />
if (Bedingung){<br />
Anweisung;<br />
}<br />
<br /><br />
====''if-else''-Anweisung====<br />
Die ''if-else''-Anweisung ist im Prinzip nur eine Erweiterung der ''if''-Anweisung, bei der festgelegt wird, welche Anweisungen ausgeführt werden sollen, wenn die Bedingung nicht erfüllt wird. Man hat also zwei mögliche Fälle. In Java sieht die ''if-else''-Anweisung so aus:<br />
<br />
if (Bedingung) {<br />
Anweisung1;<br />
} <br />
else {<br />
Anweisung2;<br />
}<br />
<br /><br />
<br />
====''else-if''-Anweisung====<br />
Wenn man eine Verzweigung in drei verschiedene Programmbereiche braucht, kann man die ''else-if''-Anweisung verwenden. Bei der''else-if''-Anweisung wird erstmal überprüft, ob die erste Bedingung zutrifft. Wenn diese Bedingung zutrifft, wird der erste Programmbereich durchlaufen. Wenn diese Bedingung nicht zutrifft, wird zur nächsten Prüfung einer Bedingung gesprungen. Wenn diese zweite Bedingung zutrifft, dann werden die dazugehörigen Anweisungen ausgeführt. Wenn diese zweite Bedingung nicht zutrifft, dann wird zum letzten Teil der ''else-if''-Anweisung gesprungen und der letzte Programmbereich ausgeführt. In Java sieht die ''else-if''-Anweisung so aus: <br />
<br />
if (Bedingung1) {<br />
Anweisung1;<br />
} else if (Bedingung2) {<br />
Anweisung2;<br />
} else {<br />
Anweisung3;<br />
}<br />
<br />
<br /><br />
===Schleifen===<br />
'''FOR-Schleife'''<br />
<br />
Die sogenannte FOR-Scheife wird verwendet, wenn man die benötigten Schleifendurchläufe bereits im Voraus kennt. Man benötigt die folgenden drei Parameter: Initialisierung/Startwert, Zielwert und Schrittweite<br />
<br />
<u>Syntax</u><br />
<br />
for(Startwert; Zielwert; Schrittweite)<br />
<br />
<u>Beispiel</u><br />
<br />
for(int i = 1; i < 3; i++) {<br />
gehe 10 Schritte;<br />
}<br />
<br />
Mit dieser Schleife wird bei i == 1 10 Schritte gegangen und bei i == 2 ebenfalls, bei i == 3 nicht mehr, da der Zielwert erreicht ist.<br />
<br />
'''WHILE-Schleife'''<br />
<br />Die sogenannte WHILE-Schleife wird solange ausgeführt, bis eine bestimmte Bedingung nicht erfüllt ist. Diese Bedingung steht am Anfang der Schleife. Sofern die Bedingung anfangs nicht erfüllt wird, wird die Schleife übersprungen.<br />
<br />
<u>Syntax</u><br />
<br />
while(Bedingung) {<br />
Anweisung;<br />
}<br />
<u>Beispiel</u><br />
<br />
boolean correct = true;<br />
while(correct) {<br />
gehe 10 Schritte;<br />
correct = false;<br />
}<br />
Die Schleife wird einmal ausgeführt, da die Bedingung anfangs korrekt und danach nicht mehr korrekt ist.<br />
<br />
<br />
'''DO-WHILE-Schleife'''<br />
<br />
Die sogenannte DO-WHILE-Schleife ist eine WHILE-SCHLEIFE mit dem Unterschied, dass die Anweisung mindestens einmal ausgeführt wird, hierbei ist es anfangs egal, ob die Bedingung erfüllt ist oder nicht.<br />
<br />
<u>Syntax</u><br />
<br />
do {<br />
Anweisung;<br />
} while(Bedingung);<br />
<u>Beispiel</u><br />
<br />
int o = 1;<br />
do {<br />
gehe 10 Schritte;<br />
} while(o == 2);<br />
Diese Schleife wird einmal ausgeführt, danach nicht mehr, da die Bedingung nicht erfüllt wird.<br />
<br />
<br /><br />
<br />
===Reihungen===<br />
<br>'''Definition'''<p><br />
Eine Reihung besteht aus einer Anzahl von Werten des gleichen Datentyps. Sie alle werden unter einem Namen geführt und unterscheiden sich nur in den Feldnummern, welche die Position in der Reihung bestimmt.<p><br />
<p><br />
'''Arten von Reihungen'''<p><br />
Es gibt verschiedene Arten von Reihungen. Diese unterscheiden sich in dem Datentyp der Variablen, die in ihnen gespeichert sind.<br />
<br />
*<p> int[] a; Reihung aus ganzen Zahlen<br />
*<p> char[] b; Reihungen aus Zeichen<br />
*<p> boolean[] c; Reihung aus Wahrheitswerten<br />
*<p> int[][] d; Mehrdimensionale Reihung, dabei ist in jedem Element ein eigenes Array enthalten. Jede Dimension wird durch ein paar eckige Klammern dargestellt.<p> <p>'''Deklaration von Reihungen'''<br />
<p><br />
Reihungen werden grundsätzlich mit dem Operator <b> new </b>deklariert.<br />
<p><br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = new int[5]<br />
<br />
oder<br />
<br />
int[] b;<br />
a = new int[5]<br />
</syntaxhighlight><p><br />
In diesen Beispielen erzeugen wir zwei Reihungen mit je 5 Elementen, welche jedoch noch keine Werte enthalten.<br />
<P><p><br />
'''Initialisierung von Reihungen'''<p><br />
Bei der Initialisierung werden die im vorigen Kapitel erstellten Reihungen mit Werten gefüllt. Dafür gibt es verschiedene Möglichkeiten:<br /><br />
<br />
#Möchte man eine Reihung mit bereits bekannten Werten initialisieren, fällt der Operator <b> new </b> weg. Die eckigen Klammern werden durch geschwungene ersetzt innerhalb welcher alle Werte, durch ein Komma getrennt, eingetragen werden. Hier wird die Reihung also gleichzeitig '''deklariert''' und '''initialisiert'''. Beispiel:<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
</syntaxhighlight>In diesem Beispiel erzeugen wir eine Reihungen mit einer Länge von 5 Elementen mit den Werten 1, 2, 3, 4 und 5. <br /><br />
#Man kann eine Reihung auch initialisieren, indem man die Positionen einzeln mit Werten befüllt. Beispiel:<syntaxhighlight lang="java"><br />
b[0] = 1;<br />
b[1] = 2;<br />
b[2] = 3;<br />
b[3] = 4;<br />
b[4] = 5; <br />
</syntaxhighlight>Hier werden die verschiedenen Positionen der Reihung einzeln mit Werten gefüllt.<br />
<br />
'''Achtung:''' Dabei wird die Position bei 0 beginnend gezählt. Also befindet sich die erste Zahl in der Reihung auf Position 0, die zweite Zahl in der Reihung auf Position 2 und so weiter...<br />
<br />
'''Auslesen von Werten'''<br />
<br />
Um Werte aus einer Reihung auszulesen, muss man den Namen der Reihung, sowie die Position des Elements in der Reihung auswählen. <br />
<br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
<br />
Dann gilt:<br />
a[3] = 4<br />
</syntaxhighlight></div>12jojo08https://projekte.zum.de/index.php?title=Informatik_am_Johanneum/Java&diff=41436Informatik am Johanneum/Java2021-01-16T15:15:06Z<p>12jojo08: </p>
<hr />
<div>===Offene Aufgaben===<br />
<br />
Bitte tragt in die Tabellen ein, welches Thema ihr bearbeiten wollt. Erst wenn ihr euch in der Tabelle für ein Thema eingetragen habt, könnt ihr mit der Bearbeitung beginnen. Ihr könnt Themen auch zu zweit erstellen.<br />
<br />
{| class="wikitable"<br />
|+offene Aufgaben<br />
!offene Aufgabe!!Verantwortlicher<br />
|-<br />
|Klassen in Eclipse anlegen||Erik<br />
|-<br />
|Variablentypen<br />
|Vinzent/J-P<br />
|-<br />
|eigene Methoden schreiben, Syntax der Signatur, return Statement<br />
|<br />
|-<br />
|typische Fehlermeldungen, IndexOutOfBoundsExcecption<br />
|<br />
|-<br />
|Arithmetische Operatoren<br />
|Niklas<br />
|-<br />
|Verzweigungen<br />
|Finn, Nikita<br />
|-<br />
|Schleifen (For-Schleife, While Schleife)<br />
|Vinzent/J-P<br />
|-<br />
|Reihungen (Initialisierung, ...)<br />
|Arian, Dharam<br />
|-<br />
|<br />
|<br />
|}<br />
<br />
Tipps zur Erstellung eines Eintrags: <br />
<br />
*jedes Thema hat eine Überschrift von Typ Unterüberschrift1<br />
*Verwende danach für die einzelnen Teilthemen Unterüberschrift2 oder weitere Unterüberschriften. So erscheinen diese Felder im Inhaltsverzeichnis.<br />
*Quellcode kann eingefügt werden, indem die Zeile im Modus Quelltextbearbeitung mit einem Leerzeichen begonnen wird.<br />
<br />
public void quellcodeSchreiben(){<br />
// dies ist ein Beispiel, wie Quellcode dargestellt werden kann.<br />
// wechsele dazu in den Modus Quelltextbearbeitung (oben rechts bei dem Stft)<br />
// beginne dann jede Quelltextzeile mit einem Leerzeichen.<br />
}<br />
<br /><br />
===Klassen in Eclipse anlegen===<br />
<br /><br />
===Variablentypen===<br />
In Java gibt es verschiedene Typen von Variablen. Einige davon werden im Folgenden erläutert.<br />
<br />
===='''Syntax einer Variable:'''====<br />
Erste Erstellung: Typ + Name = Wert -> Beispiel: int number = 3 / boolean correct = false<br />
<br />
Spätere Bearbeitung: Name = Wert -> Beispiel: number = 1 / correct = true<br />
<br />
Abfrage (z.B. in IF/ELSE Anfragen oder WHILE-Schleifen): Name == Wert -> number == 1 / correct == true<br />
<br />
===='''Ganzzahl-Typen:'''====<br />
integer (int): alle Zahlen zwischen -2147483648 und 2147483647.<br />
<br />
long: alle Zahlen zwischen -9223372036854775808 und 9223372036854775807.<br />
<br />
===='''Kommazahl-Typen:'''====<br />
double: Zahlen mit Kommastellen, aber auch ohne. Double wird verwendet, da die Ganzzahl-Typen keine Kommastellen speichern können.<br />
<br />
===='''Boolean:'''====<br />
boolean: kann zwei Werte annehmen, entweder true oder false, also wahr oder falsch.<br />
<br />
===='''Char'''====<br />
char: kann den Wert eines Unicodezeichens annehmen, also beispielsweise einen Buchstaben oder eine Zahl von 0-9.<br />
<br />
<u>Syntax</u> <br />
<br />
char i = 'J'<br />
<br />
===='''String'''====<br />
String: kann die Werte einer Zeichenkette annehmen<br />
<br />
ACHTUNG: Der Typ String muss in Java mit einem großen 'S' geschrieben werden.<br />
<br />
<u>Syntax</u> <br />
<br />
String java = "Hello World!"<br />
<br />
===='''Array'''====<br />
array[]: eine Reihung von Zahlen: man kann jeder Stelle eines Arrays eine bestimmte Zahl zuweisen.<br />
<br />
<u>''Syntax''</u> <br />
<br />
<u>Erstellen eines Arrays mit der Länge u</u><br />
<br />
int[] example = new int[u]<br />
<br />
<u>Erstellen eines Arrays mit bestimmten vorgegebenen Werten</u><br />
<br />
int example[] = {0, 3, 5, 10, 20, 25}<br />
<br />
<u>Die Ausgaben kann folgendermaßen aussehen</u><br />
<br />
example[3] == 10;<br />
<br />
example[4] == 20;<br />
<br />
<u>Zuweisung eines Wertes für eine Arraystelle:</u><br />
<br />
example[1] = 4;<br />
<br />
Die abgeänderte Reihung besitzt nun folgende Werte: {0, 4, 5, 10, 20, 25}<br />
<br />
<br /><br />
===Arithmetische Operatoren===<br />
=====Grundlagen=====<br />
In der Programmiersprache Java sind arithmetische Operatoren implementiert. Dabei müssen immer numerische Operanten (int, long, float, double) verwendet werden.<br />
=====Operatoren=====<br />
======Addition======<br />
Der Operator der Addition (a+b) addiert einen numerischen Operanden mit einem weiteren numerischen Operanden.<br />
<br />
public class Addition {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a + b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 10<br />
======Subtraktion======<br />
Der Operator der Subtraktion (a-b) subtrahiert einen numerischen Operanden von einem anderen numerischen Operator.<br />
<br />
public class Subtraktion {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a - b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 4 <br />
======Multiplikation======<br />
Der Operator der Multiplikation (a*b) multipliziert einen numerischen Operanden mit einem anderen numerischen Operanden.<br />
<br />
public class Multiplikation {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a * b;<br />
System.out.print(ergebnis);<br />
}<br />
} <br />
<br />
Ausgabe = 21<br />
======Division======<br />
Der Operator der Division (a/b) dividiert einen numerischen Operanden durch einen anderen numerischen Operanden. <br />
<u>Division zweier numerischer Operanden gleichen Typs:</u><br />
In diesem Fall sind die beiden numerischen Operanden ganzzahlig, daher ist auch das Ergebnis ganzzahlig:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 2<br />
<br />
<u> Division zweier numerischer Operanden unterschiedlichen Typs </u><br />
Es ist möglich numerische Operanden unterschiedlichen Typs zu dividieren. Ist einer der numerischen Operanden als Gleitkommazahl definiert, so ist auch das Ergebnis eine Gleitkommazahl:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
float b = 3;<br />
<br />
errgebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe: 2.3333333<br />
<br />
======Division mit Rest======<br />
Bei der Division mit Rest (modulo) dividiert einen numerischen Operanden durch einen zweiten numerischen Operanden (a%b). Dabei wird der ganzzahlige Rest als Ergebnis ausgegeben:<br />
<br />
public class Modulodivision {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a % b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 1<br />
===Verzweigungen===<br />
<br />
====Einführung====<br />
Verzweigungen gehören zu den Kontrollstrukturen Javas, die einen flexiblen und ereignisgesteuerten Ablauf eines Programmes ermöglichen. Für die Verzweigungen braucht man festgelegte Bedingungen. Beim Durchlauf des Programmes wird dann an den Verzweigungen überprüft, ob die Bedingung erfüllt wird oder nicht. Je nachdem welcher Fall zutrifft, wird ein bestimmter Bereich des Programmes ausgeführt. Im Folgenden unterscheiden wir in drei Verzweigungen: ''if''-Anweisung, ''if''-''else''-Anweisung und ''else-if''-Anweisung.<br /><br />
<br />
====''if''-''Anweisung''====<br />
Bei der ''if''-Anweisung wird als erstes überprüft, ob die gestellte Bedingung erfüllt wird oder nicht. Wird die Bedingung erfüllt, werden die danach folgenden Anweisungen ausgeführt. Wird die Bedingung nicht erfüllt, werden die danach folgenden Anweisungen übersprungen. In Java sieht die ''if''-Anweisung so aus:<br />
<br />
if (Bedingung){<br />
Anweisung;<br />
}<br />
<br /><br />
====''if-else''-Anweisung====<br />
Die ''if-else''-Anweisung ist im Prinzip nur eine Erweiterung der ''if''-Anweisung, bei der festgelegt wird, welche Anweisungen ausgeführt werden sollen, wenn die Bedingung nicht erfüllt wird. Man hat also zwei mögliche Fälle. In Java sieht die ''if-else''-Anweisung so aus:<br />
<br />
if (Bedingung) {<br />
Anweisung1;<br />
} <br />
else {<br />
Anweisung2;<br />
}<br />
<br /><br />
<br />
====''else-if''-Anweisung====<br />
Wenn man eine Verzweigung in drei verschiedene Programmbereiche braucht, kann man die ''else-if''-Anweisung verwenden. Bei der''else-if''-Anweisung wird erstmal überprüft, ob die erste Bedingung zutrifft. Wenn diese Bedingung zutrifft, wird der erste Programmbereich durchlaufen. Wenn diese Bedingung nicht zutrifft, wird zur nächsten Prüfung einer Bedingung gesprungen. Wenn diese zweite Bedingung zutrifft, dann werden die dazugehörigen Anweisungen ausgeführt. Wenn diese zweite Bedingung nicht zutrifft, dann wird zum letzten Teil der ''else-if''-Anweisung gesprungen und der letzte Programmbereich ausgeführt. In Java sieht die ''else-if''-Anweisung so aus: <br />
<br />
if (Bedingung1) {<br />
Anweisung1;<br />
} else if (Bedingung2) {<br />
Anweisung2;<br />
} else {<br />
Anweisung3;<br />
}<br />
<br />
<br /><br />
===Schleifen===<br />
'''FOR-Schleife'''<br />
<br />
Die sogenannte FOR-Scheife wird verwendet, wenn man die benötigten Schleifendurchläufe bereits im Voraus kennt. Man benötigt die folgenden drei Parameter: Initialisierung/Startwert, Zielwert und Schrittweite<br />
<br />
<u>Syntax</u><br />
<br />
for(Startwert; Zielwert; Schrittweite)<br />
<br />
<u>Beispiel</u><br />
<br />
for(int i = 1; i < 3; i++) {<br />
gehe 10 Schritte;<br />
}<br />
<br />
Mit dieser Schleife wird bei i == 1 10 Schritte gegangen und bei i == 2 ebenfalls, bei i == 3 nicht mehr, da der Zielwert erreicht ist.<br />
<br />
'''WHILE-Schleife'''<br />
<br />Die sogenannte WHILE-Schleife wird solange ausgeführt, bis eine bestimmte Bedingung nicht erfüllt ist. Diese Bedingung steht am Anfang der Schleife. Sofern die Bedingung anfangs nicht erfüllt wird, wird die Schleife übersprungen.<br />
<br />
<u>Syntax</u><br />
<br />
while(Bedingung) {<br />
Anweisung;<br />
}<br />
<u>Beispiel</u><br />
<br />
boolean correct = true;<br />
while(correct) {<br />
gehe 10 Schritte;<br />
correct = false;<br />
}<br />
Die Schleife wird einmal ausgeführt, da die Bedingung anfangs korrekt und danach nicht mehr korrekt ist.<br />
<br />
<br />
'''DO-WHILE-Schleife'''<br />
<br />
Die sogenannte DO-WHILE-Schleife ist eine WHILE-SCHLEIFE mit dem Unterschied, dass die Anweisung mindestens einmal ausgeführt wird, hierbei ist es anfangs egal, ob die Bedingung erfüllt ist oder nicht.<br />
<br />
<u>Syntax</u><br />
<br />
do {<br />
Anweisung;<br />
} while(Bedingung);<br />
<u>Beispiel</u><br />
<br />
int o = 1;<br />
do {<br />
gehe 10 Schritte;<br />
} while(o == 2);<br />
Diese Schleife wird einmal ausgeführt, danach nicht mehr, da die Bedingung nicht erfüllt wird.<br />
<br />
<br /><br />
<br />
===Reihungen===<br />
<br>'''Definition'''<p><br />
Eine Reihung besteht aus einer Anzahl von Werten des gleichen Datentyps. Sie alle werden unter einem Namen geführt und unterscheiden sich nur in den Feldnummern, welche die Position in der Reihung bestimmt.<p><br />
<p><br />
'''Arten von Reihungen'''<p><br />
Es gibt verschiedene Arten von Reihungen. Diese unterscheiden sich in dem Datentyp der Variablen, die in ihnen gespeichert sind.<br />
<br />
*<p> int[] a; Reihung aus ganzen Zahlen<br />
*<p> char[] b; Reihungen aus Zeichen<br />
*<p> boolean[] c; Reihung aus Wahrheitswerten<br />
*<p> int[][] d; Mehrdimensionale Reihung, dabei ist in jedem Element ein eigenes Array enthalten. Jede Dimension wird durch ein paar eckige Klammern dargestellt.<p> <p>'''Deklaration von Reihungen'''<br />
<p><br />
Reihungen werden grundsätzlich mit dem Operator <b> new </b>deklariert.<br />
<p><br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = new int[5]<br />
<br />
oder<br />
<br />
int[] b;<br />
a = new int[5]<br />
</syntaxhighlight><p><br />
In diesen Beispielen erzeugen wir zwei Reihungen mit je 5 Elementen, welche jedoch noch keine Werte enthalten.<br />
<P><p><br />
'''Initialisierung von Reihungen'''<p><br />
Bei der Initialisierung werden die im vorigen Kapitel erstellten Reihungen mit Werten gefüllt. Dafür gibt es verschiedene Möglichkeiten:<br /><br />
<br />
#Möchte man eine Reihung mit bereits bekannten Werten initialisieren, fällt der Operator <b> new </b> weg. Die eckigen Klammern werden durch geschwungene ersetzt innerhalb welcher alle Werte, durch ein Komma getrennt, eingetragen werden. Hier wird die Reihung also gleichzeitig '''deklariert''' und '''initialisiert'''. Beispiel:<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
</syntaxhighlight>In diesem Beispiel erzeugen wir eine Reihungen mit einer Länge von 5 Elementen mit den Werten 1, 2, 3, 4 und 5. <br /><br />
#Man kann eine Reihung auch initialisieren, indem man die Positionen einzeln mit Werten befüllt. Beispiel:<syntaxhighlight lang="java"><br />
b[0] = 1;<br />
b[1] = 2;<br />
b[2] = 3;<br />
b[3] = 4;<br />
b[4] = 5; <br />
</syntaxhighlight>Hier werden die verschiedenen Positionen der Reihung einzeln mit Werten gefüllt.<br />
<br />
'''Achtung:''' Dabei wird die Position bei 0 beginnend gezählt. Also befindet sich die erste Zahl in der Reihung auf Position 0, die zweite Zahl in der Reihung auf Position 2 und so weiter...<br />
<br />
<br />
<br />
'''Auslesen von Werten'''<br />
<br />
Um Werte aus einer Reihung auszulesen, muss man den Namen der Reihung, sowie die Position des Elements in der Reihung auswählen. <br />
<br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
<br />
Dann gilt:<br />
a[3] = 4<br />
</syntaxhighlight></div>12jojo08https://projekte.zum.de/index.php?title=Informatik_am_Johanneum/Java&diff=41435Informatik am Johanneum/Java2021-01-16T15:14:50Z<p>12jojo08: </p>
<hr />
<div>===Offene Aufgaben===<br />
<br />
Bitte tragt in die Tabellen ein, welches Thema ihr bearbeiten wollt. Erst wenn ihr euch in der Tabelle für ein Thema eingetragen habt, könnt ihr mit der Bearbeitung beginnen. Ihr könnt Themen auch zu zweit erstellen.<br />
<br />
{| class="wikitable"<br />
|+offene Aufgaben<br />
!offene Aufgabe!!Verantwortlicher<br />
|-<br />
|Klassen in Eclipse anlegen||Erik<br />
|-<br />
|Variablentypen<br />
|Vinzent/J-P<br />
|-<br />
|eigene Methoden schreiben, Syntax der Signatur, return Statement<br />
|<br />
|-<br />
|typische Fehlermeldungen, IndexOutOfBoundsExcecption<br />
|<br />
|-<br />
|Arithmetische Operatoren<br />
|Niklas<br />
|-<br />
|Verzweigungen<br />
|Finn, Nikita<br />
|-<br />
|Schleifen (For-Schleife, While Schleife)<br />
|Vinzent/J-P<br />
|-<br />
|Reihungen (Initialisierung, ...)<br />
|Arian, Dharam<br />
|-<br />
|<br />
|<br />
|}<br />
<br />
Tipps zur Erstellung eines Eintrags: <br />
<br />
*jedes Thema hat eine Überschrift von Typ Unterüberschrift1<br />
*Verwende danach für die einzelnen Teilthemen Unterüberschrift2 oder weitere Unterüberschriften. So erscheinen diese Felder im Inhaltsverzeichnis.<br />
*Quellcode kann eingefügt werden, indem die Zeile im Modus Quelltextbearbeitung mit einem Leerzeichen begonnen wird.<br />
<br />
public void quellcodeSchreiben(){<br />
// dies ist ein Beispiel, wie Quellcode dargestellt werden kann.<br />
// wechsele dazu in den Modus Quelltextbearbeitung (oben rechts bei dem Stft)<br />
// beginne dann jede Quelltextzeile mit einem Leerzeichen.<br />
}<br />
<br /><br />
===Klassen in Eclipse anlegen===<br />
<br /><br />
===Variablentypen===<br />
In Java gibt es verschiedene Typen von Variablen. Einige davon werden im Folgenden erläutert.<br />
<br />
===='''Syntax einer Variable:'''====<br />
Erste Erstellung: Typ + Name = Wert -> Beispiel: int number = 3 / boolean correct = false<br />
<br />
Spätere Bearbeitung: Name = Wert -> Beispiel: number = 1 / correct = true<br />
<br />
Abfrage (z.B. in IF/ELSE Anfragen oder WHILE-Schleifen): Name == Wert -> number == 1 / correct == true<br />
<br />
===='''Ganzzahl-Typen:'''====<br />
integer (int): alle Zahlen zwischen -2147483648 und 2147483647.<br />
<br />
long: alle Zahlen zwischen -9223372036854775808 und 9223372036854775807.<br />
<br />
===='''Kommazahl-Typen:'''====<br />
double: Zahlen mit Kommastellen, aber auch ohne. Double wird verwendet, da die Ganzzahl-Typen keine Kommastellen speichern können.<br />
<br />
===='''Boolean:'''====<br />
boolean: kann zwei Werte annehmen, entweder true oder false, also wahr oder falsch.<br />
<br />
===='''Char'''====<br />
char: kann den Wert eines Unicodezeichens annehmen, also beispielsweise einen Buchstaben oder eine Zahl von 0-9.<br />
<br />
<u>Syntax</u> <br />
<br />
char i = 'J'<br />
<br />
===='''String'''====<br />
String: kann die Werte einer Zeichenkette annehmen<br />
<br />
ACHTUNG: Der Typ String muss in Java mit einem großen 'S' geschrieben werden.<br />
<br />
<u>Syntax</u> <br />
<br />
String java = "Hello World!"<br />
<br />
===='''Array'''====<br />
array[]: eine Reihung von Zahlen: man kann jeder Stelle eines Arrays eine bestimmte Zahl zuweisen.<br />
<br />
<u>''Syntax''</u> <br />
<br />
<u>Erstellen eines Arrays mit der Länge u</u><br />
<br />
int[] example = new int[u]<br />
<br />
<u>Erstellen eines Arrays mit bestimmten vorgegebenen Werten</u><br />
<br />
int example[] = {0, 3, 5, 10, 20, 25}<br />
<br />
<u>Die Ausgaben kann folgendermaßen aussehen</u><br />
<br />
example[3] == 10;<br />
<br />
example[4] == 20;<br />
<br />
<u>Zuweisung eines Wertes für eine Arraystelle:</u><br />
<br />
example[1] = 4;<br />
<br />
Die abgeänderte Reihung besitzt nun folgende Werte: {0, 4, 5, 10, 20, 25}<br />
<br />
<br /><br />
===Arithmetische Operatoren===<br />
=====Grundlagen=====<br />
In der Programmiersprache Java sind arithmetische Operatoren implementiert. Dabei müssen immer numerische Operanten (int, long, float, double) verwendet werden.<br />
=====Operatoren=====<br />
======Addition======<br />
Der Operator der Addition (a+b) addiert einen numerischen Operanden mit einem weiteren numerischen Operanden.<br />
<br />
public class Addition {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a + b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 10<br />
======Subtraktion======<br />
Der Operator der Subtraktion (a-b) subtrahiert einen numerischen Operanden von einem anderen numerischen Operator.<br />
<br />
public class Subtraktion {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a - b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 4 <br />
======Multiplikation======<br />
Der Operator der Multiplikation (a*b) multipliziert einen numerischen Operanden mit einem anderen numerischen Operanden.<br />
<br />
public class Multiplikation {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a * b;<br />
System.out.print(ergebnis);<br />
}<br />
} <br />
<br />
Ausgabe = 21<br />
======Division======<br />
Der Operator der Division (a/b) dividiert einen numerischen Operanden durch einen anderen numerischen Operanden. <br />
<u>Division zweier numerischer Operanden gleichen Typs:</u><br />
In diesem Fall sind die beiden numerischen Operanden ganzzahlig, daher ist auch das Ergebnis ganzzahlig:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 2<br />
<br />
<u> Division zweier numerischer Operanden unterschiedlichen Typs </u><br />
Es ist möglich numerische Operanden unterschiedlichen Typs zu dividieren. Ist einer der numerischen Operanden als Gleitkommazahl definiert, so ist auch das Ergebnis eine Gleitkommazahl:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
float b = 3;<br />
<br />
errgebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe: 2.3333333<br />
<br />
======Division mit Rest======<br />
Bei der Division mit Rest (modulo) dividiert einen numerischen Operanden durch einen zweiten numerischen Operanden (a%b). Dabei wird der ganzzahlige Rest als Ergebnis ausgegeben:<br />
<br />
public class Modulodivision {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a % b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 1<br />
===Verzweigungen===<br />
<br />
====Einführung====<br />
Verzweigungen gehören zu den Kontrollstrukturen Javas, die einen flexiblen und ereignisgesteuerten Ablauf eines Programmes ermöglichen. Für die Verzweigungen braucht man festgelegte Bedingungen. Beim Durchlauf des Programmes wird dann an den Verzweigungen überprüft, ob die Bedingung erfüllt wird oder nicht. Je nachdem welcher Fall zutrifft, wird ein bestimmter Bereich des Programmes ausgeführt. Im Folgenden unterscheiden wir in drei Verzweigungen: ''if''-Anweisung, ''if''-''else''-Anweisung und ''else-if''-Anweisung.<br /><br />
<br />
====''if''-''Anweisung''====<br />
Bei der ''if''-Anweisung wird als erstes überprüft, ob die gestellte Bedingung erfüllt wird oder nicht. Wird die Bedingung erfüllt, werden die danach folgenden Anweisungen ausgeführt. Wird die Bedingung nicht erfüllt, werden die danach folgenden Anweisungen übersprungen. In Java sieht die ''if''-Anweisung so aus:<br />
<br />
if (Bedingung){<br />
Anweisung;<br />
}<br />
<br /><br />
====''if-else''-Anweisung====<br />
Die ''if-else''-Anweisung ist im Prinzip nur eine Erweiterung der ''if''-Anweisung, bei der festgelegt wird, welche Anweisungen ausgeführt werden sollen, wenn die Bedingung nicht erfüllt wird. Man hat also zwei mögliche Fälle. In Java sieht die ''if-else''-Anweisung so aus:<br />
<br />
if (Bedingung) {<br />
Anweisung1;<br />
} <br />
else {<br />
Anweisung2;<br />
}<br />
<br /><br />
<br />
====''else-if''-Anweisung====<br />
Wenn man eine Verzweigung in drei verschiedene Programmbereiche braucht, kann man die ''else-if''-Anweisung verwenden. Bei der''else-if''-Anweisung wird erstmal überprüft, ob die erste Bedingung zutrifft. Wenn diese Bedingung zutrifft, wird der erste Programmbereich durchlaufen. Wenn diese Bedingung nicht zutrifft, wird zur nächsten Prüfung einer Bedingung gesprungen. Wenn diese zweite Bedingung zutrifft, dann werden die dazugehörigen Anweisungen ausgeführt. Wenn diese zweite Bedingung nicht zutrifft, dann wird zum letzten Teil der ''else-if''-Anweisung gesprungen und der letzte Programmbereich ausgeführt. In Java sieht die ''else-if''-Anweisung so aus: <br />
<br />
if (Bedingung1) {<br />
Anweisung1;<br />
} else if (Bedingung2) {<br />
Anweisung2;<br />
} else {<br />
Anweisung3;<br />
}<br />
<br />
<br /><br />
===Schleifen===<br />
'''FOR-Schleife'''<br />
<br />
Die sogenannte FOR-Scheife wird verwendet, wenn man die benötigten Schleifendurchläufe bereits im Voraus kennt. Man benötigt die folgenden drei Parameter: Initialisierung/Startwert, Zielwert und Schrittweite<br />
<br />
<u>Syntax</u><br />
<br />
for(Startwert; Zielwert; Schrittweite)<br />
<br />
<u>Beispiel</u><br />
<br />
for(int i = 1; i < 3; i++) {<br />
gehe 10 Schritte;<br />
}<br />
<br />
Mit dieser Schleife wird bei i == 1 10 Schritte gegangen und bei i == 2 ebenfalls, bei i == 3 nicht mehr, da der Zielwert erreicht ist.<br />
<br />
'''WHILE-Schleife'''<br />
<br />Die sogenannte WHILE-Schleife wird solange ausgeführt, bis eine bestimmte Bedingung nicht erfüllt ist. Diese Bedingung steht am Anfang der Schleife. Sofern die Bedingung anfangs nicht erfüllt wird, wird die Schleife übersprungen.<br />
<br />
<u>Syntax</u><br />
<br />
while(Bedingung) {<br />
Anweisung;<br />
}<br />
<u>Beispiel</u><br />
<br />
boolean correct = true;<br />
while(correct) {<br />
gehe 10 Schritte;<br />
correct = false;<br />
}<br />
Die Schleife wird einmal ausgeführt, da die Bedingung anfangs korrekt und danach nicht mehr korrekt ist.<br />
<br />
<br />
'''DO-WHILE-Schleife'''<br />
<br />
Die sogenannte DO-WHILE-Schleife ist eine WHILE-SCHLEIFE mit dem Unterschied, dass die Anweisung mindestens einmal ausgeführt wird, hierbei ist es anfangs egal, ob die Bedingung erfüllt ist oder nicht.<br />
<br />
<u>Syntax</u><br />
<br />
do {<br />
Anweisung;<br />
} while(Bedingung);<br />
<u>Beispiel</u><br />
<br />
int o = 1;<br />
do {<br />
gehe 10 Schritte;<br />
} while(o == 2);<br />
Diese Schleife wird einmal ausgeführt, danach nicht mehr, da die Bedingung nicht erfüllt wird.<br />
<br />
<br /><br />
<br />
===Reihungen===<br />
<br>'''Definition'''<p><br />
Eine Reihung besteht aus einer Anzahl von Werten des gleichen Datentyps. Sie alle werden unter einem Namen geführt und unterscheiden sich nur in den Feldnummern, welche die Position in der Reihung bestimmt.<p><br />
<p><br />
'''Arten von Reihungen'''<p><br />
Es gibt verschiedene Arten von Reihungen. Diese unterscheiden sich in dem Datentyp der Variablen, die in ihnen gespeichert sind.<br />
<br />
*<p> int[] a; Reihung aus ganzen Zahlen<br />
*<p> char[] b; Reihungen aus Zeichen<br />
*<p> boolean[] c; Reihung aus Wahrheitswerten<br />
*<p> int[][] d; Mehrdimensionale Reihung, dabei ist in jedem Element ein eigenes Array enthalten. Jede Dimension wird durch ein paar eckige Klammern dargestellt.<p> <p>'''Deklaration von Reihungen'''<br />
<p><br />
Reihungen werden grundsätzlich mit dem Operator <b> new </b>deklariert.<br />
<p><br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = new int[5]<br />
<br />
oder<br />
<br />
int[] b;<br />
a = new int[5]<br />
</syntaxhighlight><p><br />
In diesen Beispielen erzeugen wir zwei Reihungen mit je 5 Elementen, welche jedoch noch keine Werte enthalten.<br />
<P><p><br />
'''Initialisierung von Reihungen'''<p><br />
Bei der Initialisierung werden die im vorigen Kapitel erstellten Reihungen mit Werten gefüllt. Dafür gibt es verschiedene Möglichkeiten:<br /><br />
<br />
#Möchte man eine Reihung mit bereits bekannten Werten initialisieren, fällt der Operator <b> new </b> weg. Die eckigen Klammern werden durch geschwungene ersetzt innerhalb welcher alle Werte, durch ein Komma getrennt, eingetragen werden. Hier wird die Reihung also gleichzeitig '''deklariert''' und '''initialisiert'''. Beispiel:<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
</syntaxhighlight>In diesem Beispiel erzeugen wir eine Reihungen mit einer Länge von 5 Elementen mit den Werten 1, 2, 3, 4 und 5. <br /><br />
#Man kann eine Reihung auch initialisieren, indem man die Positionen einzeln mit Werten befüllt. Beispiel:<syntaxhighlight lang="java"><br />
b[0] = 1;<br />
b[1] = 2;<br />
b[2] = 3;<br />
b[3] = 4;<br />
b[4] = 5; <br />
</syntaxhighlight>Hier werden die verschiedenen Positionen der Reihung einzeln mit Werten gefüllt.<br />
<br />
'''Achtung:''' Dabei wird die Position bei 0 beginnend gezählt. Also befindet sich die erste Zahl in der Reihung auf Position 0, die zweite Zahl in der Reihung auf Position 2 und so weiter...<br />
<br />
<br />
'''Auslesen von Werten'''<br />
<br />
Um Werte aus einer Reihung auszulesen, muss man den Namen der Reihung, sowie die Position des Elements in der Reihung auswählen. <br />
<br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
<br />
Dann gilt:<br />
a[3] = 4<br />
</syntaxhighlight></div>12jojo08https://projekte.zum.de/index.php?title=Informatik_am_Johanneum/Java&diff=41434Informatik am Johanneum/Java2021-01-16T15:14:04Z<p>12jojo08: </p>
<hr />
<div>===Offene Aufgaben===<br />
<br />
Bitte tragt in die Tabellen ein, welches Thema ihr bearbeiten wollt. Erst wenn ihr euch in der Tabelle für ein Thema eingetragen habt, könnt ihr mit der Bearbeitung beginnen. Ihr könnt Themen auch zu zweit erstellen.<br />
<br />
{| class="wikitable"<br />
|+offene Aufgaben<br />
!offene Aufgabe!!Verantwortlicher<br />
|-<br />
|Klassen in Eclipse anlegen||Erik<br />
|-<br />
|Variablentypen<br />
|Vinzent/J-P<br />
|-<br />
|eigene Methoden schreiben, Syntax der Signatur, return Statement<br />
|<br />
|-<br />
|typische Fehlermeldungen, IndexOutOfBoundsExcecption<br />
|<br />
|-<br />
|Arithmetische Operatoren<br />
|Niklas<br />
|-<br />
|Verzweigungen<br />
|Finn, Nikita<br />
|-<br />
|Schleifen (For-Schleife, While Schleife)<br />
|Vinzent/J-P<br />
|-<br />
|Reihungen (Initialisierung, ...)<br />
|Arian, Dharam<br />
|-<br />
|<br />
|<br />
|}<br />
<br />
Tipps zur Erstellung eines Eintrags: <br />
<br />
*jedes Thema hat eine Überschrift von Typ Unterüberschrift1<br />
*Verwende danach für die einzelnen Teilthemen Unterüberschrift2 oder weitere Unterüberschriften. So erscheinen diese Felder im Inhaltsverzeichnis.<br />
*Quellcode kann eingefügt werden, indem die Zeile im Modus Quelltextbearbeitung mit einem Leerzeichen begonnen wird.<br />
<br />
public void quellcodeSchreiben(){<br />
// dies ist ein Beispiel, wie Quellcode dargestellt werden kann.<br />
// wechsele dazu in den Modus Quelltextbearbeitung (oben rechts bei dem Stft)<br />
// beginne dann jede Quelltextzeile mit einem Leerzeichen.<br />
}<br />
<br /><br />
===Klassen in Eclipse anlegen===<br />
<br /><br />
===Variablentypen===<br />
In Java gibt es verschiedene Typen von Variablen. Einige davon werden im Folgenden erläutert.<br />
<br />
===='''Syntax einer Variable:'''====<br />
Erste Erstellung: Typ + Name = Wert -> Beispiel: int number = 3 / boolean correct = false<br />
<br />
Spätere Bearbeitung: Name = Wert -> Beispiel: number = 1 / correct = true<br />
<br />
Abfrage (z.B. in IF/ELSE Anfragen oder WHILE-Schleifen): Name == Wert -> number == 1 / correct == true<br />
<br />
===='''Ganzzahl-Typen:'''====<br />
integer (int): alle Zahlen zwischen -2147483648 und 2147483647.<br />
<br />
long: alle Zahlen zwischen -9223372036854775808 und 9223372036854775807.<br />
<br />
===='''Kommazahl-Typen:'''====<br />
double: Zahlen mit Kommastellen, aber auch ohne. Double wird verwendet, da die Ganzzahl-Typen keine Kommastellen speichern können.<br />
<br />
===='''Boolean:'''====<br />
boolean: kann zwei Werte annehmen, entweder true oder false, also wahr oder falsch.<br />
<br />
===='''Char'''====<br />
char: kann den Wert eines Unicodezeichens annehmen, also beispielsweise einen Buchstaben oder eine Zahl von 0-9.<br />
<br />
<u>Syntax</u> <br />
<br />
char i = 'J'<br />
<br />
===='''String'''====<br />
String: kann die Werte einer Zeichenkette annehmen<br />
<br />
ACHTUNG: Der Typ String muss in Java mit einem großen 'S' geschrieben werden.<br />
<br />
<u>Syntax</u> <br />
<br />
String java = "Hello World!"<br />
<br />
===='''Array'''====<br />
array[]: eine Reihung von Zahlen: man kann jeder Stelle eines Arrays eine bestimmte Zahl zuweisen.<br />
<br />
<u>''Syntax''</u> <br />
<br />
<u>Erstellen eines Arrays mit der Länge u</u><br />
<br />
int[] example = new int[u]<br />
<br />
<u>Erstellen eines Arrays mit bestimmten vorgegebenen Werten</u><br />
<br />
int example[] = {0, 3, 5, 10, 20, 25}<br />
<br />
<u>Die Ausgaben kann folgendermaßen aussehen</u><br />
<br />
example[3] == 10;<br />
<br />
example[4] == 20;<br />
<br />
<u>Zuweisung eines Wertes für eine Arraystelle:</u><br />
<br />
example[1] = 4;<br />
<br />
Die abgeänderte Reihung besitzt nun folgende Werte: {0, 4, 5, 10, 20, 25}<br />
<br />
<br /><br />
===Arithmetische Operatoren===<br />
=====Grundlagen=====<br />
In der Programmiersprache Java sind arithmetische Operatoren implementiert. Dabei müssen immer numerische Operanten (int, long, float, double) verwendet werden.<br />
=====Operatoren=====<br />
======Addition======<br />
Der Operator der Addition (a+b) addiert einen numerischen Operanden mit einem weiteren numerischen Operanden.<br />
<br />
public class Addition {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a + b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 10<br />
======Subtraktion======<br />
Der Operator der Subtraktion (a-b) subtrahiert einen numerischen Operanden von einem anderen numerischen Operator.<br />
<br />
public class Subtraktion {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a - b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 4 <br />
======Multiplikation======<br />
Der Operator der Multiplikation (a*b) multipliziert einen numerischen Operanden mit einem anderen numerischen Operanden.<br />
<br />
public class Multiplikation {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a * b;<br />
System.out.print(ergebnis);<br />
}<br />
} <br />
<br />
Ausgabe = 21<br />
======Division======<br />
Der Operator der Division (a/b) dividiert einen numerischen Operanden durch einen anderen numerischen Operanden. <br />
<u>Division zweier numerischer Operanden gleichen Typs:</u><br />
In diesem Fall sind die beiden numerischen Operanden ganzzahlig, daher ist auch das Ergebnis ganzzahlig:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 2<br />
<br />
<u> Division zweier numerischer Operanden unterschiedlichen Typs </u><br />
Es ist möglich numerische Operanden unterschiedlichen Typs zu dividieren. Ist einer der numerischen Operanden als Gleitkommazahl definiert, so ist auch das Ergebnis eine Gleitkommazahl:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
float b = 3;<br />
<br />
errgebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe: 2.3333333<br />
<br />
======Division mit Rest======<br />
Bei der Division mit Rest (modulo) dividiert einen numerischen Operanden durch einen zweiten numerischen Operanden (a%b). Dabei wird der ganzzahlige Rest als Ergebnis ausgegeben:<br />
<br />
public class Modulodivision {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a % b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 1<br />
===Verzweigungen===<br />
<br />
====Einführung====<br />
Verzweigungen gehören zu den Kontrollstrukturen Javas, die einen flexiblen und ereignisgesteuerten Ablauf eines Programmes ermöglichen. Für die Verzweigungen braucht man festgelegte Bedingungen. Beim Durchlauf des Programmes wird dann an den Verzweigungen überprüft, ob die Bedingung erfüllt wird oder nicht. Je nachdem welcher Fall zutrifft, wird ein bestimmter Bereich des Programmes ausgeführt. Im Folgenden unterscheiden wir in drei Verzweigungen: ''if''-Anweisung, ''if''-''else''-Anweisung und ''else-if''-Anweisung.<br /><br />
<br />
====''if''-''Anweisung''====<br />
Bei der ''if''-Anweisung wird als erstes überprüft, ob die gestellte Bedingung erfüllt wird oder nicht. Wird die Bedingung erfüllt, werden die danach folgenden Anweisungen ausgeführt. Wird die Bedingung nicht erfüllt, werden die danach folgenden Anweisungen übersprungen. In Java sieht die ''if''-Anweisung so aus:<br />
<br />
if (Bedingung){<br />
Anweisung;<br />
}<br />
<br /><br />
====''if-else''-Anweisung====<br />
Die ''if-else''-Anweisung ist im Prinzip nur eine Erweiterung der ''if''-Anweisung, bei der festgelegt wird, welche Anweisungen ausgeführt werden sollen, wenn die Bedingung nicht erfüllt wird. Man hat also zwei mögliche Fälle. In Java sieht die ''if-else''-Anweisung so aus:<br />
<br />
if (Bedingung) {<br />
Anweisung1;<br />
} <br />
else {<br />
Anweisung2;<br />
}<br />
<br /><br />
<br />
====''else-if''-Anweisung====<br />
Wenn man eine Verzweigung in drei verschiedene Programmbereiche braucht, kann man die ''else-if''-Anweisung verwenden. Bei der''else-if''-Anweisung wird erstmal überprüft, ob die erste Bedingung zutrifft. Wenn diese Bedingung zutrifft, wird der erste Programmbereich durchlaufen. Wenn diese Bedingung nicht zutrifft, wird zur nächsten Prüfung einer Bedingung gesprungen. Wenn diese zweite Bedingung zutrifft, dann werden die dazugehörigen Anweisungen ausgeführt. Wenn diese zweite Bedingung nicht zutrifft, dann wird zum letzten Teil der ''else-if''-Anweisung gesprungen und der letzte Programmbereich ausgeführt. In Java sieht die ''else-if''-Anweisung so aus: <br />
<br />
if (Bedingung1) {<br />
Anweisung1;<br />
} else if (Bedingung2) {<br />
Anweisung2;<br />
} else {<br />
Anweisung3;<br />
}<br />
<br />
<br /><br />
===Schleifen===<br />
'''FOR-Schleife'''<br />
<br />
Die sogenannte FOR-Scheife wird verwendet, wenn man die benötigten Schleifendurchläufe bereits im Voraus kennt. Man benötigt die folgenden drei Parameter: Initialisierung/Startwert, Zielwert und Schrittweite<br />
<br />
<u>Syntax</u><br />
<br />
for(Startwert; Zielwert; Schrittweite)<br />
<br />
<u>Beispiel</u><br />
<br />
for(int i = 1; i < 3; i++) {<br />
gehe 10 Schritte;<br />
}<br />
<br />
Mit dieser Schleife wird bei i == 1 10 Schritte gegangen und bei i == 2 ebenfalls, bei i == 3 nicht mehr, da der Zielwert erreicht ist.<br />
<br />
'''WHILE-Schleife'''<br />
<br />Die sogenannte WHILE-Schleife wird solange ausgeführt, bis eine bestimmte Bedingung nicht erfüllt ist. Diese Bedingung steht am Anfang der Schleife. Sofern die Bedingung anfangs nicht erfüllt wird, wird die Schleife übersprungen.<br />
<br />
<u>Syntax</u><br />
<br />
while(Bedingung) {<br />
Anweisung;<br />
}<br />
<u>Beispiel</u><br />
<br />
boolean correct = true;<br />
while(correct) {<br />
gehe 10 Schritte;<br />
correct = false;<br />
}<br />
Die Schleife wird einmal ausgeführt, da die Bedingung anfangs korrekt und danach nicht mehr korrekt ist.<br />
<br />
<br />
'''DO-WHILE-Schleife'''<br />
<br />
Die sogenannte DO-WHILE-Schleife ist eine WHILE-SCHLEIFE mit dem Unterschied, dass die Anweisung mindestens einmal ausgeführt wird, hierbei ist es anfangs egal, ob die Bedingung erfüllt ist oder nicht.<br />
<br />
<u>Syntax</u><br />
<br />
do {<br />
Anweisung;<br />
} while(Bedingung);<br />
<u>Beispiel</u><br />
<br />
int o = 1;<br />
do {<br />
gehe 10 Schritte;<br />
} while(o == 2);<br />
Diese Schleife wird einmal ausgeführt, danach nicht mehr, da die Bedingung nicht erfüllt wird.<br />
<br />
<br /><br />
<br />
===Reihungen===<br />
<br>'''Definition'''<p><br />
Eine Reihung besteht aus einer Anzahl von Werten des gleichen Datentyps. Sie alle werden unter einem Namen geführt und unterscheiden sich nur in den Feldnummern, welche die Position in der Reihung bestimmt.<p><br />
<p><br />
'''Arten von Reihungen'''<p><br />
Es gibt verschiedene Arten von Reihungen. Diese unterscheiden sich in dem Datentyp der Variablen, die in ihnen gespeichert sind.<br />
<br />
*<p> int[] a; Reihung aus ganzen Zahlen<br />
*<p> char[] b; Reihungen aus Zeichen<br />
*<p> boolean[] c; Reihung aus Wahrheitswerten<br />
*<p> int[][] d; Mehrdimensionale Reihung, dabei ist in jedem Element ein eigenes Array enthalten. Jede Dimension wird durch ein paar eckige Klammern dargestellt.<p> <p>'''Deklaration von Reihungen'''<br />
<p><br />
Reihungen werden grundsätzlich mit dem Operator <b> new </b>deklariert.<br />
<p><br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = new int[5]<br />
<br />
oder<br />
<br />
int[] b;<br />
a = new int[5]<br />
</syntaxhighlight><p><br />
In diesen Beispielen erzeugen wir zwei Reihungen mit je 5 Elementen, welche jedoch noch keine Werte enthalten.<br />
<P><p><br />
'''Initialisierung von Reihungen'''<p><br />
Bei der Initialisierung werden die im vorigen Kapitel erstellten Reihungen mit Werten gefüllt. Dafür gibt es verschiedene Möglichkeiten:<br /><br />
<br />
#Möchte man eine Reihung mit bereits bekannten Werten initialisieren, fällt der Operator <b> new </b> weg. Die eckigen Klammern werden durch geschwungene ersetzt innerhalb welcher alle Werte, durch ein Komma getrennt, eingetragen werden. Hier wird die Reihung also gleichzeitig '''deklariert''' und '''initialisiert'''. Beispiel:<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
</syntaxhighlight>In diesem Beispiel erzeugen wir eine Reihungen mit einer Länge von 5 Elementen mit den Werten 1, 2, 3, 4 und 5. <br /><br />
#Man kann eine Reihung auch initialisieren, indem man die Positionen einzeln mit Werten befüllt. Beispiel:<syntaxhighlight lang="java"><br />
b[0] = 1;<br />
b[1] = 2;<br />
b[2] = 3;<br />
b[3] = 4;<br />
b[4] = 5; <br />
</syntaxhighlight>Hier werden die verschiedenen Positionen der Reihung einzeln mit Werten gefüllt.<br />
<br />
'''Achtung:''' Dabei wird die Position bei 0 beginnend gezählt. Also befindet sich die erste Zahl in der Reihung auf Position 0, die zweite Zahl in der Reihung auf Position 2 und so weiter...<br />
<br />
<br />
<br />
'''Auslesen von Werten'''<br />
<br />
Um Werte aus einer Reihung auszulesen, muss man den Namen der Reihung, sowie die Position des Elements in der Reihung auswählen. <br />
<br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
<br />
Dann gilt:<br />
a[3] = 4<br />
</syntaxhighlight></div>12jojo08https://projekte.zum.de/index.php?title=Informatik_am_Johanneum/Java&diff=41433Informatik am Johanneum/Java2021-01-16T15:09:06Z<p>12jojo08: </p>
<hr />
<div>===Offene Aufgaben===<br />
<br />
Bitte tragt in die Tabellen ein, welches Thema ihr bearbeiten wollt. Erst wenn ihr euch in der Tabelle für ein Thema eingetragen habt, könnt ihr mit der Bearbeitung beginnen. Ihr könnt Themen auch zu zweit erstellen.<br />
<br />
{| class="wikitable"<br />
|+offene Aufgaben<br />
!offene Aufgabe!!Verantwortlicher<br />
|-<br />
|Klassen in Eclipse anlegen||Erik<br />
|-<br />
|Variablentypen<br />
|Vinzent/J-P<br />
|-<br />
|eigene Methoden schreiben, Syntax der Signatur, return Statement<br />
|<br />
|-<br />
|typische Fehlermeldungen, IndexOutOfBoundsExcecption<br />
|<br />
|-<br />
|Arithmetische Operatoren<br />
|Niklas<br />
|-<br />
|Verzweigungen<br />
|Finn, Nikita<br />
|-<br />
|Schleifen (For-Schleife, While Schleife)<br />
|Vinzent/J-P<br />
|-<br />
|Reihungen (Initialisierung, ...)<br />
|Arian, Dharam<br />
|-<br />
|<br />
|<br />
|}<br />
<br />
Tipps zur Erstellung eines Eintrags: <br />
<br />
*jedes Thema hat eine Überschrift von Typ Unterüberschrift1<br />
*Verwende danach für die einzelnen Teilthemen Unterüberschrift2 oder weitere Unterüberschriften. So erscheinen diese Felder im Inhaltsverzeichnis.<br />
*Quellcode kann eingefügt werden, indem die Zeile im Modus Quelltextbearbeitung mit einem Leerzeichen begonnen wird.<br />
<br />
public void quellcodeSchreiben(){<br />
// dies ist ein Beispiel, wie Quellcode dargestellt werden kann.<br />
// wechsele dazu in den Modus Quelltextbearbeitung (oben rechts bei dem Stft)<br />
// beginne dann jede Quelltextzeile mit einem Leerzeichen.<br />
}<br />
<br /><br />
===Klassen in Eclipse anlegen===<br />
<br /><br />
===Variablentypen===<br />
In Java gibt es verschiedene Typen von Variablen. Einige davon werden im Folgenden erläutert.<br />
<br />
===='''Syntax einer Variable:'''====<br />
Erste Erstellung: Typ + Name = Wert -> Beispiel: int number = 3 / boolean correct = false<br />
<br />
Spätere Bearbeitung: Name = Wert -> Beispiel: number = 1 / correct = true<br />
<br />
Abfrage (z.B. in IF/ELSE Anfragen oder WHILE-Schleifen): Name == Wert -> number == 1 / correct == true<br />
<br />
===='''Ganzzahl-Typen:'''====<br />
integer (int): alle Zahlen zwischen -2147483648 und 2147483647.<br />
<br />
long: alle Zahlen zwischen -9223372036854775808 und 9223372036854775807.<br />
<br />
===='''Kommazahl-Typen:'''====<br />
double: Zahlen mit Kommastellen, aber auch ohne. Double wird verwendet, da die Ganzzahl-Typen keine Kommastellen speichern können.<br />
<br />
===='''Boolean:'''====<br />
boolean: kann zwei Werte annehmen, entweder true oder false, also wahr oder falsch.<br />
<br />
===='''Char'''====<br />
char: kann den Wert eines Unicodezeichens annehmen, also beispielsweise einen Buchstaben oder eine Zahl von 0-9.<br />
<br />
<u>Syntax</u> <br />
<br />
char i = 'J'<br />
<br />
===='''String'''====<br />
String: kann die Werte einer Zeichenkette annehmen<br />
<br />
ACHTUNG: Der Typ String muss in Java mit einem großen 'S' geschrieben werden.<br />
<br />
<u>Syntax</u> <br />
<br />
String java = "Hello World!"<br />
<br />
===='''Array'''====<br />
array[]: eine Reihung von Zahlen: man kann jeder Stelle eines Arrays eine bestimmte Zahl zuweisen.<br />
<br />
<u>''Syntax''</u> <br />
<br />
<u>Erstellen eines Arrays mit der Länge u</u><br />
<br />
int[] example = new int[u]<br />
<br />
<u>Erstellen eines Arrays mit bestimmten vorgegebenen Werten</u><br />
<br />
int example[] = {0, 3, 5, 10, 20, 25}<br />
<br />
<u>Die Ausgaben kann folgendermaßen aussehen</u><br />
<br />
example[3] == 10;<br />
<br />
example[4] == 20;<br />
<br />
<u>Zuweisung eines Wertes für eine Arraystelle:</u><br />
<br />
example[1] = 4;<br />
<br />
Die abgeänderte Reihung besitzt nun folgende Werte: {0, 4, 5, 10, 20, 25}<br />
<br />
<br /><br />
===Arithmetische Operatoren===<br />
=====Grundlagen=====<br />
In der Programmiersprache Java sind arithmetische Operatoren implementiert. Dabei müssen immer numerische Operanten (int, long, float, double) verwendet werden.<br />
=====Operatoren=====<br />
======Addition======<br />
Der Operator der Addition (a+b) addiert einen numerischen Operanden mit einem weiteren numerischen Operanden.<br />
<br />
public class Addition {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a + b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 10<br />
======Subtraktion======<br />
Der Operator der Subtraktion (a-b) subtrahiert einen numerischen Operanden von einem anderen numerischen Operator.<br />
<br />
public class Subtraktion {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a - b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 4 <br />
======Multiplikation======<br />
Der Operator der Multiplikation (a*b) multipliziert einen numerischen Operanden mit einem anderen numerischen Operanden.<br />
<br />
public class Multiplikation {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a * b;<br />
System.out.print(ergebnis);<br />
}<br />
} <br />
<br />
Ausgabe = 21<br />
======Division======<br />
Der Operator der Division (a/b) dividiert einen numerischen Operanden durch einen anderen numerischen Operanden. <br />
<u>Division zweier numerischer Operanden gleichen Typs:</u><br />
In diesem Fall sind die beiden numerischen Operanden ganzzahlig, daher ist auch das Ergebnis ganzzahlig:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 2<br />
<br />
<u> Division zweier numerischer Operanden unterschiedlichen Typs </u><br />
Es ist möglich numerische Operanden unterschiedlichen Typs zu dividieren. Ist einer der numerischen Operanden als Gleitkommazahl definiert, so ist auch das Ergebnis eine Gleitkommazahl:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
float b = 3;<br />
<br />
errgebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe: 2.3333333<br />
<br />
======Division mit Rest======<br />
Bei der Division mit Rest (modulo) dividiert einen numerischen Operanden durch einen zweiten numerischen Operanden (a%b). Dabei wird der ganzzahlige Rest als Ergebnis ausgegeben:<br />
<br />
public class Modulodivision {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a % b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 1<br />
===Verzweigungen===<br />
<br />
====Einführung====<br />
Verzweigungen gehören zu den Kontrollstrukturen Javas, die einen flexiblen und ereignisgesteuerten Ablauf eines Programmes ermöglichen. Für die Verzweigungen braucht man festgelegte Bedingungen. Beim Durchlauf des Programmes wird dann an den Verzweigungen überprüft, ob die Bedingung erfüllt wird oder nicht. Je nachdem welcher Fall zutrifft, wird ein bestimmter Bereich des Programmes ausgeführt. Im Folgenden unterscheiden wir in drei Verzweigungen: ''if''-Anweisung, ''if''-''else''-Anweisung und ''else-if''-Anweisung.<br /><br />
<br />
====''if''-''Anweisung''====<br />
Bei der ''if''-Anweisung wird als erstes überprüft, ob die gestellte Bedingung erfüllt wird oder nicht. Wird die Bedingung erfüllt, werden die danach folgenden Anweisungen ausgeführt. Wird die Bedingung nicht erfüllt, werden die danach folgenden Anweisungen übersprungen. In Java sieht die ''if''-Anweisung so aus:<br />
<br />
if (Bedingung){<br />
Anweisung;<br />
}<br />
<br /><br />
====''if-else''-Anweisung====<br />
Die ''if-else''-Anweisung ist im Prinzip nur eine Erweiterung der ''if''-Anweisung, bei der festgelegt wird, welche Anweisungen ausgeführt werden sollen, wenn die Bedingung nicht erfüllt wird. Man hat also zwei mögliche Fälle. In Java sieht die ''if-else''-Anweisung so aus:<br />
<br />
if (Bedingung) {<br />
Anweisung1;<br />
} <br />
else {<br />
Anweisung2;<br />
}<br />
<br /><br />
<br />
====''else-if''-Anweisung====<br />
Wenn man eine Verzweigung in drei verschiedene Programmbereiche braucht, kann man die ''else-if''-Anweisung verwenden. Bei der''else-if''-Anweisung wird erstmal überprüft, ob die erste Bedingung zutrifft. Wenn diese Bedingung zutrifft, wird der erste Programmbereich durchlaufen. Wenn diese Bedingung nicht zutrifft, wird zur nächsten Prüfung einer Bedingung gesprungen. Wenn diese zweite Bedingung zutrifft, dann werden die dazugehörigen Anweisungen ausgeführt. Wenn diese zweite Bedingung nicht zutrifft, dann wird zum letzten Teil der ''else-if''-Anweisung gesprungen und der letzte Programmbereich ausgeführt. In Java sieht die ''else-if''-Anweisung so aus: <br />
<br />
if (Bedingung1) {<br />
Anweisung1;<br />
} else if (Bedingung2) {<br />
Anweisung2;<br />
} else {<br />
Anweisung3;<br />
}<br />
<br />
<br /><br />
===Schleifen===<br />
'''FOR-Schleife'''<br />
<br />
Die sogenannte FOR-Scheife wird verwendet, wenn man die benötigten Schleifendurchläufe bereits im Voraus kennt. Man benötigt die folgenden drei Parameter: Initialisierung/Startwert, Zielwert und Schrittweite<br />
<br />
<u>Syntax</u><br />
<br />
for(Startwert; Zielwert; Schrittweite)<br />
<br />
<u>Beispiel</u><br />
<br />
for(int i = 1; i < 3; i++) {<br />
gehe 10 Schritte;<br />
}<br />
<br />
Mit dieser Schleife wird bei i == 1 10 Schritte gegangen und bei i == 2 ebenfalls, bei i == 3 nicht mehr, da der Zielwert erreicht ist.<br />
<br />
'''WHILE-Schleife'''<br />
<br />Die sogenannte WHILE-Schleife wird solange ausgeführt, bis eine bestimmte Bedingung nicht erfüllt ist. Diese Bedingung steht am Anfang der Schleife. Sofern die Bedingung anfangs nicht erfüllt wird, wird die Schleife übersprungen.<br />
<br />
<u>Syntax</u><br />
<br />
while(Bedingung) {<br />
Anweisung;<br />
}<br />
<u>Beispiel</u><br />
<br />
boolean correct = true;<br />
while(correct) {<br />
gehe 10 Schritte;<br />
correct = false;<br />
}<br />
Die Schleife wird einmal ausgeführt, da die Bedingung anfangs korrekt und danach nicht mehr korrekt ist.<br />
<br />
<br />
'''DO-WHILE-Schleife'''<br />
<br />
Die sogenannte DO-WHILE-Schleife ist eine WHILE-SCHLEIFE mit dem Unterschied, dass die Anweisung mindestens einmal ausgeführt wird, hierbei ist es anfangs egal, ob die Bedingung erfüllt ist oder nicht.<br />
<br />
<u>Syntax</u><br />
<br />
do {<br />
Anweisung;<br />
} while(Bedingung);<br />
<u>Beispiel</u><br />
<br />
int o = 1;<br />
do {<br />
gehe 10 Schritte;<br />
} while(o == 2);<br />
Diese Schleife wird einmal ausgeführt, danach nicht mehr, da die Bedingung nicht erfüllt wird.<br />
<br />
<br /><br />
<br />
===Reihungen===<br />
<br>'''Definition'''<p><br />
Eine Reihung besteht aus einer Anzahl von Werten des gleichen Datentyps. Sie alle werden unter einem Namen geführt und unterscheiden sich nur in den Feldnummern, welche die Position in der Reihung bestimmt.<p><br />
<p><br />
'''Arten von Reihungen'''<p><br />
Es gibt verschiedene Arten von Reihungen. Diese unterscheiden sich in dem Datentyp der Variablen, die in ihnen gespeichert sind.<br />
<br />
*<p> int[] a; Reihung aus ganzen Zahlen<br />
*<p> char[] b; Reihungen aus Zeichen<br />
*<p> boolean[] c; Reihung aus Wahrheitswerten<br />
*<p> int[][] d; Mehrdimensionale Reihung, dabei ist in jedem Element ein eigenes Array enthalten. Jede Dimension wird durch ein paar eckige Klammern dargestellt.<p> <p>'''Deklaration von Reihungen'''<br />
<p><br />
Reihungen werden grundsätzlich mit dem Operator <b> new </b>deklariert.<br />
<p><br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = new int[5]<br />
<br />
oder<br />
<br />
int[] b;<br />
a = new int[5]<br />
</syntaxhighlight><p><br />
In diesen Beispielen erzeugen wir zwei Reihungen mit je 5 Elementen, welche jedoch noch keine Werte enthalten.<br />
<P><p><br />
'''Initialisierung von Reihungen'''<p><br />
Bei der Initialisierung werden die im vorigen Kapitel erstellten Reihungen mit Werten gefüllt. Dafür gibt es verschiedene Möglichkeiten:<br /><br />
<br />
#Möchte man eine Reihung mit bereits bekannten Werten initialisieren, fällt der Operator <b> new </b> weg. Die eckigen Klammern werden durch geschwungene ersetzt innerhalb welcher alle Werte, durch ein Komma getrennt, eingetragen werden. Hier wird die Reihung also gleichzeitig '''deklariert''' und '''initialisiert'''. Beispiel:<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
</syntaxhighlight>In diesem Beispiel erzeugen wir eine Reihungen mit einer Länge von 5 Elementen mit den Werten 1, 2, 3, 4 und 5. <br /><br />
#Man kann eine Reihung auch initialisieren, indem man die Positionen einzeln mit Werten befüllt. Beispiel:<syntaxhighlight lang="java"><br />
b[0] = 1;<br />
b[1] = 2;<br />
b[2] = 3;<br />
b[3] = 4;<br />
b[4] = 5; <br />
</syntaxhighlight>Hier werden die verschiedenen Positionen der Reihung einzeln mit Werten gefüllt.<br />
<br />
'''Achtung:''' Dabei wird die Position bei 0 beginnend gezählt. Also befindet sich die erste Zahl in der Reihung auf Position 0, die zweite Zahl in der Reihung auf Position 2 und so weiter...<br />
<br />
<br />
'''Auslesen von Werten'''<br />
<br />
Um Werte aus einer Reihung auszulesen, muss man den Namen der Reihung, sowie die Position des Elements in der Reihung auswählen. <br />
<br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
<br />
Dann gilt:<br />
a[3] = 4<br />
</syntaxhighlight></div>12jojo08https://projekte.zum.de/index.php?title=Informatik_am_Johanneum/Java&diff=41432Informatik am Johanneum/Java2021-01-16T15:08:26Z<p>12jojo08: Nur Sachen richtig gerückt</p>
<hr />
<div>===Offene Aufgaben===<br />
<br />
Bitte tragt in die Tabellen ein, welches Thema ihr bearbeiten wollt. Erst wenn ihr euch in der Tabelle für ein Thema eingetragen habt, könnt ihr mit der Bearbeitung beginnen. Ihr könnt Themen auch zu zweit erstellen.<br />
<br />
{| class="wikitable"<br />
|+offene Aufgaben<br />
!offene Aufgabe!!Verantwortlicher<br />
|-<br />
|Klassen in Eclipse anlegen||Erik<br />
|-<br />
|Variablentypen<br />
|Vinzent/J-P<br />
|-<br />
|eigene Methoden schreiben, Syntax der Signatur, return Statement<br />
|<br />
|-<br />
|typische Fehlermeldungen, IndexOutOfBoundsExcecption<br />
|<br />
|-<br />
|Arithmetische Operatoren<br />
|Niklas<br />
|-<br />
|Verzweigungen<br />
|Finn, Nikita<br />
|-<br />
|Schleifen (For-Schleife, While Schleife)<br />
|Vinzent/J-P<br />
|-<br />
|Reihungen (Initialisierung, ...)<br />
|Arian, Dharam<br />
|-<br />
|<br />
|<br />
|}<br />
<br />
Tipps zur Erstellung eines Eintrags: <br />
<br />
*jedes Thema hat eine Überschrift von Typ Unterüberschrift1<br />
*Verwende danach für die einzelnen Teilthemen Unterüberschrift2 oder weitere Unterüberschriften. So erscheinen diese Felder im Inhaltsverzeichnis.<br />
*Quellcode kann eingefügt werden, indem die Zeile im Modus Quelltextbearbeitung mit einem Leerzeichen begonnen wird.<br />
<br />
public void quellcodeSchreiben(){<br />
// dies ist ein Beispiel, wie Quellcode dargestellt werden kann.<br />
// wechsele dazu in den Modus Quelltextbearbeitung (oben rechts bei dem Stft)<br />
// beginne dann jede Quelltextzeile mit einem Leerzeichen.<br />
}<br />
<br /><br />
===Klassen in Eclipse anlegen===<br />
<br /><br />
===Variablentypen===<br />
In Java gibt es verschiedene Typen von Variablen. Einige davon werden im Folgenden erläutert.<br />
<br />
===='''Syntax einer Variable:'''====<br />
Erste Erstellung: Typ + Name = Wert -> Beispiel: int number = 3 / boolean correct = false<br />
<br />
Spätere Bearbeitung: Name = Wert -> Beispiel: number = 1 / correct = true<br />
<br />
Abfrage (z.B. in IF/ELSE Anfragen oder WHILE-Schleifen): Name == Wert -> number == 1 / correct == true<br />
<br />
===='''Ganzzahl-Typen:'''====<br />
integer (int): alle Zahlen zwischen -2147483648 und 2147483647.<br />
<br />
long: alle Zahlen zwischen -9223372036854775808 und 9223372036854775807.<br />
<br />
===='''Kommazahl-Typen:'''====<br />
double: Zahlen mit Kommastellen, aber auch ohne. Double wird verwendet, da die Ganzzahl-Typen keine Kommastellen speichern können.<br />
<br />
===='''Boolean:'''====<br />
boolean: kann zwei Werte annehmen, entweder true oder false, also wahr oder falsch.<br />
<br />
===='''Char'''====<br />
char: kann den Wert eines Unicodezeichens annehmen, also beispielsweise einen Buchstaben oder eine Zahl von 0-9.<br />
<br />
<u>Syntax</u> <br />
<br />
char i = 'J'<br />
<br />
===='''String'''====<br />
String: kann die Werte einer Zeichenkette annehmen<br />
<br />
ACHTUNG: Der Typ String muss in Java mit einem großen 'S' geschrieben werden.<br />
<br />
<u>Syntax</u> <br />
<br />
String java = "Hello World!"<br />
<br />
===='''Array'''====<br />
array[]: eine Reihung von Zahlen: man kann jeder Stelle eines Arrays eine bestimmte Zahl zuweisen.<br />
<br />
<u>''Syntax''</u> <br />
<br />
<u>Erstellen eines Arrays mit der Länge u</u><br />
<br />
int[] example = new int[u]<br />
<br />
<u>Erstellen eines Arrays mit bestimmten vorgegebenen Werten</u><br />
<br />
int example[] = {0, 3, 5, 10, 20, 25}<br />
<br />
<u>Die Ausgaben kann folgendermaßen aussehen</u><br />
<br />
example[3] == 10;<br />
<br />
example[4] == 20;<br />
<br />
<u>Zuweisung eines Wertes für eine Arraystelle:</u><br />
<br />
example[1] = 4;<br />
<br />
Die abgeänderte Reihung besitzt nun folgende Werte: {0, 4, 5, 10, 20, 25}<br />
<br />
<br /><br />
===Arithmetische Operatoren===<br />
=====Grundlagen=====<br />
In der Programmiersprache Java sind arithmetische Operatoren implementiert. Dabei müssen immer numerische Operanten (int, long, float, double) verwendet werden.<br />
=====Operatoren=====<br />
======Addition======<br />
Der Operator der Addition (a+b) addiert einen numerischen Operanden mit einem weiteren numerischen Operanden.<br />
<br />
public class Addition {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a + b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 10<br />
======Subtraktion======<br />
Der Operator der Subtraktion (a-b) subtrahiert einen numerischen Operanden von einem anderen numerischen Operator.<br />
<br />
public class Subtraktion {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a - b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 4 <br />
======Multiplikation======<br />
Der Operator der Multiplikation (a*b) multipliziert einen numerischen Operanden mit einem anderen numerischen Operanden.<br />
<br />
public class Multiplikation {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a * b;<br />
System.out.print(ergebnis);<br />
}<br />
} <br />
<br />
Ausgabe = 21<br />
======Division======<br />
Der Operator der Division (a/b) dividiert einen numerischen Operanden durch einen anderen numerischen Operanden. <br />
<u>Division zweier numerischer Operanden gleichen Typs:</u><br />
In diesem Fall sind die beiden numerischen Operanden ganzzahlig, daher ist auch das Ergebnis ganzzahlig:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 2<br />
<br />
<u> Division zweier numerischer Operanden unterschiedlichen Typs </u><br />
Es ist möglich numerische Operanden unterschiedlichen Typs zu dividieren. Ist einer der numerischen Operanden als Gleitkommazahl definiert, so ist auch das Ergebnis eine Gleitkommazahl:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
float b = 3;<br />
<br />
errgebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe: 2.3333333<br />
<br />
======Division mit Rest======<br />
Bei der Division mit Rest (modulo) dividiert einen numerischen Operanden durch einen zweiten numerischen Operanden (a%b). Dabei wird der ganzzahlige Rest als Ergebnis ausgegeben:<br />
<br />
public class Modulodivision {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a % b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 1<br />
===Verzweigungen===<br />
<br />
====Einführung====<br />
Verzweigungen gehören zu den Kontrollstrukturen Javas, die einen flexiblen und ereignisgesteuerten Ablauf eines Programmes ermöglichen. Für die Verzweigungen braucht man festgelegte Bedingungen. Beim Durchlauf des Programmes wird dann an den Verzweigungen überprüft, ob die Bedingung erfüllt wird oder nicht. Je nachdem welcher Fall zutrifft, wird ein bestimmter Bereich des Programmes ausgeführt. Im Folgenden unterscheiden wir in drei Verzweigungen: ''if''-Anweisung, ''if''-''else''-Anweisung und ''else-if''-Anweisung.<br /><br />
<br />
====''if''-''Anweisung''====<br />
Bei der ''if''-Anweisung wird als erstes überprüft, ob die gestellte Bedingung erfüllt wird oder nicht. Wird die Bedingung erfüllt, werden die danach folgenden Anweisungen ausgeführt. Wird die Bedingung nicht erfüllt, werden die danach folgenden Anweisungen übersprungen. In Java sieht die ''if''-Anweisung so aus:<br />
<br />
if (Bedingung){<br />
Anweisung;<br />
}<br />
<br /><br />
====''if-else''-Anweisung====<br />
Die ''if-else''-Anweisung ist im Prinzip nur eine Erweiterung der ''if''-Anweisung, bei der festgelegt wird, welche Anweisungen ausgeführt werden sollen, wenn die Bedingung nicht erfüllt wird. Man hat also zwei mögliche Fälle. In Java sieht die ''if-else''-Anweisung so aus:<br />
<br />
if (Bedingung) {<br />
Anweisung1;<br />
} <br />
else {<br />
Anweisung2;<br />
}<br />
<br /><br />
<br />
====''else-if''-Anweisung====<br />
Wenn man eine Verzweigung in drei verschiedene Programmbereiche braucht, kann man die ''else-if''-Anweisung verwenden. Bei der''else-if''-Anweisung wird erstmal überprüft, ob die erste Bedingung zutrifft. Wenn diese Bedingung zutrifft, wird der erste Programmbereich durchlaufen. Wenn diese Bedingung nicht zutrifft, wird zur nächsten Prüfung einer Bedingung gesprungen. Wenn diese zweite Bedingung zutrifft, dann werden die dazugehörigen Anweisungen ausgeführt. Wenn diese zweite Bedingung nicht zutrifft, dann wird zum letzten Teil der ''else-if''-Anweisung gesprungen und der letzte Programmbereich ausgeführt. In Java sieht die ''else-if''-Anweisung so aus: <br />
<br />
if (Bedingung1) {<br />
Anweisung1;<br />
} else if (Bedingung2) {<br />
Anweisung2;<br />
} else {<br />
Anweisung3;<br />
}<br />
<br />
<br /><br />
===Schleifen===<br />
'''FOR-Schleife'''<br />
<br />
Die sogenannte FOR-Scheife wird verwendet, wenn man die benötigten Schleifendurchläufe bereits im Voraus kennt. Man benötigt die folgenden drei Parameter: Initialisierung/Startwert, Zielwert und Schrittweite<br />
<br />
<u>Syntax</u><br />
<br />
for(Startwert; Zielwert; Schrittweite)<br />
<br />
<u>Beispiel</u><br />
<br />
for(int i = 1; i < 3; i++) {<br />
gehe 10 Schritte;<br />
}<br />
<br />
Mit dieser Schleife wird bei i == 1 10 Schritte gegangen und bei i == 2 ebenfalls, bei i == 3 nicht mehr, da der Zielwert erreicht ist.<br />
<br />
'''WHILE-Schleife'''<br />
<br />Die sogenannte WHILE-Schleife wird solange ausgeführt, bis eine bestimmte Bedingung nicht erfüllt ist. Diese Bedingung steht am Anfang der Schleife. Sofern die Bedingung anfangs nicht erfüllt wird, wird die Schleife übersprungen.<br />
<br />
<u>Syntax</u><br />
<br />
while(Bedingung) {<br />
Anweisung;<br />
}<br />
<u>Beispiel</u><br />
<br />
boolean correct = true;<br />
while(correct) {<br />
gehe 10 Schritte;<br />
correct = false;<br />
}<br />
Die Schleife wird einmal ausgeführt, da die Bedingung anfangs korrekt und danach nicht mehr korrekt ist.<br />
<br />
<br />
'''DO-WHILE-Schleife'''<br />
<br />
Die sogenannte DO-WHILE-Schleife ist eine WHILE-SCHLEIFE mit dem Unterschied, dass die Anweisung mindestens einmal ausgeführt wird, hierbei ist es anfangs egal, ob die Bedingung erfüllt ist oder nicht.<br />
<br />
<u>Syntax</u><br />
<br />
do {<br />
Anweisung;<br />
} while(Bedingung);<br />
<u>Beispiel</u><br />
<br />
int o = 1;<br />
do {<br />
gehe 10 Schritte;<br />
} while(o == 2);<br />
Diese Schleife wird einmal ausgeführt, danach nicht mehr, da die Bedingung nicht erfüllt wird.<br />
<br />
<br /><br />
<br />
===Reihungen===<br />
<br>'''Definition'''<p><br />
Eine Reihung besteht aus einer Anzahl von Werten des gleichen Datentyps. Sie alle werden unter einem Namen geführt und unterscheiden sich nur in den Feldnummern, welche die Position in der Reihung bestimmt.<p><br />
<p><br />
'''Arten von Reihungen'''<p><br />
Es gibt verschiedene Arten von Reihungen. Diese unterscheiden sich in dem Datentyp der Variablen, die in ihnen gespeichert sind.<br />
<br />
*<p> int[] a; Reihung aus ganzen Zahlen<br />
*<p> char[] b; Reihungen aus Zeichen<br />
*<p> boolean[] c; Reihung aus Wahrheitswerten<br />
*<p> int[][] d; Mehrdimensionale Reihung, dabei ist in jedem Element ein eigenes Array enthalten. Jede Dimension wird durch ein paar eckige Klammern dargestellt.<p> <p>'''Deklaration von Reihungen'''<br />
<p><br />
Reihungen werden grundsätzlich mit dem Operator <b> new </b>deklariert.<br />
<p><br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = new int[5]<br />
<br />
oder<br />
<br />
int[] b;<br />
a = new int[5]<br />
</syntaxhighlight><p><br />
In diesen Beispielen erzeugen wir zwei Reihungen mit je 5 Elementen, welche jedoch noch keine Werte enthalten.<br />
<P><p><br />
'''Initialisierung von Reihungen'''<p><br />
Bei der Initialisierung werden die im vorigen Kapitel erstellten Reihungen mit Werten gefüllt. Dafür gibt es verschiedene Möglichkeiten:<br /><br />
<br />
#Möchte man eine Reihung mit bereits bekannten Werten initialisieren, fällt der Operator <b> new </b> weg. Die eckigen Klammern werden durch geschwungene ersetzt innerhalb welcher alle Werte, durch ein Komma getrennt, eingetragen werden. Hier wird die Reihung also gleichzeitig '''deklariert''' und '''initialisiert'''. Beispiel:<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
</syntaxhighlight>In diesem Beispiel erzeugen wir eine Reihungen mit einer Länge von 5 Elementen mit den Werten 1, 2, 3, 4 und 5. <br /><br />
#Man kann eine Reihung auch initialisieren, indem man die Positionen einzeln mit Werten befüllt. Beispiel:<syntaxhighlight lang="java"><br />
b[0] = 1;<br />
b[1] = 2;<br />
b[2] = 3;<br />
b[3] = 4;<br />
b[4] = 5; <br />
</syntaxhighlight>Hier werden die verschiedenen Positionen der Reihung einzeln mit Werten gefüllt.<br />
<br />
'''Achtung:''' Dabei wird die Position bei 0 beginnend gezählt. Also befindet sich die erste Zahl in der Reihung auf Position 0, die zweite Zahl in der Reihung auf Position 2 und so weiter...<br />
<br />
<br />
'''Auslesen von Werten'''<br />
<br />
Um Werte aus einer Reihung auszulesen, muss man den Namen der Reihung, sowie die Position des Elements in der Reihung auswählen. <br />
<br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
<br />
Dann gilt:<br />
a[3] = 4<br />
</syntaxhighlight></div>12jojo08https://projekte.zum.de/index.php?title=Informatik_am_Johanneum/Java&diff=41431Informatik am Johanneum/Java2021-01-16T15:07:28Z<p>12jojo08: Ich habe die Kategorie Initialisierung ergänzt und Absätze eingefügt. Außerdem wurden noch ein paar Änderungen und Ergänzungen vorgenommen</p>
<hr />
<div>===Offene Aufgaben===<br />
<br />
Bitte tragt in die Tabellen ein, welches Thema ihr bearbeiten wollt. Erst wenn ihr euch in der Tabelle für ein Thema eingetragen habt, könnt ihr mit der Bearbeitung beginnen. Ihr könnt Themen auch zu zweit erstellen.<br />
<br />
{| class="wikitable"<br />
|+offene Aufgaben<br />
!offene Aufgabe!!Verantwortlicher<br />
|-<br />
|Klassen in Eclipse anlegen||Erik<br />
|-<br />
|Variablentypen<br />
|Vinzent/J-P<br />
|-<br />
|eigene Methoden schreiben, Syntax der Signatur, return Statement<br />
|<br />
|-<br />
|typische Fehlermeldungen, IndexOutOfBoundsExcecption<br />
|<br />
|-<br />
|Arithmetische Operatoren<br />
|Niklas<br />
|-<br />
|Verzweigungen<br />
|Finn, Nikita<br />
|-<br />
|Schleifen (For-Schleife, While Schleife)<br />
|Vinzent/J-P<br />
|-<br />
|Reihungen (Initialisierung, ...)<br />
|Arian, Dharam<br />
|-<br />
|<br />
|<br />
|}<br />
<br />
Tipps zur Erstellung eines Eintrags: <br />
<br />
*jedes Thema hat eine Überschrift von Typ Unterüberschrift1<br />
*Verwende danach für die einzelnen Teilthemen Unterüberschrift2 oder weitere Unterüberschriften. So erscheinen diese Felder im Inhaltsverzeichnis.<br />
*Quellcode kann eingefügt werden, indem die Zeile im Modus Quelltextbearbeitung mit einem Leerzeichen begonnen wird.<br />
<br />
public void quellcodeSchreiben(){<br />
// dies ist ein Beispiel, wie Quellcode dargestellt werden kann.<br />
// wechsele dazu in den Modus Quelltextbearbeitung (oben rechts bei dem Stft)<br />
// beginne dann jede Quelltextzeile mit einem Leerzeichen.<br />
}<br />
<br /><br />
===Klassen in Eclipse anlegen===<br />
<br /><br />
===Variablentypen===<br />
In Java gibt es verschiedene Typen von Variablen. Einige davon werden im Folgenden erläutert.<br />
<br />
===='''Syntax einer Variable:'''====<br />
Erste Erstellung: Typ + Name = Wert -> Beispiel: int number = 3 / boolean correct = false<br />
<br />
Spätere Bearbeitung: Name = Wert -> Beispiel: number = 1 / correct = true<br />
<br />
Abfrage (z.B. in IF/ELSE Anfragen oder WHILE-Schleifen): Name == Wert -> number == 1 / correct == true<br />
<br />
===='''Ganzzahl-Typen:'''====<br />
integer (int): alle Zahlen zwischen -2147483648 und 2147483647.<br />
<br />
long: alle Zahlen zwischen -9223372036854775808 und 9223372036854775807.<br />
<br />
===='''Kommazahl-Typen:'''====<br />
double: Zahlen mit Kommastellen, aber auch ohne. Double wird verwendet, da die Ganzzahl-Typen keine Kommastellen speichern können.<br />
<br />
===='''Boolean:'''====<br />
boolean: kann zwei Werte annehmen, entweder true oder false, also wahr oder falsch.<br />
<br />
===='''Char'''====<br />
char: kann den Wert eines Unicodezeichens annehmen, also beispielsweise einen Buchstaben oder eine Zahl von 0-9.<br />
<br />
<u>Syntax</u> <br />
<br />
char i = 'J'<br />
<br />
===='''String'''====<br />
String: kann die Werte einer Zeichenkette annehmen<br />
<br />
ACHTUNG: Der Typ String muss in Java mit einem großen 'S' geschrieben werden.<br />
<br />
<u>Syntax</u> <br />
<br />
String java = "Hello World!"<br />
<br />
===='''Array'''====<br />
array[]: eine Reihung von Zahlen: man kann jeder Stelle eines Arrays eine bestimmte Zahl zuweisen.<br />
<br />
<u>''Syntax''</u> <br />
<br />
<u>Erstellen eines Arrays mit der Länge u</u><br />
<br />
int[] example = new int[u]<br />
<br />
<u>Erstellen eines Arrays mit bestimmten vorgegebenen Werten</u><br />
<br />
int example[] = {0, 3, 5, 10, 20, 25}<br />
<br />
<u>Die Ausgaben kann folgendermaßen aussehen</u><br />
<br />
example[3] == 10;<br />
<br />
example[4] == 20;<br />
<br />
<u>Zuweisung eines Wertes für eine Arraystelle:</u><br />
<br />
example[1] = 4;<br />
<br />
Die abgeänderte Reihung besitzt nun folgende Werte: {0, 4, 5, 10, 20, 25}<br />
<br />
<br /><br />
===Arithmetische Operatoren===<br />
=====Grundlagen=====<br />
In der Programmiersprache Java sind arithmetische Operatoren implementiert. Dabei müssen immer numerische Operanten (int, long, float, double) verwendet werden.<br />
=====Operatoren=====<br />
======Addition======<br />
Der Operator der Addition (a+b) addiert einen numerischen Operanden mit einem weiteren numerischen Operanden.<br />
<br />
public class Addition {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a + b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 10<br />
======Subtraktion======<br />
Der Operator der Subtraktion (a-b) subtrahiert einen numerischen Operanden von einem anderen numerischen Operator.<br />
<br />
public class Subtraktion {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a - b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 4 <br />
======Multiplikation======<br />
Der Operator der Multiplikation (a*b) multipliziert einen numerischen Operanden mit einem anderen numerischen Operanden.<br />
<br />
public class Multiplikation {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a * b;<br />
System.out.print(ergebnis);<br />
}<br />
} <br />
<br />
Ausgabe = 21<br />
======Division======<br />
Der Operator der Division (a/b) dividiert einen numerischen Operanden durch einen anderen numerischen Operanden. <br />
<u>Division zweier numerischer Operanden gleichen Typs:</u><br />
In diesem Fall sind die beiden numerischen Operanden ganzzahlig, daher ist auch das Ergebnis ganzzahlig:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 2<br />
<br />
<u> Division zweier numerischer Operanden unterschiedlichen Typs </u><br />
Es ist möglich numerische Operanden unterschiedlichen Typs zu dividieren. Ist einer der numerischen Operanden als Gleitkommazahl definiert, so ist auch das Ergebnis eine Gleitkommazahl:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
float b = 3;<br />
<br />
errgebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe: 2.3333333<br />
<br />
======Division mit Rest======<br />
Bei der Division mit Rest (modulo) dividiert einen numerischen Operanden durch einen zweiten numerischen Operanden (a%b). Dabei wird der ganzzahlige Rest als Ergebnis ausgegeben:<br />
<br />
public class Modulodivision {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a % b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 1<br />
===Verzweigungen===<br />
<br />
====Einführung====<br />
Verzweigungen gehören zu den Kontrollstrukturen Javas, die einen flexiblen und ereignisgesteuerten Ablauf eines Programmes ermöglichen. Für die Verzweigungen braucht man festgelegte Bedingungen. Beim Durchlauf des Programmes wird dann an den Verzweigungen überprüft, ob die Bedingung erfüllt wird oder nicht. Je nachdem welcher Fall zutrifft, wird ein bestimmter Bereich des Programmes ausgeführt. Im Folgenden unterscheiden wir in drei Verzweigungen: ''if''-Anweisung, ''if''-''else''-Anweisung und ''else-if''-Anweisung.<br /><br />
<br />
====''if''-''Anweisung''====<br />
Bei der ''if''-Anweisung wird als erstes überprüft, ob die gestellte Bedingung erfüllt wird oder nicht. Wird die Bedingung erfüllt, werden die danach folgenden Anweisungen ausgeführt. Wird die Bedingung nicht erfüllt, werden die danach folgenden Anweisungen übersprungen. In Java sieht die ''if''-Anweisung so aus:<br />
<br />
if (Bedingung){<br />
Anweisung;<br />
}<br />
<br /><br />
====''if-else''-Anweisung====<br />
Die ''if-else''-Anweisung ist im Prinzip nur eine Erweiterung der ''if''-Anweisung, bei der festgelegt wird, welche Anweisungen ausgeführt werden sollen, wenn die Bedingung nicht erfüllt wird. Man hat also zwei mögliche Fälle. In Java sieht die ''if-else''-Anweisung so aus:<br />
<br />
if (Bedingung) {<br />
Anweisung1;<br />
} <br />
else {<br />
Anweisung2;<br />
}<br />
<br /><br />
<br />
====''else-if''-Anweisung====<br />
Wenn man eine Verzweigung in drei verschiedene Programmbereiche braucht, kann man die ''else-if''-Anweisung verwenden. Bei der''else-if''-Anweisung wird erstmal überprüft, ob die erste Bedingung zutrifft. Wenn diese Bedingung zutrifft, wird der erste Programmbereich durchlaufen. Wenn diese Bedingung nicht zutrifft, wird zur nächsten Prüfung einer Bedingung gesprungen. Wenn diese zweite Bedingung zutrifft, dann werden die dazugehörigen Anweisungen ausgeführt. Wenn diese zweite Bedingung nicht zutrifft, dann wird zum letzten Teil der ''else-if''-Anweisung gesprungen und der letzte Programmbereich ausgeführt. In Java sieht die ''else-if''-Anweisung so aus: <br />
<br />
if (Bedingung1) {<br />
Anweisung1;<br />
} else if (Bedingung2) {<br />
Anweisung2;<br />
} else {<br />
Anweisung3;<br />
}<br />
<br />
<br /><br />
===Schleifen===<br />
'''FOR-Schleife'''<br />
<br />
Die sogenannte FOR-Scheife wird verwendet, wenn man die benötigten Schleifendurchläufe bereits im Voraus kennt. Man benötigt die folgenden drei Parameter: Initialisierung/Startwert, Zielwert und Schrittweite<br />
<br />
<u>Syntax</u><br />
<br />
for(Startwert; Zielwert; Schrittweite)<br />
<br />
<u>Beispiel</u><br />
<br />
for(int i = 1; i < 3; i++) {<br />
gehe 10 Schritte;<br />
}<br />
<br />
Mit dieser Schleife wird bei i == 1 10 Schritte gegangen und bei i == 2 ebenfalls, bei i == 3 nicht mehr, da der Zielwert erreicht ist.<br />
<br />
'''WHILE-Schleife'''<br />
<br />Die sogenannte WHILE-Schleife wird solange ausgeführt, bis eine bestimmte Bedingung nicht erfüllt ist. Diese Bedingung steht am Anfang der Schleife. Sofern die Bedingung anfangs nicht erfüllt wird, wird die Schleife übersprungen.<br />
<br />
<u>Syntax</u><br />
<br />
while(Bedingung) {<br />
Anweisung;<br />
}<br />
<u>Beispiel</u><br />
<br />
boolean correct = true;<br />
while(correct) {<br />
gehe 10 Schritte;<br />
correct = false;<br />
}<br />
Die Schleife wird einmal ausgeführt, da die Bedingung anfangs korrekt und danach nicht mehr korrekt ist.<br />
<br />
<br />
'''DO-WHILE-Schleife'''<br />
<br />
Die sogenannte DO-WHILE-Schleife ist eine WHILE-SCHLEIFE mit dem Unterschied, dass die Anweisung mindestens einmal ausgeführt wird, hierbei ist es anfangs egal, ob die Bedingung erfüllt ist oder nicht.<br />
<br />
<u>Syntax</u><br />
<br />
do {<br />
Anweisung;<br />
} while(Bedingung);<br />
<u>Beispiel</u><br />
<br />
int o = 1;<br />
do {<br />
gehe 10 Schritte;<br />
} while(o == 2);<br />
Diese Schleife wird einmal ausgeführt, danach nicht mehr, da die Bedingung nicht erfüllt wird.<br />
<br />
===Reihungen===<br />
<br>'''Definition'''<p><br />
Eine Reihung besteht aus einer Anzahl von Werten des gleichen Datentyps. Sie alle werden unter einem Namen geführt und unterscheiden sich nur in den Feldnummern, welche die Position in der Reihung bestimmt.<p><br />
<p><br />
'''Arten von Reihungen'''<p><br />
Es gibt verschiedene Arten von Reihungen. Diese unterscheiden sich in dem Datentyp der Variablen, die in ihnen gespeichert sind.<br />
<br />
*<p> int[] a; Reihung aus ganzen Zahlen<br />
*<p> char[] b; Reihungen aus Zeichen<br />
*<p> boolean[] c; Reihung aus Wahrheitswerten<br />
*<p> int[][] d; Mehrdimensionale Reihung, dabei ist in jedem Element ein eigenes Array enthalten. Jede Dimension wird durch ein paar eckige Klammern dargestellt.<p> <p>'''Deklaration von Reihungen'''<br />
<p><br />
Reihungen werden grundsätzlich mit dem Operator <b> new </b>deklariert.<br />
<p><br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = new int[5]<br />
<br />
oder<br />
<br />
int[] b;<br />
a = new int[5]<br />
</syntaxhighlight><p><br />
In diesen Beispielen erzeugen wir zwei Reihungen mit je 5 Elementen, welche jedoch noch keine Werte enthalten.<br />
<P><p><br />
'''Initialisierung von Reihungen'''<br />
<br />
Bei der Initialisierung werden die im vorigen Kapitel erstellten Reihungen mit Werten gefüllt. Dafür gibt es verschiedene Möglichkeiten:<br />
<br />
<br /><br />
<br />
# Möchte man eine Reihung mit bereits bekannten Werten initialisieren, fällt der Operator <b> new </b> weg. Die eckigen Klammern werden durch geschwungene ersetzt innerhalb welcher alle Werte, durch ein Komma getrennt, eingetragen werden. Hier wird die Reihung also gleichzeitig '''deklariert''' und '''initialisiert'''. Beispiel:<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
</syntaxhighlight>In diesem Beispiel erzeugen wir eine Reihungen mit einer Länge von 5 Elementen mit den Werten 1, 2, 3, 4 und 5. <br /><br />
# Man kann eine Reihung auch initialisieren, indem man die Positionen einzeln mit Werten befüllt. Beispiel:<syntaxhighlight lang="java"><br />
b[0] = 1;<br />
b[1] = 2;<br />
b[2] = 3;<br />
b[3] = 4;<br />
b[4] = 5; <br />
</syntaxhighlight>Hier werden die verschiedenen Positionen der Reihung einzeln mit Werten gefüllt.<br />
<br />
'''Achtung:''' Dabei wird die Position bei 0 beginnend gezählt. Also befindet sich die erste Zahl in der Reihung auf Position 0, die zweite Zahl in der Reihung auf Position 2 und so weiter...<br />
<br />
<br />
'''Auslesen von Werten'''<br />
<br />
Um Werte aus einer Reihung auszulesen, muss man den Namen der Reihung, sowie die Position des Elements in der Reihung auswählen. <br />
<br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
<br />
Dann gilt:<br />
a[3] = 4<br />
</syntaxhighlight></div>12jojo08https://projekte.zum.de/index.php?title=Informatik_am_Johanneum/Java&diff=41427Informatik am Johanneum/Java2021-01-16T14:25:01Z<p>12jojo08: Nur kleine Schliffe</p>
<hr />
<div>===Offene Aufgaben===<br />
<br />
Bitte tragt in die Tabellen ein, welches Thema ihr bearbeiten wollt. Erst wenn ihr euch in der Tabelle für ein Thema eingetragen habt, könnt ihr mit der Bearbeitung beginnen. Ihr könnt Themen auch zu zweit erstellen.<br />
<br />
{| class="wikitable"<br />
|+offene Aufgaben<br />
!offene Aufgabe!!Verantwortlicher<br />
|-<br />
|Klassen in Eclipse anlegen||Erik<br />
|-<br />
|Variablentypen<br />
|Vinzent/J-P<br />
|-<br />
|eigene Methoden schreiben, Syntax der Signatur, return Statement<br />
|<br />
|-<br />
|typische Fehlermeldungen, IndexOutOfBoundsExcecption<br />
|<br />
|-<br />
|Arithmetische Operatoren<br />
|Niklas<br />
|-<br />
|Verzweigungen<br />
|Finn, Nikita<br />
|-<br />
|Schleifen (For-Schleife, While Schleife)<br />
|Vinzent/J-P<br />
|-<br />
|Reihungen (Initialisierung, ...)<br />
|Arian, Dharam<br />
|-<br />
|<br />
|<br />
|}<br />
<br />
Tipps zur Erstellung eines Eintrags: <br />
<br />
*jedes Thema hat eine Überschrift von Typ Unterüberschrift1<br />
*Verwende danach für die einzelnen Teilthemen Unterüberschrift2 oder weitere Unterüberschriften. So erscheinen diese Felder im Inhaltsverzeichnis.<br />
*Quellcode kann eingefügt werden, indem die Zeile im Modus Quelltextbearbeitung mit einem Leerzeichen begonnen wird.<br />
<br />
public void quellcodeSchreiben(){<br />
// dies ist ein Beispiel, wie Quellcode dargestellt werden kann.<br />
// wechsele dazu in den Modus Quelltextbearbeitung (oben rechts bei dem Stft)<br />
// beginne dann jede Quelltextzeile mit einem Leerzeichen.<br />
}<br />
<br /><br />
===Klassen in Eclipse anlegen===<br />
<br /><br />
===Variablentypen===<br />
In Java gibt es verschiedene Typen von Variablen. Einige davon werden im Folgenden erläutert.<br />
<br />
===='''Syntax einer Variable:'''====<br />
Erste Erstellung: Typ + Name = Wert -> Beispiel: int number = 3 / boolean correct = false<br />
<br />
Spätere Bearbeitung: Name = Wert -> Beispiel: number = 1 / correct = true<br />
<br />
Abfrage (z.B. in IF/ELSE Anfragen oder WHILE-Schleifen): Name == Wert -> number == 1 / correct == true<br />
<br />
===='''Ganzzahl-Typen:'''====<br />
integer (int): alle Zahlen zwischen -2147483648 und 2147483647.<br />
<br />
long: alle Zahlen zwischen -9223372036854775808 und 9223372036854775807.<br />
<br />
===='''Kommazahl-Typen:'''====<br />
double: Zahlen mit Kommastellen, aber auch ohne. Double wird verwendet, da die Ganzzahl-Typen keine Kommastellen speichern können.<br />
<br />
===='''Boolean:'''====<br />
boolean: kann zwei Werte annehmen, entweder true oder false, also wahr oder falsch.<br />
<br />
===='''Char'''====<br />
char: kann den Wert eines Unicodezeichens annehmen, also beispielsweise einen Buchstaben oder eine Zahl von 0-9.<br />
<br />
<u>Syntax</u> <br />
<br />
char i = 'J'<br />
<br />
===='''String'''====<br />
String: kann die Werte einer Zeichenkette annehmen<br />
<br />
ACHTUNG: Der Typ String muss in Java mit einem großen 'S' geschrieben werden.<br />
<br />
<u>Syntax</u> <br />
<br />
String java = "Hello World!"<br />
<br />
===='''Array'''====<br />
array[]: eine Reihung von Zahlen: man kann jeder Stelle eines Arrays eine bestimmte Zahl zuweisen.<br />
<br />
<u>''Syntax''</u> <br />
<br />
<u>Erstellen eines Arrays mit der Länge u</u><br />
<br />
int[] example = new int[u]<br />
<br />
<u>Erstellen eines Arrays mit bestimmten vorgegebenen Werten</u><br />
<br />
int example[] = {0, 3, 5, 10, 20, 25}<br />
<br />
<u>Die Ausgaben kann folgendermaßen aussehen</u><br />
<br />
example[3] == 10;<br />
<br />
example[4] == 20;<br />
<br />
<u>Zuweisung eines Wertes für eine Arraystelle:</u><br />
<br />
example[1] = 4;<br />
<br />
Die abgeänderte Reihung besitzt nun folgende Werte: {0, 4, 5, 10, 20, 25}<br />
<br />
<br /><br />
===Arithmetische Operatoren===<br />
=====Grundlagen=====<br />
In der Programmiersprache Java sind arithmetische Operatoren implementiert. Dabei müssen immer numerische Operanten (int, long, float, double) verwendet werden.<br />
=====Operatoren=====<br />
======Addition======<br />
Der Operator der Addition (a+b) addiert einen numerischen Operanden mit einem weiteren numerischen Operanden.<br />
<br />
public class Addition {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a + b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 10<br />
======Subtraktion======<br />
Der Operator der Subtraktion (a-b) subtrahiert einen numerischen Operanden von einem anderen numerischen Operator.<br />
<br />
public class Subtraktion {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a - b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 4 <br />
======Multiplikation======<br />
Der Operator der Multiplikation (a*b) multipliziert einen numerischen Operanden mit einem anderen numerischen Operanden.<br />
<br />
public class Multiplikation {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a * b;<br />
System.out.print(ergebnis);<br />
}<br />
} <br />
<br />
Ausgabe = 21<br />
======Division======<br />
Der Operator der Division (a/b) dividiert einen numerischen Operanden durch einen anderen numerischen Operanden. <br />
<u>Division zweier numerischer Operanden gleichen Typs:</u><br />
In diesem Fall sind die beiden numerischen Operanden ganzzahlig, daher ist auch das Ergebnis ganzzahlig:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 2<br />
<br />
<u> Division zweier numerischer Operanden unterschiedlichen Typs </u><br />
Es ist möglich numerische Operanden unterschiedlichen Typs zu dividieren. Ist einer der numerischen Operanden als Gleitkommazahl definiert, so ist auch das Ergebnis eine Gleitkommazahl:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
float b = 3;<br />
<br />
errgebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe: 2.3333333<br />
<br />
======Division mit Rest======<br />
Bei der Division mit Rest (modulo) dividiert einen numerischen Operanden durch einen zweiten numerischen Operanden (a%b). Dabei wird der ganzzahlige Rest als Ergebnis ausgegeben:<br />
<br />
public class Modulodivision {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a % b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 1<br />
===Verzweigungen===<br />
<br />
====Einführung====<br />
Verzweigungen gehören zu den Kontrollstrukturen Javas, die einen flexiblen und ereignisgesteuerten Ablauf eines Programmes ermöglichen. Für die Verzweigungen braucht man festgelegte Bedingungen. Beim Durchlauf des Programmes wird dann an den Verzweigungen überprüft, ob die Bedingung erfüllt wird oder nicht. Je nachdem welcher Fall zutrifft, wird ein bestimmter Bereich des Programmes ausgeführt. Im Folgenden unterscheiden wir in drei Verzweigungen: ''if''-Anweisung, ''if''-''else''-Anweisung und ''else-if''-Anweisung.<br /><br />
<br />
====''if''-''Anweisung''====<br />
Bei der ''if''-Anweisung wird als erstes überprüft, ob die gestellte Bedingung erfüllt wird oder nicht. Wird die Bedingung erfüllt, werden die danach folgenden Anweisungen ausgeführt. Wird die Bedingung nicht erfüllt, werden die danach folgenden Anweisungen übersprungen. In Java sieht die ''if''-Anweisung so aus:<br />
<br />
if (Bedingung){<br />
Anweisung;<br />
}<br />
<br /><br />
====''if-else''-Anweisung====<br />
Die ''if-else''-Anweisung ist im Prinzip nur eine Erweiterung der ''if''-Anweisung, bei der festgelegt wird, welche Anweisungen ausgeführt werden sollen, wenn die Bedingung nicht erfüllt wird. Man hat also zwei mögliche Fälle. In Java sieht die ''if-else''-Anweisung so aus:<br />
<br />
if (Bedingung) {<br />
Anweisung1;<br />
} <br />
else {<br />
Anweisung2;<br />
}<br />
<br /><br />
<br />
====''else-if''-Anweisung====<br />
Wenn man eine Verzweigung in drei verschiedene Programmbereiche braucht, kann man die ''else-if''-Anweisung verwenden. Bei der''else-if''-Anweisung wird erstmal überprüft, ob die erste Bedingung zutrifft. Wenn diese Bedingung zutrifft, wird der erste Programmbereich durchlaufen. Wenn diese Bedingung nicht zutrifft, wird zur nächsten Prüfung einer Bedingung gesprungen. Wenn diese zweite Bedingung zutrifft, dann werden die dazugehörigen Anweisungen ausgeführt. Wenn diese zweite Bedingung nicht zutrifft, dann wird zum letzten Teil der ''else-if''-Anweisung gesprungen und der letzte Programmbereich ausgeführt. In Java sieht die ''else-if''-Anweisung so aus: <br />
<br />
if (Bedingung1) {<br />
Anweisung1;<br />
} else if (Bedingung2) {<br />
Anweisung2;<br />
} else {<br />
Anweisung3;<br />
}<br />
<br />
<br /><br />
===Schleifen===<br />
'''FOR-Schleife'''<br />
<br />
Die sogenannte FOR-Scheife wird verwendet, wenn man die benötigten Schleifendurchläufe bereits im Voraus kennt. Man benötigt die folgenden drei Parameter: Initialisierung/Startwert, Zielwert und Schrittweite<br />
<br />
<u>Syntax</u><br />
<br />
for(Startwert; Zielwert; Schrittweite)<br />
<br />
<u>Beispiel</u><br />
<br />
for(int i = 1; i < 3; i++) {<br />
gehe 10 Schritte;<br />
}<br />
<br />
Mit dieser Schleife wird bei i == 1 10 Schritte gegangen und bei i == 2 ebenfalls, bei i == 3 nicht mehr, da der Zielwert erreicht ist.<br />
<br />
'''WHILE-Schleife'''<br />
<br />Die sogenannte WHILE-Schleife wird solange ausgeführt, bis eine bestimmte Bedingung nicht erfüllt ist. Diese Bedingung steht am Anfang der Schleife. Sofern die Bedingung anfangs nicht erfüllt wird, wird die Schleife übersprungen.<br />
<br />
<u>Syntax</u><br />
<br />
while(Bedingung) {<br />
Anweisung;<br />
}<br />
<u>Beispiel</u><br />
<br />
boolean correct = true;<br />
while(correct) {<br />
gehe 10 Schritte;<br />
correct = false;<br />
}<br />
Die Schleife wird einmal ausgeführt, da die Bedingung anfangs korrekt und danach nicht mehr korrekt ist.<br />
<br />
<br />
'''DO-WHILE-Schleife'''<br />
<br />
Die sogenannte DO-WHILE-Schleife ist eine WHILE-SCHLEIFE mit dem Unterschied, dass die Anweisung mindestens einmal ausgeführt wird, hierbei ist es anfangs egal, ob die Bedingung erfüllt ist oder nicht.<br />
<br />
<u>Syntax</u><br />
<br />
do {<br />
Anweisung;<br />
} while(Bedingung);<br />
<u>Beispiel</u><br />
<br />
int o = 1;<br />
do {<br />
gehe 10 Schritte;<br />
} while(o == 2);<br />
Diese Schleife wird einmal ausgeführt, danach nicht mehr, da die Bedingung nicht erfüllt wird.<br />
<br />
===Reihungen===<br />
<br>'''Definition'''<p><br />
Eine Reihung besteht aus einer Anzahl von Werten des gleichen Datentyps. Sie alle werden unter einem Namen geführt und unterscheiden sich nur in den Feldnummern, welche die Position in der Reihung bestimmt.<br />
<p><br />
'''Arten von Reihungen'''<br />
<br />
* <p> int[] a; Reihung aus ganzen Zahlen<br />
* <p> char[] b; Reihungen aus Zeichen<br />
* <p> boolean[] c; Reihung aus Wahrheitswerten<br />
* <p> int[][] d; Mehrdimensionale Reihung, dabei ist in jedem Element ein eigenes Array enthalten. Jede Dimension wird durch ein paar eckige Klammern dargestellt.<p><br />
'''Initialisierung von Reihen'''<br />
<p><br />
Reihungen werden grundsätzlich mit dem Operator <b> new </b>initialisiert.<br />
<p><br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = new int[10]<br />
</syntaxhighlight><p><br />
In diesem Beispiel erzeugen wir eine Reihung mit 10 Elementen, dieses enthält jedoch noch keine Werte.<br />
<P><br />
Möchte man hingegen eine Reihung mit bereits bekannten Werten initialisieren, fällt der Operator <b> new </b> weg. Die eckigen Klammern werden durch geschwungene ersetzt innerhalb welcher alle Werte, durch ein Komma getrennt, eingetragen werden.<br />
<p> <br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] b = {1,2,3,4,5}<br />
</syntaxhighlight><p><br />
In diesem Beispiel erzeugen wir eine Reihungen mit einer Länge von 5 Elementen mit den Werten 1, 2, 3, 4 und 5.<br />
<br />
'''Auslesen von Werten'''<br />
<br />
Um Werte aus einer Reihung auszulesen, muss man den Namen der Reihung, sowie die Position des Elements in der Reihung auswählen.<br />
<br />
''Beispiel:''<syntaxhighlight lang="java"><br />
int[] a = {1,2,3,4,5}<br />
<br />
Dann gilt:<br />
a[3] = 4<br />
</syntaxhighlight></div>12jojo08https://projekte.zum.de/index.php?title=Informatik_am_Johanneum/Java&diff=41358Informatik am Johanneum/Java2021-01-15T11:25:18Z<p>12jojo08: Nur ein Test</p>
<hr />
<div>===Offene Aufgaben===<br />
<br />
Bitte tragt in die Tabellen ein, welches Thema ihr bearbeiten wollt. Erst wenn ihr euch in der Tabelle für ein Thema eingetragen habt, könnt ihr mit der Bearbeitung beginnen. Ihr könnt Themen auch zu zweit erstellen.<br />
<br />
{| class="wikitable"<br />
|+offene Aufgaben<br />
!offene Aufgabe!!Verantwortlicher<br />
|-<br />
|Klassen in Eclipse anlegen||Erik<br />
|-<br />
|Variablentypen<br />
|Vinzent/J-P<br />
|-<br />
|eigene Methoden schreiben, Syntax der Signatur, return Statement<br />
|<br />
|-<br />
|typische Fehlermeldungen, IndexOutOfBoundsExcecption<br />
|<br />
|-<br />
|Arithmetische Operatoren<br />
|Niklas<br />
|-<br />
|Verzweigungen<br />
|Finn, Nikita<br />
|-<br />
|Schleifen (For-Schleife, While Schleife)<br />
|Vinzent/J-P<br />
|-<br />
|Reihungen (Initialisierung, ...)<br />
|Arian, Dharam<br />
|-<br />
|<br />
|<br />
|}<br />
<br />
Tipps zur Erstellung eines Eintrags: <br />
<br />
*jedes Thema hat eine Überschrift von Typ Unterüberschrift1<br />
*Verwende danach für die einzelnen Teilthemen Unterüberschrift2 oder weitere Unterüberschriften. So erscheinen diese Felder im Inhaltsverzeichnis.<br />
*Quellcode kann eingefügt werden, indem die Zeile im Modus Quelltextbearbeitung mit einem Leerzeichen begonnen wird.<br />
<br />
public void quellcodeSchreiben(){<br />
// dies ist ein Beispiel, wie Quellcode dargestellt werden kann.<br />
// wechsele dazu in den Modus Quelltextbearbeitung (oben rechts bei dem Stft)<br />
// beginne dann jede Quelltextzeile mit einem Leerzeichen.<br />
}<br />
<br /><br />
===Klassen in Eclipse anlegen===<br />
<br /><br />
===Variablentypen===<br />
In Java gibt es verschiedene Typen von Variablen. Einige davon werden im Folgenden erläutert.<br />
<br />
===='''Syntax einer Variable:'''====<br />
Erste Erstellung: Typ + Name = Wert -> Beispiel: int number = 3 / boolean correct = false<br />
<br />
Spätere Bearbeitung: Name = Wert -> Beispiel: number = 1 / correct = true<br />
<br />
Abfrage (z.B. in IF/ELSE Anfragen oder WHILE-Schleifen): Name == Wert -> number == 1 / correct == true<br />
<br />
===='''Ganzzahl-Typen:'''====<br />
integer (int): alle Zahlen zwischen -2147483648 und 2147483647.<br />
<br />
long: alle Zahlen zwischen -9223372036854775808 und 9223372036854775807.<br />
<br />
===='''Kommazahl-Typen:'''====<br />
double: Zahlen mit Kommastellen, aber auch ohne. Double wird verwendet, da die Ganzzahl-Typen keine Kommastellen speichern können.<br />
<br />
===='''Boolean:'''====<br />
boolean: kann zwei Werte annehmen, entweder true oder false, also wahr oder falsch.<br />
<br />
===='''Char'''====<br />
char: kann den Wert eines Unicodezeichens annehmen, also beispielsweise einen Buchstaben oder eine Zahl von 0-9.<br />
<br />
<u>Syntax</u> <br />
<br />
char i = 'J'<br />
<br />
===='''String'''====<br />
String: kann die Werte einer Zeichenkette annehmen<br />
<br />
ACHTUNG: Der Typ String muss in Java mit einem großen 'S' geschrieben werden.<br />
<br />
<u>Syntax</u> <br />
<br />
String java = "Hello World!"<br />
<br />
===='''Array'''====<br />
array[]: eine Reihung von Zahlen: man kann jeder Stelle eines Arrays eine bestimmte Zahl zuweisen.<br />
<br />
<u>''Syntax''</u> <br />
<br />
<u>Erstellen eines Arrays mit der Länge u</u><br />
<br />
int[] example = new int[u]<br />
<br />
<u>Erstellen eines Arrays mit bestimmten vorgegebenen Werten</u><br />
<br />
int example[] = {0, 3, 5, 10, 20, 25}<br />
<br />
<u>Die Ausgaben kann folgendermaßen aussehen</u><br />
<br />
example[3] == 10;<br />
<br />
example[4] == 20;<br />
<br />
<u>Zuweisung eines Wertes für eine Arraystelle:</u><br />
<br />
example[1] = 4;<br />
<br />
Die abgeänderte Reihung besitzt nun folgende Werte: {0, 4, 5, 10, 20, 25}<br />
<br />
<br /><br />
===Arithmetische Operatoren===<br />
=====Grundlagen=====<br />
In der Programmiersprache Java sind arithmetische Operatoren implementiert. Dabei müssen immer numerische Operanten (int, long, float, double) verwendet werden.<br />
=====Operatoren=====<br />
======Addition======<br />
Der Operator der Addition (a+b) addiert einen numerischen Operanden mit einem weiteren numerischen Operanden.<br />
<br />
public class Addition {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a + b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 10<br />
======Subtraktion======<br />
Der Operator der Subtraktion (a-b) subtrahiert einen numerischen Operanden von einem anderen numerischen Operator.<br />
<br />
public class Subtraktion {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a - b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 4 <br />
======Multiplikation======<br />
Der Operator der Multiplikation (a*b) multipliziert einen numerischen Operanden mit einem anderen numerischen Operanden.<br />
<br />
public class Multiplikation {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a * b;<br />
System.out.print(ergebnis);<br />
}<br />
} <br />
<br />
Ausgabe = 21<br />
======Division======<br />
Der Operator der Division (a/b) dividiert einen numerischen Operanden durch einen anderen numerischen Operanden. <br />
<u>Division zweier numerischer Operanden gleichen Typs:</u><br />
In diesem Fall sind die beiden numerischen Operanden ganzzahlig, daher ist auch das Ergebnis ganzzahlig:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 2<br />
<br />
<u> Division zweier numerischer Operanden unterschiedlichen Typs </u><br />
Es ist möglich numerische Operanden unterschiedlichen Typs zu dividieren. Ist einer der numerischen Operanden als Gleitkommazahl definiert, so ist auch das Ergebnis eine Gleitkommazahl:<br />
<br />
public class Division {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
float b = 3;<br />
<br />
errgebnis = a / b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe: 2.3333333<br />
<br />
======Division mit Rest======<br />
Bei der Division mit Rest (modulo) dividiert einen numerischen Operanden durch einen zweiten numerischen Operanden (a%b). Dabei wird der ganzzahlige Rest als Ergebnis ausgegeben:<br />
<br />
public class Modulodivision {<br />
public static void main(String[] args) {<br />
int a = 7;<br />
int b = 3;<br />
<br />
ergebnis = a % b;<br />
System.out.print(ergebnis);<br />
}<br />
}<br />
<br />
Ausgabe = 1<br />
===Verzweigungen===<br />
<br />
====Einführung====<br />
Verzweigungen gehören zu den Kontrollstrukturen Javas, die einen flexiblen und ereignisgesteuerten Ablauf eines Programmes ermöglichen. Für die Verzweigungen braucht man festgelegte Bedingungen. Beim Durchlauf des Programmes wird dann an den Verzweigungen überprüft, ob die Bedingung erfüllt wird oder nicht. Je nachdem welcher Fall zutrifft, wird ein bestimmter Bereich des Programmes ausgeführt. Im Folgenden unterscheiden wir in drei Verzweigungen: ''if''-Anweisung, ''if''-''else''-Anweisung und ''else-if''-Anweisung.<br /><br />
<br />
====''if''-''Anweisung''====<br />
Bei der ''if''-Anweisung wird als erstes überprüft, ob die gestellte Bedingung erfüllt wird oder nicht. Wird die Bedingung erfüllt, werden die danach folgenden Anweisungen ausgeführt. Wird die Bedingung nicht erfüllt, werden die danach folgenden Anweisungen übersprungen. In Java sieht die ''if''-Anweisung so aus:<br />
<br />
if (Bedingung){<br />
Anweisung;<br />
}<br />
<br /><br />
====''if-else''-Anweisung====<br />
Die ''if-else''-Anweisung ist im Prinzip nur eine Erweiterung der ''if''-Anweisung, bei der festgelegt wird, welche Anweisungen ausgeführt werden sollen, wenn die Bedingung nicht erfüllt wird. Man hat also zwei mögliche Fälle. In Java sieht die ''if-else''-Anweisung so aus:<br />
<br />
if (Bedingung) {<br />
Anweisung1;<br />
} <br />
else {<br />
Anweisung2;<br />
}<br />
<br /><br />
<br />
==== ''else-if''-Anweisung ====<br />
Wenn man eine Verzweigung in drei verschiedene Programmbereiche braucht, kann man die ''else-if''-Anweisung verwenden. Bei der''else-if''-Anweisung wird erstmal überprüft, ob die erste Bedingung zutrifft. Wenn diese Bedingung zutrifft, wird der erste Programmbereich durchlaufen. Wenn diese Bedingung nicht zutrifft, wird zur nächsten Prüfung einer Bedingung gesprungen. Wenn diese zweite Bedingung zutrifft, dann werden die dazugehörigen Anweisungen ausgeführt. Wenn diese zweite Bedingung nicht zutrifft, dann wird zum letzten Teil der ''else-if''-Anweisung gesprungen und der letzte Programmbereich ausgeführt. In Java sieht die ''else-if''-Anweisung so aus: <br />
<br />
if (Bedingung1) {<br />
Anweisung1;<br />
} else if (Bedingung2) {<br />
Anweisung2;<br />
} else {<br />
Anweisung3;<br />
}<br />
<br />
<br /><br />
===Schleifen===<br />
'''FOR-Schleife'''<br />
<br />
Die sogenannte FOR-Scheife wird verwendet, wenn man die benötigten Schleifendurchläufe bereits im Voraus kennt. Man benötigt die folgenden drei Parameter: Initialisierung/Startwert, Zielwert und Schrittweite<br />
<br />
<u>Syntax</u><br />
<br />
for(Startwert; Zielwert; Schrittweite)<br />
<br />
<u>Beispiel</u><br />
<br />
for(int i = 1; i < 3; i++) {<br />
gehe 10 Schritte;<br />
}<br />
<br />
Mit dieser Schleife wird bei i == 1 10 Schritte gegangen und bei i == 2 ebenfalls, bei i == 3 nicht mehr, da der Zielwert erreicht ist.<br />
<br />
'''WHILE-Schleife'''<br />
<br />Die sogenannte WHILE-Schleife wird solange ausgeführt, bis eine bestimmte Bedingung nicht erfüllt ist. Diese Bedingung steht am Anfang der Schleife. Sofern die Bedingung anfangs nicht erfüllt wird, wird die Schleife übersprungen.<br />
<br />
<u>Syntax</u><br />
<br />
while(Bedingung) {<br />
Anweisung;<br />
}<br />
<u>Beispiel</u><br />
<br />
boolean correct = true;<br />
while(correct) {<br />
gehe 10 Schritte;<br />
correct = false;<br />
}<br />
Die Schleife wird einmal ausgeführt, da die Bedingung anfangs korrekt und danach nicht mehr korrekt ist.<br />
<br />
<br />
'''DO-WHILE-Schleife'''<br />
<br />
Die sogenannte DO-WHILE-Schleife ist eine WHILE-SCHLEIFE mit dem Unterschied, dass die Anweisung mindestens einmal ausgeführt wird, hierbei ist es anfangs egal, ob die Bedingung erfüllt ist oder nicht.<br />
<br />
<u>Syntax</u><br />
<br />
do {<br />
Anweisung;<br />
} while(Bedingung);<br />
<u>Beispiel</u><br />
<br />
int o = 1;<br />
do {<br />
gehe 10 Schritte;<br />
} while(o == 2);<br />
Diese Schleife wird einmal ausgeführt, danach nicht mehr, da die Bedingung nicht erfüllt wird.<br />
<br />
===Reihungen===<br />
'''Definition'''<br />
Das ist ein test</div>12jojo08https://projekte.zum.de/index.php?title=Benutzer:12jojo08&diff=41356Benutzer:12jojo082021-01-15T11:19:37Z<p>12jojo08: Ich habe eine neue Benutzerseite angelegt</p>
<hr />
<div>=== Projekte: [[Informatik am Johanneum]] ===<br />
<br />
=== Lehrerin: [[Benutzer:Info jojo]] ===</div>12jojo08https://projekte.zum.de/index.php?title=Informatik_am_Johanneum/Java&diff=40992Informatik am Johanneum/Java2021-01-12T10:20:55Z<p>12jojo08: </p>
<hr />
<div>===Offene Aufgaben===<br />
<br />
Bitte tragt in die Tabellen ein, welches Thema ihr bearbeiten wollt. Erst wenn ihr euch in der Tabelle für ein Thema eingetragen habt, könnt ihr mit der Bearbeitung beginnen. Ihr könnt Themen auch zu zweit erstellen.<br />
<br />
{| class="wikitable"<br />
|+offene Aufgaben<br />
!offene Aufgabe!!Verantwortlicher<br />
|-<br />
|Klassen in Eclipse anlegen||Erik<br />
|-<br />
|Variablentypen<br />
|Vinzent/J-P<br />
|-<br />
|eigene Methoden schreiben, Syntax der Signatur, return Statement<br />
|<br />
|-<br />
|typische Fehlermeldungen, IndexOutOfBoundsExcecption<br />
|<br />
|-<br />
|Arithmetische Operatoren<br />
|<br />
|-<br />
|Verzweigungen<br />
|<br />
|-<br />
|Schleifen (For-Schleife, While Schleife)<br />
|Vinzent/J-P<br />
|-<br />
|Reihungen (Initialisierung, ...)<br />
|Arian, Dharam<br />
|-<br />
|<br />
|<br />
|}<br />
<br />
Tipps zur Erstellung eines Eintrags: <br />
<br />
*jedes Thema hat eine Überschrift von Typ Unterüberschrift1<br />
*Quellcode kann eingefügt werden, indem die Zeile im Modus Quelltextbearbeitung mit einem Leerzeichen begonnen wird.<br />
<br />
public void quellcodeSchreiben(){<br />
// dies ist ein Beispiel, wie Quellcode dargestellt werden kann.<br />
// wechsele dazu in den Modus Quelltextbearbeitung (oben rechts bei dem Stft)<br />
// beginne dann jede Quelltextzeile mit einem Leerzeichen.<br />
}<br />
<br />
===Variablentypen===<br />
In Java gibt es verschiedene Typen von Variablen. Einige davon werden im Folgenden erläutert.<br />
<br />
<br />
'''Syntax einer Variable:'''<br />
<br />
Erste Erstellung: Typ + Name = Wert -> Beispiel: int number = 3 / boolean correct = false<br />
<br />
Spätere Bearbeitung: Name = Wert -> Beispiel: number = 1 / correct = true<br />
<br />
Abfrage (z.B. in IF/ELSE Anfragen oder WHILE-Schleifen): Name == Wert -> number == 1 / correct == true<br />
<br />
<br />
'''Ganzzahl-Typen:'''<br />
<br />
integer (int): alle Zahlen zwischen -2147483648 und 2147483647.<br />
<br />
long: alle Zahlen zwischen -9223372036854775808 und 9223372036854775807.<br />
<br />
<br />
'''Kommazahl-Typen:'''<br />
<br />
double: Zahlen mit Kommastellen, aber auch ohne. Double wird verwendet, da die Ganzzahl-Typen keine Kommastellen speichern können.<br />
<br />
<br />
'''Boolean:'''<br />
<br />
boolean: kann zwei Werte annehmen, entweder true oder false, also wahr oder falsch.<br />
<br />
<br />
'''Char'''<br />
<br />
char: kann den Wert eines Unicodezeichens annehmen, also beispielsweise einen Buchstaben oder eine Zahl von 0-9.<br />
<br />
<u>Syntax</u> <br />
<br />
char i = 'J'<br />
<br />
<br />
'''String'''<br />
<br />
String: kann die Werte einer Zeichenkette annehmen<br />
<br />
ACHTUNG: Der Typ String muss in Java mit einem großen 'S' geschrieben werden.<br />
<br />
<u>Syntax</u> <br />
<br />
String java = "Hello World!"<br />
<br />
<br />
'''Array'''<br />
<br />
array[]: eine Reihung von Zahlen: man kann jeder Stelle eines Arrays eine bestimmte Zahl zuweisen.<br />
<br />
<u>''Syntax''</u> <br />
<br />
<u>Erstellen eines Arrays mit der Länge u</u><br />
<br />
int[] example = new int[u]<br />
<br />
<u>Erstellen eines Arrays mit bestimmten vorgegebenen Werten</u><br />
<br />
int example[] = {0, 3, 5, 10, 20, 25}<br />
<br />
<u>Die Ausgaben kann folgendermaßen aussehen</u><br />
<br />
example[3] == 10;<br />
<br />
example[4] == 20;<br />
<br />
<u>Zuweisung eines Wertes für eine Arraystelle:</u><br />
<br />
example[1] = 4;<br />
<br />
Die abgeänderte Reihung besitzt nun folgende Werte: {0, 4, 5, 10, 20, 25}<br />
<br />
<br /><br />
<br />
===Schleifen===<br />
'''FOR-Schleife'''<br />
<br />
Die sogenannte FOR-Scheife wird verwendet, wenn man die benötigten Schleifendurchläufe bereits im Voraus kennt. Man benötigt die folgenden drei Parameter: Initialisierung/Startwert, Zielwert und Schrittweite<br />
<br />
<u>Syntax</u><br />
<br />
for(Startwert; Zielwert; Schrittweite)<br />
<br />
<u>Beispiel</u><br />
<br />
for(int i = 1; i < 3; i++) {<br />
gehe 10 Schritte;<br />
}<br />
<br />
Mit dieser Schleife wird bei i == 1 10 Schritte gegangen und bei i == 2 ebenfalls, bei i == 3 nicht mehr, da der Zielwert erreicht ist.<br />
<br />
'''WHILE-Schleife'''<br />
<br />Die sogenannte WHILE-Schleife wird solange ausgeführt, bis eine bestimmte Bedingung nicht erfüllt ist. Diese Bedingung steht am Anfang der Schleife. Sofern die Bedingung anfangs nicht erfüllt wird, wird die Schleife übersprungen.<br />
<br />
<u>Syntax</u><br />
<br />
while(Bedingung) {<br />
Anweisung;<br />
}<br />
<u>Beispiel</u><br />
<br />
boolean correct = true;<br />
while(correct) {<br />
gehe 10 Schritte;<br />
correct = false;<br />
}<br />
Die Schleife wird einmal ausgeführt, da die Bedingung anfangs korrekt und danach nicht mehr korrekt ist.<br />
<br />
<br />
'''DO-WHILE-Schleife'''<br />
<br />
Die sogenannte DO-WHILE-Schleife ist eine WHILE-SCHLEIFE mit dem Unterschied, dass die Anweisung mindestens einmal ausgeführt wird, hierbei ist es anfangs egal, ob die Bedingung erfüllt ist oder nicht.<br />
<br />
<u>Syntax</u><br />
<br />
do {<br />
Anweisung;<br />
} while(Bedingung);<br />
<u>Beispiel</u><br />
<br />
int o = 1;<br />
do {<br />
gehe 10 Schritte;<br />
} while(o == 2);<br />
Diese Schleife wird einmal ausgeführt, danach nicht mehr, da die Bedingung nicht erfüllt wird.</div>12jojo08