innere Klassen
obaya
parent
3e24e2841b
commit
898277c351
|
|
@ -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{
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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();
|
||||
|
||||
}
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -4,17 +4,25 @@ import java.util.ArrayList;
|
|||
public class Nacnhrichten{
|
||||
|
||||
|
||||
public static ArrayList<String> nachrichtenlists = new ArrayList<>();
|
||||
public ArrayList<String> 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());
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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 <String> speicherContact;
|
||||
private ArrayList <String> speicherNummern;
|
||||
private ArrayList <Whatsapp> addGrouppe;
|
||||
private String grouppeName;
|
||||
public class Whatsapp {
|
||||
protected String name;
|
||||
protected String teleN;
|
||||
protected String nachricht;
|
||||
protected Whatsapp empf;
|
||||
protected ArrayList <String> speicherContact;
|
||||
protected ArrayList <String> speicherNummern;
|
||||
protected ArrayList <Whatsapp> 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<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));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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<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 + "]";
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -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<Whatsapp> gr1 = new ArrayList<>();
|
||||
gr1.add(omar);
|
||||
gr1.add(abd);
|
||||
obai.addgrouppe("Almidani",gr1);
|
||||
obai.printgrouppe();
|
||||
obai.addContact("abd", "049321384324");
|
||||
obai.printContacte();
|
||||
|
||||
//Nacnhrichten.printNachrichtLists();
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue