diff --git a/Programmierung2/src/oop/Abstraction/Abstraction.java b/Programmierung2/src/oop/Abstraction/Abstraction.java new file mode 100644 index 0000000..efbef37 --- /dev/null +++ b/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(); + + +} diff --git a/Programmierung2/src/oop/Abstraction/Auto.java b/Programmierung2/src/oop/Abstraction/Auto.java new file mode 100644 index 0000000..c73631e --- /dev/null +++ b/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(); + + + +} diff --git a/Programmierung2/src/oop/Abstraction/Auto2.java b/Programmierung2/src/oop/Abstraction/Auto2.java new file mode 100644 index 0000000..f6c8b69 --- /dev/null +++ b/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); + + } + + + + +} diff --git a/Programmierung2/src/oop/Abstraction/Hatchback.java b/Programmierung2/src/oop/Abstraction/Hatchback.java new file mode 100644 index 0000000..d54d496 --- /dev/null +++ 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"); + + } + + + +} diff --git a/Programmierung2/src/oop/Abstraction/MarkerInterface.java b/Programmierung2/src/oop/Abstraction/MarkerInterface.java new file mode 100644 index 0000000..4cda615 --- /dev/null +++ b/Programmierung2/src/oop/Abstraction/MarkerInterface.java @@ -0,0 +1,6 @@ +package oop.Abstraction; + +public class MarkerInterface { + // Keine Methoden oder Konstanten + +} diff --git a/Programmierung2/src/oop/Abstraction/NestedInterface.java b/Programmierung2/src/oop/Abstraction/NestedInterface.java new file mode 100644 index 0000000..af778b2 --- /dev/null +++ b/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"); + } + + } + +} diff --git a/Programmierung2/src/oop/Abstraction/SUV.java b/Programmierung2/src/oop/Abstraction/SUV.java new file mode 100644 index 0000000..9b76cc0 --- /dev/null +++ b/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"); + + } + + +} diff --git a/Programmierung2/src/oop/Abstraction/Test.java b/Programmierung2/src/oop/Abstraction/Test.java new file mode 100644 index 0000000..22f6afc --- /dev/null +++ b/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 + + } + +} diff --git a/Programmierung2/src/oop/AnonymousInnerClass/AnonymousInnerClass.java b/Programmierung2/src/oop/AnonymousInnerClass/AnonymousInnerClass.java new file mode 100644 index 0000000..950f0c8 --- /dev/null +++ b/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. + * + * + */ + +} diff --git a/Programmierung2/src/oop/AnonymousInnerClass/Interface.java b/Programmierung2/src/oop/AnonymousInnerClass/Interface.java new file mode 100644 index 0000000..67bcaec --- /dev/null +++ b/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(); + } +} diff --git a/Programmierung2/src/oop/AnonymousInnerClass/Konstruktor.java b/Programmierung2/src/oop/AnonymousInnerClass/Konstruktor.java new file mode 100644 index 0000000..ae83138 --- /dev/null +++ b/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(); + + } + +} diff --git a/Programmierung2/src/oop/AnonymousInnerClass/RewardClass.java b/Programmierung2/src/oop/AnonymousInnerClass/RewardClass.java new file mode 100644 index 0000000..b6288fc --- /dev/null +++ b/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€."); + } + + +} diff --git a/Programmierung2/src/oop/AnonymousInnerClass/Test.java b/Programmierung2/src/oop/AnonymousInnerClass/Test.java new file mode 100644 index 0000000..240f952 --- /dev/null +++ b/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 + */ + } + +} diff --git a/Programmierung2/src/oop/Aufgaben/BankKonto.java b/Programmierung2/src/oop/Aufgaben/BankKonto.java new file mode 100644 index 0000000..c7aa3bc --- /dev/null +++ b/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; + } + +} diff --git a/Programmierung2/src/oop/Aufgaben/Kreis.java b/Programmierung2/src/oop/Aufgaben/Kreis.java new file mode 100644 index 0000000..0db1c3f --- /dev/null +++ b/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() ; + } + + +} diff --git a/Programmierung2/src/oop/Aufgaben/Mitarbeiter.java b/Programmierung2/src/oop/Aufgaben/Mitarbeiter.java new file mode 100644 index 0000000..a2d2f54 --- /dev/null +++ b/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; + } + + +} diff --git a/Programmierung2/src/oop/Aufgaben/Personalverwaltung.java b/Programmierung2/src/oop/Aufgaben/Personalverwaltung.java new file mode 100644 index 0000000..4ef8398 --- /dev/null +++ b/Programmierung2/src/oop/Aufgaben/Personalverwaltung.java @@ -0,0 +1,32 @@ +package oop.Aufgaben; + +import java.util.ArrayList; + +public class Personalverwaltung { + + ArrayList mitarbeiterliste = new ArrayList(); + + + + 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); + } + } + +} diff --git a/Programmierung2/src/oop/Einführung/Einführung.java b/Programmierung2/src/oop/Einführung/Einführung.java new file mode 100644 index 0000000..6f32c1a --- /dev/null +++ b/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; + } +} diff --git a/Programmierung2/src/oop/Enumeration/EnumMethods.java b/Programmierung2/src/oop/Enumeration/EnumMethods.java new file mode 100644 index 0000000..fd8c8b7 --- /dev/null +++ b/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 days = EnumSet.allOf(EnumMethods.class); + System.out.println(days); + + // gibt nur Werte ,die ich eingebe + EnumSet day = EnumSet.of(EnumMethods.DIENSTAG, EnumMethods.FREITAG); + System.out.println(day); + + // gibt nur einmal Diesntag aus! + EnumSet day1 = EnumSet.of(EnumMethods.DIENSTAG, EnumMethods.DIENSTAG); + System.out.println(day); + + // gibt mir von Konstante to Kosntnate zurück! + EnumSet range = EnumSet.range(EnumMethods.DIENSTAG, EnumMethods.FREITAG); + System.out.println(range); + + + EnumSet noneOf = EnumSet.noneOf(EnumMethods.class); + noneOf.add(DIENSTAG); + noneOf.addAll(noneOf); + noneOf.remove(DIENSTAG); + noneOf.removeAll(noneOf); + System.out.println(noneOf); + + } + +} diff --git a/Programmierung2/src/oop/Enumeration/Enumeration.java b/Programmierung2/src/oop/Enumeration/Enumeration.java new file mode 100644 index 0000000..b6070a1 --- /dev/null +++ b/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 + * + */ + +} diff --git a/Programmierung2/src/oop/Enumeration/Numbers.java b/Programmierung2/src/oop/Enumeration/Numbers.java new file mode 100644 index 0000000..5e5f21e --- /dev/null +++ b/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"); + } + +} diff --git a/Programmierung2/src/oop/Enumeration/Order.java b/Programmierung2/src/oop/Enumeration/Order.java new file mode 100644 index 0000000..5c6c298 --- /dev/null +++ b/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; + } + + + +} diff --git a/Programmierung2/src/oop/Enumeration/OrderTest.java b/Programmierung2/src/oop/Enumeration/OrderTest.java new file mode 100644 index 0000000..4594a88 --- /dev/null +++ b/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()); + + } + +} diff --git a/Programmierung2/src/oop/Enumeration/Test.java b/Programmierung2/src/oop/Enumeration/Test.java new file mode 100644 index 0000000..1eb085f --- /dev/null +++ b/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(); + + + + + + } + +} diff --git a/Programmierung2/src/oop/Enumeration/Wochentage.java b/Programmierung2/src/oop/Enumeration/Wochentage.java new file mode 100644 index 0000000..80e2f3e --- /dev/null +++ b/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(); + + +} diff --git a/Programmierung2/src/oop/ExceptionHandling/Bildschirmfoto vom 2024-08-06 12-04-58.png b/Programmierung2/src/oop/ExceptionHandling/Bildschirmfoto vom 2024-08-06 12-04-58.png new file mode 100644 index 0000000..a5ed8dc Binary files /dev/null and b/Programmierung2/src/oop/ExceptionHandling/Bildschirmfoto vom 2024-08-06 12-04-58.png differ diff --git a/Programmierung2/src/oop/ExceptionHandling/Bildschirmfoto vom 2024-08-06 12-07-28.png b/Programmierung2/src/oop/ExceptionHandling/Bildschirmfoto vom 2024-08-06 12-07-28.png new file mode 100644 index 0000000..7d7a4aa Binary files /dev/null and b/Programmierung2/src/oop/ExceptionHandling/Bildschirmfoto vom 2024-08-06 12-07-28.png differ diff --git a/Programmierung2/src/oop/ExceptionHandling/CheckedException.java b/Programmierung2/src/oop/ExceptionHandling/CheckedException.java new file mode 100644 index 0000000..4cfe17c --- /dev/null +++ b/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); + } + } + +} diff --git a/Programmierung2/src/oop/ExceptionHandling/ExceptionHandling.java b/Programmierung2/src/oop/ExceptionHandling/ExceptionHandling.java new file mode 100644 index 0000000..d457359 --- /dev/null +++ b/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"); + + + + } + + +} diff --git a/Programmierung2/src/oop/ExceptionHandling/Finally.java b/Programmierung2/src/oop/ExceptionHandling/Finally.java new file mode 100644 index 0000000..9debfef --- /dev/null +++ b/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; + } + } +} diff --git a/Programmierung2/src/oop/ExceptionHandling/MultiCatchBlocks.java b/Programmierung2/src/oop/ExceptionHandling/MultiCatchBlocks.java new file mode 100644 index 0000000..eb1b79c --- /dev/null +++ b/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); + } + } + + +} diff --git a/Programmierung2/src/oop/ExceptionHandling/Throwkeyword.java b/Programmierung2/src/oop/ExceptionHandling/Throwkeyword.java new file mode 100644 index 0000000..c02670e --- /dev/null +++ b/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"); + } +} diff --git a/Programmierung2/src/oop/ExceptionHandling/ThrowsKeyword.java b/Programmierung2/src/oop/ExceptionHandling/ThrowsKeyword.java new file mode 100644 index 0000000..9e7c141 --- /dev/null +++ b/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); + } + + } +} diff --git a/Programmierung2/src/oop/ExceptionHandling/UnCheckedException.java b/Programmierung2/src/oop/ExceptionHandling/UnCheckedException.java new file mode 100644 index 0000000..edbe662 --- /dev/null +++ b/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(); + } +} diff --git a/Programmierung2/src/oop/File-Handling.odt b/Programmierung2/src/oop/File-Handling.odt new file mode 100644 index 0000000..2bc3d1a Binary files /dev/null and b/Programmierung2/src/oop/File-Handling.odt differ diff --git a/Programmierung2/src/oop/FileHandling/ByteKlassen/Eingefügtes Bild.png b/Programmierung2/src/oop/FileHandling/ByteKlassen/Eingefügtes Bild.png new file mode 100644 index 0000000..5096fe1 Binary files /dev/null and b/Programmierung2/src/oop/FileHandling/ByteKlassen/Eingefügtes Bild.png differ diff --git a/Programmierung2/src/oop/FileHandling/ByteKlassen/Fileinputstream.java b/Programmierung2/src/oop/FileHandling/ByteKlassen/Fileinputstream.java new file mode 100644 index 0000000..b72dba1 --- /dev/null +++ b/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); + } + + + + } +} diff --git a/Programmierung2/src/oop/FileHandling/ByteKlassen/Filoutputstream.java b/Programmierung2/src/oop/FileHandling/ByteKlassen/Filoutputstream.java new file mode 100644 index 0000000..8d6575e --- /dev/null +++ b/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()); + } + + +} diff --git a/Programmierung2/src/oop/FileHandling/ByteKlassen/LeseEinBild.java b/Programmierung2/src/oop/FileHandling/ByteKlassen/LeseEinBild.java new file mode 100644 index 0000000..5847edb --- /dev/null +++ b/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(); + + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/ByteKlassen/Test b/Programmierung2/src/oop/FileHandling/ByteKlassen/Test new file mode 100644 index 0000000..f2ba8f8 --- /dev/null +++ b/Programmierung2/src/oop/FileHandling/ByteKlassen/Test @@ -0,0 +1 @@ +abc \ No newline at end of file diff --git a/Programmierung2/src/oop/FileHandling/ByteKlassen/Test2 b/Programmierung2/src/oop/FileHandling/ByteKlassen/Test2 new file mode 100644 index 0000000..9d3f046 --- /dev/null +++ b/Programmierung2/src/oop/FileHandling/ByteKlassen/Test2 @@ -0,0 +1 @@ +ä \ No newline at end of file diff --git a/Programmierung2/src/oop/FileHandling/ByteKlassen/neues Bild.png b/Programmierung2/src/oop/FileHandling/ByteKlassen/neues Bild.png new file mode 100644 index 0000000..5096fe1 Binary files /dev/null and b/Programmierung2/src/oop/FileHandling/ByteKlassen/neues Bild.png differ diff --git a/Programmierung2/src/oop/FileHandling/FileHandling.java b/Programmierung2/src/oop/FileHandling/FileHandling.java new file mode 100644 index 0000000..5d2dea1 --- /dev/null +++ b/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. + */ + + +} diff --git a/Programmierung2/src/oop/FileHandling/FileKlasse.java b/Programmierung2/src/oop/FileHandling/FileKlasse.java new file mode 100644 index 0000000..8a9b86f --- /dev/null +++ b/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."); + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/FileTest.txt b/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/FileTest.txt new file mode 100644 index 0000000..c9d61dc Binary files /dev/null and b/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/FileTest.txt differ diff --git a/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/Test.java b/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/Test.java new file mode 100644 index 0000000..18b7212 --- /dev/null +++ b/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 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 multiobjekt = (ArrayList)readList.readObject(); + System.out.println(multiobjekt); + + + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/writeObjekt.java b/Programmierung2/src/oop/FileHandling/SerializationAndDeserialization/writeObjekt.java new file mode 100644 index 0000000..d5cbf51 --- /dev/null +++ b/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 + "]"; + } +} diff --git a/Programmierung2/src/oop/FileHandling/TestFolder/1.txt b/Programmierung2/src/oop/FileHandling/TestFolder/1.txt new file mode 100644 index 0000000..e69de29 diff --git a/Programmierung2/src/oop/FileHandling/TestFolder/2.txt b/Programmierung2/src/oop/FileHandling/TestFolder/2.txt new file mode 100644 index 0000000..e69de29 diff --git a/Programmierung2/src/oop/FileHandling/character/Bufferedreader.java b/Programmierung2/src/oop/FileHandling/character/Bufferedreader.java new file mode 100644 index 0000000..334ab95 --- /dev/null +++ b/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 + } + + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/character/Bufferedwriter.java b/Programmierung2/src/oop/FileHandling/character/Bufferedwriter.java new file mode 100644 index 0000000..bcfed73 --- /dev/null +++ b/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(); + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/character/Filereader.java b/Programmierung2/src/oop/FileHandling/character/Filereader.java new file mode 100644 index 0000000..c6aa85f --- /dev/null +++ b/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); + + + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/character/Filewriter.java b/Programmierung2/src/oop/FileHandling/character/Filewriter.java new file mode 100644 index 0000000..47471aa --- /dev/null +++ b/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(); + + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/character/OutPutStreamWriter.java b/Programmierung2/src/oop/FileHandling/character/OutPutStreamWriter.java new file mode 100644 index 0000000..2a868c6 --- /dev/null +++ b/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! + } + +} diff --git a/Programmierung2/src/oop/FileHandling/character/Printwriter.java b/Programmierung2/src/oop/FileHandling/character/Printwriter.java new file mode 100644 index 0000000..74b1b68 --- /dev/null +++ b/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); + + + } + +} diff --git a/Programmierung2/src/oop/FileHandling/character/Scannerklass.java b/Programmierung2/src/oop/FileHandling/character/Scannerklass.java new file mode 100644 index 0000000..be4ff4a --- /dev/null +++ b/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()); + } + +} diff --git a/Programmierung2/src/oop/FileHandling/character/Test1 b/Programmierung2/src/oop/FileHandling/character/Test1 new file mode 100644 index 0000000..e69de29 diff --git a/Programmierung2/src/oop/FinalKeyword/FinalKeywords.java b/Programmierung2/src/oop/FinalKeyword/FinalKeywords.java new file mode 100644 index 0000000..1795610 --- /dev/null +++ b/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. + * + */ + +} diff --git a/Programmierung2/src/oop/FinalKeyword/Student.java b/Programmierung2/src/oop/FinalKeyword/Student.java new file mode 100644 index 0000000..1974ded --- /dev/null +++ b/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 + "]"; + } + */ + + +} diff --git a/Programmierung2/src/oop/FinalKeyword/Test.java b/Programmierung2/src/oop/FinalKeyword/Test.java new file mode 100644 index 0000000..c549d9d --- /dev/null +++ b/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()); + } + +} diff --git a/Programmierung2/src/oop/Generics/AddMitarbeiter.java b/Programmierung2/src/oop/Generics/AddMitarbeiter.java new file mode 100644 index 0000000..3d24886 --- /dev/null +++ b/Programmierung2/src/oop/Generics/AddMitarbeiter.java @@ -0,0 +1,21 @@ +package oop.Generics; +import java.util.ArrayList; + + +public class AddMitarbeiter { + + ArrayList m1 = new ArrayList<>(); + + public ArrayList getM1() { + return m1; + } + + public void setM1(ArrayList m1) { + this.m1 = m1; + } + + @Override + public String toString() { + return "AddMitarbeiter [m1=" + m1 + "]"; + } +} diff --git a/Programmierung2/src/oop/Generics/DateTyps.java b/Programmierung2/src/oop/Generics/DateTyps.java new file mode 100644 index 0000000..7dde328 --- /dev/null +++ b/Programmierung2/src/oop/Generics/DateTyps.java @@ -0,0 +1,23 @@ +package oop.Generics; + +public class DateTyps { + + 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; + } + +} diff --git a/Programmierung2/src/oop/Generics/EinfachesBeispiel.java b/Programmierung2/src/oop/Generics/EinfachesBeispiel.java new file mode 100644 index 0000000..106440a --- /dev/null +++ b/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 void auslesenGenerics(obj[] array) { + + for (obj i : array) + System.out.print(i + " "); + } + +} diff --git a/Programmierung2/src/oop/Generics/Generics.java b/Programmierung2/src/oop/Generics/Generics.java new file mode 100644 index 0000000..30a4931 --- /dev/null +++ b/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) + * 2. Methoden: (public static void printArray(T[] array)) + * 3. Interfaces: (public interface Container) + */ + +} diff --git a/Programmierung2/src/oop/Generics/Mietarbeiter.java b/Programmierung2/src/oop/Generics/Mietarbeiter.java new file mode 100644 index 0000000..db912ce --- /dev/null +++ b/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 + "]"; + } + + + +} diff --git a/Programmierung2/src/oop/Generics/Test.java b/Programmierung2/src/oop/Generics/Test.java new file mode 100644 index 0000000..d7f8322 --- /dev/null +++ b/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 d1 = new DateTyps<>(); + + } + +} diff --git a/Programmierung2/src/oop/Interface/Auto.java b/Programmierung2/src/oop/Interface/Auto.java new file mode 100644 index 0000000..3e55fce --- /dev/null +++ b/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"); + } + + + + + +} diff --git a/Programmierung2/src/oop/Interface/Interface.java b/Programmierung2/src/oop/Interface/Interface.java new file mode 100644 index 0000000..1fe9531 --- /dev/null +++ b/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 + */ + +} diff --git a/Programmierung2/src/oop/Interface/Movable.java b/Programmierung2/src/oop/Interface/Movable.java new file mode 100644 index 0000000..6638ecf --- /dev/null +++ b/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"); + } + +} diff --git a/Programmierung2/src/oop/Interface/SelfDrivable.java b/Programmierung2/src/oop/Interface/SelfDrivable.java new file mode 100644 index 0000000..9237272 --- /dev/null +++ b/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 + } + +} diff --git a/Programmierung2/src/oop/Interface/Test.java b/Programmierung2/src/oop/Interface/Test.java new file mode 100644 index 0000000..93726d3 --- /dev/null +++ b/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(); + + } + +} diff --git a/Programmierung2/src/oop/Konstroktur/Konstroktur.java b/Programmierung2/src/oop/Konstroktur/Konstroktur.java new file mode 100644 index 0000000..11268ea --- /dev/null +++ b/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); + } + + +} diff --git a/Programmierung2/src/oop/Polymorphism/DailyMitarbeiter.java b/Programmierung2/src/oop/Polymorphism/DailyMitarbeiter.java new file mode 100644 index 0000000..aa24486 --- /dev/null +++ b/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; + } + + + + +} diff --git a/Programmierung2/src/oop/Polymorphism/GehaltMitarbeiter.java b/Programmierung2/src/oop/Polymorphism/GehaltMitarbeiter.java new file mode 100644 index 0000000..0b7b232 --- /dev/null +++ b/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 + + +} diff --git a/Programmierung2/src/oop/Polymorphism/HourlyMitarbeiter.java b/Programmierung2/src/oop/Polymorphism/HourlyMitarbeiter.java new file mode 100644 index 0000000..f05fc89 --- /dev/null +++ b/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; + } + + + +} diff --git a/Programmierung2/src/oop/Polymorphism/Mitarbeiter.java b/Programmierung2/src/oop/Polymorphism/Mitarbeiter.java new file mode 100644 index 0000000..b6c0052 --- /dev/null +++ b/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() {} + +} diff --git a/Programmierung2/src/oop/Polymorphism/Polymorphism.java b/Programmierung2/src/oop/Polymorphism/Polymorphism.java new file mode 100644 index 0000000..0cb614d --- /dev/null +++ b/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 + */ + + +} diff --git a/Programmierung2/src/oop/Polymorphism/Test.java b/Programmierung2/src/oop/Polymorphism/Test.java new file mode 100644 index 0000000..ff11872 --- /dev/null +++ b/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 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; + } + + +} diff --git a/Programmierung2/src/oop/Verebung/Verebung2.java b/Programmierung2/src/oop/Verebung/Verebung2.java new file mode 100644 index 0000000..36e97bb --- /dev/null +++ b/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; + } + +} diff --git a/Programmierung2/src/oop/Verebung/Verebung3.java b/Programmierung2/src/oop/Verebung/Verebung3.java new file mode 100644 index 0000000..e34d0ab --- /dev/null +++ b/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"); + } + +}