diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/.gitignore b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/.gitignore new file mode 100644 index 0000000..661d056 --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/.gitignore @@ -0,0 +1,6 @@ +*.sh +*.class +*.ctxt +repo.adoc +repo_subtree.adoc +/alt diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/.gitignore b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/.gitignore new file mode 100644 index 0000000..661d056 --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/.gitignore @@ -0,0 +1,6 @@ +*.sh +*.class +*.ctxt +repo.adoc +repo_subtree.adoc +/alt diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Aufgabe.java b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Aufgabe.java new file mode 100644 index 0000000..ce8379b --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Aufgabe.java @@ -0,0 +1,113 @@ +import java.util.*; +import java.time.*; + +/** + * Verschiedene Aufgaben, die statisch direkt aus BlueJ heraus aufgerufen werden. + * + * @author S.Gebert + * @version 12.2020 + */ +public class Aufgabe +{ + + /** + * Aufgabe.a1 + * Schreibe eine Methode, die für das erste Element einer gegebene Filmsammlung (von Serien) die Bewertung auf 5.0 setzt + * und + * den Titel und die Anzahl der vorhandenen Episoden auf der Konsole ausgibt. + * + * Hinweise: - Betrachte die Dokumentation der Klasse Filmsammlung. Mit welcher Methode kannst du auf die Elemente der Sammlung zugreifen? + * - Prüfe an welcher Stelle eine Typkonvertierung nötig ist. + * + * Teste deine Methode mit der Filmsammlung s und kf (Basis - Objektzustand wiederherstellen) + * + * @param fs Eine Filmsammlung + */ + public static void a1(Filmsammlung fs) + { + + } + + /** + * Aufgabe.a2 + * Schreibe eine Methode, die für das zweite Element einer gegebene Filmsammlung (von Serien) die Bewertung auf 5.0 setzt + * und + * den Titel und die Anzahl der vorhandenen Episoden auf der Konsole ausgibt. + * + * Teste deine Methode mit der Filmsammlung s und kf (Basis - Objektzustand wiederherstellen) + * + * @param fsG Eine Seriensammlung + */ + public static void a2(FilmsammlungGeneric fsG) + { + + } + + /** + * Aufgabe.a3 + * Erstelle verschieden Filmsammlungen und teste deren Methoden. + * Um einzelne Filme zu erhalten kannst die Methoden Daten.randomFilm(), Daten.randomKinofilm(), Daten.randomSerie() und Daten.randomEpisode() verwenden. + * + * - Welche konkreten Typparameter sind erlaubt, welche nicht? + * - Finde Beispiele für die es zu Compilierungs/Laufzeitfehlern kommen kann. + */ + public static void a3() + { + //Beispiel + FilmsammlungGeneric sammlung1 = new FilmsammlungGeneric<>( new SerienEpisode[]{Daten.randomEpisode(), Daten.randomEpisode() }); + System.out.println(sammlung1.get(0).getTitel()); + + //Weitere Beispiele + + } + + /** + * Aufgabe.a4 + * Die gegebene Methode soll die Titel aller Filme in einer Filmsammlung ausgeben. + * Teste die gegebene Methode mit den Basisdaten sG und kfG. + * + * - Notiere dir den Laufzeitfehler den du erhälst. + * - Ändere die Methode so ab, dass es mit sG bzw. kfG funktioniert. Gibt es eine allgemeine Lösung? + * @param fsG Eine Filmsammlung + */ + public static void a4(FilmsammlungGeneric fsG) + { + Iterator iter = fsG.iterator(); + + while( iter.hasNext() ){ + System.out.print( iter.next().getTitel() +", "); + } + + } + + /** + * Aufgabe.a5 + * Die gegebene Methode soll die Titel aller Filme in einer Filmsammlung von Kinofilmen ausgeben. + * Implementiere die Methode mit der erweiterten for-Schleife + * Teste mit den Basisdaten kfG. + * + * @param fsG Eine Filmsammlung + */ + public static void a5(FilmsammlungGeneric fsG) + { + + } + + /** + * Aufgabe.a6 + * Finde für jede gegebene Reihung jeweils das Minimum. + * Schreibe dafür je eine private statische Methode und rufe diese auf. + * Gib das Ergebnis auf der Konsole aus. + * + */ + public static void a6() + { + //Gegebene Reihungen + Integer[] rInt = {5, 90, 4, 1, -70, 400, 30}; + String[] rString = {"Bär","Affe","Nilpferd","Zebra"}; + Float[] rFloat = {3.4f, 9.78f,.01f}; + + //Aufruf + + } +} diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Basis.java b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Basis.java new file mode 100644 index 0000000..6d40263 --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Basis.java @@ -0,0 +1,52 @@ + + +import static org.junit.Assert.*; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** + * Ausgangsbasis für Operationen in der Direkteigabe. + * + * @author S.Gebert + * @version 12.2020 + */ +public class Basis +{ + Filmsammlung f; + Filmsammlung kf; + Filmsammlung s; + FilmsammlungGeneric kfG; + FilmsammlungGeneric sG; + + /** + * Konstruktor fuer die Test-Klasse ProjektTest + */ + public Basis() + { + } + + /** + * Setzt das Testgerüst fuer den Test. + * + * Wird vor jeder Testfall-Methode aufgerufen. + */ + @Before + public void setUp() + { + kf = new Filmsammlung( Daten.kinofilme().values() ); + s = new Filmsammlung( Daten.serien().values() ); + kfG = new FilmsammlungGeneric( Daten.kinofilme().values() ); + sG = new FilmsammlungGeneric( Daten.serien().values() ); + } + + /** + * Gibt das Testgerüst wieder frei. + * + * Wird nach jeder Testfall-Methode aufgerufen. + */ + @After + public void tearDown() + { + } +} diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Daten.java b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Daten.java new file mode 100644 index 0000000..b63230b --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Daten.java @@ -0,0 +1,64 @@ +import java.util.*; +import java.time.*; + +/** + * Stellt statische Methoden zur Verfügung, welche Testdaten zur Nutzung im Projekt bereitstellen. + * + * @author S.Gebert + * @version 12.2020 + */ +public class Daten +{ + static HashMap kinofilme() + { + HashMap filme = new HashMap<>(); + + filme.put("f1", new Kinofilm( "The Terminator", Year.of(1984), "Sci-Fi", 107, 16, 8.0 )); + filme.put("f2", new Kinofilm( "Terminator 2", Year.of(1991), "Sci-Fi", 137, 16, 8.5 )); + filme.put("f3", new Kinofilm( "Terminator 3", Year.of(2003), "Sci-Fi", 109, 16, 6.3 )); + filme.put("f4", new Kinofilm( "Terminator Salvation", Year.of(2009), "Sci-Fi", 115, 16, 6.5 )); + filme.put("f5", new Kinofilm( "Terminator Genisys", Year.of(2015), "Sci-Fi", 126, 12, 6.3 )); + filme.put("f6", new Kinofilm( "Terminator: Dark Fate", Year.of(2019), "Sci-Fi", 128, 16, 6.2 )); + filme.put("f7", new Kinofilm( "Forest Gump", Year.of(2019), "Satire", 142, 12, 8.2)); + filme.put("f8", new Kinofilm( "Die Känguru-Chroniken", Year.of(2020), "Komödie", 92, 0, 5.4 )); + + return filme; + } + + static HashMap serien() + { + HashMap filme = new HashMap<>(); + Serie s1 = new Serie( "Terminator: The Sarah Connor Chronicles", Year.of(2008), "Sci-Fi", 16 ); + filme.put("s1", s1); + SerienEpisode e1 = new SerienEpisode( "Pilot", null, "Drama", 46, 7.8, s1, 1, 1 ); + SerienEpisode e2 = new SerienEpisode( "Dungeons & Dragons", null, "Action", 44, 7.0, s1, 1, 6 ); + Serie s2 = new Serie( "The Big Bang Theory", Year.of(2007), "Komödie", 6 ); + filme.put("s2", s2); + SerienEpisode e3 = new SerienEpisode( "The Middle Earth Paradigm", Year.of(2009), "Komödie", 21, 8.5, s2, 1, 6 ); + SerienEpisode e4 = new SerienEpisode( "The Stockholm Syndrome", Year.of(2019), "Komödie", 23, 9.6, s2, 12, 24 ); + + return filme; + } + + static Serie randomSerie() + { + return serien().values().stream().skip( new Random().nextInt(serien().size())).findFirst().get(); + } + + static Kinofilm randomKinofilm() + { + return kinofilme().values().stream().skip( new Random().nextInt(serien().size())).findFirst().get(); + } + + static Film randomFilm() + { + if( Math.random() > 0.5 ) return randomSerie(); + return randomKinofilm(); + } + + static SerienEpisode randomEpisode() + { + Serie e = randomSerie(); + return (SerienEpisode) e.getEpisoden().get( (int)Math.round((e.getAnzahlEpisoden()-1) * Math.random())); + } +} diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Film.java b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Film.java new file mode 100644 index 0000000..45506bd --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Film.java @@ -0,0 +1,133 @@ + import java.time.*; + +/** + * Ein Film, wie er z.B. in der www.imdb.com oder moviepilot.de eingetragen sein könnte. + * + * @author S.Gebert + * @version 12.2020 + */ +public abstract class Film +{ + /** + * Mögliche Filmtypen + * {@link #KINOFILM} + * {@link #SERIE} + * {@link #EPISODE} + */ + public static enum FilmTyp { + /** + * Ein Kinofilm + */ + KINOFILM, + /** + * Eine Serie + */ + SERIE, + /** + * Eine Episode einer Serie + */ + EPISODE + } + + /** + * Der Filmtyp des Films + */ + protected FilmTyp typ; + + /** + * Der Filmtitel + */ + private String titel; + /** + * Das Produktionsjahr + */ + private Year produktionsjahr; // Year implementiert Comparable + /** + * Das Genre. Bei mehreren möglichen Genre, dasjenige in das der Film am besten passt. + */ + private String genre; + /** + * Die Laufzeit in Minuten + */ + private int laufzeit; + /** + * Die Altersfreigabe in Jahren + */ + private int altersfreigabe; + /** + * Eine Bewertung. Von unterirdisch 0.0 bis 10.0 göttlich + */ + private double bewertung; // von 0.0 bis 10.0 + + /** + * Erzeugt einen Film + * + * @param titel Filmtitel + * @param produktionsjahr Das Produktionsjahr + * @param genre Hauptgenre + * @param laufzeit Laufzeit in Minuten + * @param altersfreigabe Altersfreigabe in Jahren + */ + public Film(String titel, Year produktionsjahr, String genre, int laufzeit, int altersfreigabe) + { + this.titel = titel; + this.produktionsjahr = produktionsjahr; + this.genre = genre; + this.laufzeit = laufzeit; + this.altersfreigabe = altersfreigabe; + } + + /** + * Erzeugt einen Film + * + * @param titel Filmtitel + * @param produktionsjahr Das Produktionsjahr + * @param genre Hauptgenre + * @param laufzeit Laufzeit in Minuten + * @param altersfreigabe Altersfreigabe in Jahren + * @param bewertung Bewertung (0.0 bis 10.0) + */ + public Film(String titel, Year produktionsjahr, String genre, int laufzeit, int altersfreigabe, double bewertung) + { + this.titel = titel; + this.produktionsjahr = produktionsjahr; + this.genre = genre; + this.laufzeit = laufzeit; + this.altersfreigabe = altersfreigabe; + this.bewertung = bewertung; + } + + /** + * Setter für Bewertung + * + * @param bewertung Bewertung (0.0 bis 10.0) + */ + public void setBewertung( double bewertung ) + { + if( this.bewertung == bewertung ) return; + if( Settings.VERBOSE == Settings.V_LEVEL.INFO ) System.out.println("Bisherige Bewertung ("+this.bewertung+") von '" + this.getTitel() + "' nach "+ bewertung +" geändert."); + this.bewertung = bewertung; + + } + + /** + * Getter für Bewertung + * + * @return Die Bewertung (0.0 bis 10.0) + */ + public double getBewertung() + { + return this.bewertung; + } + + /** + * Getter für Titel + * + * @return Der Filmtitel + */ + public String getTitel() + { + return this.titel; + } + +} diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Filmsammlung.java b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Filmsammlung.java new file mode 100644 index 0000000..408b19a --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Filmsammlung.java @@ -0,0 +1,173 @@ +import java.util.*; + +/** + * Eine Filmsammlung. + * Einfache Implementierung auf einer Reihung festgelegter Größe. + * + * @author S.Gebert + * @version 12.2020 + */ +public class Filmsammlung +{ + + /** + * Die der Sammlung zugrundegelegte Reihung. + */ + private Film[] sammlung; + /** + * Die Anzahl Filme in der Sammlung. + * Diese muss nicht der Länge der zugrundegelegten Reihung entsprechen. In dieser können sich auch null-Werte befinden. + */ + private int anzahlFilme = 0; + + /** + * Erstellt eine leere Filmsammlung. + * + * @param laenge Die maximale Anzahl Filme in der Filmsammlung + */ + public Filmsammlung(int laenge) + { + this.sammlung = new Film[laenge]; + } + + /** + * Erstellt eine Filmsammlung und füllt diese mit gegebenen Filmen. + * + * @param sammlung Ein Reihung aller Filme welche in die Filmsammlung aufgenommen werden sollen. + */ + public Filmsammlung(Film[] sammlung) + { + this.sammlung = sammlung; + this.anzahlFilme = sammlung.length; //Annahme, dass keine Null-Werte in sammlung + } + + /** + * Erstellt eine Filmsammlung und füllt diese mit gegebenen Filmen. + * + * @param sammlung Ein Sammlung aller Filme welche in die Filmsammlung aufgenommen werden sollen. + */ + public Filmsammlung(Collection sammlung) + { + this.sammlung = sammlung.toArray(new Film[0]); + this.anzahlFilme = this.sammlung.length; //Annahme, dass keine Null-Werte in sammlung + } + /** + * Fügt den gegebenen Film an die gegebene Position in der Sammlung ein. + * Falls sich an der Position bereits ein Film befindet, wird dieser überschrieben. + * + * @param index Die Position in der Sammlung an der der Film eingefügt werden soll + * @param film Film der in die Sammlung eingefügt werden soll + */ + public void add( int index, Film film ) + { + /* TODO: Bounds Check + * Stelle sicher, dass sich der Wert der Parametervariable index + * im zulässigen Bereich befindet. + */ + sammlung[index] = film; + /* TODO: Korrekte Filmanzahl + * Stelle sicher, dass sich die Filmzahl nur dann ändert, + * falls an der Position zuvor kein anderer Film war. + */ + this.anzahlFilme++; + } + + /** + * Fügt den gegebenen Film ans Ende der Sammlung ein. + * Falls kein Platz mehr frei ist, wird der Film nicht in die Sammlung aufgenommen. + * + * @param film Film der in die Sammlung eingefügt werden soll + */ + public void add( Film film ) + { + for( int i = 0; i < this.sammlung.length; i ++ ){ + if( this.sammlung[i] == null ){ + add(i, film); + return; + } + } + } + + /** + * Entfernt einen Film an der angegeben Position aus der Filmsammlung. + * Die Position bleibt danach leer. + * + * @param index Die Position in der Filmsammlung aus der der Film entfernt werden soll + * @return Der Film, der aus der Sammlung entfernt wurde + */ + public Film remove( int index ) + { + /* TODO: Bounds Check + * Stelle sicher, dass sich der Wert der Parametervariable index + * im zulässigen Bereich befindet. + */ + Film f = sammlung[index]; + sammlung[index] = null; + /* TODO: Korrekte Filmanzahl + * Stelle sicher, dass die Anzahl nur verringert wird, + * falls zuvor ein Film an der Position war. + */ + this.anzahlFilme--; + return f; + } + + /** + * Gibt den Film an der angegeben Position in der Sammlung zurück + * + * @param index Die Position in der Filmsammlung an der sich der zurückzugebende Film befindet + * @return Der Film an der angegebenen Position + */ + public Film get( int index ) + { + /* TODO: Bounds Check + * Stelle sicher, dass sich der Wert der Parametervariable index + * im zulässigen Bereich befindet. + */ + return sammlung[index]; + } + + /** + * Sucht einen Film anhand dessen Titels und gibt die Position in der Sammlung zurück. + * Konnte der Film nicht gefunden werden, wird -1 zurück gegeben. + * + * @param titel Der Titel des gesuchten Films + * @return Die Position des gesuchten Films + */ + public int find( String titel ) + { + /* TODO: Suche + * Implementiere eine einfache sequentielle bzw. lineare Suche + */ + return 0; + } + + /** + * Gibt die Anzahl Filme in der Sammlung zurück + * + * @return Die Anzahl Filme in der Sammlung + */ + public int anzahlFilme() + { + return this.anzahlFilme; + } + + /** + * Bestimmt die durchschnittliche Bewertung aller Filme aus der Sammlung. + * + * @return Die durchschnittle Bewertung aller Filme aus der Sammlung + */ + public double getBewertung( ) + { + double sum = 0.0; + int num = 0; + + for( int i = 0; i < this.sammlung.length; i++ ){ + if( this.sammlung[i] != null ){ + sum += this.sammlung[i].getBewertung(); + num ++; + } + } + + return Math.round(sum/num * 10.0) / 10.0; //auf eine Nachkommastelle runden. + } +} diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/FilmsammlungGeneric.java b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/FilmsammlungGeneric.java new file mode 100644 index 0000000..f8239be --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/FilmsammlungGeneric.java @@ -0,0 +1,94 @@ +import java.util.*; + +/** + * Eine Filmsammlung. + * Generische Implementierung auf Basis einer ArrayList + * + * @author S.Gebert + * @version 12.2020 + */ +public class FilmsammlungGeneric extends ArrayList +//public class FilmsammlungGeneric extends ArrayList +{ + + /** + * Erstellt eine leere Filmsammlung. + * + * @param laenge Die Anzahl Filme, welche zu Beginn in die Filmsammlung passen. + */ + public FilmsammlungGeneric(int laenge) + { + super(laenge); + } + + /** + * Erstellt eine Filmsammlung und füllt diese mit gegebenen Filmen. + * + * @param sammlung Ein Reihung aller Filme welche in die Filmsammlung aufgenommen werden sollen. + */ + public FilmsammlungGeneric(E[] sammlung) + { + super( Arrays.asList(sammlung) ); + } + + /** + * Erstellt eine Filmsammlung und füllt diese mit gegebenen Filmen. + * + * @param sammlung Ein Sammlung aller Filme welche in die Filmsammlung aufgenommen werden sollen. + */ + public FilmsammlungGeneric(Collection c) + { + super(c); + } + + /** + * Sucht einen Film anhand dessen Titels und gibt die Position in der Sammlung zurück. + * Konnte der Film nicht gefunden werden, wird -1 zurück gegeben. + * + * @param titel Der Titel des gesuchten Films + * @return Die Position des gesuchten Films + */ + public int find( String titel ) + { + /* TODO: Suche + * Implementiere eine einfache sequentielle bzw. lineare Suche + * z.B. mit einem Lambdaausdruck + */ + return 0; + } + + /** + * Gibt die Anzahl Filme in der Sammlung zurück + * + * @return Die Anzahl Filme in der Sammlung + */ + public int anzahlFilme() + { + return this.size(); + } + + + /** + * Bestimmt die durchschnittliche Bewertung aller Filme aus der Sammlung. + * + * @return Die durchschnittle Bewertung aller Filme aus der Sammlung + */ + // public double getBewertung( ) + // { + // double sum = 0.0; + // int num = 0; + + // /* TODO: Alternative Implementierung + // * Nutze statt der erweiterten For-Schleife einen Lambdaausdruck. + // */ + + // for( E e: this ){ + // if( e != null ){ + // sum += e.getBewertung(); + // num ++; + // } + // } + + // return Math.round(sum/num * 10.0) / 10.0; //auf eine Nachkommastelle runden. + // } +} diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Kinofilm.java b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Kinofilm.java new file mode 100644 index 0000000..b43920c --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Kinofilm.java @@ -0,0 +1,40 @@ +import java.time.*; +/** + * Ein Kinofilm. + * + * @author S.Gebert + * @version 12.2020 + */ +public class Kinofilm extends Film +{ + /** + * Konstruktor für Objekte der Klasse Kinofilm + * + * @param titel Filmtitel + * @param produktionsjahr Das Produktionsjahr + * @param genre Hauptgenre + * @param laufzeit Laufzeit in Minuten + * @param altersfreigabe Altersfreigabe in Jahren + * @param bewertung Bewertung (0.0 bis 10.0) + */ + public Kinofilm(String titel, Year produktionsjahr, String genre, int laufzeit, int altersfreigabe, double bewertung) + { + super(titel, produktionsjahr, genre, laufzeit, altersfreigabe, bewertung); + this.typ = FilmTyp.KINOFILM; + } + + /** + * Konstruktor für Objekte der Klasse Kinofilm + * + * @param titel Filmtitel + * @param produktionsjahr Das Produktionsjahr + * @param genre Hauptgenre + * @param laufzeit Laufzeit in Minuten + * @param altersfreigabe Altersfreigabe in Jahren + */ + public Kinofilm(String titel, Year produktionsjahr, String genre, int laufzeit, int altersfreigabe) + { + super(titel, produktionsjahr, genre, laufzeit, altersfreigabe); + this.typ = FilmTyp.KINOFILM; + } +} diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/README.TXT b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/README.TXT new file mode 100644 index 0000000..0f7f32d --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/README.TXT @@ -0,0 +1,8 @@ +PROJEKTBEZEICHNUNG: Filmsammlung +PROJEKTZWECK: Einführung in generische Datentypen, Sammlungen und Iteration über Elemente einer Sammlung z.B.über die erweiterte For-Schleife und Lambdaausdrücke +VERSION oder DATUM: 02.2021 +WIE IST DAS PROJEKT ZU STARTEN: Das Projekt wird über die Direkteingabe in BlueJ gesteuert. +AUTOR(EN): S.Gebert +BENUTZERHINWEISE: Mit der Unit-Test Klasse "Basis" kann ein Objektzustand als Ausgangsbasis vorgegeben werden. Auf dieser wird dann über die Direkteingabe operiert. + In der Klasse "Aufgaben" werden statische Methoden pro Aufgabe definiert, welche über die Direkteingabe aufgerufen werden. + Beispielaufgaben finden sich im Begleitmaterial. diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Serie.java b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Serie.java new file mode 100644 index 0000000..ff4326c --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Serie.java @@ -0,0 +1,98 @@ +import java.time.*; + +/** + * Eine Serie. + * + * @author S.Gebert + * @version 12.2020 + */ +public class Serie extends Film +{ + /** + * Die Anzahl Staffeln der Serie + */ + private int anzahlStaffeln; + /** + * Enthält alle Episoden der Serie + */ + private Filmsammlung episoden; + /* TODO: Typsicherheit garantieren + * Nutze statt des Typs Filmsammlung den generischen Typ FilmsammlungGeneric + * und schreibe den Code dieser Klasse entsprechend um. + */ + + /** + * Erzeugt eine Serie + * + * @param titel Filmtitel + * @param produktionsjahr Das Produktionsjahr + * @param genre Hauptgenre + * @param altersfreigabe Altersfreigabe in Jahren + */ + public Serie(String titel, Year produktionsjahr, String genre, int altersfreigabe) + { + super(titel, produktionsjahr, genre, -1, altersfreigabe); + this.typ = FilmTyp.SERIE; + this.episoden = new Filmsammlung(20); + } + + /** + * Gibt die Anzahl aller Episoden der Serie zurück. + * + * @return Die Anzahl Episoden der Serie + */ + public int getAnzahlEpisoden( ) + { + return this.episoden.anzahlFilme(); + } + + /** + * Fügt der Serie eine Episode hinzu. + * + * @param episode Die einzufügende Episode + */ + public void addEpisode( SerienEpisode episode ) + { + this.episoden.add( episode ); + } + + /** + * Gibt die Episoden der Serie als Filmsammlung zurück + * + * @return Die Episoden der Serie als Filmsammlung + */ + public Filmsammlung getEpisoden() + { + /* TODO: Typsicherheit garantieren + * s.o. + */ + return this.episoden; + } + + /** + * Gibt die Bewertung der Serie zurück. + * Diese berechnet sich aus dem Mittelwert aller enthaltenen Episoden. + * + * @return Die mittlere Bewertung aller Episoden (0.0 bis 10.0) + */ + @Override + public double getBewertung( ) + { + super.setBewertung( this.episoden.getBewertung() ); + return super.getBewertung(); + } + + /** + * Legt die Bewertung der Serie fest. + * Da die Bewertung automatisch aus den einzelnen Episoden berechnet wird, wird nichts getan. + * + * @param bewertung Bewertung (0.0 bis 10.0) + */ + @Override + public void setBewertung( double bewertung ) + { + if( Settings.VERBOSE == Settings.V_LEVEL.INFO ) System.out.println("Bewertung nicht geändert, da sich die Bewertung aus den Bewertungen der Episoden berechnet."); + //Nichts tun, da die Bewertung aus der Bewertung der Episoden berechnet wird. + return; + } +} diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/SerienEpisode.java b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/SerienEpisode.java new file mode 100644 index 0000000..8e7627d --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/SerienEpisode.java @@ -0,0 +1,70 @@ +import java.util.*; +import java.time.*; + +/** + * Eine Episode einer Serie + * + * @author S.Gebert + * @version 12.2020 + */ +public class SerienEpisode extends Film +{ + /** + * Die Serie zu der die Episode gehört + */ + private Serie serie; + /** + * Die Nummer der Episode innerhalb der Serie + */ + private int episode; + /** + * Die Nummer der Staffel zu der die Episode gehört + */ + private int staffel; + + /** + * Erzeugt eine Episode einer Serie + * + * @param titel Filmtitel + * @param produktionsjahr Das Produktionsjahr + * @param genre Hauptgenre + * @param laufzeit Laufzeit in Minuten + * @param bewertung Bewertung (0.0 bis 10.0) + * @param serie Zugehörige Serie + * @param staffel Nummer der Staffel + * @param episode Nummer der Episode + */ + public SerienEpisode(String titel, Year produktionsjahr, String genre, int laufzeit, double bewertung, Serie serie, int staffel, int episode ) + { + super(titel, produktionsjahr, genre, laufzeit, -1, bewertung); + this.typ = FilmTyp.EPISODE; + this.serie = serie; + this.serie.addEpisode(this); + this.staffel = staffel; + this.episode = episode; + } + + /** + * Erzeugt eine Episode einer Serie + * + * @param titel Filmtitel + * @param produktionsjahr Das Produktionsjahr + * @param genre Hauptgenre + * @param laufzeit Laufzeit in Minuten + * @param serie Zugehörige Serie + * @param staffel Nummer der Staffel + * @param episode Nummer der Episode + */ + public SerienEpisode(String titel, Year produktionsjahr, String genre, int laufzeit, Serie serie, int staffel, int episode ) + { + super(titel, produktionsjahr, genre, laufzeit, -1); + this.typ = FilmTyp.EPISODE; + this.serie = serie; + this.staffel = staffel; + this.episode = episode; + } + + /* TODO: Getter + * Schreibe Getter für die privaten Attribute und dokumentiere diese. + */ +} diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Settings.java b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Settings.java new file mode 100644 index 0000000..75403be --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Settings.java @@ -0,0 +1,41 @@ + +/** + * Globale Einstellungen des Projekts + * + * @author S.Gebert + * @version 12.2020 + */ +public class Settings +{ + /** + * Verbosität + * {@link #NONE} + * {@link #INFO} + * {@link #DEBUG} + * {@link #ALL} + */ + static enum V_LEVEL { + /** + * Keine Ausgaben in der Konsole + */ + NONE, + /** + * Auf der Konsole werden Informationen für den Nutzer ausgegeben. + */ + INFO, + /** + * Auf der Konsole werden Informationen für den Programmierer ausgegeben. + */ + DEBUG, + /** + * Alle verfügbaren Informationen werden auf der Konsole ausgegeben. + */ + ALL + } + + /** + * Die Verbosität des Programms. + * Im Code kann diese überprüft und entsprechend Ausgaben erstellt werden. + */ + static V_LEVEL VERBOSE = V_LEVEL.INFO; +} diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/package.bluej b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/package.bluej new file mode 100644 index 0000000..1b6f9cc --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/package.bluej @@ -0,0 +1,161 @@ +#BlueJ package file +dependency1.from=Basis +dependency1.to=Filmsammlung +dependency1.type=UsesDependency +dependency10.from=Aufgabe +dependency10.to=Film +dependency10.type=UsesDependency +dependency11.from=Aufgabe +dependency11.to=Kinofilm +dependency11.type=UsesDependency +dependency12.from=Aufgabe +dependency12.to=Daten +dependency12.type=UsesDependency +dependency13.from=Filmsammlung +dependency13.to=Film +dependency13.type=UsesDependency +dependency14.from=Film +dependency14.to=Settings +dependency14.type=UsesDependency +dependency15.from=Serie +dependency15.to=Filmsammlung +dependency15.type=UsesDependency +dependency16.from=Serie +dependency16.to=SerienEpisode +dependency16.type=UsesDependency +dependency17.from=Serie +dependency17.to=Settings +dependency17.type=UsesDependency +dependency18.from=SerienEpisode +dependency18.to=Serie +dependency18.type=UsesDependency +dependency19.from=Daten +dependency19.to=Kinofilm +dependency19.type=UsesDependency +dependency2.from=Basis +dependency2.to=FilmsammlungGeneric +dependency2.type=UsesDependency +dependency20.from=Daten +dependency20.to=Serie +dependency20.type=UsesDependency +dependency21.from=Daten +dependency21.to=SerienEpisode +dependency21.type=UsesDependency +dependency22.from=Daten +dependency22.to=Film +dependency22.type=UsesDependency +dependency3.from=Basis +dependency3.to=Kinofilm +dependency3.type=UsesDependency +dependency4.from=Basis +dependency4.to=Serie +dependency4.type=UsesDependency +dependency5.from=Basis +dependency5.to=Daten +dependency5.type=UsesDependency +dependency6.from=Aufgabe +dependency6.to=Filmsammlung +dependency6.type=UsesDependency +dependency7.from=Aufgabe +dependency7.to=FilmsammlungGeneric +dependency7.type=UsesDependency +dependency8.from=Aufgabe +dependency8.to=Serie +dependency8.type=UsesDependency +dependency9.from=Aufgabe +dependency9.to=SerienEpisode +dependency9.type=UsesDependency +editor.fx.0.height=0 +editor.fx.0.width=0 +editor.fx.0.x=0 +editor.fx.0.y=0 +objectbench.height=271 +objectbench.width=749 +package.divider.horizontal=0.6 +package.divider.vertical=0.6971677559912854 +package.editor.height=633 +package.editor.width=1126 +package.editor.x=100 +package.editor.y=27 +package.frame.height=1020 +package.frame.width=1280 +package.numDependencies=22 +package.numTargets=10 +package.showExtends=true +package.showUses=true +project.charset=UTF-8 +readme.height=60 +readme.name=@README +readme.width=49 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=Basis +target1.showInterface=false +target1.type=UnitTestTargetJunit4 +target1.width=120 +target1.x=30 +target1.y=90 +target10.height=50 +target10.name=Settings +target10.showInterface=false +target10.type=ClassTarget +target10.width=130 +target10.x=340 +target10.y=50 +target2.height=50 +target2.name=Filmsammlung +target2.showInterface=false +target2.type=ClassTarget +target2.width=180 +target2.x=300 +target2.y=210 +target3.height=50 +target3.name=FilmsammlungGeneric +target3.showInterface=false +target3.type=ClassTarget +target3.width=270 +target3.x=370 +target3.y=270 +target4.height=50 +target4.name=Kinofilm +target4.showInterface=false +target4.type=ClassTarget +target4.width=90 +target4.x=600 +target4.y=330 +target5.height=50 +target5.name=Film +target5.showInterface=false +target5.type=AbstractTarget +target5.width=80 +target5.x=630 +target5.y=160 +target6.height=50 +target6.name=Aufgabe +target6.showInterface=false +target6.type=ClassTarget +target6.width=100 +target6.x=120 +target6.y=160 +target7.height=50 +target7.name=SerienEpisode +target7.showInterface=false +target7.type=ClassTarget +target7.width=130 +target7.x=760 +target7.y=450 +target8.height=50 +target8.name=Daten +target8.showInterface=false +target8.type=ClassTarget +target8.width=100 +target8.x=220 +target8.y=50 +target9.height=50 +target9.name=Serie +target9.showInterface=false +target9.type=ClassTarget +target9.width=80 +target9.x=680 +target9.y=390 diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/02_Filmsammlung_Loes/.gitignore b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/02_Filmsammlung_Loes/.gitignore new file mode 100644 index 0000000..661d056 --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/02_Filmsammlung_Loes/.gitignore @@ -0,0 +1,6 @@ +*.sh +*.class +*.ctxt +repo.adoc +repo_subtree.adoc +/alt diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/02_Filmsammlung_Loes/Aufgabe.java b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/02_Filmsammlung_Loes/Aufgabe.java new file mode 100644 index 0000000..188291d --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/02_Filmsammlung_Loes/Aufgabe.java @@ -0,0 +1,240 @@ +import java.util.*; +import java.time.*; + +/** + * Verschiedene Aufgaben, die statisch direkt aus BlueJ heraus aufgerufen werden. + * + * @author S.Gebert + * @version 12.2020 + */ +public class Aufgabe +{ + + /** + * Aufgabe.a1 + * Schreibe eine Methode, die für das erste Element einer gegebene Filmsammlung (von Serien) die Bewertung auf 5.0 setzt + * und + * den Titel und die Anzahl der vorhandenen Episoden auf der Konsole ausgibt. + * + * Hinweise: - Betrachte die Dokumentation der Klasse Filmsammlung. Mit welcher Methode kannst du auf die Elemente der Sammlung zugreifen? + * - Prüfe an welcher Stelle eine Typkonvertierung nötig ist. + * + * Teste deine Methode mit der Filmsammlung s und kf (Basis - Objektzustand wiederherstellen) + * + * @param fs Eine Filmsammlung + */ + public static void a1(Filmsammlung fs) + { + fs.get(0).setBewertung( 5.0 ); // Durch Polymorphie wird die korrekte Methode der Serie bzw. des Films aufgerufen, bei einer Serie findet keine Änderung der Bewertung statt. + System.out.println( "Anzahl Episoden der Serie '"+ fs.get(0).getTitel()+"': " + ( (Serie) fs.get(0) ).getAnzahlEpisoden() ); + /* + * Falls fs eine Filmsammlung von Serien: + * fs.get(0).getTitel(); //implitzite erweiternde Typumwandlung: Serie -> Film + * ( (Serie) fs.getFilm(0) ).getAnzahlEpisoden(); //explizite einschränkende Typumwandlung: Film -> Serie + * + * Falls fs eine Filmsammlung von Kinofilmen: + * Exception: java.lang.ClassCastException (class Kinofilm cannot be cast to class Serie) + */ + + } + + /** + * Aufgabe.a2 + * Schreibe eine Methode, die für das zweite Element einer gegebene Filmsammlung (von Serien) die Bewertung auf 5.0 setzt + * und + * den Titel und die Anzahl der vorhandenen Episoden auf der Konsole ausgibt. + * + * Teste deine Methode mit der Filmsammlung s und kf (Basis - Objektzustand wiederherstellen) + * + * @param fsG Eine Seriensammlung + */ + public static void a2(FilmsammlungGeneric fsG) + { + fsG.get(1).setBewertung( 5.0 ); // die Methode der Serie aufgerufen, es findet keine Änderung der Bewertung statt. + System.out.println( "Anzahl Episoden der Serie '"+ fsG.get(1).getTitel()+"': " + fsG.get(1).getAnzahlEpisoden() ); + /* + * fsG.get(1).getTitel(); //keine Typumwandlung, die von der Vaterklasse geerbte Methode wird aufgerufen. + * fsG.get(1).getAnzahlEpisoden(); //keine Typumwandlung notwendig, weder implizit noch explizit + */ + + } + + /** + * Aufgabe.a3 + * Erstelle verschieden Filmsammlungen und teste deren Methoden. + * Um einzelne Filme zu erhalten kannst die Methoden Daten.randomFilm(), Daten.randomKinofilm(), Daten.randomSerie() und Daten.randomEpisode() verwenden. + * + * - Welche konkreten Typparameter sind erlaubt, welche nicht? + * - Finde Beispiele für die es zu Compilierungs/Laufzeitfehlern kommen kann. + */ + public static void a3() + { + //Beispiel + FilmsammlungGeneric sammlung1 = new FilmsammlungGeneric<>( new SerienEpisode[]{Daten.randomEpisode(), Daten.randomEpisode() }); + System.out.println(sammlung1.get(0).getTitel()); + + //Lösungsbeispiel + FilmsammlungGeneric sammlung2 = new FilmsammlungGeneric<>( new String[]{"1","blabla" }); + //System.out.println(sammlung2.get(0).getTitel()); //Hier kommt es zum Compilierungsfehler "cannot find symbol - method getTitel() + + } + + /** + * Aufgabe.a4 + * Die gegebene Methode soll die Titel aller Filme in einer Filmsammlung ausgeben. + * Teste die gegebene Methode mit den Basisdaten sG und kfG. + * + * - Notiere dir den Laufzeitfehler den du erhälst. + * - Ändere die Methode so ab, dass es mit sG bzw. kfG funktioniert. Gibt es eine allgemeine Lösung? + * @param fsG Eine Filmsammlung + */ + public static void a4(FilmsammlungGeneric fsG) + { + Iterator iter = fsG.iterator(); + + while( iter.hasNext() ){ + System.out.print( iter.next().getTitel() +", "); + } + + } + + /** + * Musterlösung der Aufgabe.a4 + * generische Implementierung + * + * @param fsG Eine Filmsammlung + */ + public static void a4_generic(FilmsammlungGeneric fsG) + { + Iterator iter = fsG.iterator(); + + while( iter.hasNext() ){ + System.out.print( iter.next().getTitel() +", "); + } + + //Alternativ + for( E f : fsG ){ + System.out.print( f.getTitel() + ", "); + } + } + + /** + * Aufgabe.a5 + * Die gegebene Methode soll die Titel aller Filme in einer Filmsammlung von Kinofilmen ausgeben. + * Implementiere die Methode mit der erweiterten for-Schleife + * Teste mit den Basisdaten kfG. + * + * @param fsG Eine Filmsammlung + */ + public static void a5(FilmsammlungGeneric fsG) + { + for( Kinofilm f : fsG ){ + System.out.print( f.getTitel() +", "); + } + } + + /** + * Aufgabe.a6 + * Finde für jede gegebene Reihung jeweils das Minimum. + * Schreibe dafür je eine private statische Methode und rufe diese auf. + * Gib das Ergebnis auf der Konsole aus. + * + */ + public static void a6() + { + //Gegebene Reihungen + Integer[] rInt = {5, 90, 4, 1, -70, 400, 30}; + String[] rString = {"Bär","Affe","Nilpferd","Zebra"}; + Float[] rFloat = {3.4f, 9.78f,.01f}; + + //Aufruf + System.out.println( getMinInteger(rInt) ); + System.out.println( getMinString(rString) ); + System.out.println( getMinFloat(rFloat) ); + + //Aufruf der generischen Implementierung + System.out.println(getMinGeneric(Arrays.asList(rInt))); + System.out.println(getMinGeneric(Arrays.asList(rString))); + System.out.println(getMinGeneric(Arrays.asList(rFloat))); + } + + private static Integer getMinInteger(Integer[] r) + { + + Integer min = r[0]; + + for(int i = 1; i < r.length; i++) + { + if(r[i] < min) + min = r[i]; + } + + return min; + } + + private static String getMinString(String[] r) + { + + String min = r[0]; + + for(int i = 1; i < r.length; i++) + { + if(r[i].toLowerCase().compareTo(min.toLowerCase()) < 0) + min = r[i]; + } + + return min; + } + + private static Float getMinFloat(Float[] r) + { + Float min = r[0]; + + for(int i = 1; i < r.length; i++) + { + if(r[i] < min) + min = r[i]; + } + + return min; + } + + //verwende generische Methoden um Abhängigkeiten zwischen Parametern und/oder Rückgabewert auszudrücken. + private static < T extends Comparable > T getMinGeneric(List r) + { + T min = r.get(0); + + for( T t : r ) + { + if(t.compareTo(min) < 0) + min = t; + } + + return min; + + } + + //Einzeiler für die Nutzung in der Direkteingabe. Siehe Beispielaufgaben im Unterrichtsgang + private static void einZeiler(FilmsammlungGeneric kfG) + { + //Filme mit Bewertung schlechter als 7.0 aus Sammlung entfernen. + kfG.removeIf(f -> (f.getBewertung()<7.0)); + + //Alle Titel einer Sammlung ausgeben. + kfG.forEach(f -> System.out.print(f.getTitel()+", ")); + + //Alle Bewertungen um 0.5 erhöhen, aber nicht über 10.0 + kfG.forEach(f -> {if(f.getBewertung()<=9.5) f.setBewertung(f.getBewertung()+0.5);}); + + //Filmtitel mit schlechtester Bewertung ausgeben + System.out.println("Schlechteste Bewertung: " + java.util.Collections.min(kfG, java.util.Comparator.comparing(f -> f.getBewertung() )).getTitel()); + + //Filmtitel mit schlechtester Bewertung via Stream bestimmen und ausgeben. + System.out.println("Schlechteste Bewertung:"+ kfG.stream().reduce(kfG.get(0), (min, t) -> (t.getBewertung() < min.getBewertung()) ? t : min).getTitel() ); + + // Anzahl aller Filme der Sammlung mit einer Bewertung besser als 7.0 + System.out.println("Anzahl Bewertungen über 7.0:" + kfG.stream().filter( f -> f.getBewertung()>7.0 ).mapToInt(f -> 1).sum() ); + + } + +} diff --git a/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/readme.adoc b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/readme.adoc new file mode 100644 index 0000000..849992d --- /dev/null +++ b/Quellcodes/Alg_GR_Str_Progr_Filmsammlung/readme.adoc @@ -0,0 +1,11 @@ += Material : + +|=== +|Zuordnung| +|Klassenstufe| +|Bildungsplanbezug | +|Werkzeug| +|Autoren| +|=== + +== Inhalt