Subtrees hinzugefügt
This commit is contained in:
Dirk Zechnall
parent
1cc6192581
commit
7baadffbea
17 changed files with 1316 additions and 0 deletions
6
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/.gitignore
vendored
Normal file
6
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/.gitignore
vendored
Normal 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
6
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/01_Filmsammlung_Roh/.gitignore
vendored
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
*.sh
|
||||
*.class
|
||||
*.ctxt
|
||||
repo.adoc
|
||||
repo_subtree.adoc
|
||||
/alt
|
||||
|
|
@ -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
|
||||
|
||||
}
|
||||
}
|
||||
|
|
@ -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()
|
||||
{
|
||||
}
|
||||
}
|
||||
|
|
@ -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()));
|
||||
}
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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.
|
||||
}
|
||||
}
|
||||
|
|
@ -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.
|
||||
// }
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
@ -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.
|
||||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
@ -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.
|
||||
*/
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
|
@ -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
6
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/02_Filmsammlung_Loes/.gitignore
vendored
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
*.sh
|
||||
*.class
|
||||
*.ctxt
|
||||
repo.adoc
|
||||
repo_subtree.adoc
|
||||
/alt
|
||||
|
|
@ -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
11
Quellcodes/Alg_GR_Str_Progr_Filmsammlung/readme.adoc
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
= Material :
|
||||
|
||||
|===
|
||||
|Zuordnung|
|
||||
|Klassenstufe|
|
||||
|Bildungsplanbezug |
|
||||
|Werkzeug|
|
||||
|Autoren|
|
||||
|===
|
||||
|
||||
== Inhalt
|
||||
Loading…
Add table
Add a link
Reference in a new issue