Przejdź do głównej treści
INF.04-02-26.06-SGCzerwiec 2026 · 18 kroków · ok. 55 min · 33 kryteria z klucza

Rozwiązanie krok po kroku: Aplikacja notatek konsolowa i mobilna (Java + Android)

Rozwiązujemy arkusz z notatnikiem w wersji Java + Android Studio: w konsoli klasa Notatka z tytułem, treścią, priorytetem i datą dodania, dwoma konstruktorami i metodą, która wypisuje notatkę między liniami podkreślników - przetestowana na notatce ważnej i na notatce z tytułem z klawiatury; w aplikacji mobilnej lista notatek i formularz, którym dopisujemy nową notatkę na koniec listy. Lista przechowuje obiekty tej samej klasy Notatka co konsola. Do tego nagłówek metody według wzoru z arkusza, zrzuty i plik 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) - data dodania to chwila tego uruchomienia. Ekran telefonu to symulacja w przeglądarce zbudowana z pliku XML danego kroku; jej zachowanie odpowiada kodowi Javy z kroku - wpisz tytuł i treść, 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 .NET MAUI w części mobilnej - ten wariant to jedna z możliwych dróg.

Jak liczą się punkty. Klucz ma 33 kryteria (R.1.1 - R.4.9), każde za 1 punkt. Próg zdania części praktycznej to 75%, czyli 25 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.

  1. Etap 1: Przygotowanie

    Krok 1 · po tym etapie masz 0 z 33 kryteriów (pkt)

    Krok 1: Folder zdającego i podfoldery

    ok. 1 min
    Polecenie z arkusza

    Utwórz folder i nazwij go numerem zdającego. W folderze utwórz trzy podfoldery o nazwach: konsolowa, mobilna, dokumentacja. Po wykonaniu zadania umieścisz w nich rezultaty swojej pracy.

    Na pulpicie zakładamy folder o nazwie z numerem PESEL, a w nim konsolowa, mobilna i dokumentacja. Arkusz nie ma załączników.

  2. Etap 2: Aplikacja konsolowa

    Kroki 2-7 · po tym etapie masz 17 z 33 kryteriów (pkt)

    Krok 2: Projekt konsola w Javie

    ok. 3 min
    Polecenie z arkusza

    Napisz program implementujący klasę Notatka służącą programowi do notatek użytkownika. Program wykonywany w konsoli. Zastosowany 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ą, więc klasę Notatka przeniesiemy potem do projektu Android bez przepisywania. W IntelliJ IDEA: New Project → Java, nazwa konsola. Nazwa klasy jest z arkusza, więc pola i metody też nazwiemy po polsku.

    konsola/src/Main.java Java nowy plik
    public class Main {
        public static void main(String[] args) {
        }
    }
  3. Krok 3: Klasa Notatka i cztery pola public

    Kryteria: , , ,

    R.2.1 Program składa się z programu głównego oraz definicji klasy Notatka (Note), w której zdefiniowane przynajmniej jedno pole

    R.2.2 Klasa zawiera cztery pola o zasięgu public: dwa tekstowe, logiczny, oraz do zapisu daty, w zależności od języka programowania: DateTime, Date lub inne w tym prosty o ile jest dobrze obsługiwany (w języku Python typy wynikają z przypisanych im danych)

    R.1.4 Polskie lub angielskie, znaczące nazewnictwo pól. 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, foo, tab, tablica

    R.1.5 Typy zmiennych pasują do problemu np. typ tekstowy dla tytułu i treści notatki, bool dla określenia priorytetu notatki, typ daty dla przypisania aktualnej daty dodania notatki (w przypadku języka Python typ wynika z przypisanych danych)

    ok. 3 min
    Polecenie z arkusza

    Zawiera klasę Notatka (Note) oraz sprawdzenie działania klasy w programie głównym. Ogólnodostępne pola klasy, zawierające: tytuł notatki, typu napisowego, treść notatki, typu napisowego, priorytet notatki, typu logicznego, notatka jest ważna lub nie jest ważna, datę dodania notatki typu przechowującego datę.

    New → Java Class → Notatka (R.2.1). „Ogólnodostępne” to public (R.2.2): dwa napisy, priorytet jako boolean wazna (true = ważna) i data dodania.

    Na datę bierzemy LocalDateTime z pakietu java.time - przechowuje datę i godzinę, a ilustracja 1 pokazuje obie (R.1.5). To nowoczesny typ daty w Javie; starsze java.util.Date też by wystarczyło, ale ma niewygodne metody.

    konsola/src/Notatka.java Java nowy plik
    import java.time.LocalDateTime;
    
    public class Notatka {
        public String tytul;
        public String tresc;
        public boolean wazna;
        public LocalDateTime dataDodania;
    }
  4. Krok 4: Dwa konstruktory: trój- i jednoargumentowy

    Kryteria: ,

    R.2.3 Klasa zawiera dwa konstruktory (w języku Python jeden konstruktor z dwoma argumentami domyślnymi) o argumentach: 1) tytuł, treść i priorytet 2) tytuł

    R.2.4 Konstruktory przypisują wartości argumentów do odpowiednich pól, polu daty aktualną datę oraz w przypadku konstruktora jednoargumentowego jawnie przypisane są wartości do treści: "" i priorytetu: false

    ok. 4 min
    Polecenie z arkusza

    Konstruktor trójargumentowy, którego argumentami są: tytuł, treść i priorytet, mający za zadanie: przypisać wartości argumentów do odpowiednich pól klasy, przypisać dacie dodania notatki aktualną datę. Konstruktor jednoargumentowy, którego argumentem jest tytuł, mający za zadanie: przypisać wartość argumentu do pola tytułu, przypisać treści pusty napis, priorytet notatki ustawić na wartość oznaczającą, że notatka nie jest ważna, przypisać dacie dodania notatki aktualną datę.

    Java pozwala na przeciążanie konstruktorów - dwa konstruktory o tej samej nazwie różnią się listą parametrów (R.2.3).

    • Trójargumentowy przepisuje argumenty do pól (this. odróżnia pole od parametru).
    • Jednoargumentowy ustawia tytuł, a resztę jawnie: pusty napis "" i false (R.2.4). Klucz wymaga jawnych przypisań - dlatego nie skracamy go wywołaniem drugiego konstruktora.
    • Oba wpisują LocalDateTime.now() - bieżącą datę i godzinę w chwili utworzenia notatki.
    Typowe błędy

    W konstruktorze jednoargumentowym brak przypisania tresc = "" - pole zostaje null i metoda wyświetlająca wypisze słowo „null” zamiast pustej linii (R.2.4).

    konsola/src/Notatka.java Java zmienione: 14 linii
    import java.time.LocalDateTime;
    
    public class Notatka {
        public String tytul;
        public String tresc;
        public boolean wazna;
        public LocalDateTime dataDodania;
    
        public Notatka(String tytul, String tresc, boolean wazna) {
            this.tytul = tytul;
            this.tresc = tresc;
            this.wazna = wazna;
            this.dataDodania = LocalDateTime.now();
        }
    
        public Notatka(String tytul) {
            this.tytul = tytul;
            this.tresc = "";
            this.wazna = false;
            this.dataDodania = LocalDateTime.now();
        }
    }
  5. Krok 5: Metoda wyswietl: notatka między liniami

    Kryteria: , , , ,

    R.2.5 Zdefiniowana metoda bezargumentowa, która nie zwraca wartości i ma zakres public

    R.2.6 Metoda wyświetla na ekranie w osobnych liniach: - linię poziomą, - tytuł notatki, poprzedzony słowem WAŻNA tylko wtedy, gdy priorytet notatki jest równy true, - treść notatki, - datę notatki, - linię poziomą

    R.1.3 Polskie lub angielskie, znaczące nazewnictwo metod

    R.1.1 Kod źródłowy zapisany 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 zapisany z wcięciami dla zagnieżdżeń bloków

    ok. 4 min
    Polecenie z arkusza

    Ogólnodostępna metoda wypisująca notatkę, bezargumentowa i niezwracająca wartości. Wyświetla na ekranie w osobnych liniach: linię poziomą utworzoną z kilkunastu podkreślników, jeżeli notatka jest ważna, tekst: „Notatka WAŻNA! <tytuł>”, w przeciwnym razie, tekst: „Notatka <tytuł>” gdzie <tytuł> jest wartością odpowiedniego pola klasy, treść notatki, datę dodania notatki, linię poziomą utworzoną z kilkunastu podkreślników.

    Metoda public void bez parametrów (R.2.5, R.1.3). Wypisuje po kolei, każde w osobnej linii (R.2.6):

    1. linię z 20 podkreślników,
    2. tytuł - ze słowem „WAŻNA!” tylko dla ważnej notatki (if (wazna)),
    3. treść,
    4. datę w formacie z ilustracji 1 - DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm:ss"): dd dzień, MM miesiąc (wielkie M - małe mm to minuty), yyyy rok, HH godzina w zapisie 24-godzinnym,
    5. drugą linię.
    Typowe błędy

    Wzorzec "dd.mm.yyyy" - w miejscu miesiąca pojawiają się minuty, np. 14.10.2024 zamiast 14.02.2024.

    konsola/src/Notatka.java Java zmienione: 13 linii
    import java.time.LocalDateTime;
    import java.time.format.DateTimeFormatter;
    
    public class Notatka {
        public String tytul;
        public String tresc;
        public boolean wazna;
        public LocalDateTime dataDodania;
    
        public Notatka(String tytul, String tresc, boolean wazna) {
            this.tytul = tytul;
            this.tresc = tresc;
            this.wazna = wazna;
            this.dataDodania = LocalDateTime.now();
        }
    
        public Notatka(String tytul) {
            this.tytul = tytul;
            this.tresc = "";
            this.wazna = false;
            this.dataDodania = LocalDateTime.now();
        }
    
        public void wyswietl() {
            System.out.println("____________________");
            if (wazna) {
                System.out.println("Notatka WAŻNA! " + tytul);
            } else {
                System.out.println("Notatka " + tytul);
            }
            System.out.println(tresc);
            System.out.println(dataDodania.format(DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm:ss")));
            System.out.println("____________________");
        }
    }
  6. Krok 6: Program główny: dwie notatki i ich wyświetlenie

    Kryteria: , ,

    R.2.8 W programie głównym jest tworzony obiekt notatki konstruktorem trójargumentowym oraz jednoargumentowym. Dana do konstruktora jednoargumentowego jest wprowadzona z klawiatury (w Python w przypadku konstruktora jednoargumentowego dla parametrów treść oraz priorytet wartości ustawione na domyślne)

    R.2.9 Program wypisuje na ekranie dane obu notatek korzystając z metody wypisującej

    R.1.7 Komunikacja z użytkownikiem prowadzona jest w sposób zrozumiały. Jeżeli kod nie uruchamia się z powodu błędów kompilacji - sprawdzić w kodzie aplikacji

    ok. 3 min
    Polecenie z arkusza

    Program główny ma za zadanie: utworzyć obiekt klasy Notatka za pomocą konstruktora trójargumentowego (podając trzy argumenty). Notatka jest ważna, wartości argumentów konstruktora dowolne – statycznie wpisane w kodzie. Utworzyć obiekt klasy Notatka za pomocą konstruktora jednoargumentowego (podając jeden argument). Tytuł notatki został pobrany z klawiatury. Wyświetlić dane obu obiektów za pomocą metody do tego przeznaczonej (ilustracja 1).

    Pierwszą notatkę tworzymy konstruktorem trójargumentowym z wartościami wpisanymi w kodzie i true - jest ważna. Drugą - jednoargumentowym, z tytułem wczytanym z klawiatury całym wierszem nextLine() (tytuł może mieć spacje) (R.2.8). Obie wyświetlamy metodą wyswietl (R.2.9, R.1.7).

    Podgląd to prawdziwe uruchomienie z tytułem „spotkanie z kolegami”, jak na ilustracji 1 - druga notatka ma pustą treść.

    konsola/src/Main.java Java zmienione: 11 linii
    import java.util.Scanner;
    
    public class Main {
        public static void main(String[] args) {
            Notatka waznaNotatka = new Notatka("tenis", "Gra z Ewą w poniedziałek", true);
    
            Scanner scanner = new Scanner(System.in);
            System.out.println("Podaj tytuł notatki:");
            String tytul = scanner.nextLine();
            Notatka zwyklaNotatka = new Notatka(tytul);
    
            waznaNotatka.wyswietl();
            zwyklaNotatka.wyswietl();
        }
    }
    Wynik programu po tym kroku
    > java Main
    Podaj tytuł notatki:
    spotkanie z kolegami
    ____________________
    Notatka WAŻNA! tenis
    Gra z Ewą w poniedziałek
    02.10.2026 22:11:03
    ____________________
    ____________________
    Notatka spotkanie z kolegami
    
    02.10.2026 22:11:03
    ____________________
  7. Krok 7: Folder konsolowa: archiwum, źródła i zrzut

    Kryteria: , ,

    R.1.6 Podjęta próba uruchomienia kodu, na zrzucie ekranowym widoczny jest uruchomiony program lub błędy jego kompilacji / interpretacji

    R.2.7 Program uruchamia się w konsoli, udokumentowane zrzutem ekranu

    R.4.6 Zapisany przynajmniej jeden zrzut ekranu z uruchomienia lub kompilacji aplikacji konsolowej

    ok. 3 min
    Polecenie z arkusza

    Kod aplikacji przygotuj do nagrania na płytę. W folderze konsolowa należy umieścić archiwum całego projektu i skopiowany z projektu plik z kodem źródłowym programu oraz plik wykonywalny, jeżeli istnieje. Aplikacja konsolowa – dowolna liczba zrzutów nazwanych konsola1, konsola2 ...

    Zrzut całego ekranu z IntelliJ z wynikiem programu (widoczny pasek zadań) - konsola1 w folderze dokumentacja (R.1.6, R.2.7, R.4.6). Folder projektu pakujemy do archiwum (po dopisaniu komentarza z części III), obok kopiujemy Notatka.java i Main.java.

    Wynik programu bez zmian - taki jak po kroku 6.

  8. Etap 3: Aplikacja mobilna

    Kroki 8-10 · po tym etapie masz 21 z 33 kryteriów (pkt)

    Krok 8: Nowy projekt Notatnik w Android Studio

    ok. 3 min
    Polecenie z arkusza

    Za pomocą środowiska programistycznego dostępnego na stanowisku egzaminacyjnym wykonaj aplikację mobilną służącą do zapisywania notatek użytkownika. Do wykonania zadania można zastosować klasę Notatka z aplikacji konsolowej.

    New Project → szablon Empty Views Activity (z widokami w XML). Nazwa Notatnik, pakiet com.example.notatnik, język Java. Będziemy zmieniać activity_main.xml i MainActivity.java i dodamy klasę Notatka.

    Notatnik/app/src/main/java/com/example/notatnik/MainActivity.java Java nowy plik
    package com.example.notatnik;
    
    import android.os.Bundle;
    
    import androidx.activity.EdgeToEdge;
    import androidx.appcompat.app.AppCompatActivity;
    import androidx.core.graphics.Insets;
    import androidx.core.view.ViewCompat;
    import androidx.core.view.WindowInsetsCompat;
    
    public class MainActivity extends AppCompatActivity {
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            EdgeToEdge.enable(this);
            setContentView(R.layout.activity_main);
            ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {
                Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
                v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
                return insets;
            });
        }
    }
    Notatnik/app/src/main/res/layout/activity_main.xml XML nowy plik
    <?xml version="1.0" encoding="utf-8"?>
    <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/main"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".MainActivity">
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Hello World!"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toTopOf="parent" />
    
    </androidx.constraintlayout.widget.ConstraintLayout>
    Ekran telefonu po tym kroku

    Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.

  9. Krok 9: Pionowy LinearLayout AliceBlue, napis „Notatki” i lista

    Kryteria: , , ,

    R.3.1 Interfejs użytkownika zdefiniowany zgodnie z wybraną technologią (np. XML, XAML lub w przypadku Swift w kodzie źródłowym) oraz zastosowano rozkład liniowy (LinearLayout / StackLayout lub inny o tej idei)

    R.3.2 Zastosowana kontrolka widoku listy (np. ListView)

    R.3.3 Zastosowane kontrolki: cztery tekstowe ("Notatki", "Dodanie notatki", "Tytuł notatki:", "Treść notatki:") , dwie edycyjne oraz przycisku o treści DODAJ

    R.3.4 Nadane kolory: tła rozkładu lub strony AliceBlue (#F0F8FF) , czcionki przycisku i napisów "Notatki", "Dodanie notatki": MediumBlue (#0000CD) . Powiększona czcionka napisów "Notatki" i "Dodanie notatki"

    ok. 3 min
    Polecenie z arkusza

    Interfejs użytkownika zapisany za pomocą języka znaczników wspieranego w danym środowisku (np. XAML, XML). Zastosowany liniowy typ rozkładu z kolorem tła AliceBlue (#F0F8FF). Rozkład zawiera: napis o treści „Notatki”, rozmiar czcionki większy od pozostałych napisów, kolor tekstu MediumBlue (#0000CD). Lista (widok listy), której źródłem jest kolekcja przechowująca notatki jako elementy.

    Pionowy LinearLayout z tłem #F0F8FF (R.3.1, R.3.4); zostawiamy android:id="@+id/main" (używa go kod szablonu). Napis „Notatki” - kolor #0000CD, największa czcionka 26sp (R.3.3, R.3.4).

    ListView (R.3.2) ma wysokość 0dp z layout_weight="1": zajmie całą wysokość, która zostanie po pozostałych elementach - formularz dodawania stanie na dole ekranu, jak na ilustracji 4. Lista jest pusta, dopóki kod nie poda jej danych.

    Notatnik/app/src/main/res/layout/activity_main.xml XML zmienione: 13 linii
    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/main"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="#F0F8FF"
        android:orientation="vertical"
        tools:context=".MainActivity">
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Notatki"
            android:textColor="#0000CD"
            android:textSize="26sp" />
    
        <ListView
            android:id="@+id/notesList"
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1" />
    
    </LinearLayout>
    Ekran telefonu po tym kroku

    Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.

  10. Krok 10: Formularz dodania: napisy, dwa pola i DODAJ

    Kryteria: ,

    R.3.3 Zastosowane kontrolki: cztery tekstowe ("Notatki", "Dodanie notatki", "Tytuł notatki:", "Treść notatki:") , dwie edycyjne oraz przycisku o treści DODAJ

    R.3.4 Nadane kolory: tła rozkładu lub strony AliceBlue (#F0F8FF) , czcionki przycisku i napisów "Notatki", "Dodanie notatki": MediumBlue (#0000CD) . Powiększona czcionka napisów "Notatki" i "Dodanie notatki"

    ok. 3 min
    Polecenie z arkusza

    Napis o treści „Dodanie notatki”, rozmiar czcionki większy od domyślnego rozmiaru, kolor tekstu MediumBlue (#0000CD). Napis o treści „Tytuł notatki: ”. Pole do wprowadzania tekstu. Napis o treści „Treść notatki: ”. Pole do wprowadzania tekstu. Przycisk o treści „DODAJ” o kolorze czcionki MediumBlue (#0000CD).

    Pod listą: „Dodanie notatki” w kolorze #0000CD i czcionką 20sp - większą od domyślnych 14sp, mniejszą od tytułu (R.3.3, R.3.4), dwa napisy z dwoma polami edycyjnymi titleInput i contentInput oraz przycisk na całą szerokość z tekstem w kolorze #0000CD (R.3.3, R.3.4).

    Notatnik/app/src/main/res/layout/activity_main.xml XML zmienione: 35 linii
    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/main"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="#F0F8FF"
        android:orientation="vertical"
        tools:context=".MainActivity">
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Notatki"
            android:textColor="#0000CD"
            android:textSize="26sp" />
    
        <ListView
            android:id="@+id/notesList"
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1" />
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Dodanie notatki"
            android:textColor="#0000CD"
            android:textSize="20sp" />
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Tytuł notatki: " />
    
        <EditText
            android:id="@+id/titleInput"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:inputType="text" />
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Treść notatki: " />
    
        <EditText
            android:id="@+id/contentInput"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:inputType="text" />
    
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="DODAJ"
            android:textColor="#0000CD" />
    
    </LinearLayout>
    Ekran telefonu po tym kroku

    Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.

  11. Etap 4: Aplikacja mobilna - działanie

    Kroki 11-14 · po tym etapie masz 26 z 33 kryteriów (pkt)

    Krok 11: Klasa Notatka w projekcie Android

    ok. 3 min
    Polecenie z arkusza

    Do wykonania zadania można zastosować klasę Notatka z aplikacji konsolowej.

    Kopiujemy Notatka.java z konsoli do pakietu com.example.notatnik - dopisujemy tylko pierwszą linię package com.example.notatnik;. Klasa jest ta sama: te same pola i konstruktory.

    Dokładamy jedną metodę: toString(). Lista Androida wyświetla element, wywołując jego toString() - bez nadpisania pokazałaby napis w rodzaju com.example.notatnik.Notatka@1c2f3a7 (nazwa klasy i adres obiektu). Nasza wersja zwraca tytuł i treść w dwóch wierszach (\n), jak na ilustracji 5.

    LocalDateTime działa od Androida 8 (API 26) - na emulatorze i współczesnych telefonach bez przeszkód.

    Typowe błędy

    Brak toString() - lista pokazuje com.example.notatnik.Notatka@... zamiast tytułu i treści (R.3.7).

    Notatnik/app/src/main/java/com/example/notatnik/Notatka.java Java nowy plik
    package com.example.notatnik;
    
    import java.time.LocalDateTime;
    import java.time.format.DateTimeFormatter;
    
    public class Notatka {
        public String tytul;
        public String tresc;
        public boolean wazna;
        public LocalDateTime dataDodania;
    
        public Notatka(String tytul, String tresc, boolean wazna) {
            this.tytul = tytul;
            this.tresc = tresc;
            this.wazna = wazna;
            this.dataDodania = LocalDateTime.now();
        }
    
        public Notatka(String tytul) {
            this.tytul = tytul;
            this.tresc = "";
            this.wazna = false;
            this.dataDodania = LocalDateTime.now();
        }
    
        public void wyswietl() {
            System.out.println("____________________");
            if (wazna) {
                System.out.println("Notatka WAŻNA! " + tytul);
            } else {
                System.out.println("Notatka " + tytul);
            }
            System.out.println(tresc);
            System.out.println(dataDodania.format(DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm:ss")));
            System.out.println("____________________");
        }
    
        @Override
        public String toString() {
            return tytul + "\n" + tresc;
        }
    }
    Ekran telefonu po tym kroku

    Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.

  12. Krok 12: Kolekcja notatek jako źródło listy

    Kryteria: ,

    R.3.5 Jako źródło danych do widoku listy zdefiniowana jest dowolna kolekcja, tak aby jej zmiana powodowała zmianę wyświetlenia listy na ekranie. Lista przechowuje elementy notatki. Np. ArrayList<Notatka>, ObservableCollection<Notatka> (W Xamarin i .NET Maui kolekcja musi być Observable; w Android Studio stosowane jest notifyDataSetChanged() w połączeniu z ArrayAdapterem do ListView)

    R.3.7 Aplikacja kompiluje się i uruchamia w emulatorze aplikacji mobilnej, co udokumentowane jest zrzutem ekranu. Jej układ jest zgodny z ilustracją 2 lub 4 w arkuszu egzaminacyjnym. W stanie początkowym jest wyświetlana jedna notatka z dowolnym tytułem i treścią (w uruchomionej aplikacji lub na zrzucie i obowiązkowo w kodzie)

    ok. 3 min
    Polecenie z arkusza

    Lista (widok listy), której źródłem jest kolekcja przechowująca notatki jako elementy (kolekcja musi być typu, który jest możliwy do zastosowania z widokiem listy. Dodanie elementów do kolekcji jest widoczne w widoku listy). Stan początkowy: wyświetlona jest jedna notatka z dowolnym tytułem i treścią (ilustracja 2 lub 4).

    Kolekcja to ArrayList<Notatka> - lista obiektów notatek, nie napisów (R.3.5). Na start dokładamy jedną notatkę (R.3.7).

    Listę z kolekcją łączy ArrayAdapter<Notatka> z systemowym wyglądem wiersza simple_list_item_1: dla każdej notatki wstawia do wiersza wynik jej toString(). Adapter zapisujemy w polu - przycisk będzie go potrzebował do odświeżenia listy.

    Notatnik/app/src/main/java/com/example/notatnik/MainActivity.java Java zmienione: 12 linii
    package com.example.notatnik;
    
    import android.os.Bundle;
    import android.widget.ArrayAdapter;
    import android.widget.ListView;
    
    import androidx.activity.EdgeToEdge;
    import androidx.appcompat.app.AppCompatActivity;
    import androidx.core.graphics.Insets;
    import androidx.core.view.ViewCompat;
    import androidx.core.view.WindowInsetsCompat;
    
    import java.util.ArrayList;
    
    public class MainActivity extends AppCompatActivity {
    
        private final ArrayList<Notatka> notes = new ArrayList<>();
        private ArrayAdapter<Notatka> adapter;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            EdgeToEdge.enable(this);
            setContentView(R.layout.activity_main);
            ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {
                Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
                v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
                return insets;
            });
    
            notes.add(new Notatka("tenis", "Gra z Ewą w poniedziałek", true));
            adapter = new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, notes);
            ListView notesList = findViewById(R.id.notesList);
            notesList.setAdapter(adapter);
        }
    }
    Ekran telefonu po tym kroku

    Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.

  13. Krok 13: DODAJ: nowa notatka na liście

    Kryteria: ,

    R.3.6 Zdefiniowana funkcja powiązana ze zdarzeniem kliknięcia przycisku. Funkcja dodaje do kolekcji notatkę, której tytuł i treść wpisane są w pola edycyjne

    R.3.8 Po wpisaniu tekstu do obu pól edycyjnych i wciśnięciu przycisku jest widoczny dodany nowy element listy (w uruchomionej aplikacji lub na zrzucie i obowiązkowo w kodzie)

    ok. 3 min
    Polecenie z arkusza

    Działanie aplikacji po wybraniu przycisku (ilustracja 3 lub 5): tworzony jest nowy element notatki z wartościami tytułu i treści pobranymi z pól edycyjnych, notatka nie jest ważna. Element jest dodawany do kolekcji oraz jest widoczny w widoku listy.

    Metodę addNote wiążemy z przyciskiem atrybutem android:onClick (R.3.6). Tworzy notatkę konstruktorem trójargumentowym z tytułem i treścią z pól i false - nie jest ważna - i dodaje ją do kolekcji. notifyDataSetChanged() mówi adapterowi, że kolekcja się zmieniła: lista się przerysowuje i nowa notatka pojawia się na końcu (R.3.8).

    Wpisz w podglądzie „Lekarz” i „Wizyta u laryngologa wtorek”, kliknij „DODAJ” - jak na ilustracji 5.

    Typowe błędy

    Bez notifyDataSetChanged() notatka trafia do kolekcji, ale lista na ekranie zostaje bez zmian (R.3.8).

    Notatnik/app/src/main/java/com/example/notatnik/MainActivity.java Java zmienione: 11 linii
    package com.example.notatnik;
    
    import android.os.Bundle;
    import android.view.View;
    import android.widget.ArrayAdapter;
    import android.widget.EditText;
    import android.widget.ListView;
    
    import androidx.activity.EdgeToEdge;
    import androidx.appcompat.app.AppCompatActivity;
    import androidx.core.graphics.Insets;
    import androidx.core.view.ViewCompat;
    import androidx.core.view.WindowInsetsCompat;
    
    import java.util.ArrayList;
    
    public class MainActivity extends AppCompatActivity {
    
        private final ArrayList<Notatka> notes = new ArrayList<>();
        private ArrayAdapter<Notatka> adapter;
        private EditText titleInput;
        private EditText contentInput;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            EdgeToEdge.enable(this);
            setContentView(R.layout.activity_main);
            ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {
                Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
                v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
                return insets;
            });
    
            notes.add(new Notatka("tenis", "Gra z Ewą w poniedziałek", true));
            adapter = new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, notes);
            ListView notesList = findViewById(R.id.notesList);
            notesList.setAdapter(adapter);
            titleInput = findViewById(R.id.titleInput);
            contentInput = findViewById(R.id.contentInput);
        }
    
        public void addNote(View view) {
            notes.add(new Notatka(titleInput.getText().toString(), contentInput.getText().toString(), false));
            adapter.notifyDataSetChanged();
        }
    }
    Notatnik/app/src/main/res/layout/activity_main.xml XML zmienione: 1 linia
    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/main"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="#F0F8FF"
        android:orientation="vertical"
        tools:context=".MainActivity">
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Notatki"
            android:textColor="#0000CD"
            android:textSize="26sp" />
    
        <ListView
            android:id="@+id/notesList"
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1" />
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Dodanie notatki"
            android:textColor="#0000CD"
            android:textSize="20sp" />
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Tytuł notatki: " />
    
        <EditText
            android:id="@+id/titleInput"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:inputType="text" />
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Treść notatki: " />
    
        <EditText
            android:id="@+id/contentInput"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:inputType="text" />
    
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="addNote"
            android:text="DODAJ"
            android:textColor="#0000CD" />
    
    </LinearLayout>
    Ekran telefonu po tym kroku

    Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.

  14. Krok 14: Uruchomienie w emulatorze, zrzuty i folder mobilna

    Kryteria: ,

    R.3.7 Aplikacja kompiluje się i uruchamia w emulatorze aplikacji mobilnej, co udokumentowane jest zrzutem ekranu. Jej układ jest zgodny z ilustracją 2 lub 4 w arkuszu egzaminacyjnym. W stanie początkowym jest wyświetlana jedna notatka z dowolnym tytułem i treścią (w uruchomionej aplikacji lub na zrzucie i obowiązkowo w kodzie)

    R.4.7 Zapisany 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

    Podejmij próbę kompilacji i emulacji aplikacji. Aplikacja mobilna – dowolna liczba zrzutów nazwanych mobilna1, mobilna2 ... (np. stan początkowy, po dodaniu elementu). W folderze mobilna: spakowany cały projekt aplikacji mobilnej, modyfikowane pliki źródłowe.

    Uruchamiamy aplikację w emulatorze. Zrzuty całego ekranu z Android Studio do folderu dokumentacja: mobilna1 - stan początkowy, mobilna2 - po dodaniu notatki (R.3.7, R.4.7). W folderze mobilna: archiwum projektu, activity_main.xml, MainActivity.java i Notatka.java.

    Ekran telefonu bez zmian - taki jak po kroku 13.

  15. Etap 5: Dokumentacja

    Kroki 15-16 · po tym etapie masz 32 z 33 kryteriów (pkt)

    Krok 15: Nagłówek metody wyswietl według listingu 1

    Kryteria: , , , ,

    R.4.1 Komentarz jest zgodny z Listingiem 1 arkusza egzaminacyjnego. Komentarz może być wieloliniowy lub kilka jednoliniowych, lub Docstrings (potrójny cudzysłów)

    R.4.2 W komentarzu umieszczona nazwa metody oraz opisane jej działanie

    R.4.3 W komentarzu umieszczone nazwa i krótki opis wszystkich parametrów lub "brak", gdy nie ma parametrów

    R.4.4 W komentarzu umieszczona nazwa typu zwracanego i opis co jest zwracane lub "brak"

    R.4.5 W komentarzu umieszczony numer zdającego

    ok. 3 min
    Polecenie z arkusza

    W kodzie źródłowym aplikacji konsolowej za pomocą komentarza utwórz jeden nagłówek do metody według wzoru z listingu 1. Komentarz powinien znaleźć się nad lub pod nazwą funkcji. W miejscu nawiasów <> należy podać odpowiednie opisy. W miejscu autor należy podać numer zdającego.

    Komentarz wieloliniowy nad metodą wyswietl z polami listingu 1 (R.4.1): nazwa i opis działania (R.4.2), parametry - brak, bo metoda jest bezargumentowa (R.4.3), zwracany typ - brak (void) (R.4.4) - i autor (R.4.5). Na egzaminie w polu autor wpisujemy numer PESEL - tu stoi Bartosz Bryniarski.

    konsola/src/Notatka.java Java zmienione: 8 linii
    import java.time.LocalDateTime;
    import java.time.format.DateTimeFormatter;
    
    public class Notatka {
        public String tytul;
        public String tresc;
        public boolean wazna;
        public LocalDateTime dataDodania;
    
        public Notatka(String tytul, String tresc, boolean wazna) {
            this.tytul = tytul;
            this.tresc = tresc;
            this.wazna = wazna;
            this.dataDodania = LocalDateTime.now();
        }
    
        public Notatka(String tytul) {
            this.tytul = tytul;
            this.tresc = "";
            this.wazna = false;
            this.dataDodania = LocalDateTime.now();
        }
    
        /*
          nazwa:        wyswietl
          opis:         wypisuje notatkę w osobnych liniach: linia podkreślników, tytuł (ze słowem WAŻNA!
                        dla ważnej notatki), treść, data dodania, linia podkreślników
          parametry:    brak
          zwracany typ: brak (void)
          autor:        Bartosz Bryniarski
        */
        public void wyswietl() {
            System.out.println("____________________");
            if (wazna) {
                System.out.println("Notatka WAŻNA! " + tytul);
            } else {
                System.out.println("Notatka " + tytul);
            }
            System.out.println(tresc);
            System.out.println(dataDodania.format(DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm:ss")));
            System.out.println("____________________");
        }
    }
    Wynik programu po tym kroku
    > java Main
    Podaj tytuł notatki:
    spotkanie z kolegami
    ____________________
    Notatka WAŻNA! tenis
    Gra z Ewą w poniedziałek
    02.10.2026 22:11:05
    ____________________
    ____________________
    Notatka spotkanie z kolegami
    
    02.10.2026 22:11:05
    ____________________
  16. Krok 16: Plik egzamin

    Kryteria:

    R.4.8 Dokumentacja zawiera: nazwę systemu operacyjnego, nazwy środowisk programistycznych, emulatora, nazwy języków programowania

    ok. 2 min
    Polecenie z arkusza

    Utwórz plik tekstowy i nazwij go egzamin. Dokument powinien zawierać informacje o narzędziach wykorzystanych na egzaminie: nazwę systemu operacyjnego, nazwy środowisk programistycznych, nazwę emulatora dla aplikacji mobilnej, nazwy języków programowania.

    Plik tekstowy egzamin.txt (wystarczy Notatnik) w folderze dokumentacja: system, środowiska, emulator i języki (R.4.8).

    egzamin.txt Tekst nowy plik
    System operacyjny: Windows 11
    Środowiska programistyczne: IntelliJ IDEA (aplikacja konsolowa), Android Studio (aplikacja mobilna)
    Emulator: Pixel 8 (Android 16, API 36) z Android Studio
    Języki programowania: Java (aplikacja konsolowa i mobilna), XML (układ aplikacji mobilnej)

    Wynik programu bez zmian - taki jak po kroku 15.

  17. Etap 6: Dobre praktyki (poza kluczem)

    Krok 17 · po tym etapie masz 32 z 33 kryteriów (pkt)

    Krok 17: Android: notatka bez tytułu nie wejdzie, pola czyszczone

    ok. 3 min
    Polecenie z arkusza

    Tworzony jest nowy element notatki z wartościami tytułu i treści pobranymi z pól edycyjnych, notatka nie jest ważna.

    Kliknięcie „DODAJ” przy pustych polach dodaje pusty wiersz. Trzy poprawki:

    • tytuł bez spacji z brzegów (trim()); pusty tytuł - setError pokazuje przy polu czerwony wykrzyknik z podpowiedzią, a notatka nie powstaje,
    • treść też przycinamy,
    • po dodaniu oba pola czyścimy - gotowe na następną notatkę.

    Na egzaminie wystarczy wersja wcześniejsza - klucz tego nie sprawdza.

    Notatnik/app/src/main/java/com/example/notatnik/MainActivity.java Java zmienione: 8 linii
    package com.example.notatnik;
    
    import android.os.Bundle;
    import android.view.View;
    import android.widget.ArrayAdapter;
    import android.widget.EditText;
    import android.widget.ListView;
    
    import androidx.activity.EdgeToEdge;
    import androidx.appcompat.app.AppCompatActivity;
    import androidx.core.graphics.Insets;
    import androidx.core.view.ViewCompat;
    import androidx.core.view.WindowInsetsCompat;
    
    import java.util.ArrayList;
    
    public class MainActivity extends AppCompatActivity {
    
        private final ArrayList<Notatka> notes = new ArrayList<>();
        private ArrayAdapter<Notatka> adapter;
        private EditText titleInput;
        private EditText contentInput;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            EdgeToEdge.enable(this);
            setContentView(R.layout.activity_main);
            ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {
                Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
                v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
                return insets;
            });
    
            notes.add(new Notatka("tenis", "Gra z Ewą w poniedziałek", true));
            adapter = new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, notes);
            ListView notesList = findViewById(R.id.notesList);
            notesList.setAdapter(adapter);
            titleInput = findViewById(R.id.titleInput);
            contentInput = findViewById(R.id.contentInput);
        }
    
        public void addNote(View view) {
            String title = titleInput.getText().toString().trim();
            if (title.isEmpty()) {
                titleInput.setError("Podaj tytuł notatki");
                return;
            }
            notes.add(new Notatka(title, contentInput.getText().toString().trim(), false));
            adapter.notifyDataSetChanged();
            titleInput.setText("");
            contentInput.setText("");
        }
    }
    Ekran telefonu po tym kroku

    Symulacja ekranu w przeglądarce - w Android Studio / Visual Studio wygląd może się nieco różnić.

  18. Etap 7: Oddanie pracy

    Krok 18 · po tym etapie masz 33 z 33 kryteriów (pkt)

    Krok 18: Nagranie płyty

    Kryteria:

    R.4.9 Przygotowana jest dokumentacja w postaci płyty: oba projekty są spakowane oraz zmodyfikowane pliki są umieszczone na zewnątrz archiwów

    ok. 5 min
    Polecenie z arkusza

    Nagraj płytę z rezultatami pracy. W folderze z numerem zdającego powinny się znajdować trzy foldery: dokumentacja, konsolowa i mobilna.

    Sprawdzamy zawartość przed nagraniem (R.4.9):

    • konsolowa: archiwum projektu (po dopisaniu komentarza), Notatka.java, Main.java,
    • mobilna: archiwum projektu, activity_main.xml, MainActivity.java, Notatka.java,
    • dokumentacja: konsola1, mobilna1, mobilna2, egzamin.txt.

    Nagrywamy, sprawdzamy odczyt płyty, opisujemy ją numerem zdającego.

    Ekran telefonu bez zmian - taki jak po kroku 17.

Podgląd

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: . 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.