📝 Pytania otwarte — GUI/Java

Gotowe opisy do dwóch typów pytań otwartych: opisz proces (np. wątek) oraz model widoku. Ucz się struktury odpowiedzi, nie na pamięć.

Spis: 1. Cykl życia wątku · 2. Tworzenie i sterowanie wątkami · 3. Inne „procesy" do opisania · 4. Model widoku (MVC) · 5. Model–delegat w Swing · 6. Właściwości i wiązania w JavaFX (MVVM)

1. Cykl życia wątku (przykład „procesu" do opisania)

Wątek w Javie przechodzi przez zdefiniowane stany (enum Thread.State). Opisując proces, wymień stany, przejścia i metody, które je wywołują.

start() zajęcie procesora NEW ─────────────▶ RUNNABLE ◀───────────────────┐ (utworzony) (gotowy / │ │ notify()/notifyAll(), wykonywany)│ │ upływ czasu, zwolnienie │ │ monitora, koniec I/O wejście do │ wait(), │ synchronized zajęte │ sleep(t), │ ▼ │ join() │ BLOCKED ├───────▶ WAITING / TIMED_WAITING (czeka na monitor) │ ▼ TERMINATED (run() się zakończył)

Stan	Znaczenie	Jak się tu trafia
NEW	Wątek utworzony, jeszcze nie uruchomiony	`new Thread(...)`
RUNNABLE	Gotowy do wykonania lub wykonywany (Java nie rozróżnia „ready" i „running")	`start()`
BLOCKED	Czeka na wejście do sekcji `synchronized` (na monitor)	monitor zajęty przez inny wątek
WAITING	Czeka bezterminowo na inny wątek	`wait()`, `join()` bez czasu
TIMED_WAITING	Czeka przez określony czas	`sleep(t)`, `wait(t)`, `join(t)`
TERMINATED	Zakończony (`run()` się zakończył lub wyjątek)	koniec metody `run()`

Na egzaminie warto dodać: ponowne start() na wątku TERMINATED rzuca IllegalThreadStateException; wątek nie wraca z TERMINATED. Java łączy „gotowy" i „aktywny" w jeden stan RUNNABLE (o przydziale procesora decyduje planista SO).

2. Tworzenie i sterowanie wątkami

Trzy sposoby utworzenia zadania

Dziedziczenie po Thread i nadpisanie run().
Implementacja Runnable (run() zwraca void, bez wyniku) i przekazanie do new Thread(runnable) — preferowane (kompozycja).
Implementacja Callable<T> (call() zwraca wynik i może rzucać wyjątki) — uruchamiana przez ExecutorService, wynik przez Future.

Kluczowe metody

start() — uruchamia NOWY wątek (a run() wywołane wprost działa w bieżącym wątku).
join() — bieżący wątek czeka, aż dany wątek się zakończy.
sleep(ms) — usypia wątek (nie zwalnia monitorów).
interrupt() — ustawia flagę przerwania; wątek powinien ją sprawdzać/obsłużyć.
wait()/notify()/notifyAll() — synchronizacja na monitorze (tylko w synchronized); wait() zwalnia monitor. Warunek sprawdzaj w pętli while.

Bezpieczeństwo wątkowe: wspólny zmienny stan wymaga synchronizacji (synchronized, volatile tylko widoczność, AtomicInteger, blokady). Obiekty niemutowalne są bezpieczne z natury. value++ nie jest atomowe.

3. Inne „procesy", które mogą paść jako pytanie otwarte

Model zdarzeń (delegacyjny model zdarzeń)

Źródło zdarzenia (komponent) utrzymuje listę słuchaczy (obserwatorów). Gdy zajdzie zdarzenie (np. klik), tworzy obiekt zdarzenia (ActionEvent) i wywołuje metodę każdego zarejestrowanego słuchacza (actionPerformed). To wzorzec Observer. W Swing zdarzenia obsługiwane są na EDT.

Cykl życia aplikacji JavaFX

launch() → JavaFX tworzy wątek aplikacji → init() (poza wątkiem FX) → start(Stage) (na wątku FX, budujemy Scene i pokazujemy Stage) → działanie (pętla zdarzeń) → stop() przy zamknięciu.

Odśmiecanie (garbage collection) — w skrócie

Obiekt jest kandydatem do usunięcia, gdy nie jest już osiągalny z żadnego korzenia (referencji lokalnej, statycznej itp.). GC działa automatycznie; nie należy polegać na finalize().

4. Model widoku — wzorzec MVC

MVC (Model–View–Controller) rozdziela odpowiedzialności, żeby dane, prezentacja i logika sterowania były niezależne.

┌──────────┐ powiadamia o zmianie ┌──────────┐ │ MODEL │ ───────────────────────▶ │ VIEW │ │ (dane + │ │(prezentacja│ │ logika) │ ◀─────────┐ odczyt ────│ danych) │ └──────────┘ │ └────┬─────┘ ▲ │ │ akcje użytkownika │ aktualizuje │ ▼ │ ┌──────────────┐ (zdarzenia) └────────────│ CONTROLLER │◀────────┘ │ (obsługa │ │ wejścia) │ └──────────────┘

Model — dane i reguły biznesowe; nie wie nic o widoku. Powiadamia obserwatorów o zmianie.
View (widok) — wyświetla dane modelu; sam nie przechowuje logiki.
Controller — odbiera akcje użytkownika, tłumaczy je na zmiany modelu.

Zalety: separacja odpowiedzialności, łatwiejsze testowanie, jeden model może mieć wiele widoków.

5. Model widoku w Swing — architektura model–delegat

Swing stosuje wariant MVC zwany model–delegat: View i Controller są połączone w jeden „UI delegate", a osobno stoi model danych.

Komponent	Model danych
`JTable`	`TableModel` / `AbstractTableModel`
`JList`	`ListModel`
`JTree`	`TreeModel`
`JComboBox`	`ComboBoxModel`

Model przechowuje dane, a komponent tylko je wyświetla. Po zmianie danych model musi powiadomić widok (wzorzec Observer), np. fireTableRowsInserted(...) — inaczej tabela się nie odświeży.

Do implementacji AbstractTableModel nadpisujemy min. getRowCount(), getColumnCount(), getValueAt(r,c); opcjonalnie isCellEditable, setValueAt.

To dobry przykład „modelu widoku" na egzaminie: pokaż separację danych (TableModel) od prezentacji (JTable) i mechanizm powiadamiania (fire...).

6. Model widoku w JavaFX — właściwości, wiązania, MVVM

JavaFX opiera prezentację na właściwościach obserwowalnych (Property) i wiązaniach (bindings), co naturalnie realizuje ideę MVVM (Model–View–ViewModel).

Property (np. StringProperty, IntegerProperty) — obserwowalna wartość; można podpiąć ChangeListener.
bind — wiązanie jednostronne: etykieta.textProperty().bind(model.imieProperty()). Po związaniu nie można ustawiać ręcznie bez unbind().
bindBidirectional — synchronizacja w obie strony (np. pole tekstowe ↔ model).
ObservableList — lista powiadamiająca; podpięta do TableView/ListView odświeża widok automatycznie (bez ręcznego „fire" jak w Swing).

MVVM w JavaFX

MODEL VIEWMODEL VIEW (FXML) (dane) ◀──▶ właściwości + logika ◀──bind──▶ kontrolki prezentacji (Property) (dwustronne wiązania)

ViewModel wystawia dane modelu jako właściwości; widok (FXML + kontroler) wiąże się z nimi. Zmiana modelu automatycznie odświeża widok i odwrotnie — bez pisania kodu synchronizującego.

Porównanie na egzaminie: Swing — ręczne powiadamianie modelu (fire...); JavaFX — automatyczne przez właściwości/wiązania i ObservableList. To częsty punkt różnicujący.

Materiał pomocniczy do samodzielnej nauki. Ćwicz odtwarzanie tych opisów własnymi słowami — na egzaminie liczy się struktura odpowiedzi.