Ջավա

**Java**, պլատֆորմից անկախ, ընդհանուր նշանակության ծրագրավորման լեզու է, որը զուգահեռ, կլասսների վրա հիմնված, օբյեկտ – կողմնորոշված և հատուկ մշակված է, որպեսզի ունենա ինչքան հնարավոր է շատ իրագործումներ։ Այն նախատեսված է, որպեսզի «Գրվի մեկ անգամ, աշխատի ամենուր» ("Write once, run anywhere", WORA), որը նշանակում է, կոմպիլացված Java կոդը կարող է կատարվել բոլոր Java աջակցող պլատֆորմների վրա առանց նորից կոմպիլացվելու։ Java ծրագրերը կոմպիլացվում են բայթկոդ–ի, որոնք կարող են իրագործվել ցանկացած Java վիրտուալ մեքենայի (JVM) վրա, անկախ համակարգչային ճարտարապետությունից։ Մինչ 2015 թվականը Java–ն հանդիսացել է ամենահայտնի օգտագործվող ծրագրավորման լեզուներից մեկը, մասնավորապես կլիենտ–սերվեր ծրագրերի համար, մոտ 9 միլլիոն գրանցված ծրագրավորողներով։ Java–ն ստեղծվել է Ջեյմս Գոսլինգի կողմից Sun Microsystems–ում (որը հետագայում Oracle կազմակերպությունը գնեց) և ներկայացվել է 1995 թվականին որպես Java պլատֆորմի հիմնական մաս։ Այն ծրագրավորվել է C++–ի միջոցով։ Լեզվի սինտաքսիսը մեծ մասամբ համընկնում է C և C++ լեզուների հետ, բայց այն ունի ավելի քիչ ցածր – մակարդակի միջոցներ, քան նրանցից յուրաքանչյուրը։ Ի տարբերություն C++–ի Java–ն ունի նաև ինտեգրված լայն կլասսների գրադարան (օրինակ բազմապրոցեսային, համացանց, ֆայլային և այլն), որոնք ի շնորհիվ պլատֆորմային անկախության աշխատում են տարատեսակ օպերացիոն համակարգերում։ Որպեսզի Java լեզվով ստեղծված ծրագիրը կարողանա աշխատել ձեր համակարգչում կամ շարժական էլեկտրոնային սարքում, դուք պետք է ունենաք համապատասխան միջավայր՝ JRE (Java Runtime Environment)։ Օրիգինալ և ներդրված Java կոմպիլյատորների, վիրտուալ մեքենաների և կլասսների գրադարանի իրագործումը ի սկզբանե թողարկվել է Sun–ի պատենտավորված լիցենզիայի տակ։ 2007 թվականի մայիսի դրությամբ, Sun–ը Java տեխնոլոգիայի մեծ մասի լիցենզիան փոխել է GNU General Public License:

## Պատմություն
Ծրագրավորման մեջ C++ ծրագրավորման լեզվի հեղափոխությունից հետո քչերն էին սպասում ավելի բեկումնային հեղափոխության, որը կատարել է Java–ն։ Կանխատեսելով շարժական էլեկտրոնային սարքերի լայն տարածումը, Sun–ը 1991–ին հիմնեց այդ ուղղությամբ զբաղվող ներքին կորպորատիվ հետազոտական նախագիծ, որը ստացավ *Green* անվանումը։ Նախագծի արդյունքում ստեղծվեց C/C++ վրա հիմնված ծրագրավորման լեզու, որին նրա ստեղծող Ջեյմս Գոսլինգը անվանեց Oak (կաղնի) ի պատիվ այն կաղնու, որը երևում էր նրա աշխատասենյակից։ Հետագայում հայտնաբերվեց, որ արդեն գոյություն ունի ծրագրավորման լեզու Oak անունով և Sun–ը նրան տվեց նոր անուն Java, որով էլ այն հետագայում ներկայացվեց հասարակությանը։ Այն անվանվել է ի պատիվ Java սուրճի տեսակի (որը այն ժամանակ շատ տարածված էր ծրագրավորողների շրջանում), որն էլ իր հերթին իր անվանումը ստացել է Ինդոնեզական Յավա կղզուց։ Sun–ի սպասված շարժական էլեկտրոնային սարքերի արագ առաջընթացը չէր ստացվում և նրա հրապարակումը ուշանում էր։ ՄիաԺամանակ համացանցը սկսել էր մեծ զարգացում ապրել և 1993 թվականին Sun–ի աշխատակիցները սկսեցին Java–ն համալրել համացանցում դինամիկ էջեր ստեղծելու ունակություններով։ Sun Microsystems–ը ներկայացրեց Java–ի առաջին տարբերակը՝ Java 1.0 1995 թվականին։ Java–ի երկրորդ տարբերակի հետ (ներկայացվել է 1998 թվականի սեպտեմբերին որպես J2SE 1.2) նոր տարբերակները ունեին բազմաթիվ կոնֆիգուրացիաներ տարբեր տեսակի պլատֆորմների համար։ J2EE–ն ներառում տեխնոլոգիաներ սերվերների վրա աշխատող ծրագրերի համար, մինչդեռ J2ME–ն օպտիմիզացված էր շարժական պլատֆորմների համար։ Դեսկտոպ տարբերակը վերանվանվեց J2SE: 2006 թվականին մարքեթինգային նկատառուներից ելնելով Sun–ը J2–ի տարբերակները վերանվանել է Java EE, Java ME և Java SE համապատասխանաբար։ Java–ն համարվում է փաստացի ստանդարտավորված, կառավարվում է JCP–ի կողմից (JCP – Java Community Process)։ 

2006 թվականի նոյեմբերի 13–ին Sun–ը ներկայացրեց Java–ի մեծ մասը որպես FOSS (Free and open source software), համապատասխան GNU–ի Հիմանական հասարակական լիցենզիայի (GPL – General Public License) սկզբունքների։ 2007 թվականի մայիսի 8–ին Sun–ը վերջացրեց այդ պրոցեսսը։

Java ծրագրերը աշխատում են ամենուրեք, սկսած շարժական համակարգիչներից (laptops) մինչև տվյալների կենտրոններ (data centers), խաղային կոնսոլներից մինչև գիտական սուպերհամակարգիչներ։ Java–ն օգտագործվում է դինամիկ պարունակությամբ վեբ էջեր, բազմատեսակ սպառողական ծրագրեր ստեղծելու, շարժական բազմապիսի էլեկտրոնային սարքերը ծրագրերով ապահովելու համար։

## Տեխնիկական նկարագրություն
thumb|300px|Java վիրտուալ մեքենայի աշխատանքի սկզբունքը
Գոյություն ուներ հինգ հիմնական նպատակ Java լեզվի ստեղծման ժամանակ։
*Այն պետք է լինի «պարզ, օբյեկտ – կողմնորոշված, ծանոթ»
*Այն պետք է լինի «հուսալի և անվտանգ»
*Այն պետք է լինի «ճարտարապետությունից անկախ և տեղափոխելի»
*Այն պետք է կատարվի «բարձր արագությամբ»
*Այն պետք է լինի «ինտերպրետացվող և դինամիկ»
Java–ի տեղափոխելությունը պայմանավորված է նրանով, որ կոմպիլացվելուց հետո կոդն անմիջապես չի դառնում միջավայրին համապատասխան մեքենայական կոդ, այլ վերածվում է միջանկյալ կոդի, որը կոչվում է Java բայթկոդ։ Վերջինս աշխատեցվում է Java վիրտուալ մեքենայի կողմից, որն արդեն հատուկ է տվյալ միջավայրին։ Սովորաբար բոլոր օգտագործողների սարքերում էլ տեղադրված է Java Runtime Environment–ը (JRE), որն էլ ապահովում է Java վիրտուալ մեքենայի առկայությունը։ Վերջինիս աշխատանքը ներկայացված է նկարում։ Ինչպես երևում է նկարից՝ Java վիրտուալ մեքենան նախատեսված է ոչ միայն Java–ի, այլ նաև այլ ծրագրավորման լեզուների համար (նկարում ներկայացված է Python–ը)։ Սովորաբար Java–ով գրված ծրագրերը C++–ով գրվածների հեմեմատ ունեն ավելի դանդաղ աշխատելու և շատ հիշողություն օգտագործելու համբավ։ Բայց Java–ի Just–in–time (JIT) կոմպիլացայի ներդրումից հետո ծրագրերի արագագործությունը զգալիորեն մեծացել է։ JIT–ի դերն այն է, որ այն դինամիկ ձևով Java բայթկոդը թարգմանում է մեքենայական կոդի, որն էլ միանգամից կատարվում է։

Ծրագրերի կատարման այս մեթոդի առավելությունն այն է, որ բայթկոդը անկախ է օպերացիոն համակարգից և սարքավորումից, հետևաբար Java ծրագրերը կարելի է կատարել ցանկացած սարքի վրա, որի համար գոյություն ունի համապատասխան վիրտուալ մեքենա։
Մյուս կարևոր առանձնահատկությունը կայանում է ճկուն անվտանգության համակարգում, որի շրջանակներում ծրագրի կատարումը ամբողջությամբ կառավարում է վիրտուալ մեքենան։ Ցանկացած օպերացիա, որը գերազանցում է ծրագրի իրավունքները (օրինակ չթույլատրված մուտք դեպի տվյալներ կամ ուրիշ համակարգչի հետ կապ), առաջացնում են ծրագրի անահապաղ դադարեցում։ 
Վիրտուալ մեքենայի գլխավոր թերությունը ցածր արագագործությունն է համարվում։ Որոշ կատարելագործումներ բարձրացրել Java ծրագրերի կատարման արագությունը։
*Բայթկոդի հեռարձակումը մեքենայական կոդի դինամիկ ձևով ծրագրի կատարման ժամանակ (JIT տեխնոլոգիա, Just–in–time (JIT))։
*Պլատֆորմ – կողմնորոշված կոդի լայն օգտագործում (native կոդ) ստանդարտ գրադարաններում։
*Սարքերի միջոցներ, որոնք ապահովում են բայթկոդի արագացված մշակում (օրինակ Jazelle տեխնոլոգիան, որը կիրառվում է որոշ ARM պրոցեսսորների համար)։

Ըստ http://shootout.alioth.debian.org  կայքի, 7 տարբեր խնդիրների համար Java–ով գրված ծրագրի կատարման ժամանակը 1.5 – 2 անգամ ավելի շատ է, քան C\C++ –ով գրված ծրագրի համար։ Առանձին դեպքերում Java–ն ավելի արագ է, իսկ որոշ դեպքերում 7 անգամ ավելի դանդաղ։ Մյուս կողմից, այդ խնդիրներից շատերի համար հիշողության սպառումը 10 – 30 անգամ ավելի շատ է, քան C\C++ –ով գրված ծրագրերի համար։ 
Վիրտուալ մեքենայի կոնցեպցիան մեծ ազդեցություն թողեց, և շատ ծրագրավորման լեզուների համար ստեղծվեցին համապատասխան տեխնոլոգիաներ։ Այդ գաղափարը նաև իրագործվել է CLI ինֆաստրուկտուրայի մեջ, որը հանդիսանում է Microsoft ընկերության .NET պլատֆորմի հիմքը։

Java–ն օգտագործում է աղբահավաք՝ () հիշողության ավտոմատ կազմակերպման համար։ Երբ ծրագրի աշխատանքի ժամանակ որևէ օբյեկտ չի օգտագործվում, այսինքն չկա նրա վրա ցուցող որևէ հղում, ապա աղբահավաքը ջնջում է այն հիշողությունից։ Չնայած այս ավտոմատացված կազմակերպմանը՝ հիշողության արտահոսքի () վտանգը դեռ մնում է։ Օրինակ հիշողության արտահոսք կարող է լինել, եթե ոչ պետքական օբյեկտի վրա ցուցող հղում () մնա։ Ի տարբերություն C++–ի Java–ն հնարավորություն չի տալիս ցուցիչների () հետ աշխատելու, ձեռքով հիշողությունն ազատելու, խելացի ցուցիչներ () օգտագործելու և այլն։ Աղբահավաքը կարող է աշխատել ցանկացած պահի, իդեալական դեպքում այն աշխատում է համեմատաբար պարապուրդի մեջ եղած ժամանակ։ Երաշխավորված է, որ այն կաշխատի, երբ բավարար հիշողություն չլինի նոր օբյեկտ ստեղծելիս։ Սա թույլ է տալիս աղբահավաքին տեղափոխել օբյեկտների հասցեները և տալիս է տիպերի ապահովություն։ Ինչպես C++–ում և որոշ օբյեկտ–կողմնորոշված ծրագրավորման լեզեւներում, Java – ում պրիմիտիվ տիպերը(int, double, boolean, char) պահվում են դաշտերում (օբյեկտների համար), ստեկում () (ֆունկցիաների համար), այդ պատճառով դրանց համար աղբահավաք չի աշխատում։ Սա Java – ի ստեղծողների գիտակցված որոշումն է, որի նպատակն է բարձրացնել արագագործությունը։ 
Java–ն ունի մի քանի տեսակի աղբահավաքներ։ Java – ով գրված ծրագրերի 90% –ի համար Concurrent Mark–Sweep () աղբահավաքը բավարար է։ Oracle –ը մտադրված է փոխարինել այն Garbage–first collector (G1) աղբահավաքով։

## Java տարբերակների պատմությունը

### JDK 1.0

Java–ի նախագծումը սկսվել է 1990 թվականին, առաջին պաշտոնական տարբերակը թողարկվեց 1996 թվականի օգոստոսի 26–ին։

### JDK 1.1

Նշանակալի փոփոխությունները․
* AWT գրադարանի մեջ փոփոխություններ։
* Լեզվի մեջ ավելացան ներքին կլասսները։
* JavaBeans (կլասսներ, որոնք գրված են որոշ օրենքներով։ Օգտագործվում են մի քանի օբյեկտները մեկի մեջ միավորելու և ավելի հարմար փոխանցելու համար)։
* JDBC, պլատֆորմ–անկախ արդյունաբերական ստանդարտ Java ծրագրերը տարբեր տեսակի տվյալների բազաների հետ փոխազդելու համար։
* RMI, ծրագրային ինտերֆեյս հեռավոր մեթոդները կանչելու համար։

### J2SE 1.2

Այս տարբերակը խորհրդանշում էր երկրորդ սերունդը։ Java 2–ի առաջին տարբերակին տրվեց 1․2 համարը։ 2–րդ տարբերակի ի հայտ գալուց հետո, Sun Microsystems –ը սկսեց թողարկել Java–ն J2SE փաթեթի տեսքով։
Այս պահին Java 2–ը ակտիվորեն զարգանում է, մասնավորապես .Net պլատֆորմայի հետ մրցակցության պատճառով, որը վերցրել է Java–ից որոշ առանցքային առանձնահատկություններ։
Այս տարբերակում հիմնական փոփոխություններն էին։
* Swing գրադարանը, որը թույլ էր տալիս ստեղծել օգտագործողի գրաֆիկական ինտերֆեյս։
* Հավաքածու (JSR 166)։
* Policy ֆայլերը։
* Օգտվողի թվային սերտիֆիկատները։
* Accessibility գրադարանը։
* Java 2D։
* Drag–and–drop տեխնոլոգիան։
* Unicode–ի ամբողջական աջակցումը, ներառյալ արևելյան գրերը։
* Որոշ հայտնի ֆորմատների աուդիոֆայլերի աջակցումը։
* CORBA տեխնոլոգիայի ամբողջական աջակցում։
* JIT կոմպիլյատոր, արագագործության բարձրացում։

### J2SE 5.0

Java 5 սպեցիֆիկացիան թողարկվեց 2004 թվականի սեպտեմբերին։ Այս տարբերակում լեզու մտցրվեցին մի շարք կարևոր հնարավորություններ։
* Թվարկվող տեսակ (enum)։ Այն մշակված էր C++ –ի enum–ի նման, բարց ուներ մի շարք հավելյալ հնարավորություններ։
** Java–ում enum–ը լիարժեք կլասս է, այսինքն ունի կոնստրուկտոր, դաշտեր, մեթոդներ, այդ թվում թաքուն և աբստրակտ։
** Այն կարող է իրագործել ինտերֆեյսներ։
**Այն ունի ներդրված մեթոդներ, որոնք թույլ են տալիս ստանալ արժեքը ըստ անվան, վերափոխումը համարի և արժեքի միջև, տեսակի ստուգումը և այլն։
* Մետատվյաներ (metadata, annotations), թույլ է տալիս ավելացնել կոդի մեջ մետատվյալներ, որոնք չեն ազդում կոդի կատարման վրա, բայց թույլ են տալիս ստանալ տարբեր տվյալներ կոդի և նրա կատարման մասին։
* Ընդհանուր ծրագրավորման միջոցներ (generics), Eiffel–ին համարժեք տեխնոլոգիա (սկզբունքորեն տարբերվում է C++–ի կաղապարներից), որը թույլ է տալիս ստեղծել կլասսներ և մեթոդներ ցանկացած տեսակի դաշտերով և պարամետրերով։ Այս մեխանիզմով իրականացվել են Java–յի ստանդարտ գրադարանի հավաքածուների նոր տարբերակները։
* Անորոշ թվով պսրամետրեր ունեցող մեթոդներ։
* Autoboxing/Unboxing, Java–յի սկալյար տիպերի և դրանց համապատասխան տիպ–վրապպերների միջև ավտոմատ փոխակերպումը (օրինակ int – Integer)։
* Ստատիկ մեթոդների և փոփոխականների ներմուծում։
* Լեզվի մեջ ավելացան օբյեկտների հավաքածուի վրայով ցիկլերը (իտերատոր, foreach)։

### Java SE7
Java 7–ը խոշոր թարմացում էր։ Ստեղծման պրոցեսսը բաժանվել էր 13 փուլերի։ Նոր հնարավորությունները։
* Վիրտուալ մեքենան սկսեց աջակցել դինամիկ լեզուները։
* 64 բիթանոց սեղմված ցուցիչներ։
* Զուգահեռ իրականացման համար միջոցներ (JSR 166)։
* Մուտք – ելք նոր գրադարանը, որը լավացնում էր պլատֆորմ–անկախությունը։
* XRender Java 2D–ի համար, որը լավացնում էր ժամանակակից GPU–ների կառավարման հնարավորություննրը։
* Նոր գրաֆիկական API:
* Ցանցային ընթացակարգերի աջակցման ընդարձակում։
* XML և Յունիկոդի թարմացում։
* Նոր JVM (Java HotSpot Virtual Machine 22)
* Oracle Solaris 11–ի աջակցում։
* Firefox 5–ի և ավելի բարձրների աջակցում։
* Java FX մտավ Java SEի մեջ։

### Java SE 8

Դուրս եկավ 2014 թ մարտի 18–ին։
Նոր հնարավորությունները։
* Լյամբդա–արտահայտությունները և լռելությամբ տրամադրվող մեթոդները ինտերֆեյսներում։
* Տիպերի մետատվյալները։
* Զանգվածների և հավաքածուների զուգահեռ կարգավորում։
* Base64 դեկոդերը
* Date & Time API
* Bulk օպերացիան հավաքածուների համար։

## Java պլատֆորմների դասակարգումը

Java պլատֆորմները
*Java SE – Java Standart Edition, Java–ի հիմնական հրատարակությունը, պարունակում է կոմպիլյատորներ. API, JRE (Java Runtime Enviroment)։ Օգտագործվում է սպառողական ծրագրերի ստեղծման համար, մասնավորապես PC–ների և Laptop–ների համար։
*Java EE – Java Enterprise Edition, պարունակում է սպեցիֆիկացիաների հավաքածու կազմակերպությունների ծրագրային ապահովման ստեղծման համար։
*Java ME – Java Micro Edition, ստեղծվել է, որպեսզի օգտագործվի այնպիսի սարքերում, որոնք սահմանափակ հաշվարկային հզորություն ունեն, օրինակ բջջային հեռախոսները, պլանշետները, ներդրված համակարգերը։
*Java FX – տեխնոլոգիա, որը հանդիսանում է Java–ի էվոլյուցիան Rich Client Platform – ում։ Նախատեսված է կազմակերպությունների ծրագրային ապահովման և բիզնես ծրագրերի գրաֆիական ինտերֆեյսի ստեղծման համար։
*Java Card – տեխնոլոգիան ներկայացնում է անվտանգ միջավայր այն ծրագրերի համար, որոնք աշխատում են սմարթ քարտերի և այլ սարքերի վրա, որոնք ունեն չափազանց սահմանափակ հիշողության ծավալ և մշակաման հնարավորություններ։

## Շարահյուսությունը
Java–ի սինտակսիսը մեծ մասամբ համընկնում է C++ –ի սինտակսիսի հետ։ Ի տարբերություն C++ –ի, որը կոմբինացրել է ստրուկտուրային, ընդհանուր և օբյեկտ–կողմնորոշված ծրագրավորումը, Java–ն կառուցված է որպես օբյեկտ–կողմնորոշված լեզու։ Ամբողջ կոդը գրվում է կլասսների ներսում, և ցանկացած տվյալ, բացառությամբ պրիմիտիվ տիպերի, գտնվում է օբյեկտի մեջ։ Java –ն կրկնում է C++ –ի որոշ հայտնի ասպեկտները (օրինակ printf() ֆունկցիան)։ 
Ի տարբերություն C++–ի, Java–ում չկա օպերատորների վերասահմանում () կամ բազմակի ժառանգում () կլասսների համար, բայց բազմակի ժառանգումը իրագործված է ինտերֆեյսների համար։ Դա պարզեցնում է լեզուն և կանխում հնարավոր սխալները։
Java–ն մեկնաբանությունների (comments) սինտակսիսը համարժեք է C++–ին։ Կա երեք տեսակի մեկնաբանություն։ Մեկ տողի համար (`//`), մի քանի տողերի համար՝ սկսվում է `/*` – ով և վերջանում `*/` –ով, և Javadoc ()տեսակը, որը սկսվում է `/**`–ով, և վերջանում `*/` –ով։

**Օրինակ**


```java
// Սա մեկ տողանոց մեկնաբանության օրինակ է

/* Սա մի քանի տողանոց մեկնաբանության օրինակ է։
 Այս տեսակի մեկնաբանությունը կարող է օգտագործվել շատ ինֆորմացիա գրելու համար,
բայց շատ կարևոր է չմոռանալ այն փակել */

package fibsandlies;
import java.util.HashMap;

/**
 * Սա Javadoc մեկնաբանության տեսակ է; 
 * Javadoc մեկնաբանությունները պետք է անմիջապես նախորդեն այն կլասսին, ֆունկցիային կամ դաշտին, որը մեկնաբանվում է։
 */
public class FibCalculator extends Fibonacci implements Calculator {
    private static Map<Integer, Integer> memoized = new HashMap<Integer, Integer>();

    /*
     * main ֆունկցիան հանդիսանում է ծրագրի կատարման սկզբնակետը։
     */
    public static void main(String[] args) {
        memoized.put(1, 1);
        memoized.put(2, 1);
        System.out.println(fibonacci(12)); //Get the 12th Fibonacci number and print to console
    }

    /**
     * Կլասսում գրված ֆունկցիայի օրինակ։
     * ստանում է ոչ բացասական թիվ FIBINDEX, վերադարձնում է 
     * N-րդ Ֆիբոնաչիի թիվը։
     * @param fibIndex Ֆիբօնաչիի շարքի ինդեքսը
     * @return Ֆիբոնաչիի թիվը։
     */
    public static int fibonacci(int fibIndex) {
        if (memoized.containsKey(fibIndex)) {
            return memoized.get(fibIndex);
        } else {
            int answer = fibonacci(fibIndex - 1) + fibonacci(fibIndex - 2);
            memoized.put(fibIndex, answer);
            return answer;
        }
    }
}
```


## Օրինակ

Ավանդական "Hello, world!" () ծրագիրը Java–ով կարող է գրվել այսպես։


```java
class HelloWorldApp {
    public static void main(String[] args) {
        System.out.println("Hello World!"); // Տպում է տողը կոնսոլի մեջ։
    }
}
```


Ֆալլերը պետք է անվանվեն այն public կլասսի անունով, որը նրանք պարունակում են։ Օրինակ `HelloWorldApp.java`։ Այն սկզբում կոմպիլացվելու է բայթկոդի, որի արդյունքում ստացվելու է `HelloWorldApp.class` ֆայլը։ Դրանից հետո միայն այն կկատարվի։ Java ֆայլը կարող է պարունակել միայն մեկ `public` կլասս, բայց այն կարող է պարունակել բազմաթիվ կլասսներ `public`–ից բացի այլ թույլտվության սպեցիֆիկատորներով և ցանկացած թվով ներդրված կլասսներ (նաև `public`)։

`public` սպեցիֆիկատորը նշանակում է, որ ֆունկցիան կարող է կանչվել այլ կլասսներից կամ որ կլասսը կարող է օգտագործվել հիերարխիայից դուրս այլ կլասսներում։ Կլասսների հիերարխիան կապված է այն կատալոգին, որտեղ գտնվում է Java ֆայլը։ Սա կոչվում է թույլտվության աստիճանի մոդիֆիկատոր։ Մյուս թույլտվության աստիճանի մոդիֆիկատորներն են `private` և `protected`։

`static` սպեցիֆիկատորը սահմանում է ստատիկ ֆունկցիա, որը կապված է միայն կլասսին, և ոչ թե նրա օբյեկտների հետ։ Միայն ստատիկ ֆունկցիաները կարող են կանչվել առանց օբյեկտի հասցեի։ Ստատիկ ֆունկցիաները չեն կարող դիմել կլասսի այն անդամներին, որոնք ստատիկ չեն։

`void` սպեցիֆիկատորը ցույց է տալիս, որ ֆունկցիան չի վերադարձնում որևէ արժեք։

`main`–ը ուղղակի գլխավոր ֆունկցիայի անվանումն է, այն սպեցիֆիկատոր չէ։ Java կլասսները, որոնք աշխատում են կառավարվող միջավայրում, main() ֆունկցիայի կարիքը չունեն։ Ծրագիրը կարող է պարունակել բազմաթիվ կլասսներ, որոնք ունեն `main` ֆունկցիաներ։ Այս դեպքում պետք է ակնհայտ նշել, թե որն է ծրագրի սկիզբը։

`main` ֆունկցիան պետք է ստանա `String`–ների զանգված։ Ըստ համաձայնության այն անվանվում է `args`, թեև, ցանկացած ուրիշ թույլատրված անուն ևս կարող է օգտագործվել։

## Ջավան և Մայքրոսոֆթը

Մայքրոսոֆթ ընկերության կողմից մշակվել է JVM–ի () սեփական իրագործումը(MSJVM), որը ընդգրկվել է տարբեր օպերացիոն համակարգերի մեջ, սկսած Windows 98 (նաև ընդգրկվել է Internet Explorer–ի մեջ, սկսած 3–րդ տարբերակից, որը թույլ էր տալիս օգտագործել MSJVM–ը Windows 95 և Windows NT 4 օպերացիոն համակարգերում IE3+–ը տեղադրելուց հետո)։

MSJVM–ը ուներ էական տարբերություններ Sun Java–ից, մեծ մասամբ կոտրելով տեղափոխելիության հիմնական սկզբունքը։
* բացակայում էր RMI–ի () ծրագրային ինտերֆեյսը։
* բացակայում էր JNI (:en:Java Native Interface) տեխնոլոգիան։
* ոչ ստանդարտ ավելացումներ, ինչպիսին Java–ի ինտեգրացիան DCOM–ի () մեջ, որը աշխատում էր միայն Windows պլատֆորմների վրա։

Վերջին կետը կասկածի տակ էր դնում լեզվի բազմապլատֆորմային սկզբունքը։ Հետագայում դրա պատճառով *Sun Microsystems*–ը դատական հայց ներկայացրեց Microsoft–ին։ Դատարանը ընդունեց Sun Microsystems–ի իրավացիությունը։ Ի վերջո երկու ընկերությունների միջև համաձայնություն է կնքվել, որը թույլ է տալիս երկարաձգել *MSJVM* օգտագործումը մինչև 2007 թվական։

## Ջավան և Անդրոիդը

Ջավա լեզուն ակտիվ օգտագործվում է Անդրոիդ օպերացիոն համակարգի վրա տեղափոխելի ծրագրեր գրելու համար։ Ծրագրերը կոմպիլացվում են ոչ ստանդարտ բայթկոդ, որպեսզի այն կարողանա օգտագործվել Dalvik վիրտուալ մեքենայում։ Այսպիսի կոմպիլյացիայի համար օգտագործվում է լրացուցիչ գործիք՝ Software Development Kit, մշակված Google ընկերության կողմից։

Ծրագրերի իրագործումը կարելի է կատարել հետևյալ միջավայրերում՝ Android Studio, NetBeans, Eclipse (օգտագործելով Android Development Tools (ADT) պլագինը), IntelliJ IDEA։ JDK–ի տարբերակը պետք է լինի 5․0 կամ բարձր։

2014 թվականի դեկտեմբերի 8–ին Google–ը Android Studio–ն  ճանաչել է նախընտրելի միջավայր Android ՕՀ–ում նախագծելու համար։ 

## Հիմնական հնարավորությունները
* Հիշողության ավտոմատ կառավարում
* Բացառիկ իրավիճակների կառավարման ընդլայնված հնարավորություններ
* Մուտք–ելքի ֆիլտրացիայի հարուստ միջոցներ
* Ստանդարտ հավաքածուներ՝ զանգվածներ, ստեկ և այլն
* Ցանցային ծրագրերի ստեղծման պարզ միջոցներ (այդ թվում RMI պրոտոկոլը)
* Կլասսների առկայություն, որոնք թույլ են տալիս կատարել HTTP հարցումներ և մշկել պատասխանները
* Լեզվում ներդրված է բազմահոսքային ծրագրերի ստեղծման միջոցներ, որոնք հետագայում օգտագործվել են շատ այլ ծրագրավորման լեզուներում (օրինակ Python)
* Տվյալների բազաների հետ հեշտացված աշխատանք
* Լյամբդա ֆունկցիաներ (սկսած 1.8 տարբերակից)
* Ծրագրերի զուգահեռ կատարում

## Հիմանական գաղափարները
### Պրիմիտիվ տիպերը
Java լեզվում կան ընդամենը 8 պրիմիտիվ տիպեր՝ boolean, byte, char, short, int, long, float, double. Գոյություն ունի նաև 9–րդ տիպ՝ void, բայց այս տիպի փոփոխականներ և դաշտեր հայտարարելը կոդում արգելված է։ Այ օգտագործվում է կլասսներում և մեթոդներում, որպես ոչինչ չվերադարձնող արժեք։
Տիպերի երկարությունը և արժեքների միջակայքը որոշվում են ստանդարտով, ոչ թե իրագործմամբ։ Char–ը երկու բայթ է զբաղեցնում, լոկալիզացիայի հարմարության համար։ Երբ մշակվում էր ստանդարտը, արդեն գոյություն ուներ Unicode–32–ը, բայց ոչ Unicode–64–ը։ Քանի որ չկար մեկ բայթանոց փոփոխական, ավելացրեցին նոր տիպ՝ byte, և ի տարբերություն ուրիշ ծրագրավորման լեզուների, այն առանց նշանի չէ։ Float և double տիպերը կարող են ունենալ հատուկ արժեքներ ՝ +\infty, -\infty и «ոչ թիվ» (NaN)։ Double տեսակի համար դրանք ցույց են տրվում `Double.POSITIVE_INFINITY`, `Double.NEGATIVE_INFINITY`, `Double.NaN`; Float տիպի համար նմանապես, միայն Double–ի տեղը պետք է դնել Float: Առավելագույն և նվազագույն արժեքները նույնպես ստանդարտավորված են։

Այսպիսի խիստ ստանդարտավորումը անհրաժեշտ էր, որպեսզի լեզուն լիներ պլատֆորմ–անկախ, որը Java–ի գաղափարական գլխավոր պահանջներից մեկն էր։ Այնուամենայնիվ մի մի փոքր պրոբլեմ, կապված պլատֆորմային անկախության հետ մնաց։ Որոշ պրոցեսսորներ միջանկյալ արժեքները պահելու համար օգտագործում են 10 բայթանոց ռեգիստրներ կամ այլ միջոցներով են լավացնում հաշվարկների ճշտությունը։ Որպեսզի Java–ն առավելագույն համապատասխանություն ունենար տարբեր համակարգերի միջև, տարբեր տեսակներում հաշվարկնեի բարձրացման միջոցները արգելվեցին։ Սակայն դա բերում էր արագագործության նվազեցմանը։ Բազմաթիվ բողոքներից հետո այդ արգելքը վերացրեցին, բայց ավելացրին `strictfp` ծառայողական բառը, որը արգելում էր ճշտության բարձրացումը։

### Մաթեմատիկական գործողությունների ժամանակ փոխակերպումները
Java լեզվում գործում են հետևյալ կանոնները
# Եթե օպերանդներից մեկը ունի double տիպ, ապա մնացած օպերանդները բերվում են double–ի
# Հակառակ դեպքում, եթե օպերանդներից մեկը ունի float տիպ, ապա մնացած օպերանդները բերվում են float–ի
# Հակառակ դեպքում, եթե օպերանդներից մեկը ունի long տիպ, ապա մնացած օպերանդները բերվում են long–ի
# Հակառակ դեպքում բոլոր օպերանդները բերվում են int տիպի։
Այս ոչ ակընհայտ փոխակերպումնրը ամբողջությամբ համապատասխանում են C++ –ում գոյություն ունեցող փոխակերպումներին։

### Օբյեկտային փոփոխականներ, օբյեկտներ, ցուցիչներ և հղումներ
Java–ում կան միայն դինամիկ ստեղծվող օբյեկտներ։ Ընդ որում օբյեկտային փոփոխականները և օբյեկտները բացարձակապես տարբեր բաներ են։ Օբյեկտային փոփոխականները հղումներ են, այսինքն ոչ ակնհայտ ցուցիչներ դինամիկ ստեղծվող օբյեկտների վրա։ Դա երևում լեզվի սինտակսիսում։ Այպես, չի կարելի գրել՝

```java
double a[10][20];
Foo b(30);
```

այլ պետք է։

```java
double[][] a = new double[10][20];
Foo b = new Foo(30);
```

Վերագրումների, փոխանցումներ և համեմատման ժամանակ օբյեկտային փոփոխականները իրենց պահում են ինչպես ցուցիչներ, այսինքն գործողությունները կատարվում են փոփոխականների հասցեների հետ։ Նաև այս տիպի փոփոխականներին դիմելուս որևէ հատուկ օպերատոր չի կանչվում, ամեն ինչ կատարվում է այնպես, ասես օբյեկտային փոփոխականը հենց օբյեկտ է։ 
Օբյեկտային են համարվում բոլոր տեսակի փոփոխականները, բացի պրիմիտիվ տիպերի փոփոխականներից։ Java–ում ակնհայտ ցուցիչներ չկան։ Ի տարբերություն C, C++ և այլ լեզուների, հղումների օգտագործումը java–ում ունի բարձր անվտագույան շեմ, քանի որ դրված են խիստ սահմանափակումներ դրանց օգտագործման վրա՝
* Չի կարելի փոխակերպել պրիմիտիվ տեսակի օբյեկտը ցուցիչի կամ հղումի, և հակառակը։
* Ցուցիչների հետ չի կարելի կատարել հանրահաշվական գործողություններ (++, ––, +, –)։
* Տիպերի փոխակերպումը խիստ կառավարվում է։ Բացառությամբ զանգվածների վրա հղումներից, թույլատրված փոխակերպել հղումները միայն ժառանգվող տիպի և նրա ծնողի միջև, ընդ որում փոխակերպումը պետք է ակնհայտ ցույց տրվի։
* Java–ում չկա հասցե վերցնելու օպերատոր (&) և օբյեկտի վերցնումը ըստ հասցեի (*)։
Այսպիսով կառավարել հիշողությունը ֆիզիկական մակարդակի վրա անհնար է։ Նաև կարելի է ստուգել, արդյոք ցուցիչ հղված է null–ի վրա։
### Հղումների կրկնօրինակումը
Քանի որ օբյեկտային փոփոխականները հղումներ են, նրանց վերագրման ժամանակ օբյեկտի կրկնօրինակում չի կատարվում։ Օրինակ՝ 

```java
Foo foo, bar;
…
bar = foo;
```

այս դեպքում կկատարվի հասցեի կրկնօրինակումը `foo` փոփոխականից դեպի `bar` փոփոխական։ Այսինքն երկու փոփոխականներն էլ հղված հիշողության նույն տիրույթի վրա, այսինքն նույն օբյեկտի վրա։ Եթե անհրաժեշտ է ստանալ հենց օբյեկտի կրկնօրինակը, ապա օգտագործում են կամ մեթոդ՝ `clone()`, կամ կրկնօրինակող կոնստրուկտոր։ 
`clone()` մեթոդը պահանջում է, որպեսզի կլասսը իրագործի `Cloneable` ինտերֆեյսը։
### Փոփոխականների սկզբնաարժեքավորումը
Բոլոր փոփոխականները պահանջում են սկզբնաարժեքավորում, կամ ավտոմատ լցվում 0–ներով (0, null, զրոների զանգված)։ Այսպիսով անհետանում են C լեզվին բնորոշ չսկզբնաարժեքավորված փոփոխականների օգտագործումը։

### Աղբի հավաքումը
Java–ում անհնար է օբյեկտի ակնհայտ ջնջումը հիշողությունից, դրա փոխարեն իրագործված է աղբի հավաքումը։ Ավանդական միջոցը, որով հասկացվում է աղբահավաքին, որ պետք է ազատել հիշողությունը, հանդիսանում է փոփականին null վերագրելը։ Դա չի նշանակում, որ այդպիսի օբյեկտը միանգամից կջնգվի, բայց այն տալիս է երաշխիք, որ այն կջնջվի ապագայում։ Պետք է հաշվի առնել, որ օբյկտը չի ջնջվի, քանի դեռ նրա վրա հղված է թեկուզ մեկ ցուցիչ։

## Ծանոթագրություններ

## Արտաքին հղումներ
* Ջավայի պաշտոնական կայքը
* Ձեռք բերեք նորագույն Ջավա ծրագրեր և իմացեք ավելին Ջավայի մասին

Կատեգորիա:Օբյեկտ կողմնորոշված ծրագրավորման լեզուներ