ZSL-Mirror/alg_gr_strukt_programmierung_ks
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Subtrees hinzugefügt

Browse source
This commit is contained in:
Dirk Zechnall 2025-01-05 12:09:42 +01:00
parent 1cc6192581
commit 7baadffbea
17 changed files with 1316 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/.gitignore vendored Normal file
View file

@ -0,0 +1,6 @@
*.sh
*.class
*.ctxt
repo.adoc
repo_subtree.adoc
/alt

6
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/.gitignore vendored Normal file
View file

@ -0,0 +1,6 @@
*.sh
*.class
*.ctxt
repo.adoc
repo_subtree.adoc
/alt

113
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Aufgabe.java Normal file
View file

@ -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<Serie> 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<SerienEpisode> 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<Film> fsG)
{
Iterator<Film> 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<Kinofilm> 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
}
}

52
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Basis.java Normal file
View file

@ -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<Kinofilm> kfG;
FilmsammlungGeneric<Serie> 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<Kinofilm>( Daten.kinofilme().values() );
sG = new FilmsammlungGeneric<Serie>( Daten.serien().values() );
}
/**
* Gibt das Testgerüst wieder frei.
*
* Wird nach jeder Testfall-Methode aufgerufen.
*/
@After
public void tearDown()
{
}
}

64
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Daten.java Normal file
View file

@ -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<String,Kinofilm> kinofilme()
{
HashMap<String, Kinofilm> 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<String,Serie> serien()
{
HashMap<String, Serie> 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()));
}
}

133
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Film.java Normal file
View file

@ -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<Year>
/**
* 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;
}
}

173
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Filmsammlung.java Normal file
View file

@ -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<? extends Film> 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.
}
}

94
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/FilmsammlungGeneric.java Normal file
View file

@ -0,0 +1,94 @@
import java.util.*;
/**
* Eine Filmsammlung.
* Generische Implementierung auf Basis einer ArrayList<E>
*
* @author S.Gebert
* @version 12.2020
*/
public class FilmsammlungGeneric<E> extends ArrayList<E>
//public class FilmsammlungGeneric<E extends Film> extends ArrayList<E>
{
/**
* 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<? extends E> 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.
// }
}

40
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Kinofilm.java Normal file
View file

@ -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;
}
}

8
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/README.TXT Normal file
View file

@ -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.

98
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Serie.java Normal file
View file

@ -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;
}
}

70
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/SerienEpisode.java Normal file
View file

@ -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.
*/
}

41
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/Settings.java Normal file
View file

@ -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;
}

161
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/package.bluej Normal file
View file

@ -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

6
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/02_Filmsammlung_Loes/.gitignore vendored Normal file
View file

@ -0,0 +1,6 @@
*.sh
*.class
*.ctxt
repo.adoc
repo_subtree.adoc
/alt

240
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/02_Filmsammlung_Loes/Aufgabe.java Normal file
View file

@ -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<Serie> 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<SerienEpisode> sammlung1 = new FilmsammlungGeneric<>( new SerienEpisode[]{Daten.randomEpisode(), Daten.randomEpisode() });
System.out.println(sammlung1.get(0).getTitel());
//Lösungsbeispiel
FilmsammlungGeneric<String> 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<Film> fsG)
{
Iterator<Film> 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 <E extends Film> void a4_generic(FilmsammlungGeneric<E> fsG)
{
Iterator<E> 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<Kinofilm> 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<T> 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<Kinofilm> 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() );
}
}

11
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/readme.adoc Normal file
View file

@ -0,0 +1,11 @@
= Material :
|===
|Zuordnung|
|Klassenstufe|
|Bildungsplanbezug |
|Werkzeug|
|Autoren|
|===
== Inhalt