First Commit

Lektion 1.md

@@ -0,0 +1,227 @@
+### 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);
+	
+```