Java: Unterschied zwischen den Versionen
Uli (Diskussion | Beiträge) |
Uli (Diskussion | Beiträge) |
||
(84 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt) | |||
Zeile 44: | Zeile 44: | ||
float variable11 = 2.123456789f; | float variable11 = 2.123456789f; | ||
double variable12 = 2.123456789123456789; | double variable12 = 2.123456789123456789; | ||
+ | ===Sichtbarkeit von Variablen=== | ||
+ | Variablen sind immer nur in den Blöcken, in denen sie deklariert/initialisiert wurden und den darunterliegenden Blöcken, sichtbar | ||
+ | '''Beispiel''' | ||
+ | |||
+ | { | ||
+ | int var1 = 1; | ||
+ | |||
+ | { | ||
+ | <font color=lime>'''System.out.println(var1)'''</font> | ||
+ | } | ||
+ | <font color=lime>'''System.out.println(var1)'''</font> | ||
+ | } | ||
+ | <font color=red>'''System.out.println(var1)'''</font> | ||
+ | Variablen werden nach ende de Blocks, in denen sie deklariert/initialisiert wurde, zerstört. | ||
− | + | ===String=== | |
− | |||
<font color=green>//String ist ein komplexer Datentype.</font> | <font color=green>//String ist ein komplexer Datentype.</font> | ||
<font color=green>//Diese werden am Anfang groß geschrieben</font> | <font color=green>//Diese werden am Anfang groß geschrieben</font> | ||
Zeile 55: | Zeile 68: | ||
System.out.println(verketterString); | System.out.println(verketterString); | ||
− | + | ===boolean=== | |
boolean variable1 = true; | boolean variable1 = true; | ||
boolean variable2 = false; | boolean variable2 = false; | ||
Zeile 64: | Zeile 77: | ||
System.out.println(variable3); | false <font color=green>//Hier wird die Wahrheit geprüft</font> | System.out.println(variable3); | false <font color=green>//Hier wird die Wahrheit geprüft</font> | ||
− | + | ===char=== | |
<font color=green>//Die Variable '''char''' kann immer nur ein Zeichen Speichern</font> | <font color=green>//Die Variable '''char''' kann immer nur ein Zeichen Speichern</font> | ||
char variable1 = 'a'; | char variable1 = 'a'; | ||
Zeile 130: | Zeile 143: | ||
'''==''' gleich <font color=green>//4 == 4 (true) 3 == 4 (false)</font> | '''==''' gleich <font color=green>//4 == 4 (true) 3 == 4 (false)</font> | ||
'''!=''' ungleich <font color=green>//4 != 4 (false 3 != 4 (true)</font> | '''!=''' ungleich <font color=green>//4 != 4 (false 3 != 4 (true)</font> | ||
+ | ===Ternärer Operator=== | ||
+ | Der ternäre Operator kann eine if-else-Verzweigung ersetzen. Er ist der einzige Operator, der '''mit drei Operanden arbeitet''', wird oft auch Bedingungsoperator genannt. Wenn die <font color=blue>Bedingung</font> '''true''' ist, wird der <font color=red>erste Wert</font> nach dem Fragezeichen zugewiesen, wenn die <font color=blue>Bedingung</font> '''false''' ist, wird der <font color=orange>zweite Wert</font> zugewiesen | ||
+ | variable = <font color=blue>bedingung</font> ? <font color=red>wert1</font> : <font color=orange>wert2</font> | ||
+ | |||
+ | max = <font color=blue>(a > b)</font> '''?''' <font color=red>a</font> : <font color=orange>b;</font> | ||
+ | Der ternäre Operand kann deshalb auch ale einfach '''IF''' Bedingung verwendet werden [[#If | zum IF Abschnitt]] | ||
===Logische Operatoren=== | ===Logische Operatoren=== | ||
'''||''' logisches ODER kurz: OR <font color=green>//(a<b) '''||''' (c==d)</font> | '''||''' logisches ODER kurz: OR <font color=green>//(a<b) '''||''' (c==d)</font> | ||
− | '''&&''' logisches UND kurz: AND <font color=green>//(a<b) '''&& | + | '''&&''' logisches UND kurz: AND <font color=green>//(a<b) '''&&''' (c==d)</font> |
'''! ''' logisches NICHT kurz: NOT <font color=green>//!b</font> | '''! ''' logisches NICHT kurz: NOT <font color=green>//!b</font> | ||
+ | |||
+ | ===Bitweise Operatoren=== | ||
+ | '''<<''' Linksshift x<<1; <font color=green>//alle Bits nach links schieben</font> | ||
+ | '''>>''' Rechtsshift x>>1; <font color=green>//alle Bits nach rechts schieben</font> | ||
+ | '''& ''' AND 2&3; <font color=green>//UND Operator</font> | ||
+ | '''| ''' OR 2|3; <font color=green>//ODER Operator</font> | ||
+ | '''^ ''' XOR 2^3; <font color=green>//exlusiv ODER Operator</font> | ||
+ | ====Beispiele==== | ||
+ | int a = 6; | ||
+ | int b = a & 0xFD; | ||
+ | <font color=green>// 6 0000 0110</font> | ||
+ | <font color=green>// 0x01 0000 0001</font> | ||
+ | <font color=green>// --------------------</font> | ||
+ | <font color=green>// 1111 0100</font> | ||
+ | <font color=green>//Alles Bits die in der Maske 0 sind, werden auf 0 gesetzt</font> | ||
+ | <font color=green>//Alles Bits die in der Maske 1 sind bleiben unverändert</font> | ||
+ | |||
+ | System.out.println("Ergebnis: " + b); | ||
+ | |||
+ | int aa = 6; | ||
+ | int bb = aa | 0x01; | ||
+ | <font color=green>// 6 0000 0110</font> | ||
+ | <font color=green>// 0x01 0000 0001</font> | ||
+ | <font color=green>// --------------------</font> | ||
+ | <font color=green>// 0000 0111</font> | ||
+ | <font color=green>//Alles Bits die in der Maske 1 sind, werden auf 1 gesetzt</font> | ||
+ | <font color=green>//Alles Bits die in der Maske 0 sind bleiben unverändert</font> | ||
+ | |||
+ | System.out.println("Ergebnis: " + bb); | ||
+ | |||
+ | int aaa = 6; | ||
+ | int bbb = aaa ^ 0x0F; | ||
+ | <font color=green>// 6 0000 0110</font> | ||
+ | <font color=green>// 0x0F 0000 1111</font> | ||
+ | <font color=green>// --------------------</font> | ||
+ | <font color=green>// 0000 1001</font> | ||
+ | <font color=green>//Alles Bits die in der Maske 1 sind, werden invertiert</font> | ||
+ | <font color=green>//Alles Bits die in der Maske 0 sind bleiben unverändert</font> | ||
+ | |||
+ | System.out.println("Ergebnis: " + bbb); | ||
+ | |||
+ | ===Rangfolge der Operatoren=== | ||
+ | * Beispiel | ||
+ | int a = 2 | ||
+ | int ergebnis = ++a * 2 <font color=green>//oder</font> | ||
+ | int ergebnis = (++a) * (2) | ||
+ | [https://de.wikibooks.org/w/index.php?title=Java_Standard:_Operatoren&action=edit§ion=10 QUELLE de.wikibooks.org] | ||
+ | * Die Rangfolge der Operatoren wird hier in einer georneten Liste dargestellt. | ||
+ | {| class="wikitable center" style="text-align:left" | ||
+ | ! Rangfolge | ||
+ | ! Typ | ||
+ | ! Operatoren | ||
+ | |- | ||
+ | | style="width: 5%" | 1 | ||
+ | | style="width:50%" | Postfix-Operatoren, Postinkrement, Postdekrement || <code>x++</code>, <code>x--</code> | ||
+ | |- | ||
+ | || 2 || Einstellige (unäre) Operatoren, Vorzeichen || <code>++x</code>, <code>--x</code>, <code>+x</code>, <code>-x</code>, <code>~b</code>, <code>!b</code> | ||
+ | |- | ||
+ | || 3 || Multiplikation, Teilerrest || <code>a*b</code>, <code>a/b</code>, <code>a % b</code> | ||
+ | |- | ||
+ | || 4 || Addition, Subtraktion || <code>a + b</code>, <code>a - b</code> | ||
+ | |- | ||
+ | || 5 || Bitverschiebung || <code>d << k</code>, <code>d >> k</code>, <code>d >>> k</code> | ||
+ | |- | ||
+ | || 6 || Vergleiche || <code>a < b</code>, <code>a > b</code>, <code>a <= b</code>, <code>a >= b</code>, <code>s instanceof S</code> | ||
+ | |- | ||
+ | || 7 || Gleich, Ungleich || <code>a == b</code>, <code>a != b</code> | ||
+ | |- | ||
+ | || 8 || UND (Bits) || <code>b & c</code> | ||
+ | |- | ||
+ | || 9 || Exor (Bits) || <code>b ^ c</code> | ||
+ | |- | ||
+ | || 10 || ODER (Bits) || <code>b <nowiki>|</nowiki> c</code> | ||
+ | |- | ||
+ | || 11 || Logisch UND || <code>B && C</code> | ||
+ | |- | ||
+ | || 12 || Logisch ODER || <code>B <nowiki>||</nowiki> C</code> | ||
+ | |- | ||
+ | || 13 || Bedingungsoperator || <code>a ? b : c</code> | ||
+ | |- | ||
+ | || 14 || Zuweisungen || <code>a = b</code>, <code>a += 3</code>, <code>a -= 3</code>, <code>a *= 3</code>, <code>a /= 3</code>, <code>a %= 3</code>, <code>b &= c</code>, <code>b ^= c</code>, <code>b <nowiki>|</nowiki>= c</code>, <code>d <<=k</code>, <code>d >>= k</code>, <code>d >>>= k</code> | ||
+ | |} | ||
==Ausgabe== | ==Ausgabe== | ||
Zeile 197: | Zeile 298: | ||
} | } | ||
+ | } | ||
+ | |||
+ | ==Kontrollstrukturen== | ||
+ | |||
+ | ===If=== | ||
+ | if(zahl < 30) { | ||
+ | System.out.println("Die Zahl ist kleiner 30"): | ||
+ | } | ||
+ | else if(zahl > 30) { | ||
+ | System.out.println("Die Zahl ist größer 30"): | ||
+ | } | ||
+ | else { | ||
+ | System.out.println("Die Zahl ist gleich 30"): | ||
+ | } | ||
+ | Beispiele: | ||
+ | * AND Verknüpfung | ||
+ | if(zahl < 3 & zahl > 0) { | ||
+ | <font color=green>//Die Bedingung ist nur '''true''' wenn '''zahl''' 1 oder 2 ist</font> | ||
+ | } | ||
+ | * OR Verknüpfung | ||
+ | if(zahl == 3 || zahl == 4) { | ||
+ | <font color=green>//Die Bedingung ist '''true''' wenn '''zahl''' 3 oder 4 ist</font> | ||
+ | } | ||
+ | ===ternärer Operand '''?''' statt IF=== | ||
+ | Eine Besonderheit ist der [[#Tern.C3.A4rer_Operator | siehe weiter oben]] | ||
+ | var = <font color=blue>(a > b)</font> '''?''' <font color=red>a</font> : <font color=orange>b</font>; | ||
+ | Wenn die <font color=blue>Bedingung</font> '''true''' ist, wird der <font color=red>erste Wert</font> nach dem Fragezeichen zugewiesen, wenn die <font color=blue>Bedingung</font> '''false''' ist, wird der <font color=orange>zweite Wert</font> zugewiesen | ||
+ | |||
+ | ===Switch Case=== | ||
+ | <font color=green>Der '''break'''am Ende ist wichtig, da sonst die anderen Case auch ausgeführt wedern</font> | ||
+ | switch(zahl) { | ||
+ | case 1: System.out.println("Die Zahl 1 wurde eingegeben"); break; | ||
+ | case 2: System.out.println("Die Zahl 2 wurde eingegeben"); break; | ||
+ | case 3: System.out.println("Die Zahl 3 wurde eingegeben"); break; | ||
+ | default: System.out.println("Es wurde nicht die Zahl 1, 2 oder 3 eingegeben ..."); | ||
+ | } | ||
+ | * Weitere Beispiele wie ein case verwendet werden kann: | ||
+ | switch(zahl) { | ||
+ | case 1: System.out.println("Die Zahl 1 wurde eingegeben"); break; | ||
+ | '''case 2: case 3:''' System.out.println("Die Zahl 2 wurde eingegeben"); break; | ||
+ | default: System.out.println("Es wurde nicht die Zahl 1, 2 oder 3 eingegeben ..."); | ||
+ | } | ||
+ | |||
+ | switch(zahl) { | ||
+ | case 1: { | ||
+ | System.out.println("Die Zahl 1 wurde eingegeben"); | ||
+ | break; | ||
+ | } | ||
+ | case 2: { | ||
+ | System.out.println("Die Zahl 2 wurde eingegeben"); | ||
+ | break; | ||
+ | } | ||
+ | case 3: { | ||
+ | System.out.println("Die Zahl 3 wurde eingegeben"); | ||
+ | break; | ||
+ | } | ||
+ | default: System.out.println("Es wurde nicht die Zahl 1, 2 oder 3 eingegeben ..."); | ||
+ | } | ||
+ | |||
+ | ==Schleifen== | ||
+ | ===While Schleife=== | ||
+ | * Kopfgesteuerte Schleife | ||
+ | while(var1 < 10) { | ||
+ | |||
+ | System.out.println("Das ist eine Schleife " + var1); | ||
+ | |||
+ | var1++; <font color=green>//Die Variable var1 wird immer um eins erhöht, bis die Bedingung (var1 < 10) nicht mehr true zurück liefert</font> | ||
+ | } | ||
+ | ===DO While Schleife=== | ||
+ | * Fußgesteuerte Schleife | ||
+ | int var1 = 8 | ||
+ | do { | ||
+ | System.out.println("Das ist eine Schleife " + var1); | ||
+ | var1--; | ||
+ | } | ||
+ | while(var1 > 5); <font color=green>//Erst wird die Schleife mit Anweisungen ausgeführt, dann erst kommt die Prüfung</font> | ||
+ | ===FOR Schleife=== | ||
+ | * Kopfgesteuerte Schleife | ||
+ | * In der FOR Schleife wird im ersten Block die Variable '''i''' initialisiert, im zweiten Block wird eine Bedingungen geprüft und im dritten Block wird die initialisierte Variable hoch gezählt. Die Initialisierung geschieht nur beim Start der FOR Schleife. | ||
+ | for(int i = 0; i <= 10; i++) { <font color=green> //i++ entsprichet i = i + 1</font> | ||
+ | System.out.println("Durchlauf Nr: " + i); | ||
+ | } | ||
+ | |||
+ | ==Methodem== | ||
+ | Mittels Methoden lassen sich Programmteile aus der Main-Methode auslagern. Dies erhöht die Übersichtlichkeit der Main-Methode. Zudem können Programmteile die an verschiedenen Stellen im Programm benötigt werden, als Mehtode aufgerufen werden. Damit muss der Code nicht mehrfach geschrieben werden. | ||
+ | |||
+ | public class Program { | ||
+ | |||
+ | public static void main(String[] args) { | ||
+ | |||
+ | int ersteZahl = 0; | ||
+ | int zweiteZahl = 0; | ||
+ | |||
+ | <font color=green>//Aufruf - Methode ohne Übergabe von Parametern</font> | ||
+ | public static void einfacheMethode() | ||
+ | |||
+ | <font color=green>//Aufruf - Methode mit Übergabe von Parametern</font> | ||
+ | public static void UebergabeMethode(ersteZahl, zweiteZahl) | ||
+ | |||
+ | } | ||
+ | |||
+ | <font color=green>//Methode ohne Übergabe von Parametern</font> | ||
+ | public static void einfacheMethode() { | ||
+ | |||
+ | System.out.print("Mehr macht die Methode nicht"); | ||
+ | |||
+ | } | ||
+ | <font color=green>//Methode mit Übergabe von Parametern | ||
+ | //Der variablen Typ muss in der Methode neu deklariert werden</font> | ||
+ | public static void UebergabeMethode(int ersteZahl, int zweiteZahl) { | ||
+ | |||
+ | System.out.print("Ausgabe der Variablen: " + ersteZahl + zweiteZahl); | ||
+ | |||
+ | } | ||
+ | } | ||
+ | |||
+ | =Beispiele= | ||
+ | ==BMI Rechner== | ||
+ | <font color=green>//Import Scanner Class</font> | ||
+ | import java.util.Scanner; | ||
+ | |||
+ | public class Program { | ||
+ | |||
+ | public static void main(String[] args) { | ||
+ | |||
+ | <font color=green>Variablen deklarieren</font> | ||
+ | double gewicht; | ||
+ | double groesse; | ||
+ | int alter; | ||
+ | |||
+ | <font color=green>//Scanner definieren</font> | ||
+ | Scanner sc = new Scanner(System.in); | ||
+ | |||
+ | <font color=green>//Werte abfragen</font> | ||
+ | System.out.print("Bitte geben Sie Ihr Gewicht ein :"); | ||
+ | gewicht = sc.nextDouble(); | ||
+ | |||
+ | System.out.print("Bitte geben Sie Ihre Größe ein :"); | ||
+ | groesse = sc.nextDouble(); | ||
+ | |||
+ | System.out.print("Bitte geben Sie Ihr Alter ein :"); | ||
+ | alter = sc.nextInt(); | ||
+ | |||
+ | <font color=green>//Berechnung des BMI</font> | ||
+ | double bmi = (gewicht) / (groesse * groesse); | ||
+ | System.out.println("Ihr BMI beträgt: " + bmi); | ||
+ | |||
+ | <font color=green>//Ausgabe des Soll BMI Werts entsprechend dem Alter</font> | ||
+ | if (alter >= 19 && alter <= 24) { | ||
+ | System.out.println("Ihr BMI sollte zwischen 19 und 24 liegen"); | ||
+ | } else if (alter >= 25 && alter <= 34) { | ||
+ | System.out.println("Ihr BMI sollte zwischen 20 und 25 liegen"); | ||
+ | } else if (alter >= 35 && alter <= 44) { | ||
+ | System.out.println("Ihr BMI sollte zwischen 21 und 26 liegen"); | ||
+ | } else if (alter >= 45 && alter <= 54) { | ||
+ | System.out.println("Ihr BMI sollte zwischen 22 und 27 liegen"); | ||
+ | } else if (alter >= 55 && alter <= 34) { | ||
+ | System.out.println("Ihr BMI sollte zwischen 23 und 28 liegen"); | ||
+ | } else { | ||
+ | System.out.println("Ihr BMI sollte zwischen 24 und 29 liegen"); | ||
+ | } | ||
+ | } | ||
+ | ==Berechnung mit Modulo - IF Abfrage - FOR Schleife == | ||
+ | Es werden die Zahlen '''1 bis 100''' ausgegeben. Die Zahlen die durch '''3 oder/und 4 teilbar''' sind werden durch '''entsprechenden Text ersetzt''' | ||
+ | public class Program { | ||
+ | |||
+ | public static void main(String[] args) { | ||
+ | |||
+ | for(int i = 1; i <= 100; i++) { | ||
+ | |||
+ | int var3 = 3; | ||
+ | int var4 = 4; | ||
+ | |||
+ | var3 = i % 3; <font color=green>//vorherige Berechnun mit Modulo</font> | ||
+ | var4 = i % 4; <font color=green>//vorherige Berechnun mit Modulo</font> | ||
+ | |||
+ | if((i % 3) == 0 && (i % 4) != 0) { <font color=green>//Beispiel ohne vorherige Berechnung</font> | ||
+ | System.out.println("Durch 3 teilbar"); | ||
+ | } else if(var4 == 0 && var3 != 0) { | ||
+ | System.out.println("Durch 4 teilbar"); | ||
+ | } else if(var3 == 0 && var4 == 0) { | ||
+ | System.out.println("Durch 3 und 4 teilbar"); | ||
+ | } else { | ||
+ | System.out.println("Durchlauf Nr: " + i); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | ==Einfacher Taschenrechner== | ||
+ | import java.util.Scanner; | ||
+ | |||
+ | public class Program { | ||
+ | |||
+ | public static void main(String[] args) { | ||
+ | |||
+ | int zahl1; | ||
+ | int zahl2; | ||
+ | int op; | ||
+ | int result; | ||
+ | int next = 1; | ||
+ | |||
+ | |||
+ | do { | ||
+ | |||
+ | Scanner sc = new Scanner(System.in); | ||
+ | |||
+ | System.out.print("Bitte geben Sie eine Ganzahll ein: "); | ||
+ | zahl1 = sc.nextInt(); | ||
+ | |||
+ | System.out.print("Bitte geben Sie eine weiter Ganzahll ein: "); | ||
+ | zahl2 = sc.nextInt(); | ||
+ | |||
+ | System.out.print("Bitte geben Sie einen Operator ein: 1+ 2- 3* 4/ "); | ||
+ | op = sc.nextInt(); | ||
+ | |||
+ | switch(op) { | ||
+ | case 1: { | ||
+ | result = zahl1 + zahl2; | ||
+ | System.out.println("Ergebnis: " + result ); break; | ||
+ | } | ||
+ | case 2: { | ||
+ | result = zahl1 - zahl2; | ||
+ | System.out.println("Ergebnis: " + result ); break; | ||
+ | } | ||
+ | case 3: { | ||
+ | result = zahl1 * zahl2; | ||
+ | System.out.println("Ergebnis: " + result ); break; | ||
+ | } | ||
+ | case 4: { | ||
+ | result = zahl1 / zahl2; | ||
+ | System.out.println("Ergebnis: " + result ); break; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | System.out.print("Möchten Sie eine weitere Berechnung durchführen? 1/Ja 2/Nein : "); | ||
+ | next = sc.nextInt(); | ||
+ | } | ||
+ | while(next == 1); | ||
+ | |||
+ | } | ||
+ | |||
} | } | ||
Aktuelle Version vom 26. November 2018, 16:54 Uhr
Inhaltsverzeichnis
Java - allgemeines
Installation der notwendigen Programme
Um mit Java Programmieren zu können, benötigt man das Java SE Development KIT. Bei der Erstellung dieser Doku war Java SE 8u191aktuell. Grundsätzlich sollte die Doku aber auch für später folgende Versionen genutzt werden können.
Um sich die Java Programmierung leichter zu machen, empfiehlt sich eine IDE (Entwicklungsumgebung). Ich verwende Eclipse
Java
IDE Eclipse
- https://www.eclipse.org/downloads/ Download Eclipse
Java Buch online
Programmierung
Das Hauptprogramm
Java benötigt ein Startprogramm. Dieses wir immer zuerst ausgeführt
public class Program { public static void main(String[] args) { // Main Progam }
Variablen
- Wahrheitswert
boolean = true/false
- Zeichen //char kann nur ein Zeichen aufnehmen
char = A
- Ganzahlen Datentypen
byte = Ganzzahlen 8bit -128 bis + 127 short = Ganzzahlen 16bit -32768 bis 32767 int = Ganzzahlen 32bit -2.147.483.648 bis 2.147.483.647 long = Ganzzahlen 64bit -9223372036854775808 bis 9223372036854775807
- Flieskomma Datentypen
float = Flieskomma 32bit +/-1,4E-45 ... +/-3,4E+38 an f denken double = Flieskomma 64bit +/-4,9E-324 ... +/-1,7E+308 float variable11 = 2.123456789f; double variable12 = 2.123456789123456789;
Sichtbarkeit von Variablen
Variablen sind immer nur in den Blöcken, in denen sie deklariert/initialisiert wurden und den darunterliegenden Blöcken, sichtbar
Beispiel { int var1 = 1; { System.out.println(var1) } System.out.println(var1) } System.out.println(var1)
Variablen werden nach ende de Blocks, in denen sie deklariert/initialisiert wurde, zerstört.
String
//String ist ein komplexer Datentype. //Diese werden am Anfang groß geschrieben String testVariable = "Teste einen String"; String verketterString = testVariable + " Hallo"; System.out.println(testVariable); System.out.println(verketterString);
boolean
boolean variable1 = true; boolean variable2 = false; boolean variable3 = 2 < 1; //Hier wird die Wahrheit geprüft System.out.println(variable1); | true System.out.println(variable2); | false System.out.println(variable3); | false //Hier wird die Wahrheit geprüft
char
//Die Variable char kann immer nur ein Zeichen Speichern char variable1 = 'a'; char variable2 = 'B'; char variable3 = '*'; variable3 = 'a' + 'b'; System.out.println(variable3); //Ergebiss à - Es werden die ASCII Zahlen addiert und das Entsprechende Zeichen ausgegeben
Operatoren
Zuweisungoperator
Das = ist der Zuweisungsopertator. Mit diesem Zeichen werden Werte Variablen zugewiesen
//einfacher Zuweisungsoperator int ergebnis1 = 12; int ergebnis2 = 12 + 7; int ergebnis3 = (12+4) * 2;
Das = kann mit andren Operatorne kombiniert werden um z.B. Berechnungen durchzuführen und das Ergebnis einer Variablen zuzuweisen
//kombinierter Zuweisungsoperator int variable1 = 3; variable1 = variable1 + 10; //oder in der Kurzschreibweise
variable2 += 10; // entspricht: variable2 = variable2 + 10; variable2 -= 10; // entspricht: variable2 = variable2 - 10; variable2 /= 3; // entspricht: variable2 = variable2 / 3; variable2 *= 5; // entspricht: variable2 = variable2 * 5; variable2 %= 2; // entspricht: variable2 = variable2 % 2; //Modulo
Arithmetische Operatoren
- Vorzeichen - Beispiel: zahl = -3; + Vorzeichen + Beispiel: zahl = +3;
+ Addition Beispiel: zahl = 3 + 4; - Subtraktion Beispiel: zahl = 3 + 4; * Multiplikation Beispiel: zahl = 3 + 4; / Division Beispiel: zahl = 3 + 4;
Modulo darf nur mit Ganzzahlen verwendet werden
% Modulo Beispiel: zahl = 32%3; Ergebnis: 2) //Rest der nach Division übrig bleibt int zahl1 = 13; int zahl2 = 4; int ergebnis = zahl1 / zahl2; Ergebnis: 3 //INT ist eine Ganzzahl, deshalb werden Nachkommazahlen nicht angezeigt int ergebnis = zahl1 % zahl2; Ergebnis: 1 //Bei Modulo wird der Resr der Division ausgegeben 13/4 = 12 Rest 1
Inkrement und Dekrement Operator
- unäre Operatoren
- erhöht bzw. verringert den Wert einer Variable um eine EinheitVergleichsoper
Syntax des Inkrement Operators: ++ Syntax des Dekrement Operators: --
c = ++a; //Präinkrement Ergebnis c = 6 c = a++; //Postinkrement Ergebnis c = 5 c = --a; //Präinkrement Ergebnis c = 4 c = a--; //Postinkrement Ergebnis c = 5
- Wird der De/Inkrement Operator vor die Variable geschrieben, wird der Wert der Variable erst in c geschrieben und danach erhöht/verringert
- Wird der De/Inkrement Operator hinter die Variable geschrieben, wird der Wert der Variable erst erhöht/verringert und danach in c der neue Wert geschrieben
Vergleichsoperatoren
< kleiner als //1 < 6 (true) > größer als //1 > 6 (false) <= kleiner als oder gleich //4 <= 4 (true) 3 <= 4 (true) >= größer als oder gleich //4 >= 4 (true) 6 >= 4 (true) == gleich //4 == 4 (true) 3 == 4 (false) != ungleich //4 != 4 (false 3 != 4 (true)
Ternärer Operator
Der ternäre Operator kann eine if-else-Verzweigung ersetzen. Er ist der einzige Operator, der mit drei Operanden arbeitet, wird oft auch Bedingungsoperator genannt. Wenn die Bedingung true ist, wird der erste Wert nach dem Fragezeichen zugewiesen, wenn die Bedingung false ist, wird der zweite Wert zugewiesen
variable = bedingung ? wert1 : wert2
max = (a > b) ? a : b;
Der ternäre Operand kann deshalb auch ale einfach IF Bedingung verwendet werden zum IF Abschnitt
Logische Operatoren
|| logisches ODER kurz: OR //(a<b) || (c==d) && logisches UND kurz: AND //(a<b) && (c==d) ! logisches NICHT kurz: NOT //!b
Bitweise Operatoren
<< Linksshift x<<1; //alle Bits nach links schieben >> Rechtsshift x>>1; //alle Bits nach rechts schieben & AND 2&3; //UND Operator | OR 2|3; //ODER Operator ^ XOR 2^3; //exlusiv ODER Operator
Beispiele
int a = 6; int b = a & 0xFD; // 6 0000 0110 // 0x01 0000 0001 // -------------------- // 1111 0100 //Alles Bits die in der Maske 0 sind, werden auf 0 gesetzt //Alles Bits die in der Maske 1 sind bleiben unverändert System.out.println("Ergebnis: " + b); int aa = 6; int bb = aa | 0x01; // 6 0000 0110 // 0x01 0000 0001 // -------------------- // 0000 0111 //Alles Bits die in der Maske 1 sind, werden auf 1 gesetzt //Alles Bits die in der Maske 0 sind bleiben unverändert System.out.println("Ergebnis: " + bb); int aaa = 6; int bbb = aaa ^ 0x0F; // 6 0000 0110 // 0x0F 0000 1111 // -------------------- // 0000 1001 //Alles Bits die in der Maske 1 sind, werden invertiert //Alles Bits die in der Maske 0 sind bleiben unverändert System.out.println("Ergebnis: " + bbb);
Rangfolge der Operatoren
- Beispiel
int a = 2 int ergebnis = ++a * 2 //oder int ergebnis = (++a) * (2)
- Die Rangfolge der Operatoren wird hier in einer georneten Liste dargestellt.
Rangfolge | Typ | Operatoren |
---|---|---|
1 | Postfix-Operatoren, Postinkrement, Postdekrement | x++ , x--
|
2 | Einstellige (unäre) Operatoren, Vorzeichen | ++x , --x , +x , -x , ~b , !b
|
3 | Multiplikation, Teilerrest | a*b , a/b , a % b
|
4 | Addition, Subtraktion | a + b , a - b
|
5 | Bitverschiebung | d << k , d >> k , d >>> k
|
6 | Vergleiche | a < b , a > b , a <= b , a >= b , s instanceof S
|
7 | Gleich, Ungleich | a == b , a != b
|
8 | UND (Bits) | b & c
|
9 | Exor (Bits) | b ^ c
|
10 | ODER (Bits) | b | c
|
11 | Logisch UND | B && C
|
12 | Logisch ODER | B || C
|
13 | Bedingungsoperator | a ? b : c
|
14 | Zuweisungen | a = b , a += 3 , a -= 3 , a *= 3 , a /= 3 , a %= 3 , b &= c , b ^= c , b |= c , d <<=k , d >>= k , d >>>= k
|
Ausgabe
Mit System.out.println oder System.out.print. Bei println wird im Gegensatz zu print ein Zeilenumbruch nach der Ausgabe gemacht.
public class Program { public static void main(String[] args) { System.out.println("Hallo Welt"); //Variablen initialisieren String einString = "Ich bin ein STring"; int zahl = 7; //Konstanten ausgeben System.out.print("Test "); System.out.println(4); //Variablen ausgeben System.out.println(einString); System.out.println(zahl); //Ausgaben verketten System.out.println(einString + zahl); System.out.println("Der inhalt der Variablen zahl ist: " + zahl); } }
Eingabe (Scanner)
Mit der Klasse Scanner können Eingaben vom Nutzer an das Programm übergeben werden
//Import Scanner Klasse import java.util.Scanner; public class Program { //Main Program public static void main(String[] args) { //Variablen werden immer am Anfang des Programms definiert String vorname, nachname; int alter; //Scanner Klasse für die Eingabe wird definiert Scanner sc = new Scanner(System.in); //Abfrage Vornamen System.out.print("Bitte gegen Sie Ihren Vornamen ein: "); vorname = sc.next(); //Zuweisung des Scanners in eine Stringvariable //Abfrage Nachnamen System.out.print("Bitte gegen Sie Ihren Nachnamen ein: "); nachname = sc.next(); //Zuweisung des Scanners in eine Stringvariable //Abfrage Alter System.out.print("Bitte gegen Sie Ihr Alter ein: "); alter = sc.nextInt(); //Zuweisung des Scanners in eine Integer Variable //Ausgabe der Eingaben System.out.println("Hallo Herr " + vorname + " " + nachname); System.out.println("Sie sind " + alter + " Jahre alt"); } }
Kontrollstrukturen
If
if(zahl < 30) { System.out.println("Die Zahl ist kleiner 30"): } else if(zahl > 30) { System.out.println("Die Zahl ist größer 30"): } else { System.out.println("Die Zahl ist gleich 30"): }
Beispiele:
- AND Verknüpfung
if(zahl < 3 & zahl > 0) { //Die Bedingung ist nur true wenn zahl 1 oder 2 ist }
- OR Verknüpfung
if(zahl == 3 || zahl == 4) { //Die Bedingung ist true wenn zahl 3 oder 4 ist }
ternärer Operand ? statt IF
Eine Besonderheit ist der siehe weiter oben
var = (a > b) ? a : b;
Wenn die Bedingung true ist, wird der erste Wert nach dem Fragezeichen zugewiesen, wenn die Bedingung false ist, wird der zweite Wert zugewiesen
Switch Case
Der breakam Ende ist wichtig, da sonst die anderen Case auch ausgeführt wedern switch(zahl) { case 1: System.out.println("Die Zahl 1 wurde eingegeben"); break; case 2: System.out.println("Die Zahl 2 wurde eingegeben"); break; case 3: System.out.println("Die Zahl 3 wurde eingegeben"); break; default: System.out.println("Es wurde nicht die Zahl 1, 2 oder 3 eingegeben ..."); }
- Weitere Beispiele wie ein case verwendet werden kann:
switch(zahl) { case 1: System.out.println("Die Zahl 1 wurde eingegeben"); break; case 2: case 3: System.out.println("Die Zahl 2 wurde eingegeben"); break; default: System.out.println("Es wurde nicht die Zahl 1, 2 oder 3 eingegeben ..."); }
switch(zahl) { case 1: { System.out.println("Die Zahl 1 wurde eingegeben"); break; } case 2: { System.out.println("Die Zahl 2 wurde eingegeben"); break; } case 3: { System.out.println("Die Zahl 3 wurde eingegeben"); break; } default: System.out.println("Es wurde nicht die Zahl 1, 2 oder 3 eingegeben ..."); }
Schleifen
While Schleife
- Kopfgesteuerte Schleife
while(var1 < 10) { System.out.println("Das ist eine Schleife " + var1); var1++; //Die Variable var1 wird immer um eins erhöht, bis die Bedingung (var1 < 10) nicht mehr true zurück liefert }
DO While Schleife
- Fußgesteuerte Schleife
int var1 = 8 do { System.out.println("Das ist eine Schleife " + var1); var1--; } while(var1 > 5); //Erst wird die Schleife mit Anweisungen ausgeführt, dann erst kommt die Prüfung
FOR Schleife
- Kopfgesteuerte Schleife
- In der FOR Schleife wird im ersten Block die Variable i initialisiert, im zweiten Block wird eine Bedingungen geprüft und im dritten Block wird die initialisierte Variable hoch gezählt. Die Initialisierung geschieht nur beim Start der FOR Schleife.
for(int i = 0; i <= 10; i++) { //i++ entsprichet i = i + 1 System.out.println("Durchlauf Nr: " + i); }
Methodem
Mittels Methoden lassen sich Programmteile aus der Main-Methode auslagern. Dies erhöht die Übersichtlichkeit der Main-Methode. Zudem können Programmteile die an verschiedenen Stellen im Programm benötigt werden, als Mehtode aufgerufen werden. Damit muss der Code nicht mehrfach geschrieben werden.
public class Program { public static void main(String[] args) { int ersteZahl = 0; int zweiteZahl = 0; //Aufruf - Methode ohne Übergabe von Parametern public static void einfacheMethode() //Aufruf - Methode mit Übergabe von Parametern public static void UebergabeMethode(ersteZahl, zweiteZahl) } //Methode ohne Übergabe von Parametern public static void einfacheMethode() { System.out.print("Mehr macht die Methode nicht"); } //Methode mit Übergabe von Parametern //Der variablen Typ muss in der Methode neu deklariert werden public static void UebergabeMethode(int ersteZahl, int zweiteZahl) { System.out.print("Ausgabe der Variablen: " + ersteZahl + zweiteZahl); } }
Beispiele
BMI Rechner
//Import Scanner Class import java.util.Scanner; public class Program { public static void main(String[] args) { Variablen deklarieren double gewicht; double groesse; int alter; //Scanner definieren Scanner sc = new Scanner(System.in); //Werte abfragen System.out.print("Bitte geben Sie Ihr Gewicht ein :"); gewicht = sc.nextDouble(); System.out.print("Bitte geben Sie Ihre Größe ein :"); groesse = sc.nextDouble(); System.out.print("Bitte geben Sie Ihr Alter ein :"); alter = sc.nextInt(); //Berechnung des BMI double bmi = (gewicht) / (groesse * groesse); System.out.println("Ihr BMI beträgt: " + bmi); //Ausgabe des Soll BMI Werts entsprechend dem Alter if (alter >= 19 && alter <= 24) { System.out.println("Ihr BMI sollte zwischen 19 und 24 liegen"); } else if (alter >= 25 && alter <= 34) { System.out.println("Ihr BMI sollte zwischen 20 und 25 liegen"); } else if (alter >= 35 && alter <= 44) { System.out.println("Ihr BMI sollte zwischen 21 und 26 liegen"); } else if (alter >= 45 && alter <= 54) { System.out.println("Ihr BMI sollte zwischen 22 und 27 liegen"); } else if (alter >= 55 && alter <= 34) { System.out.println("Ihr BMI sollte zwischen 23 und 28 liegen"); } else { System.out.println("Ihr BMI sollte zwischen 24 und 29 liegen"); } }
Berechnung mit Modulo - IF Abfrage - FOR Schleife
Es werden die Zahlen 1 bis 100 ausgegeben. Die Zahlen die durch 3 oder/und 4 teilbar sind werden durch entsprechenden Text ersetzt
public class Program { public static void main(String[] args) { for(int i = 1; i <= 100; i++) { int var3 = 3; int var4 = 4; var3 = i % 3; //vorherige Berechnun mit Modulo var4 = i % 4; //vorherige Berechnun mit Modulo if((i % 3) == 0 && (i % 4) != 0) { //Beispiel ohne vorherige Berechnung System.out.println("Durch 3 teilbar"); } else if(var4 == 0 && var3 != 0) { System.out.println("Durch 4 teilbar"); } else if(var3 == 0 && var4 == 0) { System.out.println("Durch 3 und 4 teilbar"); } else { System.out.println("Durchlauf Nr: " + i); } } }
}
Einfacher Taschenrechner
import java.util.Scanner; public class Program { public static void main(String[] args) { int zahl1; int zahl2; int op; int result; int next = 1; do { Scanner sc = new Scanner(System.in); System.out.print("Bitte geben Sie eine Ganzahll ein: "); zahl1 = sc.nextInt(); System.out.print("Bitte geben Sie eine weiter Ganzahll ein: "); zahl2 = sc.nextInt(); System.out.print("Bitte geben Sie einen Operator ein: 1+ 2- 3* 4/ "); op = sc.nextInt(); switch(op) { case 1: { result = zahl1 + zahl2; System.out.println("Ergebnis: " + result ); break; } case 2: { result = zahl1 - zahl2; System.out.println("Ergebnis: " + result ); break; } case 3: { result = zahl1 * zahl2; System.out.println("Ergebnis: " + result ); break; } case 4: { result = zahl1 / zahl2; System.out.println("Ergebnis: " + result ); break; } } System.out.print("Möchten Sie eine weitere Berechnung durchführen? 1/Ja 2/Nein : "); next = sc.nextInt(); } while(next == 1); } }