Java Language
Literały

Wprowadzenie

Literały szesnastkowe, ósemkowe i binarne

Liczba hexadecimal jest wartością w podstawie 16. Jest 16 cyfr, 0-9 i liter AF (wielkość liter nie ma znaczenia). AF reprezentują 10-16 .

Liczba octal jest wartością w bazie-8 i używa cyfr 0-7 .

Liczba binary jest wartością w bazie-2 i wykorzystuje cyfry 0 i 1 .

Wszystkie te liczby dają tę samą wartość, 110 :

int dec = 110;            // no prefix   --> decimal literal
int bin = 0b1101110;      // '0b' prefix --> binary literal
int oct = 0156;           // '0' prefix  --> octal literal
int hex = 0x6E;           // '0x' prefix --> hexadecimal literal

Zauważ, że binarna dosłowna składnia została wprowadzona w Javie 7.

Oktalowy literał może łatwo być pułapką na błędy semantyczne. Jeśli zdefiniujesz wiodące '0' do liter dziesiętnych, otrzymasz niewłaściwą wartość:

int a = 0100;        // Instead of 100, a == 64

Używanie podkreślenia w celu poprawy czytelności

Od wersji Java 7 możliwe jest użycie jednego lub więcej znaków podkreślenia (_) do oddzielenia grup cyfr w pierwotnym dosłownym numerze dosłownym, aby poprawić ich czytelność.

Na przykład te dwie deklaracje są równoważne:

int i1 = 123456;
int i2 = 123_456;
System.out.println(i1 == i2); // true

Można to zastosować do wszystkich pierwotnych literałów liczbowych, jak pokazano poniżej:

byte color = 1_2_3;
short yearsAnnoDomini= 2_016;
int socialSecurtyNumber = 999_99_9999;
long creditCardNumber = 1234_5678_9012_3456L;
float piFourDecimals =  3.14_15F;
double piTenDecimals =  3.14_15_92_65_35;

Działa to również przy użyciu przedrostków dla baz binarnych, ósemkowych i szesnastkowych:

short binary= 0b0_1_0_1;
int octal = 07_7_7_7_7_7_7_7_0;
long hexBytes = 0xFF_EC_DE_5E;

Istnieje kilka zasad dotyczących podkreślników, które zabraniają ich umieszczania w następujących miejscach:

• Na początku lub na końcu numeru (np _123 lub 123_ nie są ważne)
• Sąsiaduje z przecinkiem w zmiennoprzecinkowej dosłowny (np 1._23 lub 1_.23 nie są ważne)
• Przed sufiksem F lub L (np. 1.23_F lub 9999999_L nie są ważne)
• W miejscach, gdzie spodziewana jest ciąg cyfr (np 0_xFFFF nie jest ważna)

Sekwencje specjalne w literałach

Literały ciągów i znaków zapewniają mechanizm zmiany znaczenia, który umożliwia ekspresowe kody znaków, które w innym przypadku nie byłyby dozwolone w literale. Sekwencja ucieczki składa się ze znaku odwrotnego ukośnika ( \ ), po którym następuje jedna lub więcej innych znaków. Te same sekwencje są poprawne zarówno dla literału, jak i literału łańcuchowego.

Pełny zestaw sekwencji specjalnych jest następujący:

<octal> powyżej zawiera jedną, dwie lub trzy cyfry ósemkowe (od „0” do „7”), które reprezentują liczbę od 0 do 255 (dziesiętnie).

Zauważ, że ukośnik odwrotny, po którym następuje dowolny inny znak, jest nieprawidłową sekwencją zmiany znaczenia. Nieprawidłowe sekwencje specjalne są traktowane przez JLS jako błędy kompilacji.

Odniesienie:

• JLS 3.10.6. Sekwencje specjalne dla liter i znaków

Ucieka Unicode

Oprócz opisanych powyżej sekwencji ucieczki ciągów i znaków, Java ma bardziej ogólny mechanizm zmiany znaczenia Unicode, jak zdefiniowano w JLS 3.3. Ucieka Unicode . Kod ucieczki Unicode ma następującą składnię:

'\' 'u' <hex-digit> <hex-digit> <hex-digit> <hex-digit> 

gdzie <hex-digit> jest jednym z '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' , 'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'A' , 'B' , 'C' , 'D' , 'E' , 'F' .

Kod ucieczki Unicode jest odwzorowywany przez kompilator Java na znak (ściśle mówiąc 16-bitową jednostkę kodu Unicode) i może być używany w dowolnym miejscu kodu źródłowego, w którym znak odwzorowany jest prawidłowy. Jest powszechnie używany w literałach znakowych i łańcuchowych, gdy trzeba przedstawić literał w postaci innej niż ASCII.

Ucieczka w wyrażeniach regularnych

TBD

Liczby całkowite dziesiętne

Literały całkowite zapewniają wartości, których można użyć tam, gdzie potrzebujesz instancji byte , short , int , long lub char . (Ten przykład koncentruje się na prostych formach dziesiętnych. Inne przykłady wyjaśniają, jak literały w liczbach ósemkowych, szesnastkowych i binarnych, a także stosowanie znaków podkreślenia w celu poprawy czytelności.)

Zwykłe literały całkowite

Najprostszą i najczęstszą formą literału całkowitego jest dziesiętny literał całkowity. Na przykład:

 0       // The decimal number zero       (type 'int')
 1       // The decimal number one        (type 'int')
 42      // The decimal number forty two  (type 'int')

Musisz być ostrożny z zerami wiodącymi. Zero wiodące powoduje, że literał całkowity jest interpretowany jako ósemkowy, a nie dziesiętny.

 077    // This literal actually means 7 x 8 + 7 ... or 63 decimal!

Literały całkowite są niepodpisane. Jeśli widzisz coś w rodzaju -10 lub +10 , są to wyrażenia korzystające z jednoargumentowych - i jednoargumentowych operatorów + .

Zakres literałów całkowitych tej postaci ma wewnętrzny typ int i musi mieścić się w zakresie od zera do 2 ³¹ lub 2 147 483 648.

Zauważ, że 2 ³¹ jest o 1 większy niż liczba Integer.MAX_VALUE . Literówki od 0 do celu 2147483647 mogą być wykorzystane w dowolnym miejscu, ale jest to błąd kompilacji używać 2147483648 bez poprzedzającego jednoargumentowego - operatora. (Innymi słowy, jest zarezerwowany do wyrażania wartości Integer.MIN_VALUE .)

 int max = 2147483647;     // OK
 int min = -2147483648;    // OK
 int tooBig = 2147483648;  // ERROR

Długie literały całkowite

long literały typu są wyrażane przez dodanie przyrostka L Na przykład:

 0L          // The decimal number zero       (type 'long')
 1L          // The decimal number one        (type 'long')
 2147483648L // The value of Integer.MAX_VALUE + 1

 long big = 2147483648;    // ERROR
 long big2 = 2147483648L;  // OK

Zauważ, że rozróżnienie między literałami int i long jest znaczące w innych miejscach. Na przykład

 int i = 2147483647;
 long l = i + 1;           // Produces a negative value because the operation is
                           // performed using 32 bit arithmetic, and the 
                           // addition overflows
 long l2 = i + 1L;         // Produces the (intuitively) correct value.

Odniesienie: JLS 3.10.1 - Literały całkowite

Literały logiczne

Literały logiczne są najprostszymi literałami w języku programowania Java. Dwie możliwe wartości boolean są reprezentowane przez literały true i false . Rozróżniana jest wielkość liter. Na przykład:

boolean flag = true;    // using the 'true' literal
flag = false;           // using the 'false' literal

Literały łańcuchowe

Literały łańcuchowe zapewniają najwygodniejszy sposób reprezentowania wartości łańcuchowych w kodzie źródłowym Java. Dosłowny ciąg składa się z:

• Początkowy znak podwójnego cudzysłowu ( " ).
• Zero lub więcej innych znaków, które nie są ani cudzysłowem, ani znakiem końca linii. (Znak odwrotnego ukośnika ( \ ) zmienia znaczenie kolejnych znaków; patrz Sekwencje specjalne w literałach .)
• Końcowy znak podwójnego cudzysłowu.

Na przykład:

"Hello world"   // A literal denoting an 11 character String
""              // A literal denoting an empty (zero length) String
"\""            // A literal denoting a String consisting of one 
                //     double quote character
"1\t2\t3\n"     // Another literal with escape sequences

Zauważ, że literał w jednym łańcuchu może nie obejmować wielu linii kodu źródłowego. Jest to błąd kompilacji podziału linii (lub końca pliku źródłowego), który występuje przed zamknięciem podwójnego cudzysłowu literału. Na przykład:

"Jello world    // Compilation error (at the end of the line!)

Długie sznurki

Jeśli potrzebujesz łańcucha, który jest zbyt długi, aby zmieścił się w linii, konwencjonalnym sposobem jego wyrażenia jest podzielenie go na wiele literałów i użycie operatora konkatenacji ( + ) do łączenia elementów. Na przykład

String typingPractice = "The quick brown fox " +
                        "jumped over " +
                        "the lazy dog"

Wyrażenie podobne do powyższego, składające się z literałów łańcuchowych i + spełnia wymagania dotyczące wyrażenia ciągłego . Oznacza to, że wyrażenie zostanie ocenione przez kompilator i reprezentowane w czasie wykonywania przez pojedynczy obiekt String .

Internowanie literałów łańcuchowych

Gdy JVM ładuje plik klasy zawierający literały łańcuchowe, odpowiednie obiekty String są internalizowane przez system wykonawczy. Oznacza to, że literał łańcuchowy używany w wielu klasach nie zajmuje więcej miejsca niż gdyby był używany w jednej klasie.

Więcej informacji na temat internowania i puli ciągów można znaleźć w przykładzie puli ciągów i pamięci masowej sterty w temacie Ciągi.

Literał zerowy

Literał Null (zapisany jako null ) reprezentuje jedyną wartość typu null. Oto kilka przykładów

    MyClass object = null;
    MyClass[] objects = new MyClass[]{new MyClass(), null, new MyClass()};

    myMethod(null);

    if (objects != null) {
         // Do something
    }

Typ zerowy jest raczej nietypowy. Nie ma nazwy, więc nie można wyrazić jej w kodzie źródłowym Java. (I nie ma też reprezentacji środowiska wykonawczego.)

Jedynym celem typu null jest bycie typem null . Jest to przypisanie kompatybilne ze wszystkimi typami referencji i może być rzutowane na dowolny typ referencji. (W tym drugim przypadku rzutowanie nie wymaga sprawdzenia typu środowiska wykonawczego).

Wreszcie, null ma właściwość, którą null instanceof <SomeReferenceType> oceni na false , bez względu na typ.

Literały zmiennoprzecinkowe

Literały zmiennoprzecinkowe zapewniają wartości, których można użyć tam, gdzie potrzebujesz wystąpienia float lub double . Istnieją trzy rodzaje literału zmiennoprzecinkowego.

• Proste formy dziesiętne
• Skalowane formy dziesiętne
• Formy szesnastkowe

(Reguły składniowe JLS łączą dwie formy dziesiętne w jedną formę. Traktujemy je osobno dla ułatwienia wyjaśnienia.)

Istnieją różne typy literałów dla float i literałów double , wyrażone za pomocą przyrostków. Różne formy używają liter do wyrażania różnych rzeczy. Te litery nie uwzględniają wielkości liter.

Proste formy dziesiętne

Najprostsza forma literału zmiennoprzecinkowego składa się z jednej lub więcej cyfr dziesiętnych i przecinka dziesiętnego ( . ) Oraz opcjonalnego sufiksu ( f , F , d lub D ). Opcjonalny sufiks pozwala określić, że literał jest wartością float ( f lub F ) lub double ( d lub D ). Domyślnie (gdy nie podano przyrostka) jest double .

Na przykład

 0.0     // this denotes zero
 .0      // this also denotes zero
 0.      // this also denotes zero
 3.14159 // this denotes Pi, accurate to (approximately!) 5 decimal places.
 1.0F    // a `float` literal
 1.0D    // a `double` literal.  (`double` is the default if no suffix is given)

W rzeczywistości cyfry dziesiętne, po których następuje sufiks, są również literami zmiennoprzecinkowymi.

 1F      // means the same thing as 1.0F

Znaczenie literału dziesiętnego to liczba zmiennoprzecinkowa IEEE, która jest najbliższa nieskończonej precyzji matematycznej liczby rzeczywistej oznaczonej przez liczbę dziesiętną zmiennoprzecinkową. Ta wartość koncepcyjna jest konwertowana na binarną reprezentację zmiennoprzecinkową IEEE za pomocą zaokrąglenia do najbliższego . (Dokładna semantyka konwersji dziesiętnej jest określona w javadocs dla Double.valueOf(String) i Float.valueOf(String) , pamiętając o różnicach w składni liczbowej.)

Skalowane formy dziesiętne

Skalowane formy dziesiętne składają się z prostego dziesiętnego z częścią wykładniczą wprowadzoną literą E lub e , po której następuje podpisana liczba całkowita. Część wykładnicza to krótka ręka do pomnożenia postaci dziesiętnej przez potęgę dziesięciu, jak pokazano w poniższych przykładach. Istnieje również opcjonalny sufiks do rozróżniania float i liczb double . Oto kilka przykładów:

 1.0E1    // this means 1.0 x 10^1 ... or 10.0 (double)
 1E-1D    // this means 1.0 x 10^(-1) ... or 0.1 (double)
 1.0e10f  // this means 1.0 x 10^(10) ... or 10000000000.0 (float)

Rozmiar literału jest ograniczony reprezentacją ( float lub double ). Jest to błąd kompilacji, jeśli współczynnik skali powoduje, że wartość jest zbyt duża lub zbyt mała.

Formy szesnastkowe

Począwszy od Java 6, możliwe jest wyrażanie literałów zmiennoprzecinkowych w systemie szesnastkowym. Forma szesnastkowa ma analogiczną składnię do prostych i skalowanych postaci dziesiętnych, z następującymi różnicami:

1. Każdy szesnastkowy literał zmiennoprzecinkowy zaczyna się od zera ( 0 ), a następnie od x lub X
2. Cyfry liczby (ale nie część wykładnicza!) Obejmują również cyfry szesnastkowe od a do f oraz ich odpowiedniki wielkich liter.
3. Wykładnik jest obowiązkowy i jest wprowadzany literą p (lub P ) zamiast e lub E Wykładnik reprezentuje współczynnik skalowania, który jest potęgą 2 zamiast potęgi 10.

Oto kilka przykładów:

0x0.0p0f    // this is zero expressed in hexadecimal form (`float`)
0xff.0p19   // this is 255.0 x 2^19 (`double`)

Rada: ponieważ szesnastkowe formy zmiennoprzecinkowe są nieznane większości programistów Java, zaleca się ich oszczędne używanie.

Podkreślenia

Począwszy od Java 7, znaki podkreślenia są dozwolone w ciągach cyfr we wszystkich trzech formach literału zmiennoprzecinkowego. Dotyczy to również części „wykładnikowych”. Zobacz Korzystanie z podkreślników w celu poprawy czytelności .

Przypadki specjalne

Jest to błąd kompilacji, jeśli literał zmiennoprzecinkowy oznacza liczbę, która jest zbyt duża lub zbyt mała, aby reprezentować ją w wybranej reprezentacji; tj. jeśli liczba przepełni się do + INF lub -INF, lub niedopełnienia do 0,0. Jednak literał może reprezentować niezerową liczbę zdenormalizowaną.

Zmienna literałowa składnia literalna nie zapewnia reprezentacji literalnych dla wartości specjalnych IEEE 754, takich jak wartości INF i NaN. Jeśli chcesz je wyrazić w kodzie źródłowym, zalecanym sposobem jest użycie stałych zdefiniowanych przez java.lang.Float i java.lang.Double ; np. Float.NaN , Float.NEGATIVE_INFINITY i Float.POSITIVE_INFINITY .

Literały postaci

Literały znakowe zapewnić Najwygodniejszym sposobem wyrażania char wartości w kodzie źródłowym Javy. Dosłowny charakter składa się z:

• Początkowy znak pojedynczego cudzysłowu ( ' ).
• Przedstawienie postaci. Ta reprezentacja nie może być pojedynczym cudzysłowem ani znakiem końca linii, ale może być sekwencją zmiany znaczenia wprowadzoną znakiem odwrotnego ukośnika ( \ ); patrz sekwencje specjalne w literałach .
• Końcowy znak pojedynczego cudzysłowu ( ' ).

Na przykład:

char a = 'a';
char doubleQuote = '"';
char singleQuote = '\'';

Podział wiersza w literałach znaków jest błędem kompilacji:

char newline = '
// Compilation error in previous line
char newLine = '\n';  // Correct