Java Academy · Lekcja

Deklarowanie bloków tekstowych

Pisz wielowierszowe napisy za pomocą potrójnych cudzysłowów

Deklarowanie bloków tekstowych to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Problem z wieloma wierszami

Przed Javą 15 zapis tekstu w wielu wierszach oznaczał łączenie napisów za pomocą \n i +. Taki zapis był trudny do odczytania i łatwo było popełnić w nim błąd. Rozwiązaniem są bloki tekstowe.

Potrójne cudzysłowy

Blok tekstowy rozpoczyna się trzema znakami cudzysłowu """, po których następuje znak nowego wiersza, a kończy zamykającymi znakami """. Cała zawartość pomiędzy nimi jest napisem.

public class Main {
    public static void main(String[] args) {
        String message = """
            Hello
            World
            """;
        System.out.println(message);
    }
}

Reguła pierwszego wiersza

Zawartość musi zaczynać się w wierszu następującym po otwierającym """. Nie można umieścić tekstu bezpośrednio po otwierającym ograniczniku. Ten znak nowego wiersza jest wymaganą częścią składni.

public class Main {
    public static void main(String[] args) {
        String poem = """
            Roses are red
            Violets are blue
            """;
        System.out.println(poem);
    }
}

Znaki nowego wiersza są dodawane automatycznie

Każdy podział wiersza w bloku tekstowym staje się znakiem \n w wynikowym napisie. Nie trzeba już ręcznie zapisywać sekwencji specjalnych oznaczających końce wierszy.

public class Main {
    public static void main(String[] args) {
        String list = """
            Apples
            Bananas
            Cherries
            """;
        System.out.print(list);
    }
}

Koniec z konkatenacją

Proszę porównać stary sposób ("a\n" + "b\n") z blokiem tekstowym. Blok tekstowy wygląda dokładnie tak jak wynik, dzięki czemu błędy są od razu widoczne.

public class Main {
    public static void main(String[] args) {
        String html = """
            <html>
              <body>Hi</body>
            </html>
            """;
        System.out.println(html);
    }
}

Cudzysłowy bez znaków ucieczki

Wewnątrz bloku tekstowego pojedyncze cudzysłowy " nie wymagają znaków ucieczki. Jest to idealne rozwiązanie dla treści zawierających cudzysłowy, takich jak JSON.

public class Main {
    public static void main(String[] args) {
        String json = """
            {"name": "Alice", "age": 30}
            """;
        System.out.println(json);
    }
}

Blok tekstowy nadal jest napisem

Wynikiem jest zwykły obiekt String. Można wywoływać na nim dowolne metody String, łączyć go z innymi napisami lub przekazywać do innych metod.

public class Main {
    public static void main(String[] args) {
        String text = """
            one
            two
            """;
        System.out.println("Length: " + text.length());
        System.out.println("Upper: " + text.toUpperCase());
    }
}

Łączenie bloków tekstowych

Blok tekstowy można łączyć z innymi napisami za pomocą +, tak jak każdy literał napisowy.

public class Main {
    public static void main(String[] args) {
        String name = "Bob";
        String greeting = """
            Dear customer,
            """ + "Welcome " + name;
        System.out.println(greeting);
    }
}

Puste wiersze są zachowywane

Puste wiersze wewnątrz bloku zostają zachowane jako puste wiersze w napisie. Dzięki temu można naturalnie formatować wynik z odstępami.

public class Main {
    public static void main(String[] args) {
        String spaced = """
            Title

            Body text
            """;
        System.out.print(spaced);
    }
}

Czytelne fragmenty kodu

Bloki tekstowe świetnie sprawdzają się przy osadzaniu treści przypominających kod. W tym przykładzie niewielki blok pseudokonfiguracji pozostaje doskonale czytelny.

public class Main {
    public static void main(String[] args) {
        String config = """
            host = localhost
            port = 8080
            debug = true
            """;
        System.out.print(config);
    }
}

Liczenie wierszy

Ponieważ znaki nowego wiersza są rzeczywiście obecne, blok tekstowy można podzielić za pomocą \n, aby przetwarzać każdy wiersz osobno.

public class Main {
    public static void main(String[] args) {
        String data = """
            red
            green
            blue
            """;
        String[] lines = data.split("\n");
        System.out.println("Lines: " + lines.length);
    }
}

Szybkie sprawdzenie

Gdzie musi zaczynać się zawartość bloku tekstowego?

Podsumowanie

Poznali Państwo sposób deklarowania bloków tekstowych:

Blok otwiera się i zamyka za pomocą """
Zawartość musi zaczynać się w następnym wierszu
Podziały wierszy są automatycznie zamieniane na \n
Cudzysłowy nie wymagają znaków ucieczki
Wynikiem jest zwykły obiekt String

Często zadawane pytania

Czy lekcja „Deklarowanie bloków tekstowych” jest bezpłatna?

Tak — pełny tekst „Deklarowanie bloków tekstowych” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Deklarowanie bloków tekstowych”?

Pisz wielowierszowe napisy za pomocą potrójnych cudzysłowów Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Deklarowanie bloków tekstowych”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Java Academy