Ջավա (ծրագրավորման լեզու)

Վիքիպեդիայից՝ ազատ հանրագիտարանից
Disambig.svg Անվան այլ կիրառումների համար տես՝ Ջավա (այլ կիրառումներ)
Ջավա
Java logo.png
Տեսակ ծրագրավորման լեզու և օբյեկտներին կողմնորոշված ծրագրավորման լեզու
Սեմանտիկա օբյեկտա-կողմնորոշված,ստրուկտուրային,իմպերատիվ
Կատարման ձև կոմպիլացվում է բայթ կոդ
Առաջացել է 1995
Ստեղծող Sun Microsystems և Oracle Corporation
Նախագծող Ջեյմս Գոսլինգ և Sun Microsystems
Ընդլայնումներ java
Տիպիզացիա ստատիկ
Հիմնական իրականացումներ OpenJDK, HotSpot և այլն․․․
Ներշնչվել է Ada 83,C++, C#,Delphi Object Pascal,Eiffel, Generic Java, Mesa,Modula-3, UCSD Pascal, Smalltalk
Ներշնչել է Ada 2005, BeanShell, C#, Clojure, D, ECMAScript, Groovy, J#, JavaScript, PHP, Python, Scala
Արտոնագիր GNU GPL
Անվանված է Ջավա սուրճ
Հմայագիր Դյուկ[1]
Կայք https://www.oracle.com/java/
Java (programming language) Վիքիպահեստում

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-ն օգտագործվում է դինամիկ պարունակությամբ վեբ էջեր, բազմատեսակ սպառողական ծրագրեր ստեղծելու, շարժական բազմապիսի էլեկտրոնային սարքերը ծրագրերով ապահովելու համար։

Տեխնիկական նկարագրություն[խմբագրել | խմբագրել կոդը]

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-ն օգտագործում է աղբահավաք՝ (անգլ.՝ Garbage collector - GC) հիշողության ավտոմատ կազմակերպման համար։ Երբ ծրագրի աշխատանքի ժամանակ որևէ օբյեկտ չի օգտագործվում, այսինքն չկա նրա վրա ցուցող որևէ հղում, ապա աղբահավաքը ջնջում է այն հիշողությունից։ Չնայած այս ավտոմատացված կազմակերպմանը՝ հիշողության արտահոսքի (անգլ.՝ Memory leak) վտանգը դեռ մնում է։ Օրինակ հիշողության արտահոսք կարող է լինել, եթե ոչ պետքական օբյեկտի վրա ցուցող հղում (անգլ.՝ Refernce) մնա։ Ի տարբերություն C++-ի Java-ն հնարավորություն չի տալիս ցուցիչների (անգլ.՝ Pointer) հետ աշխատելու, ձեռքով հիշողությունն ազատելու, խելացի ցուցիչներ (անգլ.՝ Smart pointer) օգտագործելու և այլն։ Աղբահավաքը կարող է աշխատել ցանկացած պահի, իդեալական դեպքում այն աշխատում է համեմատաբար պարապուրդի մեջ եղած ժամանակ։ Երաշխավորված է, որ այն կաշխատի, երբ բավարար հիշողություն չլինի նոր օբյեկտ ստեղծելիս։ Սա թույլ է տալիս աղբահավաքին տեղափոխել օբյեկտների հասցեները և տալիս է տիպերի ապահովություն։ Ինչպես C++-ում և որոշ օբյեկտ-կողմնորոշված ծրագրավորման լեզեւներում, Java - ում պրիմիտիվ տիպերը(int, double, boolean, char) պահվում են դաշտերում (օբյեկտների համար), ստեկում (անգլ.՝ Stack) (ֆունկցիաների համար), այդ պատճառով դրանց համար աղբահավաք չի աշխատում։ Սա Java - ի ստեղծողների գիտակցված որոշումն է, որի նպատակն է բարձրացնել արագագործությունը։ Java-ն ունի մի քանի տեսակի աղբահավաքներ։ Java - ով գրված ծրագրերի 90% -ի համար Concurrent Mark-Sweep (անգլ.՝ Concurrent mark sweep collector) աղբահավաքը բավարար է։ 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-ում չկա օպերատորների վերասահմանում (անգլ.՝ Operator overloading) կամ բազմակի ժառանգում (անգլ.՝ Multiple inheritance) կլասսների համար, բայց բազմակի ժառանգումը իրագործված է ինտերֆեյսների համար։ Դա պարզեցնում է լեզուն և կանխում հնարավոր սխալները։ Java-ն մեկնաբանությունների (comments) սինտակսիսը համարժեք է C++-ին։ Կա երեք տեսակի մեկնաբանություն։ Մեկ տողի համար (//), մի քանի տողերի համար՝ սկսվում է /* - ով և վերջանում */ -ով, և Javadoc (անգլ.՝ Javadoc)տեսակը, որը սկսվում է /**-ով, և վերջանում */ -ով։

Օրինակ

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

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

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!" (անգլ.՝ "Hello, World!" program) ծրագիրը 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, թեև, ցանկացած ուրիշ թույլատրված անուն ևս կարող է օգտագործվել։

Java-ն և Microsoft-ը[խմբագրել | խմբագրել կոդը]

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

MSJVM-ը ուներ էական տարբերություններ Sun Java -ից, մեծ մասամբ կոտրելով տեղափոխելիության հիմնական սկզբունքը։

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

Java-ն և Android-ը[խմբագրել | խմբագրել կոդը]

Java լեզուն ակտիվ օգտագործվում է Android օպերացիոն համակարգի վրա տեղափոխելի ծրագրեր գրելու համար։ Ծրագրերը կոմպիլացվում են ոչ ստանդարտ բայթկոդ, որպեսզի այն կարողանա օգտագործվել 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: Առավելագույն և նվազագույն արժեքները նույնպես ստանդարտավորված են:

Տիպ Երկարություն (բայթերով) Միջակայքը կամ արժեքների բազմությունը
boolean 1 զանգվածներում, 4 փոփոխականներում true, false
byte 1 −128..127
char 2 0..216−1, կամ 0..65535
short 2 −215..215−1, կամ −32768..32767
int 4 −231..231−1, կամ −2147483648..2147483647
long 8 −263..263−1, կամ մոտավոր −9.2·1018..9.2·1018
float 4 -(2-2−23)·2127..(2-2−23)·2127, կամ մոտավոր −3.4·1038..3.4·1038, նաև -\infty, \infty, NaN
double 8 -(2-2−52)·21023..(2-2−52)·21023, կամ մոտավոր −1.8·10308..1.8·10308, նաև -\infty, \infty, NaN

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

Մաթեմատիկական գործողությունների ժամանակ փոխակերպումները[խմբագրել | խմբագրել կոդը]

Java լեզվում գործում են հետևյալ կանոնները

  1. Եթե օպերանդներից մեկը ունի double տիպ, ապա մնացած օպերանդները բերվում են double-ի
  2. Հակառակ դեպքում, եթե օպերանդներից մեկը ունի float տիպ, ապա մնացած օպերանդները բերվում են float-ի
  3. Հակառակ դեպքում, եթե օպերանդներից մեկը ունի long տիպ, ապա մնացած օպերանդները բերվում են long-ի
  4. Հակառակ դեպքում բոլոր օպերանդները բերվում են int տիպի:

Այս ոչ ակընհայտ փոխակերպումնրը ամբողջությամբ համապատասխանում են C++ -ում գոյություն ունեցող փոխակերպումներին:

Օբյեկտային փոփոխականներ, օբյեկտներ, ցուցիչներ և հղումներ[խմբագրել | խմբագրել կոդը]

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

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

այլ պետք է:

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

Վերագրումների, փոխանցումներ և համեմատման ժամանակ օբյեկտային փոփոխականները իրենց պահում են ինչպես ցուցիչներ, այսինքն գործողությունները կատարվում են փոփոխականների հասցեների հետ: Նաև այս տիպի փոփոխականներին դիմելուս որևէ հատուկ օպերատոր չի կանչվում, ամեն ինչ կատարվում է այնպես, ասես օբյեկտային փոփոխականը հենց օբյեկտ է: Օբյեկտային են համարվում բոլոր տեսակի փոփոխականները, բացի պրիմիտիվ տիպերի փոփոխականներից: Java-ում ակնհայտ ցուցիչներ չկան: Ի տարբերություն C, C++ և այլ լեզուների, հղումների օգտագործումը java-ում ունի բարձր անվտագույան շեմ, քանի որ դրված են խիստ սահմանափակումներ դրանց օգտագործման վրա՝

  • Չի կարելի փոխակերպել պրիմիտիվ տեսակի օբյեկտը ցուցիչի կամ հղումի, և հակառակը:
  • Ցուցիչների հետ չի կարելի կատարել հանրահաշվական գործողություններ (++, --, +, -):
  • Տիպերի փոխակերպումը խիստ կառավարվում է: Բացառությամբ զանգվածների վրա հղումներից, թույլատրված փոխակերպել հղումները միայն ժառանգվող տիպի և նրա ծնողի միջև, ընդ որում փոխակերպումը պետք է ակնհայտ ցույց տրվի:
  • Java-ում չկա հասցե վերցնելու օպերատոր (&) և օբյեկտի վերցնումը ըստ հասցեի (*):

Այսպիսով կառավարել հիշողությունը ֆիզիկական մակարդակի վրա անհնար է: Նաև կարելի է ստուգել, արդյոք ցուցիչ հղված է null-ի վրա:

Հղումների կրկնօրինակումը[խմբագրել | խմբագրել կոդը]

Քանի որ օբյեկտային փոփոխականները հղումներ են, նրանց վերագրման ժամանակ օբյեկտի կրկնօրինակում չի կատարվում: Օրինակ՝

Foo foo, bar;

bar = foo;

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

Փոփոխականների սկզբնաարժեքավորումը[խմբագրել | խմբագրել կոդը]

Բոլոր փոփոխականները պահանջում են սկզբնաարժեքավորում, կամ ավտոմատ լցվում 0-ներով (0, null, զրոների զանգված): Այսպիսով անհետանում են C լեզվին բնորոշ չսկզբնաարժեքավորված փոփոխականների օգտագործումը:

Աղբի հավաքումը[խմբագրել | խմբագրել կոդը]

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

Ծանոթագրություններ[խմբագրել | խմբագրել կոդը]

Արտաքին հղումներ[խմբագրել | խմբագրել կոդը]