INF.04-02-23.01-SGStyczeń 2023 · 24 kroki · ok. 64 min · 34 kryteria z klucza
Rozwiązanie krok po kroku: Notatki konsolowe i mobilne (Java + Android)
Rozwiązujemy arkusz z notatkami w wersji Java + Android Studio: w konsoli klasa Notatka z licznikiem utworzonych notatek, identyfikatorem, tytułem i treścią, konstruktorem i dwiema metodami (wyświetlenie i diagnostyka), sprawdzona na dwóch notatkach; w aplikacji mobilnej lista notatek z polem „Nowy element” i przyciskiem DODAJ, który dopisuje wpis na końcu listy. Do tego komentarz dokumentujący klasę według wzoru z arkusza, zrzuty i dokument egzamin.
Kroki idą zdanie po zdaniu za treścią arkusza - każdy zaczyna się poleceniem z arkusza, a kod pokazuje dokładnie te linie, które je spełniają. Najpierw piszemy najprostszą wersję, której wymaga klucz, a w etapie „Dobre praktyki” poprawiamy to, czego klucz nie sprawdza.
Co widać w podglądzie. Wyniki programu konsolowego pochodzą z prawdziwego uruchomienia kodu z danego kroku (JDK 21). Ekran telefonu to symulacja w przeglądarce zbudowana z pliku XML danego kroku; jej zachowanie odpowiada kodowi Javy z kroku - wpisz notatkę i kliknij „DODAJ”. Każdy stan aplikacji zbudowaliśmy też w Android Studio (Gradle) i sprawdziliśmy na emulatorze Pixel 8.
Arkusz pozwala też na C++, C# albo Pythona w konsoli i na Xamarin / .NET MAUI w części mobilnej - ten wariant to jedna z możliwych dróg.
Jak liczą się punkty. Klucz ma 34 kryteria (R.1.1 - R.4.8), każde za 1 punkt. Próg zdania części praktycznej to 75%, czyli 26 punktów - można stracić 8 kryteriów i nadal zdać. Przy każdym kroku jest napisane, które kryteria spełnia; egzaminator ocenia spełnienie kryteriów z klucza, nie zgodność z tym kodem.
Krok 1 · po tym etapie masz 0 z 34 kryteriów (pkt)
Krok 1: Folder zdającego, podfoldery i dane z zad2.zip
ok. 2 min
Polecenie z arkusza
Utwórz folder i nazwij go numerem zdającego. W folderze utwórz podfoldery: konsola, mobilna, dokumentacja. Dane początkowe aplikacji zapisano w pliku dane.txt, zawartym w archiwum zad2.zip, które znajduje się na pulpicie konta Egzamin i jest zabezpieczony hasłem: !D@Ne$
Na pulpicie zakładamy folder o nazwie z numerem PESEL, a w nim konsola, mobilna i dokumentacja. Archiwum zad2.zip rozpakowujemy hasłem z arkusza - jest w nim jeden plik, dane.txt, z trzema notatkami w cudzysłowach, oddzielonymi przecinkami:
To gotowe literały napisów - wkleimy je do kodu aplikacji mobilnej. Plik jest zapisany w kodowaniu Windows-1250: jeśli Notatnik albo środowisko pokaże „krzaczki” zamiast „ł” i „ć”, popraw te litery ręcznie po wklejeniu.
Etap 2: Aplikacja konsolowa
Kroki 2-9 · po tym etapie masz 17 z 34 kryteriów (pkt)
Krok 2: Projekt konsola w Javie
ok. 3 min
Polecenie z arkusza
Napisz program implementujący klasę do obsługi notatek. Program wykonywany w konsoli. Obiektowy język programowania zgodny z zainstalowanym na stanowisku egzaminacyjnym: C++ lub C#, lub Java, lub Python.
Wybieramy Javę - tę samą, w której napiszemy aplikację mobilną. W IntelliJ IDEA: New Project → Java, nazwa konsola. Program główny to metoda main klasy Main; klasę notatki zapiszemy w osobnym pliku.
R.2.1 Kod składa się z programu głównego oraz definicji klasy notatka w której zdefiniowano przynajmniej jedno pole i przynajmniej jedną metodę zgodne z treścią zadania (może być niedokończona, lub z błędami)
R.2.2 Klasa zawiera dwa pola numeryczne o zasięgu private oraz dwa pola napisowe o zasięgu protected (w Python zgodnie z konwencją zastosowano dla protected jeden podkreślnik w nazwie, dla private dwa podkreślniki)
R.1.5 Zastosowano typy zmiennych pasujące do problemu (np. dowolny typ numeryczny dla identyfikatora i licznika; typ napisowy dla tytułu i treści notatki; dopuszcza się w języku Python bez typu)
ok. 3 min
Polecenie z arkusza
Klasa notatka zawiera pola: statyczne numeryczne licznika notatek do zliczania utworzonych notatek, numeryczne do zapisu unikalnego identyfikatora, dwa tekstowe do zapisu tytułu notatki i treści notatki. Dostęp do wszystkich pól jest ograniczony do wnętrza klasy notatka, przy czym pola identyfikatora i licznika nie są dostępne dla klas potomnych, a pola tekstowe są dostępne dla klas potomnych.
Prawy przycisk na src → New → Java Class → Notatka (w Javie nazwa klasy wielką literą - arkusz na to pozwala). Klasa publiczna leży w pliku o tej samej nazwie: Notatka.java (R.2.1).
Modyfikatory dostępu wynikają wprost z arkusza (R.2.2):
private - licznik i identyfikator: widoczne tylko w tej klasie, klasa potomna ich nie zobaczy,
protected - tytuł i treść: niedostępne z zewnątrz, ale dostępne w klasach potomnych.
Licznik jest static - jeden wspólny dla wszystkich notatek, a nie osobny w każdym obiekcie (R.2.3). Typy: int dla liczb, String dla tekstu (R.1.5).
Typowe błędy
Licznik bez static - każdy obiekt ma wtedy własny licznik równy 1 i obie notatki dostają id 1 (R.2.3, R.2.9).
Krok 4: Konstruktor: licznik, identyfikator, tytuł i treść
Kryteria: ,
R.2.3 Pole licznika notatek jest statyczne oraz jest inkrementowane (lub zwiększane o jeden) w konstruktorze przed przypisaniem jego wartości do pola identyfikatora
R.2.4 Klasa zawiera konstruktor z dwoma parametrami wejściowymi typu napisowego. Parametry są przypisywane do tytułu i treści notatki, do pola identyfikatora jest przypisana wartość licznika
ok. 3 min
Polecenie z arkusza
Klasa notatka zawiera jeden konstruktor o parametrach wejściowych dla tytułu i treści. Ma on za zadanie kolejno: inkrementować licznik notatek, ustawić pole identyfikatora równe licznikowi notatek, czyli pierwsza utworzona notatka ma id równe 1, druga – 2, itd., ustawić pola tytułu i treści równe parametrom.
Kolejność ma znaczenie: najpierwcounter++, potemid = counter (R.2.3). Licznik startuje od 0, więc pierwsza notatka dostaje id 1, druga 2.
Parametry nazywają się tak samo jak pola, dlatego pole zapisujemy z this. - this.title to pole obiektu, samo title to parametr (R.2.4).
Typowe błędy
Odwrócona kolejność (id = counter; przed counter++;) daje pierwszej notatce id 0. Zapis title = title; bez this. przypisuje parametr sam do siebie - pole zostaje null.
R.2.5 Zdefiniowano dwie metody bezparametrowe oraz nie zwracające wartości (np. typ void). Obie metody mają zakres public
R.2.6 Jedna metoda wyświetla jedynie tytuł i treść notatki
R.1.3 Użyto znaczące nazewnictwo metod / funkcji
ok. 2 min
Polecenie z arkusza
Klasa notatka zawiera dwie metody bezparametrowe i niezwracające wartości, które mogą być wołane w programie głównym: metodę wyświetlenia tytułu i treści notatki.
Metoda public (wywołamy ją z Main), void (nic nie zwraca), bez parametrów (R.2.5). Wyświetla tylko tytuł i treść, każde z opisem - bez identyfikatora i licznika (R.2.6).
Krok 6: Metoda showDiagnostics: wszystkie pola po średniku
Kryteria: ,
R.2.5 Zdefiniowano dwie metody bezparametrowe oraz nie zwracające wartości (np. typ void). Obie metody mają zakres public
R.2.7 Druga metoda wypisuje zawartość wszystkich pól klasy oddzielonych od siebie średnikiem
ok. 2 min
Polecenie z arkusza
Metodę diagnostyczną wypisującą zawartości wszystkich pól oddzielone od siebie średnikami.
Druga metoda, też public void bez parametrów (R.2.5), wypisuje wszystkie cztery pola - licznik, identyfikator, tytuł, treść - rozdzielone średnikiem (R.2.7). Opis „Diagnostyka:” na początku mówi użytkownikowi, co ogląda (R.1.7).
Krok 7: Program główny: pierwsza notatka i obie metody
Kryteria: ,
R.1.7 Program nawiązuje zrozumiałą komunikację z użytkownikiem. Wyświetla tytuł i treść notatki. Jeżeli kod nie uruchamia się z powodu błędów kompilacji - sprawdzić w kodzie aplikacji
R.1.4 Użyto znaczące nazewnictwo zmiennych / pól oraz klasy. Wyjątkami od reguły są zmienne bufor, tmp, iteratory pętli itp. Kryterium nie jest spełnione tylko wtedy, gdy nazwy zmiennych nic nie znaczą, np. x, fun
ok. 2 min
Polecenie z arkusza
Program główny powinien zawierać test działania aplikacji polegający na utworzeniu dwóch notatek z dowolnymi (znaczącymi) danymi (źródło danych jest dowolne: stała napisowa, literał lub pobrane z klawiatury) oraz uruchomieniu dla każdej z nich obu metod.
Tworzymy notatkę z literałów i wywołujemy na niej obie metody. Podgląd to prawdziwe uruchomienie: licznik i identyfikator mają wartość 1 - istnieje jedna notatka (R.2.9).
> java Main
Tytuł: Zakupy
Treść: chleb, masło, ser
Diagnostyka: 1;1;Zakupy;chleb, masło, ser
Krok 8: Druga notatka: identyfikator 2
Kryteria: , , ,
R.2.9 W programie tworzone są dwa obiekty klasy notatka, pierwszy ma identyfikator równy 1, drugi - 2 . Wartość licznika jest zgodna ze stanem rzeczywistym i jest równa 1, gdy jest utworzony tylko jeden obiekt, 2 gdy dwa obiekty itd. (sprawdzić w kodzie jaka jest kolejność tworzenia obiektu względem wyświetlania danych diagnostycznych)
R.2.8 Program kompiluje się i uruchamia w konsoli, co udokumentowano zrzutem ekranu
R.1.1 Kod źródłowy zapisano w sposób czytelny: instrukcje w osobnych liniach, stosowane spacje pomiędzy operatorami, konsekwentnie stosowana wybrana konwencja dla nawiasów klamrowych
R.1.2 Kod zapisano z wcięciami dla zagłębień bloków
ok. 2 min
Polecenie z arkusza
Program główny powinien zawierać test działania aplikacji polegający na utworzeniu dwóch notatek z dowolnymi (znaczącymi) danymi oraz uruchomieniu dla każdej z nich obu metod.
Drugą notatkę tworzymy po wyświetleniu pierwszej. Dzięki temu diagnostyka pierwszej pokazuje licznik 1 (wtedy istniała jedna notatka), a druga - licznik 2 i identyfikator 2. Egzaminator sprawdza właśnie tę zgodność licznika ze stanem rzeczywistym (R.2.9). Pusta linia oddziela notatki w wyniku.
konsola/src/Main.javaJavazmienione: 5 linii
publicclassMain {publicstaticvoidmain(String[] args) { Notatka shopping = new Notatka("Zakupy", "chleb, masło, ser"); shopping.show(); shopping.showDiagnostics(); System.out.println(); Notatka todo = new Notatka("Do zrobienia", "obiad, umyć podłogi"); todo.show(); todo.showDiagnostics(); }}
Wynik programu po tym kroku
> java Main
Tytuł: Zakupy
Treść: chleb, masło, ser
Diagnostyka: 1;1;Zakupy;chleb, masło, ser
Tytuł: Do zrobienia
Treść: obiad, umyć podłogi
Diagnostyka: 2;2;Do zrobienia;obiad, umyć podłogi
Krok 9: Folder konsola: archiwum, źródła i zrzuty
Kryteria: ,
R.1.6 Podjęto próbę skompilowania kodu, co udokumentowano zrzutem ekranowym przedstawiającym uruchomiony program lub jego kompilację
R.4.6 Zapisano przynajmniej jeden zrzut ekranu z uruchomienia lub kompilacji aplikacji konsolowej, na zrzucie widoczne jest środowisko, w którym powstała aplikacja
ok. 3 min
Polecenie z arkusza
Kod aplikacji przygotuj do nagrania na płytę. W podfolderze konsola powinno znaleźć się archiwum całego projektu o nazwie konsola.zip, plik z kodem źródłowym programu oraz plik uruchomieniowy, jeżeli istnieje. Aplikacja konsolowa – zrzuty nazwane: konsola1, konsola2 ...
Zrzut całego ekranu z IntelliJ z wynikiem programu (widoczny pasek zadań) - konsola1 w folderze dokumentacja (R.1.6, R.4.6). Folder projektu pakujemy do konsola.zip (po dopisaniu komentarza z części III), obok kopiujemy Notatka.java i Main.java.
Kroki 10-19 · po tym etapie masz 28 z 34 kryteriów (pkt)
Krok 10: Nowy projekt Notatki w Android Studio
ok. 3 min
Polecenie z arkusza
Wykonaj aplikację mobilną obsługującą proste notatki tekstowe za pomocą środowiska programistycznego dostępnego na stanowisku egzaminacyjnym oraz uruchom ją w dostępnym emulatorze systemu mobilnego.
New Project → szablon Empty Views Activity (z widokami w XML). Nazwa Notatki, pakiet com.example.notatki, język Java. Będziemy zmieniać res/layout/activity_main.xml (wygląd) i MainActivity.java (logika).
Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.
Krok 11: Pionowy LinearLayout
Kryteria: ,
R.3.1 Zastosowano język znaczników XML/XAML lub inny do opisu interfejsu użytkownika oraz kod zawiera przynajmniej jeden element / kontrolkę interfejsu graficznego
R.3.2 Zastosowano rozkład liniowy wertykalny (LinearLayout / StackLayout lub inny o tej idei) z zagłębionym rozkładem liniowym horyzontalnym dla pola edycyjnego i przycisku
ok. 2 min
Polecenie z arkusza
Interfejs użytkownika zapisany za pomocą języka znaczników wspieranego w danym środowisku (np. XAML, XML). Zastosowany rozkład liniowy wertykalny (Linear / Stack lub inny o tej idei).
W widoku Code zamieniamy ConstraintLayout na LinearLayout z android:orientation="vertical" - elementy ułożą się jeden pod drugim (R.3.1, R.3.2). Zostawiamy android:id="@+id/main": korzysta z niego kod szablonu w onCreate (odstęp od paska stanu). Ekran jest na razie pusty.
Notatki/app/src/main/res/layout/activity_main.xmlXMLzmienione: 3 linie
Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.
Krok 12: Poziomy pasek i pole „Nowy element”
Kryteria: ,
R.3.2 Zastosowano rozkład liniowy wertykalny (LinearLayout / StackLayout lub inny o tej idei) z zagłębionym rozkładem liniowym horyzontalnym dla pola edycyjnego i przycisku
R.3.3 Zastosowano kontrolki: edycyjną, przycisku o treści DODAJ oraz widoku listy (np. ListView)
ok. 3 min
Polecenie z arkusza
Pole edycyjne z podpowiedzią „Nowy element”. Zastosowany rozkład liniowy wertykalny z zagłębionym rozkładem liniowym horyzontalnym dla pola edycyjnego i przycisku.
Wewnątrz pionowego układu zagnieżdżamy poziomy LinearLayout - w nim staną obok siebie pole i przycisk (R.3.2). Pole EditText:
android:hint="Nowy element" - szara podpowiedź, która znika po wpisaniu tekstu (R.3.10),
layout_width="0dp" z layout_weight="1" - pole zajmie całą szerokość, jaka zostanie obok przycisku,
inputType="text" - jeden wiersz tekstu.
Typowe błędy
android:text="Nowy element" zamiast hint - napis jest wtedy treścią pola i trzeba go skasować przed wpisaniem notatki.
Notatki/app/src/main/res/layout/activity_main.xmlXMLzmienione: 15 linii
Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.
Krok 13: Przycisk DODAJ: tło Crimson, biały napis
Kryteria: ,
R.3.3 Zastosowano kontrolki: edycyjną, przycisku o treści DODAJ oraz widoku listy (np. ListView)
R.3.4 Nadano kolory dla przycisku: tło Crimson (#DC143C), czcionka biała
ok. 2 min
Polecenie z arkusza
Przycisk o treści: „DODAJ”. Cechy przycisku: Kolor tła Crimson (#DC143C), biały kolor czcionki, zgodnie z Obrazem 1a.
Przycisk stoi w poziomym pasku za polem (R.3.3). Kolor tła dajemy przez backgroundTint="#DC143C" - w motywie Material 3 przycisk barwi swoje tło kolorem motywu i zwykłe android:background ignoruje, a backgroundTint podmienia ten kolor. Napis biały: textColor="#FFFFFF" (R.3.4).
Typowe błędy
android:background="#DC143C" w Material 3 nie zmienia koloru przycisku - zostaje fioletowy kolor motywu (R.3.4).
Notatki/app/src/main/res/layout/activity_main.xmlXMLzmienione: 8 linii
Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.
Krok 14: Lista: ListView pod paskiem
Kryteria:
R.3.3 Zastosowano kontrolki: edycyjną, przycisku o treści DODAJ oraz widoku listy (np. ListView)
ok. 2 min
Polecenie z arkusza
Lista (element widoku listy). Rozmieszczenie elementów zgodne z obrazami 1a i 1b.
Pod paskiem ListView na całą szerokość i resztę wysokości ekranu (R.3.3). Lista nie ma jeszcze danych, więc jest pusta - wypełni ją kod Javy w następnych krokach.
Notatki/app/src/main/res/layout/activity_main.xmlXMLzmienione: 5 linii
Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.
Krok 15: Kolekcja ArrayList z trzema notatkami z dane.txt
Kryteria: ,
R.3.6 Zdefiniowano zmienną dowolnej kolekcji o typie napisowym do przechowywania notatek, np. String[], ArrayList<String>, ObservableCollection<String> lub inne
R.3.8 W stanie początkowym aplikacja wyświetla trzy notatki o treści zgodnej z plikiem dane.txt
ok. 3 min
Polecenie z arkusza
W stanie początkowym wyświetlone są 3 notatki. Treść notatek można skopiować z pliku dane.txt lub ręcznie wpisać do kodu źródłowego z obrazu 1b. Notatki są zapisane w dowolnej kolekcji z elementami typu napisowego połączonej z widokiem listy jako jej źródło danych.
Kolekcja to pole aktywności ArrayList<String> notes - lista napisów, do której potem dopiszemy kolejne notatki (R.3.6). Trzy napisy wklejamy z dane.txt (R.3.8).
Dlaczego new ArrayList<>(Arrays.asList("a", "b")), a nie samo Arrays.asList("a", "b")? Lista z Arrays.asList ma stały rozmiar - przy pierwszym add aplikacja zatrzyma się z błędem UnsupportedOperationException. Kopia w ArrayList pozwala dopisywać.
Lista na ekranie jest jeszcze pusta: kolekcji nie połączyliśmy z widokiem.
Typowe błędy
Pole typu List<String> przypisane wprost z Arrays.asList("a", "b"), bez kopii w ArrayList - kompiluje się i wyświetla trzy notatki, ale kliknięcie „DODAJ” zatrzymuje aplikację (R.3.9).
Notatki/app/src/main/java/com/example/notatki/MainActivity.javaJavazmienione: 10 linii
Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.
Krok 16: ArrayAdapter: kolekcja jako źródło danych listy
Kryteria: ,
R.3.6 Zdefiniowano zmienną dowolnej kolekcji o typie napisowym do przechowywania notatek, np. String[], ArrayList<String>, ObservableCollection<String> lub inne
R.3.8 W stanie początkowym aplikacja wyświetla trzy notatki o treści zgodnej z plikiem dane.txt
ok. 3 min
Polecenie z arkusza
Notatki są zapisane w dowolnej kolekcji z elementami typu napisowego połączonej z widokiem listy jako jej źródło danych. Cechy elementów listy: domyślny kolor czcionki.
ListView nie czyta kolekcji sam - pośredniczy adapter. ArrayAdapter dostaje trzy rzeczy:
this - aktywność (kontekst),
android.R.layout.simple_list_item_1 - gotowy, systemowy wygląd jednego wiersza: pojedynczy tekst w domyślnym kolorze czcionki,
notes - naszą kolekcję.
setAdapter łączy adapter z listą i na ekranie pojawiają się trzy notatki (R.3.8). Adapter zapisujemy w polu, bo przycisk będzie go potrzebował. Między wierszami widać cienki szary separator - to domyślny wygląd listy, kolor zmienimy w następnym kroku.
Notatki/app/src/main/java/com/example/notatki/MainActivity.javaJavazmienione: 6 linii
Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.
Krok 17: Separator listy: Crimson i wysokość 2dp
Kryteria: ,
R.3.5 Dla widoku listy ustawiono kolor separatora: Crimson
R.3.10 Aplikacja kompiluje się i uruchamia w emulatorze, co udokumentowano zrzutem ekranu jej układ jest zgodny z obrazem 1a lub 1b w arkuszu egzaminacyjnym. Pole edycyjne wyświetla podpowiedź "Nowy element". Separator jest widoczny (np. w Android Studio ustawiono wysokość separatora)
ok. 2 min
Polecenie z arkusza
Cechy elementów listy: domyślny kolor czcionki, kolor separatora: Crimson, separator jest widoczny (np. poprzez ustawienie wysokości separatora).
android:dividerHeight="2dp" - wysokość linii (R.3.10).
Drugi atrybut jest konieczny: kolor podany w divider nie ma własnej wysokości, więc bez dividerHeight lista rysuje separator o wysokości 0 - znika zupełnie, także ten szary. Sprawdziliśmy to na emulatorze. Dlatego arkusz pisze „separator jest widoczny (np. poprzez ustawienie wysokości)”.
Typowe błędy
Sam android:divider="#DC143C" bez android:dividerHeight - między notatkami nie ma żadnej linii (R.3.10).
Notatki/app/src/main/res/layout/activity_main.xmlXMLzmienione: 3 linie
Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.
Krok 18: DODAJ: notatka na koniec listy
Kryteria: ,
R.3.7 Zdefiniowano funkcję powiązaną ze zdarzeniem kliknięcia przycisku. Funkcja dodaje do kolekcji treść wpisaną w pole edycyjne
R.3.9 Po wpisaniu treści do pola edycyjnego i wybraniu przycisku jest ona wyświetlana jako ostatni element widoku listy
ok. 3 min
Polecenie z arkusza
Po wpisaniu do pola edycyjnego treści i wybraniu przycisku, jest ona zapisywana jako ostatni element widoku listy (obraz 2). Wybranie przycisku powoduje dopisanie do kolekcji treści z pola edycyjnego, widok listy jest automatycznie odświeżany. Dla uproszczenia można założyć, że pole jest zawsze wypełnione, jeśli wybrany jest przycisk.
Pole tekstowe znajdujemy przez findViewById i zapisujemy w polu klasy. Metodę addNote wiążemy z przyciskiem atrybutem android:onClick="addNote" (R.3.7):
notes.add dopisuje tekst z pola na końcu kolekcji,
adapter.notifyDataSetChanged() mówi adapterowi, że dane się zmieniły - lista przerysowuje się i nowa notatka pojawia się jako ostatni wiersz (R.3.9).
Wpisz w podglądzie „Urodziny Ali” i kliknij „DODAJ” - jak na obrazie 2.
Typowe błędy
Bez notifyDataSetChanged() notatka trafia do kolekcji, ale lista na ekranie się nie odświeża (R.3.9).
Notatki/app/src/main/java/com/example/notatki/MainActivity.javaJavazmienione: 9 linii
Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.
Krok 19: Uruchomienie w emulatorze, zrzuty i folder mobilna
Kryteria: ,
R.3.10 Aplikacja kompiluje się i uruchamia w emulatorze, co udokumentowano zrzutem ekranu jej układ jest zgodny z obrazem 1a lub 1b w arkuszu egzaminacyjnym. Pole edycyjne wyświetla podpowiedź "Nowy element". Separator jest widoczny (np. w Android Studio ustawiono wysokość separatora)
R.4.7 Zapisano przynajmniej jeden zrzut ekranu z uruchomienia lub kompilacji aplikacji mobilnej, na zrzucie widoczne jest środowisko, w którym powstała aplikacja
ok. 3 min
Polecenie z arkusza
Aplikacja mobilna – zrzuty nazwane: mobile1, mobile2 ... (np. stan początkowy, w trakcie pisania, po dodaniu elementu). W podfolderze mobilna powinno znaleźć się archiwum całego projektu o nazwie mobilna.zip, plik z kodem źródłowym interfejsu użytkownika (XAML lub XML) oraz plik źródłowy kodu skojarzonego z interfejsem użytkownika.
Uruchamiamy aplikację w emulatorze. Zrzuty całego ekranu z Android Studio: mobile1 - stan początkowy, mobile2 - w trakcie pisania, mobile3 - po dodaniu notatki - do folderu dokumentacja (R.4.7, R.3.10). W folderze mobilna: mobilna.zip z całym projektem, activity_main.xml i MainActivity.java.
Kroki 20-21 · po tym etapie masz 34 z 34 kryteriów (pkt)
Krok 20: Nagłówek klasy Notatka według listingu 1
Kryteria: , , , ,
R.4.1 Dla klasy z aplikacji konsolowej zapisano nagłówek w postaci komentarza zgodny z Listingiem 1 z arkusza egzaminacyjnego (nie liczymy gwiazdek), komentarz może być wieloliniowy lub kilka jednoliniowych
R.4.2 W komentarzu ujęto nazwę i opis działania klasy
R.4.3 W komentarzu ujęto nazwy wszystkich pól klasy
R.4.4 Dla pól, które ujęto w komentarzu zapisano opis
R.4.5 W komentarzu ujęto numer zdającego
ok. 4 min
Polecenie z arkusza
W kodzie źródłowym aplikacji konsolowej utwórz nagłówek klasy, według wzoru. Nagłówek powinien znaleźć się nad definicją klasy. W miejscu nawiasów <> należy podać odpowiednie opisy. W miejscu autor należy podać numer zdającego.
Komentarz wieloliniowy /* ... */ nad public class Notatka z polami listingu 1 (R.4.1): nazwa klasy i opis, co reprezentuje (R.4.2), wszystkie cztery pola (R.4.3), każde z opisem, co przechowuje (R.4.4), i autor (R.4.5). Na egzaminie w polu autor wpisujemy numer PESEL - tu stoi Bartosz Bryniarski.
konsola/src/Notatka.javaJavazmienione: 12 linii
/* ****************************************************** klasa: Notatka opis: reprezentuje notatkę z tytułem i treścią; każda utworzona notatka dostaje kolejny identyfikator, a klasa zlicza notatki pola: counter - liczba utworzonych notatek, wspólna dla wszystkich obiektów id - unikalny identyfikator notatki (1 dla pierwszej, 2 dla drugiej...) title - tytuł notatki content - treść notatki autor: Bartosz Bryniarski ****************************************************** */publicclassNotatka {privatestaticint counter = 0;privateint id;protected String title;protected String content;publicNotatka(String title, String content) { counter++; id = counter;this.title = title;this.content = content; }publicvoidshow() { System.out.println("Tytuł: " + title); System.out.println("Treść: " + content); }publicvoidshowDiagnostics() { System.out.println("Diagnostyka: " + counter + ";" + id + ";" + title + ";" + content); }}
Wynik programu po tym kroku
> java Main
Tytuł: Zakupy
Treść: chleb, masło, ser
Diagnostyka: 1;1;Zakupy;chleb, masło, ser
Tytuł: Do zrobienia
Treść: obiad, umyć podłogi
Diagnostyka: 2;2;Do zrobienia;obiad, umyć podłogi
Krok 21: Dokument egzamin
Kryteria:
R.4.8 Dokumentacja zawiera: nazwę systemu operacyjnego, nazwy środowisk, emulatora, nazwy języków programowania
ok. 3 min
Polecenie z arkusza
W edytorze tekstu pakietu biurowego utwórz plik z dokumentacją i nazwij go egzamin. Dokument powinien zawierać zrzuty ekranu oraz informacje: Nazwę systemu operacyjnego, na którym pracował zdający, Nazwy środowisk programistycznych, z których zdający korzystał na egzaminie, Nazwę emulatora dla aplikacji mobilnej, Nazwy języków programowania, Opcjonalnie komentarz do wykonanej pracy.
W Wordzie albo Writerze dokument egzamin w folderze dokumentacja: zrzuty, system, środowiska, emulator i języki (R.4.8).
egzamin.txtTekstnowy plik
Zrzuty ekranu: konsola1 - wynik programu; mobile1 - stan początkowy; mobile2 - w trakcie pisania; mobile3 - po dodaniu notatkiSystem operacyjny: Windows 11Środowiska programistyczne: IntelliJ IDEA (aplikacja konsolowa), Android Studio (aplikacja mobilna)Emulator: Pixel 8 (Android 16, API 36) z Android StudioJęzyki programowania: Java (aplikacja konsolowa i mobilna), XML (układ aplikacji mobilnej)
Kroki 22-23 · po tym etapie masz 34 z 34 kryteriów (pkt)
Krok 22: Konsola: identyfikator jako final
ok. 1 min
Polecenie z arkusza
Klasa notatka zawiera pola: numeryczne do zapisu unikalnego identyfikatora.
Identyfikator nadaje konstruktor i nikt nie powinien go potem zmieniać - inaczej przestałby być unikalny. Słowo final pilnuje tego w czasie kompilacji: pole trzeba ustawić dokładnie raz, w konstruktorze, a każda późniejsza próba przypisania to błąd kompilacji.
Na egzaminie wystarczy wersja wcześniejsza - klucz tego nie sprawdza.
konsola/src/Notatka.javaJavazmienione: 1 linia
/* ****************************************************** klasa: Notatka opis: reprezentuje notatkę z tytułem i treścią; każda utworzona notatka dostaje kolejny identyfikator, a klasa zlicza notatki pola: counter - liczba utworzonych notatek, wspólna dla wszystkich obiektów id - unikalny identyfikator notatki (1 dla pierwszej, 2 dla drugiej...) title - tytuł notatki content - treść notatki autor: Bartosz Bryniarski ****************************************************** */publicclassNotatka {privatestaticint counter = 0;privatefinalint id;protected String title;protected String content;publicNotatka(String title, String content) { counter++; id = counter;this.title = title;this.content = content; }publicvoidshow() { System.out.println("Tytuł: " + title); System.out.println("Treść: " + content); }publicvoidshowDiagnostics() { System.out.println("Diagnostyka: " + counter + ";" + id + ";" + title + ";" + content); }}
Krok 23: Android: bez pustych notatek, pole czyszczone po dodaniu
ok. 3 min
Polecenie z arkusza
Dla uproszczenia można założyć, że pole jest zawsze wypełnione, jeśli wybrany jest przycisk.
Arkusz pozwala założyć, że pole jest wypełnione, ale w prawdziwej aplikacji kliknięcie „DODAJ” przy pustym polu dodaje pusty wiersz. Trzy poprawki:
trim() obcina spacje z początku i końca - same spacje też liczymy jako pusty tekst,
if (text.isEmpty()) return; - pusty tekst nie trafia do listy,
noteInput.setText("") - po dodaniu pole jest gotowe na następną notatkę.
Sprawdź w podglądzie: „DODAJ” przy pustym polu nic nie robi, a po dodaniu pole się czyści. Na egzaminie wystarczy wersja wcześniejsza - klucz tego nie sprawdza.
Notatki/app/src/main/java/com/example/notatki/MainActivity.javaJavazmienione: 6 linii
Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.
To jedno z możliwych rozwiązań. Egzaminator ocenia spełnienie kryteriów z klucza odpowiedzi, a nie zgodność z tym kodem - inna, poprawna droga też daje punkty.
Autor rozwiązania: Bartosz Bryniarski. Licencja CC BY-NC 4.0 - kopiowanie i przeróbki do celów niekomercyjnych, z podaniem autora i źródła (link do tej strony). Treść arkusza i klucza oceniania pochodzi z CKE.