diff --git a/docs/additional-material/daniel-java1/cheatsheet.md b/docs/additional-material/daniel-java1/cheatsheet.md new file mode 100644 index 0000000000..fa7b1d0b9f --- /dev/null +++ b/docs/additional-material/daniel-java1/cheatsheet.md @@ -0,0 +1,59 @@ +--- +title: Cheatsheet +description: '' +sidebar_position: 30 +tags: [] +--- + +## Java API + +| Klasse | Methode | Statisch | Rückgabetyp | +| ------------- | ------------------------------------------------------------------- | -------- | ------------ | +| Aufzählung | `valueOf(arg0: String)` | X | Aufzählung | +| Aufzählung | `values()` | X | Aufzählung[] | +| `Boolean` | `valueOf(s: String)`, `valueOf(b: boolean)` | X | `Boolean` | +| `Double` | `valueOf(s: String)`, `valueOf(d: double)` | X | `Double` | +| `Integer` | `valueOf(s: String)`, `valueOf(i: int)` | X | `Integer` | +| `LocalDate` | `getDayOfMonth()`, `getDayOfYear()`, `getMonthValue()`, `getYear()` | | `int` | +| `LocalDate` | `now()` | X | `LocalDate` | +| `LocalDate` | `of(year: int, month: int, dayOfMonth: int)` | X | `LocalDate` | +| `LocalTime` | `getHour()`, `getMinute()`, `getSecond()` | | `int` | +| `LocalTime` | `now()` | X | `LocalTime` | +| `LocalTime` | `of(hour: int, minute: int, second: int)` | X | `LocalTime` | +| `Object` | `equals(object: Object)` | | `boolean` | +| `Object` | `hashCode()` | | `int` | +| `Object` | `toString()` | | `String` | +| `PrintStream` | print-Methoden, println-Methoden | | `void` | +| `Random` | `nextInt(bound: int)` | | `int` | +| `Scanner` | `hasNextLine()` | | `boolean` | +| `Scanner` | `next()` | | `String` | +| `Scanner` | `nextBoolean()` | | `boolean` | +| `Scanner` | `nextDouble()` | | `double` | +| `Scanner` | `nextInt()` | | `int` | +| `Scanner` | `nextLine()` | | `String` | +| `String` | `charAt(index: int)` | | `char` | +| `String` | `length()` | | `int` | +| `String` | `split(regex: String)` | | `String[]` | +| `String` | `toLowerCase()`, `toUpperCase()` | | `String` | +| `System` | `currentTimeMillis()` | X | `long` | + +## Java Collections Framework + +| Klasse | Methode | Statisch | Rückgabetyp | +| -------------- | --------------------------------------- | -------- | ----------- | +| `ArrayList` | `add(e: E)` | | `boolean` | +| `ArrayList` | `add(index: int, element: E)` | | `void` | +| `ArrayList` | `contains(o: Object)` | | `boolean` | +| `ArrayList` | `get(index: int)` | | `E` | +| `ArrayList` | `remove(index: int)` | | `E` | +| `ArrayList` | `remove(o: Object)` | | `boolean` | +| `ArrayList` | `size()` | | `int` | +| `Collections` | `sort(list: List, c: Comparator)` | X | `void` | +| `List` | `of(elements: E...)` | X | `List` | + +## Funktionale Schnittstellen + +| Klasse | Methode | Statisch | Rückgabetyp | +| --------------- | ----------------------- | -------- | ----------- | +| `Comparable` | `compareTo(o: T)` | | `int` | +| `Comparator` | `compare(o1: T, o2: T)` | | `int` | diff --git a/docs/additional-material/daniel/daniel.md b/docs/additional-material/daniel-java1/daniel-java1.md similarity index 78% rename from docs/additional-material/daniel/daniel.md rename to docs/additional-material/daniel-java1/daniel-java1.md index 0fbbca90d7..e3c4102756 100644 --- a/docs/additional-material/daniel/daniel.md +++ b/docs/additional-material/daniel-java1/daniel-java1.md @@ -1,5 +1,5 @@ --- -title: Daniel +title: Daniel (Programmierung 1) description: '' sidebar_position: 20 tags: [] diff --git a/docs/additional-material/daniel-java1/exam-results.md b/docs/additional-material/daniel-java1/exam-results.md new file mode 100644 index 0000000000..f1d809e3ac --- /dev/null +++ b/docs/additional-material/daniel-java1/exam-results.md @@ -0,0 +1,36 @@ +--- +title: Klausurergebnisse +description: '' +sidebar_position: 50 +tags: [] +--- + +## Klausur Q2 2022 + +```mermaid +pie title 1/10 + "100+ Punkte" : 2 + "90-99 Punkte" : 5 + "80-89 Punkte" : 4 + "70-79 Punkte" : 5 + "60-69 Punkte" : 3 + "50-59 Punkte" : 4 + "40-49 Punkte" : 3 + "30-39 Punkte" : 3 + "20-29 Punkte" : 3 + "10-19 Punkte" : 0 + "0-9 Punkte" : 1 +``` + +```mermaid +pie title 1/3 + "68-100 Punkte" : 16 + "34-67 Punkte" : 11 + "0-33 Punkte" : 6 +``` + +```mermaid +pie title 1/2 + "50-100 Punkte" : 23 + "0-49 Punkte" : 10 +``` diff --git a/docs/additional-material/daniel-java1/sample-exam.md b/docs/additional-material/daniel-java1/sample-exam.md new file mode 100644 index 0000000000..2041ce7ba8 --- /dev/null +++ b/docs/additional-material/daniel-java1/sample-exam.md @@ -0,0 +1,667 @@ +--- +title: Musterklausur +description: '' +sidebar_position: 10 +tags: [] +--- + +## Hinweise zur Klausur + +- Die in dieser Klausur verwendeten Personenbezeichnungen beziehen sich – sofern + nicht anders kenntlich gemacht – auf alle Geschlechter +- Es kann davon ausgegangen werden, dass sämtliche Klassen entsprechende + Implementierungen der Object-Methoden besitzen +- Der Stereotyp `<>` impliziert, dass die Aufzählung einen + passenden, privaten Konstruktor sowie gegebenenfalls passende Getter für alle + Attribute besitzt +- Pakete und Klassenimporte müssen nicht angegeben werden +- Für die Konsolenausgabe kann das Kürzel _sysout_ verwendet werden +- Methoden- und Attributsbezeichner dürfen sinnvoll gekürzt geschrieben werden + (Beispiel _getLWMCP()_ statt _getLectureWithMostCreditPoints()_) + +## Aufgabe 1 (20 Punkte) + +- Welche Konsolenausgabe erzeugen die Methoden `void a()`, `void b()`, + `void c()` und `void d()` der abgebildeten Klasse `ExamTask01` (15 Punkte)? +- Notiere jeweils Bezeichner sowie Zeilennummer der Deklaration und Zeilennummer + der Initialisierung aller Datenobjekte der Methode `void d()` der abgebildeten + Klasse `ExamTask01` (5 Punkte) + +### Quelltext + +```java title="ExamTask01" showLineNumbers +public class ExamTask01 { + + private static String textA, textB; + + private static void a() { + byte byte1 = 0b1011010; + byte byte2 = 0b101110; + int int1 = byte1 - byte2; + System.out.println("byte1: " + byte1); + System.out.println("byte2: " + byte2); + System.out.println("int1: " + int1); + } + + private static void b() { + String[] values = {"cold", "AEIOU", "hot"}; + int index1 = values[2].length() == 3 ? 2 : 0; + String value1 = values[index1]; + int index2 = (int) (2.1 + 2.8); + char value2 = values[1].charAt(index2); + System.out.println(index1 + value1 + index2 + value2); + } + + private static void c() { + char x = 'X'; + for (int i = 0; i < 5; i++) { + System.out.print(i + ": "); + for (int j = 5 - i - 1; j > 0; j--) { + System.out.print(x); + } + System.out.println(); + } + } + + private static void d() { + textA = new String("Text A"); + textB = new String("Text B"); + boolean boolean1, boolean2; + int int2 = 1; + boolean1 = (textA == textB) ? true : false; + boolean2 = boolean1 && ++int2 % 2 == 0 ? true : false; + System.out.println("int2: " + int2); + System.out.println("boolean1: " + boolean1); + System.out.println("boolean2: " + boolean2); + } + +} +``` + +### Musterlösung + +```console +byte1: 90 +byte2: 46 +int1: 44 +2hot4U +0: XXXX +1: XXX +2: XX +3: X +4: +int2: 1 +boolean1: false +boolean2: false +``` + +| Bezeichner | Deklaration | Initialisierung | +| ---------- | ----------- | --------------- | +| `textA` | 3 | 35 | +| `textB` | 3 | 36 | +| `boolean1` | 37 | 39 | +| `boolean2` | 37 | 40 | +| `int2` | 38 | 38 | + +## Aufgabe 2 (20 Punkte) + +- Erstelle die Klasse `Class` anhand des abgebildeten Klassendiagramms (15 + Punkte) +- Erstelle die ausführbare Klasse `ExamTask02` wie folgt (5 Punkte): Erstelle + einen Kurs mit 2 Studierenden und 2 Vorlesungen und gib anschließend den Kurs + sowie die Vorlesung mit den meisten Creditpoints auf der Konsole aus + +### Klassendiagramm + +```mermaid +classDiagram + Class o-- Lecture + Class o-- Student + Class o-- CourseOfStudies + + class Class { + -description String + -courseOfStudies CourseOfStudies + -lectures List~Lecture~ + -students List~Student~ + +Class(description String, courseOfStudies CourseOfStudies) + +description() String + +courseOfStudies() CourseOfStudies + +lectures() List~Lecture~ + +students() List~Student~ + +addLecture(lecture Lecture) void + +addStudent(student Student) void + +getLectureWithMostCreditPoints() Lecture + +toString() String + } + + class Student { + -matriculationNumber String + -name String + +Student(matriculationNumber String, name String) + +matriculationNumber() String + +name() String + +toString() String + } + + class Lecture { + -description String + -creditPoints int + +Lecture(description String, creditPoints int) + +description() String + +creditPoints() int + +toString() String + } + + class CourseOfStudies { + <> + WI = Wirtschaftsinformatik + INF = Informatik + BWL = Betriebswirtschaftslehre + -description String + } + + class ExamTask02 { + +main(args String[])$ void + } +``` + +### Hinweise zur Klasse Class + +- Der Konstruktor soll alle Attribute initialisieren +- Die Methode `void addStudent(student Student)` soll der Studierendenliste + (`students`) den eingehenden Studierenden hinzufügen +- Die Methode `void addLecture(lecture Lecture)` soll der Vorlesungsliste + (`lectures`) die eingehende Vorlesung hinzufügen +- Die Methode `Lecture getLectureWithMostCreditPoints()` soll die Vorlesung mit + den meisten Creditpoints zurückgeben +- Die Methode `String toString()` soll den Kurs in der Form _Class + [description=[Beschreibung des Kurses\], courseOfStudies=[Beschreibung des + Studiengangs\], lectures=[Vorlesungen\], students=[Studierende\]\]_ + zurückgeben + +### Musterlösung + +```java title="Class.java" showLineNumbers +public class Class { // 0,5 + + private String description; // 0,25 + private CourseOfStudies courseOfStudies; // 0,25 + private List lectures; // 0,25 + private List students; // 0,25 + + public Class(String description, CourseOfStudies courseOfStudies) { // 0,5 + this.description = description; // 0,25 + this.courseOfStudies = courseOfStudies; // 0,25 + this.lectures = lectures; // 0,25 + lectures = new ArrayList<>(); // 0,25 + students = new ArrayList<>(); // 0,25 + } + + public String description() { // 0,5 + return description; // 0,5 + } + + public CourseOfStudies courseOfStudies() { // 0,5 + return courseOfStudies; // 0,5 + } + + public List lectures() { // 0,5 + return lectures; // 0,5 + } + + public List students() { // 0,5 + return students; // 0,5 + } + + public void addLecture(Lecture lecture) { // 0,5 + lectures.add(lecture); // 0,5 + } + + public void addStudent(Student student) { // 0,5 + students.add(student); // 0,5 + } + + public Lecture getLectureWithMostCreditPoints() { // 0,5 + Lecture lecture = lectures.get(0); // 0,5 + int creditPoints = lecture.creditPoints(); // 0,5 + for (int i = 0; i < lectures.size(); i++) { // 0,5 + if (lectures.get(i).creditPoints() > creditPoints) { // 1 + lecture = lectures.get(i); // 0,5 + creditPoints = lecture.creditPoints(); // 0,5 + } + } + return lecture; // 0,5 + } + + public String toString() { // 0,5 + return "Class [description=" + description + ", courseOfStudies=" + courseOfStudies.description() + + ", lectures=" + lectures + ", students=" + students + "]"; // 1 + } + +} +``` + +```java title="ExamTask02.java" showLineNumbers +public class ExamTask02 { // 0,5 + + public static void main(String[] args) { // 0,5 + + List lectures = new ArrayList<>(); // 0,5 + lectures.add(new Lecture("Mathe", 5)); // 0,5 + lectures.add(new Lecture("Programmierung", 10)); // 0,5 + + Class class1 = new Class("WWIBE122", CourseOfStudies.WI, lectures); // 0,5 + class1.addStudent(new Student("8271625", "Hans Maier")); // 0,5 + class1.addStudent(new Student("9102934", "Peter Müller")); // 0,5 + + System.out.println(class1.toString()); // 0,5 + System.out.println(class1.getLectureWithMostCreditPoints()); // 0,5 + + } + +} +``` + +## Aufgabe 3 (21 Punkte) + +Erstelle die Klasse `ExamTask03` anhand des abgebildeten Klassendiagramms sowie +anhand der abgebildeten Aktivitätsdiagramme. + +### Klassendiagramm + +folgt + +### Aktivitätsdiagramme + +folgt + +### Beispielhafte Konsolenausgaben + +```console +PIN: 387 +PIN ist ungültig (Länge) +``` + +```console +PIN: 3871 +PIN ist ungültig (Zahlenwert) +``` + +```console +PIN: 3872 +PIN ist gültig +``` + +### Musterlösung + +```java title="ExamTask03.java" showLineNumbers +public class ExamTask03 { // 0,5 + + private static int[] pin; // 0,5 + + public static void main(String[] args) { // 0,5 + @SuppressWarnings("resource") + Scanner sc = new Scanner(System.in); // 1 + + System.out.print("Bitte PIN eingeben: "); // 0,5 + String text = sc.next(); // 0,5 + textToPin(text); // 0,5 + if (!checkPinLength()) { // 0,5 + System.out.println("PIN ist ungültig (Länge)"); // 0,5 + } else if (!checkPinValue()) { // 0,5 + System.out.println("PIN ist ungültig (Zahlenwert)"); // 0,5 + } else { // 0,5 + System.out.println("PIN ist gültig"); // 0,5 + } + } + + private static boolean checkPinLength() { // 0,5 + int length = pin.length; // 0,5 + if (length < 4 || length > 8) { // 1 + return false; // 0,5 + } + return true; // 0,5 + } + + private static boolean checkPinValue() { // 0,5 + int length = pin.length; // 0,5 + int total = 0; // 0,5 + int i = 0; // 0,5 + while (i < length) { // 1 + int value = pin[i]; // 0,5 + total += value; // 0,5 + i++; // 0,5 + } + if (total % 2 != 0) { // 1 + return false; // 0,5 + } + return true; // 0,5 + } + + private static void textToPin(String text) { // 0,5 + int length = text.length(); // 0,5 + pin = new int[length]; // 0,5 + int i = 0; // 0,5 + while (i < length) { // 0,5 + char c = text.charAt(i); // 0,5 + pin[i] = Integer.valueOf(c); // 1 + i++; // 0,5 + } + } + +} +``` + +## Aufgabe 4 (21 Punkte) + +- Erstelle die Klasse `Player` (7 Punkte) anhand des abgebildeten + Klassendiagramms +- Erstelle die ausführbare Klasse `ExamTask04` wie folgt (14 Punkte): + - Zu Beginn des Spiels sollen die Spieler ihre Namen eingeben können + - Zu Beginn einer jeder Runde soll der aktuelle Punktestand ausgegeben werden + - Anschließend sollen beide Spieler ihre Würfel werfen + - Der Spieler mit dem niedrigeren Wurfwert soll einen Lebenspunkt verlieren, + bei Gleichstand soll keiner der Spieler einen Lebenspunkt verlieren + - Das Spiel soll Enden, sobald ein Spieler keine Lebenspunkte mehr besitzt + - Am Ende soll der Gewinner des Spiels ausgegeben werden + +### Klassendiagramm + +```mermaid +classDiagram + ExamTask04 o-- Player + Player o-- Dice + + class ExamTask04 { + -player1 Player$ + -player2 Player$ + -scanner Scanner$ + +main(args String[])$ void + } + + class Player { + -name String + -healthPoints int + -dice Dice + +Player(name String) + +name() String + +getHealthPoints() int + +reduceHealthPoints() int + +rollTheDice() int + } + + class Dice { + -value int + +getValue() int + +rollTheDice() void + } +``` + +### Hinweis zur Klasse Player + +- Der Konstruktor soll den Namen (`name`) mit dem eingehenden Namen belegen, die + Lebenspunkte des Spielers (`healthPoints`) auf den Wert 10 setzen sowie den + Würfel (`dice`) initialisieren +- Die Methode `int rollTheDice()` soll den Würfel des Spielers werfen und den + Würfelwert zurückgeben +- Die Methode `void reduceHealthPoints()` soll die Lebenspunkte des Spielers + (`healthPoints`) um 1 reduzieren + +### Beispielhafte Konsolenausgabe + +```console +Spieler 1, gib bitte Deinen Namen ein: Hans +Spieler 2, gib bitte Deinen Namen ein: Peter + +Hans hat 10 Lebenspunkte +Peter hat 10 Lebenspunkte +Hans würfelt eine 6 +Peter würfelt eine 6 +… +Hans hat 4 Lebenspunkte +Peter hat 1 Lebenspunkte +Hans würfelt eine 5 +Peter würfelt eine 1 +Peter verliert einen Punkt + +Hans gewinnt +``` + +### Musterlösung + +```java title="Player.java" showLineNumbers +public class Player { // 0,5 + + private String name; // 0,25 + private int healthPoints; // 0,25 + private Dice dice; // 0,25 + + public Player(String name) { // 0,5 + this.name = name; // 0,25 + healthPoints = 10; // 0,5 + dice = new Dice(); // 0,5 + } + + public String name() { // 0,5 + return name; // 0,5 + } + + public int getHealthPoints() { // 0,5 + return healthPoints; // 0,5 + } + + public int rollTheDice() { // 0,5 + dice.rollTheDice(); // 0,25 + return dice.getValue(); // 0,25 + } + + public void reduceHealthPoints() { // 0,5 + healthPoints--; // 0,5 + } + +} +``` + +```java title="ExamTask04.java" showLineNumbers +public class ExamTask04 { // 0,5 + + private static Player player1; // 0,25 + private static Player player2; // 0,25 + private static Scanner scanner; // 0,25 + + public static void main(String[] args) { // 0,5 + + scanner = new Scanner(System.in); // 0,25 + + System.out.print("Spieler 1, gib bitte Deinen Namen ein: "); // 0,5 + String name1 = scanner.nextLine(); // 0,5 + player1 = new Player(name1); // 0,5 + + System.out.print("Spieler 2, gib bitte Deinen Namen ein: "); // 0,5 + String name2 = scanner.nextLine(); // 0,5 + player2 = new Player(name2); // 0,5 + + System.out.println(); + + while (player1.getHealthPoints() > 0 && player2.getHealthPoints() > 0) { // 1 + System.out.println(player1.name() + " hat " + player1.getHealthPoints() + " Lebenspunkte"); // 0,5 + System.out.println(player2.name() + " hat " + player2.getHealthPoints() + " Lebenspunkte"); // 0,5 + int value1 = player1.rollTheDice(); // 0,5 + System.out.println(player1.name() + " würfelt eine " + value1); // 0,5 + int value2 = player2.rollTheDice(); // 0,5 + System.out.println(player2.name() + " würfelt eine " + value2); // 0,5 + if (value1 > value2) { // 0,5 + player2.reduceHealthPoints(); // 0,5 + System.out.println(player2.name() + " verliert einen Punkt");// 0,5 + } else if (value2 > value1) { // 0,5 + player1.reduceHealthPoints(); // 0,5 + System.out.println(player1.name() + " verliert einen Punkt");// 0,5 + } + System.out.println(); + } + + if (player1.getHealthPoints() > player2.getHealthPoints()) {// 0,5 + System.out.println(player1.name() + " gewinnt");// 0,5 + } else {// 0,5 + System.out.println(player2.name() + " gewinnt");// 0,5 + } + + } + +} +``` + +## Aufgabe 5 (21 Punkte) + +Erstelle die Klassen `StuffedCookie` (8 Punkte), `CookieJar` (7 Punkte) und +`IngredientsReader` (6 Punkte) anhand des abgebildeten Klassendiagramms. + +### Klassendiagramm + +```mermaid +classDiagram + CookieJar o-- Cookie + Cookie <|-- StuffedCookie + Cookie o-- Recipe + StuffedCookie o-- Recipe + Recipe o-- Ingredient + + class CookieJar { + -cookies List~Cookie~ + +CookieJar() + +addCookie(cookie Cookie) void + +getStuffedCookie() StuffedCookie + } + + class Cookie { + -name String + -dough Recipe + +Cookie(name String, dough Recipe) + +getIngredients() List~Ingredient~ + } + + class StuffedCookie { + -jam Recipe + +StuffedCookie(name String, dough Recipe, jam Recipe) + +getIngredients() List~Ingredient~ + } + + class Recipe { + -name String + -ingredients List~Ingredient~ + +Recipe(name String) + +addIngredient(ingredient Ingredient) void + } + + class Ingredient { + -name String + +Ingredient(name String) + } + + class IngredientsReader { + +readIngredients(file File)$ List~Ingredient~ + } +``` + +### Hinweise zur Klasse StuffedCookie + +- Der Konstruktor soll alle Attribute initialisieren +- Die Methode `List getIngredients()` soll alle Zutaten zurückgeben. + Doppelte Zutaten sollen dabei nur einmal zurückgegeben werden + +### Hinweise zur Klasse CookieJar + +- Der Konstruktor soll alle Attribute initialisieren +- Die Methode `void addCookie(cookie Cookie)` soll der Plätzchenbox ein + Plätzchen hinzufügen +- Die Methode `StuffedCookie getStuffedCookie()` soll ein gefülltes Plätzchen + zurückgeben und aus der Plätzchenbox entfernen. Für den Fall, dass kein + gefülltes Plätzchen vorhanden ist, soll der Wert `null` zurückgegeben werden + +### Hinweis zur Klasse IngredientsReader + +Die statische Methode `List readIngredients()` soll alle Zutaten der +eingehenden Zutatendatei lesen und zurückgeben. + +### Beispielhafter Aufbau der Zutatendatei + +```console +Mehl +Zucker +... +``` + +### Musterlösung + +```java title="StuffedCookie.java" showLineNumbers +public class StuffedCookie extends Cookie { // 1 + + private Recipe jam; // 0,25 + + public StuffedCookie(String name, Recipe dough, Recipe jam) { // 0,5 + super(name, dough); // 1 + this.jam = jam; // 0,25 + } + + public List getIngredients() { // 0,5 + List ingredients = super.getIngredients(); // 0,5 + for (int i = 0; i < jam.ingredients().size(); i++) { // 1 + Ingredient ingredient = jam.ingredients().get(i); // 1 + if (ingredients.contains(ingredient)) { // 0,5 + continue; // 0,5 + } + ingredients.add(ingredient); // 0,5 + } + return ingredients; // 0,5 + } + +} +``` + +```java title="CookieJar.java" showLineNumbers +public class CookieJar { // 0,5 + + private List cookies; // 0,25 + + public CookieJar() { // 0,5 + cookies = new ArrayList<>(); // 0,25 + } + + public void addCookie(Cookie cookie) { // 0,5 + cookies.add(cookie); // 0,5 + } + + public StuffedCookie getStuffedCookie() { // 0,5 + for (int i = 0; i < cookies.size(); i++) { // 0,5 + Cookie cookie = cookies.get(i); // 0,5 + if (cookie instanceof StuffedCookie s) { // 1,5 + cookies.remove(s); // 0,5 + return s; // 0,5 + } + } + return null; // 0,5 + } + +} +``` + +```java title="IngredientsReader.java" showLineNumbers +public class IngredientsReader { // 0,5 + + public static List readIngredients(File file) throws FileNotFoundException { // 1 + Scanner sc = new Scanner(file); // 1 + + List ingredients = new ArrayList<>(); // 0,5 + while (sc.hasNextLine()) { // 1 + String line = sc.nextLine(); // 0,5 + Ingredient i = new Ingredient(line); // 0,5 + ingredients.add(i); // 0,5 + } + + sc.close(); + return ingredients; // 0,5 + } + +} +``` diff --git a/docs/additional-material/daniel/cheatsheet-java2.md b/docs/additional-material/daniel-java2/cheatsheet.md similarity index 52% rename from docs/additional-material/daniel/cheatsheet-java2.md rename to docs/additional-material/daniel-java2/cheatsheet.md index b5b23dee6b..fde3bcc21e 100644 --- a/docs/additional-material/daniel/cheatsheet-java2.md +++ b/docs/additional-material/daniel-java2/cheatsheet.md @@ -1,5 +1,5 @@ --- -title: Cheatsheet Programmierung 2 +title: Cheatsheet description: '' sidebar_position: 40 tags: [] @@ -7,124 +7,122 @@ tags: [] ## Java API -| Klasse | Methode | Rückgabetyp | -| ---------------- | --------------------------------------------------------------------------------- | ---------------- | -| Aufzählung | `valueOf(arg0: String)` | Aufzählung | -| Aufzählung | `values()` | Aufzählung[] | -| `Boolean` | `valueOf(s: String)`, `valueOf(b: boolean)` | `Boolean` | -| `Double` | `valueOf(s: String)`, `valueOf(d: double)` | `Double` | -| `Integer` | `valueOf(s: String)`, `valueOf(i: int)` | `Integer` | -| `LocalDateTime` | `getDayOfMonth()` | `int` | -| `LocalDateTime` | `getDayOfYear()` | `int` | -| `LocalDateTime` | `getHour()` | `int` | -| `LocalDateTime` | `getMinute()` | `int` | -| `LocalDateTime` | `getMonthValue()` | `int` | -| `LocalDateTime` | `getSecond()` | `int` | -| `LocalDateTime` | `getYear()` | `int` | -| `LocalDateTime` | `now()` | `LocalDateTime` | -| `LocalDateTime` | `of(year: int, month: int, dayOfMonth: int, hour: int, minute: int, second: int)` | `LocalDateTime` | -| `Object` | `equals(object: Object)` | `boolean` | -| `Object` | `hashCode()` | `int` | -| `Object` | `toString()` | `String` | -| `Optional` | `empty()` | `Optional` | -| `Optional` | `get()` | `T` | -| `Optional` | `ifPresent(action: Consumer)` | `void` | -| `Optional` | `ifPresentOrElse(action: Consumer, emptyAction: Runnable)` | `void` | -| `Optional` | `isPresent()` | `boolean` | -| `Optional` | `of(t: T), ofNullable(t: T)` | `Optional` | -| `Optional` | `orElse(other: T)` | `T` | -| `OptionalDouble` | `empty()` | `OptionalDouble` | -| `OptionalDouble` | `getAsDouble()` | `double` | -| `OptionalDouble` | `ifPresent(action: DoubleConsumer)` | `void` | -| `OptionalDouble` | `ifPresentOrElse(action: DoubleConsumer, emptyAction: Runnable)` | `void` | -| `OptionalDouble` | `isPresent()` | `boolean` | -| `OptionalDouble` | `of(value: double)` | `OptionalDouble` | -| `OptionalDouble` | `orElse(other: double)` | `double` | -| `PrintStream` | print-Methoden, println-Methoden | `void` | -| `Random` | `nextInt(bound: int)` | `int` | -| `Scanner` | `hasNextLine()` | `boolean` | -| `Scanner` | `next()` | `String` | -| `Scanner` | `nextBoolean()` | `boolean` | -| `Scanner` | `nextDouble()` | `double` | -| `Scanner` | `nextInt()` | `int` | -| `Scanner` | `nextLine()` | `String` | -| `String` | `charAt(index: int)` | `char` | -| `String` | `length()` | `int` | -| `String` | `split(regex: String)` | `String[]` | -| `String` | `toLowerCase()`, `toUpperCase()` | `String` | -| `System` | `currentTimeMillis()` | `long` | +| Klasse | Methode | Statisch | Rückgabetyp | +| ---------------- | ------------------------------------------------------------------- | -------- | ---------------- | +| Aufzählung | `valueOf(arg0: String)` | X | Aufzählung | +| Aufzählung | `values()` | X | Aufzählung[] | +| `Boolean` | `valueOf(s: String)`, `valueOf(b: boolean)` | X | `Boolean` | +| `Double` | `valueOf(s: String)`, `valueOf(d: double)` | X | `Double` | +| `Integer` | `valueOf(s: String)`, `valueOf(i: int)` | X | `Integer` | +| `LocalDate` | `getDayOfMonth()`, `getDayOfYear()`, `getMonthValue()`, `getYear()` | | `int` | +| `LocalDate` | `now()` | X | `LocalDate` | +| `LocalDate` | `of(year: int, month: int, dayOfMonth: int)` | X | `LocalDate` | +| `LocalTime` | `getHour()`, `getMinute()`, `getSecond()` | | `int` | +| `LocalTime` | `now()` | X | `LocalTime` | +| `LocalTime` | `of(hour: int, minute: int, second: int)` | X | `LocalTime` | +| `Object` | `equals(object: Object)` | | `boolean` | +| `Object` | `hashCode()` | | `int` | +| `Object` | `toString()` | | `String` | +| `Optional` | `empty()` | | `Optional` | +| `Optional` | `get()` | | `T` | +| `Optional` | `ifPresent(action: Consumer)` | | `void` | +| `Optional` | `ifPresentOrElse(action: Consumer, emptyAction: Runnable)` | | `void` | +| `Optional` | `isPresent()` | | `boolean` | +| `Optional` | `of(t: T), ofNullable(t: T)` | X | `Optional` | +| `Optional` | `orElse(other: T)` | | `T` | +| `OptionalDouble` | `empty()` | X | `OptionalDouble` | +| `OptionalDouble` | `getAsDouble()` | | `double` | +| `OptionalDouble` | `ifPresent(action: DoubleConsumer)` | | `void` | +| `OptionalDouble` | `ifPresentOrElse(action: DoubleConsumer, emptyAction: Runnable)` | | `void` | +| `OptionalDouble` | `isPresent()` | | `boolean` | +| `OptionalDouble` | `of(value: double)` | X | `OptionalDouble` | +| `OptionalDouble` | `orElse(other: double)` | | `double` | +| `PrintStream` | print-Methoden, println-Methoden | | `void` | +| `Random` | `nextInt(bound: int)` | | `int` | +| `Scanner` | `hasNextLine()` | | `boolean` | +| `Scanner` | `next()` | | `String` | +| `Scanner` | `nextBoolean()` | | `boolean` | +| `Scanner` | `nextDouble()` | | `double` | +| `Scanner` | `nextInt()` | | `int` | +| `Scanner` | `nextLine()` | | `String` | +| `String` | `charAt(index: int)` | | `char` | +| `String` | `length()` | | `int` | +| `String` | `split(regex: String)` | | `String[]` | +| `String` | `toLowerCase()`, `toUpperCase()` | | `String` | +| `System` | `currentTimeMillis()` | X | `long` | ## Java Collections Framework -| Klasse | Methode | Rückgabetyp | -| --------------- | ---------------------------------------------------------- | ------------------ | -| `ArrayList` | `add(e: E)` | `boolean` | -| `ArrayList` | `add(index: int, element: E)` | `void` | -| `ArrayList` | `contains(o: Object)` | `boolean` | -| `ArrayList` | `forEach(action: Consumer)` | `void` | -| `ArrayList` | `get(index: int)` | `E` | -| `ArrayList` | `remove(index: int)` | `E` | -| `ArrayList` | `remove(o: Object)` | `boolean` | -| `ArrayList` | `size()` | `int` | -| `Collections` | `sort(list: List, c: Comparator)` | `void` | -| `Entry` | `getKey()` | `K` | -| `Entry` | `getValue()` | `V` | -| `HashMap` | `containsKey(key: Object)`, `containsValue(value: Object)` | `boolean` | -| `HashMap` | `entrySet()` | `Set>` | -| `HashMap` | `forEach(action: BiConsumer)` | `void` | -| `HashMap` | `get(key: Object)` | `V` | -| `HashMap` | `keySet()` | `Set` | -| `HashMap` | `put(key: K, value: V)` | `V` | -| `HashMap` | `values()` | `Collection` | -| `List` | `of(elements: E...)` | `List` | +| Klasse | Methode | Statisch | Rückgabetyp | +| --------------- | ---------------------------------------------------------- | -------- | ------------------ | +| `ArrayList` | `add(e: E)` | | `boolean` | +| `ArrayList` | `add(index: int, element: E)` | | `void` | +| `ArrayList` | `contains(o: Object)` | | `boolean` | +| `ArrayList` | `forEach(action: Consumer)` | | `void` | +| `ArrayList` | `get(index: int)` | | `E` | +| `ArrayList` | `remove(index: int)` | | `E` | +| `ArrayList` | `remove(o: Object)` | | `boolean` | +| `ArrayList` | `size()` | | `int` | +| `Collections` | `sort(list: List, c: Comparator)` | X | `void` | +| `Entry` | `getKey()` | | `K` | +| `Entry` | `getValue()` | | `V` | +| `HashMap` | `containsKey(key: Object)`, `containsValue(value: Object)` | | `boolean` | +| `HashMap` | `entrySet()` | | `Set>` | +| `HashMap` | `forEach(action: BiConsumer)` | | `void` | +| `HashMap` | `get(key: Object)` | | `V` | +| `HashMap` | `keySet()` | | `Set` | +| `HashMap` | `put(key: K, value: V)` | | `V` | +| `HashMap` | `values()` | | `Collection` | +| `List` | `of(elements: E...)` | X | `List` | ## Funktionale Schnittstellen -| Klasse | Methode | Rückgabetyp | -| ------------------------ | ------------------------- | ----------- | -| `BiConsumer` | `accept(t: T, u: U)` | `void` | -| `Comparable` | `compareTo(o: T)` | `int` | -| `Comparator` | `compare(o1: T, o2: T)` | `int` | -| `Consumer` | `accept(t: T)` | `void` | -| `DoubleConsumer` | `accept(value: double)` | `void` | -| `Executable` | `execute()` | `void` | -| `Function` | `apply(t: T)` | `R` | -| `Predicate` | `test(t: T)` | `boolean` | -| `ToDoubleFunction` | `applyAsDouble(value: T)` | `double` | -| `ToIntFunction` | `applyAsInt(value: T)` | `int` | +| Klasse | Methode | Statisch | Rückgabetyp | +| ------------------------ | ------------------------- | -------- | ----------- | +| `BiConsumer` | `accept(t: T, u: U)` | | `void` | +| `Comparable` | `compareTo(o: T)` | | `int` | +| `Comparator` | `compare(o1: T, o2: T)` | | `int` | +| `Consumer` | `accept(t: T)` | | `void` | +| `DoubleConsumer` | `accept(value: double)` | | `void` | +| `Executable` | `execute()` | | `void` | +| `Function` | `apply(t: T)` | | `R` | +| `Predicate` | `test(t: T)` | | `boolean` | +| `ToDoubleFunction` | `applyAsDouble(value: T)` | | `double` | +| `ToIntFunction` | `applyAsInt(value: T)` | | `int` | ## Java Stream API -| Klasse | Methode | Rückgabetyp | -| -------------- | -------------------------------------------------------------------------------------------------------------- | ---------------------------------- | -| `Collectors` | `toList()` | `Collector>` | -| `Collectors` | `toMap(keyMapper: Function, valueMapper: Function)` | `Collector` | -| `Collectors` | `groupingBy(classifier: Function)` | `Collector>>` | -| `DoubleStream` | `average()` | `OptionalDouble` | -| `DoubleStream` | `sum()` | `double` | -| `IntStream` | `average()` | `OptionalDouble` | -| `IntStream` | `sum()` | `int` | -| `Stream` | `allMatch(predicate: Predicate)`, `anyMatch(predicate: Predicate)`, `noneMatch(predicate: Predicate)` | `boolean` | -| `Stream` | `collect(collector: Collector)` | `R` | -| `Stream` | `count()` | `long` | -| `Stream` | `distinct()` | `Stream` | -| `Stream` | `filter(predicate: Predicate)` | `Stream` | -| `Stream` | `findAny(), findFirst()` | `Optional` | -| `Stream` | `forEach(action: Consumer)` | `void` | -| `Stream` | `limit(maxSize: long)` | `Stream` | -| `Stream` | `map(mapper: Function)` | `Stream` | -| `Stream` | `mapToDouble(mapper: ToDoubleFunction)` | `DoubleStream` | -| `Stream` | `mapToInt(mapper: ToIntFunction)` | `IntStream` | -| `Stream` | `max(comparator: Comparator), min(comparator: Comparator)` | `Optional` | -| `Stream` | `skip(n: long)` | `Stream` | -| `Stream` | `sorted()`, `sorted(comparator: Comparator)` | `Stream` | +| Klasse | Methode | Statisch | Rückgabetyp | +| -------------- | -------------------------------------------------------------------------------------------------------------- | -------- | ---------------------------------- | +| `Collectors` | `toList()` | X | `Collector>` | +| `Collectors` | `toMap(keyMapper: Function, valueMapper: Function)` | X | `Collector` | +| `Collectors` | `groupingBy(classifier: Function)` | X | `Collector>>` | +| `DoubleStream` | `average()` | | `OptionalDouble` | +| `DoubleStream` | `sum()` | | `double` | +| `IntStream` | `average()` | | `OptionalDouble` | +| `IntStream` | `sum()` | | `int` | +| `Stream` | `allMatch(predicate: Predicate)`, `anyMatch(predicate: Predicate)`, `noneMatch(predicate: Predicate)` | | `boolean` | +| `Stream` | `collect(collector: Collector)` | | `R` | +| `Stream` | `count()` | | `long` | +| `Stream` | `distinct()` | | `Stream` | +| `Stream` | `filter(predicate: Predicate)` | | `Stream` | +| `Stream` | `findAny(), findFirst()` | | `Optional` | +| `Stream` | `forEach(action: Consumer)` | | `void` | +| `Stream` | `limit(maxSize: long)` | | `Stream` | +| `Stream` | `map(mapper: Function)` | | `Stream` | +| `Stream` | `mapToDouble(mapper: ToDoubleFunction)` | | `DoubleStream` | +| `Stream` | `mapToInt(mapper: ToIntFunction)` | | `IntStream` | +| `Stream` | `max(comparator: Comparator), min(comparator: Comparator)` | | `Optional` | +| `Stream` | `skip(n: long)` | | `Stream` | +| `Stream` | `sorted()`, `sorted(comparator: Comparator)` | | `Stream` | +| `Stream` | `toList()` | | `List` | ## JUnit 5 -| Klasse | Methode | Rückgabetyp | -| ------------ | ----------------------------------------------------------------------------------------------------- | ----------- | -| `Assertions` | `assertEquals(expected: Object, actual: Object)`, `assertNotEquals(expected: Object, actual: Object)` | `void` | -| `Assertions` | `assertNull(actual: Object)`, `assertNotNull(actual: Object)` | `void` | -| `Assertions` | `assertSame(expected: Object, actual: Object)`, `assertNotSame(expected: Object, actual: Object)` | `void` | -| `Assertions` | `assertThrows(expectedType: Class, executable: Executable)` | `T` | -| `Assertions` | `assertTrue(condition: boolean)`, `assertFalse(condition: boolean)` | `void` | +| Klasse | Methode | Statisch | Rückgabetyp | +| ------------ | ----------------------------------------------------------------------------------------------------- | -------- | ----------- | +| `Assertions` | `assertEquals(expected: Object, actual: Object)`, `assertNotEquals(expected: Object, actual: Object)` | X | `void` | +| `Assertions` | `assertNull(actual: Object)`, `assertNotNull(actual: Object)` | X | `void` | +| `Assertions` | `assertSame(expected: Object, actual: Object)`, `assertNotSame(expected: Object, actual: Object)` | X | `void` | +| `Assertions` | `assertThrows(expectedType: Class, executable: Executable)` | X | `T` | +| `Assertions` | `assertTrue(condition: boolean)`, `assertFalse(condition: boolean)` | X | `void` | diff --git a/docs/additional-material/daniel-java2/daniel-java2.md b/docs/additional-material/daniel-java2/daniel-java2.md new file mode 100644 index 0000000000..a310dcb4e6 --- /dev/null +++ b/docs/additional-material/daniel-java2/daniel-java2.md @@ -0,0 +1,10 @@ +--- +title: Daniel (Programmierung 2) +description: '' +sidebar_position: 25 +tags: [] +--- + +import DocCardList from '@theme/DocCardList'; + + diff --git a/docs/additional-material/daniel-java2/exam-results.md b/docs/additional-material/daniel-java2/exam-results.md new file mode 100644 index 0000000000..ecbf076b11 --- /dev/null +++ b/docs/additional-material/daniel-java2/exam-results.md @@ -0,0 +1,31 @@ +--- +title: Klausurergebnisse +description: '' +sidebar_position: 60 +tags: [] +--- + +## Klausur Q2 2023 + +```mermaid +pie title 1/10 + "50+ Punkte" : 4 + "40-49 Punkte" : 18 + "30-39 Punkte" : 10 + "20-29 Punkte" : 12 + "10-19 Punkte" : 10 + "0-9 Punkte" : 9 +``` + +```mermaid +pie title 1/3 + "34-50 Punkte" : 26 + "18-33 Punkte" : 21 + "0-32 Punkte" : 16 +``` + +```mermaid +pie title 1/2 + "25-50 Punkte" : 37 + "0-24 Punkte" : 26 +``` diff --git a/docs/additional-material/daniel/sample-exam-java2.md b/docs/additional-material/daniel-java2/sample-exam.md similarity index 69% rename from docs/additional-material/daniel/sample-exam-java2.md rename to docs/additional-material/daniel-java2/sample-exam.md index 262c7e3c94..1d017152f6 100644 --- a/docs/additional-material/daniel/sample-exam-java2.md +++ b/docs/additional-material/daniel-java2/sample-exam.md @@ -1,5 +1,5 @@ --- -title: Musterklausur Programmierung 2 +title: Musterklausur description: '' sidebar_position: 20 tags: [] @@ -7,12 +7,16 @@ tags: [] ## Hinweise zur Klausur +- Die in dieser Klausur verwendeten Personenbezeichnungen beziehen sich – sofern + nicht anders kenntlich gemacht – auf alle Geschlechter +- Es kann davon ausgegangen werden, dass sämtliche Klassen entsprechende + Implementierungen der Object-Methoden besitzen - Der Stereotyp `<>` impliziert, dass die Datenklasse einen entsprechenden Konstruktor, Getter zu allen Attributen sowie entsprechende - Implementierungen für die Object-Methoden besitzt + Implementierungen der Object-Methoden besitzt - Der Stereotyp `<>` impliziert, dass die Aufzählung einen - passenden, privaten Konstruktor sowie ggbfs. passende Setter und Getter - besitzt + passenden, privaten Konstruktor sowie gegebenenfalls passende Getter für alle + Attribute besitzt - Pakete und Klassenimporte müssen nicht angegeben werden - Für die Konsolenausgabe kann das Kürzel _sysout_ verwendet werden - Methoden- und Attributsbezeichner dürfen sinnvoll gekürzt geschrieben werden @@ -82,36 +86,33 @@ classDiagram } ``` -### Hinweise zur Testklasse SuperLeagueTest +### Hinweise zur Klasse SuperLeagueTest - Die Lebenszyklus-Methode `void setUp()` soll das nachfolgende Testszenario aufbauen: - - Es soll ein DC-Superheld mit dem Namen _Superman_ und der Stärke 10 erstellt - und dem Attribut `superman` zugewiesen werden - - Es soll ein MARVEL-Superheld mit dem Namen _Iron Man_ und der Stärke 7 - erstellt und dem Attribut `ironman` zugewiesen werden - - Es soll ein MARVEL-Superheld mit dem Namen _Spider-Man_ und der Stärke 8 - erstellt und dem Attribut `spiderman` zugewiesen werden + - Es sollen die Superhelden Superman (DC, Stärke 10), Iron Man (MARVEL, 7) und + Spider-Man (MARVEL, 8) erstellt und den entsprechenden Attributen zugewiesen + werden - Es soll eine MARVEL-Superheldenliga mit dem Namen _Avengers_ erstellt und - dem Attribut `avengers` zugewiesen werden + dem entsprechenden Attribut zugewiesen werden - Die Superhelden Iron Man und Spider-Man sollen den Avengers als verfügbaren - Superhelden hinzugefügt werden. Es muss dabei berücksichtigt werden, dass - die Methode `void addSuperHuman(t: T)` die Ausnahme `WrongUniverseException` - auslösen kann + Superhelden hinzugefügt werden - Der Superheld mit dem Namen Spider-Man soll auf eine Mission geschickt werden -- Die Testmethode `void testAddSuperHuman()` soll den nachfolgenden Testfall - abdecken: Beim Aufruf der Methode `void addSuperHuman(t: T)` auf das Attribut - `avengers` mit dem Wert `superman` wird die Ausnahme `WrongUniverseException` - erwartet -- Die Testmethode `void testGetAllAvailableSuperHumans()` soll den nachfolgenden - Testfall abdecken: Beim Aufruf der Methode - `List getAllAvailableSuperHumans()` auf das Attribut `avengers` wird als - Rückgabe eine Liste der Größe 1 erwartet -- Die Testmethode `void testGetMostPowerfulSuperHuman()` soll den nachfolgenden - Testfall abdecken: Beim Aufruf der Methode - `Optional getMostPowerfulSuperHuman()` auf das Attribut `avengers` wird als - Rückgabe der Superheld mit dem Namen _Spider-Man_ als Optional erwartet +- Die Testmethode `void testAddSuperHuman()` soll prüfen, ob beim Aufruf der + Methode `void addSuperHuman(t: T)` auf das Attribut `avengers` mit dem Wert + `superman` die Ausnahme `WrongUniverseException` ausgelöst wird +- Die Testmethode `void testGetAllAvailableSuperHumans()` soll prüfen, ob beim + Aufruf der Methode `List getAllAvailableSuperHumans()` auf das Attribut + `avengers` eine Liste der Größe 1 zurückgegeben wird +- Die Testmethode `void testGetMostPowerfulSuperHuman()` soll prüfen, ob beim + Aufruf der Methode `Optional getMostPowerfulSuperHuman()` auf das Attribut + `avengers` der Superheld Spider-Man als Optional zurückgegeben wird + +### Hinweis zur Klasse SuperLeague + +Die Methode `void addSuperHuman(t: T)` kann die Ausnahme +`WrongUniverseException` auslösen. ### Musterlösung @@ -222,7 +223,8 @@ classDiagram ### Musterlösung ```java title="SuperLeage.java" showLineNumbers -public record SuperLeague(String name, Universe universe, HashMap members) { // 1 +public record SuperLeague members) { // 1 public Optional getMostPowerfulSuperHuman() { // 0,5 T mostPowerfulSuperHuman = null; // 0,5 @@ -313,51 +315,25 @@ classDiagram ### Hinweise zur Klasse SingleQueries -- Die statische Methode - `void printAllSinglesWithMoreThan25MillionSalesPerCountry()` soll alle - Singles, die sich mehr als 25 Millionen mal verkauft haben, gruppiert nach dem - Land in der Form _[Land\]: [[Single\], [Single\],...\]_ ausgeben -- Die statische Methode `void printAverageBirthYearOfAllDeceasedArtists()` soll - das durchschnittliche Geburtsjahr aller verstorbenen Künstler bzw. aller +- Die Methode `void printAllSinglesWithMoreThan25MillionSalesPerCountry()` soll + alle Singles, die sich mehr als 25 Millionen mal verkauft haben, gruppiert + nach dem Land in der Form _[Land\]: [[Single\], [Single\],...\]_ ausgeben +- Die Methode `void printAverageBirthYearOfAllDeceasedArtists()` soll das + durchschnittliche Geburtsjahr aller verstorbenen Künstler bzw. aller verstorbenen Künstlerinnen ausgeben. Für den Fall, dass es keinen verstorbenen Künstler bzw. keine verstorbene Künstlerin gibt, soll der Wert -1 ausgegeben werden -- Die statische Methode - `boolean isAnySingleFromChinaWithMoreThan10MillionSales()` soll zurückgeben, - ob es eine Single eines Künstlers bzw. einer Künstlerin aus China gibt, - welches sich mehr als 10 Millionen Mal verkauft hat -- Die statische Methode - `List getTop3SinglesOfThisCenturyBySalesInMillions()` soll die 3 am - häufigsten verkauften Singles des jetzigen Jahrtausends sortiert nach der - Anzahl Verkäufe in Millionen in der Form _[Name der Single\]: [Name des +- Die Methode `boolean isAnySingleFromChinaWithMoreThan10MillionSales()` soll + zurückgeben, ob es eine Single eines Künstlers bzw. einer Künstlerin aus China + gibt, welches sich mehr als 10 Millionen Mal verkauft hat +- Die Methode `List getTop3SinglesOfThisCenturyBySalesInMillions()` soll + die 3 am häufigsten verkauften Singles des jetzigen Jahrtausends sortiert nach + der Anzahl Verkäufe in Millionen in der Form _[Name der Single\]: [Name des Künstlers bzw. Name der Künstlerin\], [Verkäufe in Millionen\] Millionen_ zurückgeben -- Die statische Methode `List getAllSinglesFromEdSheeran()` soll alle - Singles des Künstlers Ed Sheeran (Land: Großbritannien, Geburtstag: - 17.02.1991, Status: lebendig) zurückgeben - -### Beispielhafte Konsolenausgabe - -```console -printAllSinglesWithMoreThan25MillionSalesPerCountry: -CHN: [Single[name=Spotlight, artist=Artist[name=Xiao Zhan, country=CHN, birthdate=1991-10-05, -isAlive=true], salesInMillion=33, publishingYear=2020],...] -GBR: [Single[name=Shape of You, artist=Artist[name=Ed Sheeran, country=GBR, birthdate=1991-02-17, -isAlive=true], salesInMillion=42, publishingYear=2017],...] -... - -printAverageBirthYearOfAllDeceasedArtists: -1915.75 - -isAnySingleFromChinaWithMoreThan10MillionSales: -true - -getTop3SinglesOfThisCenturyBySalesInMillions: -[Shape of You: Ed Sheeran, 42 Millionen, Despacito: Luis Fonsi, 36 Millionen, Spotlight: Xiao Zhan, 33 Millionen,...] - -getAllSinglesFromEdSheeran: -[Single[name=Shape of You, artist=Artist[name=Ed Sheeran, country=GBR, birthdate=1991-02-17, isAlive=true], salesInMillions=42, publishingYear=2017], Single[name=Perfect, artist=Artist[name=Ed Sheeran, country=GBR, birthdate=1991-02-17, isAlive=true], salesInMillions=21, publishingYear=2017],...] -``` +- Die Methode `List getAllSinglesFromEdSheeran()` soll alle Singles des + Künstlers Ed Sheeran (Land: Großbritannien, Geburtstag: 17.02.1991, Status: + lebendig) zurückgeben ### Musterlösung @@ -365,23 +341,23 @@ getAllSinglesFromEdSheeran: public record SingleQueries(List singles) { // 1 private void a() { // 0,5 - Map> x = singles.stream() // 1 + Map> tmp = singles.stream() // 1 .filter(a -> a.salesInMillions() > 25) // 0,5 .collect(Collectors.groupingBy(a -> a.artist().country())); // 1 - x.forEach((c, sl) -> System.out.println(c + ": " + sl); // 1 + tmp.forEach((c, sl) -> System.out.println(c + ": " + sl); // 1 } } private void b() { // 0,5 - OptionalDouble x = singles.stream() // 1 + OptionalDouble tmp = singles.stream() // 1 .map(a -> a.artist()) // 0,5 .distinct() // 0,5 .filter(a -> !a.isAlive()) // 0,5 .mapToInt(a -> a.birthdate().getYear()) // 1 .average(); // 0,5 - x.ifPresentOrElse(System.out::println, () -> System.out.println(-1)); // 1 + tmp.ifPresentOrElse(System.out::println, () -> System.out.println(-1)); // 1 } private boolean c() { // 0,5 @@ -401,7 +377,8 @@ public record SingleQueries(List singles) { // 1 private List e() { // 0,5 return singles.stream() // 1 - .filter(a -> a.artist().equals(new Artist("Ed Sheeran", Country.GBR, LocalDate.of(1991, 2, 17), true))) // 1 + .filter(a -> a.artist().equals( + new Artist("Ed Sheeran", Country.GBR, LocalDate.of(1991, 2, 17), true))) // 1 .collect(Collectors.toList()); // 0,5 } diff --git a/docs/additional-material/daniel/cheatsheet-java1.md b/docs/additional-material/daniel/cheatsheet-java1.md deleted file mode 100644 index f52eef8bcf..0000000000 --- a/docs/additional-material/daniel/cheatsheet-java1.md +++ /dev/null @@ -1,62 +0,0 @@ ---- -title: Cheatsheet Programmierung 1 -description: '' -sidebar_position: 30 -tags: [] ---- - -## Java API - -| Klasse | Methode | Rückgabetyp | -| --------------- | --------------------------------------------------------------------------------- | --------------- | -| Aufzählung | `valueOf(arg0: String)` | Aufzählung | -| Aufzählung | `values()` | Aufzählung[] | -| `Boolean` | `valueOf(s: String)`, `valueOf(b: boolean)` | `Boolean` | -| `Double` | `valueOf(s: String)`, `valueOf(d: double)` | `Double` | -| `Integer` | `valueOf(s: String)`, `valueOf(i: int)` | `Integer` | -| `LocalDateTime` | `getDayOfMonth()` | `int` | -| `LocalDateTime` | `getDayOfYear()` | `int` | -| `LocalDateTime` | `getHour()` | `int` | -| `LocalDateTime` | `getMinute()` | `int` | -| `LocalDateTime` | `getMonthValue()` | `int` | -| `LocalDateTime` | `getSecond()` | `int` | -| `LocalDateTime` | `getYear()` | `int` | -| `LocalDateTime` | `now()` | `LocalDateTime` | -| `LocalDateTime` | `of(year: int, month: int, dayOfMonth: int, hour: int, minute: int, second: int)` | `LocalDateTime` | -| `Object` | `equals(object: Object)` | `boolean` | -| `Object` | `hashCode()` | `int` | -| `Object` | `toString()` | `String` | -| `PrintStream` | print-Methoden, println-Methoden | `void` | -| `Random` | `nextInt(bound: int)` | `int` | -| `Scanner` | `hasNextLine()` | `boolean` | -| `Scanner` | `next()` | `String` | -| `Scanner` | `nextBoolean()` | `boolean` | -| `Scanner` | `nextDouble()` | `double` | -| `Scanner` | `nextInt()` | `int` | -| `Scanner` | `nextLine()` | `String` | -| `String` | `charAt(index: int)` | `char` | -| `String` | `length()` | `int` | -| `String` | `split(regex: String)` | `String[]` | -| `String` | `toLowerCase()`, `toUpperCase()` | `String` | -| `System` | `currentTimeMillis()` | `long` | - -## Java Collections Framework - -| Klasse | Methode | Rückgabetyp | -| -------------- | --------------------------------------- | ----------- | -| `ArrayList` | `add(e: E)` | `boolean` | -| `ArrayList` | `add(index: int, element: E)` | `void` | -| `ArrayList` | `contains(o: Object)` | `boolean` | -| `ArrayList` | `get(index: int)` | `E` | -| `ArrayList` | `remove(index: int)` | `E` | -| `ArrayList` | `remove(o: Object)` | `boolean` | -| `ArrayList` | `size()` | `int` | -| `Collections` | `sort(list: List, c: Comparator)` | `void` | -| `List` | `of(elements: E...)` | `List` | - -## Funktionale Schnittstellen - -| Klasse | Methode | Rückgabetyp | -| --------------- | ----------------------- | ----------- | -| `Comparable` | `compareTo(o: T)` | `int` | -| `Comparator` | `compare(o1: T, o2: T)` | `int` | diff --git a/docs/additional-material/daniel/sample-exam-java1.md b/docs/additional-material/daniel/sample-exam-java1.md deleted file mode 100644 index c2e95cff53..0000000000 --- a/docs/additional-material/daniel/sample-exam-java1.md +++ /dev/null @@ -1,8 +0,0 @@ ---- -title: Musterklausur Programmierung 1 -description: '' -sidebar_position: 10 -tags: [] ---- - -tbd