PR1Crashkurs/Lektion 1.md

### Programmieren Crash Kurs 
---
### Die Fragen
1. Warum jetzt ausgerechnet Java?
2. Warum fangen wir so simpel an?

---

### Struktur eines Programmes

Ein Java Programm beginnt in der main Methode

```java
class MeineKlasse{
	public static void main(String[] args){
		// Hier beginnt der Code
	}
}
```

---
### Ablauf eines Programms

Fürs erste fokusieren wir uns auf **procedurale** Programmierung. D.h. jede Arbeitasanweisung wird Schritt für Schritt abgearbeitet.

```
class MeineKlasse{
	public static void main(String[] args){
		int ersteZahl = 0; // 1. Befehl
		int zweiteZahl = 1; // 2. Befehl
		int ergebnis = ersteZahl + zweiteZahl; // 3. Befehl
		System.out.println(ergebnis); // 4. Befehl;
	}
}
```
i.d.R Endet jede Anweisung mit einem Semicolon (;)

---
### Variablen

Variablen von einfachen Datentypen speichern Aussagen(Expressions). Variablen können nur Aussagen Ihres Datentypens speichern

```
boolean my_bool = true;
int my_integer = 14;
double my_double = 2.4;
char my_char = 'H';
```

---
### Aufgabe 0

Finde die Fehler

```java
class MeineKlasse{
	int a = 0;
	public static void main(String[] args){
		int b = 15;
		int c = 4.0
		System.out.println(ergebnis);
		int ergebnis = a + b + c;
	}
}

```
---
### Deklarierung und Initialisierung
```
int c;
c = 10;
int d = 10;
```
```
int result;
// viel Code dazwischen
result = kalkulation();
```
---
### Aufgabe 1

1. Deklariere die Variable 'c' mit dem Datentyp Integer
2. Initialisiere die Variable 'c' mit dem Wert 0
3. Weise der Variablen 'c' dem Wert 16 zu

---
### Aufgabe 2
1. Erstelle 3 Variablen x,y und z und initialisiere Sie auf beliebige Werte
2. Erstelle 3 Variablen d,m,y und initialisiere Sie auf deinen Geburtstag

-> Was fällt dabei auf?
---
### Einfache Datentypen

Welche einfache Datentypen kennst du?

Erstelle zu jedem eine Variable und einen entsprechenden Wert!

Wie unterscheiden sich diese Datentypen?

---
### Unter der Haube (MALLOC)

Java reserviert Speicher für jede deklarierte Variable. Die Menge an Speicher ist abhängig von dem jeweiligen Datentypen.
```
int i; // Reserviert 4 byte
long l; // Reserviert 8 byte
short s; // Reserviert 2 byte
char c; // Reserviert 2 byte
```
---
### Operatoren

Auf Datentypen können verschiedene Operationen durchgeführt werden. Den wichtigsten Operator kennst du bereits, den Zuweisungsoperator:
```
int i = 10;
```
Der Zuweisungsoperator nimmt eine **Aussage** (rechts) und weist sie einer Variablen (links) zu. Aussagen und Zuweisungen werden in der **funktionalen** Programmierung sehr wichtig.

---
### Operatoren

Auf numerischen Datentypen können eine Vielzahl an mathematischen Operationen durchgeführt werden
```
int i = 10;
int j = 15;
int k = i + j; // Addition
int l = i - j; // Subtraktion
int m = i * j; // Multiplikation
int n = i / j; // Division
int o = i % j; // Modulo
int p = i++;   // Inkrementieren
int q = i--;   // Dekrementieren
```
---
### Operatoren

Auf numerischen Datentypen können eine Vielzahl an logischen Operationen durchgeführt werden.
```
int a = 5;
int b = 10;
boolean c = a > b; // größer 
boolean d = a < b; // kleiner 
boolean e = a >= b; // größer gleich
boolean f = a <= b; // kleiner gleich
boolean g = a == b; // gleich
boolean h = a != b; // ungleich


```

---
### Aufgabe 3

Erstelle einen Algorithmus, welcher überprüft, ob eine Zahl gerade oder ungerade ist. Wenn die Zahl gerade ist, speichere das Ergebnis in einer variablen 'boolean ist_gerade' ab.

---
### Operatoren 

Auf boolean Werte können logische Operatoren angewendet werden:
```
boolean a = true;
boolean b = false;
boolean c = a || b; // logisches Oder
boolean d = a && b; // logisches Und
boolean e = a == b; // gleichheit
boolean f = a != b; // ungleichheit
boolean g = a | b; // bitweise oder
boolean h = a & b; // bitweise und
```

---
### Kontrollstrukturen

Kontrollstrukturen geben dem Programm die Möglichkeit anhand von Daten (State) unterschiedliche Entscheidungen zu treffen
``` java
Scanner scanner  = new Scanner(System.in);
int alter = scanner.nextInt();
if(alter >= 10){
	// Programm normal fortsetzen
} else {
	// Normalen programmfluss unterbrachen
}
```
---
### Kontrollstrukturen

Es gibt 2 fundamentale Kontrollstrukturen: Abzweigungnen und Schleifen
```java
// Beispiel einer Schleife
boolean gesunder_maschinenzustand = true; 
do{
	// Programmfluss
	gesunder_maschinenzustand = pruefeZustand();
} while(gesunder_maschinenzustand);
```

---

### Aufgabe 4

1. Erstelle ein Programm, welches die Zahlen 1 - 10 ausgibt.
2. Erstelle ein Programm welches die Zahlen 1 - 100 ausgibt.
3. Erstelle ein Programm welches alle geraden Zahlen von 1 bis 100 ausgibt.
4. Erstelle ein Programm, welches alle Zahlen von 1 - 1000 ausgibt, die ein vielfaches von 13 sind.
5. Erstelle ein Programm, welches alle Primzahlen von 1 - 100 ausgibt.
---

### Schleifen
In Java gibt es 3 Schleifen: for, while, do-while:

```java
	for(int i = 0; i < 10; i++){
		System.out.println(i);
	}
	int j = 0;
	while(j < 10){
		System.out.println(j);
		j++;
	}
	int k = 0;
	do{
		System.out.println(k);
		k++;
	}while(k < 10);
	
```