Java Academy · Lekcja

Konwersje rozszerzające i zawężające

Poznaj automatyczne konwersje rozszerzające oraz dowiedz się, jak bezpiecznie wykonywać jawne rzutowania zawężające.

Lekcja 2 z 413 kroki

Konwersje rozszerzające i zawężające to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 2 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.

Konwersje typów w Javie

Java pozwala konwertować wartości między zgodnymi typami. Istnieją dwa kierunki:

Rozszerzanie — konwersja do większego typu (bezpieczna, automatyczna)
Zawężanie — konwersja do mniejszego typu (ryzykowna, wymaga jawnego rzutowania)

Konwersja rozszerzająca

Rozszerzanie odbywa się automatycznie podczas przypisywania wartości do większego zgodnego typu. Nie dochodzi do utraty danych, ponieważ typ docelowy może reprezentować wszystkie wartości typu źródłowego.

Kolejność rozszerzania: byte → short → int → long → float → double

byte b = 42;
short s = b;    // byte → short (widening)
int i = s;      // short → int (widening)
long l = i;     // int → long (widening)
float f = l;    // long → float (widening)
double d = f;   // float → double (widening)

System.out.println(d); // 42.0

Konwersja zawężająca

Zawężanie należy wykonać jawnie za pomocą operatora rzutowania (type). Wartość może zostać obcięta lub zniekształcona, jeśli nie mieści się w typie docelowym.

double price = 99.99;
int wholePart = (int) price; // narrows — decimal truncated
System.out.println(wholePart); // 99 (not rounded!)

long bigNum = 130L;
byte small = (byte) bigNum;  // 130 overflows byte (max 127)
System.out.println(small);   // -126 (unexpected!)

Przepełnienie podczas konwersji zawężającej

Gdy podczas zawężania dochodzi do przepełnienia, Java zawija wartość zgodnie z arytmetyką modulo — nie jest zgłaszany żaden wyjątek. Należy samodzielnie zabezpieczyć się przed taką sytuacją.

int million = 1_000_000;
byte narrowed = (byte) million;
System.out.println(narrowed); // 64 (wraps around)

// Safe narrowing: check bounds first
if (million >= Byte.MIN_VALUE && million <= Byte.MAX_VALUE) {
    byte safe = (byte) million;
} else {
    System.out.println("Value doesn't fit in byte!");
}

Konwersje char i int

char to 16-bitowa liczba całkowita bez znaku reprezentująca punkt kodowy Unicode. Jest automatycznie rozszerzany do int, ale konwersja z int z powrotem do char wymaga jawnego rzutowania.

char letter = 'A';
int code = letter;          // widening: char → int
System.out.println(code);   // 65

int nextCode = code + 1;
char nextLetter = (char) nextCode; // narrowing: int → char
System.out.println(nextLetter);    // B

// Useful for Caesar cipher shifts
char shifted = (char) ('a' + 3);
System.out.println(shifted); // d

Obcinanie części ułamkowej przy konwersji liczby zmiennoprzecinkowej na całkowitą

Rzutowanie liczby zmiennoprzecinkowej na całkowitą obcina część ułamkową w kierunku zera — nie zaokrągla. Jeśli potrzebne jest zaokrąglanie, należy użyć Math.round().

double pos = 3.9;
double neg = -3.9;

System.out.println((int) pos);         // 3 (not 4)
System.out.println((int) neg);         // -3 (not -4)
System.out.println(Math.round(pos));   // 4
System.out.println(Math.round(neg));   // -4

Konwersja String na liczbę

Do parsowania String na liczbę służą metody klas opakowujących — nie rzutowanie. Przekazanie nie numerycznego ciągu znaków powoduje zgłoszenie NumberFormatException.

String input = "42";
int parsed = Integer.parseInt(input);
double parsedD = Double.parseDouble("3.14");

System.out.println(parsed + 1);  // 43
System.out.println(parsedD);     // 3.14

try {
    int bad = Integer.parseInt("abc");
} catch (NumberFormatException e) {
    System.out.println("Not a valid number!");
}

Konwersja liczby na String

Konwersję liczby na String można wykonać za pomocą String.valueOf(), Integer.toString() lub konkatenacji łańcuchów z użyciem "".

int score = 95;
String s1 = String.valueOf(score);    // "95"
String s2 = Integer.toString(score);  // "95"
String s3 = score + "";              // "95" (concat trick)

System.out.println(s1.getClass().getSimpleName()); // String

// Converting to different bases
System.out.println(Integer.toBinaryString(42)); // 101010
System.out.println(Integer.toHexString(255));   // ff

Promocja w wyrażeniach

W wyrażeniach arytmetycznych Java automatycznie promuje operandy:

byte, short, char → przed wykonaniem operacji są promowane do int
Jeśli jeden z operandów ma typ long, wynik ma typ long
Jeśli jeden z operandów ma typ float lub double, wynik ma szerszy z tych typów

byte x = 10;
byte y = 20;
// byte z = x + y; // compile error! sum is promoted to int
int z = x + y;      // correct

long a = 100L;
float b = 2.5f;
double result = a * b; // long * float → double
System.out.println(result); // 250.0

Operatory przypisania złożonego

Operatory złożone, takie jak +=, -= i *=, zawierają niejawne zawężające rzutowanie. Dzięki temu można pisać zwięzły kod korzystający ze zmiennych typu byte i short.

byte count = 100;
// count = count + 1; // compile error — int result needs cast
count += 1;           // OK — compound op casts automatically
System.out.println(count); // 101

short total = 1000;
total *= 2;  // implicit narrow cast included
System.out.println(total); // 2000

Praktyka: bezpieczne parsowanie liczb całkowitych

Praktyczny wzorzec: bezpiecznie sparsować dane wprowadzone przez użytkownika, sprawdzić zakres i zawęzić wynik do dokładnie potrzebnego typu.

public static byte parseAsByte(String input) {
    int value = Integer.parseInt(input); // can throw NumberFormatException
    if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
        throw new IllegalArgumentException(
            "Value " + value + " out of byte range");
    }
    return (byte) value;
}

// Usage
System.out.println(parseAsByte("100")); // 100
System.out.println(parseAsByte("200")); // IllegalArgumentException

Szybki test

Jaki wynik zwróci poniższy kod?

double d = -7.8;
int i = (int) d;
System.out.println(i);

Odpowiedz w interaktywnej lekcji

Podsumowanie: rozszerzanie i zawężanie

Najważniejsze informacje:

Konwersja rozszerzająca jest automatyczna i bezpieczna: byte→short→int→long→float→double
Konwersja zawężająca wymaga jawnego rzutowania i może prowadzić do utraty danych lub przepełnienia
char jest rozszerzany do int; int można z powrotem zawęzić do char za pomocą rzutowania
Konwersja liczb zmiennoprzecinkowych na int obcina część ułamkową w kierunku zera (nie zaokrągla)
Do konwersji String na liczby służą Integer.parseInt/Double.parseDouble
Operatory złożone (+=, *=) zawierają niejawne zawężające rzutowanie

Bezpłatny start

Ucz się Java dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 104
Lekcje: 374

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Konwersje rozszerzające i zawężające” jest bezpłatna?

Tak — pełny tekst „Konwersje rozszerzające i zawężające” 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 „Konwersje rozszerzające i zawężające”?

Poznaj automatyczne konwersje rozszerzające oraz dowiedz się, jak bezpiecznie wykonywać jawne rzutowania zawężające. Ć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 2 z 4.

Ile czasu zajmuje lekcja „Konwersje rozszerzające i zawężające”?

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