ჯავა - მოკლე ისტორია, საწყისები.

                                

მოკლე ისტორია თუ რისგან შედგება ჯავა, (ბირთვი) JVM, JIT, JAVA API, JRE და JDK, ჩამოთვლილ თაგებს მოგვიანებით განვავრცობ და დეტალურად განვიხილავ!

შეიქმნა 1991 – 1992 წელს, როგორც დამოუკიდებელი პლატფორმა, ის წააგავს უფრო ადრეულ ენებს C და C++, ოფიციალურად დარეგისტრირებულ იქნა 1995 წლის 23 მაის Sun Microsystems-ის მიერ. ჯავა არის ობიეკტზე ორიენტირებული პროგრამირების ენა (OOP – Object Oriented Programing Language), რომელიც იყენებს ვირტუალურ მანქანას (JVM- Java Virtual Machine) რომლის ძირითადი დანიშნულება არის თარგმნოს ადამიანის ენაზე გასაგები სიტყვები კომპიუტერის ენაზე, (მოახდინოს კომპილაცია ჯავა პროგრამების, ბაითკოდებში, რაც უზრუნველყოფს კომპილირებული პროგრამის დამოუკიდებლობას გამშვებ სისტემასთან მიმართებაში)  

ადამიანის სხეული რო წარმოიდგინოთ ვირტუალური მანქანა არის ჯავას გული. რომლის კონტროლსაც ახდენს GB (Garbage Colletion)

ვიტუალური მანქანა არის შუამავალი ჩვენსა და ოპერაციულ სისტემას შორის.

ვირტუალურმა მანქანამ არ იცის ჯავა პროგრამირების ენა, უბრალოდ ბაიტკოდის ინსტრუქციებს მიყვება რომელიც მასში დევს როგორც კლას ფაილები (Class Files) ყველა ენა რომელიც ახდენს კონვერტირებას ბაიტკოდებში შეიძლება გამოიყენოს ვირტუალურმა მაქნანამ, ანუ წაიკითხოს.

ევოლუცია 1996 წლიდან დღემდე :

1996 წელი, ვერსია 1,0 კლასების და ინტერფეისების ჯამური ოდენობა შედგენს 211.

1997 წელი, ვერსია 1.1 კლასების და ინტერფეისების ჯამური ოდენობა 477, ძირითადი სიახლე - შიდა კლასი (Inner Class)

1998 წელი, ვერსია 1,2 კლასების და ინტერფეისების ჯამური ოდენობა შეადგენს 1524.

2000 წელი, ვერსია 1,3 კლასების და ინტრეფეისების ჯამური ოდენობა შეადგენს 1840

2004 წელი, ვერსია 1,4, კლასების და ინტერფეისების ჯამური ოდენობა შეადგენს 2732. ძირითადი სიახლე მტკიცებები (assertions )

2004 წელი ვერსია 5,0 კლასების და ინტერფეისების ჯამური ოდენობა შედგენს 3279. ძირითადი სიახლეები generics, foreach, varargs, autoboxing, metadata, enumerations, static import.

2006 წელი, ვერსია 6,0 კლასებს და ინტერფეისების ჯამური ოდენობა შეადგენს 3777.

2011 წელი, ვერსია 7,0 კლასების და ინტერფეისების ჯამური ოდენობა შეადგენს 4024. ძირითადი სიახლეები multiple exceptions, try with resources, <> syntax .

2014 წლიდან დღემდე, ვერსია 8,0 კლასების და ინტერფეისების ჯამური ოდენობა4240, ძირითადი სიახლეები lambda, annotations .

ჯავა პროგრამირების ენა არის:

1.ობიეკტზე ორიენტირებული პროგრამირების ენა

2. სინტაკსი ახლოს დგას C ენასთან

3. ადვილია ასათვისებლად

4, სტატიკურად ტიპიზირებული (Staticaly typed) რაც ნიშნავს იმას რო აუცუილებლად უნდა მაოხდინოთ ყველა ცვლადის წინასწარ ტიპიზირება. სტატიკური წერა თავიდან გვარიდებს უამრავ უაზრო ბაგს ადრეულ სტადიაზე. დასაწყისშივე,  თუ არ მოახდინეთ ცვლადის ტიპიზირება კომპილატორი კოდს არ წაიკითხავს. სტატიკურად ტიპიზირებული ენებია C, C++ Java. არსებობს დინამიკურად ტიპიზირებული წერის სტილი რაც არ მოითხოვს ცვლადის ინიციალიზაციას (ტიპიზირებას), მისი ტიპიზირება  ხდება პროგრამის ჩატვირთვის პროცესში, (at Runtime) რაც ბევრ პროგრამისტს იზიდავს და უმარტივებს საქმეს მაგრამ შედეგად უამრავი ბაგი შეიძლება მიიღოთ თუ მაღალი კლასის პროგრამისტი არ ხართ.  აგრეთვე არსებობს წერის სუსტი და ძლიერი ტიპები. „Strongly Typed“ და “Weakly Typed”მაგრამ ამ ეტაპზე ამას აღარ განვიხილავთ, მოგვიანებით მოუბრუნდებით.

5. თავსებადია ყველანაირ პროეკტებთან

6. პლატფორმულად და არხიტეკტურულად დამოუკიდებელი

7. ენა რომელიც ავტომატურად მართავს მეხსიერებას.

იდეა რო იყოს პლატფპრმულად დამოუკიდებელი ჯავას დასაწყისშივეა ჩადებული და ეს გამოიხატება შემდეგი პატარა სიცბიერით, ან წინდახედულობა დავარქათ თუ გინდათ, ან აფერისტობა, როგორც გესიამოვნებათ, source code-ის კომპილაცია არ ხდება ინსტრუქცირების გარეშე, და ინფორმაცია პროცესორამდე არ მიდის ავტომატურ რეჟიმში, კომპიუტერის სპეციფიურ პრიორიტეტებს არ იყენებს და კომპილაციას ახდენს გზაზე, პროცესორსა და კოდს შორის, წარმოიდგინეთ იერარხია, რომლის სათავეშია საწყისი კოდი, რომლის კომპილაცია ხდება, რის შემდეგაც  საწყისი კოდი იცვლება და ხდება ბაითკოდი (bytecode) ბაითკოდად გადაქცევის მერე ინფორმაცია უნდა მივიდეს პროცესორთან რაც არ მიდის, კოდი უკვე ბაითკოდია, ხდება კლონირება და პროცესორს აძლევს კოპირებულ ინფორმაციას და არა ორიგინალს. ანუ კომპილაცია ხდება პროცესორამდე და პროცესორს მიდის უკვე შესრულებული ოპერაციის კოპირებული ვერსია რომლის შესრულებას ახდენს შემდგომ პროცესორი. მსგავსად მუშაობს ყველა ოპერაციულ სისტემასთან, განურჩევლად, ლინუქსი იქნება ვინდოუსი თუ ანდროიდი. ამიტომაც არის პლატფორმულად და იერარხიულად დამოუკიდებელი, იერარხიულად იმედია ხვდებით რატომ და პლატფორმულად ნათელია რატომაც.

JAVA API (Application Programming Interface) ეს არის სია ყველა კლასების რომელიც ნაწილია JDK-ის, (Java Development Kit). აპი შეიცავს ყველა ჯავა პაკეტს, კლასს, ინტერფეის, მათი მეთოდების კონსტრუკტორების და ველების ჩათვლით. აპლიკაციების სია მოცემულია შემდგომ ბმულზე. https://docs.oracle.com/javase/7/docs/api/

JAVA JRE (Java Runtime Environment) არის  ბიბლიოთეკების ერთობა,

რომელიც შეიცავს პლაგინებს, ბრაუზერ პლაგინებს, აპლეტ პლაგინებს და ვირტუალურ მანქანას, (JVM)-ს, როდესაც უბრალოდ გინდათ დაწეროთ ჯავა პროგრამა, ან აპლიკაცია, online თუ offline აუცილებლად დაგჭირდებათ JRE, მოცულობით პატარა არის და მარტივადც ყენდება, JRE თავის მხრივ არის JDK-ის ნაწილი რომელსაც დაბლა განვიხილავ.  JRE = JVM + Java API

JDK( Java Development Kit) არის პროგრამირებისთვის საჭირო ხელსაწყო, რომლის მეშვეობითაც ხდება აპლიაკციების და აპლეტების შექმნა, ის შეიცავს JRE (Java Runtime Environment)-ს, interpreter/loader (java)-ს, a compiler (javac)-ს, an archiver (jar)-ს, a documentation generator (javadoc)-ს და სხვა მნიშვნელოვან ფაილებს, რომელიც საჭიროა ჯავა პროგრამირებისთვის.  

an interpreter/loader (java)- ახდენს კლას ფაილებს კომპილაციას, ანუ როდესაც პროგრამას წერ ის არის (java) ფაილი, მერე ხდება კლასს ფაილი და მერე ხდება სხვა და სხვა მიმთითებლების გამოყენება, მთავარი რისი ცოდნაც საჭიროა ეს რის, „ახდებს კლას ფაილების კომპილაციას. “  ეს არის Command promt- ის ბრძანება რო გამოიძახო ჯავა ფაილი და შეამოწმო შენ მიერ დაწერილი პროგრამა მუშაობს თუ არა, დღეს-დღეობით არავინ იყენებს და სრულიად გამოუსადეგარია ეს ინფორმაცია მაგრამ გამოცდებს თუ აბარებთ ან გასაუბრებაზე ხართ აუცილებლად გკითხავენ, უნდა იცოდე!

a compiler (javac) ახდენს ჯავა ფაილის კომპილაციას CMD-ან (Command promt), მაგალითად, დავწერეთ პროგრამა, რომლის სახელიც არის Dzagli yefs. რომ გადავამოწმობთ ყეფს თუ არა ძაღლი, ვხსნით CMD-ის და ვწერთ, javac DzagliYeefs.java (javac-ის მერე space), შესაძლებელია რამოდენიმე პროგრამის ერთდროულად გადამოწმება, შეისაძლებელია მთლიანი ფაილის გადამოწმება მუშაობს თუ არა. მთლიანი ფაილის გადამოცმება ხდება javac *.java ამ ბრძანებით, სადაც ფიფქი ყველას ნიშნავს. 

archiver (jar) არის არქივ ფაილი, სადაც ინახავთ დაარქივებულ ინფორმაციას, ან მთლიან აპლიკაციას, დაარქივების დროს მარტივია მოახდინოთ მთლიანი პროგრამის ერთ ფაილში მოქცევა და მისი შემდგომ წარმოება. (ფოტოების, ტექსტის, ხმების, კლასების,  მეტადატის და სხვა უამრავი საჭირო რამის) ჯარ ფაილი რომ შექმნათ უბრალოდ უნდა დააბოლოვოთ ფოლდერი .jar-ზე.  ის შექმნილია ZIP ფაილ ფორმატზე, და ახდენს კომპრესირებას ამა თუ იმ იმფორმაციის. რეალურ ცხოვრებაში თუ ვინმემ გკითხართ რა არის ჯარ ფაილი ჯავაშიო უბრალო უპასუხეთ ზიპ ფაილია ყოველდღიურ ცხოვრებაშითქო. სხვა დანიშნულება მას არ აქვს.

documentation generator (javadoc)  რეგენერაციის ხელსაწყო, ის ახდენს ჯავა კოდის (აპლიკაციების, API-ის) რეგენერირებას HTML დოკუმენტაციად.  უფრო დეტალურად ინფორმაცია მოიძიეთ google.com-ზე. საკმაოდ ვრცელი , მოცულობით დიდი ინფორმაციაა, რომელსაც დიდ დროს ვერ დაუთმობ.

 Java Web Start(Jawaws)- ერთ-ერთი მნიშვნელოვანი ბრძანება რომლის გამოყენებაც გვიწევს ვებ-პროგრამირების დროს. მისი მეშვეობით ხდება ჯავა ვებ აპლიკაციების გადმოწერა და გაშვება.  ის არის JRE-ის ნაწილი. დამატებითი ინფორმაციისთვის წაიკითხეთ ბმული. https://www.java.com/en/download/faq/java_webstart.xml

JIT (Just In Time) კომპილატორი რომელიც ნაწილია JVM-ის მაგრამ სრულიად განსხვავებული დანიშნულება აქვს, ვირტუალური მანქანა ახდენს სათითაოდ და თანმიმდევრობით ყველა მეთოდის ჩატვირთავს და წაკითხვას,  გავიხსენოთ  როგორ ხდება source code-ის bytecode-ად გადაქცევა და როგორ ახდენს ვირტუალური მანქანა მის მიწოდებას პროცესორზე რომ მოახდინოს კომპილაცია, გვაქვს საწყისი კოდი, რომელიც იცვლება და ხდება ბაითკოდი რომელსაც ვირტუალური მანქანა აწვდის პროცესორს პროცესორის გასაგებ ენაზე. მანქანნის ენაზე.  JIT კომპილატორი ვირტუალური მანქანისგან განსხვავებით ეძებს კოდში HOTSPOT-ებს. ანუ ყველაზე ხშირად გამოყენებად კოდებს, ის არ აწვდის მთლიან კოდს პროცესორს, მხოლოდ ნაწილს, რომელიც მნიშვნელოვანია პროგრამის სტარტიტებისთვის, ეფეკტურობის გაზრდისთვის და სწრაფი მოქმედებისთვის. ამიტომაც ქვია Just In Time კომპილატორი. სხვაობა ვირტუალურ მანქანასა და მეორე ვირტუალურ მანქანას შორის არის ის რომ ერთი კითხულობს მნიშვნელოვან ინფორმაციას მეორე კითხულობს ლამის ყველაფერს. ცნობისთვის ვირტუალურ მანქანას აქვს წაკითხვის სტილი და იერარხია.

ჯავა პროგრამების წერისთვის ყველაზე განვრცელებული ხელსაწყოებია: ECLIPSE, www.eclipse.org  არის უფასო, ერთ-ერთი ყველაზე გამოყენებადი ხელსაწყო დღევანდელი მონაცემებით, აქვს დიდი ბაზა პლაგინების,  შესაბამისად არის ნელი. ახდენს რესურსების დიდი რაოდენობით მოხმარებას.  ბოლო ინფორმაციით დაკარგა ანდროიდის მხარდაჭერა. თავსებადია მხოლოდ Android 8.0-მდე.

NetBeans IDE www.netbeans.org უფასო, ადვილია მოხმარებისთვის, დიდი ერთობა სხვა და სხვა ხელსაწყოების და რაც მთავარია მხარდაჭერა აქვს Sun-ზე ორიენტირებული ტექნოლოგიებისგან

IntelliJ IDEA. www.jetbrains.com/idea/  ყველაზე ინტელეკტუალური ხელსაწყო მუშაობისთვის, ფასიანი. უფასო გახსნილი კოდით.

ჯავას ნაირსახეობები პროგრამირებისთვის JAVA SE, JAVA EE, JAVA ME,  JAVA CARD,  JAVAFx:

JAVA SE (java standart (second) Edition) არის საკმაოდ კარგი სახეობა პროგრამირებისთვის, როგორც ყველა სხვა ვარიანტი ის არის სტატიკურად ტიპიზირებული, ობეიკტზე ორიენტირებული და გააჩნია ლამის მთლიანი ბიბლიოთეკა რომელსაც ჯავა იყენებს კოდის წერისთვის. ის შეიძლება იქნეს გამოყენებული როგორც Stand alone (დესკტოპ აპლიკაციები) აპლიკაციების შესაქმნელად  ასევე ვებ აპლიკაციებისთვისაც.

JAVA EE (Enterpsise Edition) არის თითქმის იგივე რაც მისი წინამორბედი JAVA SE, ძირითადი სხვაობა მათ შორის არის ის რომ EE-ს შეუძლია Sowtfare-ის შექმნა სერვერ აპლიკაციაში. (inside server application) Java SE შექმნილია უფრო Stand alone აპლიკაციებისთვის რომელსაც არ გააჩნია სტანდარტიზებული ინტერფეისი. ეე არის სტანდარტიზებული, სპეციფიური დანიშნულების გამოყენებისთვის.

JAVA ME(Micro Edition) შემუშავებულია მობილური პროგრამირებისთვის, გაითვალისინეთ Micro Edition არ არის იგივე რაც Android პროგრამირება. ის უბრალოდ უმკლავდება მობილურ ხელსაწყოებს და პროგრამირებას უკეთ ვიდრე SE.

JAVA CARD არის ძალიან პატარა, ის შექმნილია ATM პროგრამირებისთვის, პლასტიკური ბარათებისთვის და მსგავსი პატარა მოცულობის ინვენტარებისთვის პ.ს დიახ პლასტიკური ბარათებიც და ბანკებიც იყენებენ ჯავას.

JavaFx შექმნილია დიზაინის შექმნისთვის. მას გააჩნია დიდი ბაზა Framework-ის. რაც ხელს გიწყობს შექმნა 2D, 3D, CSS, Scene Building, და სხვა მრავალი დიზაინერული დანიშნულების აპლიაკციები, შესაძლებელია მობილური აპლიკაციის შექმნის დროსაც გამოიყენოთ, რაც მთავარია ხელს გიწყობს შექმნათ მდიდარი GUI აპლიკაციები.

 მოსაწყენი და „გამოუსადეგარი“ ინფორმაციების ტალღა დასრულდა. გადავიდეთ ჩვენი პირველი პროგრამის შექმნაზე, ამისთვის საჭიროა გადმოიწეროთ ნებისმიერი მაღლა ნახსენები ხელსაწყო და დააყენოთ თქვენ კომპიუტერზე. www.eclipse.org  www.netbeans.org www.jetbrains.com/idea/   თუ არ დააყენებთ და კოდის წერას Notepad++ აპირებთ მაშინ მოგიწევს კომპილატორის გამოძახება. გზამკვლევის დაყენება და შემდგომ კოდის წერა. ჯერ Old School სტილში გავიაროთ ყველაფერი.

შევდივართ ლინკზე : http://www.oracle.com/technetwork/java/javase/downloads/index.html

ვიწერთ : JDK-ს

ვაინსტალირებთ : JDK-ს

ირჩევთ პტაფრორმას რომელზეც მუშაობთ:

ვნიშნავთ Accept License Agreement.

და ვამოწმებთ დაყენდა თუ არა. ამისთვის ვხსნით CMD-ის

და ვწერთ javac ბრძანებას. სწორად არ დაყენების შემთხვევაში

ნახავთ მსგავს ფანჯარას. 

ანუ კომპილატორი ვერ ხედავს პროგრამას. რომ ნახოს გზა უნდა გაუკვლიოთ.  გზის გაკვლევა ხდება შემდეგნაირად. Computer > Local Disk C >  Program files> Java

შევდივართ ჯდკ ფოლდერში, შემდგომ Bin ფოლდერში და ვხსნით Properties, ვაკოპირებთ Location-ის გასწვრივ ინფორმაციას

 და ვხსნით Properties ამ ჯერად my computer-ზე. რის შემდეგადაც შევდივართ Advanced System Setting-ში.

ვხსნით Environment Variables > New > Variable Name-ის გასწვრივ ვწერთ Path, Variable Value-ს გასწვრივ ვწერთ Location-ან დაკოპირებულ ინფორმაციას.

რის შემდგომაც ვამოწმებთ კომპილატორს.

ამ ჯერზე იდეალურად მუშაობს როგორც ხედავთ.

მხოლოდ ამ პროცედურის გავლის შემდეგ არის პროგრამირება შესაძლებელი.

ან უბრალოდ ვიწერთ ნებისმიერ ხელსაწყოს. ეკლიპს, ნეტბინს და ვაინსტალირებთ რომელსაც JDK ავტომატურად მოყვება.

სკრინი არის IntelIij IDEA-ან, თქვენც თუ იგივე ხელსაწყოს გამოიყენებთ ბევრად გაგიადვილდებათ აღქმა.

როგორ შევქმნათ პაკეტი, Package. ვხსნით - File> new Project, ვუთითებთ რომელ ფოლდერში გვინდა ჩვენი ნამუშევარის შენახვა, რის შემდგომაც, ვხსნით src > new package > packahe name (პაკეტის სახელი ყოველთვის უნდა იყოს პატარა ბგერებით) პაკეტის შექმნის შემდეგ ვაწვებით მარჯვენა ღილაკს მაუსზე და ვხსნით new > java class რის შემდგომაც გაიხსნება მსგავსი ფანჯარა როგორიც სკრინზეა.

განვიხილოთ რა მოხდა სკრინზე:

სამი ლოგიკური ნაწილისგან შედგება ეს პრიმიტიული პროგრამა;

• 1.     მოვახდინეთ კლასის დეფინირება public class Dzagli
• 2.     მოვახდინეთ მეთოდის დეფინირება public static void main(String[] arguments)
• 3.     მოვახდინეთ ძირითადი main() მეთოდის შიგთავსის კომპილირება.

დაბლა სკრინზე ნახავთ თუ როგორ უნდა მოახდინოთ პროგრამის კომპილირება.

მარჯვენა ღილაკი მაუსზე ხსნის მენიუს სადაც მითითებულ პუნკტს ვაწვებით ან შორთქათით (მითითებული წრე) ვუშვებთ პროგრამას სისტემაში რის შემდეგადაც გვიბრუნდება შედეგი, რომელსაც მარცხენა ქვედა კუთხეში ხედავთ. ჩვენმა პატარა პროგრამამ იდეალურად გაართვა მისიას თავი.

მნიშვნელოვანი ინფორმაცია;

• 1.      ჯავა ანსხვავებს დიდ ბგერებს პატარა ბგერებისგან (A ,a)
• 2.      პროგრამული კოდი ფორმატირებულ უნდა იქნეს სწორად
• 3.      ფაილის სახელი უნდა მეტყველებდეს მის შიგთავსზე. მაგ; პაკეტი cxoveli > Class Dzagli
• 4.      მეთოდები აუცილებლად უნდა მოაქციოთ კლასში.
• 5.      ფრჩხილი { აუცილებლად უნდა გახსნათ იგივე ველზე რომელზეც კლასი იმყოფება, ენთერზე დაწოლის შემდეგ ის ავტომატურად შექმნის დამკეტ ფრჩხილს }
• 6.      კლასის სახელწოდება აუცილებლად უნდა დაიწყოთ დიდი ბგერით class Dzagli < სწორია, class dzagli < შეცდომა!
• 7.      ცვლადების და მეთოდების სახელი უნდა დაიწყოთ პატარა ბგერით. ცვლადი String dzagli; < სწორია. String Dzgali; < მცდარია.  მეთოდი Main(); Print(); Prinf(); < მცდარია, main(); < სწორია.
• 8.      პაკეტის სახელი აუცილებლად პატარა ბგერებით. Kartofili მცდარია, kartofili < სწორია.
• 9.      ჯავას სახელწოდებებისთვის იყენებს camelCase სინტაქს. მაგ: თუ სახელი შედგება ორი სიტყვისგან მეორე სიტყვა ყოველთვის დიდი ბგერით იწყება. firstName,  actionPerformed, learnJava.