From 898277c351159f60f78e65d6c87cc291704ce7dd Mon Sep 17 00:00:00 2001 From: obaya Date: Fri, 16 Aug 2024 00:50:12 +0200 Subject: [PATCH] innere Klassen --- .../src/oop/InnereKlassen/Allgemein.java | 25 ++++++ .../InnereKlassen/AnonymeInnereKlassen.java | 26 ++++++ .../oop/InnereKlassen/LokaleInnereKlasse.java | 48 +++++++++++ .../NichtStatischeInnereKlasse.java | 45 +++++++++++ .../InnereKlassen/StatischeInnereKlasse.java | 80 +++++++++++++++++++ Programmierung2/src/Übungen/Nacnhrichten.java | 22 +++-- Programmierung2/src/Übungen/Whatsapp.java | 74 ++++++++--------- Programmierung2/src/Übungen/WhatsappTest.java | 24 +++--- 8 files changed, 281 insertions(+), 63 deletions(-) create mode 100644 Programmierung2/src/oop/InnereKlassen/Allgemein.java create mode 100644 Programmierung2/src/oop/InnereKlassen/AnonymeInnereKlassen.java create mode 100644 Programmierung2/src/oop/InnereKlassen/LokaleInnereKlasse.java create mode 100644 Programmierung2/src/oop/InnereKlassen/NichtStatischeInnereKlasse.java create mode 100644 Programmierung2/src/oop/InnereKlassen/StatischeInnereKlasse.java diff --git a/Programmierung2/src/oop/InnereKlassen/Allgemein.java b/Programmierung2/src/oop/InnereKlassen/Allgemein.java new file mode 100644 index 0000000..dabae45 --- /dev/null +++ b/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{ + + } + } + +} diff --git a/Programmierung2/src/oop/InnereKlassen/AnonymeInnereKlassen.java b/Programmierung2/src/oop/InnereKlassen/AnonymeInnereKlassen.java new file mode 100644 index 0000000..6d03050 --- /dev/null +++ b/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(); + } + +} diff --git a/Programmierung2/src/oop/InnereKlassen/LokaleInnereKlasse.java b/Programmierung2/src/oop/InnereKlassen/LokaleInnereKlasse.java new file mode 100644 index 0000000..d25fb48 --- /dev/null +++ b/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(); + + } +} diff --git a/Programmierung2/src/oop/InnereKlassen/NichtStatischeInnereKlasse.java b/Programmierung2/src/oop/InnereKlassen/NichtStatischeInnereKlasse.java new file mode 100644 index 0000000..1fc956d --- /dev/null +++ b/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(); + } + +} diff --git a/Programmierung2/src/oop/InnereKlassen/StatischeInnereKlasse.java b/Programmierung2/src/oop/InnereKlassen/StatischeInnereKlasse.java new file mode 100644 index 0000000..08fc1a7 --- /dev/null +++ b/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); + } + +} diff --git a/Programmierung2/src/Übungen/Nacnhrichten.java b/Programmierung2/src/Übungen/Nacnhrichten.java index d4fcb03..bb10f8a 100644 --- a/Programmierung2/src/Übungen/Nacnhrichten.java +++ b/Programmierung2/src/Übungen/Nacnhrichten.java @@ -4,17 +4,25 @@ import java.util.ArrayList; public class Nacnhrichten{ - public static ArrayList nachrichtenlists = new ArrayList<>(); + public ArrayList nachrichtenlists; - - public static void addMessage(String message) { - nachrichtenlists.add(message); + public Nacnhrichten() { + + this.nachrichtenlists = new ArrayList<>(); } - public static void printNachrichtLists() { - for (String nachricht : nachrichtenlists) - System.out.println(nachricht); + + public void saveMessages(String nachricht){ + + nachrichtenlists.add(nachricht); + + } + public void printAllMessages() { + for(String mes: nachrichtenlists) + System.out.println(mes.toString()); + } + } diff --git a/Programmierung2/src/Übungen/Whatsapp.java b/Programmierung2/src/Übungen/Whatsapp.java index 5e63849..04fd52c 100644 --- a/Programmierung2/src/Übungen/Whatsapp.java +++ b/Programmierung2/src/Übungen/Whatsapp.java @@ -1,49 +1,55 @@ package Übungen; import java.util.ArrayList; -public class Whatsapp extends Nacnhrichten { - private String name; - private String teleN; - private String nachricht; - private Whatsapp empf; - private ArrayList speicherContact; - private ArrayList speicherNummern; - private ArrayList addGrouppe; - private String grouppeName; +public class Whatsapp { + protected String name; + protected String teleN; + protected String nachricht; + protected Whatsapp empf; + protected ArrayList speicherContact; + protected ArrayList speicherNummern; + protected ArrayList addGrouppe; + protected String grouppeName; + private Nacnhrichten nachrichten; - - - public Whatsapp(){} - - public Whatsapp(String name, String teleN) { + public Whatsapp(String name, String teleN,Nacnhrichten nachrichten) { 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; - this.empf.setNachricht(nachricht); - nachrichtenlists.add(getSendeNachricht()); - + if (empf != null) { + this.empf = empf; + 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 addGrouppe) { + + public ArrayList addgrouppe(String grouppeName,ArrayList 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)); - } + } } public void addContact(String name, String teleN){ @@ -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 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 + "]"; } - - - - - - } \ No newline at end of file diff --git a/Programmierung2/src/Übungen/WhatsappTest.java b/Programmierung2/src/Übungen/WhatsappTest.java index 67bb2a6..aa44291 100644 --- a/Programmierung2/src/Übungen/WhatsappTest.java +++ b/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"); - Whatsapp omar = new Whatsapp("Omar", "049321384324"); - Whatsapp abd = new Whatsapp("abd", "049321384324"); + Nacnhrichten nachrichten = new Nacnhrichten(); + 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 gr1 = new ArrayList<>(); - gr1.add(omar); - gr1.add(abd); - obai.addgrouppe("Almidani",gr1); - obai.printgrouppe(); - obai.addContact("abd", "049321384324"); - obai.printContacte(); - - //Nacnhrichten.printNachrichtLists(); + }