Java (3) - Proměnné

Tato kapitola bude věnována proměnným a primitivním datovým typům. Bohužel se jedná o látku, která sice není příliš náročná, ale je objemná, z tohoto důvodu se operacemi nad těmito typy budeme zabývat až v další kapitole.

Co je to proměnná?

Proměnná je pojmenovaná část paměti, kterou používáme k uložení informace. Vezmeme-li si jako příklad zaměstnance nějaké firmy, tak proměnná popisující jeho plat může mít hodnotu 25000, heslo k jeho uživatelskému účtu bude nenavidimPraci a příznak jeho pohlaví jeMuz bude nastaven na hodnotu PRAVDA.

Typ proměnné

V Javě vždy při deklaraci proměnné určíme její typ. Tento typ později již nemůžeme nijak změnit (v rámci bloku, kde je proměnná platná). Pokud například prohlásíme o proměnné x, že je typu celé číslo, tak se do ní nesmíme později snažit umístit řetězec. Toto není nijak překvapivé pro začátečníka, případně pro člověka se zkušenostmi s jiným silně typovaným jazykem. Ale pro uživatele například PHP to může být šok (PHP je dynamicky typované – typ proměnných se mění automaticky v závislosti na datech).

Silná typovost se proto může zdát být slabinou a zbytečným šikanováním programátora, ale ve skutečnosti velmi usnadňuje práci (vývojové prostředí může lépe radit a pomáhat) a zabraňuje značnému množství chyb z nepozornosti.

Jména proměnných

Jména proměnných v Javě mohou být libovolně dlouhá, ale musí začínat písmenem, symbolem podtržítka (_) nebo dolaru ($) a nesmí být klíčovým slovem jazyka (např. název datového typu). V názvu smíme používat libovolné znaky, protože Java pro zdrojové kódy používá Unicode, ale mějme na paměti, že kód mohou číst i jiní lidé jiných národů. Jak by nám asi bylo příjemné, kdybychom měli půlku kódu v japonských znacích (které ani nemáme na klávesnici).

Konvence pro názvy proměnných říká, že pokud se nejedná o konstanty, tak by měly by být psány camelCasem – první písmeno názvu vždy malým písmenem, pokud název obsahuje více slov, tak první písmeno každého nového slova vždy velké (cisarovyNoveSaty).

Upozornění na závěr: Java je case-sensitive. Proměnné pes a Pes jsou různé.

Primitivní datové typy

Celočíselné datové typy

Pro ukládání celých čísel Java obsahuje čtyři datové typy byte, short, int, long. Tyto typy se liší pouze v rozsahu hodnot, které mohou používat. Všechny obsahují jak kladná, tak záporná čísla (a nelze to ovlivnit).

Důležitou poznámkou je, že všechny celočíselné literály (tj. hodnoty přímo vepsané ve zdrojovém kódu) jsou implicitně typu int. Pokud proto chteme vložit do proměnné typu long hodnotu, která je vyšší než maximální rozsah typu int, tak musíme na konec literálu přidt znak l nebo L.

Typ	Rozsah	Paměť
byte	-128 až 127	1 bajt (8 bitů)
short	-32768 až 32767	2 bajty (16 bitů)
int	-2147483648 až 2147483647	4 bajty (32 bitů)
long	-9223372036854775808 až 9223372036854775807	8 bajtů (64 bitů)

Datové typy reálných čísel

Pro reálná čísla existují typy float a double (viz tabulka). Protože tyto typy musí mít velký rozsah (od obrovských čísel po velmi malé zlomky), používá se pro jejich reprezentaci plovoucí desetinné čárky. To znamená, že jsou čísla zapsána tak, aby jejich první platná číslice byla přímo za desetinnou čárkou (tzv. mantisa) a za tímto zápisem následuje číslo reprezentující exponent základu soustavy, kterým když přenásobíme mantisu, tak dostaneme uložené číslo. Takto to vypadá velmi složitě, ale z příkladů (v desítkové soustavě) je jasně patrné, jak to funguje.

$0.165e3 = 0.165 \\cdot 10^{3} = 165$
$0.1e0 = 0.1 \\cdot 10^{0} = 0.1$
$0.1e3 = 0.1 \\cdot 10^{3} = 100$

Na tomto matematickém cvičení je důležité jedno poselství – typy float a double nejsou přesné, protože obsahují určitý fixní počet míst pro zápis mantisy a exponentu.

Typ	Rozsah	Přesnost	Paměť
float	-3.4e38 až 3.4e38	cca. 7 míst	4 bajty (32 bitů)
double	-1.7e308 až 1.7e308	cca. 17 míst	8 bajtů (64 bitů)

Poslední poznámkou pro reálná čísla je, že pro literály je implicitním typem double, proto pokud chceme říci kompilátoru, že je daný literál typu float, tak na konec literálu připojíme znak f nebo F.

Datový typ znak

Pro ukládání jednotlivých znaků v Javě slouží typ char, který zabírá v paměti 2 bajty místa. Pro vložení hodnoty znaku do proměnné lze použít buď celočíselného literálu, apostrofů ('A') nebo Unicode sekvence ('\\u0041').

Poznámka: Mezi použitím apostrofů a uvozovek je v Javě rozdíl. Zatímco 'A' znamená znak A, "A" znamená řetězec, který obsahuje jeden znak A.

Logické hodnoty

Pro reprezentaci logických hodnot (pravda/nepravda) slouží typ boolean. Boolean může obsahovat buď hodnotu true – pravda nebo false – nepravda.

Deklarace a inicializace proměnných

Pro vytvoření proměnné (deklaraci) a dosazení hodnoty do proměnné (inicializaci) se dá použít několik různých zápisů. Všechny zápisy jsou správné, některé jsou však správnější (viz komentáře). Následující kód obsahuje deklarace a inicializace všech datových typů, které jsme si dnes ukázali.

Jak si asi všimnete, tak je za každým příkazem středník, to je v Javě povinnost. Povinností ovšem není mít na řádce pouze jeden příkaz, to je obecná kultura.

Java

        /*****************************
         *  Deklarace a inicializace *
         *****************************/
        int i1; //pouze deklarace
        i1 = 1500; //inicializace

        int i2 = 1500; //deklarace s inicializaci - doporuceny postup
        int i3, i4, i5; //deklarace vice promennych - neni doporuceno
        int i6 = 7, i7 = 15, i8 = 17; //toto take neni doporuceno

        /*****************************
         *         Cela cisla        *
         *****************************/
        byte b = 100; //byte

        short s = -30000; //short - zaporne cislo
        short s2 = 30000; //short - kladne cislo

        int i = 10000;

        long l = 100;
        long l2 = 150000000000l; //long - prilis velke cislo
        long l3 = 150000000000L; //long - varianta L

        /*****************************
         *        Realna cisla       *
         *****************************/
        double d = 100.5;
        double d2 = 0.5;
        double d3 = .5; //0.5
        double d4 = 5E-1; //0.5
        double d5 = 0.5e0; //0.5

        float f = 100.5f;
        float f2 = 100.5F;

        /*****************************
         *           Znaky           *
         *****************************/
        char ch = 'A';
        char ch2 = 65; // A (ASCII hodnota)
        char ch3 = '\\u0041';

        /*****************************
         *       Logicke hodnoty     *
         *****************************/
        boolean bool = true;
        boolean bool2 = false;

        /*****************************
         *       Priklad vypisu      *
         *****************************/
        System.out.println(b);
        System.out.println(i);
        System.out.println(l);
        System.out.println(d5);
        System.out.println(f2);
        System.out.println(ch3);
        System.out.println(bool);

Pokud si chcete tento kód vyzkoušet, tak jej umístěte na stejné místo, na které jsme v minulém díle umístili výpis řetězce Hello world. Zároveň si vyzkoušejte, že lze vypsat proměnné všech datových typů stejným způsobem, jako jsme to minule udělali s oním nápisem. Celý projekt si také můžete stáhnout zde.

Literatura

HORTON, Ivor. Java 5. Praha : Neocortex spol s.r.o., 2005. 1443 s. ISBN 80-86330-12-5.