Zusammenfassung Lernstoff für POS-Wh-Prüfung 2324

Hier noch zur besseren Übersicht eine noch unfertige Zusammenfassung:

In Arbeit ...

1. Schwerpunkte PLF-1

1.1. Vererbung Grundlagen

  • Vererbung mit Schlüsselwort extends:
    public class Schueler extends Person {…​}

  • Methoden (und Attribute) die "weiter oben" in der Vererbungshierarchie implementiert und nicht private oder package-sichtbar (ohne Sichtbarkeits-Schlüsselwort) sind, können von allen erbenden Klassen mitgenutzt, aber auch spezifisch überschrieben (override) werden.

  • Polymorphie: Die richtige Methodenversion wird dynamisch zur Laufzeit festgestellt und aufgerufen (die "nächstgelegene"/spezifischeste Implementation)

  • Konstruktoren: Als erstes Statement entweder expliziter Aufruf des Superkonstruktors: super(param1, param2, …​) oder, falls expliziter Aufruf fehlt und in Superklasse ein Default-Konstruktor existiert, wird dieser implizit aufgerufen. Andernfalls: Compilerfehler.

  • V.a. bei Override: Zugriff auf implementierte Methoden der Superklasse (oder darüber) mit super.methodName()

  • Statische Methoden, Klassenvariabeln, Konstante und Konstruktoren liegen außerhalb der Vererbungslogik!!

1.2. Exceptions

  • Checked Exceptions (erben von Exception) und Unchecked Exceptions (erben von RuntimeException, das seinerseits von Exception erbt)

  • try-catch (nicht wirklich besprochen: -finally)

  • Werfen von Exceptions mit throw new SomeExceptionType("Message") o.ä.

  • Checked Exceptions müssen im Methodenkopf deklariert werden, wenn sie im Rumpf geworfen werden könnten (selbst direkt oder innerhalb verwendeten Codes): public void someMethod() throws SomeCheckedException {…​}. Damit werden sie an den Aufrufer weitergereicht, der sie entweder selbst behandeln muss oder ebenfalls weiterreichen kann (spätestens die Virtuelle Maschine selbst reagiert mit Programmabbruch und "Stacktrace").

  • Erstellen eigener Exceptions durch Erben von Exception oder RuntimeException und Implementation der benötigten Konstruktoren (oft 3 mit den Parameterlisten String message, Throwable cause und String message, Throwable cause)

  • Bei Bedarf können auch zusätzlich Attribute definiert werden, die die Exception-Instanz mit sich trägt und die im Konstruktor gesetzt werden (meist mit zusätzlichem Parameter).
    Dann ist auch ein Getter oder eine andere Methode nötig, um diese Attribute zu nutzen.

1.3. Interfaces

Java hat nur Einfachvererbung, aber jede Klasse kann beliebig viele Interfaces implementieren.
Diese werden mit implements eingebunden und können enthalten:

  • Deklarationen von Methoden (wie abstrakte Methoden)

  • Deklarationen von Konstanten (wie in Klassen)

  • Implementationen von static Methoden (wie in Klassen)

  • Implementationen von default Methoden (noch nicht unterrichtet)

1.4. Collections

  • Basics zu Generics

  • Generic Interfaces Collection, List, Set (List, Set "extends" Collection!)

  • Wichtige Operationen Collection: add, remove, contains, size, isEmpty, clear etc.

  • Wichtige zusätzliche Methoden von List und Set

  • Maps (Sammlungen von Schlüssel-Wert-Paaren)

  • Methoden boolean equals(Object other) und int hashCode()

1.5. Sortieren von Collections

  • Basis ist entweder compareTo(other) ("natürliche Ordnung", Voraussetzung: Elemente implementieren Comparable)
    Sortierung nach der "natürlichen Ordnung" erfolgt entweder mit Collections.sort(eineListe) oder eineListe.sort(null) wenn Elemente Comparable implementieren

  • oder Verwendung eines Comparator-Objekts, das von Interface Comparator abgeleitet ist. Das kann entweder über eine eigene (eventuell eingebettete oder sogar anonyme) Klasse oder über einen Lambda-Ausdruck erfolgen – z.B.:

    eineListe.sort(new Comparator() {   // anonyme Klasse
        public int compare(Object o1, Object o2) {
            int cmp = o1.getSomeAttribute().compareTo(o2.getSomeAttribute());
            if (cmp == 0) {
                cmp = o1.getSomeIntAttribute() - o2.getSomeIntAttribute();
            }
            // u.U. weitere Vergleichslogik
            return cmp;
        }
    });

Weiteres siehe

In Arbeit ...

2. Schwerpunkte PLF-2 (Liste Koll. Lackinger)

2.1. Die in den letzten Beispielen verwendeten Konzepte, z.B.:

  • Maven-Projekt konfigurieren (erster Lauf HelloApplication z. Download, Source und Javadoc herunterladen)

  • Serialisierung (Import Serializable, Schreiben mit ObjectOutputStream, Lesen mit ObjectInputStream)

  • MVC

  • Layout (z.B. BorderLayout, GridPane, HBox, VBox, …​)

MenuBar, Menu, MenuItem

TextField, Button, Label, CheckBox, RadioButton, ToggleGroup, etc.

ComboBox, ListView (mit ObservableList)

Alert

Dialog (mit ResultConverter, Filter bei Fehler)

EventFilter

EventHandler

MouseEvent

WindowEvent

ChangeListener (an Properties)

Switch zw. Views

Properties (OPTIONAL, max. f. Bonus-Aufgaben)

2.2. Serialization

https://www.baeldung.com/java-serialization [Introduction to Java Serialization | Baeldung] …​ 2024-05-08

https://www.tutorialspoint.com/java/java_serialization.htm [Java - Serialization] …​ 2024-05-08

2.3. Events und Listeners

(z.B. EventHandler, ChangeListener, InvalidationListener, …​)

https://www.tutorialspoint.com/javafx/javafx_event_handling.htm [JavaFX - Event Handling] …​ 2024-05-08 https://taylorial.com/gui/fxevents/ [taylorial.com] …​ 2024-05-08

https://stackoverflow.com/questions/45117076/javafx-invalidationlistener-or-changelistener [java - JavaFX InvalidationListener or ChangeListener - Stack Overflow] …​ 2024-05-08

Dokument noch in Arbeit (Stand: 2023-12-30 15:40) !!
Es werden noch Links auf die entsprechenden Unterlagen-Seiten u.ä. eingefügt, u.U. Vergessenes ergänzt.

Im Prinzip ist der gesamte aktuelle Stoff Thema.

Hier eine provisorische Liste der wichtigsten Themen (hoffentlich nichts vergessen):

2.4. Schwerpunkte zur PLF-2:

Neben den unten angeführten Themen der letzten PLF liegt der Schwerpunkt diesmal in folgenden Themen:

  • Projekttyp Maven

    • Zuerst Erstellen eines "Empty Project" in IntelliJ: Menü File  New  Project…​, im Formular links oben 2. Eintrag: Empty Project.
      Feld Name liefert Verzeichnisname des Projekts (für PLF immer eigener Nachname – Anfangsbuchstabe GROSS, Rest klein), Feld Location ist das Basis-Verzeichnis (für PLF immer Z:\), in dem das Projekt-Verzeichnis <Name> angelegt wird.

    • Dann gerade erzeugtes IntelliJ-Projekt auswählen und danach mit Menü File  New  Module…​, im Formular links oben 1. Eintrag: New Module selektieren, Feld Name liefert Modul-Name (sollte aus Kleinbuchstaben, Ziffern und '-' ab 2. Stelle bestehen). Dieser ist per Default auch die Maven-ArtifactId), Feld Location sollte den Verzeichnispfad des zuvor ausgewählten IntelliJ-Projekts enthalten (). für PLF immer eigener nachname (ALLES kleinbuchstaben).

    • Import bestehender Source-Code in neu erstelltes Maven-Projekt:

      • Komplettes Basis-Package der Quelle (mit alles Sub-Packages und Java-Dateien) in das Ziel-Verzeichnis src/main/java kopieren

      • mit Refactor-Rename (wenn schwerere Java-Fehler bestehen, funktioniert nicht alles automatisch) das kopierte Package umbenennen

    • Setzen Java-Version und Encoding (maven.compiler.source, maven.compiler.target und project.build.sourceEncoding) in pom.xml

  • JUnit 5 via Maven, einfache Tests implementieren

    • Annotations @Test, @BeforeEach, @AfterEach, @BeforeAll, @AfterAll

    • Test hinzufügen (Strg+Einfg), im Formular fehlendes JUnit5 fixen

    • AssertEquals

    • AssertTrue, AssertFalse

    • assertNull, assertNotNull

    • AssertThrows

  • List (mit generic Type)
    Deklaration: List<ElementType> list = new ArrayList<>(); (Typ möglichst allgemein – oft Interface)

  • Set hat keine definierte Ordnung → iterierbar nur mit "enhanced for" oder Iterator
    (Sicheres Entfernen mehrerer Elemente nur jeweils für aktuelles Element: theIterator.remove(); !!)
    Einzelnes Element kann gefahrlos mit theSet.remove(theElem); break; entfernt werden!

  • Map mit keySet(), values() (oder auch – nicht besprochen – entrySet()).
    Iteration mit

    • keySet() (z.B. for (KeyTyp k : map.keySet()) { …​ } ) oder

    • values() (z.B. for (ValueTyp v : map.values()) { …​ } ) oder

    • entrySet() (z.B. for (Map.Entry<KeyTyp, ValueTyp> entry : map.entrySet()) { …​ } )

    • oder Iterator (z.B. Iterator<KeyTyp> it = map.keySet().iterator(); while (it.hasNext()) { KeyTyp k = it.next(); …​ } )

  • Interface Comparable ("natürliche" Ordnung einer Klasse) mit this.compareTo(other)

  • Interface Comparator (zusätzliche Ordnung einer Klasse) mit comparator.compare(o1, o2)

  • sowohl this.compareTo(other) als auch compare(obj1, obj2) liefern int-Wert:

    • negativ: this bzw. obj1 ist kleiner als other bzw. obj2

    • 0: this bzw. obj1 ist gleich other bzw. obj2

    • positiv: this bzw. obj1 ist größer als other bzw. obj2

    Relation (kleiner, gleich, größer) immer bezogen auf den ersten Wert (this oder obj1 !!!). Zahlenwert ist IRRELEVANT !

  • Text-Dateien lesen und schreiben (mit FileReader, FileWriter, BufferedReader, BufferedWriter, PrintWriter).

    • Try with Resources (try mit Klammern, in denen die Reader/Writer-Objekte erzeugt werden, kein zwingendes catch! )

    • FileWriter-Objekt erzeugen mit Anfügen am Ende statt Neuschreiben: Konstruktor mit 2. Parameter boolean append auf true.

    • Zeilenweises Lesen mit aBufferedReader.readLine() mit:
      while ((line = br.readLine()) != null) { …​ }

    • Zeilenweises Schreiben mit
      aBufferedWriter.write(String s); aBufferedWriter.newLine() oder mit aPrintWriter.println(String s) (mit automatischem Zeilenvorschub)

3. Lernstoff 2CHIF für PLF-3 am Di,2024-04-03

Original siehe Moodle!

  1. JavaFx

    1. Stage: Änderung von Icon, Titel und Größe

    2. Panes: BorderPane,GridPane, VBox, HBox, FlowPane, TitledPane, Accordion

      1. Richtige Verwendung

      2. Einfügen von Abständen (Padding, Spacing, Gaps)

      3. Zugriff auf die Elemente mit getChildren() (ausser GridPane und BorderPane)

      4. Löschen von Elementen getChildren().remove(…) … auch bei GridPane!

    3. Subklassen von Shape: Circle, Rectangle, Polygon in Pane

    4. GUI Componenten : TextField, TextArea, Label, Button, RadioButtons (gekoppelt mit ToggleGroup), CheckBox (mit Image), MenuBar (mit Menu - und MenuItem- Elementen)

    5. ImageView – inkl. Größenänderung, Fileangabe (absolut/relativ)

    6. FileChooser bzw. DirectoryChooser (inkl. Verwendung der Klasse File und deren Methoden, Realisierung modal), ColorPicker

    7. Backgroundfarbe ändern, (Font ändern), Fill ändern, Border

    8. EventHandler zum Reagieren auf Ereignisse: ActionEvent, WindowEvent, MouseEvent, KeyEvent, …. MenuBar (mit Elementen und EventHandler)

    9. EventFilter zum Abfangen/Konsumieren von Events

    10. WICHTIG: Aufteilung model, view und control !

    11. Dialoge: Alert, ChoiceDialog, TextInputdialog

      1. Auswertung (Welcher Button wurde gedrückt)

      2. Returnwert (Optional) weiterverwenden

  2. … und für das Model

    1. CharacterStreams/ByteStreams:

      1. Daten lesen und speichern mit Hilfe von Serialisierung

    2. File: anwenden von existierenden Methoden (delete(), exists(), length(),…)

    3. Exception Handling bei falscher Benutzereingabe

    4. Vererbung

      1. abgeleitete Klassen

      2. Verwenden des super Keywords im Konstruktor und in Methoden

      3. Verwenden aller Zugriffsmodifizierer – auch protected und/oder default (gar kein Modifizierer)

      4. Verwendung abstrakter Klassen und Interfaces v. Collections.sort(…​)
        Comparable, Comparator

      5. Überschreiben von Methoden (Polymorphie)

      6. Überschreiben der equals(..) Methode zur Verwendung der ArrayList Methoden remove(Object o) und contains(Object o).

  3. … und für den Controller

    1. Das Zusammenspiel von MVC muss funktionieren

    2. z.B. Spielstand muss (in Attributen) gemerkt werden

    3. Es muss festgestellt werden, von welcher Komponente das Event ausgelöst wurde (instanceof, UserData)

    4. Mögliche fehlerhafte Benutzereingaben müssen abgefangen und im GUI angezeigt werden (z.B. durch Dialoge oder Error-Labels)

    5. Es darf nur eine Instanz von Model, View (inkl. primaryStage), Controller – Instanzen erzeugt werden, diese werden als Parameter im Konstruktor „weitergegeben“

4. Lernstoff 2CHIF für PLF-4 am Di,2024-05-14

4.1. Schwerpunkte

Die in den letzten Beispielen verwendeten Konzepte, z.B.:

  • JavaFX-Projekt auf Laufwerk Z: erstellen mit GroupID plf4, ArtifactID meier (eigener Nachname in Kleinbuchstaben). Daraus ergibt sich ein Package-Name plf4.meier.

  • Maven-Projekt konfigurieren:

    1. POM-File kontrollieren bzw. ausbessern

    2. Rechtsklick darauf, im Popup-Menü " + Add as Maven Project"

    3. erster Lauf HelloApplication z. Download der JavaFX-Bibliotheken (Fortschrittsbalken unten sichtbar)

    4. Source und Javadoc herunterladen (nun müsste in Zeile …​ = new Scene(…​) width und height eingeblendet werden)

  • Serialisierung: Import Serializable, Schreiben mit ObjectOutputStream, Lesen mit ObjectInputStream

  • Sortieren von Listen mit liste.sort(new Comparator<Typ>()) (siehe List - sort)

  • Erzeugen gefilterte Listen aus bestehenden Listen

  • Rethrowen von Checked Exceptions als Unchecked Exc. mit Weitergabe des Exception-Objekts (wichtig z.B. in Lambda-Ausdrücken, wo in der zugrunde liegenden Interface-Def. oft keine Checked Exc. vorgesehen):
    try { throw new IOException("fake exception"); } catch (IOException ex) {
          throw new RuntimeException(ex); } // Exception-Objekt ex weitergeben!

  • LocalDate: Erzeugen: now(), of(…​), parse(…​), formatieren, Jahr etc. zurückliefern, etc.

  • Lesen und Schreiben von Text/CSV-Dateien mit BufferedReader, BufferedWriter oder PrintWriter. (Try with Resources ist PLICHT!)

  • FileChooser zum Öffnen (showOpenDialog(…​)) und Speichern (showSaveDialog(…​)) von Dateien

  • MVC (Model-View-Controller)

  • Layout: (z.B. BorderPane, GridPane, HBox, VBox, …​)

  • Menus: MenuBar, Menu, MenuItem

  • Wichtige einfache Controls: TextField, Button, Label, CheckBox, RadioButton mit ToggleGroup, etc.

  • Wichtige erweiterte Controls: ComboBox, ListView (basieren beide auf ObservableList)

  • DatePicker

  • Alert

  • Dialog<R>, wobei R der Rückgabetyp ist (z.B. Person)

    • mit Dialog - setResultConverter auf z.B. Person (immer wenn Rückgabetyp R nicht ButtonType),

    • Erzeugen ButtonType Instanzen, dann getDialogPane().getButtonTypes().addAll(btOK, btCancel);

    • Aufruf Dialog mit z.B.:
      Optional<Person> persOpt = dialog.showAndWait();
      if (persOpt.isPresent())   { person = persOpt.get(); …​ }

    • Abfangen des OK-Buttons (Beispiel in Dialog-Javadoc-Seite – Suche Strg+F darin z.B. nach Intercepting Button Actions oder EventFilter)

  • Vererbungshierarchie von Nodes siehe auch JavaFX Layouts, Containers, Nodes^

  • Setzen von EventFilter und EventHandler möglich auf alles, was von Node erbt (fast alles außer Scene, MenuItem, etc. – siehe darüber):

    • aNode.addEventFilter(…​) und analog: aNode.addEventHandler(…​)

    • Sowohl Filter als auch Handler sehen genau gleich aus:
      z.B. aNode.addEventFilter(MouseEvent.MOUSE_CLICKED, event -> { …​ });

    • Bei den meisten Events liefert event.getSource() das Objekt, auf das geklickt wurde (z.B. Button, CheckBox, …​).
      Mit if (event.getSource() instanceof Button btn) { …​ } kann typabhängig reagiert werden – z.B. mit String id = btn.getId(); (oder id = (String)btn.getUserData(); ) kann für jeden Event-Auslöser spezifisch gearbeitet werden.

  • Events:

    • ActionEvent (z.B. Button, MenuItem, CheckBox, ComboBox, …​ mit setOnAction(…​))

    • MouseEvent

    • WindowEvent: üblicherweise f. stage, z.B. :
      stage.addEventFilter(WindowEvent.WINDOW_CLOSE_REQUEST, event -> { event.consume(); })

  • ChangeListener (an Properties) v.a. für ListView SelectionModel (ListView - getSelectionModel mit MultipleSelectionModel und SingleSelectionModel)

  • ListView mit getSelectionModel() …​ in Arbeit!!

  • Switch zw. Views …​ in Arbeit!!

  • GESTRICHEN: Property-Binding (OPTIONAL, max. f. Bonus-Aufgaben)

4.2. Moodle-Folien etc.

4.3. Wichtige Tastenkürzel:

  • Anzeige Methoden-Parameterliste: Cursor auf Methodenname oder in Param-Klammer, dann Strg+P

  • Javadoc zu Klasse/Methode im Browser: Cursor auf Klasse/Methode, dann Shift+F1 (Voraussetzung: Javadoc per Maven heruntergeladen – siehe oben)

  • Refactor - Rename: Cursor auf Bezeichner, dann Shift+F6 (Klassen, Methoden, Variablen, …​)

4.4. Serialization

https://www.baeldung.com/java-serialization [Introduction to Java Serialization | Baeldung^] …​ 2024-05-08

https://www.tutorialspoint.com/java/java_serialization.htm [Java - Serialization^] …​ 2024-05-08

4.5. Events und Listeners

(z.B. EventHandler, ChangeListener, InvalidationListener, …​)

https://www.tutorialspoint.com/javafx/javafx_event_handling.htm [JavaFX - Event Handling^] …​ 2024-05-08 https://taylorial.com/gui/fxevents/ [taylorial.com^] …​ 2024-05-08

https://stackoverflow.com/questions/45117076/javafx-invalidationlistener-or-changelistener [java - JavaFX InvalidationListener or ChangeListener - Stack Overflow^] …​ 2024-05-08

5. Beispiel möglicherweise mit:

  • Model-View-Controller (MVC) - Struktur

  • Model:

    • Liste mit Elementen, die von einer abstrakten Klasse erben und Serializable sind (für Objekt-Speicherung / Serialieierung / Deserialisierung).
      In der Liste sind alle Elemente erlaubt, die von der abstrakten Klasse erben (also von den abgeleiteten Klassen).
      Als Liste wird gleich eine JavaFX-ObservableList verwendet, damit die GUI automatisch aktualisiert wird, wenn sich die Liste ändert (bei Hinzufügen, entfernen, Umsortieren, nicht aber bei "Inneren" Änderungen der Elemente selber!).

    • Die Liste kann sortiert werden (FXCollections.sort(listenObj, ComparatorObj) mit Objekten mehrerer Komparator-Klassen für unterschiedliche Sortierungen). Wenn die Elemente Comparable implementieren, kann auch FXCollections.sort(listenObj) verwendet werden. Beim Sortieren wird nur ein einziger Change-Event ausgelöst, wenn die Liste neu sortiert wird (nicht bei jeder der vielen Austausch-Operationen während des Sortierens).

    • Speichern/Laden von CSV-Dateien (mit BufferedReader, BufferedWriter oder PrintWriter)

    • Speichern mittels Serialisierung (ObjectOutputStream) – hier wird lediglich das Listenobjekt serialialisiert, damit werden automatisch auch alle in der Liste referenzierten Element-Objekte samt ihrer Beziehung zur Liste gespeichert.

    • Laden mittels Deserialisierung (ObjectInputStream) – hier wird die Liste samt aller daran hängender Element-Objekte samt ihrer Beziehung wiederhergestellt.

    • Unit-Tests mit JUnit 5 (u.a. mit Annotations @Test, @BeforeEach, @AfterEach, @BeforeAll, @AfterAll).

    • Exception-Handling mit Rethrowwing von Checked Exceptions als z.B. eigene Unchecked Exceptions (v.a. in Lambda-Ausdrücken und anonymen inneren Klassen nötig). Anzeige der Excepption-Message z.B. in Error-Label mit roter Schriftfarbe oder in einer Alert-Box.

  • JavaFX-GUI (View und Controller):

    • Anzeige der Liste in einer ListView (mit ObservableList) mit

    • Im GUI könnten auch Bilder (ImageView) und Dateien (FileChooser) eine Rolle spielen.

    • Vermutlich ist ein Menü und eine Liste zu füllen, zu sortieren und zu speichern/lesen.

    • Elemente können per selbstgeschriebenem Dialog erzeugt und geändert werden

    • Einfach- und Mehrfachselektion in der Liste (mit ListView und SelectionModel)

    • Weitere GUI-Elemente: Label, TextField, Checkbox, Radio-Button, ComboBox, DatePicker, ColorPicker, …​ können auch vorkommen.

    • Container: BorderPane, GridPane, VBox, HBox, FlowPane, TitledPane, Accordion, …​

    • Event-Handling: ActionEvent, MouseEvent, KeyEvent, WindowEvent, …​

    • Event-Filter zum Abfangen von Events

    • Event-Handler zum Reagieren auf Events

    • Dialoge: Alert, ChoiceDialog, TextInputDialog, eigene Dialog-Implementation…​