From e6f149e7f989fdfbf3182b0dc7623fe40b139953 Mon Sep 17 00:00:00 2001 From: andre Date: Sun, 23 Jun 2024 15:15:05 +0200 Subject: [PATCH] Erstellen --- PR1_Pflichtuebung6/.classpath | 10 + PR1_Pflichtuebung6/.project | 17 ++ .../org.eclipse.core.resources.prefs | 2 + .../.settings/org.eclipse.jdt.core.prefs | 14 ++ PR1_Pflichtuebung6/bin/.gitignore | 1 + PR1_Pflichtuebung6/src/ueb6/Packstation.java | 81 ++++++++ PR1_Pflichtuebung6/src/ueb6/Paket.java | 24 +++ PR1_Pflichtuebung6/src/ueb6/Rechner.java | 182 ++++++++++++++++++ PR1_Pflichtuebung6/src/ueb6/TestPacket.java | 42 ++++ 9 files changed, 373 insertions(+) create mode 100644 PR1_Pflichtuebung6/.classpath create mode 100644 PR1_Pflichtuebung6/.project create mode 100644 PR1_Pflichtuebung6/.settings/org.eclipse.core.resources.prefs create mode 100644 PR1_Pflichtuebung6/.settings/org.eclipse.jdt.core.prefs create mode 100644 PR1_Pflichtuebung6/bin/.gitignore create mode 100644 PR1_Pflichtuebung6/src/ueb6/Packstation.java create mode 100644 PR1_Pflichtuebung6/src/ueb6/Paket.java create mode 100644 PR1_Pflichtuebung6/src/ueb6/Rechner.java create mode 100644 PR1_Pflichtuebung6/src/ueb6/TestPacket.java diff --git a/PR1_Pflichtuebung6/.classpath b/PR1_Pflichtuebung6/.classpath new file mode 100644 index 0000000..ac9ce57 --- /dev/null +++ b/PR1_Pflichtuebung6/.classpath @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/PR1_Pflichtuebung6/.project b/PR1_Pflichtuebung6/.project new file mode 100644 index 0000000..755e257 --- /dev/null +++ b/PR1_Pflichtuebung6/.project @@ -0,0 +1,17 @@ + + + PR1_Pflichtuebung6 + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/PR1_Pflichtuebung6/.settings/org.eclipse.core.resources.prefs b/PR1_Pflichtuebung6/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000..4824b80 --- /dev/null +++ b/PR1_Pflichtuebung6/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +encoding/=UTF-8 diff --git a/PR1_Pflichtuebung6/.settings/org.eclipse.jdt.core.prefs b/PR1_Pflichtuebung6/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..dbc27c5 --- /dev/null +++ b/PR1_Pflichtuebung6/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,14 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=17 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=17 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=17 diff --git a/PR1_Pflichtuebung6/bin/.gitignore b/PR1_Pflichtuebung6/bin/.gitignore new file mode 100644 index 0000000..4eb0996 --- /dev/null +++ b/PR1_Pflichtuebung6/bin/.gitignore @@ -0,0 +1 @@ +/ueb6/ diff --git a/PR1_Pflichtuebung6/src/ueb6/Packstation.java b/PR1_Pflichtuebung6/src/ueb6/Packstation.java new file mode 100644 index 0000000..1453b4b --- /dev/null +++ b/PR1_Pflichtuebung6/src/ueb6/Packstation.java @@ -0,0 +1,81 @@ +package ueb6; + +import java.awt.Point; + +public class Packstation { + + /** + * Zweidimensionales Array zur Speicherung von Paketen, wobei jede Position + * im Array ein Fach in der Packstation repräsentiert. + */ + public Paket[][] station; + + /** + * Dieser Konstruktor legt eine Packstation mit benutzerdefinierter Größe an. + * @param breite: Die Anzahl an Fächern in der Breite der Packstation. + * @param hoehe: Die Anzahl an Fächern in der Höhe der Packstation. + */ + public Packstation(int breite, int hoehe) { + if (breite <= 0 || hoehe <= 0) { + throw new IllegalArgumentException("Breite und Höhe müssen größer als 0 sein."); + } + station = new Paket[breite][hoehe]; + } + + public Packstation() { + station = new Paket[5][4]; + } + + /** + * Legt ein Paket an einer freien Stelle in der Packstation ab und gibt die + Position zurück. + * @param paket: Das abzulegende Paket. + * @return Ein Point-Objekt, das die Position (Spalte, Reihe) enthält, an der das + Paket abgelegt wurde. Die kleinste Position für ein Paket ist x=0,y=0. + * @throws IllegalStateException Wenn kein Platz mehr in der Packstation ist. + */ + public Point legePaketAb(Paket paket) throws IllegalStateException { + throw new IllegalStateException("Kein Platz mehr in der Packstation."); + } + + /** + * Zählt die Anzahl der freien Boxen in der Packstation. + * @return Die Anzahl der freien Boxen als ganze Zahl. + */ + public int zaehleFreieBoxen() { + int count = 0; + + for(int i = 0; i < station.length; i++) { + for(int j = 0; j < station[0].length; j++) { + if (station[i][j] == null) + count++; + } + } + return count; + } + + + /** + * Liefert Informationen über den Empfänger und die Adresse des Pakets, das an der + angegebenen Position abgelegt ist, + * sofern die Box belegt ist. Andernfalls wird die Information zurückgegeben, dass + die Box leer ist. + * Falls die angegebene Box nicht existiert, wird eine IllegalArgumentException + Exception geworfen. + * @param spalte: Die Spalte der Box in der Packstation (beginnend bei 0). + * @param reihe: Die Reihe der Box in der Packstation (beginnend bei 0) . + * @return Ein String mit Informationen über den Empfänger und die Adresse des + Pakets oder die Nachricht "Die Box ist leer". + * @throws IllegalArgumentException Wenn die angegebene Box nicht existiert. + */ + public String informationZumBoxenplatz(int spalte, int reihe) throws IllegalArgumentException { + + String empfaenger = station[spalte][reihe].getEmpfaenger(); + String anschrift = station[spalte][reihe].getAnschrift(); + if (empfaenger == null && anschrift == null) { + throw new IllegalArgumentException("Die angegebene Box existiert nicht."); + } + + return empfaenger + "\n" + anschrift; + } +} diff --git a/PR1_Pflichtuebung6/src/ueb6/Paket.java b/PR1_Pflichtuebung6/src/ueb6/Paket.java new file mode 100644 index 0000000..d6fa612 --- /dev/null +++ b/PR1_Pflichtuebung6/src/ueb6/Paket.java @@ -0,0 +1,24 @@ +package ueb6; + +public class Paket { + + public String name; + public String adress; + + public Paket (String empfaenger, String adresse) { + name = empfaenger; + adress = adresse; + } + + public String getAnschrift() { + return adress; + } + + public String getEmpfaenger() { + return name; + } + + public String toString() { + return name + "\n" + adress; + } +} diff --git a/PR1_Pflichtuebung6/src/ueb6/Rechner.java b/PR1_Pflichtuebung6/src/ueb6/Rechner.java new file mode 100644 index 0000000..82e772e --- /dev/null +++ b/PR1_Pflichtuebung6/src/ueb6/Rechner.java @@ -0,0 +1,182 @@ +package ueb6; +import java.util.Scanner; + +public class Rechner { + public static void main(String[] args) { + String eingabe; + int ergebnis; + char c; + + while (true) { + Scanner input = new Scanner(System.in); + System.out.println("Welche Rechenart soll ausgeführt werden?"); + System.out.println("[ Multiplikation | Division | Exponent | Fakultät ]"); + System.out.println("[ m | d | e | f ]"); + System.out.print("Geben Sie das zugehörige Zeichen ein: "); + + eingabe = input.nextLine(); + + ergebnis = 0; + + if (eingabe.length() == 1) { + c = eingabe.charAt(0); + ergebnis = berechnung(c); + } else { + System.out.println("Fehler! Bitte nur eins der angegebenen Buchstaben eingeben!"); + } + System.out.println("Ergebnis der gewählten Berechnung: " + ergebnis); + System.out.println(); + input.close(); + } + } + + /** + * Führt die ausgewählte Berechnung basierend auf dem übergebenen Zeichen aus. + * @param c Das Zeichen, das die gewünschte Berechnung angibt + * ('m' für Multiplikation, 'd' für Division, 'e' für Exponentialfunktion, 'f' für + * Fakultät) + * @return Das Ergebnis der Berechnung oder -1 bei fehlerhafter Eingabe + */ + public static int berechnung(char c) { + int ergebnis = 0; + Scanner zahl = new Scanner(System.in); + + if (c == 'm') { + try { + System.out.print("Erster Faktor: "); + int faktor1 = zahl.nextInt(); + System.out.print("Zweiter Faktor: "); + int faktor2 = zahl.nextInt(); + ergebnis = multiplizieren(faktor1, faktor2); + } catch (IllegalArgumentException e) { + System.out.println("Fehler! Keine der Zahlen darf negativ sein!"); + ergebnis = -1; + } + } else if (c == 'd') { + try { + System.out.print("Dividend: "); + int dividend = zahl.nextInt(); + System.out.print("Divisor: "); + int divisor = zahl.nextInt(); + ergebnis = dividieren(dividend, divisor); + } catch (IllegalArgumentException e) { + System.out.println("Fehler! Keine der Zahlen darf negativ sein!"); + ergebnis = -1; + } catch (ArithmeticException e) { + System.out.println("Fehler! Der Divisor darf nicht 0 sein!"); + ergebnis = -1; + } + } else if (c == 'e') { + try { + System.out.print("Grundwert: "); + int grundwert = zahl.nextInt(); + System.out.print("Exponent: "); + int exponent = zahl.nextInt(); + ergebnis = exponent(grundwert, exponent); + } catch (IllegalArgumentException e) { + System.out.println("Fehler! Keine der Zahlen darf negativ sein!"); + ergebnis = -1; + } + } else if (c == 'f') { + try { + System.out.print("Zahl: "); + int n = zahl.nextInt(); + ergebnis = fakultaet(n); + } catch (IllegalArgumentException e) { + System.out.println("Fehler! Die Zahl darf nicht negativ sein!"); + ergebnis = -1; + } + } else { + ergebnis = -1; + } + zahl.close(); + return ergebnis; + } + + /** + * Berechnet rekursiv das Produkt von zwei ganzen positiven Zahlen. + * @param faktor1 Der erste Faktor + * @param faktor2 Der zweite Faktor + * @return Das Produkt der beiden Faktoren + * @throws IllegalArgumentException Wenn einer der Faktoren negativ ist + */ + public static int multiplizieren(int faktor1, int faktor2) throws IllegalArgumentException { + if(faktor1 < 0 || faktor2 < 0) + throw new IllegalArgumentException(); + if(faktor1 == 1) + return faktor2; + else if(faktor2 == 1) + return faktor1; + else { + return multiplizieren(faktor1, faktor2-1) + faktor1; + } + } + + /** + * Berechnet rekursiv den Quotienten von zwei ganzen positiven Zahlen. + * @param dividend Der Dividend + * @param divisor Der Divisor + * @return Der Quotient der beiden Zahlen + * @throws IllegalArgumentException Wenn einer der Werte negativ ist + * @throws ArithmeticException Wenn der Divisor 0 ist + * */ + public static int dividieren(int divident, int divisor) throws IllegalArgumentException, ArithmeticException { + int ergebnis = 0; + + if(divident < 0 || divisor < 0) + throw new IllegalArgumentException(); + if (divisor == 0) + throw new ArithmeticException(); + if(divisor == 1) + return divident; + else if (divisor > divident) + return 0; + else if (divident == divisor) + return 1; + else { + while(divident >= divisor) { + divident -= divisor; + ergebnis += 1; + } + return ergebnis; + } + } + + /** + * Berechnet rekursiv die Potenz, mit gegebenem positiven ganzen Grundwert und + * Exponenten. + * @param grundwert Die Basis + * @param exponent Der Exponent der Basis + * @return Das Ergebnis der Potenzierung + * @throws IllegalArgumentException Wenn einer der Werte negativ ist + */ + public static int exponent(int grundwert, int exponent) { + if(grundwert < 0 || exponent < 0) + throw new IllegalArgumentException(); + if (exponent == 0) + return 1; + if(grundwert == 1) + return grundwert; + else if(exponent == 1) + return grundwert; + else { + return exponent(grundwert, exponent-1) * grundwert; + } + } + + /** + * Berechnet rekursiv die Fakultät einer ganzen positiven Zahl. + * @param n Die Zahl, deren Fakultät berechnet werden soll + * @return Die Fakultät der Zahl + * @throws IllegalArgumentException Wenn die Zahl negativ ist + */ + public static int fakultaet(int n) throws IllegalArgumentException { + if (n < 0) + throw new IllegalArgumentException(); + if (n == 0 || n == 1) + return 1; + else { + return fakultaet(n-1) * n; + } + } +} \ No newline at end of file diff --git a/PR1_Pflichtuebung6/src/ueb6/TestPacket.java b/PR1_Pflichtuebung6/src/ueb6/TestPacket.java new file mode 100644 index 0000000..1eee5cc --- /dev/null +++ b/PR1_Pflichtuebung6/src/ueb6/TestPacket.java @@ -0,0 +1,42 @@ +package ueb6; + +public class TestPacket { + + public static void main(String[] args) { + Paket Fry = new Paket("Philip J. Fry", "Frystreet 1\nNew New York\nUSA"); + Paket Leela = new Paket("Turanga Leela", "Lilaweg 69\nNew New York\nUSA"); + Paket Bender = new Paket("Bender Rodriguez", "Biegeallee 420\nTijuana\nMexico"); + + Packstation Test = new Packstation(2, 2); + + + System.out.println("Empfänger des 1. Pakets ist: " + Fry.getEmpfaenger()); + System.out.println("Adresse des 1. Pakets ist: " + Fry.getAnschrift()); + System.out.println("Empfänger des 2. Pakets ist: " + Leela.getEmpfaenger()); + System.out.println("Adresse des 2. Pakets ist: " + Leela.getAnschrift()); + System.out.println("Empfänger des 3. Pakets ist: " + Bender.getEmpfaenger()); + System.out.println("Adresse des 3. Pakets ist: " + Bender.getAnschrift()); + System.out.println(); + System.out.println(Fry.toString()); + System.out.println(); + System.out.println(Leela.toString()); + System.out.println(); + System.out.println(Bender.toString()); + System.out.println(); + + try { + Test.legePaketAb(Fry); + } catch (IllegalStateException e) { + System.out.println("Es existiert keine freier Platz mehr."); + } + int freiePlaetze = Test.zaehleFreieBoxen(); + System.out.println("Es gibt " + freiePlaetze + " freie Plätze."); + System.out.println(); + try { + String info = Test.informationZumBoxenplatz(1, 1); + System.out.println("Empfängerinformationen für Platz: " + info); + } catch (IllegalArgumentException e) { + System.out.println("Die angegebene Box existiert nicht."); + } + } +}