OOP

Programmierung2/src/oop/Abstraction/Abstraction.java

@@ -0,0 +1,45 @@
+package oop.Abstraction;
+
+ public abstract class Abstraction {
+	
+	/*Was ist abstraction:Das Verbergen der internen Implementierung der (Methode, Funktion) 
+	 * und das Zeigen nur der Funktionalität für die Benutzer.
+	 * 
+	 * 
+	 * wie errecihen wir die Abstraktion?
+	 * 
+	 *  1. Abstract Class => not fully Abstraction 
+	 *  2. Interface => fully Abstraction 
+	 *  
+	 * -----------------------------------------
+	 * 
+	 * Die abstrakte Klasse:
+	 * 
+	 * Deklaration als abstract: Eine abstrakte Klasse muss mit dem Schlüsselwort abstract deklariert werden
+	 * abstrakte Klassen in Java müssen vererbt werden, damit ihre abstrakten Methoden implementiert werden können
+	 * Da abstrakte Klassen nicht instanziiert werden können (man kann also keine Objekte direkt von ihnen erstellen)
+	 * Die Abstrakte klasse kann eine Abstrakte methode haben aber soll nicht 
+	 * Die Abstrakte klasse können final methods haben
+	 * Die Abstrakte klasse können constructors und static methods haben
+	 * Setter und getter sind gültig	
+	 * 
+	 * - Die Unterklasse:
+	 * 		die nicht abstrakte Unterklassen muss alle abstrakte methoden implementieren!
+	 * 		die abstrakte Unterklassen muss nicht  alle abstrakte methoden implementieren! 
+	 *----------------------------------------
+	 *
+	 *Die abstrakte Methode:
+	 *warum Abstrakte Methods? damit jede Unterklasse diese Methoden implementiert
+	 *wenn wir eine abstrakte Methode erzeugen, soll ihre Klasse auch Abstrakt sein.
+	 *Abstrakte Methoden können von der abstrakten Klasse nicht implemntiert werden.
+	 *Abstrakte Methoden können nur von Unterklassen mit @Override implementiert werden.
+	 *Abstrakte Methoden können ohne und mit Rückabe wert sein.
+	 *Statiche und private Methodes können nicht abstrakt sein warum?
+	 *weil satatic und private gehören nur der Klasse
+	 */
+	
+	  protected abstract void fahre();
+	  public abstract int count();
+
+
+}

Programmierung2/src/oop/Abstraction/Auto.java

@@ -0,0 +1,25 @@
+package oop.Abstraction;
+
+public abstract class Auto {
+	
+	double  höhe;
+	double gewicht;
+	int anzahlDerRäder;
+	
+	
+	
+	public Auto(double höhe, double gewicht, int anzahlDerRäder) {
+		this.höhe = höhe;
+		this.gewicht = gewicht;
+		this.anzahlDerRäder = anzahlDerRäder;
+	}
+
+	abstract void autopilot(); //  automatischen Fahren 
+	
+	abstract void streamingService();
+	
+	abstract void parkingSensors();
+	
+
+
+}

Programmierung2/src/oop/Abstraction/Auto2.java

@@ -0,0 +1,19 @@
+package oop.Abstraction;
+
+
+public class Auto2 {
+	
+	  class Test{
+		
+		
+	}
+	  @FunctionalInterface
+	  public  interface Test2{
+		   int berechne(int a, int b);
+		  
+	  }
+	
+	
+	
+	
+}

Programmierung2/src/oop/Abstraction/Hatchback.java

@@ -0,0 +1,29 @@
+package oop.Abstraction;
+
+public class Hatchback extends Auto {
+
+	
+	public Hatchback(double höhe, double gewicht, int anzahlDerRäder) {
+		super(höhe, gewicht, anzahlDerRäder);
+	}
+
+	@Override
+	void autopilot() {
+		System.out.println(" Hatchback : autopilot");
+	}
+
+	@Override
+	void streamingService() {
+		System.out.println("Hatchback :  streamingService");
+		
+	}
+
+	@Override
+	void parkingSensors() {
+		System.out.println(" Hatchback :  parkingSensors");
+		
+	}
+	
+
+
+}

Programmierung2/src/oop/Abstraction/MarkerInterface.java

@@ -0,0 +1,6 @@
+package oop.Abstraction;
+
+public class MarkerInterface {
+    // Keine Methoden oder Konstanten
+
+}

Programmierung2/src/oop/Abstraction/NestedInterface.java

@@ -0,0 +1,14 @@
+package oop.Abstraction;
+
+public interface NestedInterface {
+	void test();
+	
+	interface InnerInterface  {
+		default void test2() {
+			
+			System.out.print("Innerinterface");
+		}
+		
+	}
+
+}

Programmierung2/src/oop/Abstraction/SUV.java

@@ -0,0 +1,29 @@
+package oop.Abstraction;
+
+public class SUV extends Auto {
+	
+	
+	
+	public SUV(double höhe, double gewicht, int anzahlDerRäder) {
+		super(höhe, gewicht, anzahlDerRäder);
+	}
+
+	@Override
+	void autopilot() {
+		System.out.println(" SUV :  autopilot");
+	}
+
+	@Override
+	void streamingService() {
+		System.out.println(" SUV : streamingService");
+		
+	}
+
+	@Override
+	void parkingSensors() {
+		System.out.println("SUV :  parkingSensors");
+		
+	}
+	
+
+}

Programmierung2/src/oop/Abstraction/Test.java

@@ -0,0 +1,12 @@
+package oop.Abstraction;
+
+public class Test {
+
+	public static void main(String[] args) {
+		
+		// Auto SUV1 = new Auto(); Verboten da die Auto Klasse Abstrakt ist!
+		// Auto SUV1 = new SUV(); das ist gültig
+		
+	}
+
+}

Programmierung2/src/oop/AnonymousInnerClass/AnonymousInnerClass.java

@@ -0,0 +1,27 @@
+package oop.AnonymousInnerClass;
+
+public class AnonymousInnerClass {
+	/*
+	 * - ist ohne Name definiert und werden direkt in der Instanziierung (manin Methode) erstellt.
+	 * - Verwendung: Sie werden verwendet,um Schnittstellen oder abstrakte Klassen zu implementieren 
+	 *   und deren Methoden zu überschreiben, ohne eine separate, benannte Klasse zu erstellen.
+	 * - kann entweder extends klasse oder implements interface aber (nicht beids gleichzeitig)
+	 * - ist für methoden und Konstruktoren
+	 * - Anonymous Inner Class können kein Konstruktoren haben, weil sie ohne Name sind!
+	 * - Anonymous kann mehreren Methoden überschreiben
+	 * - können über definiert werden, wo Klasseninstanzen benötigt werden
+	 * - die Methoden und die Variablen innerhalb der Anonymous sind nur innerhalb Anonymous sichtbar
+	 * 	 oder ich muss z.b anstatt (Konstruktor test  = new Konstruktor()) => var test  = new Konstruktor()
+	 *   das  ermöglicht mir die methoden und die Variable die in Anonymous in außen zu verweden
+	 * - anonyme innere Klassen können verschachtelt werden also in anonyme ein anonyme
+	 * - können keine statischen Variablen oder Methoden haben, das sie keinen Name haben
+	 * - Private Elemente sind erlaubt aber sind nur innerhalb der anonyme innere Klassen sichtbar
+	 *   
+	 *  Warum benötigen wir sowas?
+	 *  für Einmalige Verwendung: Sie sind ideal für einmalige Implementierungen, 
+	 *  wie z.B. Event-Handler, Callbacks oder Threads.
+	 *  
+	 *  
+	 */
+
+}

Programmierung2/src/oop/AnonymousInnerClass/Interface.java

@@ -0,0 +1,40 @@
+package oop.AnonymousInnerClass;
+
+public class Interface {
+	
+	public interface Showable{
+		
+		void print();
+	}
+	
+	// methode übernimmt ein Interface
+	static void display(Showable s) {
+		
+		s.print();
+	}
+	
+	public static void main (String[] args) {
+		// Anonymous Inner Class mit methode
+		display(new Showable() {
+			
+			@Override
+			public void print() {
+				System.out.print("von der Methode");
+			}
+		});
+				
+				
+		
+		// Anonymous Inner Class mit interface
+		Showable showable = new Showable() {
+			
+			@Override
+			public void print() {
+				
+				System.out.println("Hallo welt");
+			}
+		};
+		
+		showable.print();
+	}
+}

Programmierung2/src/oop/AnonymousInnerClass/Konstruktor.java

@@ -0,0 +1,83 @@
+package oop.AnonymousInnerClass;
+
+public class Konstruktor {
+	
+	public Konstruktor() {
+		System.out.println("das ist Konstruktor");
+	}
+	
+	// Methode enthält Anonymous Inner Class
+	public static void main() {
+		new Konstruktor() {
+			
+			public static void print() {
+				System.out.println("main methode");
+			}
+			
+			int x = 5;
+			@Override
+			public void testMethod() {
+				
+				System.out.println("main methode");
+			
+			}
+			
+			
+		};
+	}
+	
+	public void testMethod() {
+		
+		System.out.println("Das ist in der klasse");
+	}
+	
+	
+	 int x = 2;
+	
+	public static void main(String[] str) {
+		
+		// Konstruktor wird aufgerufen und aussgegeben
+		Konstruktor test  = new Konstruktor() {
+			
+			public void print() {
+				System.out.println("extra methode");
+				//x = 3; Änderung ist verboten
+			}
+			
+			int x = 5;
+			@Override
+			public void testMethod() {
+				
+				System.out.println("Das ist in der main" + x);
+				print();// innere Methode
+			}
+			
+			
+		};
+		
+		test.testMethod();
+		
+		// Konstruktor wird aufgerufen und aussgegeben
+				var test2  = new Konstruktor() {
+					
+					public static void print() {
+						System.out.println("extra methode");
+					}
+					
+					int x = 5;
+					@Override
+					public void testMethod() {
+						
+						System.out.println("Das ist in der main" + x);
+					
+					}
+					
+					
+				};
+				// aufruf der innere methode
+				//test2.print();
+				test2.main();
+		
+	}
+
+}

Programmierung2/src/oop/AnonymousInnerClass/RewardClass.java

@@ -0,0 +1,10 @@
+package oop.AnonymousInnerClass;
+
+public class RewardClass {
+	public void rewardMethode() {
+		
+		System.out.println("Deine Belohnung ist 10€.");
+	}
+	
+
+}

Programmierung2/src/oop/AnonymousInnerClass/Test.java

@@ -0,0 +1,35 @@
+package oop.AnonymousInnerClass;
+
+public class Test {
+	
+	public static void main(String[] args) {
+		
+		RewardClass mietarebiter1 = new RewardClass();
+		RewardClass mietarebiter2 = new RewardClass();
+		RewardClass mietarebiter3 = new RewardClass()
+		//  Anonymous Inner Class 
+		{	
+			
+			@Override
+			public void rewardMethode() {
+				
+				System.out.println("Deine Belohnung ist 20€.");
+			}
+		};
+		
+		mietarebiter1.rewardMethode();//Belohnung ist 10€
+		mietarebiter2.rewardMethode();//Belohnung ist 10€
+		
+		mietarebiter3.rewardMethode();//Belohnung ist 20€
+		
+		/* wenn ich für den dritten mietarebiter3 20€ statt 10€ geben möchte!
+		 * dann habe ich 2 möglichkeiten
+		 * 
+		 * 1. erben: ich kann eine Klasse erstellen die meine (RewardClass) erbt 
+		 *           und ihre Methode mit 20€ überschreibt!
+		 *           
+		 * 2.Anonymous Inner Class 
+		 */
+	}
+
+}

Programmierung2/src/oop/Aufgaben/BankKonto.java

@@ -0,0 +1,65 @@
+package oop.Aufgaben;
+
+public class BankKonto {
+	
+	private String name;
+	private double amount;
+	private int kontoNummer;
+	private static int counter = 1;
+	
+	public BankKonto() {
+		
+		
+	}
+	
+	
+	
+	public BankKonto( String name,double amount) {
+		this.kontoNummer = counter;
+		this.name = name;
+		this.amount = amount;
+		counter++;
+		bounus();
+		willkommen(this.name);
+		}
+	
+	
+	public static void willkommen(String n) {
+	
+		BankKonto b1 = new BankKonto();
+		b1.name = n;
+		System.out.println("Willkommen: " + b1.name);
+	}
+	
+	
+	public double bounus() {
+		
+		
+		return this.amount += 5;
+	}
+	
+	public void einzahlung(double wert) {
+		
+		this.amount += wert;
+		
+	}
+	
+	public void auszahlung(double wert) {
+		
+		if (wert <= this.amount)
+			this.amount -= wert;
+		else
+			System.out.println("Das Geld reicht nicht aus!");
+	}
+	
+	public void checkKonto() {
+		
+		System.out.println("Ihre Stand ist: " + this.amount);
+	}
+	
+	public String toString() {
+		
+		return "Kontoname = " + this.name + " nummer = " + kontoNummer + " Satand = " + this.amount; 
+	}
+
+}

Programmierung2/src/oop/Aufgaben/Kreis.java

@@ -0,0 +1,59 @@
+package oop.Aufgaben;
+
+public class Kreis {
+	
+	 private double radius;
+	 private String color;
+	
+	
+	 // Konstruktor mit zwei Parametern
+	    public Kreis(double radius, String color) {
+	        this.radius = radius;
+	        this.color = color;
+	    }
+
+	    // Konstruktor mit einem Parameter (radius), Standardfarbe wird zugewiesen
+	    public Kreis(double radius) {
+	    	this.radius = radius; // Standardfarbe ist "weiß"
+	    }
+	 
+	 
+	public void setRadius(double radius) {
+		
+		this.radius =radius ;//this (unterscheidet zwishcne Parameter und Attribute)
+	}
+	
+	public double getRadius() {
+		
+		return radius;
+	}
+	
+	public void setColor(String color) {
+		
+		this.color = color; // this (unterscheidet zwishcne Parameter und Attribute)
+	}
+	
+	public String getColor() {
+		
+		return color;
+	}
+	
+	
+	public double getFlaeche() {
+		
+		return radius * radius * Math.PI;
+	}
+	
+	public double getUmfang() {
+		
+		return 2 * radius * Math.PI;
+		
+	}
+	
+	public String toString() {
+		
+		return "Kreis:" + getFlaeche()  + " " + getUmfang() ;
+	}
+	
+
+}

Programmierung2/src/oop/Aufgaben/Mitarbeiter.java

@@ -0,0 +1,38 @@
+package oop.Aufgaben;
+
+public class Mitarbeiter {
+	
+	
+	private static int id = 0;
+	protected int idMitarbeiter; 
+	protected String name;
+	
+	
+	public Mitarbeiter() {
+	
+	}
+	
+	public Mitarbeiter(String name) {
+		this.idMitarbeiter = ++id;
+		this.name = name;
+		
+	}
+	
+	public void setName(String name) {
+		
+		 this.name = name;
+	}
+	
+	public String getName() {
+		
+		return this.name;
+	}
+	
+	
+	public String toString() {
+		
+		return "ID: " + id + " Name: " + this.name;
+	}
+	
+
+}

Programmierung2/src/oop/Aufgaben/Personalverwaltung.java

@@ -0,0 +1,32 @@
+package oop.Aufgaben;
+
+import java.util.ArrayList;
+
+public class Personalverwaltung {
+	
+	ArrayList<Mitarbeiter> mitarbeiterliste = new ArrayList<Mitarbeiter>();
+
+	
+	
+	public void add(Mitarbeiter mitarbeiter) {
+		
+		mitarbeiterliste.add(mitarbeiter);
+	}
+	
+	
+	public void remove(Mitarbeiter mitarbeiter) {
+		
+		mitarbeiterliste.remove(mitarbeiter);
+	}
+	
+	
+	
+
+	public void listMitarbeiter(){
+		
+		 for (Mitarbeiter mitarbeiter : mitarbeiterliste) {
+	            System.out.println(mitarbeiter);
+	        }
+	}
+
+}

Programmierung2/src/oop/Einführung/Einführung.java

@@ -0,0 +1,31 @@
+package oop.Einführung;
+
+public class Einführung {
+	
+	String name;
+	int maxSpeed;
+	double price;
+	int model;
+	
+	
+	void setName(String n) {
+		 name = n;
+	}
+	
+	String getName() {
+		
+		return name;
+	}
+	
+	void setModel(int mod) {
+		if (mod >= 2016)
+			model = mod;
+		else
+			System.out.println("Nei geht nicht!");
+	}
+	
+	int getModel() {
+		
+		return model;
+	}
+}

Programmierung2/src/oop/Enumeration/EnumMethods.java

@@ -0,0 +1,65 @@
+package oop.Enumeration;
+import java.util.EnumSet;
+
+public enum EnumMethods {
+	MONTAG, DIENSTAG, MITTWOCH, DONNERSTAG, FREITAG, SAMSTAG, SONNTAG;
+	
+	
+	
+	public static void main(String[] args) {
+		// gibt mir die Index meiner Konstante zurück
+		System.out.println(EnumMethods.DIENSTAG.ordinal());
+		
+		//vergleicht zwei enum-Konstanten basierend auf ihrer Reihenfolge
+		System.out.println(EnumMethods.DIENSTAG.compareTo(EnumMethods.DONNERSTAG));
+		
+		// gibt true oder false zurück 
+		System.out.println(EnumMethods.DIENSTAG.toString() == "DIENSTAG");
+		
+		// gibt true oder false zurück 
+		System.out.println(EnumMethods.DIENSTAG.name() == "DIENSTAG");
+		
+		// gibt der Name der Kosntant zurück
+		System.out.println(EnumMethods.valueOf("DONNERSTAG"));
+		
+		// gibt mir alle Konstante zurück
+		for (EnumMethods test: EnumMethods.values()) {
+			System.out.print(test + " ");
+			if (test == EnumMethods.DIENSTAG)
+				System.out.print(EnumMethods.values() + " ");
+		}
+		System.out.println(EnumMethods.values()[0] + "Einzelene Konstant");
+		
+		System.out.println();
+		
+		/*
+		 * Enumset::
+		 */
+		
+		// gibt alle Werte die enums aus
+		EnumSet<EnumMethods> days = EnumSet.allOf(EnumMethods.class);
+		System.out.println(days);
+		
+		// gibt nur Werte ,die ich eingebe
+		EnumSet<EnumMethods> day = EnumSet.of(EnumMethods.DIENSTAG, EnumMethods.FREITAG);
+		System.out.println(day);
+		
+		// gibt nur einmal Diesntag aus!
+		EnumSet<EnumMethods> day1 = EnumSet.of(EnumMethods.DIENSTAG, EnumMethods.DIENSTAG);
+		System.out.println(day);
+		
+		// gibt mir von Konstante to Kosntnate zurück!
+		EnumSet<EnumMethods> range = EnumSet.range(EnumMethods.DIENSTAG, EnumMethods.FREITAG);
+		System.out.println(range);
+		
+		
+		EnumSet<EnumMethods> noneOf = EnumSet.noneOf(EnumMethods.class);
+		noneOf.add(DIENSTAG);
+		noneOf.addAll(noneOf);
+		noneOf.remove(DIENSTAG);
+		noneOf.removeAll(noneOf);
+		System.out.println(noneOf);
+	
+	}
+
+}

Programmierung2/src/oop/Enumeration/Enumeration.java

@@ -0,0 +1,23 @@
+package oop.Enumeration;
+
+public class Enumeration  {
+	
+	/*Enum was ist?
+	 * - repräsentiert eine Gruppe von Konstanten
+	 *   ,die public, static und final sind und die immer großegeschrieben werden sollen
+	 * - Deklariert mit dem Schlüsselwort enum z.b(public enum klassenname)
+	 * - Jede Konstante wird durch Kommas getrennt und am Ende optional mit einem Semikolon abgeschlossen.
+	 * - kann als Datentyp verwendet werden
+	 * - Kann in switch-Anweisungen verwendet werden.
+	 * - kann Felder, Konstruktoren (ohne public) und Methoden enthalten.
+	 * - Konstruktoren sind immer privat oder paketprivat (d.h. sie können nicht public sein)
+	 *   ,die Dienen zur Initialisierung der Felder.
+	 * - Enums können abstrakte Methoden enthalten, aber es sollen alle Kosntanten sie implementieren (siehe Wochentage class).
+	 * - Enums können Interfaces implementieren.
+	 * - Enums können eigene Methoden und Überschreibungen von toString(), equals(), hashCode(), etc. enthalten.
+	 * - Enums können keine anderen Klassen erweitern und auch nicht von anderen Klassen erben
+	 * - Enums können interface implementieren
+	 * 
+	 */
+
+}

Programmierung2/src/oop/Enumeration/Numbers.java

@@ -0,0 +1,28 @@
+package oop.Enumeration;
+
+public  enum Numbers{
+	
+	ONE,TWO,THREE; // Semikolon ist optional
+	
+	/*
+	 * ONE TOW THREE sind Objekte in die unten stehenden Klassen
+	 * Konstante ONE wir präsentiert durch:
+	 * Class Numbers{
+	 * 		public static final Numbers ONE = new Numbers();
+	 * }
+	 * 
+	 * und TWO auch so..
+	 * Class Numbers{
+	 * 		public static final Numbers TWO = new Numbers();
+	 * }
+	 * und THREE auch so..
+	 * 
+	 */
+	
+	
+	public void print() {
+		
+		System.out.println("dasd");
+	}
+
+}

Programmierung2/src/oop/Enumeration/Order.java

@@ -0,0 +1,37 @@
+package oop.Enumeration;
+
+public class Order {
+	
+	public enum OrderStatus{
+		
+		PENDING,
+		PREPARING,
+		COMPLETED,
+		DELIVERING,
+		CANCELED;
+	}
+	
+	
+	
+	// Attribute mit enum Objekt
+	private OrderStatus status;
+	
+	public boolean check() {
+		
+		if (getStatus() == status.COMPLETED)
+			return true;
+		
+		return false;
+	}
+
+	public OrderStatus getStatus() {
+		return status;
+	}
+
+	public void setStatus(OrderStatus status) {
+		this.status = status;
+	}
+	
+	
+
+}

Programmierung2/src/oop/Enumeration/OrderTest.java

@@ -0,0 +1,17 @@
+package oop.Enumeration;
+
+public class OrderTest {
+
+	public static void main(String[] args) {
+		//ordinal globale methode gibt mir die Index meiner enum Konstanten
+		System.out.println(Order.OrderStatus.CANCELED.ordinal());
+		
+		Order order1 = new Order();
+		order1.setStatus(Order.OrderStatus.DELIVERING);
+		System.out.println(order1.check());
+		// z.b für Tracking der bestellung 
+		System.out.print(order1.getStatus());
+		
+	}
+
+}

Programmierung2/src/oop/Enumeration/Test.java

@@ -0,0 +1,35 @@
+package oop.Enumeration;
+
+public class Test {
+
+	public static void main(String[] args) {
+		// Numbers val1 = new Numbers(); verboten da enum Konstruktoren private ist	
+										// und ONE automatisch static ist 
+		   Numbers val1 = Numbers.ONE; // TWO ist ein Objekt
+		   
+		   switch (val1) {
+		   
+		   case ONE: System.out.println("1");
+		   break;
+		   
+		   case TWO: System.out.println("2");
+		   break;
+		   
+		   case THREE: System.out.println("3");
+		   break;
+		   }
+		   
+		  val1.print();
+		  
+		  System.out.println(Wochentage.MONTAG.getStatus());
+		  Wochentage.MONTAG.testmethode();
+		  System.out.println(Wochentage.DIENSTAG.getStatus());
+		  Wochentage.DIENSTAG.testmethode();
+		  
+		  
+		 
+			
+			
+	}
+
+}

Programmierung2/src/oop/Enumeration/Wochentage.java

@@ -0,0 +1,41 @@
+package oop.Enumeration;
+
+public enum Wochentage {// erbt von abstract class (enum)
+	// wenn eine Konstante einen Konstruktor hat, dann sollen Alle Konstaten sollen einen Konstruktor haben 
+	 /*
+	  * 	MONTAG("Arbeitstag"), 
+	  *  	DIENSTAG("Arbeitstag");
+	  */
+	
+	// Alle Konstanten sollen die abstrakte Methoden implementieren
+	MONTAG ("Konstruktor: Montag") {
+		@Override
+		public void testmethode() {
+			System.out.println("Montag");
+		}
+		
+	},
+	DIENSTAG ("Konstruktor: Diesnstag"){
+		@Override
+		public void testmethode() {
+			System.out.println("Diesnstag");
+		}
+	};
+	String status;
+	
+	Wochentage(String status){
+		this.status = status;
+	}
+
+	public String getStatus() {
+		return status;
+	}
+
+	public void setStatus(String status) {
+		this.status = status;
+	}
+	
+	public abstract void testmethode();
+	
+	
+}

Programmierung2/src/oop/ExceptionHandling/CheckedException.java

@@ -0,0 +1,78 @@
+package oop.ExceptionHandling;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class CheckedException {
+
+	public static void main(String[] args) {
+		readFile("D:\\Test.txt");
+
+	}
+	
+	static void readFile(String filePath) {
+		FileReader reader = null;
+		// hier der Compiler zeigt mir eine Error und zwingt micht eine try-catch Block zu erstellen
+		try {
+			reader = new FileReader(filePath);// resource
+			System.out.println("File Inhalt: ");
+			
+			int r = 0;
+			while((r = reader.read()) != -1) {
+				System.out.print((char) r);
+			}
+		}catch(FileNotFoundException e) {
+			
+			System.out.println(e);
+			
+		}catch(IOException e) {
+			System.out.println(e);
+		}finally {
+			try {
+				reader.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+	
+	// try() mit resources, hier benötigt man finally block nicht
+	static void readFile2(String filePath) {
+		try (FileReader reader = new FileReader(filePath);) {
+			System.out.println("File Inhalt: ");
+			
+			int r = 0;
+			while((r = reader.read()) != -1) {
+				System.out.print((char) r);
+			}
+		}catch(FileNotFoundException e) {
+			
+			System.out.println(e);
+			
+		}catch(IOException e) {
+			System.out.println(e);
+		}
+	}
+	
+	
+	
+	// try() mit mehrere resources, hier benötigt man auch finally block nicht
+		static void readFile3(String filePath) {
+			try (FileReader reader = new FileReader(filePath); FileReader reader2 = new FileReader(filePath)) {
+				System.out.println("File Inhalt: ");
+				
+				int r = 0;
+				while((r = reader.read()) != -1) {
+					System.out.print((char) r);
+				}
+			}catch(FileNotFoundException e) {
+				
+				System.out.println(e);
+				
+			}catch(IOException e) {
+				System.out.println(e);
+			}
+		}
+
+}

Programmierung2/src/oop/ExceptionHandling/ExceptionHandling.java

@@ -0,0 +1,102 @@
+package oop.ExceptionHandling;
+
+public class ExceptionHandling {
+	
+	/*Was ist das?
+	 * - Hauptidee ist, dass falls der Programmer oder der User einen Fehler gemacht hat, läuft das Programm trotzdem weiter!
+	 * - An exception ist ein unerwünschtes oder unerwartetes Ereignis
+	 *   ,das während der Ausführung eines Programms zur Laufzeit auftritt.
+	 * 
+	 * - wenn man nicht weiß, was der Fehler ist, kann man dan die Basis Klasse aufrufen (Exception)
+	 * 	 aber das wird langsamer als wenn ich den Fehler direkt schreibe
+	 * 
+	 * - unterstützt keine Methoden und Klasse
+	 * - kann nicht als Parameter innerhalb einer Methode verwendet werden
+	 * - kann aber innerhalb ale arten von Methoden geschrieben werden
+	 * 
+	 * was sid die checked und unchecked Exceptions?
+	 *  - checked: Compiler zwingt mich  ein try-catch Block zu erstellen und Sie erben von der Klasse Exception, aber nicht von RuntimeException.
+	 *  			wie z.b(IOException, SQLException, FileNotFoundException)
+	 *  - unchecked: Compiler zwingt mich nicht try-catch Block zu erstllen und  Sie erben nur von RuntimeException.
+	 *  			 wie z.b (ullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException)
+	 *  
+	 * welche Arten haben wir?
+	 * 1. NullPointerException: Zugriff auf null-Referenz.
+	 * 2. ArrayIndexOutOfBoundsException: Ungültiger Array-Indexzugriff.
+	 * 3. ClassCastException: Ungültige Typumwandlung
+	 * 4. ArithmeticException: Fehler in arithmetischer Operation (z.B. Division durch null).
+	 * 5. NumberFormatException: Fehlerhafte Zahlumwandlung.
+	 * 6. IOException: Eingabe-/Ausgabefehler.
+	 * 7. FileNotFoundException: Datei nicht gefunden.
+	 * 8. SQLException: Fehler in der Datenbankoperation.
+	 * 9. IllegalArgumentException: Ungültiges Argument übergeben.
+	 * etc...
+	 */
+	
+	
+	/*
+	 * Try-catch block: 
+	 * 
+	 * try{
+	 * 	- m try-Block wird der Code geschrieben, 
+	 * 	  der möglicherweise einen Fehler verursachen könnte.
+	 * 
+	 * }catch(Exception e){
+	 * - Was passieren soll, wenn ein Fehler auftritt?
+	 * - Exception:ist die Basisklasse für alle Ausnahmen, die das Programm möglicherweise behandeln sollte. 
+	 * 				wie z.b(IOException),SQLException,NullPointerException sind unterklasse von Exception
+	 * - e: ist ist ein belibeger Name eines Objektes 
+	 * 
+	 * - man kann try in ein try erzeugen
+	 * }
+	 */
+	public static void main(String[] args) {
+		
+		//Try-catch block beispiel
+		try {
+			int[] arr = new int[] {1,2,3};
+			System.out.println(arr[4]);
+		}catch(Exception e) {
+			//entweder
+			System.out.println("das ist ungültig");
+			//oder
+			System.out.println(e);
+			//oder
+			System.out.println(e + "das ist ungültig");
+		}
+		// trotz des Fehlers läuft das Programm weiter, da ich try catch habe
+		System.out.println("1");
+		
+		
+		//Try-catch block mit NullPointerException (ist eine klasse) beispiel
+		//also Objekt ist leer!
+		try {
+			int[] arr = null;
+			System.out.println(arr[4]);
+		}catch(Exception e) {
+			
+			System.out.println(e.toString());
+		}
+		// trotz des Fehlers läuft das Programm weiter, da ich try catch habe
+		System.out.println("1");
+		
+		
+		//Try-catch block mit NumberForamtEception (ist eine klasse) beispiel
+		try {
+			System.out.println("haöö");// die wird ausgegeben
+			int val = Integer.parseInt("String23");
+			System.out.println(val);
+			System.out.println("haöö");// die wird nicht ausgegeben
+		}catch(Exception e) {
+					
+			System.out.println(e.toString());
+		}
+		// trotz des Fehlers läuft das Programm weiter, da ich try catch habe
+		System.out.println("1");
+				
+	
+		
+	}
+	
+
+}

Programmierung2/src/oop/ExceptionHandling/Finally.java

@@ -0,0 +1,58 @@
+package oop.ExceptionHandling;
+
+public class Finally {
+
+	public static void main(String[] args) {
+		/*
+		 * Wenn ein Programmfehler auftaucht, springe in catch Block gib den Fehler aus und laufe nicht weiter
+		 * und am Ende gib finally Block aus!
+		 */
+		try {
+			int arr[] = new int[5];
+			arr[7] = 5;
+			
+		}catch(Exception e) {
+			
+			System.out.println(e);
+			return;
+		
+		}finally {
+			System.out.println("finally");
+		}
+		
+		
+		/*
+		 * wegen System.exit in catch wird finally Block nicht ausgegenen
+		 */
+		try {
+			int arr[] = new int[5];
+			arr[7] = 5;
+			
+		}catch(Exception e) {
+			
+			System.out.println(e);
+			System.exit(0);
+		
+		}finally {
+			System.out.println("finally");
+		}
+		//System.out.println(getNumber(3));
+		
+		
+	}
+	
+	// hier wir die 3 ausgegben, weil finally soll ausgegeben werden
+	public static int getNumber(int x) {
+		
+		try {
+			if (x == 3)
+				return 1;
+			
+		}catch (Exception e){
+			return 2;
+			
+		}finally {
+			return 3;
+		}
+	}
+}

Programmierung2/src/oop/ExceptionHandling/MultiCatchBlocks.java

@@ -0,0 +1,16 @@
+package oop.ExceptionHandling;
+
+public class MultiCatchBlocks {
+	
+	public static void main(String[] args) {
+		try {
+			int arr[] = new int[5];
+			arr[10] = 7/0;
+		}
+		catch(ArrayIndexOutOfBoundsException|java.lang.ArithmeticException  ex) {
+			System.out.println(ex);
+		}
+	}
+	
+
+}

Programmierung2/src/oop/ExceptionHandling/Throwkeyword.java

@@ -0,0 +1,44 @@
+package oop.ExceptionHandling;
+
+public class Throwkeyword {
+	
+	public static void main(String[] args) {
+		// hier try und catch sind optional
+		try {
+			number(-1);
+		}catch (Exception e){
+			System.out.println("die Zahl ist negativ");
+		}
+		
+		/*
+		 *  in diesem try verfachen hier, wird das Block finally 
+		 *  erst ausgeführt, before das Block catch mit throw
+		 */
+		try {
+			int x = 5/0;
+			
+		}catch(Exception e) {
+			throw new ArithmeticException("neu throw");
+			
+		}finally{
+			System.out.println("finally Block");
+		}
+		
+		
+		
+	}
+	
+	//throws Exception ist hier optional
+	static void number(int number) throws Exception {
+		
+		if (number <= 0) {
+			//throw new ArithmeticException();Oder
+			//throw new ArithmeticException("das geht nicht");oder
+			ArithmeticException message = new ArithmeticException("die Zahl geht nicht");
+			throw message;
+		}
+			
+		else
+			System.out.println("Die Zahl ist richtig");
+	}
+}

Programmierung2/src/oop/ExceptionHandling/ThrowsKeyword.java

@@ -0,0 +1,39 @@
+package oop.ExceptionHandling;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class ThrowsKeyword {
+	/*
+	 * - Wenn der Programmiere weiß, wie er mit den Fehlern umgehen kann.
+	 * - zwingt jeder, der solche Methoden implementiert, throws zu behandeln
+	 */
+		public static void main(String[] args) {
+			/*
+			 *  da ich in readFile Methode throws verwendet habe
+			 *  ,soll ich hier z.b try catch erzeugen
+			 */
+			try {
+				readFile("D:\\Test.txt");
+			} catch (FileNotFoundException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+	
+		}
+	
+		public static void readFile(String File) throws FileNotFoundException, IOException{
+			FileReader reader = new FileReader(File);// resource
+			System.out.println("File Inhalt: ");
+			
+			int r = 0;
+			while((r = reader.read()) != -1) {
+				System.out.print((char) r);
+		}
+		
+	}
+}

Programmierung2/src/oop/ExceptionHandling/UnCheckedException.java

@@ -0,0 +1,23 @@
+package oop.ExceptionHandling;
+
+public class UnCheckedException {
+	
+	public static void main(String[] args) {
+		/*
+		 * - Solche Errors kann man nicht mit try und Catch behandeln also sie sind  keine gute Praxis
+		 * - try und catch werden den Error nicht lösen
+		 */
+		try {
+			f();
+		}catch (Error e) {
+			System.out.println(e);//java.lang.StackOverflowError
+		}
+		
+	}
+	
+	// Die Methode ruft sich bis unendlich
+	static void f() {
+		System.out.println("f()");
+		f();
+	}
+}

Programmierung2/src/oop/FileHandling/ByteKlassen/Fileinputstream.java

@@ -0,0 +1,57 @@
+package oop.FileHandling.ByteKlassen;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+//also ich habe daten auf meinm File und ich will diese Datein lesen oder importieren
+// man kann heir mit Text bearbeiten aber es ist nicht dafür richtig alternative Möglichkeit (die abstrakte klasse reader und Writer)
+public class Fileinputstream {
+	
+	/*read() Methode:
+	 * - fis.read liest aus dem File nur ein Byte aus und gibt ein Integer zurück
+	 * - z.b a liest als (97) lösung als (char) casting
+	 * - wenn die Methode keinen Byte lesen kann, gibt -1 zurück
+	 * 
+	 *read(byte [] b) Method: 
+	 *	- die übernimmt array vom type byte
+	 */
+
+	public static  void main(String[] args) throws IOException {
+		 FileInputStream fis = null;
+		 fis = new FileInputStream("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test");
+		 	{
+			 // das ist falsch, weil ich die Aufruf der Methode ist falsch
+			 while (fis.read() != -1)
+				System.out.print((char)fis.read());			 
+		 }
+		
+		 
+		 //richtig!!
+		 int data;
+		 while((data = fis.read()) != -1)// wenn kein mehr chars gibt, ist -1
+			 System.out.print((char)data);
+		 
+		 {
+			 // read() übernimmt ein byte array
+			 byte[] b = new byte[3]; // byte array
+			 fis.read(b);// methode übernimmt byte array
+			 String s = new String(b);//mit diesem Konstruktor gebe ich alle Inhalt aus ohne Loop
+			 System.out.println(s);
+		 }
+		
+		 
+		 
+		 {
+			// read() übernimmt ein byte array mit dynamischen size für array
+			File f = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test");
+			FileInputStream f2 = new FileInputStream(f);
+			byte[] b = new byte[(int) f.length()]; //Methode gibt long zurück size soll aber int sein
+			fis.read(b);// methode übernimmt byte array
+			String s = new String(b);//mit diesem Konstruktor gebe ich alle Inhalte aus (ohne Loop)
+			System.out.println(s);
+		 }
+		 
+		 
+		
+	}
+}

Programmierung2/src/oop/FileHandling/ByteKlassen/Filoutputstream.java

@@ -0,0 +1,33 @@
+package oop.FileHandling.ByteKlassen;
+
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+//also ich habe datein in meine Programm und ich will diese Datein zu meinem File schicken also (schreiben)
+//man kann heir mit Text bearbeiten aber es ist nicht dafür richtig alternative Möglichkeit (die abstrakte klasse reader und Writer)
+
+public class Filoutputstream  {
+	
+	/*write() methode: 
+	 * - die übernimmt nur (integer) zahlen
+	 * - kann Strings mit Hilfe von byte array aufnehmen
+	 *   z.b fSchreiben.write("ABF".getBytes());
+	 * - fSchreiben.write("arabische sprache".getBytes()("UTF-8")); um andere Sprachen aufzunehmen 
+	 * - fSchreiben.flush(); stellt sicher, dass die Datein richtig geschrieben werden
+	 * 
+	 */
+	public static void main(String[] args) throws IOException {
+		// hier wenn er den File (Test2) nicht findet, erzeugt er File mit dem Name Test2 automatisch
+		FileOutputStream fSchreiben = new FileOutputStream("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test2");
+		//fSchreiben.write(10);
+		fSchreiben.write("ä".getBytes());
+		fSchreiben.flush();
+		
+		//lesen der Datei
+		FileInputStream fLesen = new FileInputStream("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test2");
+		System.out.println((char)fLesen.read());
+	}
+	
+
+}

Programmierung2/src/oop/FileHandling/ByteKlassen/LeseEinBild.java

@@ -0,0 +1,33 @@
+package oop.FileHandling.ByteKlassen;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+public class LeseEinBild {
+
+	public static void main(String[] args) throws IOException {
+		//gibt mit die gesamte size vom byte meine Bildes
+		File file = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling");
+		
+		FileInputStream fin = new FileInputStream(file);
+		byte b[] = new byte[(int) file.length()];
+		fin.read(b);
+		
+		//Optional loop
+		for (int i = 0; i < b.length; i++)
+			System.out.print(b[i]);
+	
+		
+		/*
+		 * - erstellt mir eine neues Bild mit dem Name (neues Bild)
+		 * - dieses Verfahren kann mit allen Arten von Byts verwendet werden
+		 */
+		FileOutputStream fos = new FileOutputStream("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\neues Bild.png");
+		fos.write(b);
+		fos.flush();
+		fos.close();
+		
+		
+	}
+
+}

Programmierung2/src/oop/FileHandling/ByteKlassen/Test

@@ -0,0 +1 @@
+abc

Programmierung2/src/oop/FileHandling/ByteKlassen/Test2

@@ -0,0 +1 @@
+ä

Programmierung2/src/oop/FileHandling/FileHandling.java

@@ -0,0 +1,39 @@
+package oop.FileHandling;
+
+public class FileHandling {
+	/*
+	 * - bezieht sich auf das Arbeiten mit Dateien und Verzeichnissen, einschließlich Erstellen, Lesen, 
+	 *   Schreiben, Bearbeiten und Löschen.
+	 * - die Kommunikation zwischen File und Programm  heißt (stream)
+	 * - Programm liest (Read) aus dem File (Input stream)
+	 * - Programm schreibt (Write) oder (speichert) auf dem File (output Stream)
+	 * - Es gibt ein eingine Stream für Lesen
+	 * - Es gibt ein eingine Stream für schreiben
+	 * - man kann das easy in Konstruktor als parameter und methode als parameter machen oder drin 
+	 * 
+	 * - FileInputStream und FileOutPutStream sind für File Texte nicht geeignet, 
+	 * 	 alternativ möglichkeit die abstrakte Klassen Reader und Writer 
+	 * - Hinweis: Die abstrakte Klasse Reader liest Zeichen für Zeichen und ruft die Methode read() jedes Mal auf, wenn ein neues Zeichen gelesen wird.
+	 * 		Wenn wir z.B. 10 Zeichen lesen möchten, wird die Methode read() 10 Mal aufgerufen.
+ 	 * 		
+ 	 * 		Alternative Möglichkeit: Die Klasse BufferedReader kann verwendet werden, um ganze Zeilen oder größere Blöcke von Zeichen auf einmal zu lesen,
+ 	 * 		was effizienter sein kann, da sie den Lesevorgang puffert und somit weniger oft auf die zugrunde liegende Datenquelle zugreift.
+ 	 * - printWriter ist für alle Datentyps  gut geeinigt (kann nur schreiben auf dem File)
+ 	 * - Scanner ist für alle Datentyps gut geeinigt (kann nur lesen auf dem File)
+ 	 * - flush() soll aufgerufen werden
+ 	 * - BufferReader ist besser als Scanner
+ 	 * 
+ 	 * Objekte einer Klasse können auch auf dem File gelesen und geschriben werden:
+ 	 * 
+ 	 * - Serialization: ist eine (marker) lerre interface Klasse, die implemntiert werden soll
+ 	 * 					, wenn wir das Objekt auf einem File schreiben möchten
+ 	 * 
+ 	 * 1. Serialization (Objekt schreiben): Ist ein Mechanismus zur Umwandlung eines Objekts in einen Byte-Stream,
+ 	 * 					  der dann in einer Datei gespeichert werden kann. Dies wird durch die Klasse ObjectOutputStream ermöglicht.
+ 	 * 
+ 	 * 2. Deserialization (Objekt lesen): Ist ein Mechanismus zur Umwandlung eines Byte-Streams zurück in ein Objekt.
+ 	 * 										 Dies wird durch die Klasse ObjectInputStream ermöglicht.
+ 	 */			
+	
+
+}

Programmierung2/src/oop/FileHandling/FileKlasse.java

@@ -0,0 +1,64 @@
+package oop.FileHandling;
+import java.io.File;
+import java.io.IOException;
+// Hauptfunktion verwaltet Files 
+public class FileKlasse {
+	
+	/*Was macht diese Kalsse?
+	 * - abstrakte Darstellungen von Dateipfaden und Verzeichnissen zu bieten und verschiedene Operationen darauf zu ermöglichen
+	 * - sie befindet sich im Paket java.io
+	 * - stellt keine Methode zum direkten Lesen oder Schreiben von Daten bereit.
+	 * - Stattdessen bietet sie Funktionen zur Dateiverwaltung.
+	 */
+	public static void main(String[] args) {
+		 File file = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test");
+		 
+		 if (file.exists()) {
+			 	System.out.println("Datei existiert: " + file.getName());
+	            System.out.println("Pfad: " + file.getPath());
+	            System.out.println("Absoluter Pfad: " + file.getAbsolutePath());
+	            System.out.println("Schreibbar: " + file.canWrite());//ob der ich in der File schreiben kann
+	            System.out.println("Lesbar: " + file.canRead()); //ob der ich in File lesen kann
+	            System.out.println("Größe: " + file.length() + " Bytes");
+	            System.out.println("kann ausführen = " + file.canExecute()); //kann ich diesen Fiel bearbeiten (ja/nein)
+
+		 }
+		 // test3 File existiert nicht im Pfad also wird einen neuen Pfeil erstellt
+		 File file2 = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\Test3");
+		 // try catch sollen erzuegt werden
+		 try {
+             if (file.createNewFile())  // createNewFile() gibt boolean zurück,ob der File ergolgreich erstellt wurde oder nicht
+                 System.out.println("Datei erstellt: " + file.getName()); // der File muss im Pfad nicht existieren, damit es erstellt wurde
+             else 
+                 System.out.println("Fehler beim Erstellen der Datei.");
+             
+         } catch (IOException e) {
+             e.printStackTrace();
+         }
+		 
+		 // erstelle ein Verzeichnes 
+		 File folder = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\TestFolder");
+		  if (!folder.exists()) {
+	            if (folder.mkdir())
+	                System.out.println("Verzeichnis erstellt: " + folder.getName());
+	            else 
+	                System.out.println("Fehler beim Erstellen des Verzeichnisses.");
+	        }
+		  
+		  
+		  // gibt die Inhalt eines Folders zurück
+	        File dir2 = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\TestFolder");
+
+	        // Auflisten der Inhalte des Verzeichnisses mit Hilfe eines String arrays 
+	        String[] fileList = dir2.list();
+	        if (fileList != null) {
+	            System.out.println("Inhalte des Verzeichnisses:");
+	            for (String fileName : fileList) 
+	                System.out.println(fileName);
+	            
+	        } else 
+	            System.out.println("Das Verzeichnis ist leer oder konnte nicht aufgelistet werden.");
+	        
+    }
+		 		 
+}

Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/Test.java

@@ -0,0 +1,53 @@
+package oop.FileHandling.SerializationAndDeserialization;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.ArrayList;
+
+public class Test {
+
+	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
+		
+		File file = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\SerializationAndDeserialization\\FileTest.txt");
+		
+		//(Serialization): schreibe das Objekt auf dem File als byte stream
+		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
+		writeObjekt write = new writeObjekt(111,"obai",3.4);
+		oos.writeObject(write);
+		
+		//(Deserialization): Lese das Objekt auf dem File als byte stream
+		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
+		
+		// Das zurückgegebene Objekt muss in den spezifischen Typ gecastet werden
+		writeObjekt f1 = (writeObjekt) ois.readObject();
+		System.out.println(f1);
+		
+		
+		
+		// multiple objects (lesen & schreiben)
+		
+		//schreiben:
+		writeObjekt s1 = new writeObjekt(111,"Obai",2.2);
+		writeObjekt s2 = new writeObjekt(111,"Omar",2.2);
+		ArrayList<writeObjekt> list = new ArrayList<>();
+		list.add(s1);
+		list.add(s2);
+		
+		ObjectOutputStream writeList = new ObjectOutputStream(new FileOutputStream(file));
+		writeList.writeObject(list);
+		
+		//Lesen:
+		ObjectInputStream readList = new ObjectInputStream(new FileInputStream(file));
+		ArrayList<writeObjekt> multiobjekt = (ArrayList<writeObjekt>)readList.readObject();
+		System.out.println(multiobjekt);
+
+
+
+	}
+
+}

Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/writeObjekt.java

@@ -0,0 +1,48 @@
+package oop.FileHandling.SerializationAndDeserialization;
+
+import java.io.Serializable;
+/*
+ * Serializable ist ein marker (leere) Interface kalsse, soll implementiert werden
+ */
+
+public class writeObjekt implements Serializable  {
+
+	int id;
+	String name;
+	double Note;
+
+	public writeObjekt(int id, String name, double note) {
+		this.id = id;
+		this.name = name;
+		Note = note;
+	}
+
+	public int getId() {
+		return id;
+	}
+
+	public void setId(int id) {
+		this.id = id;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public double getNote() {
+		return Note;
+	}
+
+	public void setNote(double note) {
+		Note = note;
+	}
+
+	@Override
+	public String toString() {
+		return "Student [id=" + id + ", name=" + name + ", Note=" + Note + "]";
+	}
+}

Programmierung2/src/oop/FileHandling/character/Bufferedreader.java

@@ -0,0 +1,28 @@
+package oop.FileHandling.character;
+import java.io.FileReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.BufferedReader;
+
+/*
+ * - hauptfubktion: Liest ganze Zeilen (line by line) auf einmal und ruft die Methode readLine() aus
+ * 
+ */
+public class Bufferedreader {
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1"));
+		String line = br.readLine();
+		/*
+		 * - Liest nur eine einzige Line auf dem File
+		 * 	 Lösungsmöglichkeit => Loop erzeugen
+		 */
+		while(line != null) {
+			System.out.println(line); // print die erste Line
+			line = br.readLine(); // spring auf die nächste Linie
+		}
+			
+		
+	}
+
+}

Programmierung2/src/oop/FileHandling/character/Bufferedwriter.java

@@ -0,0 +1,36 @@
+package oop.FileHandling.character;
+import java.io.FileWriter;
+import java.io.File;
+import java.io.IOException;
+
+import java.io.BufferedWriter;
+/*
+ * - hauptfubktion: Liest ganze Zeilen auf einmal und ruft die Methode readLine() aus
+ * - br.write(97); => 'a' sie liest keine Integer zahlen
+ * - br.write(10.5) => error geht nicht
+ * - br.write(boolean) => error geht nicht 
+ * 	 Alternative Möglichkeit (PrintWriter ) kann alle Daten Typs auf dem File schreiben
+ */
+public class Bufferedwriter {
+
+	public static void main(String[] args)  throws IOException {
+		/*
+		 * - BufferedWriter übernimmt keine Pfad für einen File,
+		 * 	 sondern übernimmt sie ein Objekt aus der Klasse (FileWriter) die extends die Abstrakte Klasse Writer
+		 * - FileWriter Klass hilft mir BufferedWriter zu verwenden
+		 */
+		
+		/*
+		 * true, damit  Wenn {@code true}, werden die Daten (fix geschpeichert)
+		 * anstatt an den Anfang. also die Datein werden nicht überschrieben werden 
+		 */
+		BufferedWriter b1 = new BufferedWriter(new FileWriter("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1",true));
+		b1.write("Hallo Welt");
+		b1.newLine(); // neue Linie
+		b1.write("Hallo Welt2");
+		b1.flush();
+		b1.close();
+		
+	}
+
+}

Programmierung2/src/oop/FileHandling/character/Filereader.java

@@ -0,0 +1,35 @@
+package oop.FileHandling.character;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class Filereader {
+	/*
+	 * - Das Verfahren läuft ganz geanu wie beim FileInputStream
+	 * - Kritik: FileReader liest jedes Char ich habe 10 Zeichen
+	 * 			 die Methode read() wird in dem Fall sich selbst 10 mal aufrufen
+	 * 	 Alternativ möglichkeit (BufferedReader)
+ 	 */
+	public static void main(String[] args) throws IOException {	
+		
+		File file = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1");
+		FileReader fr = new FileReader(file);
+		
+		// lese Dateien
+		// Variante 1:
+		int i;
+		while((i = fr.read()) != -1)
+			System.out.print((char)i);
+		
+		// Variante 2: Mit Hilfe von File Klasse 
+		char[] speicher = new char[(int) file.length()];
+		fr.read(speicher);
+		for (char c : speicher)
+			System.out.print(c);
+		
+		
+		
+	}
+
+}

Programmierung2/src/oop/FileHandling/character/Filewriter.java

@@ -0,0 +1,28 @@
+package oop.FileHandling.character;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class Filewriter {
+	// für Schreiben auf einem beliebig File
+	public static void main(String[] args) throws IOException {
+		//erstelle einen File
+		File newFile = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1");
+		if (newFile.createNewFile())  // createNewFile() gibt boolean zurück,ob der File ergolgreich erstellt wurde oder nicht
+            System.out.println("Datei erstellt: " + newFile.getName()); // der File muss im Pfad nicht existieren, damit es erstellt wurde
+             
+		String str = "Hallo Welt";
+		FileWriter fr = new FileWriter("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1");
+		fr.write(str); //wird Hallo Welt auf dem File geschrieben!
+		fr.write("\n"); // breakline im File
+		fr.write(str, 0, str.length()); //schreibt string von int x inkl bis int y exklus 
+		fr.write("\n");
+		fr.write('2');
+		
+		fr.close();
+		
+		
+	}
+
+}

Programmierung2/src/oop/FileHandling/character/OutPutStreamWriter.java

@@ -0,0 +1,18 @@
+package oop.FileHandling.character;
+import java.io.Writer;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+
+public class OutPutStreamWriter {
+
+	public static void main(String[] args) throws IOException {
+		// die Klasse (OutputStreamWriter) extends (Writer) 
+		
+		Writer writer = new OutputStreamWriter(new FileOutputStream("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1"));
+		String str = "hi Welt";
+		writer.write(str);
+		writer.flush();// da ich diese Methode aufgerufen habe, wurden die Datein zugeschieckt!
+	}
+
+}

Programmierung2/src/oop/FileHandling/character/Printwriter.java

@@ -0,0 +1,32 @@
+package oop.FileHandling.character;
+
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+
+public class Printwriter {
+	/*
+	 * - schreibt alle Daten Typs auf dem File
+	 * - flush() soll aufgerufen werden
+	 */
+	public static void main(String[] args) throws IOException {
+		 // - flush() soll aufgerufen werden
+		PrintWriter pr = new PrintWriter("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1");
+//		pr.println(97);
+//		pr.println("AAA");
+//		pr.println('B');
+//		pr.println(true);
+//		pr.flush();
+		
+		// oder
+		FileWriter fr = new FileWriter("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1");
+		PrintWriter pr2 = new PrintWriter(fr, true); //true steht für flush() Aufruf
+		pr2.write(97); // wenn wir write verwenden, sollen wir flush() aufrufen
+		pr2.println("AAA");
+		pr2.println('B');
+		pr2.println(true);
+		
+		
+		}
+
+}

Programmierung2/src/oop/FileHandling/character/Scannerklass.java

@@ -0,0 +1,25 @@
+package oop.FileHandling.character;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.Scanner;
+
+public class Scannerklass {
+
+	public static void main(String[] args) throws IOException {
+		File fr = new File("C:\\Users\\obaya\\eclipse-workspace\\OOP\\src\\oop\\FileHandling\\character\\Test1");
+		Scanner scan = new Scanner(fr);
+		
+		//System.out.println(scan.next()); liest nur ein wort und hört dann auf
+		//System.out.println(scan.nextLine()); // Liest nur eine Line und hört dann auf
+//		
+//		while(scan.hasNextLine())// hilfe mir alle Zeilen zu lesen
+//			System.out.println(scan.nextLine());
+		
+		scan.useDelimiter("w"); // gibt Foramt für den Text aus dem File
+		while(scan.hasNext())// hilfe mir alle Wörter zu lesen
+			System.out.println(scan.next()); 
+	}
+
+}

Programmierung2/src/oop/FinalKeyword/FinalKeywords.java

@@ -0,0 +1,38 @@
+package oop.FinalKeyword;
+
+public class FinalKeywords {
+	
+	/* 
+	 * Final is a non-access modifier applicable only to:
+	 * Final variables oder (Constant Variables) oder (const Variables) 		
+	 * Final parameters
+	 * Final methods
+	 * Final classes
+	 * Final References
+	 * 
+	 * 
+	 * Final variables oder:
+	 * final variable soll immer groß geschrieben werden.
+	 * für final variable kann nicht setter und getter erstellt werden
+	 * final static variable können in Constructor keinen Wert zuweisen werden 
+	 * final variable sind mit Scanner gültig
+	 * 
+	 * 
+	 * 
+	 * Final methods:
+	 * final methods können nicht überschrieben werden. complier error 
+	 * final-Methoden können in überladen werden.
+	 * 
+	 * 
+	 * Final Classes:
+	 * final classes können nicht geerbt werden.
+	 * classes die Private Konstruktoren hat, kann auch nicht  geerbt werden
+	 *
+	 *
+	 *
+	 *Final References: 
+	 *final References können nur einmal Werte zugewiesen Werden.
+	 *
+	 */
+
+}

Programmierung2/src/oop/FinalKeyword/Student.java

@@ -0,0 +1,64 @@
+package oop.FinalKeyword;
+
+public class Student {
+	final int STUDENT_ID ;
+	final static int degree;
+	String name;
+	int geburtstag;
+	
+	/* so geht 
+	 *	{STUDENT_ID = 200;}
+	 */
+	
+	
+	//oder so;
+		Student(){
+			STUDENT_ID = 20;
+			//degree = 2; Das ist verboten
+		}
+		// nur in static block
+		static {
+			degree = 20;
+		}
+	
+
+	public Student(final int STUDENT_ID, String name, int geburtstag) {
+		//STUDENT_ID = 0; verboten, das STUDENT_ID final ist
+		this.STUDENT_ID = STUDENT_ID;
+		this.name = name;
+		this.geburtstag = geburtstag;
+	}
+
+	// getmethod ist gültig
+	public int getSTUDENT_ID() {
+		return STUDENT_ID;
+	}
+
+	
+	/*das ist verboten, weil wir STUDENT_ID nicht ersetzen dürfen
+	 
+	 * public int setSTUDENT_ID(int  STUDENT_ID) {
+		this.STUDENT_ID = STUDENT_ID;
+	}
+	 */
+	
+	
+	@Override
+	final public String toString() {
+		return "Student [STUDENT_ID=" + STUDENT_ID + ", name=" + name + ", geburtstag=" + geburtstag + "]";
+	}
+}
+
+
+
+class GraduatedStudent extends Student{
+	
+	/*Verboten
+	 * @Override
+	 * public String toString() {
+		return "Student [STUDENT_ID=" + STUDENT_ID + ", name=" + name + ", geburtstag=" + geburtstag + "]";
+	}
+	 */
+	
+	
+}

Programmierung2/src/oop/FinalKeyword/Test.java

@@ -0,0 +1,14 @@
+package oop.FinalKeyword;
+
+
+public class Test {
+
+	public static void main(String[] args) {
+	 final Student st1 = new Student(123,"obai",2001);
+	 
+	// st1 = new Student (123,"obai",2001); Verboten
+	 
+	 System.out.print(st1.toString());
+	}
+
+}

Programmierung2/src/oop/Generics/AddMitarbeiter.java

@@ -0,0 +1,21 @@
+package oop.Generics;
+import java.util.ArrayList;
+
+
+public class AddMitarbeiter {
+	
+	ArrayList<Mietarbeiter> m1 = new ArrayList<>();
+	
+	public ArrayList<Mietarbeiter> getM1() {
+		return m1;
+	}
+
+	public void setM1(ArrayList<Mietarbeiter> m1) {
+		this.m1 = m1;
+	}
+
+	@Override
+	public String toString() {
+		return "AddMitarbeiter [m1=" + m1 + "]";
+	}
+}

Programmierung2/src/oop/Generics/DateTyps.java

@@ -0,0 +1,23 @@
+package oop.Generics;
+
+public class DateTyps <T,F> {
+	
+	private T inhalt;
+	private F inhalt2;
+	
+	public void setInhalt(T inhalt, F inhalt2 ) {
+		this.inhalt = inhalt;
+		this.inhalt2 = inhalt2;
+	}
+	
+	public T getInhalt() {
+		
+		return inhalt;
+		
+	}
+	
+	public F getInhalt2() {
+		return inhalt2;
+	}
+
+}

Programmierung2/src/oop/Generics/EinfachesBeispiel.java

@@ -0,0 +1,61 @@
+package oop.Generics;
+
+import java.util.ArrayList;
+
+public class EinfachesBeispiel {
+	
+
+	
+	public static void main(String[] args) {
+		
+	
+		
+		
+		int[] intArray = {1,2,3,4,5};
+		double[] doubleArray = {1.1,2.2,3.3,4.12,4.4};
+		float[] floatArray = {1.1f,2.2f,3.3f,4.12f,4.4f};
+		
+		//auslesen(floatArray);
+		
+		// für Generic
+		Integer[] IntegerArray = {1,2,3,4,5};
+		Double[] DoubleArray = {1.1,2.2,3.3,4.12,4.4};
+		Float[] FloatArray = {1.1f,2.2f,3.3f,4.12f,4.4f};
+		Character[] characterArray = {'a','b','c'};
+		String[] stringArray = {"hallo","Welt"};
+		
+		//auslesenGenerics(stringArray);
+		
+		
+		var variable = 1.1;
+		System.out.print(variable);
+		
+	}
+	public static void auslesen(int[] array) {
+		
+		for (int i : array)
+			System.out.print(i + " ");
+	}
+	
+	public static void auslesen(double[] array) {
+		
+		for (double i : array)
+			System.out.print(i + " ");
+	}
+	
+	
+	public static void auslesen(float[] array) {
+		
+		for (float i : array)
+			System.out.print(i + " ");
+	}
+	
+	// ich muss nicht immer die Mthode überladen wie oben die Methoden
+	// ich schicke also eine Objekt an diese Methode
+	public static <obj> void auslesenGenerics(obj[] array) {
+		
+		for (obj i : array)
+			System.out.print(i + " ");
+	}
+
+}

Programmierung2/src/oop/Generics/Generics.java

@@ -0,0 +1,19 @@
+package oop.Generics;
+
+public class Generics {
+	
+	/*
+	 * Generics ist ein Konzept in der Programmierung, das es ermöglicht, Klassen, Methoden und Schnittstellen so zu schreiben
+	 * ,dass sie mit beliebigen Datentypen arbeiten können. 
+	 * Anstatt festzulegen, dass eine Klasse oder Methode nur mit einem bestimmten Datentyp (z.B. int, String) arbeiten kann
+	 * , können Generics verwendet werden, um den Datentyp flexibel zu gestalten.
+	 * 
+	 * Generic wird durch: Namen ein Typparameter in spitzen Klammern (<>) angegeben wird
+	 * 
+	 * Generic funktionert mit:
+	 * 1. Klassen: (public class Box<T>)
+	 * 2. Methoden: (public static <T> void printArray(T[] array))
+	 * 3. Interfaces: (public interface Container<T>) 
+	 */
+
+}

Programmierung2/src/oop/Generics/Mietarbeiter.java

@@ -0,0 +1,23 @@
+package oop.Generics;
+
+public class Mietarbeiter {
+	
+	String name;
+	int alter;
+	
+	public Mietarbeiter(String name, int alter) {
+		super();
+		this.name = name;
+		this.alter = alter;
+	}
+
+
+
+	@Override
+	public String toString() {
+		return "Mietarbeiter [name=" + name + ", alter=" + alter + "]";
+	}
+	
+	
+	
+}

Programmierung2/src/oop/Generics/Test.java

@@ -0,0 +1,22 @@
+package oop.Generics;
+
+import java.util.ArrayList;
+
+public class Test {
+
+	public static void main(String[] args) {
+		
+		Mietarbeiter m = new Mietarbeiter("obai", 24);
+		AddMitarbeiter addMitarbeiter = new AddMitarbeiter();
+		
+		addMitarbeiter.getM1().add(m);
+		
+		System.out.println(addMitarbeiter);
+
+		
+		
+		//DateTyps<String,Integer> d1 = new DateTyps<>();
+		
+	}
+
+}

Programmierung2/src/oop/Interface/Auto.java

@@ -0,0 +1,58 @@
+package oop.Interface;
+
+public final class Auto implements Movable,SelfDrivable {
+	
+	int x,y;
+	int numberOffahrer;
+	
+	
+	public Auto() {
+		
+	}
+	
+	public Auto(int x, int y) {
+		this.x = x;
+		this.y = y;
+	}
+
+	@Override
+	public void destination(String d) {
+		System.out.println("Destination = " + d);
+	}
+
+	@Override
+	public void drive() {
+		System.out.println("drive");
+		
+	}
+
+	@Override
+	public void moveUp() {
+		y--;
+	}
+
+	@Override
+	public void moveDown() {
+		y++;
+	}
+
+	@Override
+	public void moveLeft() {
+		x--;
+	}
+
+	@Override
+	public void moveRight() {
+		x++;
+	}
+	
+	public void newMethod() {
+		
+		System.out.print("SelfDrivable");
+	}
+	
+
+	
+	
+
+}

Programmierung2/src/oop/Interface/Interface.java

@@ -0,0 +1,63 @@
+package oop.Interface;
+
+public class Interface {
+	
+	/*Was ist das?
+	 * 	Eigentlich ist das fast wie die Abstrakte klassen außer:
+	 * 
+	 *  Implementierung Mehrfachvererbung  
+	 *  abstrakte Klasse
+	 *  
+	 *  public interface klasseName  
+	 *  alle Attribute werden automatisch (public static final)
+	 * 	fast alle methoden werden automatisch (public abstract)
+	 *  	,außer die default methoden, die sollen aber in unterkalsse mit dem Wort public (soll geschrieben werden) implementiert werden und die können überschrieben werden
+	 *  Interface kann auch statiche methoden haben, die implementiert werden sollen 
+	 *  default methoden sind nur in Interface erlaubt!
+	 *  final methoden sind nicht erlaubt, da sie abstrake sind und sollen überschreiben werden!
+	 *  private methoden sind erlaubt aber nur in der selben Klasse!
+	 * 	Interface kann keinen Konstruktor haben!
+	 *  die untereklasse soll alle methode der Interface klasse implementieren
+	 * 
+	 * 
+	 * NestedInterface: 
+	 * public interface NestedInterface {
+		void test();
+	
+		interface InnerInterface  {
+			default void test2() {
+				System.out.print("Innerinterface");
+		}
+	}
+		
+	implements wid durch NestedInterface.InnerInterface
+	
+	 *Functional Interface:
+	 *  @FunctionalInterface
+	  public  interface Test2{
+		   int berechne(int a, int b);
+		  
+	  }
+	 * @FunctionalInterface dieses Interfaceklasse kann nur
+	 *   (eine abstratke) methode haben aber unendlich viele
+	 *   default,static und private methoden haben
+	 *   
+	 * Marker or Tagging Interface:
+	 *   ist ein Interface in Java, das keine Methoden oder Konstanten deklarier
+	 *    
+	 *    
+	 *    
+	 * wichtig: 
+	 * 	. eine unterekalsse extends eine Obereklasse
+	 * 	. eine normale oder final Klasse kann implements eine interface klasse
+	 *  . eine interface klasse extends eine interface klasse
+	 * 
+	 * welche java types kann interface implementieren?
+	 *  1. klassen
+	 *  2. abstrakte klassen
+	 *  3. nested Klassen (Verschateten klassen)
+	 *  4. Enum
+	 *  5. dynamic proxy
+	 */
+
+}

Programmierung2/src/oop/Interface/Movable.java

@@ -0,0 +1,15 @@
+package oop.Interface;
+
+public interface Movable  {
+	
+	void moveUp();
+	void moveDown();
+	void moveLeft();
+	void moveRight();
+	
+	default void newMethod() {
+		
+		System.out.print("SelfDrivable");
+	}
+	
+}

Programmierung2/src/oop/Interface/SelfDrivable.java

@@ -0,0 +1,30 @@
+package oop.Interface;
+
+public interface SelfDrivable  {
+	String AUTO_NAME = "BMW"; // ist default public static final
+	
+	
+	void destination (String d);
+	void drive();
+	
+	default void newMethod() {
+		
+		System.out.print("SelfDrivable");
+	}
+	
+	
+	static void klasseMethode() {
+		
+		System.out.print("Statiche Methode");
+	}
+	
+	private void hilfsMethode() {
+		  System.out.println("Hilfsmethode, die von anderen Methoden im Interface genutzt wird");
+	}
+	
+	default void standardMethode1() {
+	        System.out.println("Standardmethode 1");
+	        hilfsMethode(); // Aufruf der privaten Methode innerhalb des Interfaces
+	    }
+
+}

Programmierung2/src/oop/Interface/Test.java

@@ -0,0 +1,11 @@
+package oop.Interface;
+
+
+public class Test {
+
+	public static void main(String[] args) {
+		Movable a1 = new Auto();
+		
+	}
+
+}

Programmierung2/src/oop/Konstroktur/Konstroktur.java

@@ -0,0 +1,124 @@
+package oop.Konstroktur;
+
+public class Konstroktur {
+	
+	private String name; 
+	private String beschreibung;
+	private double price;
+	private int quantity;
+	private double discount;
+	private String color;
+	
+	
+	//Konstruktor:
+	/* 
+	 * Muss heißen wie die Klasse
+	 * Muss public sein
+	 * muss kein Return Wert haben
+	 * kann nicht abstrakt, static, final oder private sein
+	 * jedes Objekt kann nur eine einzige Konstruktor aufrufen
+	 * this.attribute = parameter
+	 * Default Konstroktur wird nur aufgerufen, wenn überhaupt kein Construktor haben
+	 */
+	
+	//Arten von Konstruktor:
+	
+	
+	//1. Default Konstroktur, wird automatisch aufgerufen, wenn wir kein Konstruktor erstellen 
+	 
+	//public Konstroktur() {}
+	
+	
+	
+	// 2.  no-argument constructor für default werte
+			public Konstroktur() {
+				this.name = "Kein Name";
+				this.beschreibung = "Kein Beschreibung";
+				this.price = 0.0;
+				this.quantity = 0;
+				this.discount =  0.0; 
+				
+			}
+			
+	//3.1 argument constructor für dynamische werte
+		    public Konstroktur(String name, String beschreibung, double price, int quantity, double discount) {
+		        this.name = name;
+		        this.beschreibung = beschreibung;
+		        this.price = price;
+		        this.quantity = quantity;
+		        this.discount = discount;
+		    }
+		    
+	//3.2 Aufruf eines andere Konstruktor ( Chaining)
+		    public Konstroktur(String name, String beschreibung, double price, int quantity, double discount,String color) {
+		    	
+		    	this (name,beschreibung,price,quantity,discount); // Aufruf der Konstruktor
+		    	this.color = color;
+		    }
+			    
+	// 4.1 Mit unterschiedlichen datentypen aber gleiche Parametern 
+			public Konstroktur(String n) {
+				 this.name = "Kein Name";
+				 this.beschreibung = "Kein Beschreibung";
+				 this.price = 0.0;
+				 this.quantity = 0;
+				 this.discount =  0.0; 
+				 			
+			}
+			
+		    
+	// 4.2 Mit unterschiedlichen datentypen aber gleiche Parametern 
+			public Konstroktur(int n) {
+				 this.name = "Kein Name";
+				 this.beschreibung = "Kein Beschreibung";
+				 this.price = 0.0;
+				 this.quantity = 0;
+				 this.discount =  0.0; 
+				 			
+			}
+			
+	// 5.1 andere Rheinfolge
+			public Konstroktur(String n, int z) {
+				this.name = "Kein Name";
+				this.beschreibung = "Kein Beschreibung";
+				this.price = 0.0;
+				this.quantity = 0;
+				this.discount =  0.0; 
+						 			
+				}
+					
+				    
+	 // 5.2 andere Rheinfolge
+			public Konstroktur(int z , String n) {
+				this.name = "Kein Name";
+				this.beschreibung = "Kein Beschreibung";
+				this.price = 0.0;
+				this.quantity = 0;
+				this.discount =  0.0;  			
+				}
+			
+			
+	// 6. Copy Constructor (dient dazu, Werte eines Objektes in anderem Objekt zu speicher)
+			public Konstroktur(Konstroktur k1) {
+				this.name = k1.name;
+				this.beschreibung = k1.beschreibung;
+				this.price = k1.price;
+				this.quantity = k1.quantity;
+				this.discount = k1.discount; 
+				
+			}
+			
+			
+			
+			
+		public void display() {
+			
+			System.out.println("Name = " + name);
+			System.out.println("Beschreibung = " + beschreibung);
+			System.out.println("price = " + price);
+			System.out.println(" quantity = " + quantity);
+			System.out.println("discount = " + discount);
+		}
+	
+
+}

Programmierung2/src/oop/Polymorphism/DailyMitarbeiter.java

@@ -0,0 +1,35 @@
+package oop.Polymorphism;
+
+public class DailyMitarbeiter extends Mitarbeiter {
+	private double Werktagspreis;
+	private int tagesrate;
+	
+	public double getWerktagspreis() {
+		return Werktagspreis;
+	}
+	
+	public void setWerktagspreis(double werktagspreis) {
+		Werktagspreis = werktagspreis;
+	}
+	
+	public int getTagesrate() {
+		return tagesrate;
+	}
+	
+	public void setTagesrate(int tagesrate) {
+		this.tagesrate = tagesrate;
+	}
+	
+	public DailyMitarbeiter() {}
+	
+		
+	public DailyMitarbeiter(String name, String adresse, String abteilung, String email, double gehalt, double Werktagspreis,int tagesrate) {
+		super(name, adresse, abteilung, email, gehalt);
+		this.Werktagspreis = Werktagspreis;
+		this.tagesrate = tagesrate;
+	}
+	
+	
+	
+	
+}

Programmierung2/src/oop/Polymorphism/GehaltMitarbeiter.java

@@ -0,0 +1,31 @@
+package oop.Polymorphism;
+
+public class GehaltMitarbeiter extends Mitarbeiter {
+	
+	double bouns;
+	
+	public GehaltMitarbeiter() {}
+	
+	public double getBouns() {
+		return bouns;
+	}
+
+	public void setBouns(double bouns) {
+		this.bouns = bouns;
+	}
+
+	public GehaltMitarbeiter(String name, String adresse, String abteilung, String email, double gehalt,double bouns) {
+		super(name, adresse, abteilung, email, gehalt);
+		this.bouns = bouns;
+		
+	}
+	
+	@Override
+	public double getGehalt() {
+		return super.getGehalt() + this.bouns;
+	}
+	// entweder super.getGehalt() 
+	// oder gehalt von private zu protected umwandlen
+	
+	
+}

Programmierung2/src/oop/Polymorphism/HourlyMitarbeiter.java

@@ -0,0 +1,43 @@
+package oop.Polymorphism;
+
+public class HourlyMitarbeiter extends Mitarbeiter {
+	
+	private double arbeitsstundenpreis;
+	private int stundensatz;
+	
+	public double getArbeitsstundenpreis() {
+		return arbeitsstundenpreis;
+	}
+	
+	public void setArbeitsstundenpreis(double arbeitsstundenpreis) {
+		this.arbeitsstundenpreis = arbeitsstundenpreis;
+	}
+	
+	public int getStundensatz() {
+		return stundensatz;
+	}
+	
+	public void setStundensatz(int stundensatz) {
+		this.stundensatz = stundensatz;
+	}
+	
+	
+	@Override
+	public double getGehalt() {
+		
+		return arbeitsstundenpreis * stundensatz;
+	}
+	
+	public HourlyMitarbeiter() {}
+
+	
+	
+	public HourlyMitarbeiter(String name, String adresse, String abteilung, String email, double gehalt,double arbeitsstundenpreis,int stundensatz ) {
+		super(name, adresse, abteilung, email, gehalt);
+		this.arbeitsstundenpreis = arbeitsstundenpreis;
+		this.stundensatz = stundensatz;
+	}
+	
+	
+
+}

Programmierung2/src/oop/Polymorphism/Mitarbeiter.java

@@ -0,0 +1,60 @@
+package oop.Polymorphism;
+
+public class Mitarbeiter {
+	
+	private String name;
+	private String adresse;
+	private String abteilung;
+	private String email;
+	private double gehalt;
+	
+	
+	
+	public String getName() {
+		return name;
+	}
+	
+	public void setName(String name) {
+		this.name = name;
+	}
+	
+	public String getAdresse() {
+		return adresse;
+	}
+	public void setAdresse(String adresse) {
+		this.adresse = adresse;
+	}
+	
+	public String getAbteilung() {
+		return abteilung;
+	}
+	
+	public void setAbteilung(String abteilung) {
+		this.abteilung = abteilung;
+	}
+	
+	public String getEmail() {
+		return email;
+	}
+	public void setEmail(String email) {
+		this.email = email;
+	}
+	
+	public double getGehalt() {
+		return gehalt;
+	}
+	public void setGehalt(double gehalt) {
+		this.gehalt = gehalt;
+	}
+	
+	public Mitarbeiter(String name, String adresse, String abteilung, String email, double gehalt) {
+		this.name = name;
+		this.adresse = adresse;
+		this.abteilung = abteilung;
+		this.email = email;
+		this.gehalt = gehalt;
+	}
+	
+	public Mitarbeiter() {}
+	
+}

Programmierung2/src/oop/Polymorphism/Polymorphism.java

@@ -0,0 +1,30 @@
+package oop.Polymorphism;
+
+public class Polymorphism {
+	
+	
+	/*Was ist das? 
+   	 * 
+	 * Method Overloading: Schlüsselwort (ohne)
+	 * 
+	 * Compile-time Polymorphism (Early binding or static binding) (frühe Bindung).
+	 * 
+	 * 	• Statische Methoden können überladen werden
+	 * 	• den selben Namen
+	 *  • Parameterlist unterscheiden sich in der Anzahl oder dem type der Parameter
+	 *  • innerhalb der selben oder abgeleiteten Klasse
+	 *  
+	 * Method Overriding: Schlüsselwort (@Override)
+	 * 
+	 * runtime-time Polymorphism (Late binding or Dynamic Polymorphism) (späte Bindung) 
+	 * 
+	 *  • Statische Methoden können nicht überschreiben werden
+	 *  • geht nur in Kindklasse also nur in Verebung mit (@Override)
+	 *  • den selben Namen
+	 *  • den selben Rückgabetyp
+	 *  • die selbe Parameterliste
+	 * 		• aber anderes Verhalten
+	 */
+	
+
+}

Programmierung2/src/oop/Polymorphism/Test.java

@@ -0,0 +1,53 @@
+package oop.Polymorphism;
+
+public class Test {
+
+	public static void main(String[] args) {
+
+		Mitarbeiter[] refarray = new  Mitarbeiter[4]; // das geht auch	
+		refarray[0] = new Mitarbeiter();
+		refarray[1] = new GehaltMitarbeiter();
+		refarray[2] = new DailyMitarbeiter();
+		refarray[3] = new HourlyMitarbeiter();
+		
+		for (int i = 0; i <refarray.length; i++)
+			
+			System.out.println(refarray[i]);
+		
+		
+		// oder 
+		for (Mitarbeiter e : refarray)
+			System.out.println(e);
+
+		
+		
+		
+		/*
+		 * Das folgende Beispiel zeigt, wie Upcasting in Java verwendet wird.
+		 * Eine Referenz der Elternklasse (Mitarbeiter) wird verwendet, um auf ein Objekt der Kindklasse (GehaltMitarbeiter) zu zeigen.
+		 * Durch Methodenüberschreibung in der Kindklasse wird die spezifische Implementierung der Kindklasse verwendet.
+		 */
+		Mitarbeiter m1 = new Mitarbeiter("Obai", "Mannheim", "IT", "Obq@gmail", 10000);
+		m1 = new GehaltMitarbeiter ("Obai", "Mannheim", "IT", "Obq@gmail", 10000,500);
+		/*
+		 * Vater kann auf die überschreibene Methode getGehalt() in kindklasse zugreifen
+		 * 	da er diese Methode hat.
+		 */
+		//System.out.println(m1.getGehalt());
+		
+		
+		/*
+		 * 
+		 * m1 kann nicht auf die methode getBouns() in kindklasse zugreifen,
+		 * da er diese Methode nicht hat
+		 * 
+		 * Lösung: downcasting
+		 */
+		if (m1 instanceof GehaltMitarbeiter) {
+			GehaltMitarbeiter  downcasting = (GehaltMitarbeiter) m1;
+			// System.out.println(downcasting.getBouns());
+		}
+		
+	}
+
+}

Programmierung2/src/oop/Test.java

@@ -0,0 +1,12 @@
+package oop;
+
+public class Test {
+	
+	public static void main(String[] args) {
+		
+	
+		
+	}
+	
+
+}

Programmierung2/src/oop/TypesofRealtionship/Abteilung.java

@@ -0,0 +1,45 @@
+package oop.TypesofRealtionship;
+
+public class Abteilung {
+	
+	private int depNo;
+	private String depName;
+	
+	
+	public Abteilung(int depNo, String depName) {
+		
+		this.depNo = depNo;
+		this.depName = depName;
+	}
+	
+	public Abteilung() { }
+	
+	
+	
+
+	public int getDepNo() {
+		return depNo;
+	}
+
+	public void setDepNo(int depNo) {
+		this.depNo = depNo;
+	}
+
+	public String getDepName() {
+		return depName;
+	}
+
+	public void setDepName(String depName) {
+		this.depName = depName;
+	}
+
+	@Override
+	public String toString() {
+		return "Abteilung [depNo=" + depNo + ", depName=" + depName + "]";
+	}
+	
+	
+	
+	
+
+}

Programmierung2/src/oop/TypesofRealtionship/Mitarbeiter.java

@@ -0,0 +1,46 @@
+package oop.TypesofRealtionship;
+
+public class Mitarbeiter {
+	
+	private int id;
+	private double gehalt;
+	/*
+	 * Relationships = Composition (Strong) warum? 
+	 * weil ein Mitarbeiter ohne Information nicht existieren darf
+	 */
+	private PersonalInformation personalInformation;
+	/*
+	 * Relationships  = Aggregation (waek) warum?
+	 * weil ein Mitarbeiter ohne Abteilung  existieren darf
+	 */
+	private Abteilung abteilung;
+	
+	public Mitarbeiter(int id, double gehalt,String vorname, String mittelname, String nachname, String kontonummer,String nationaläty, int geburts, Abteilung abteilung) {
+		this.id = id;
+		this.gehalt = gehalt;
+		/*
+		 * PersonalInformation = hier handelt es sich um Coposition, weil ich einen neuen Speicher in Class Mitarbeiter mit (new) reserviere
+		 * also Mitarbeiter kann nur mit Personalinformation existieren 
+		 */
+		this.personalInformation = new PersonalInformation(vorname,mittelname,nachname,kontonummer, nationaläty,geburts) ;
+		
+		/*
+		 * Abteilung class ist unabhängig von der Class Mitarbeiter (Siehe main Methode)
+		 */
+		this.abteilung = abteilung;
+	}
+
+	@Override
+	public String toString() {
+		return "Mitarbeiter [id=" + id + ", gehalt=" + gehalt + ", personalInformation=" + personalInformation
+				+ ", abteilungName=" + abteilung.getDepName() +", abteilungNummer=" + abteilung.getDepNo() +  "]";
+	}
+
+	
+	
+	
+	
+	
+	
+	
+}

Programmierung2/src/oop/TypesofRealtionship/PersonalInformation.java

@@ -0,0 +1,35 @@
+package oop.TypesofRealtionship;
+
+public class PersonalInformation {
+	
+	private String vorname;
+	private String mittelname;
+	private String nachname;
+	private String kontonummer;
+	private String nationaläty;
+	private int geburtstag;
+	
+	public PersonalInformation(String vorname, String mittelname, String nachname, String kontonummer,String nationaläty, int geburtstag) {
+		this.vorname = vorname;
+		this.mittelname = mittelname;
+		this.nachname = nachname;
+		this.kontonummer = kontonummer;
+		this.nationaläty = nationaläty;
+		this.geburtstag = geburtstag;
+	}
+	
+	public PersonalInformation() {
+		
+	}
+
+	@Override
+	public String toString() {
+		return "PersonalInformation [vorname=" + vorname + ", mittelname=" + mittelname + ", nachname=" + nachname
+				+ ", kontonummer=" + kontonummer + ", nationaläty=" + nationaläty + ", geburtstag=" + geburtstag + "]";
+	}
+	
+	
+
+	
+	
+}

Programmierung2/src/oop/TypesofRealtionship/Test.java

@@ -0,0 +1,14 @@
+package oop.TypesofRealtionship;
+
+public class Test {
+	
+	public static void main(String[] args) {
+		Abteilung ab1 = new Abteilung(12,"IT");// wenn das Objekt Mitarbeiter zerstört wird, bleibt das Objekt abteilung in Ordnung
+		
+		Mitarbeiter m1  = new Mitarbeiter(1,2500,"Obai","Obai","Albek","112222", "Syria",1995,ab1);
+
+		System.out.print(ab1);
+	}
+	
+
+}

Programmierung2/src/oop/Verebung/Verebung.java

@@ -0,0 +1,113 @@
+package oop.Verebung;
+
+/*Verebung Arten in Java:
+ * 
+ * Verebungklasse erbt defaultvalue vom Klasse Object, die ist in Java Automatisch
+ * 
+ * 
+ * 1. Single Verebung : ( B -> A )   Class B erbt von Class A 
+ * 2. Miultilever Verebung:(C-> B -> A )   Class C erbt von Class B und Class B erbt von Class A
+ * 3. Hierarchical Verebung: ( B -> A und C -> A) Class B erbt von A und C von A 
+ * 
+ * Wichtig: Muliverebung ist in Java nicht unterstützt
+ * 			Lösungsmöglichkeit (Interface) also mit Interface kann 
+ * 			( B -> A und B -> C) 
+ */
+
+
+/*
+ * verebung mit schlüsselwort extends
+ * Kindklasse ruft ihre constructor und ihre VaterKonstroktor 
+ * constructor kann nicht verebt werden aber wir von kindklasse aufgerufen
+ * also kindklasse gibt Parentconstructor und ihre constructor aus 
+ * 
+ */
+public class Verebung {
+	
+	protected String name;
+	protected String emailAdresse;
+	protected String phone;
+	protected String wohnung;
+	protected String adresse;
+	protected int gerbutstag;
+	
+	
+	public Verebung() {
+		
+		System.out.println("Partentklasse");		
+	}
+	
+	
+	
+	public Verebung(String name,String emailAdresse,String phone, String wohnung, String adresse,int gerbutstag) {
+		this.name = name;
+		this.emailAdresse = emailAdresse;
+		this.phone = phone;
+		this.wohnung = wohnung;
+		this.adresse = adresse;
+		this.gerbutstag = gerbutstag;
+		
+	}
+
+
+	public String getName() {
+		return name;
+	}
+
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+
+	public String getEmailAdresse() {
+		return emailAdresse;
+	}
+
+
+	public void setEmailAdresse(String emailAdresse) {
+		this.emailAdresse = emailAdresse;
+	}
+
+
+	public String getPhone() {
+		return phone;
+	}
+
+
+	public void setPhone(String phone) {
+		this.phone = phone;
+	}
+
+
+	public String getWohnung() {
+		return wohnung;
+	}
+
+
+	public void setWohnung(String wohnung) {
+		this.wohnung = wohnung;
+	}
+
+
+	public String getAdresse() {
+		return adresse;
+	}
+
+
+	public void setAdresse(String adresse) {
+		this.adresse = adresse;
+	}
+
+
+	public int getGerbutstag() {
+		return gerbutstag;
+	}
+
+
+	public void setGerbutstag(int gerbutstag) {
+		this.gerbutstag = gerbutstag;
+	}
+	
+	
+}

Programmierung2/src/oop/Verebung/Verebung2.java

@@ -0,0 +1,38 @@
+package oop.Verebung;
+
+public class Verebung2 extends Verebung {
+	
+	String projktName;
+	
+	public Verebung2(String name,String emailAdresse,String phone, String wohnung, String adresse,int gerbutstag,String projktName) {
+		/*
+		 * wichtig: Super soll erste geschrieben werden
+		 * 			Super benutzen wir nur für Parentklass in seinem Kindklass
+		 * 
+		 * Also ist falsch: 
+		 * this.projktName = projktName;
+		 * super(name,emailAdresse,phone, wohnung,adresse,gerbutstag);
+		 * 
+		 * Das geht auch:
+		 * super.attribute
+		 * super.methode
+		 */
+		
+		
+		//super(); // default constructor aufrufen
+		super(name,emailAdresse,phone, wohnung,adresse,gerbutstag);// constructor mit Argumenten aufrufen
+		this.projktName = projktName;
+	}
+	
+	public String getprojktName() {
+		
+		
+		return projktName;
+	}
+	
+	public void setprojktName(String projktName) {
+		
+		this.projktName = projktName;
+	}
+
+}

Programmierung2/src/oop/Verebung/Verebung3.java

@@ -0,0 +1,10 @@
+package oop.Verebung;
+
+public class Verebung3 extends Verebung2 {
+	
+	public Verebung3(String name,String emailAdresse,String phone, String wohnung, String adresse,int gerbutstag,String projktName) {
+		super(name,emailAdresse,phone, wohnung,adresse,gerbutstag,projktName);// constructor mit Argumenten aufrufen
+		System.out.println("Kindklasse 2");
+	}
+
+}