Letterwoorden op Java

1. Integer letterlijke getallen

En nu voor een nieuw interessant onderwerp - letterlijke woorden. Gegevens die rechtstreeks in programmacode zijn geschreven, worden letterlijke getallen genoemd . We hebben het niet over oude gegevens, maar over de waarden van primitieve typen en het Stringtype.

Stel bijvoorbeeld dat je de volgende code hebt:

int a = 5;
int b = a + 10;
String s = "Sum=" + (a + b);

5
10
"Sum="

De letterlijke waarden in deze code zijn het getal 5, het getal 10en de tekenreeks ' Sum = '.

In Java heeft alles, inclusief literals, een type. Standaard zijn alle letterlijke gehele getallen (hele getallen) in code ints. Het int-type is het standaard Java integer-type.

Bovendien zullen er geen problemen zijn als u besluit een letterlijk geheel getal toe te wijzen aan een bytevariabele of een korte variabele in uw code. U hoeft er alleen maar voor te zorgen dat de letterlijke waarde binnen het waardenbereik ligt dat het type van de variabele kan opslaan.

De Java-compiler is slim genoeg om te begrijpen dat aan een bytevariabele zonder problemen het gehele getal letterlijk 100 kan worden toegewezen.

Voorbeelden:

int a = 300;

byte a = 100; 

byte a = 300; 

U kunt ook longletterlijke tekens in uw code schrijven. Voeg hiervoor de Latijnse letter 'L' of 'l' toe aan het einde van het gehele getal.

Voorbeelden:

long a = 3000000000L; 

long a = 3000000000; 

int a = 3000000000L; 

Is het je opgevallen hoe moeilijk het is om grote getallen van 10 of meer cijfers te lezen? Je kunt niet meteen zien of de code 3 miljard of 30 miljard zegt. Om de code leesbaarder te maken (en dit is belangrijk!), staat Java toe dat onderstrepingstekens worden ingevoegd in numerieke literals (ze hebben geen invloed op de waarde van het getal).

Het bovenstaande voorbeeld kan worden herschreven met onderstrepingstekens om het een beetje duidelijker te maken:

long a = 3_000_000_000L; 

long a = 3_000_000_000; 

int a = 3_000_000_000L; 

Maar we kunnen geen komma's gebruiken in numerieke literals omdat ze al voor een ander doel worden gebruikt. Bijvoorbeeld om argumenten van elkaar te scheiden bij het aanroepen van een methode.

2. Echte letterlijke getallen

In uw code kunt u niet alleen gehele getallen opgeven, maar ook letterlijke drijvende komma's (reële getallen).

Eigenlijk is de regel vrij eenvoudig: als een getal in de code een decimaalteken bevat, dan is het getal een letterlijke drijvende komma. En niet zomaar een letterlijke, maar een doubleletterlijke.

U kunt een letterlijke float maken, maar daarvoor moet u de letter 'F' (of 'f') aan het einde van het getal plaatsen .

Voorbeelden:

double a = 100.0; 

double a = 100.;

double a = .0;

float a = 100.0f; 

float a = 100.0; 

Trouwens, je kunt een letterlijk geheel getal expliciet converteren naar een float of double literal door simpelweg ). Voorbeelden: appending the suffix 'F' (for float) or D (for double)

double a = 100D; 

float a = 100F; 

int a = 300D; 

Letterlijke getallen met drijvende komma kunnen wetenschappelijke notatie gebruiken : naast het ondertekende deel van het getal kunt u ook een macht van tien specificeren. Voorbeeld:

1.23E2

1.23 * 102

123.0

1.23E3

1.23 * 103

1230.0

1.23E-6

1.23 * 10-6

0.00000123

1E6

1.0 * 106

1000000.0

1E-10

1.0 * 10-10

0.0000000001

3. Letterlijke tekenreeksen

U kunt ook hele regels tekst in uw code opgeven. Om de compiler te vertellen dat hij een string moet behandelen als data (een letterlijke waarde) en niet als onderdeel van de code, wordt de hele string aan beide kanten tussen dubbele aanhalingstekens geplaatst.

Als een enkele coderegel meerdere dubbele aanhalingstekens heeft, worden deze in paren gesplitst. Het eerste dubbele aanhalingsteken geeft het begin van een letterlijke zin aan. De volgende geeft het einde van de letterlijke betekenis aan. De volgende daarna markeert opnieuw het begin van een nieuwe letterlijke. En de volgende markeert het einde van de tweede letterlijke. Enzovoort.

Elk van deze letterlijke tekens is een String.

Voorbeelden

"+" + "+" + "+" + "+" + "+"

""

"2+3" + "-5"

"return" + ";"

Als een letterlijke tekenreeks te lang is, kan deze worden opgesplitst in meerdere regels en aan elkaar worden gelijmd met de 'plus-operator':

String s = "I hold it true, whate'er befall, "
         + "I feel it when I sorrow most; "
         + "'Tis better to have loved and lost "
         + "Than never to have loved at all.";

4. Letterlijke tekens

U kunt niet alleen letterlijke tekenreeksen in uw code specificeren, maar ook letterlijke tekens die uit afzonderlijke tekens bestaan. Merk op dat we het niet hebben over een string die uit een enkel teken bestaat, maar over letterlijke tekens waarvan het type is char.

In tegenstelling tot een tekenreeks wordt een literaal teken omgeven door enkele aanhalingstekens . Binnen de enkele aanhalingstekens moet er een teken en slechts één teken zijn. U kunt geen lege enkele aanhalingstekens gebruiken.

Voorbeelden:

'A'

'@' 

'本' 

'\u1f3a'

In het laatste voorbeeld wordt een Unicode-teken toegewezen met een speciale notatie: eerst hebben we het voorvoegsel \u, gevolgd door 4 hexadecimale tekens. De volgende lessen bevatten uitgebreide informatie hierover.