Info/10/java_cheatsheet.md


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

---
lang: de
geometry: margin=2cm
pagestyle: empty
---
# Java Spickzettel

\large

+-----------------------+----------------------------------------------------------------------------+
|Blöcke                 |Blöcke werden in geschweiften Klammern notiert.                             |
|                       |```java                                                                     |
|                       |{                                                                           |
|                       |  //...                                                                     |
|                       |}                                                                           |
|                       |```                                                                         |
+-----------------------+----------------------------------------------------------------------------+
|Kommentare             | ```java                                                                    |
|                       | // einzeiliger Kommentar                                                   |
|                       | /* mehrzeiliger                                                            |
|                       |  Kommentar */                                                              |
|                       | ```                                                                        |
+-----------------------+----------------------------------------------------------------------------+
|primitive              | * `boolean`{.java} Wahrheitswert                                           |
|Datentypen             | * `int`{.java} Ganzzahl                                                    |
|                       | * `float`{.java} Kommazahl (notiert als `1.0f`{.java})                     |
|                       | * `double`{.java} Kommazahl                                                |
|                       | * `char`{.java} Zeichen z.B. `'C'`{.java}                                  |
|                       | * Weitere: `byte, short, long`{.java}                                      |
+-----------------------+----------------------------------------------------------------------------+
|Zeichenketten          | `String`{.java}: z. B. "Hallo"                                             |
+-----------------------+----------------------------------------------------------------------------+
|Deklaration            | ```java                                                                    |
|und Zuweisung          | int x;  // Deklaration einer Variable x                                    |
|bei primitiven         | x = 6;  // Initialisierung von x mit dem Wert 6                            |
|Datentypen             | ```                                                                        |
+-----------------------+----------------------------------------------------------------------------+
| Klasse mit            | ```java                                                                    |
| Deklaration           | class Haus {                                                               |
| von Attributen        |   String strasse;                                                          |
| und Konstruktor       |   int hausnummer;                                                          |
|                       |   public Haus(String strasseNeu, int hNrNeu) {                             |
|                       |     strasse = strasseNeu;                                                  |
|                       |     hausnummer = hNrNeu;                                                   |
|                       |   }                                                                        |
|                       | }                                                                          |
|                       | ```                                                                        |
+-----------------------+----------------------------------------------------------------------------+
| Zugriffsmodifikatoren | ```java                                                                    |
| für Attribute         | class Kind {                                                               |
| und Methoden          |   private String name; // Zugriff nur aus der Klasse                       |
|                       |   // uneingeschränkter Zugriff                                             |
|                       |   public String gibName() { return name; }                                 |
|                       | }                                                                          |
|                       | ```                                                                        |
+-----------------------+----------------------------------------------------------------------------+
|Vererbung              | `class Reihenhaus extends Haus`{.java}\newline                             |
|                       | Der Aufruf des Oberklassenkonstruktors erfolgt mit `super(...)`{.java},\   |
|                       | anderer Methoden der Oberklasse mit `super.methodenname(...)`{.java}       |
+-----------------------+----------------------------------------------------------------------------+
|Deklaration eines      | ```java                                                                    |
|Referenzattributs      | Haus h1;                                                                   |
|mit                    | h1 = new Haus("Schulstr.", 8);                                             |
|Objekterzeugung        | ```                                                                        |
+-----------------------+----------------------------------------------------------------------------+
| Deklaration           | ```java                                                                    |
| und                   | String[] wochentage;                                                       |
| Initialisierung       | wochentage = new String[7];                                                |
| eines Feldes          | ```                                                                        |
| bzw. Arrays           |                                                                            |
+-----------------------+----------------------------------------------------------------------------+
| Zugriff auf           | ```java                                                                    |
| einzelnes Element     | String[] wochentage = new String[7];                                       |
| eines Arrays          | wochentage[0] = "Sonntag";                                                 |
|                       | ```                                                                        |
+-----------------------+----------------------------------------------------------------------------+
| Leere Referenz        | `null`{.java}                                                              |
+-----------------------+----------------------------------------------------------------------------+
| Methode ohne          | ```java                                                                    |
| Rückgabewert          | void rückwärtsGehen(int schritte) {                                        |
|                       |   gehen(-schritte);                                                        |
|                       | }                                                                          |
|                       | ```                                                                        |
+-----------------------+----------------------------------------------------------------------------+
| Methode mit           | ```java                                                                    |
| Rückgabewert          | int quadrieren(int zahl) {                                                 |
|                       |   return zahl*zahl;                                                        |
|                       | }                                                                          |
|                       | ```                                                                        |
+-----------------------+----------------------------------------------------------------------------+
|Vergleichs-            | * `==`{.java} ist gleich                                                   |
|operatoren             | * `!=`{.java} ungleich                                                     |
|                       | * `> größer`{.java}                                                        |
|                       | * `>=`{.java} größer gleich                                                |
|                       | * `< kleiner`{.java}                                                       |
|                       | * `<=`{.java} kleiner gleich                                               |
+-----------------------+----------------------------------------------------------------------------+
| Logische              | * `!`{.java} nicht                                                         |
| Operatoren            | * `&&`{.java} und                                                          |
|                       | * `||`{.java} oder                                                         |
+-----------------------+----------------------------------------------------------------------------+
| Bedingte              | ```java                                                                    |
| Anweisung (bei        | if(farbe == "rot") {                                                       |
| einseitiger           |   anzahlRot = anzahlRot + 1;                                               |
| bedingter             | } else {                                                                   |
| Anweisung             |    //...                                                                   |
| entfällt der          | }                                                                          |
| else-Teil)            | ```                                                                        |
+-----------------------+----------------------------------------------------------------------------+
|Zählwiederholung       | ```java                                                                    |
|                       | for(int i = 0; i < anzahlRechtecke; i=i+1) {                               |
|                       |   //zu wiederholende Sequenz                                               |
|                       | }                                                                          |
|                       | ```                                                                        |
+-----------------------+----------------------------------------------------------------------------+
|Wiederholung mit       | ```java                                                                    |
|Anfangsbedingung       | while(!berührt()) {                                                        |
|                       |   gehen(10);                                                               |
|                       | }                                                                          |
|                       | ```                                                                        |
+-----------------------+----------------------------------------------------------------------------+
|Konsolenausgabe        | `System.out.println(...)`{.java}                                           |
+-----------------------+----------------------------------------------------------------------------+