Przejdź do głównej treści
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.

  1. Etap 1: Przygotowanie

    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:

    "Zakupy: chleb, masło, ser",
    "Do zrobienia: obiad, umyć podłogi",
    "weekend: kino, spacer z psem"
    

    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.

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

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

    Kryteria: , ,

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

    konsola/src/Notatka.java Java nowy plik
    public class Notatka {
        private static int counter = 0;
        private int id;
        protected String title;
        protected String content;
    }
  4. 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: najpierw counter++, potem id = 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.

    konsola/src/Notatka.java Java zmienione: 7 linii
    public class Notatka {
        private static int counter = 0;
        private int id;
        protected String title;
        protected String content;
    
        public Notatka(String title, String content) {
            counter++;
            id = counter;
            this.title = title;
            this.content = content;
        }
    }
  5. Krok 5: Metoda show: tytuł i treść

    Kryteria: , ,

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

    konsola/src/Notatka.java Java zmienione: 5 linii
    public class Notatka {
        private static int counter = 0;
        private int id;
        protected String title;
        protected String content;
    
        public Notatka(String title, String content) {
            counter++;
            id = counter;
            this.title = title;
            this.content = content;
        }
    
        public void show() {
            System.out.println("Tytuł: " + title);
            System.out.println("Treść: " + content);
        }
    }
  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).

    konsola/src/Notatka.java Java zmienione: 4 linie
    public class Notatka {
        private static int counter = 0;
        private int id;
        protected String title;
        protected String content;
    
        public Notatka(String title, String content) {
            counter++;
            id = counter;
            this.title = title;
            this.content = content;
        }
    
        public void show() {
            System.out.println("Tytuł: " + title);
            System.out.println("Treść: " + content);
        }
    
        public void showDiagnostics() {
            System.out.println("Diagnostyka: " + counter + ";" + id + ";" + title + ";" + content);
        }
    }
  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).

    konsola/src/Main.java Java zmienione: 3 linie
    public class Main {
        public static void main(String[] args) {
            Notatka shopping = new Notatka("Zakupy", "chleb, masło, ser");
            shopping.show();
            shopping.showDiagnostics();
        }
    }
    Wynik programu po tym kroku
    > java Main
    Tytuł: Zakupy
    Treść: chleb, masło, ser
    Diagnostyka: 1;1;Zakupy;chleb, masło, ser
  8. 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.java Java zmienione: 5 linii
    public class Main {
        public static void main(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
  9. 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.

    Wynik programu bez zmian - taki jak po kroku 8.

  10. Etap 3: Aplikacja mobilna

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

    Notatki/app/src/main/java/com/example/notatki/MainActivity.java Java nowy plik
    package com.example.notatki;
    
    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;
            });
        }
    }
    Notatki/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ć.

  11. 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.xml XML zmienione: 3 linie
    <?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:orientation="vertical"
        tools:context=".MainActivity">
    
    </LinearLayout>
    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: 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.xml XML zmienione: 15 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:orientation="vertical"
        tools:context=".MainActivity">
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">
    
            <EditText
                android:id="@+id/noteInput"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:hint="Nowy element"
                android:inputType="text" />
    
        </LinearLayout>
    
    </LinearLayout>
    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: 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.xml XML zmienione: 8 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:orientation="vertical"
        tools:context=".MainActivity">
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">
    
            <EditText
                android:id="@+id/noteInput"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:hint="Nowy element"
                android:inputType="text" />
    
            <Button
                android:id="@+id/addButton"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:backgroundTint="#DC143C"
                android:text="DODAJ"
                android:textColor="#FFFFFF" />
    
        </LinearLayout>
    
    </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: 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.xml XML zmienione: 5 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:orientation="vertical"
        tools:context=".MainActivity">
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">
    
            <EditText
                android:id="@+id/noteInput"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:hint="Nowy element"
                android:inputType="text" />
    
            <Button
                android:id="@+id/addButton"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:backgroundTint="#DC143C"
                android:text="DODAJ"
                android:textColor="#FFFFFF" />
    
        </LinearLayout>
    
        <ListView
            android:id="@+id/notesList"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />
    
    </LinearLayout>
    Ekran telefonu po tym kroku

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

  15. 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.java Java zmienione: 10 linii
    package com.example.notatki;
    
    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;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    
    public class MainActivity extends AppCompatActivity {
    
        private ArrayList<String> notes;
    
        @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 = new ArrayList<>(Arrays.asList(
                    "Zakupy: chleb, masło, ser",
                    "Do zrobienia: obiad, umyć podłogi",
                    "weekend: kino, spacer z psem"));
        }
    }
    Ekran telefonu po tym kroku

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

  16. 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.java Java zmienione: 6 linii
    package com.example.notatki;
    
    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;
    import java.util.Arrays;
    
    public class MainActivity extends AppCompatActivity {
    
        private ArrayList<String> notes;
        private ArrayAdapter<String> 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 = new ArrayList<>(Arrays.asList(
                    "Zakupy: chleb, masło, ser",
                    "Do zrobienia: obiad, umyć podłogi",
                    "weekend: kino, spacer z psem"));
            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ć.

  17. 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).

    Separator ustawiamy dwoma atrybutami ListView:

    • android:divider="#DC143C" - kolor Crimson (R.3.5),
    • 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.xml XML zmienione: 3 linie
    <?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:orientation="vertical"
        tools:context=".MainActivity">
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">
    
            <EditText
                android:id="@+id/noteInput"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:hint="Nowy element"
                android:inputType="text" />
    
            <Button
                android:id="@+id/addButton"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:backgroundTint="#DC143C"
                android:text="DODAJ"
                android:textColor="#FFFFFF" />
    
        </LinearLayout>
    
        <ListView
            android:id="@+id/notesList"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:divider="#DC143C"
            android:dividerHeight="2dp" />
    
    </LinearLayout>
    Ekran telefonu po tym kroku

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

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

    1. notes.add dopisuje tekst z pola na końcu kolekcji,
    2. 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.java Java zmienione: 9 linii
    package com.example.notatki;
    
    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;
    import java.util.Arrays;
    
    public class MainActivity extends AppCompatActivity {
    
        private ArrayList<String> notes;
        private ArrayAdapter<String> adapter;
        private EditText noteInput;
    
        @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 = new ArrayList<>(Arrays.asList(
                    "Zakupy: chleb, masło, ser",
                    "Do zrobienia: obiad, umyć podłogi",
                    "weekend: kino, spacer z psem"));
            adapter = new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, notes);
            ListView notesList = findViewById(R.id.notesList);
            notesList.setAdapter(adapter);
            noteInput = findViewById(R.id.noteInput);
        }
    
        public void addNote(View view) {
            notes.add(noteInput.getText().toString());
            adapter.notifyDataSetChanged();
        }
    }
    Notatki/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:orientation="vertical"
        tools:context=".MainActivity">
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">
    
            <EditText
                android:id="@+id/noteInput"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:hint="Nowy element"
                android:inputType="text" />
    
            <Button
                android:id="@+id/addButton"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:backgroundTint="#DC143C"
                android:onClick="addNote"
                android:text="DODAJ"
                android:textColor="#FFFFFF" />
    
        </LinearLayout>
    
        <ListView
            android:id="@+id/notesList"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:divider="#DC143C"
            android:dividerHeight="2dp" />
    
    </LinearLayout>
    Ekran telefonu po tym kroku

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

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

    Ekran telefonu bez zmian - taki jak po kroku 18.

  20. Etap 4: Dokumentacja

    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.java Java zmienione: 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
     ******************************************************
     */
    public class Notatka {
        private static int counter = 0;
        private int id;
        protected String title;
        protected String content;
    
        public Notatka(String title, String content) {
            counter++;
            id = counter;
            this.title = title;
            this.content = content;
        }
    
        public void show() {
            System.out.println("Tytuł: " + title);
            System.out.println("Treść: " + content);
        }
    
        public void showDiagnostics() {
            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
  21. 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.txt Tekst nowy plik
    Zrzuty ekranu: konsola1 - wynik programu; mobile1 - stan początkowy; mobile2 - w trakcie pisania; mobile3 - po dodaniu notatki
    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 20.

  22. Etap 5: Dobre praktyki (poza kluczem)

    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.java Java zmienione: 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
     ******************************************************
     */
    public class Notatka {
        private static int counter = 0;
        private final int id;
        protected String title;
        protected String content;
    
        public Notatka(String title, String content) {
            counter++;
            id = counter;
            this.title = title;
            this.content = content;
        }
    
        public void show() {
            System.out.println("Tytuł: " + title);
            System.out.println("Treść: " + content);
        }
    
        public void showDiagnostics() {
            System.out.println("Diagnostyka: " + counter + ";" + id + ";" + title + ";" + content);
        }
    }

    Wynik programu bez zmian - taki jak po kroku 20.

  23. 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.java Java zmienione: 6 linii
    package com.example.notatki;
    
    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;
    import java.util.Arrays;
    
    public class MainActivity extends AppCompatActivity {
    
        private ArrayList<String> notes;
        private ArrayAdapter<String> adapter;
        private EditText noteInput;
    
        @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 = new ArrayList<>(Arrays.asList(
                    "Zakupy: chleb, masło, ser",
                    "Do zrobienia: obiad, umyć podłogi",
                    "weekend: kino, spacer z psem"));
            adapter = new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, notes);
            ListView notesList = findViewById(R.id.notesList);
            notesList.setAdapter(adapter);
            noteInput = findViewById(R.id.noteInput);
        }
    
        public void addNote(View view) {
            String text = noteInput.getText().toString().trim();
            if (text.isEmpty()) {
                return;
            }
            notes.add(text);
            adapter.notifyDataSetChanged();
            noteInput.setText("");
        }
    }
    Ekran telefonu po tym kroku

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

  24. Etap 6: Oddanie pracy

    Krok 24 · po tym etapie masz 34 z 34 kryteriów (pkt)

    Krok 24: Nagranie płyty

    ok. 5 min
    Polecenie z arkusza

    Nagraj płytę z rezultatami pracy. W folderze z numerem zdającego powinny się znajdować podfoldery: konsola, mobilna, dokumentacja.

    Sprawdzamy zawartość przed nagraniem:

    • konsola: konsola.zip (po dopisaniu komentarza), Notatka.java, Main.java,
    • mobilna: mobilna.zip, activity_main.xml, MainActivity.java,
    • dokumentacja: konsola1, mobile1, mobile2, mobile3, egzamin.

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

    Ekran telefonu bez zmian - taki jak po kroku 23.

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.