R1IODkhO0WwZH

Film nawiązujący do treści materiału podstawowe typy zmiennych.

Film nawiązujący do treści materiału podstawowe typy zmiennych.

Film dostępny pod adresem /preview/resource/R1IODkhO0WwZH

Film nawiązujący do treści materiału podstawowe typy zmiennych.

Kod programu zaprezentowanego w filmie:

Podsumowanie informacji na temat zmiennych w języku Java

Typy danych w języku Java

Ponieważ zmienne są używane do przechowywania danych, niezbędne jest omówienie typów danych w języku Java. Należą do nich liczby, znaki lub ciągi znaków o różnym zakresie oraz długości, zajmujące różną ilość miejsca w pamięci komputera, co wpływa na wydajność programów. Typy danych dzielimy na:

• proste (prymitywne),

• złożone (obiektowe), które w uproszczeniu opiszemy jako składające się z typów prostych.

Do typów prostych zaliczamy typy numeryczne (mieszczące dane liczbowe):

• liczby całkowite:

1. byte ($1$ bajt) – zakres od $-127$ do $128$,

2. short ($2$ bajty) – zakres od $-32768$ do $32767$,

3. int ($4$ bajty) – zakres od $-2147483648$ do $2147483647$,

4. long ($8$ bajtów) – zakres od $-2^{63}$ do $2^{63}-1$ (mają przyrostek L lub l)

1. float ($4$ bajty) – maksymalnie $7$ liczb po przecinku,

2. double ($8$ bajtów) – maksymalnie $15$ cyfr po przecinku.

Float i double oprócz tego, że różnią się ilością zajmowanego miejsca w pamięci, są typami o różnej precyzji; double jest dokładniejszy.

Zazwyczaj w programach tworzonych w języku Java dla typów całkowitych używany jest int, a dla typów zmiennoprzecinkowych double.  Typ int jest na tyle duży, że w większości przypadków pomieści potrzebne wartości, a jednocześnie nie spowolni działania programu; double natomiast jest dostatecznie precyzyjny.

Kolejnym typem prostym jest char (z ang. character) – znak. Mieści on w sobie pojedynczy znak, który musi być umieszczony pomiędzy apostrofami, np. 'c'. Może także być zapisany w postaci liczby szesnastkowej lub dziesiętnej odpowiadającej kodowi danego znaku z tabeli unikodu, np. $\text U+0063$ to 'c' w unikodzie.

Pierwszy sposób zapisu zmiennych typu char jest zdecydowanie prostszy i dużo częściej stosowany przez programistów.

Do zmiennych typu prymitywnego zaliczamy także wartości logiczne (boolowskie) boolean, które mogą przyjmować tylko true i false. Możemy zarówno zapisać w nich wartość logiczną (prawda lub fałsz), jak również z ich pomocą sprawdzać, czy dane wyrażenie jest prawdziwe. Do tego celu używamy operatora porównania.

Kolejnym typem danych jest ciąg znaków, czyli String.

W odróżnieniu od wszystkich poprzednich String nie jest typem prymitywnym, a obiektowym – język Java jest obiektowy i to właśnie takie dane są jego główną składową.

String łatwo odróżnić od innych typów danych choćby dlatego, że jak wszystkie typy klasowe (obiektowe) jest zapisywany wielką literą. Przechowuje on ciągi dowolnych znaków, a jego wartość musi być umieszczona w cudzysłowie.

Jak tworzymy zmienne?

Zmienne w języku Java, niezależnie od typu, tworzymy według schematu:

typDanych nazwaZmiennej = wartość;

W przykładowej linii kodu utworzyliśmy zmienną w jednym kroku, dokonując jednoczesnej deklaracji i inicjalizacji.

int x = 10;

Natomiast faktycznie najpierw następuje deklaracja zmiennej:

int x;

kiedy zostaje zarezerwowane miejsce w pamięci komputera dla zmiennej x, a następnie następuje inicjalizacja zmiennej:

x = 10;

kiedy zostaje jej przypisana podana wartość.

Najczęściej deklaracja i inicjalizacja zmiennej następują w jednym kroku. Czasem przydaje się możliwość wcześniejszej deklaracji zmiennej i użycie jej w dalszej części programu.

Dla zmiennej typu float będzie to wyglądało w następujący sposób:

float z = 4.5f;
// lub 
float z = 4.5F; // pamiętamy o przyrostku, inaczej program nie skompiluje się

Analogicznie dla zmiennej przechowującej wartość logiczną:

boolean jestPelnoletni = true;

W celu sprawdzenia wartości logicznej przy pomocy zmiennej boolean, możemy napisać:

int x = 4;
int y = 6;
boolean czyJestWieksze = x > y;

Jeśli wypiszemy wynik do konsoli:

System.out.println(czyJestWieksze);

otrzymamy oczywiście false.

Java jest językiem o ścisłej kontroli typów, dlatego tworzenie w niej zmiennych jest bardziej skomplikowane pod względem zapisu niż np. w języku Python. Podajemy zawsze typ deklarowanej zmiennej, a w niektórych typach danych dodajemy przyrostki. W ten sposób kompilator dowiaduje się, że typ zmiennej jest zgodny z przypisaną wartością. Jeśli nie podamy typu lub przypiszemy wartość innego typu, program wyrzuci błąd type mismatch, czyli niezgodność typów.

RayoD5QMKY2tR

Obraz zrzutu ekranu przedstawia błąd wyjątku w wątku głównym. Tekst błędu to niedopasowanie typów, nie można przekonwertować zmiennej typu dabyl na int w linii dwunastej.

double wiek, wzrost, pensja;

// zamiast
double wiek;
double wzrost;
double pensja;

long duzaLiczba = 2_344_334_789L

Zmienne „niezmienne”

W języku Java zmienne domyślnie są modyfikowalne, np. gdy stworzymy zmienną:

int wiek = 56;

następnie zmienimy ją na:

wiek = 57;

i wydrukujemy metodą println();

System.out.println(x);

to w konsoli zobaczymy $57$, a nie $56$. Do zmiennej możemy przypisywać wartości dowolną liczbę razy. Oczywiście typ wartości musi odpowiadać typowi zmiennej. Natomiast nie możemy napisać:

int wiek = 56;
int wiek = 57;

ponieważ w ten sposób dwa razy deklarujemy zmienną o takiej samej nazwie, a tego – jak już wiadomo – robić nam nie wolno. W takim wypadku pojawi się komunikat  Duplicate local variable wiek:

RPagVN0aOQI57

Grafika przedstawia zrzut ekranu z błędem o treści: Duplikat lokalnej zmiennej o nazwie wiek. Błąd w linii dwudziestej piątej.

czyli wyjątek (błąd) mówiący o powtórnym zadeklarowaniu zmiennej wiek.

Istnieje natomiast mechanizm, który pozwala tworzyć zmienne niemodyfikowalne (niezmienne), czyli tzw. stałe. Należy użyć słowa kluczowego final:

final typDanych nazwaZmiennej = wartość;

Dla przykładu:

final double PI = 3.14159;

Zmienne finalne, czy też stałe, możemy zainicjować w programie tylko raz. Za każdym razem, kiedy będziemy próbowali zmienić wartość takiej zmiennej, otrzymamy błąd.

R1WsZPpjJd3lF

Grafika przedstawia zrzut ekranu z błędem o treści: ostateczna lokalna zmienna pi nie może być przypisana. To musi być puste, a nie złożone przypisanie. Błąd w linii dwunastej.

Zmienne finalne mogą być przydatne w sytuacjach, w których chcemy mieć pewność, że określona wartość nie została i nie zostanie zmieniona. Zmienne finalne wykorzystuje się przy pisaniu programu, który korzysta z pewnych stałych wartości w obliczeniach. Przykładem może być program, który wykorzysta liczbę $\pi$ i pobrane od użytkownika dane, by obliczyć pole koła.

Działania na zmiennych

Jak wspomnieliśmy, na zmiennych, oprócz przypisywania im wartości, wykonujemy różne operacje. Możemy je dodawać, odejmować, mnożyć, dzielić. Możemy też zapisywać w nich wyniki działań arytmetycznych. Oczywiście wszystko to z zachowaniem odpowiednich typów zmiennych i ich wartości.

double x = 6;
double y = 8;
double z = x + y;

System.out.println(z); 
// wydrukuje się 14.0

Co prawda mamy możliwość wykonania działań na różnych typach liczbowych, jednak trzeba przy tym przestrzegać pewnych zasad. Należy teraz wspomnieć o dwóch ważnych pojęciach: konwersji rozszerzającej i zawężającej.

Konwersja rozszerzająca i zawężająca

Konwersję typów w języku Java nazywa się także rzutowaniem (używa się także spolszczonego sformułowania kastowanie, od ang. cast)

Co się stanie, gdy spróbujemy wykonać takie działanie?

int liczba1 = 45;
double liczba2 = 6.67;
int wynik = liczba1 / liczba2; // / - operator dzielenia

Otrzymamy błąd. Aby móc zapisać wynik takiego działania w zmiennej  wynik, musi być ona zadeklarowana jako zmienna typu bardziej ogólnego dla działania; takiego, który „pomieści” obie strony działania, w tym wynik. W tym przypadku jest to double, a nie int. Jeśli chcemy, aby program zadziałał, musimy napisać:

int liczba1 = 5;
double liczba2 = 6.67;
double wynik = liczba1 / liczba2;
// wynik to: 0.7496251874062969

Nastąpi wtedy niejawna konwersja rozszerzająca zmiennej int liczba1 do typu double. Mówimy o konwersji niejawnej, ponieważ nie napisaliśmy jej sami w kodzie programu, tylko język Java wykonał ją automatycznie.

Typy zmiennoprzecinkowe są bardziej ogólne niż całkowite i konwersja niejawna (automatyczna) następuje tylko z typów całkowitoliczbowych do zmiennoprzecinkowych.

Jeśli chcemy, aby wynikiem działania na liczbach typu int oraz double był typ int (czyli aby wynikiem działania liczby o szerszym typie i zakresie oraz liczby o węższym typie była liczba o węższym typie), to wtedy musimy samodzielnie jawnie wykonać konwersję zawężającą, o ile oczywiście wynik będzie w zakresie typu węższego. Czyli:

int liczba1 = 5;
double liczba2 = 6.67;
int wynik = liczba1 / (int)liczba2; // tu następuje jawna konwersja zmiennej liczba2 z double do int;
                                    
System.out.println("Wynik to " + wynik);

W konsoli ukaże się napis „Wynik to 0”.

int liczba1 = 5;
double liczba2 = 6.67;

System.out.println("Wynik to " + liczba1 / liczba2);

Ciekawostka

Zmiennym można również przypisywać wartości innych zmiennych:

Linia 1. int x znak równości 67 średnik. Linia 2. int y znak równości 89 średnik. Linia 3. y znak równości x średnik. Linia 5. System kropka out kropka println otwórz nawias okrągły y zamknij nawias okrągły średnik.

int x = 67;
int y = 89;
y = x;

System.out.println(y);

jest jak najbardziej poprawny, a w konsoli wydrukuje się wartość $67$, nie $89$. Musimy jednak pamiętać, że typy zmiennych muszą się zgadzać. Zatem kod skomplikuje się:

Linia 1. int x znak równości 67 średnik. Linia 2. double y znak równości 56 kropka 7 średnik. Linia 3. y znak równości x średnik.

int x = 67;
double y = 56.7;
y = x;

Java wykona rzutowanie rozszerzające (z int na double) na wartość x. Natomiast ten kod:

Linia 1. int x znak równości 67 średnik. Linia 2. double y znak równości 56 kropka 7 średnik. Linia 3. x znak równości y średnik.

int x = 67;
double y = 56.7;
x = y;

nie skompiluje się, ponieważ Java nie wykona samodzielnie rzutowania zawężającego z wartości double do int i wyrzuci błąd z rodzaju type mismatch.

R72WY0DNMdjsV

Grafika przedstawia zrzut ekranu z błędem o treści: Błąd typu, nie można przekonwertować z dabyl do int. Błąd w linii dwudziestej piątej.

Aby program zadziałał, musielibyśmy wykonać jawną konwersję, czyli napisać w ostatniej linijce:

Linia 1. x znak równości otwórz nawias okrągły int zamknij nawias okrągły y średnik.

x = (int)y;

Język Java posiada kilka podstawowych typów danych i odpowiadających im typów zmiennych. Typy te określają, jaki rodzaj operacji może być wykonywany na zmiennych. Typy muszą być ze sobą zgodne, a Java może wykonać jedynie konwersję rozszerzającą (czyli z typu „węższego” do bardziej ogólnego).

Oczywiście ta ścisła kontrola typów ma swoje niewątpliwe zalety, dlatego język Java jest od lat tak popularny.

Słownik