Ce sunt variabilele în java. WDH: Java - Tipuri, valori și variabile

Tipurile primitive în Java sunt o parte importantă, folosită frecvent a limbajului, care necesită o manipulare specială. În această publicație vom încerca să răspundem la toate întrebările legate de tipurile primitive, mecanismul de funcționare și procesare a acestora. Articolul este destinat atât începătorilor care tocmai s-au îmbarcat pe calea spinoasă a învățării Java (eu sunt unul dintre ei), cât și persoanelor care sunt destul de familiare cu limbajul, care își vor putea reîmprospăta cunoștințele și, sper, găsesc ceva interesant pentru ei înșiși.

Tipuri primitive

Tipurile primitive încalcă ușor natura orientată pe obiect a limbajului Java, deoarece reprezintă valori unice (simple). Această caracteristică se explică prin dorința de a asigura o eficiență maximă. Crearea unui obiect variabil simplu folosind new nu este suficient de eficientă, deoarece new mută obiectul în heap. În schimb, este creată o variabilă „automată” care nu este o referință la obiect. O variabilă stochează o singură valoare și se află pe stivă. Stiva este o zonă de stocare a datelor situată în RAM. Procesorul are acces direct la această zonă printr-un pointer de stivă, astfel încât stiva este o modalitate foarte rapidă și eficientă de stocare a datelor. În ceea ce privește viteza, stiva este a doua după registre (logic, deoarece registrele sunt localizate în interiorul procesorului).
Toate dimensiunile tipurilor primitive sunt strict fixate și nu depind de arhitectura mașinii. Acesta este unul dintre motivele pentru portabilitatea îmbunătățită a programelor Java.
Java definește opt tipuri primitive, care pot fi împărțite în patru grupuri:

Numere întregi

Există patru tipuri primitive definite pentru numere întregi: octet, mic de statura, int, lung. Toate aceste tipuri reprezintă valori întregi cu semn: pozitive sau negative. Nu există valori întregi pozitive fără semn în Java ( nesemnat). După cum sa spus mai devreme, toate dimensiunile tipurilor primitive sunt fixe:
Cel mai mic tip întreg este octet. Variabilele de acest tip sunt foarte convenabile pentru lucrul cu fluxuri I/O și pentru manipularea datelor binare. Urmează tipul mic de statura, care este folosit mai rar decât toate celelalte tipuri. Cel mai des folosit tip este int. Este folosit constant în bucle pentru a indexa tablourile. Poate părea că folosirea tipurilor octetȘi mic de staturaîn locurile în care nu este necesară o gamă largă de valori, va fi mai eficient decât utilizarea int. Dar acest lucru nu este adevărat, deoarece atunci când expresiile sunt evaluate, valorile de tip octet sau scurt vor fi convertite în int(vom reveni la această problemă mai târziu). Când tipul de lungime int nu este suficient pentru a stoca valoarea, trebuie să utilizați lung. Gama sa de valori este destul de mare, ceea ce face lung convenabil atunci când lucrați cu numere întregi mari.

Numere în virgulă mobilă

Numerele în virgulă mobilă (sau numerele reale) sunt reprezentate prin tipuri plutiȘi dubla. Folosit pentru a stoca valori exacte la un anumit loc după virgulă zecimală.
Tip pluti definește o valoare numerică în virgulă mobilă cu precizie unică. Acest tip este folosit atunci când aveți nevoie de o valoare numerică cu o parte fracțională, dar fără prea multă precizie. Tip dubla folosit pentru a stoca valori cu virgulă mobilă cu precizie dublă. Procesarea valorilor cu precizie dublă este mai rapidă decât procesarea valorilor cu precizie unică. Prin urmare, majoritatea funcțiilor matematice ale clasei java.lang.Math returnează valori de tip dubla. Cel mai eficient de utilizat dubla atunci când trebuie să mențineți acuratețea calculelor repetate sau să manipulați numere mari.

Simboluri

În specificație, tipul primitiv char aparține tipurilor integrale (sau tipuri integrale), dar din moment ce joacă un rol ușor diferit, i se poate atribui propria sa categorie. Rolul său este de a reprezenta simboluri Unicode. Sunt necesari 16 biți pentru a stoca caractere. Este ciudat, deoarece 8 biți sunt suficienți pentru a reprezenta caractere în limbile majore (de exemplu, engleză, franceză, spaniolă). Dar acesta este prețul internaționalizării. Unicode folosește un set complet de caractere internaționale în toate limbile cunoscute ale lumii.

Valori logice

Tipul primitiv boolean este conceput pentru a stoca valori logice. Acest tip poate lua una dintre cele două valori posibile: adevărat sau fals. Valorile booleene sunt returnate de la toate operațiunile logice (cum ar fi operațiunile de comparare). Este obligatoriu la construirea de cicluri și operatori (de exemplu, pentru, dacă).

Literale

Valorile tipurilor de date primitive sunt în majoritatea cazurilor inițializate folosind literale. Să ne uităm la ele.

Literale întregi

Literele cele mai des folosite. Orice valoare întreagă este un literal numeric (de exemplu, -10 , 10 - valori zecimale). Puteți utiliza literale octale, hexazecimale și binare:

// literal zecimal, numere, nu începe cu 0 int decimal = 10; // 10 // literal octal începe cu 0, apoi numere int octal = 010; // 8 // literal hexazecimal începe cu 0x sau 0X, apoi numere și simboluri int hexazecimal = 0x10; // 16 // literal binar începe cu Ob sau 0B, apoi numerele int binar = 0b10; // 2
Toate literalele întregi reprezintă valori int. Dacă valoarea literală este în interval octet, mic de statura sau char, atunci poate fi atribuit unei variabile de acest tip fără tip casting. Pentru a crea un literal de tip lung, trebuie să indicați în mod explicit compilatorului prin adăugarea literalului cu litera " l" sau " L":

Octet b1 = 127; octet b2 = 128; // eroare scurtă s1 = -32768; scurt s2 = -32769; // eroare char c1 = 0; char c2 = -1; // eroare lung l1 = 10l; lung l2 = 0x7ffffffffffffffL; // valoarea maximă a tipului long

Literale cu virgulă mobilă

Există două forme de notație pentru caracterele în virgulă mobilă: standard și exponențială:

// forma standard dublu d1 = 0.; // echivalent cu.0 sau 0.0; dublu d2 = 0,125; // formă exponențială - folosește simbolul „e” sau „E” // după ce este puterea lui 10 cu care numărul dat trebuie înmulțit dublu d3 = 125E+10; // dacă gradul este pozitiv, „+” poate fi omis dublu d4 = 1,25e-10;
Toate literalele cu virgulă mobilă sunt atribuite implicit un tip dubla. Prin urmare, pentru a crea un like literal pluti, trebuie să specificați litera „ după literal f" sau " F„. De asemenea, puteți adăuga litera „ la literale d" sau " D", indicând că este un literal de tip dublu, dar de ce?

dublu d1 = 0,125; float f2 = 0,125f;
Puteți utiliza literale hexazecimale în virgulă mobilă, de exemplu:

// P - ordine binară, care indică puterea lui 2 cu care numărul dat trebuie înmulțit dublu d = 0x10.P10d; // desigur, este posibil fără „d” float f = 0x20.P10f;
Pentru a facilita citirea literalelor lungi, versiunea 7 a limbii a adăugat capacitatea de a folosi caracterul „_” în interiorul unui literal:

// puteți face orice combinație folosind orice număr de caractere "_" int phone = 111__111__111; int bin = 0b1000_1000_1000; dolari duble = 23_000.450__500; // nu este permisă utilizarea caracterului „_” la sfârșitul sau începutul unui literal și, de asemenea, nu este posibilă separarea „0x” și „0b”

Litere de caractere

Literele de caractere sunt cuprinse între ghilimele simple. Toate caracterele afișate pot fi setate în acest fel. Dacă un caracter nu poate fi introdus direct, utilizați secvențe de evacuare care încep cu caracterul " \ „. Deși toate aceste secvențe pot fi înlocuite cu cele corespunzătoare Unicode cod. De asemenea, puteți crea un caracter literal folosind forme octale ("\xxx") și hexazecimale ("\uxxxx").

Car h = "a"; // forma standard char a = "\001"; // formă octală char c = "\u0001"; // formă hexazecimală
Există, de asemenea, șiruri literale. Informații despre ele pot fi obținute.

Literale booleene

Cu operatori logici totul este simplu. Există doar două literale booleene:

Boolean da = adevărat; // boolean adevărat nu = fals; // minciună
Literale booleene pot fi alocate numai variabilelor de tip boolean. De asemenea, este important să înțelegeți asta fals nu este egal 0 , A Adevărat nu este egal 1 . Convertiți variabila de tip boolean Nu va funcționa cu alte tipuri primitive.

Operațiuni

Peste tipurile integrale

• operatori de comparare ( > , < , >= , <= ) și egalitate ( == , != )
• operatori unari ( + , - )
• multiplicativ ( * , / , % ) și aditiv ( + , - ) operatori
• spor ( ++ ) și scăderea ( -- ) în forme de prefix și postfix
• simbolic ( >> , << ) și nesemnată ( >>> ) operatori în schimburi
• operatori pe biți ( ~ , & , ^ , | )
• operator conditionat ( ? : )
• operator de turnare

De mai sus Punctul de plutire tipuri

Puteți efectua toate aceleași operații pe numere în virgulă mobilă ca și pe numere întregi, cu excepția operatorilor biți și de deplasare.

Tipul boolean deasupra

• operatori de egalitate ( == Și != )
• operatori logici ( ! ,& , | , ^ )
• operatori logici condiționali ( && , || )
• operator conditionat ( ? : )

Conversie

Există trei tipuri de transformări:

• lărgirea transformării ( lărgirea)
• transformare de restrângere ( îngustarea)
• lărgire + îngustare (conversie octet La char, la început octet schimba in int, și apoi int- V char)

Transformare în expansiune

Dacă ambele tipuri sunt compatibile și lungimea tipului țintă este mai mare decât lungimea tipului sursă, se efectuează o conversie de extindere (de exemplu octet convertit la int). Următorul tabel prezintă toate transformările de expansiune posibile. Tipurile sunt marcate în curs, conversia la care poate duce la pierderea datelor.

Transformare de îngustare

Cu o conversie care se îngustează, informațiile despre mărimea totală a unei valori numerice se pot pierde, iar precizia și intervalul se pot pierde. Toate transformările posibile de îngustare sunt prezentate în tabel:

mic de statura	octet, caracter
char	octet, scurt
int	octet, scurt, char
lung	int, octet, scurt, char
pluti	lung, int, octet, scurt, char
dubla	float, long, int, byte, short, char

Pentru a converti două tipuri incompatibile, trebuie să utilizați un cast ( turnare). Dacă valorile tipului întreg sursă sunt mai mari decât intervalul permis de valori ale tipului țintă, atunci acesta va fi redus la rezultatul divizării modulo cu intervalul tipului țintă. Dacă o valoare a unui tip în virgulă mobilă este convertită într-o valoare a unui tip întreg, atunci are loc trunchierea (partea fracțională este eliminată).

Octet a = (octet)128; // - 128 octet b = (octet)42; // ghosting-ul este posibil, dar în acest caz nu este necesar int i1 = (int)1e20f; // 2147483647 int i2 = (int)Float.NaN; // 0 float f1 = (float)-1e100; // -Infinity float f2 = (float)1e-50; // 0,0

Promovare

Atunci când precizia necesară a unei valori intermediare este în afara intervalului permis de valori pentru oricare dintre operanzii din expresie, se utilizează promovarea automată a tipului.

Int a = 100; float b = 50,0f; dublu c = 50,0; rezultat dublu = a - b + c; // 100,0 // de fapt: rezultat = (dublu)((float)a - b) + c;
Regulile de promovare sunt bine demonstrate de următoarea diagramă:

Cursuri de wrapper

Pentru a reprezenta tipurile primitive ca obiecte, au fost create clase de wrapper ( clase de ambalare). Ce beneficii ne oferă cursurile de wrapper?

• capacitatea de a utiliza obiecte din clasele wrapper ca parametri ai metodelor sau ca parametri generici
• capacitatea de a utiliza constante care sunt responsabile pentru limitele tipului de date corespunzător ( MIN_VALUEȘi MAX_VALUE)
• capacitatea de a folosi metode de conversie în alte tipuri primitive, conversie între sisteme de numere

Există opt clase de wrapper, câte una pentru fiecare tip primitiv:
Aproape toate clasele (cu excepția booleanȘi Caracter) sunt moștenite dintr-o clasă abstractă Numărși sunt comparabile (implementați interfața Comparabil). Ierarhia este cam așa:

// există mai multe moduri de a crea un întreg i1 = new Integer("10"); Integer i2 = new Integer(10); Integer i3 = Integer.valueOf(10); Integer i4 = Integer.valueOf("10", 10); // se poate specifica sistemul de numere, numai pentru wrapper-urile de tipuri primitive întregi Caracter c1 = new Character("c"); // există o singură cale // obținem valori ale tipurilor primitive int i5 = i1.intValue(); char c2 = c1.charValue();

Ambalare și despachetare automată

JDK 5 a introdus două caracteristici importante:

• Ambalare automată ( autoboxing) este procesul de încapsulare automată a unui tip primitiv într-o clasă wrapper corespunzătoare. Nu este nevoie să creați în mod explicit un obiect.
• Despachetarea ( despachetarea) este procesul de extragere automată a unui tip primitiv din clasa wrapper corespunzătoare. Nu este nevoie să apelați explicit o metodă pentru a obține un tip primitiv.

Aceste instrumente facilitează crearea de obiecte, obținerea de tipuri primitive și simplifică lucrul cu colecțiile.

Public static void main(String... s) ( Integer i1 = 10; // autoboxing - Integer.valueOf(10) int i2 = i1; // unboxing - i1.intValue() method(10); // autoboxing la obiect al clasei Integer - Integer.valueOf(10) ++i1 // unboxing - i1.intValue(), autoboxing - Integer.valueOf(i1.intValue() + 1) ) private static int method(Integer i) ( return i ; // despachetarea obiectului acceptat ca parametru - i.intValue() )

Câteva metode utile

Număr întreg i1 = 128; i1.compareTo(5); // 1, adică i.intValue() > Integer.valueOf(5) Integer.decode("0xabc"); // nu funcționează cu literalele binare Integer.parseInt("10", 3); // funcționează cu orice sistem de numere // metoda de conversie i1.byteValue(); // (byte)i.intValue() // metode de verificare Float f = 20,5f; Boolean badFloat = f.isInfinite() || f.isNaN(); // fals, autoboxing boolean // convertesc în șir f.toString();
Vă mulțumim pentru atenție. Toate completările, clarificările și criticile sunt binevenite.

Java este un limbaj orientat pe obiecte, care se caracterizează prin abstracție, dar pentru sarcini aplicate trebuie întotdeauna să operați cu parametri cunoscuți. În programare, ele sunt numite variabile. Cum este o variabilă java diferită de un obiect?

Este simplu - o variabilă este o celulă de memorie în care este stocată valoarea sa. Orice acțiune este lucru direct cu această zonă a memoriei. Un obiect este o cantitate mai complexă. Ocupă un anumit interval de memorie, interacțiunea se realizează printr-o anumită funcție de transfer (metode), exprimată în parametrii obiectului.
În acest articol vom vorbi în mod specific despre variabile, aici acesta nu este deloc un concept banal.

Variabilele Java sunt declarate astfel:

tip_date nume_variabilă;

Aici, atunci când declarați, puteți atribui o valoare.

tip_date nume_variabilă = valoare_variabilă;

De asemenea, puteți declara mai multe variabile în același timp, pur și simplu listându-le separate prin virgule.

tip_date nume_variabilă1, nume_variabilă2...;

Clasificarea după afiliere

Există patru tipuri de variabile Java:

• variabile de instanta;
• variabile de clasă;
• variabile locale;
• parametrii.

Să avem mai multe obiecte din aceeași clasă Automobile(). Pe lângă parametrii comuni, ei au unici unici, să zicem, viteza maximă maxSpeed(). Ele pot fi inițiate în corpul programului sau pot fi stocate în câmpuri de clasă non-statice (declarate fără a adăuga cuvântul static). Astfel, fiecare instanță va avea un parametru individual care nu depinde de vitezele altor obiecte.

Automobil de clasă publică (nume șir public; Viteză maximă dublă privată; Automobil public (Nume auto șir) (nume = Nume auto; ))

O variabilă de clasă sau o variabilă statică java, pe de altă parte, este declarată exclusiv folosind cuvântul static. În acest caz, valoarea sa va fi aceeași pentru toate cazurile. În cazul aceleiași mașini, introduceți parametrul gearsNum – numărul de viteze. Pentru toate cazurile va fi 6.

Modificatorul final opțional vă permite să atribuiți o valoare unei variabile o singură dată. Compilatorul impune acest lucru.

Automobil de clasă publică (model String public; Viteză maximă dublă privată; Viteză maximă public static final int gearsNum = 6;)

Variabilele și metodele locale în java sunt invariabil legate. Acestea din urmă conțin adesea parametri auxiliari care nu sunt necesari în codul suplimentar. Nu există o formă specială de inițializare pentru declararea unei variabile locale, sfera acțiunii acesteia depinde doar de locația declarației. În acest caz - în acolade în interiorul metodei. La ieșirea din el, variabila va fi distrusă, așa că nu va mai fi posibil să o accesați.

Un caz extrem de variabile locale sunt parametrii. În special, exemplul clasic de „Hello, World!”:

clasa HelloWorld ( public static void main ( String args ) ( System . out . println ( „Hello World!” ); ) )

Există doi parametri aici deodată. Primul este de fapt „Hello, World!”, al doilea este argumentul șirului de argumente în principal.

Clasificare după vizibilitate

Pe baza celor descrise mai sus, mai poate fi urmărită o diviziune - în funcție de vizibilitatea variabilelor. Sunt 4 grupe:

• Public Acest modificator de variabilă este disponibil pentru toate clasele și obiectele programului. Declarat folosind cuvântul cheie public de la începutul rândului.
• Protejat. Domeniul de aplicare al variabilelor java în acest caz este limitat la pachetul și subclasele curente. Se declară în același mod - cu cuvântul cheie protejat.
• Pachet protejat. Modificator pentru variabile disponibil numai în pachet. Nu sunt necesare declarații; absența cuvintelor cheie indică faptul că pachetul este protejat.
• Privat. Variabile care sunt accesibile exclusiv în cadrul unei clase. În acest caz, puteți determina tipul unei variabile folosind cuvântul cheie privat.

În ciuda faptului că elementele private sunt disponibile în cadrul clasei, întrebarea este: „cum se accesează variabilele private java?” mai are un raspuns. Pentru a putea modifica valoarea unui parametru privat din exterior, este suficient să creezi o metodă publică în interiorul aceleiași clase. De exemplu astfel:

clasa Drive ( private int gears; public void setGears ( int val ) ( viteze = val; ) )

În acest fel, dacă este necesar, puteți modifica cu ușurință valoarea unei variabile private.

Pointerii sunt o altă opțiune pentru variabilele globale. Amintiți-vă că folosim următoarea notație pentru a instanția un obiect:

obiect_clasa pointer_name = noua clasa_obiect;

Astfel de variabile sunt numite variabile de referință.

Java este un limbaj puternic tipizat. Aceasta înseamnă că fiecare variabilă și fiecare expresie Java trebuie să aibă tip, definit deja în etapa de compilare. Fiecare tip are un interval specific de valori și definește setul de operațiuni aplicabile acestuia și semnificația acestora. Tastarea puternică ajută la detectarea erorilor dintr-un program în timpul compilării.

Toate tipurile din Java sunt împărțite în primitivȘi referinţă. Tipul logic este primitiv boolean, tipuri numerice întregi octet, mic de statura, int, lung, charși tipurile numerice flotante plutiȘi dubla. Tipurile de referință includ clase, interfețeȘi matrice. Există și o specială tip nul.

Un obiectîn Java este fie o instanță creată dinamic a unei clase, fie o matrice creată dinamic. Valorile unui tip de referință sunt referințe la obiecte. Toate obiectele, inclusiv matricele, moștenesc metode din clasa Object. Șirurile sunt reprezentate de obiecte din clasa String.

Variabil acesta este un depozit de date numit de un anumit tip. Mai exact vorbind:

• O variabilă de tip primitiv conține întotdeauna o valoare de tipul respectiv.
• O variabilă de clasă poate conține fie valoarea nul(referință nulă) sau o referire la un obiect din această clasă sau descendentul acesteia.
• O variabilă de tip interfață poate conține fie o referință nulă, fie o referință la un obiect din orice clasă care implementează această interfață.
• O variabilă de tip „array of T”, unde T este un tip primitiv, poate conține fie o referință nulă, fie o referință la un obiect de tip „array of T”.
• O variabilă de tip „matrice de T”, unde T este un tip de referință, poate conține fie o referință nulă, fie o referință la o matrice constând din date care sunt compatibile cu T.
• O variabilă de tip Object poate conține fie o referință nulă, fie o referință la orice obiect.

5.3.2. Tipuri primitive

5.3.2.1. Tastați boolean

Tip boolean constă din două constante logice: Adevărat(adevărat) și fals(minciună). O valoare booleană poate fi turnată la tip boolean, nu există alte modele implicite pentru acest tip în Java. O valoare booleană poate fi convertită într-un șir folosind regula implicită de conversie a șirurilor.

Exemplu de declarație de variabilă booleană:

Amintiți-vă că orice număr de referințe pot indica un singur obiect. Dacă două variabile indică același obiect, atunci starea obiectului poate fi schimbată prin prima referință și apoi citită prin a doua.

5.3.3.2. Clasa de obiecte

Clasa standard Object este strămoșul tuturor celorlalte clase Java care moștenesc metodele sale. Aceste metode sunt descrise în detaliu în Cap. 5.14.

5.3.3.3. Clasa de șiruri

Instanțele clasei String sunt șiruri de text, adică șiruri de caractere Unicode. Un obiect din clasa String are o valoare constantă (imuabilă). Constantele String sunt referințe la instanțe ale clasei String.

Operatorul de concatenare a șirurilor de caractere creează implicit un nou obiect al clasei String.

5.3.4. Variabile

O variabilă este un depozit de date de un anumit tip, de obicei cu un nume unic. O variabilă conține întotdeauna o valoare care este compatibilă cu alocarea cu tipul său. Valoarea unei variabile este modificată printr-o operație de atribuire sau operații de creștere/decrementare a prefixului/postfixului.

5.3.4.1. Tipuri de variabile

Există șapte tipuri de variabile în Java:

1. Variabila de clasa Este un câmp de date static într-o declarație de clasă sau orice câmp de date dintr-o declarație de interfață. O variabilă de clasă este creată atunci când clasa sau interfața sa este încărcată; imediat după creare i se atribuie o valoare implicită. O variabilă de clasă este distrusă atunci când clasa sau interfața sa este descărcată (după finalizarea finalizării ei).
2. Variabila de implementare Acesta este un câmp de date dintr-o declarație de clasă care nu este static. O astfel de variabilă este creată și i se primește o valoare implicită atunci când este creată o instanță a clasei date sau a unei clase care este descendentă a acesteia. O variabilă de implementare este distrusă atunci când instanța de clasă corespunzătoare este colectată de gunoi (după finalizarea finalizării acesteia).
3. Elemente de matrice acestea sunt variabile fără nume care sunt create și cărora li se primește o valoare implicită atunci când matricea este creată. Aceste variabile sunt distruse atunci când matricea este eliminată prin colectarea gunoiului.
4. Opțiuni de constructor acestea sunt numele valorilor argumentului transmise constructorului. Pentru fiecare parametru din declarația constructorului, o nouă variabilă este creată de fiecare dată când acel constructor este apelat (fie explicit, fie implicit). Această variabilă i se atribuie valoarea reală a argumentului transmis constructorului atunci când este apelată. Variabila este distrusă după ce corpul constructorului încheie execuția.
5. Parametrii metodei acestea sunt numele valorilor argumentului trecute metodei. Pentru fiecare parametru dintr-o declarație de metodă, o nouă variabilă este creată de fiecare dată când acea metodă este apelată. Această variabilă i se atribuie valoarea reală a argumentului transmis metodei atunci când este apelată. Variabila este distrusă după ce corpul metodei încheie execuția.
6. Parametrul de gestionare a excepțiilor este creat ori de câte ori o parte este executată captură operator încerca. Valoarea sa devine obiectul asociat cu excepția care a avut loc. Variabila este distrusă când blocul finalizează execuția captură.
7. Variabile locale. De fiecare dată în timpul execuției programului, controlul este transferat la un nou bloc sau instrucțiune pentru, pentru fiecare declarație de variabilă din acel bloc sau instrucțiune, este creată o variabilă locală corespunzătoare. Dacă declarația conține valoarea inițială a variabilei, atunci i se atribuie această valoare. O variabilă locală este distrusă atunci când blocul sau instrucțiunea în care este declarată finalizează execuția.

Următorul exemplu conține declarații ale mai multor variabile din următoarele soiuri:

Class Point ( static int numPoints; // numPoints - variabila de clasă int x, y; // x și y - variabile de implementare int w = new int; // w - matrice de numere întregi, w - element matrice int setX(int x) ( // x - parametrul de metodă int oldx = this.x; // oldx - variabilă locală this.x = x; return oldx; ) )

5.3.4.2. Valorile inițiale ale variabilelor

Înainte ca o variabilă să poată fi accesată, trebuie să i se atribuie o valoare. în care

• Fiecărei variabile de clasă, variabilă de implementare și fiecărui element de matrice i se atribuie o valoare implicită la creare, după cum urmează:
• variabile de tip octet, mic de statura, int, lung obțineți valoarea 0 a tipului corespunzător;
• variabile de tip plutiȘi dubla obțineți valoarea +0 a tipului corespunzător;
• variabile de tip char obțineți valoarea „\u0000”;
• variabile de tip boolean obține valoarea fals;
• variabilele de tip referință primesc o valoare nul;
• Fiecărei metode și parametru constructor i se atribuie valoarea reală a argumentului corespunzător, determinată în momentul în care metoda sau constructorul a fost apelat.
• Parametrul de gestionare a excepțiilor este inițializat de obiectul corespunzător.
• O variabilă locală trebuie să primească o valoare înainte de a putea fi utilizată, fie prin inițializare într-o declarație, fie de către un operator de atribuire.

Am folosit deja variabile în exemplele noastre, deoarece fără ele ar fi foarte dificil să explicăm tipurile de date primitive în Java, dar nu ne-am concentrat asupra acestui lucru, deoarece acesta nu este un subiect mare sau complex. Nu am vorbit încă despre constante în Java. Și acum a sosit momentul! Ei bine, hai să mergem!

O variabilă este componenta principală a stocării datelor într-un program Java. O variabilă este definită printr-o combinație de un identificator, un tip și o valoare inițială opțională. In afara de asta, toate variabilele au un domeniu de aplicare, care specifică vizibilitatea lor față de alte obiecte și durata lor de viață.

În Java, toate variabilele trebuie declarate înainte de a putea fi utilizate. Puteți declara o variabilă oriunde în program. Forma de bază a declarației variabilelor arată astfel:

tip identificator[=valoare][, identificator[=valoare] ...] ;

• tip este unul dintre tipurile Java elementare sau numele unei clase sau al unei interfețe.
• identificator este numele variabilei

Puteți atribui o valoare inițială unei variabile (o inițializați) specificând un semn egal și o valoare. Rețineți că expresia de inițializare trebuie să returneze o valoare de același tip (sau compatibil) cu cea specificată pentru variabilă. Puteți utiliza o listă separată prin virgulă pentru a declara mai multe variabile de un tip specificat.

Mai jos sunt prezentate mai multe exemple de declarare a variabilelor de diferite tipuri. Rețineți că unele declarații efectuează inițializarea variabilelor.

A , b , c ; // declararea a trei variabile de tip int: a, b și c
int d = 3 , e , f = 5 ; // declararea a încă trei variabile de tip int cuinițializarea lui d și f
octet z = 22 ; // inițializați variabila z
dubla pi = 3.14159 ; // declararea valorii aproximative a variabileipi
char X = "X"; // atribuirea valorii „x” variabilei x

Nu puteți utiliza o variabilă neinițializată în expresii, așa că variabila trebuie inițializată fie atunci când o declarați, fie înainte de a o folosi în orice expresie. De exemplu, fragmentul de cod de mai jos va fi recunoscut ca eronat deja în etapa de compilare.

zile de vacanta ;
Sistem . afară . println( zile de vacanta) ; // EROARE! Variabila neinițializată

Am discutat deja despre cum să denumim corect variabilele.

Inițializarea dinamică a variabilelor

Java permite ca variabilele să fie inițializate dinamic folosind orice expresie care este valabilă în momentul în care variabila este declarată. De exemplu:

A = 3.0 , b = 4.0 ;
// inițializarea dinamică a variabilei c
dubla c = Matematică . sqrt ( A * A + b * b) ;
Sistem . afară . println( „Ipotenuza este egală cu” + c) ;

Domeniul de aplicare și durata de viață a variabilelor

Aceasta este o problemă destul de importantă și trebuie luată în considerare mai detaliat. Și pentru a face acest lucru, trebuie mai întâi să luăm în considerare utilizarea blocurilor de cod în Java.

Utilizarea blocurilor de cod

Java vă permite să grupați una sau mai multe instrucțiuni în blocuri de cod, numite și blocuri de cod. Acest lucru se face prin includerea declarațiilor între acolade. Odată creat, un bloc de cod devine un modul logic care poate fi folosit în aceleași locuri ca o singură instrucțiune. De exemplu, un bloc poate servi drept țintă a instrucțiunilor if și for. Luați în considerare următoarea afirmație if:

( X< y ) { // începutul blocului
x = y;
y= 0 ;
} // sfârşitul blocului

În acest exemplu, dacă x este mai mic decât y, programul va executa ambele instrucțiuni în interiorul blocului. Astfel, ambele instrucțiuni din interiorul blocului formează un modul logic, iar executarea unei instrucțiuni este imposibilă fără executarea simultană a celei de-a doua. Ideea de bază a acestei abordări este că ori de câte ori două sau mai multe declarații trebuie să fie legate logic, acest lucru se realizează prin crearea unui bloc.

Java permite ca variabilele să fie declarate în interiorul oricărui bloc. Un bloc începe cu o acoladă care se deschide și se termină cu o acoladă de închidere. Blocul definește domeniul de aplicare al definiției. Astfel, prin deschiderea fiecărui bloc nou, creăm unul nou domeniul de aplicare. Domeniul de aplicare specifică ce obiecte sunt vizibile pentru alte părți ale programului. De asemenea, determină durata de viață a acestor obiecte.

Regula de bază de reținut este că variabilele declarate în interiorul unui domeniu nu sunt vizibile (adică, inaccesibile) pentru a codifica în afara acestui domeniu. Astfel, declararea unei variabile într-un domeniu o menține localizată și protejată de accesul și/sau modificarea neautorizată.

Scopurile pot fi imbricate. De exemplu, de fiecare dată când creăm un bloc de cod, creăm un domeniu nou, imbricat. În aceste cazuri sfera exterioară cuprinde sfera interioară. Înseamnă că obiectele declarate în domeniul exterior vor fi vizibile pentru codul definit în domeniul interior. Cu toate acestea, inversul nu este adevărat. Obiectele care sunt declarate în sfera interioară nu vor fi vizibile în afara acestuia. Următorul exemplu poate ilustra acest lucru:

Variabil y, definită în sfera sa delimitată de acolade, este accesibilă numai în cadrul acestuia. Dincolo de limitele sale, variabila y nu mai este disponibilă, iar variabila X disponibile și în domeniul de aplicare al variabilei y.

Un alt lucru important de reținut este că variabilele sunt create atunci când intră în domeniul lor și sunt distruse când ies din el.

Aceasta înseamnă că variabila își va pierde valoarea de îndată ce iese din domeniul de aplicare.

Deși blocurile pot fi imbricate, Într-un bloc interior nu puteți declara variabile cu același nume ca în domeniul exterior.

Codul prezentat în exemplul din stânga va genera o eroare de compilare.

Astfel de trucuri, posibile în C și C++, nu funcționează în Java.

Constante în Java

În Java, cuvântul cheie folosit pentru a desemna constante este final. Cuvânt cheie finalînseamnă că puteți atribui o valoare unei anumite variabile o singură dată, după care nu poate fi schimbată. Este recomandat să folosiți majuscule pentru denumirea constantelor, deși acest lucru nu este necesar, dar acest stil contribuie la lizibilitatea codului. Exemplu de declarație constantă:

dubla CM_PER_INCH = 2.54 ;

O constantă nu trebuie inițializată când este declarată, ci trebuie inițializată înainte de a fi utilizată în orice expresie, la fel ca o variabilă, dar acest lucru poate fi făcut o singură dată. Mai mult, acest lucru se poate face și în operatori condiționali, adică inițializați valoarea unei constante în funcție de orice condiții. Compilatorul va verifica toate opțiunile posibile, iar dacă există cel puțin una în care constanta nu poate fi inițializată, va arunca o eroare.

Tipurile numerice sunt tipuri concepute pentru a stoca numere. Când faci matematică, ai de-a face cu valori numerice. Există două tipuri de tipuri numerice. Sunt numite cele concepute pentru a stoca numere fără o parte fracțională întreg tipuri și cele în care poate fi stocată partea fracțională a unui număr - real, sau tipuri cu punctul de plutire.

Nu există un concept de numere nesemnate în Java. Toate tipurile numerice din această limbă sunt semnate. De exemplu, dacă valoarea unei variabile octet este 0x80 în hexazecimal, atunci numărul este -1.

2.1.1.1. Tipuri întregi

Lipsa Java de numere nesemnate reduce numărul de tipuri întregi la jumătate. Limbajul are 4 tipuri de numere întregi, ocupând 1, 2, 4 și 8 octeți în memorie. Fiecare tip - byte, short, int și long - are propriile sale utilizări naturale.

Tipoctet

Tipul octet este un tip semnat pe 8 biți. Intervalul său este de la -128 la 127. Este cel mai potrivit pentru stocarea unui flux arbitrar de octeți descărcat din rețea sau dintr-un fișier.

octetul b;
octet c = 11;

Cu excepția cazului în care este implicată manipularea biților, tipul de octet ar trebui în general evitat. Pentru numerele întregi normale folosite ca contoare și în expresii aritmetice, tipul int este mult mai potrivit.

Tipmic de statura

Short este un tip semnat pe 16 biți. Intervalul său este de la -32768 la 32767. Este probabil cel mai rar utilizat tip în Java, deoarece este definit ca un tip în care octetul cel mai semnificativ este primul.

pantaloni scurti;
scurt t= 129;
Tipint

Tipul int reprezintă numere întregi semnate pe 32 de biți. Intervalul de valori valide pentru acest tip este de la -2147483648 la 2147483647. Cea mai obișnuită utilizare a acestui tip de date este stocarea numerelor întregi obișnuite cu valori de până la două miliarde. Acest tip este excelent pentru utilizarea cu matrice și contoare. În următorii ani, acest tip se va potrivi perfect cu cuvintele mașinii nu numai ale procesoarelor pe 32 de biți, ci și ale procesoarelor pe 64 de biți cu suport pentru pipelining rapid pentru a executa codul pe 32 de biți în modul de compatibilitate. Ori de câte ori variabile de tip octet, short, int și literali întregi apar în aceeași expresie, tipul întregii expresii este turnat la int înainte de finalizarea evaluării.

int j = 1000;
Tiplung

Tipul lung este proiectat pentru a reprezenta numere semnate pe 64 de biți. Gama sa de valori acceptabile este suficient de mare chiar și pentru sarcini precum numărarea numărului de atomi din univers,

lungm;
lungn = 123;

Nu este nevoie să se identifice adâncimea de biți tip întreg cu cantitatea de memorie pe care o ocupă. Codul Java care rulează poate folosi orice cantitate de memorie pe care o consideră potrivită pentru variabilele dvs., atâta timp cât comportamentul acestora se potrivește cu comportamentul tipurilor pe care le definiți.

Tabelul 2.1. Tabel cu adâncimi de biți și intervale acceptabile pentru diferite tipuri de numere întregi

		Adâncime de biți	Gamă
			-9, 223, 372,036, 854, 775, 808 ... 9, 223, 372, 036, 854, 775, 807
			-2, 147, 483, 648 .... 2, 147, 483, 647
			-32,768 .... 32, 767
			-128 ... 127

2.1.1.2. Numere în virgulă mobilă

Numerele în virgulă mobilă, adesea numite numere reale în alte limbi, sunt folosite în calcule care necesită utilizarea unei fracții. Java implementează un set standard (IEEE-754) de tipuri pentru numere în virgulă mobilă - float și double - și operatori pentru lucrul cu acestea.

Tabelul 2.2. Caracteristicile tipurilor de numere în virgulă mobilă

		Adâncime de biți	Gamă
			1.7e-308....1.7e+ 308
			3.4e-038....3.4e+ 038

Tippluti

În variabile cu normal, sau precizie unică, declarați folosind cuvântul cheie float, 32 de biți sunt utilizați pentru a stoca valoarea reală,

plutitor f;
float f2 = 3,14;
Tipdubla

Când precizie dubla, specificat folosind cuvântul cheie dublu, 64 de biți sunt utilizați pentru a stoca valori. Toate transcendental funcții matematice precum sin, cos, sqrt returnează un rezultat dublu,

dublad;
dublu pi = 3,14159265358979323846;