Může proměnná java začínat číslem. Proměnné v Javě. jazyk Java. Datové typy: Řetězec

Po příkazu deklarace primitivní proměnné může následovat inicializační příkaz "=", který přiřazuje počáteční hodnotu vytvořené proměnné.

1. Typy celočíselných proměnných

Celý typy se liší v množství paměti, která je jim přidělena. Charakteristiky celočíselných typů jsou uvedeny v tabulce. 1.1. Tabulka 1.1. Charakteristika celočíselných typů Java
Jak můžete vidět z tabulky níže, celočíselné proměnné, s výjimkou typu char , jsou v Javě považovány za proměnné se znaménkem. Celočíselné konstanty lze v programu zadat jedním ze tří způsobů: jako desítkové, šestnáctkové nebo osmičkové hodnoty. Ve výchozím nastavení jsou všechna čísla interpretována jako desetinný a jsou typu int . To, že jste dlouhý typ, můžete výslovně označit přidáním písmene „l“ nebo písmene „L“ na konec čísla. Hexadecimální hodnota je specifikována pomocí znaků "0x" nebo "0X" následovaných hodnotou čísla (číslice 0-9 a písmena A-F nebo a-f), například: 0x7FFF . Číslo v osmičkovém zápisu musí začínat nulou, za kterou následuje jedna nebo více osmičkových číslic, například 077777. Osmičková a šestnáctková čísla mohou být kladná nebo záporná a mohou se pohybovat ve stejných rozsazích jako desetinná čísla (například bajtová hexadecimální čísla mají maximální hodnota 0x7F a minimální hodnota– 0x80 a osmičkové – 177 a – 200, v tomto pořadí) Příklady deklarování celočíselných proměnných: int x = 0; dlouhé i, j, k; byte a1 = 0xF1, a2 = 0x07; krátké r1 = 017; Symboly v Javě jsou definovány pomocí. Symbolovou konstantu můžete zadat v programu nebo jako běžný symbol. Symbolická hodnota musí být uzavřena ve dvojici jednotlivých apostrofů, například: char symbol= "f" ; Dalším způsobem zápisu znaků je dvojice znaků "\u" následovaná čtyřmístným hexadecimálním číslem (v rozsahu od 0000 do FFFF), které představuje kód Unicode znaku, například: char symbol = "\u0042" ;

Některé znaky, které se nenacházejí na klávesnici, lze specifikovat pomocí takzvaných escape sekvencí, které obsahují znak "\" následovaný abecedním znakem identifikujícím escape sekvenci, jak je uvedeno v tabulce 1. 1.2.

Tabulka 1.2. Únikové sekvence používané v jazyce Java

Co ještě číst: 2. Reálné typy proměnných jazyk Java podporuje čísla a proměnné s s plovoucí desetinnou čárkou pravidelné a dvoumístné – plovoucí a dvojité typy. Pro čísla s plovoucí desetinnou čárkou musíte zadat celé číslo a zlomková část, oddělené tečkou, například 4,6 nebo 7,0 . Pro velká čísla můžete použít exponenciální zápis (pro oddělení mantisy od exponentu použijte symbol „e“ nebo symbol „E“), například číslo -3,58×107 se zapíše jako –3,58E7 a číslo 73,675×10 -15 se zapisuje jako 73,675e- 15. Charakteristika skutečné typy
Java jsou uvedeny v tabulce. 2.1. Tabulka 2.1. Charakteristika Java Real typů Proměnné s plovoucí desetinnou čárkou mohou ukládat nejen číselné hodnoty, ale také jakýkoli ze speciálně definovaných příznaků (stavů): záporné nekonečno, záporná nula, kladné nekonečno, kladná nula a nečíslo (NaN). Předpokládá se, že všechny konstanty s plovoucí desetinnou čárkou jsou typu double. Chcete-li zadat plovoucí číslo, musíte na konec čísla připojit znak "f" nebo symbol "F".

Příklady deklarací proměnných s plovoucí desetinnou čárkou:

float x1 = 3,5f, x2 = 3,7E6f, x3 = -1,8E-7f; dvojité z = 1,0; 3. Booleovský typ proměnné< 1 будет «ложь». В отличие от C, где результату «ложь» сопоставлено целое значение типа int , равное 0, а результату «истина» – ненулевое значение типа int , и, соответственно, результатам сравнения присваивается целое значение (обычно 0 или 1), в Java для булевских переменных введен свой, Proměnné booleovský typ (Booleovské proměnné) mohou nabývat jedné ze dvou hodnot: „true“ nebo „false“ a používají se v programovacích jazycích v relačních (srovnávacích) a logických operacích. Výsledek srovnání 5 > 3 bude tedy „pravda“ a výsledek srovnání 8 samostatný typ data. Proměnné booleovský typ v Javě jsou specifikovány pomocí klíčového slova boolean a mohou mít pouze jednu ze dvou hodnot: věrný

nebo

• soubor hodnot nebo objektů;
• sada operací, které lze použít na všechny hodnoty v sadě;
• reprezentace dat, která určují jejich uložení.

Jaké jsou datové typy v Javě?

Programovací jazyk obsahuje některé předdefinované vestavěné typy a umožňuje programátorům definovat své vlastní.

V Javě se datové typy dělí na primitivní a referenční.

„Primitivní“ znamená, že další dělení není možné. Programovací jazyk neumožňuje jeho rozšíření nebo změnu. Tento datový typ je popsán primitivními a jinými uživatelem definovanými typy.

Proměnná primitivního typu obsahuje hodnotu a referenční proměnná obsahuje adresu objektu v paměti.

jazyk Java. čas a datum

Složená data jsou rozdělena do tříd, rozhraní a polí. Členy typu rozhraní jsou abstraktní metody a konstanty. V Javě jsou datové typy data a času určeny konstruktorem Date():

• d = nové datum().

jazyk Java. Datové typy: Řetězec

String je třída definovaná v a lze ji použít pro práci s textem (sekvencí znaků).

Deklarace referenční řetězcové proměnné je následující: String str.

• str = nový řetězec("Ahoj").

Co se stane, když je tento kód spuštěn? Nejprve je alokována paměť a jméno str je spojeno s tímto paměťovým místem. To se neliší od deklarace primitivní proměnné. Druhá část kódu vytvoří v paměti objekt String s textem "Ahoj" a uloží odkaz na něj (nebo adresu paměti) do str.

Referenční datové typy Java vám také umožňují přiřadit odkaz na objekt uložený v jedné proměnné k jinému. Oba odkazují na stejný objekt v paměti. Toho lze dosáhnout následovně:

• Řetězec str1;
• řetězec str2;
• str1 = nový řetězec("Ahoj");
• str2 = str1;

Objekt String je vytvořen pomocí operátor nový. Ale protože se řetězce používají často, existuje jednodušší způsob, jak je vytvořit. Všechny řetězcové literály, tedy posloupnost znaků uzavřená v dvojité uvozovky, jsou považovány za Řetězcové předměty. Místo operátoru new tedy můžete použít řetězcové literály:

• Řetězec str1 = "Dobrý den".

Primitivní datové typy Java jsou byte, short, int, long, char, float, double a boolean. Jsou rozděleny do dvou kategorií: logické a numerické. Ty lze rozdělit na celá čísla a čísla s pohyblivou řádovou čárkou.

Java celočíselné datové typy jsou číselné typy, jehož hodnoty jsou celá čísla. Je jich pět: byte, short, int, long a char.

Int

Int je 32bitový primitivní datový typ se znaménkem. Proměnná zabírá 32 bitů paměti. Platný rozsah je -2147483648 až 2147483647 (-2 31 až 2 31 - 1). Všechna celá čísla v tomto rozsahu jsou celočíselné literály nebo konstanty. Například 10, -200, 0, 30, 19 jsou int literály. Mohou být přiřazeny k proměnné int:

• int num1 = 21;

Celočíselné literály mohou být vyjádřeny v binární, osmičkové, desítkové a hexadecimální číslo.

Když literál začíná nulou a má alespoň dvě číslice, považuje se za psaný v osmičkovém formátu. 0 a 00 představují stejnou hodnotu- nula.

Všechny hexadecimální literály int začínají 0x nebo 0x a musí obsahovat alespoň jednu hexadecimální číslici:

• int číslo1 = 0x123.

Int literály ve formátu začínají 0b nebo 0B:

• int num1 = 0b10101.

Dlouho

Toto je 64bitový primitivní typ. Používá se, když výsledek výpočtu může překročit rozsah int. Rozsah long je -2 63 až 2 63 - 1. Všechna celá čísla v tomto rozsahu jsou literály typu long.

K rozlišení mezi typy v Javě data int a dlouhý, literál druhého typu vždy končí na L nebo l.

Celočíselné literály dlouhého typu lze také vyjádřit v osmičkovém, šestnáctkovém a binárním formátu.

Když je dlouhý literál přiřazen dlouhé proměnné, kompilátor Java zkontroluje přiřazenou hodnotu, aby se ujistil, že je v přijatelném rozsahu; jinak dojde k chybě kompilace.

Protože rozsah int je menší než rozsah long, hodnotu proměnné int lze vždy přiřadit proměnné typ dlouhý. Ale zpětné přiřazení není možné ani v rozsahu int. Chcete-li to provést, použijte výslovný pokyn:

• num1 = (int) num2;

Byte

Byte je 8bitový celočíselný primitivní typ. Jeho rozsah je -128 až 127 (-2 7 až 2 7 - 1). Je to nejmenší celočíselný typ dostupný v Javě. Typicky se bajtové proměnné používají, když program obsahuje mnoho hodnot v rozsahu od -128 do 127, nebo když pracujete s binárními daty. Na rozdíl od int a long literálů zde nejsou žádné byte literály. Bytové proměnné však můžete přiřadit libovolný int literál, protože zahrnuje rozsah bajtů.

Pokud je hodnota proměnné mimo rozsah, Java vyvolá chybu kompilátoru.

Kromě toho můžete přiřadit pouze literál int, ale ne hodnotu uloženou v proměnné int, protože to může vést ke ztrátě přesnosti. To vyžaduje explicitní typ přetypování.

• b1 = (byte)číslo1.

Krátký

Představuje primitivní datový typ 16bitového celého čísla se znaménkem. Jeho rozsah je -32768 až 32767 (nebo -2 15 až 2 15 - 1).

Potřeba krátkých proměnných obvykle vzniká, když program používá velký počet hodnoty, které nepřekračují stanovený rozsah. Neexistuje žádný krátký literál, ale lze přiřadit jakýkoli int literál v rozsahu krátkých. Hodnotu bajtové proměnné lze vždy přiřadit. Zbývající pravidla pro přiřazení proměnné int nebo long short jsou stejná jako pro byte.

Char

Char je 16bitový primitivní datový typ bez znaménka, který představuje znak Unicode. Absence znaménka znamená, že proměnná nemůže mít zápornou hodnotu. Rozsah je od 0 do 65535, což je stejné kódování jako znaková sada Unicode. Literál představuje hodnotu znaku a může být vyjádřen v následujících formách:

• symbol uzavřený v jednoduché uvozovky;
• sled řídicích znaků;
• sekvence řídicích znaků Unicode;
• sekvence osmičkových řídicích znaků.

Znak lze vyjádřit tak, že jej uzavřete do jednoduchých uvozovek: char C1 = "A". označují řetězcový literál, který nelze přiřadit proměnné char, i když se řetězec skládá pouze z jednoho znaku. To je nezákonné, protože není přiřazen odkaz na primitivní proměnnou. Všechny řetězcové literály jsou objekty třída String a tedy odkazy, zatímco symbolický odkazuje na primitivní typ.

Literál vyjádřený escape sekvencí se zapisuje jako zpětné lomítko se znakem v jednoduchých uvozovkách. Je jich celkem 8: ‚\n‘, ‚\r‘, ‚\f‘, ‚\b‘, ‚\t‘, ‚\\‘, ‚\‘‘, ‚\‘‘.

Escape sekvence Unicode je "\uxxxx", kde \u ( obrácené lomítko, následované malým písmenem u) označuje jeho začátek a xxxx představuje přesně čtyři hexadecimální číslice kódu Unicode znaku. Například „A“ má hodnotu 65 palců desítková soustava a 41 v šestnáctkové soustavě. Takže tento znak může být reprezentován jako "\u0041".

Osmičková sekvence escape je zapsána jako "\nnn", kde n je osmičková číslice (0-7). Rozsah hodnot je od "\000" do "\377", kde 377 8 odpovídá 255 10. Proto se používá k reprezentaci znaků s kódem od 0 do 255, nezbytným pro kompatibilitu s jinými programovacími jazyky. Na rozdíl od sekvence Unicode, kde jsou vyžadovány všechny čtyři hexadecimální číslice, zde můžete použít 1, 2 nebo 3 osmičkové číslice: "\n", "\nn" nebo "\nnn".

Booleovský typ

Boolean má pouze dvě platné hodnoty: true a false. Říká se jim booleovské literály. Booleovskou proměnnou nelze přetypovat na jiný typ a naopak. Java nedefinuje velikost booleanu - záleží na konkrétní implementaci Java Virtual Machine.

Java datové typy s plovoucí desetinnou čárkou

Číslo, které obsahuje zlomkovou část, lze uložit do paměti počítače v reprezentaci s pevným počtem číslic před a za bodem nebo označujícím jeho polohu. Protože se počet číslic může měnit, říkají, že bod „pluje“.

V Javě používají datové typy s pohyblivou řádovou čárkou 32 bitů. Podle standard IEEE 754, to odpovídá jednoduché přesnosti, která umožňuje reprezentovat například čísla 1,4 x 10 -45 a 3,4 x 10 38, a to jak kladná, tak záporná.

Vše, co končí na f nebo F, se nazývá plovoucí literál. Mohou být prezentovány ve formátu desetinné číslo a ve formě vědeckého zápisu. Například:

• plovák f1 = 3,25F;
• plovák f2 = 32,5E-1F;
• plovák f3= 0,325E + 1F.

Typ definuje dvě nuly: +0,0F (nebo 0,0F) a -0,0F. Pro účely srovnání jsou však obě nuly považovány za stejné. Kromě toho definoval dva typy nekonečna: pozitivní a negativní. Výsledky některých operací (například nejsou definovány a jsou reprezentovány speciální hodnotou NaN.

Dvojitá přesnost

Double používá 64 bitů k uložení čísel s plovoucí desetinnou čárkou. Číslo s dvojnásobnou přesností může představovat kladné a záporné hodnoty magnituda 4,9 x 10-324 a 1,7 x 10 308.

Vše reálná čísla standardně jsou to dvojité literály. Na přání může být výslovně označeno příponou d nebo D, např. 19.27d. Dvojitý literál lze vyjádřit v desítkové a vědecké notaci.

Java je silně typovaný jazyk. To znamená, že každá proměnná a každý Java výraz musí mít typ, definovaný již ve fázi kompilace. Každý typ má specifický rozsah hodnot a definuje sadu operací, které se na něj vztahují, a jejich význam. Silné psaní pomáhá odhalit chyby v programu v době kompilace.

Všechny typy v Javě jsou rozděleny na primitivní A odkaz. Primitivní jsou booleovský typ booleovský, celočíselné číselné typy byte, krátký, int, dlouho, char a plovoucí číselné typy plovák A dvojnásobek. Mezi referenční typy patří třídy, rozhraní A pole. K dispozici je také speciální nulový typ.

Objekt v Javě je to buď dynamicky vytvořená instance třídy nebo dynamicky vytvořené pole. Hodnoty typu reference jsou odkazy na objekty. Všechny objekty, včetně polí, dědí metody ze třídy Object. Řetězce jsou reprezentovány objekty třídy String.

Variabilní toto je pojmenované úložiště dat určitý typ. Přesněji:

• Proměnná primitivního typu vždy obsahuje hodnotu daného typu.
• Proměnná třídy může obsahovat buď hodnotu null(nulový odkaz), nebo odkaz na objekt této třídy nebo jeho potomka.
• Proměnná typu interface může obsahovat buď odkaz null, nebo odkaz na objekt libovolné třídy, která implementuje toto rozhraní.
• Proměnná typu "pole T", kde T je primitivní typ, může obsahovat buď nulový odkaz, nebo odkaz na objekt typu "pole T".
• Proměnná typu "array of T", kde T je referenční typ, může obsahovat buď nulový odkaz, nebo odkaz na pole sestávající z dat, která jsou přiřazena kompatibilní s T.
• Proměnná typu Object může obsahovat buď nulový odkaz, nebo odkaz na libovolný objekt.

5.3.2. Primitivní typy

5.3.2.1. Zadejte boolean

Typ booleovský se skládá ze dvou logických konstant: data. Proměnné(pravda) a v Javě jsou specifikovány pomocí klíčového slova boolean a mohou mít pouze jednu ze dvou hodnot:(lež). Booleovskou hodnotu lze přetypovat na typ booleovský, v Javě neexistují žádné další implicitní přetypování na tento typ. Booleovskou hodnotu lze podle pravidla převést na řetězec implicitní konverze linky.

Příklad deklarace booleovské proměnné:

Pamatujte, že libovolný počet odkazů může ukazovat na jeden objekt. Pokud dvě proměnné ukazují na stejný objekt, pak lze stav objektu změnit pomocí prvního odkazu a poté číst přes druhý.

5.3.3.2. Třída objektu

Standardní třída Object je předkem všech ostatních tříd Java, které dědí její metody. Tyto metody jsou podrobně popsány v kap. 5.14.

5.3.3.3. Řetězcová třída

Instance třídy String jsou textové řetězce, tedy řetězce znaků Unicode. Objekt třídy String má konstantní (neměnnou) hodnotu. Řetězcové konstanty jsou odkazy na instance třídy String.

Operátor zřetězení řetězců implicitně vytvoří nový objekt třídy String.

5.3.4. Proměnné

Proměnná je úložiště dat určitého typu, obvykle s jedinečným názvem.

Proměnná vždy obsahuje hodnotu, která je přiřazena kompatibilní s jejím typem. Hodnota proměnné se mění operací přiřazení nebo operacemi přírůstku/snižování předpony/přípony.

5.3.4.1. Typy proměnných

1. V Javě je sedm typů proměnných: Proměnná třídy
2. Je to statické datové pole v deklaraci třídy nebo jakékoli datové pole v deklaraci rozhraní. Proměnná třídy se vytvoří při načtení její třídy nebo rozhraní; ihned po vytvoření je mu přiřazena výchozí hodnota. Proměnná třídy je zničena, když je její třída nebo rozhraní uvolněno (po dokončení její finalizace). Implementační proměnná
3. Toto je datové pole v deklaraci třídy, které není statické. Taková proměnná je vytvořena a je jí přidělena výchozí hodnota, když je vytvořena instance dané třídy nebo třídy, která je jejím potomkem. Implementační proměnná je zničena, když je odpovídající instance třídy shromážděna (po dokončení její finalizace). Prvky pole
4. toto jsou nepojmenované proměnné, které jsou vytvořeny a je jim přidělena výchozí hodnota při vytvoření pole. Tyto proměnné jsou zničeny, když je pole odstraněno garbage collection. Parametry konstruktoru toto jsou názvy hodnot argumentů předávaných konstruktoru. Pro každý parametr v deklaraci konstruktoru se pokaždé vytvoří nová proměnná tento konstruktér
5. (explicitně nebo implicitně). Této proměnné je přiřazena skutečná hodnota argumentu předávaného konstruktoru při volání. Proměnná je zničena poté, co tělo konstruktoru dokončí provádění. Parametry metody
6. toto jsou názvy hodnot argumentů předávaných metodě. Pro každý parametr v deklaraci metody se při každém volání této metody vytvoří nová proměnná. Této proměnné je přiřazena skutečná hodnota argumentu předávaného metodě při volání. Proměnná je zničena poté, co tělo metody dokončí provádění. Parametr obsluhy výjimek se vytvoří vždy, když je díl spuštěn chytit. Jeho hodnota se stane objektem spojeným s výjimkou, ke které došlo. Proměnná je zničena, když blok dokončí provádění Parametr obsluhy výjimek.
7. Lokální proměnné. Pokaždé během provádění programu se řízení přenese do nového bloku nebo příkazu pro, pro každou deklaraci proměnné v tomto bloku nebo příkazu je vytvořena odpovídající lokální proměnná. Pokud deklarace obsahuje počáteční hodnotu proměnné, pak je jí přiřazena tato hodnota. Lokální proměnná je zničena, když blok nebo příkaz, ve kterém je deklarována, dokončí provádění.

Následující příklad obsahuje deklarace několika proměnných následujících odrůd:

Class Point ( static int numPoints; // numPoints - proměnná třídy int x, y; // x a y - implementační proměnné int w = new int; // w - pole celých čísel, w - prvek pole int setX(int x) ( // x - parametr metody int oldx = this.x; // oldx - lokální proměnná this.x = x; return oldx; ) )

5.3.4.2. Počáteční hodnoty proměnných

Než bude možné přistupovat k proměnné, musí jí být přiřazena hodnota. Ve stejnou dobu

• Každý třídní proměnná, implementační proměnné a každému prvku pole je při vytvoření přiřazena výchozí hodnota takto:
• typové proměnné byte, krátký, int, dlouho získat hodnotu 0 odpovídajícího typu;
• typové proměnné plovák A dvojnásobek získat hodnotu +0 odpovídajícího typu;
• typové proměnné char získat hodnotu "\u0000";
• typové proměnné booleovský získat hodnotu v Javě jsou specifikovány pomocí klíčového slova boolean a mohou mít pouze jednu ze dvou hodnot:;
• proměnné typu reference získají hodnotu null;
• Každé metodě a parametru konstruktoru je přiřazena aktuální hodnota odpovídajícího argumentu, určená v době volání tato metoda nebo designér.
• Parametr obsluhy výjimky je inicializován odpovídajícím objektem.
• Před použitím musí být lokální proměnné přiřazena hodnota, a to buď inicializací v deklaraci, nebo operátorem přiřazení.

Primitivní typy v Javě jsou důležitou, často používanou částí jazyka, který vyžaduje speciální zacházení. V této publikaci se pokusíme odpovědět na všechny otázky týkající se primitivních typů, mechanismu jejich fungování a zpracování. Článek je určen začátečníkům, kteří teprve začali trnitou cestu učení Java(jsem jedním z nich) a pro lidi, kteří se v jazyce docela vyznají, kteří si budou moci osvěžit své znalosti a doufám, že najdou něco zajímavého pro sebe.

Primitivní typy

Primitivní typy mírně porušují objektově orientovanou povahu jazyka Java, protože tímto způsobem představují jednotlivé (jednoduché) hodnoty. Tato funkce je vysvětlena přáním zajistit maximální účinnost. Vytvoření jednoduchého proměnného objektu pomocí new není dostatečně efektivní, protože new přesune objekt na haldu. Místo toho je vytvořena "automatická" proměnná, která není odkazem na objekt. Proměnná ukládá jednu hodnotu a je umístěna v zásobníku. Zásobník je oblast pro ukládání dat umístěná v paměti RAM. Procesor má do této oblasti přímý přístup přes ukazatel zásobníku, takže zásobník je velmi rychlý a efektivní způsobúložiště dat. Z hlediska rychlosti je zásobník na druhém místě za registry (logické, protože registry jsou umístěny uvnitř procesoru).
Všechny velikosti primitivní typy přísně fixní a nezávislé na architektuře stroje. To je jeden z důvodů lepší přenositelnosti programů Java.
Java definuje osm primitivních typů, které lze rozdělit do čtyř skupin:

Celá čísla

Pro celá čísla jsou definovány čtyři primitivní typy: byte, krátký, int, dlouho. Všechny tyto typy představují celočíselné hodnoty se znaménkem: kladné nebo záporné. V Javě nejsou žádné kladné celočíselné hodnoty bez znaménka ( nepodepsaný). Jak již bylo řečeno, všechny velikosti primitivních typů jsou pevné:
Nejmenší celočíselný typ je byte. Proměnné tohoto typu jsou velmi vhodné pro práci s I/O toky a pro manipulaci s binárními daty. Následuje typ krátký, který se používá méně často než všechny ostatní typy. Nejčastěji používaným typem je int. Neustále se používá v cyklech k indexování polí. Může se zdát, že pomocí typů byte A krátký v místech, kde to není potřeba široký rozsah hodnoty budou efektivnější než použití int. To však není pravda, protože při vyhodnocování výrazů se hodnoty typu byte nebo short převedou na int(k tomuto problému se vrátíme později). Při délce typ int nestačí k uložení hodnoty, musíte použít dlouho. Jeho rozsah hodnot je poměrně velký, což činí dlouho vhodné při práci s velkými celými čísly.

Čísla s pohyblivou řádovou čárkou

Čísla s pohyblivou řádovou čárkou (nebo reálná čísla) jsou reprezentována typy plovák A dvojnásobek. Slouží k uložení hodnot s přesností na určité místo za desetinnou čárkou.
Typ plovák definuje číselnou hodnotu s plovoucí desetinnou čárkou s jednoduchou přesností. Tento typ se používá, když potřebujete číselnou hodnotu se zlomkovou částí, ale bez větší přesnosti. Typ dvojnásobek slouží k ukládání hodnot s plovoucí desetinnou čárkou s dvojitou přesností. Zpracování hodnot s dvojitou přesností je rychlejší než zpracování hodnot s jednoduchou přesností. Proto většina matematické funkce třída java.lang.Math návratové hodnoty typu dvojnásobek. Nejúčinnější použití dvojnásobek když potřebujete zachovat přesnost opakovaných výpočtů nebo manipulovat s velkými čísly.

Symboly

Specifikace je primitivní typ char patří k celočíselným typům (příp integrální typy), ale protože hraje trochu jinou roli, může mít svou vlastní kategorii. Jeho úlohou je reprezentovat symboly Unicode. K uložení znaků je potřeba 16 bitů. Je to zvláštní, protože 8 bitů stačí k reprezentaci znaků v hlavních jazycích (například angličtina, francouzština, španělština). Ale taková je cena internacionalizace. Unicode používá kompletní sada mezinárodní symboly na všech známé jazyky mír.

Logické hodnoty

Primitivní typ boolean je navržen pro ukládání logických hodnot. Tento typ může vzít jeden ze dvou možné hodnoty: pravda (pravda) nebo nepravda (nepravda). Booleovské hodnoty jsou vráceny ze všech logické operace(například srovnávací operace). Je povinný při konstrukci cyklů a operátorů (například pro, pokud).

Doslovy

Hodnoty primitivních datových typů jsou ve většině případů inicializovány pomocí literálů. Pojďme se na ně podívat.

Celočíselné literály

Nejčastěji používané literály. Jakákoli celočíselná hodnota je číselný literál (např. -10 , 10 - desetinné hodnoty). Můžete použít osmičkové, hexadecimální a binární literály:

// desetinný literál, čísla, nezačíná 0 int decimal = 10; // 10 // osmičkový literál začíná 0, pak čísla int osmičkové = 010; // 8 // hexadecimální literál začíná 0x nebo 0Х, pak čísla a symboly int hexadecimální = 0x10; // 16 // binární literál začíná Ob nebo 0B, pak čísla int binární = 0b10; // 2
Všechny celočíselné literály představují hodnoty int. Pokud je doslovná hodnota v rozsahu byte, krátký booleovský typ char, pak ji lze přiřadit proměnné tohoto typu bez přetypování. Chcete-li vytvořit literál typu dlouho, musíte kompilátoru výslovně oznámit připojením literálu písmenem " l"nebo" L":

Byte b1 = 127; byte b2 = 128; // chyba short s1 = -32768; krátké s2 = -32769; // error char c1 = 0; char c2 = -1; // chyba dlouhá l1 = 10l; dlouhé l2 = 0x7ffffffffffffffL; // maximální hodnota typu long

Literály s pohyblivou řádovou čárkou

Pro znaky s pohyblivou řádovou čárkou existují dvě formy zápisu: standardní a exponenciální:

// standardní tvar double d1 = 0.; // ekvivalent .0 nebo 0.0; dvojnásobek d2 = 0,125; // exponenciální tvar - použijte symbol "e" nebo "E" // za to je mocnina 10, kterou se má dané číslo vynásobit double d3 = 125E+10; // pokud je stupeň kladný, "+" lze vynechat double d4 = 1,25e-10;
Všem literálům s pohyblivou řádovou čárkou je ve výchozím nastavení přiřazen typ dvojnásobek. Proto vytvořit doslovný like plovák, musíte zadat písmeno " za literálem F"nebo" F". K literálům můžete také přidat písmeno " d"nebo" D“, což naznačuje, že se jedná o doslovný typ double, ale proč?

Double d1 = 0,125; plovoucí f2 = 0,125f;
Můžete použít hexadecimální literály s plovoucí desetinnou čárkou, například:

// P - binární řád, který udává mocninu 2, kterou má být dané číslo vynásobeno double d = 0x10.P10d; // samozřejmě to jde i bez "d" float f = 0x20.P10f;
Aby bylo čtení dlouhých literálů snazší, přidala verze 7 jazyka možnost používat znak „_“ uvnitř literálu:

// můžete vytvářet libovolné kombinace pomocí libovolného počtu znaků "_" int phone = 111__111__111; int bin = 0b1000_1000_1000; dvojnásobek dolarů = 23_000,450__500; // není povoleno používat znak "_" na konci nebo začátku literálu a také není možné oddělit "0x" a "0b"

Charakterové literály

Znakové literály jsou uzavřeny v jednoduchých uvozovkách. Tímto způsobem lze nastavit všechny zobrazené znaky. Pokud znak nelze zadat přímo, použijte kontrolní sekvence začínající symbolem " \ I když všechny tyto sekvence mohou být nahrazeny odpovídajícími Unicode kód. Znakový literál můžete také vytvořit pomocí osmičkové ("\xxx") a hexadecimální ("\uxxxx") formy.

Char h = "a"; // standardní tvar char a = "\001"; // osmičkový tvar char c = "\u0001"; // hexadecimální tvar
Existují také řetězcové literály. Informace o nich lze získat.

Booleovské literály

S logické operátory je to jednoduché. Existují pouze dva booleovské literály:

Boolean yes = true; // true boolean no = false; // lhát
Booleovské literály lze přiřadit pouze proměnným typu booleovský. Je také důležité tomu rozumět v Javě jsou specifikovány pomocí klíčového slova boolean a mohou mít pouze jednu ze dvou hodnot: ne rovné 0 , A data. Proměnné ne rovné 1 . Konvertovat typ proměnné booleovský S jinými primitivními typy to nebude fungovat.

Operace

Přes integrální typy

• srovnávací operátory ( > , < , >= , <= ) a rovnost ( == , != )
• unární operátoři ( + , - )
• multiplikativní ( * , / , % ) a aditivum ( + , - ) operátory
• přírůstek ( ++ ) a snížit ( -- ) v prefixových a postfixových tvarech
• ikonický ( >> , << ) a nepodepsané ( >>> ) směnoví operátoři
• bitové operátory ( ~ , & , ^ , | )
• podmíněný operátor ( ? : )
• operátor obsazení

Nad Plovoucí desetinná čárka typy

S čísly s pohyblivou řádovou čárkou můžete provádět všechny stejné operace jako s celými čísly, s výjimkou bitových operátorů a operátorů shift.

Nad booleovský typ

• operátory rovnosti ( == A != )
• logické operátory ( ! ,& , | , ^ )
• podmíněné logické operátory ( && , || )
• podmíněný operátor ( ? : )

Konverze

Existují tři typy transformací:

• rozšiřující se transformace ( rozšíření)
• zužující se transformace ( zúžení)
• rozšíření + zúžení (konverze byte Na char, nejprve byte převést na int a pak int- V char)

Rozšiřující se transformace

Pokud jsou oba typy kompatibilní a délka cílového typu je větší než délka zdrojového typu, provede se rozšiřující konverze (např. byte převeden na int). Následující tabulka ukazuje všechny možné expanzní transformace. V průběhu jsou vyznačeny typy, jejichž převod může vést ke ztrátě dat.

Zužující se transformace

Při zužujícím se převodu se může ztratit informace o celkové velikosti číselné hodnoty a také může dojít ke ztrátě přesnosti a rozsahu. Všechny možné zužující transformace jsou uvedeny v tabulce:

krátký	byte, char
char	byte, krátký
int	byte, short, char
dlouho	int, byte, short, char
plovák	long, int, byte, short, char
dvojnásobek	float, long, int, byte, short, char

Chcete-li převést dva nekompatibilní typy, musíte použít přetypování ( odlévání). Pokud jsou hodnoty originálu celočíselný typ je větší než přípustný rozsah hodnot cílového typu, pak bude redukován na výsledek dělení modulo rozsahem cílového typu. Pokud je hodnota typu s plovoucí desetinnou čárkou převedena na hodnotu typu integer, dojde ke zkrácení (zlomková část se zahodí).

Byte a = (byte)128; // - 128 byte b = (byte)42; // ghosting je možný, ale v tomto případě to není nutné int i1 = (int)1e20f; // 2147483647 int i2 = (int)Float.NaN; // 0 float f1 = (float)-1e100; // -Infinity float f2 = (float)1e-50; // 0,0

Podpora

Při požadované přesnosti střední hodnota je mimo platný rozsah hodnot pro kterýkoli z operandů ve výrazu, použije se automatické povýšení typu.

Int a = 100; float b = 50,0f; dvojité c = 50,0; dvojitý výsledek = a - b + c; // 100,0 // ve skutečnosti: výsledek = (double)((float)a - b) + c;
Pravidla propagace dobře znázorňuje následující schéma:

Třídy obalování

Pro reprezentaci primitivních typů jako objektů byly vytvořeny obalové třídy ( obalové třídy). Jaké výhody nám dávají obalové třídy?

• schopnost používat objekty obalových tříd jako parametry metod nebo jako obecné parametry
• schopnost používat konstanty, které jsou zodpovědné za hranice odpovídajícího datového typu ( MIN_VALUE A MAX_VALUE)
• schopnost používat metody pro převod na jiné primitivní typy, převod mezi číselnými soustavami

Existuje osm tříd obalů, jedna pro každý primitivní typ:
Téměř všechny třídy (kromě Boolean A Charakter) zděděno od abstraktní třída Číslo a jsou srovnatelné (implementujte rozhraní Srovnatelný). Hierarchie je zhruba takto:

// existuje několik způsobů, jak vytvořit Integer i1 = new Integer("10"); Integer i2 = new Integer(10); Integer i3 = Integer.valueOf(10); Integer i4 = Integer.valueOf("10", 10); // můžete zadat číselný systém, pouze pro obaly celočíselných primitivních typů Character c1 = new Character("c"); // je jen jeden způsob // získáme hodnoty primitivních typů int i5 = i1.intValue(); char c2 = c1.charValue();

Automatické balení a vybalování

JDK 5 představil dvě důležité funkce:

• Automatické balení ( autoboxing) je proces automatického zapouzdření primitivního typu do vhodné třídy obalu. Není potřeba explicitně vytvářet objekt.
• Rozbalení ( rozbalení) je proces automatického extrahování primitivního typu z odpovídající třídy obalu. Pro získání primitivního typu není potřeba explicitně volat metodu.

Tyto nástroje usnadňují vytváření objektů, získávání primitivních typů a zjednodušují práci s kolekcemi.

Veřejná statika prázdný hlavní(String... s) ( Integer i1 = 10; // autoboxing - Integer.valueOf(10) int i2 = i1; // unboxing - i1.intValue() method(10); // autoboxing do objektu Integer class - Integer.valueOf(10) ++i1 // rozbalení - i1.intValue(), autoboxing - Integer.valueOf(i1.intValue() + 1) ) private static int method(Integer i) ( return i; // rozbalení objektu přijato jako parametr - i.intValue() )

Některé užitečné metody

Celé číslo i1 = 128; i1.compareTo(5); // 1, to je i.intValue() > Integer.valueOf(5) Integer.decode("0xabc"); // nefunguje s binárními literály Integer.parseInt("10", 3); // funguje s libovolnou číselnou soustavou // metoda převodu i1.byteValue(); // (byte)i.intValue() // ověřovací metody Float f = 20.5f; Boolean badFloat = f.isInfinite() || f.isNaN(); // false, autoboxing boolean // převod na řetězec f.toString();
děkuji za pozornost. Všechny dodatky, upřesnění a kritika jsou vítány.

Proměnná je hlavním prvkem ukládání informací v programu Java. Proměnná je charakterizována kombinací identifikátoru, typu a rozsahu. V závislosti na tom, kde je proměnná deklarována, může být lokální, například pro kód v rámci metody, nebo to může být proměnná instance třídy, která je dostupná všem metodám této třídy. Místní obory jsou deklarovány pomocí složených závorek.

1.1. Deklarování proměnných

Všechny proměnné musí být deklarovány před jejich prvním použitím v programu. Základní forma deklarace proměnné je:

identifikátor typu[=hodnota][, identifikátor[=hodnota]...];

Typ je buď jeden z vestavěných typů, nebo název třídy nebo rozhraní. Níže jsou uvedeny některé příklady deklarací proměnných různé typy. Všimněte si, že některé příklady zahrnují inicializaci počáteční hodnoty. Proměnné, pro které nejsou zadány žádné počáteční hodnoty, se automaticky inicializují na nulu.

Tabulka 1.1. Deklarování proměnných různých typů

		Typ proměnné
	int,b, c;	Deklaruje tři celočíselné proměnné a,b, c
	int d = 3, e,f = 5;	Deklaruje další tři celočíselné proměnné, inicializujed aF
	byte z = 22;	Deklaruje proměnnouz typubyte a inicializuje jej
	dvojité pí = 3,14159;	Deklaruje proměnnoutyp pídouble a inicializuje jej na pi
	znak x ="x";	Znaková proměnná x získá hodnotu "x"

Identifikátor je název proměnné. Jako identifikátor lze použít libovolnou sekvenci malých a malých písmen. velká písmena, čísla a symboly _ (podtržítko) a $ (dolar). Identifikátory nesmí začínat číslem.

Hodnota je libovolný literál nebo výraz, jehož výsledkem je hodnota stejného (nebo kompatibilního) typu uvedeného v deklaraci proměnné. Níže uvedený příklad vytvoří tři proměnné odpovídající stranám pravoúhlého trojúhelníku a poté použije Pythagorovu větu k výpočtu délky přepony. v tomto případěčíslo 5, velikost přepony klasického pravoúhlého trojúhelníku o stranách 3-4-5.

proměnné třídy (
public static void main(String args)(
dvojité a = 3;
dvojité b = 4;
dvojité c;
S= Math.sqrt(a* a + b* b);
System.out.println("c = "+ c);
}

1.2. Variabilní rozsah

Bloky složených příkazů v Javě jsou označeny dvojicí složených závorek (). Proměnné v Javě nabývají účinnosti od bodu v programu, kde jsou deklarovány, až do konce bloku, který je obsahuje. Bloky mohou být vnořeny do sebe a každý může mít svou vlastní sadu lokálních proměnných.