|
== Հիմանական գաղափարները ==
=== Պրիմիտիվ տիպերը ===
Java լեզվում կան ընդամենը 8 պրիմիտիվ տիպեր՝ boolean, byte, char, short, int, long, float, double. Գոյություն ունի նաև 9-րդ տիպ՝ void, բայց այս տիպի փոփոխականներ և դաշտեր հայտարարելը կոդում արգելված է:է։ Այ օգտագործվում է կլասսներում և մեթոդներում, որպես ոչինչ չվերադարձնող արժեք:արժեք։
Տիպերի երկարությունը և արժեքների միջակայքը որոշվում են ստանդարտով, ոչ թե իրագործմամբ:իրագործմամբ։ Char-ը երկու բայթ է զբաղեցնում, լոկալիզացիայի հարմարության համար:համար։ Երբ մշակվում էր ստանդարտը, արդեն գոյություն ուներ Unicode-32-ը, բայց ոչ Unicode-64-ը:ը։ Քանի որ չկար մեկ բայթանոց փոփոխական, ավելացրեցին նոր տիպ՝ byte, և ի տարբերություն ուրիշ ծրագրավորման լեզուների, այն առանց նշանի չէ:չէ։ Float և double տիպերը կարող են ունենալ հատուկ արժեքներ ՝ <math>+\infty</math>, <math>-\infty</math> и «ոչ թիվ» ([[NaN]]): Double տեսակի համար դրանք ցույց են տրվում <code>Double.POSITIVE_INFINITY</code>, <code>Double.NEGATIVE_INFINITY</code>, <code>Double.NaN</code>; Float տիպի համար նմանապես, միայն Double-ի տեղը պետք է դնել Float: Առավելագույն և նվազագույն արժեքները նույնպես ստանդարտավորված են:են։
{| class="wikitable"
|}
Այսպիսի խիստ ստանդարտավորումը անհրաժեշտ էր, որպեսզի լեզուն լիներ պլատֆորմ-անկախ, որը Java-ի գաղափարական գլխավոր պահանջներից մեկն էր:էր։ Այնուամենայնիվ մի մի փոքր պրոբլեմ, կապված պլատֆորմային անկախության հետ մնաց:մնաց։ Որոշ պրոցեսսորներ միջանկյալ արժեքները պահելու համար օգտագործում են 10 բայթանոց ռեգիստրներ կամ այլ միջոցներով են լավացնում հաշվարկների ճշտությունը:ճշտությունը։ Որպեսզի Java-ն առավելագույն համապատասխանություն ունենար տարբեր համակարգերի միջև, տարբեր տեսակներում հաշվարկնեի բարձրացման միջոցները արգելվեցին:արգելվեցին։ Սակայն դա բերում էր արագագործության նվազեցմանը:նվազեցմանը։ Բազմաթիվ բողոքներից հետո այդ արգելքը վերացրեցին, բայց ավելացրին <code>strictfp</code> ծառայողական բառը, որը արգելում էր ճշտության բարձրացումը:բարձրացումը։
=== Մաթեմատիկական գործողությունների ժամանակ փոխակերպումները ===
# Հակառակ դեպքում, եթե օպերանդներից մեկը ունի float տիպ, ապա մնացած օպերանդները բերվում են float-ի
# Հակառակ դեպքում, եթե օպերանդներից մեկը ունի long տիպ, ապա մնացած օպերանդները բերվում են long-ի
# Հակառակ դեպքում բոլոր օպերանդները բերվում են int տիպի:տիպի։
Այս ոչ ակընհայտ փոխակերպումնրը ամբողջությամբ համապատասխանում են C++ -ում գոյություն ունեցող փոխակերպումներին:փոխակերպումներին։
=== Օբյեկտային փոփոխականներ, օբյեկտներ, ցուցիչներ և հղումներ ===
Java-ում կան միայն դինամիկ ստեղծվող օբյեկտներ:օբյեկտներ։ Ընդ որում օբյեկտային փոփոխականները և օբյեկտները բացարձակապես տարբեր բաներ են:են։ Օբյեկտային փոփոխականները հղումներ են, այսինքն ոչ ակնհայտ ցուցիչներ դինամիկ ստեղծվող օբյեկտների վրա:վրա։ Դա երևում լեզվի սինտակսիսում:սինտակսիսում։ Այպես, չի կարելի գրել՝
<source lang="java">
double a[10][20];
Foo b(30);
</source>
այլ պետք է:է։
<source lang="java">
double[][] a = new double[10][20];
Foo b = new Foo(30);
</source>
Վերագրումների, փոխանցումներ և համեմատման ժամանակ օբյեկտային փոփոխականները իրենց պահում են ինչպես ցուցիչներ, այսինքն գործողությունները կատարվում են փոփոխականների հասցեների հետ:հետ։ Նաև այս տիպի փոփոխականներին դիմելուս որևէ հատուկ օպերատոր չի կանչվում, ամեն ինչ կատարվում է այնպես, ասես օբյեկտային փոփոխականը հենց օբյեկտ է:է։
Օբյեկտային են համարվում բոլոր տեսակի փոփոխականները, բացի պրիմիտիվ տիպերի փոփոխականներից:փոփոխականներից։ Java-ում ակնհայտ ցուցիչներ չկան:չկան։ Ի տարբերություն C, C++ և այլ լեզուների, հղումների օգտագործումը java-ում ունի բարձր անվտագույան շեմ, քանի որ դրված են խիստ սահմանափակումներ դրանց օգտագործման վրա՝
* Չի կարելի փոխակերպել պրիմիտիվ տեսակի օբյեկտը ցուցիչի կամ հղումի, և հակառակը:հակառակը։
* Ցուցիչների հետ չի կարելի կատարել հանրահաշվական գործողություններ (++, --, +, -):
* Տիպերի փոխակերպումը խիստ կառավարվում է:է։ Բացառությամբ զանգվածների վրա հղումներից, թույլատրված փոխակերպել հղումները միայն ժառանգվող տիպի և նրա ծնողի միջև, ընդ որում փոխակերպումը պետք է ակնհայտ ցույց տրվի:տրվի։
* Java-ում չկա հասցե վերցնելու օպերատոր (&) և օբյեկտի վերցնումը ըստ հասցեի (*):
Այսպիսով կառավարել հիշողությունը ֆիզիկական մակարդակի վրա անհնար է:է։ Նաև կարելի է ստուգել, արդյոք ցուցիչ հղված է null-ի վրա:վրա։
=== Հղումների կրկնօրինակումը ===
Քանի որ օբյեկտային փոփոխականները հղումներ են, նրանց վերագրման ժամանակ օբյեկտի կրկնօրինակում չի կատարվում:կատարվում։ Օրինակ՝
<source lang="java">
Foo foo, bar;
bar = foo;
</source>
այս դեպքում կկատարվի հասցեի կրկնօրինակումը <code>foo</code> փոփոխականից դեպի <code>bar</code> փոփոխական:փոփոխական։ Այսինքն երկու փոփոխականներն էլ հղված հիշողության նույն տիրույթի վրա, այսինքն նույն օբյեկտի վրա:վրա։ Եթե անհրաժեշտ է ստանալ հենց օբյեկտի կրկնօրինակը, ապա օգտագործում են կամ մեթոդ՝ <code>clone()</code>, կամ կրկնօրինակող կոնստրուկտոր:կոնստրուկտոր։
<code>clone()</code> մեթոդը պահանջում է, որպեսզի կլասսը իրագործի <code>Cloneable</code> ինտերֆեյսը:ինտերֆեյսը։
=== Փոփոխականների սկզբնաարժեքավորումը ===
Բոլոր փոփոխականները պահանջում են սկզբնաարժեքավորում, կամ ավտոմատ լցվում 0-ներով (0, null, զրոների զանգված): Այսպիսով անհետանում են C լեզվին բնորոշ չսկզբնաարժեքավորված փոփոխականների օգտագործումը:օգտագործումը։
=== Աղբի հավաքումը ===
Java-ում անհնար է օբյեկտի ակնհայտ ջնջումը հիշողությունից, դրա փոխարեն իրագործված է աղբի հավաքումը:հավաքումը։ Ավանդական միջոցը, որով հասկացվում է աղբահավաքին, որ պետք է ազատել հիշողությունը, հանդիսանում է փոփականին null վերագրելը:վերագրելը։ Դա չի նշանակում, որ այդպիսի օբյեկտը միանգամից կջնգվի, բայց այն տալիս է երաշխիք, որ այն կջնջվի ապագայում:ապագայում։ Պետք է հաշվի առնել, որ օբյկտը չի ջնջվի, քանի դեռ նրա վրա հղված է թեկուզ մեկ ցուցիչ:ցուցիչ։
== Ծանոթագրություններ ==
| 