innere Klassen

Programmierung2/src/oop/InnereKlassen/Allgemein.java

@@ -0,0 +1,25 @@
+package oop.InnereKlassen;
+
+public class Allgemein {
+	
+	/*Was ist das?
+	 * - In Java gibt es vier Haupttypen von inneren Klassen (auch bekannt als Nested Classes)
+	 * - Diese Klassen werden innerhalb einer anderen Klasse definiert und haben unterschiedliche Eigenschaften und Anwendungsfälle
+	 * - es ist die Möglichkeit eine Klasse in eine andere Klasse zu binden
+	 * - diese Klasse heißt "innere Klasse"
+	 * - Java definiert vier Typen von inneren Klassen
+	 * 
+	 * 
+	 * . Zusammenfassung: 
+	 *	 - Statische Innere Klassen:  sind unabhängig von der äußeren Klasseninstanz und haben Zugriff nur auf die statischen Mitglieder der äußeren Klasse.
+	 *	 - Nicht-statische Innere Klassen:  benötigen eine Instanz der äußeren Klasse und haben Zugriff auf alle Mitglieder dieser Instanz.
+	 *	 - Lokale Innere Klassen: sind methoden-spezifisch und können nur innerhalb der Methode verwendet werden, in der sie definiert sind.
+	 *	 - Anonyme Innere Klassen:  sind namenlose Klassen, die sofort erstellt werden und in der Regel verwendet werden, um eine Schnittstelle oder abstrakte Klasse schnell zu implementieren.
+	 */
+	class Außen{
+		class Innen{
+			
+		}
+	}
+
+}

Programmierung2/src/oop/InnereKlassen/AnonymeInnereKlassen.java

@@ -0,0 +1,26 @@
+package oop.InnereKlassen;
+
+public class AnonymeInnereKlassen {
+	/*
+	 * - hat keinen eigenen Name
+	 * - Sie wird sofort in einer Ausdrücke definiert und instanziiert, oft als Implementierung einer Schnittstelle oder als Erweiterung einer Klasse, wenn nur eine einzige Instanz benötigt wird.
+	 * - Sie wird sofort in einer Ausdrücke definiert und instanziiert, oft als Implementierung einer Schnittstelle oder als Erweiterung einer Klasse, wenn nur eine einzige Instanz benötigt wird.
+	 * - sind ideal für einmalige Verwendungen
+	 * - die verwendung von extends und imolements ist nicht erlaubt
+	 */
+	
+	interface MyInterface {
+        void display();
+    }
+
+    public static void main(String[] args) {
+        MyInterface obj = new MyInterface() {
+            @Override
+            public void display() {
+                System.out.println("Hello from Anonymous Inner Class");
+            }
+        };
+        obj.display();
+    }
+
+}

Programmierung2/src/oop/InnereKlassen/LokaleInnereKlasse.java

@@ -0,0 +1,48 @@
+package oop.InnereKlassen;
+/*
+ * - wird nur innerhalb einer Methode, eines Konstruktors oder eines Blocks definiert
+ * - Sie ist nur innerhalb des Umfangs sichtbar, in dem sie definiert ist.
+ * - Wird typischerweise verwendet, um eine Klasse zu definieren, die nur in einer bestimmten Methode benötigt wird.
+ * - lokale Schnittstellen (interfaces) sind nicht erlaubt
+ * 
+ */
+public class LokaleInnereKlasse {
+
+	 final int x = 2;
+	 private final String nichtLokal = "ich bin nicht Lokal";
+	 
+	public static void main(String[] args) {
+		// diese Klasse ist nur innerhalb der Main methode sichtbar
+		class LokaleKlasse{
+			public String toString(){
+				return "ich bin Lokal22";
+			}
+		
+		}
+		
+		LokaleKlasse lokal = new LokaleKlasse();
+		System.out.println(lokal.toString());
+		
+		LokaleInnereKlasse test = new LokaleInnereKlasse();
+		test.zweiteLokaleKlasse();
+		
+	}
+	
+	public void zweiteLokaleKlasse() {
+		
+		final String ausgabe = "Ich bin lokal in einer methode";
+		
+		class LokaleKlass2{
+			private final String lokal = "Ich bin Lokal";
+			
+			public void print() {
+                System.out.println(nichtLokal + " " +  ausgabe +  " "+ " " + lokal );
+			}
+			
+		}
+		
+		LokaleKlass2 lokale2 = new LokaleKlass2();
+		lokale2.print();
+		
+	}
+}

Programmierung2/src/oop/InnereKlassen/NichtStatischeInnereKlasse.java

@@ -0,0 +1,45 @@
+package oop.InnereKlassen;
+/*
+ * - heißt auch (member class)
+ * - zählt auch als Attribut
+ * - kann auf alle Elemente der äußere Klasse zugreifen,die auch (private sind)
+ * - um ein Objekt der Hauptspeicher zu erzeugen, soll Objekt Computer erst erzeugt werden
+ * - unterschied zu statischen, da statischen ohne Objekt der äußere klassen sein können
+ * - nicht-statische-innere klassen dürfen keine statische Elemente definieren
+ * - sind wichtig für kompositionen 
+ */
+
+public class NichtStatischeInnereKlasse {
+	
+	 public class Computer{
+		// String static user = "obai"; verboten
+		String hersteller = "HP";
+		Hauptspeicher speicher = new Hauptspeicher();
+		// ist verboten 
+		public static void print() {
+			System.out.println("hallo");
+		}
+		
+		class  Hauptspeicher{
+			int groesse = 1024;
+			
+			public String gethersteller() {
+				//Zugriff auf das Attribut 'hersteller' der äußeren Klasse 'Computer'
+				return hersteller;
+			}
+			
+		
+		}
+		
+	}
+	 
+	 public static void main(String[] args) {
+	 NichtStatischeInnereKlasse n1 = new NichtStatischeInnereKlasse();
+	 
+	 NichtStatischeInnereKlasse.Computer c1 = n1.new Computer();
+	 Computer.Hauptspeicher h1= c1.new Hauptspeicher();
+	 System.out.println(h1.gethersteller() + " " + h1.groesse);
+	 c1.print();
+	 }
+
+}

Programmierung2/src/oop/InnereKlassen/StatischeInnereKlasse.java

@@ -0,0 +1,80 @@
+package oop.InnereKlassen;
+/*
+ * - diese ist die einfachste Variante einer innere Klasse
+ * - wege der Schachtelung wird dieser Typ im Englischen "nested top-Level class" genannt
+ * - diese Klasse kann das Gleiche wie "normale" Klassen oder Schnittstellen
+ * - statische innere Klasse benötigen keine Instanzen (Exemplare) der äußeren Klasse
+ * - statische innere Klasse werden nur sehr selten verwendet 
+ * - Statische innere Klassen in Java können auf die statischen Elemente der äußeren Klasse zugreifen,
+ *   (sobald) diese Elemente in der statischen inneren Klasse aufgerufen werden
+ *  - der Zugriff von der äußeren Klasse auf die innere Klasse ist nur möglich, wenn die äußere Klasse eine Instanz der inneren Klasse erstellt,
+		es sei denn, die innere Klasse ist statisch
+	
+	- der statische Klasse soll anderen Name als der äußere Klasse haben
+		
+ *  Wichtig: es gibt aber einen Weg, um auf die nicht-statische Elemente zuzugreifen (mit ein Objekt)
+ */
+
+public class StatischeInnereKlasse {
+	public static int x = 2;
+	private int y = 1;
+	
+	// äußere Klasse
+		public static String außen() {
+			return "ich bin außen";
+		}
+		
+		// Zugriff auf die innere Klasse von äußen
+		public int getf() {
+			Innereklasse k1 = new Innereklasse();
+			return k1.f;
+		}
+	
+	//Innere klasse
+	public static class Innereklasse{
+		public static int d = x;
+		public static int f = 20;
+		
+		public String toString() {
+			return "ich bin innen";
+		}
+		//Aufruf der statische Attribute der x der äußern klasse
+		public int getx() {
+			return x;
+		}
+		
+		// Aufruf der nicht statische Elemente der äußere Klasse
+		public void printy(StatischeInnereKlasse ob) {
+			System.out.println(ob.y);
+		}
+		
+		//Aufruf der Konstruktor  der äußere Klasse
+		 void accessOuterConstructor() {
+			// Erstellen einer neuen Instanz der äußeren Klasse und Zugriff auf ihre Elemente
+			 StatischeInnereKlasse newOuterInstance = new StatischeInnereKlasse();
+			System.out.println("New Instance Variable: " + newOuterInstance.y);
+			}
+
+	}
+	
+	
+	
+	
+	//zugreife auf innen und außen
+	public static void main(String[] args) {
+		
+		//zugriff nur auf das äußere Klasse
+		StatischeInnereKlasse außereKlasse = new StatischeInnereKlasse();
+		System.out.println(außereKlasse.toString());
+		//zugriff auf die elemente der innere Klasse von äußen
+		System.out.println(außereKlasse.getf());
+		//System.out.println(außereKlasse.f); Fehler geht nicht
+		
+		//Zugriff auf die innere Klasse
+		StatischeInnereKlasse.Innereklasse innere = new StatischeInnereKlasse.Innereklasse();
+		System.out.println(innere.getx());//2
+		//System.out.println(innere.d);
+		innere.printy(außereKlasse);
+	}
+	
+}

Programmierung2/src/Übungen/Nacnhrichten.java

@@ -4,17 +4,25 @@ import java.util.ArrayList;
 public class Nacnhrichten{
 	
 	
-	public static ArrayList<String> nachrichtenlists = new ArrayList<>();
+	public ArrayList<String> nachrichtenlists;
 	
 	
+	public Nacnhrichten() {
 		
-	public static void addMessage(String message) {
+		this.nachrichtenlists = new ArrayList<>();
-		nachrichtenlists.add(message);
 	}
 	
-	public static  void printNachrichtLists() {	
+	
-		for (String nachricht : nachrichtenlists)
+	public void saveMessages(String nachricht){
-			System.out.println(nachricht);
+		
+		nachrichtenlists.add(nachricht);
+		 
+		
+	}
+	
+	public void printAllMessages() {
+		for(String mes: nachrichtenlists)
+			System.out.println(mes.toString());
 	}
 
 }

Programmierung2/src/Übungen/Whatsapp.java

@@ -1,46 +1,52 @@
 package Übungen;
 import java.util.ArrayList;
 
-public class Whatsapp extends Nacnhrichten {
+public class Whatsapp {
-    private String name;
+    protected String name;
-    private String teleN;
+    protected String teleN;
-    private String nachricht;
+    protected String nachricht;
-    private Whatsapp empf;
+    protected Whatsapp empf;
-	private ArrayList <String> speicherContact;
+    protected ArrayList <String> speicherContact;
-	private ArrayList <String> speicherNummern;
+    protected ArrayList <String> speicherNummern;
-	private ArrayList <Whatsapp> addGrouppe;
+	protected ArrayList <Whatsapp> addGrouppe;
-	private String grouppeName;
+	protected String grouppeName;
+    private Nacnhrichten nachrichten;
 
-
+	public Whatsapp(String name, String teleN,Nacnhrichten nachrichten) {
-    
-    public Whatsapp(){}
-    
-	public Whatsapp(String name, String teleN) {
 		this.name = name;
-		this.teleN = teleN;
 		this.nachricht = null;
+		this.teleN = teleN;
+		this.nachrichten = nachrichten;
 		this.empf = null;
 		this.speicherContact = new ArrayList<>();
 		this.speicherNummern = new ArrayList<>();
 		this.addGrouppe = new ArrayList<>();
 		this.grouppeName = null;
-		
 	}
 
 	public void sendeNachricht(Whatsapp empf , String nachricht) {
-		this.empf = empf;
+		if (empf != null) {
-		this.empf.setNachricht(nachricht);
+			this.empf = empf;
-		nachrichtenlists.add(getSendeNachricht());
+			this.empf.setNachricht(nachricht);
+			String formattedMessage = this.name + " sendet an " + empf.getName() + ": " + empf.getNachricht();
 
+			nachrichten.saveMessages(formattedMessage);
+		}
+		else
+			System.err.println("Empfäbnger existitiert nicht!");
 	}
 	
-	public void addgrouppe(String grouppeName,ArrayList<Whatsapp> addGrouppe) {
+	
+	public ArrayList<Whatsapp>  addgrouppe(String grouppeName,ArrayList<Whatsapp> addGrouppe) {
 		this.addGrouppe.addAll(addGrouppe);
 		this.grouppeName = grouppeName;
+		
+		return addGrouppe; 
 	}
 	
 	public void printgrouppe(){
-		System.out.println(this.name + " hat die Grouppe " + this.grouppeName + " erstellt");
+	
+		System.out.println("Die Grouppe " + this.grouppeName );
 		for (int i = 0; i < addGrouppe.size(); i++){
 				System.out.println(addGrouppe.get(i));
 		}	
@@ -73,19 +79,11 @@ public class Whatsapp extends Nacnhrichten {
 		}
 	}
 	
-	public String getSendeNachricht() {
-		return this.name + " sendet zu  "+ this.empf.name + " : "  + this.empf.getNachricht();
 	
-	}
 	
-	public void getNachrichten() {
-		 Nacnhrichten.addMessage(this.getSendeNachricht());
 	
-	}
-	public ArrayList<String> getnachrichtenlists() {
 	
-		return nachrichtenlists;
+	
-	}
 	public String getName() {
 		return name;
 	}
@@ -110,10 +108,4 @@ public class Whatsapp extends Nacnhrichten {
 	public String toString() {
 		return "Whatsapp [name=" + name + ", teleN=" + teleN + "]";
 	}
-	
-	
-    
-    
-
-    
 }

Programmierung2/src/Übungen/WhatsappTest.java

@@ -4,23 +4,17 @@ import java.util.ArrayList;
 public class WhatsappTest {
 
 	public static void main(String[] args) {
-		Whatsapp obai = new Whatsapp("obai", "049321384324");
+        Nacnhrichten nachrichten = new Nacnhrichten();
-		Whatsapp omar = new Whatsapp("Omar", "049321384324");
+
-		Whatsapp abd = new Whatsapp("abd", "049321384324");
+		Whatsapp obai = new Whatsapp("obai", "049321384324",nachrichten);
+		Whatsapp omar = new Whatsapp("Omar", "049321384324",nachrichten);
+		obai.sendeNachricht(omar, "hallo Omar");
+		omar.sendeNachricht(obai, "hallo Obai");
+		obai.sendeNachricht(omar, "was machst du?");
+		omar.sendeNachricht(obai, "nix und du");
+		nachrichten.printAllMessages();
 		
 
-		obai.sendeNachricht(omar, "Hallo");
-		omar.sendeNachricht(obai, "Hi");
-		
-		ArrayList<Whatsapp> gr1 = new ArrayList<>();
-		gr1.add(omar);
-		gr1.add(abd);
-		obai.addgrouppe("Almidani",gr1);
-		obai.printgrouppe();
-		obai.addContact("abd", "049321384324");
-		obai.printContacte();
-		
-		//Nacnhrichten.printNachrichtLists();
 
 	}