ჯავის ენა. შესავალი.

დიდი ხნის განმავლობაში ძნელი წარმოსადგენია კომპიუტერული ჟურნალი ჯავის ენაზე სტატიის გარეშე. მის შესახებ წერდნენ ისეთი პოპულარული გაზეთები და ჟურნალები, როგორებიცაა The New York Times, The Washington Post და Business Week.

შეუძლებელია გავიხსენო, რომ ეროვნულმა საზოგადოებრივმა რადიომ ოდესმე ათი წუთი დაუთმო პროგრამირების ენას. კარგია თუ ცუდი ეს დამოკიდებულია თვალსაზრისზე. 100 მილიონი დოლარის ინვესტიცია წარმოებაში პროგრამული უზრუნველყოფაშექმნილია კონკრეტული პროგრამირების ენის გამოყენებით?! CNN, CNBC და სხვა მედია საშუალებები საუბრობდნენ და ახლაც საუბრობენ იმაზე, თუ როგორ შეუძლია და გააკეთებს ჯავას ამას.

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

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

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

Java ენა, როგორც პროგრამირების ინსტრუმენტი

როგორ გადააჭარბა ჯავას პროგრამირების ენამ თავის სარეკლამო დაპირებებს. უდავოდ, ეს არის ერთ-ერთი საუკეთესო ენა, რომელიც ხელმისაწვდომია სერიოზული პროგრამისტებისთვის. ჯავას აქვს პოტენციალი იყოს შესანიშნავი პროგრამირების ენა, მაგრამ ალბათ უკვე გვიანია. როდესაც ახალი პროგრამირების ენა გამოჩნდება, მაშინვე ჩნდება შემაშფოთებელი პრობლემა მისი თავსებადობის ადრე შექმნილ პროგრამულ უზრუნველყოფასთან. უფრო მეტიც, იმ შემთხვევაშიც კი, თუ ამ პროგრამებში ცვლილებები შეიძლება განხორციელდეს მათი ტექსტის ხელყოფის გარეშე, ძნელია ისეთი ენის შემქმნელებისთვის, რომელსაც საზოგადოება ასე თბილად მიესალმება, როგორიცაა Java ენა, პირდაპირ თქვას: „დიახ, ჩვენ შეიძლება შეცდომა დავუშვი X ვერსიის შემუშავებისას, მაგრამ Y ვერსია უკეთესი იქნება." შედეგად, შემდგომი გაუმჯობესების მოლოდინში, უნდა განვაცხადოთ, რომ ჯავის ენის სტრუქტურა უახლოეს მომავალში მნიშვნელოვნად არ შეიცვლება.

აშკარა კითხვაა: როგორ გაუმჯობესდა Java ენა?გამოდის, რომ ეს გაკეთდა არა თავად პროგრამირების ენის გაუმჯობესებით, არამედ ჯავის ენაზე დაწერილი პროგრამების ბიბლიოთეკების ძირეულად შეცვლით. Sun Microsystems-მა ყველაფერი შეცვალა: ცალკეული ბიბლიოთეკის ფუნქციების სახელებიდან (რაც მათ უფრო მნიშვნელოვნად აქცევს) და გრაფიკული მოდულების ფუნქციონირების მეთოდები (მოვლენების დამუშავების წესის შეცვლით და მუშათა პროგრამების ნაწილობრივ გადაწერით) და დამთავრებული ენის ახალი ფუნქციების შექმნით, როგორიცაა ბეჭდვის საშუალებები, რომლებიც არ იყო Java 1.0-ში. შედეგი არის ბევრად უფრო სასარგებლო პროგრამირების პლატფორმა, ვიდრე ყველა წინა ვერსიებიჯავის ენა.

მაიკროსოფტმა გამოუშვა საკუთარი პროდუქტი J++, რომელიც დაკავშირებულია Java ენასთან. J++ ენა ინტერპრეტირებულია Java ვირტუალური მანქანით თავსებადი ვირტუალური მანქანით ბაიტეკოდის შესრულებისას, მაგრამ გარე კოდის ინტერფეისები მნიშვნელოვნად განსხვავდება ამ ენებს შორის. J++ და Java ენებს აქვთ თითქმის იგივე სინტაქსი. თუმცა, Microsoft-მა შექმნა დამატებითი ენობრივი კონსტრუქციები. ყველა მათგანი საკმაოდ საეჭვო ღირებულებისაა, გარდა Windows ინტერფეისი API. გარდა იმისა, რომ ამ ენებს აქვთ იგივე სინტაქსი, მათი ძირითადი ბიბლიოთეკები (სტრიქონები, კომუნალური პროგრამები, ქსელის პროგრამირების ხელსაწყოები, მრავალძაფის ხელსაწყოები, მათემატიკის ბიბლიოთეკები და ა.შ.) არსებითად იგივეა.

თუმცა, გრაფიკული ბიბლიოთეკები, მომხმარებლის ინტერფეისი და დისტანციურ ობიექტებზე წვდომა სრულიად განსხვავებულია ამ ენებისთვის. ამჟამად, Microsoft-ი აღარ უჭერს მხარს J++ ენას, მან შეიმუშავა ახალი C# ენა, რომელსაც ბევრი მსგავსება აქვს Java-სთან, მაგრამ იყენებს განსხვავებულ ვირტუალურ მანქანას. ეს წიგნი არ მოიცავს J++ ან C#-ს.

ჯავის ენის უპირატესობები

1) Java ენის ერთ-ერთი მთავარი უპირატესობაა დამოუკიდებლობა იმ პლატფორმისგან, რომელზედაც ხორციელდება პროგრამები: იგივე კოდის გაშვება შესაძლებელია Windows, Solaris, Linux, Machintosh და ა.შ. ოპერაციული სისტემებით.
ეს ნამდვილად აუცილებელია, როდესაც პროგრამები ჩამოიტვირთება ინტერნეტით შემდგომი შესრულებისთვის სხვადასხვა ოპერაციული სისტემებით.

2) კიდევ ერთი უპირატესობა არის ის Java ენის სინტაქსი მსგავსია C ++ ენის სინტაქსისა და პროგრამისტებისთვის, რომლებმაც იციან C და C ++ ენები, არ არის რთული მისი სწავლა.. მართალია, პროგრამისტებისთვის, რომლებმაც იციან Visual Basic ენა, ეს სინტაქსი შეიძლება უჩვეულო იყოს.

თუ არასოდეს დაგიპროგრამებიათ C++-ში, ამ სექციაში გამოყენებული ზოგიერთი ტერმინი შეიძლება თქვენთვის გაუგებარი იყოს. ამ შემთხვევაში, შეგიძლიათ გამოტოვოთ იგი. სანამ მე-6 თავის ბოლომდე მიაღწევთ, ეს ტერმინები თქვენთვის ცნობილი გახდება.

3) ასევე, Java - სრულიად ობიექტზე ორიენტირებული ენა, უფრო მეტიც, ვიდრე C++. Java ენის ყველა ერთეული არის ობიექტი, გარდა რამდენიმე პრიმიტიული ტიპისა, როგორიცაა რიცხვები. (რადგან ადვილია რთული პროექტების შემუშავება ობიექტზე ორიენტირებული პროგრამირების გამოყენებით, მან ჩაანაცვლა ძველი სტრუქტურირებული პროგრამირება. თუ არ იცნობთ ობიექტზე ორიენტირებული პროგრამირებას, თავები 3-6 მოგაწვდით ყველა საჭირო ინფორმაციას მის შესახებ.)

თუმცა, საკმარისი არ არის C++ ენის სხვა, ოდნავ გაუმჯობესებული დიალექტის შემუშავება. ფუნდამენტური მნიშვნელობა აქვს, რომ უფრო ადვილია შეცდომების გარეშე პროგრამების შემუშავება Java-ში, ვიდრე C++-ში. რატომ? Java ენის დიზაინერები დიდხანს ფიქრობდნენ იმაზე, თუ რატომ არის C++-ში დაწერილი პროგრამები ასეთი შეცდომებისადმი მიდრეკილი. მათ ჯავას ენას მიაწოდეს ინსტრუმენტები, რათა თავიდან აიცილონ პროგრამების შექმნის შესაძლებლობა, რომლებიც მალავდნენ ყველაზე გავრცელებულ შეცდომებს. ამისათვის შემდეგი კეთდება Java ენაზე.

4) გამორიცხულია მეხსიერების აშკარა განაწილებისა და განთავისუფლების შესაძლებლობა.
Java ენაზე მეხსიერება ავტომატურად თავისუფლდება ნაგვის შეგროვების მექანიზმით. პროგრამისტი გარანტირებულია მეხსიერების არასწორ გამოყენებასთან დაკავშირებული შეცდომებისგან.

5) შემოღებულია ჭეშმარიტი მასივები და აკრძალულია მაჩვენებლის არითმეტიკა.
ახლა პროგრამისტებს, პრინციპში, არ შეუძლიათ მეხსიერებიდან მონაცემების წაშლა ამის გამო ბოროტად გამოყენებამაჩვენებლები.

6) გამორიცხულია მინიჭების ოპერატორის თანასწორობის შედარების ოპერატორთან აღრევის შესაძლებლობა.
ახლა თქვენ ვერც კი შეადგენთ if(ntries = 3) . . . (Visual Basic-ის პროგრამისტებმა შეიძლება საერთოდ ვერ შეამჩნიონ აქ რაიმე პრობლემა, რადგან ეს შეცდომა არის C და C++-ში ყველაზე დაბნეულობის წყარო).

7) მრავალჯერადი მემკვიდრეობა გამორიცხულია. იგი შეიცვალა ახალი კონცეფციით - ინტერფეისი, ნასესხები Objective C ენიდან.
ინტერფეისი აძლევს პროგრამისტს თითქმის ყველაფერს, რაც პროგრამისტმა შეიძლება მოიპოვოს მრავალჯერადი მემკვიდრეობით, ხოლო თავიდან აიცილებს კლასების იერარქიის მართვის სირთულეებს.

Java ენის დამახასიათებელი ნიშნები

მარტივი
ინტერპრეტირებულია
Განაწილებული
სანდო
Უსაფრთხო
მანქანა დამოუკიდებელი
Ობიექტზე ორიენტირებული
მაღალი დონის შესრულება
მრავალძაფიანი
დინამიური
დამოუკიდებელი კომპიუტერული არქიტექტურა

ჩვენ უკვე შევეხეთ ამ რამდენიმე პუნქტს ბოლო ნაწილში. ამ განყოფილებაში ჩვენ: შემოგთავაზებთ ციტატებს Java ენის სახელმძღვანელოდან, რომელიც გამოავლენს ენის მახასიათებლებს; მოდით გავუზიაროთ მკითხველს რამდენიმე მოსაზრება ენის გარკვეული თვისებების შესახებ, მისი უახლესი ვერსიის საკუთარი გამოცდილებიდან გამომდინარე.

მარტივი

გვინდოდა შეგვექმნა ისეთი სისტემა, რომელიც მარტივი დასაპროგრამებელია, არ საჭიროებს დამატებით ტრენინგს და ითვალისწინებს გაბატონებულ პრაქტიკას და პროგრამირების სტანდარტებს. ამიტომ, მიუხედავად იმისა, რომ ჩვენ მიგვაჩნია, რომ C++ ამ მიზნისთვის შეუფერებელია, Java შეიქმნა ისე, რომ იყოს მაქსიმალურად მსგავსი, რათა სისტემა უფრო ხელმისაწვდომი ყოფილიყო. Java ენა არ შეიცავს ბევრ გამოუყენებელ, ბუნდოვან და ბუნდოვან C++ მახასიათებლებს, რომლებიც, ჩვენი აზრით, უფრო მეტ ზიანს აყენებს, ვიდრე კარგს.

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

მაგალითად, ჯავის ენაზე switch განაცხადის სინტაქსი უცვლელი დარჩა. C++ ენის ცოდნით, ადვილი იქნება Java ენის სინტაქსზე გადასვლა.
თუ თქვენ ჩვეულებრივ იყენებთ ვიზუალური პროგრამირების გარემოს (როგორიცაა Visual Basic), Java ენა გაგიჭირდებათ.
მისი სინტაქსი ხშირად საკმაოდ უცნაურად გამოიყურება (თუმცა გამოთქმის მნიშვნელობის გაგება არ არის რთული). რაც მთავარია, ჯავის ენაზე მუშაობისას გაცილებით მეტი უნდა დაპროგრამოთ. Visual Basic ენის სილამაზე ის არის, რომ მისი ვიზუალური პროგრამირების გარემო საშუალებას გაძლევთ თითქმის ავტომატურად შექმნათ აპლიკაციის ინფრასტრუქტურა. Java ენის გამოყენებით იგივე შედეგის მისაღწევად, თქვენ უნდა დაპროგრამოთ ხელით, მაგრამ ეს იწვევს ბევრად უფრო მოკლე პროგრამებს.

თუმცა, არსებობს მესამე სახის პროგრამირების გარემო, რომელიც საშუალებას გაძლევთ შექმნათ პროგრამები "გადაათრიეთ და ჩამოაგდეთ" ტექნოლოგიის გამოყენებით.

სიმარტივის კიდევ ერთი ასპექტი არის სიმოკლე. ჯავის ენის ერთ-ერთი მიზანია უზრუნველყოს პროგრამების შემუშავება, რომლებიც შეიძლება სრულიად დამოუკიდებლად იმუშაონ მცირე მანქანებზე. ძირითადი თარჯიმანი და კლასის მხარდაჭერა არის დაახლოებით 40 KB; სტანდარტული ბიბლიოთეკები და ხრახნიანი ხელსაწყოები (განსაკუთრებით თვითმმართველობის მიკროკერნელი) იღებს კიდევ 17:Kb.
ეს დიდი წარმატებაა. ამასთან, გაითვალისწინეთ, რომ GUI მხარდაჭერის ბიბლიოთეკები გაცილებით დიდია.

Ობიექტზე ორიენტირებული

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

ობიექტზე ორიენტაციამ უკვე დაამტკიცა თავისი ღირსება ბოლო 30 წლის განმავლობაში და ამის გარეშე შეუძლებელია თანამედროვე პროგრამირების ენის წარმოდგენა. მართლაც, Java ენის ობიექტზე ორიენტირებული მახასიათებლები შედარებულია C++-თან. მათ შორის მთავარი განსხვავება მდგომარეობს მრავალჯერადი მემკვიდრეობის მექანიზმში, რისთვისაც ჯავის ენამ იპოვა უკეთესი გამოსავალი, ისევე როგორც ჯავის ენის მეტაკლასის მოდელში.

ასახვის მექანიზმები (თავი 5) და ობიექტების სერიალიზაცია (თავი 12) საშუალებას გაძლევთ განახორციელოთ მუდმივი ობიექტები და ინსტრუმენტები მზა კომპონენტების საფუძველზე გრაფიკული მომხმარებლის ინტერფეისების შესაქმნელად.

თუ არასოდეს დაგიპროგრამებიათ ობიექტზე ორიენტირებულ ენაზე, ყურადღებით დააკვირდით თავებს 4-6. ეს თავები წარმოგიდგენთ ობიექტზე ორიენტირებული პროგრამირების საფუძვლებს და აჩვენებს, თუ როგორ შეიძლება მისი გამოყენება რთული პროექტების შესაქმნელად ტრადიციულ, პროცედურულ ენებზე, როგორიცაა C ან Basic.

Განაწილებული

ჯავას აქვს პროგრამების დიდი ბიბლიოთეკა მონაცემთა გადაცემისთვის TCP/IP (გადაცემის კონტროლის პროტოკოლი/ინტერნეტ პროტოკოლი) პროტოკოლებზე, როგორიცაა HTTP (ჰიპერტექსტის გადაცემის პროტოკოლი) ან FTP (ფაილის გადაცემის პროტოკოლი). ფაილის გადაცემის პროტოკოლი. Java ენაზე დაწერილ აპლიკაციებს შეუძლიათ გახსნან და წვდომა მიიღონ ობიექტებზე ქსელის მეშვეობით დაURL-ები (Uniform Resource Location - უნივერსალური რესურსის მისამართი) როგორც მარტივად ლოკალური ქსელი.

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

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

სანდო

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

ეს ქონება ასევე ძალიან სასარგებლოა. Java ენის შემდგენელი აღმოაჩენს შეცდომებს, რომლებიც სხვა ენებში მხოლოდ გაშვების დროს არის გამოვლენილი. გარდა ამისა, პროგრამისტები, რომლებმაც მრავალი საათი გაატარეს ცუდი მაჩვენებლის გამო მეხსიერების გაფუჭების შეცდომის ძიებაში, ძალიან კმაყოფილი იქნებიან, რომ პრინციპში მსგავსი პრობლემები ვერ წარმოიქმნება Java ენაზე.

თუ ოდესმე დაგიპროგრამებიათ Visual Basic ან COBOL ენებზე, რომლებიც აშკარად არ იყენებენ მაჩვენებლებს, შეიძლება ვერ გაიგოთ, რატომ არის ეს ასე მნიშვნელოვანი. C პროგრამისტები გაცილებით ნაკლებ იღბლიანები არიან. მათ სჭირდებათ მაჩვენებლები სტრიქონებზე, მასივებზე, ობიექტებზე და ფაილებზეც კი წვდომისთვის. Visual Basic-ში პროგრამირებისას არცერთი ეს არ არის საჭირო და პროგრამისტს არ უწევს ფიქრი ამ ერთეულებისთვის მეხსიერების გამოყოფაზე. მეორეს მხრივ, ბევრი მონაცემთა სტრუქტურა ენაზე, რომელსაც არ აქვს მაჩვენებლები, ძალიან რთულია დანერგვა. ჩვეულებრივ სტრუქტურებს, როგორიცაა სტრიქონები და მასივები, არ სჭირდებათ მაჩვენებლები. პოინტერების სრული სიმძლავრე ვლინდება მხოლოდ იქ, სადაც მათი გაუქმება შეუძლებელია, მაგალითად, შექმნისას დაკავშირებული სიები. Java პროგრამისტს სამუდამოდ არ იცავს ცუდი მითითებები, არასწორი განაწილება და მეხსიერების გაჟონვა.

Უსაფრთხო

Java ენა შექმნილია ქსელურ ან განაწილებულ გარემოში გამოსაყენებლად. ამ მიზეზით, დიდი ყურადღება დაეთმო უსაფრთხოებას. Java ენა საშუალებას გაძლევთ შექმნათ სისტემები, რომლებიც დაცულია ვირუსებისგან და ხელყოფისგან.

პირველ გამოცემაში ჩვენ დავწერეთ „არასოდეს თქვა არასოდეს“ და მართალი ვიყავით. პრინსტონის უნივერსიტეტის უსაფრთხოების ექსპერტთა ჯგუფმა აღმოაჩინა უსაფრთხოების პირველი შეცდომები Java 1.0-ში JDK-ის პირველი ვერსიის გაყიდვის შემდეგ მალევე. უფრო მეტიც, მათ და სხვა სპეციალისტებმა განაგრძეს უფრო და უფრო მეტი შეცდომების პოვნა Java ენის ყველა შემდგომი ვერსიის უსაფრთხოების მექანიზმებში.

ამ სიტუაციის დადებითი მხარე, ჯავის ენის განვითარების ჯგუფმა გამოაცხადა ნულოვანი ტოლერანტობა უსაფრთხოების სისტემაში არსებული ნებისმიერი ხარვეზის მიმართ და დაუყოვნებლივ დაიწყო აპლეტის უსაფრთხოების მექანიზმში აღმოჩენილი ნებისმიერი პრობლემის გამოსწორება. კერძოდ, Java ენის თარჯიმნის შიდა სპეციფიკაციების გამოქვეყნებით, Sun-მა გააადვილა ფარული უსაფრთხოების შეცდომების პოვნა და დამოუკიდებელ ექსპერტებს გადასცა.

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

Sun-ის უსაფრთხოების ვებ გვერდს აქვს შემდეგი URL: http://java.sun.com/sfaq/.

აქ არის რამდენიმე სიტუაცია, რომელსაც ჯავის უსაფრთხოების სისტემა ხელს უშლის.

1) შესრულებადი პროგრამის სტეკის გადატვირთვა, რომელიც გამოწვეული იყო ინტერნეტში გავრცელებულმა სამარცხვინო „ჭიამ“.

2) მეხსიერების უბნების დაზიანება, რომლებიც პროცესისთვის გამოყოფილი სივრცის მიღმაა.

3) ლოკალური ფაილების წაკითხვა და ჩაწერა უსაფრთხო კლასის დამტვირთველის გამოყენებისას, როგორიცაა ვებ ბრაუზერი, რომელიც კრძალავს ასეთ ფაილზე წვდომას.

უსაფრთხოების ყველა ეს ზომა შესაბამისია და ჩვეულებრივ მუშაობს უნაკლოდ, მაგრამ დისკრეცია არასოდეს ავნებს. მიუხედავად იმისა, რომ დღემდე აღმოჩენილი ხარვეზები შორს იყო ტრივიალურისგან და მათი პოვნის დეტალები ხშირად გასაიდუმლოებულია, უნდა ვაღიაროთ, რომ Java ენის უსაფრთხოების დადასტურება ალბათ აღარ არის შესაძლებელი.

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

Microsoft-ის მიერ შემოთავაზებული კოდის მიწოდების ალტერნატიული მექანიზმი ეფუძნება ActiveX ტექნოლოგიას და უსაფრთხოებისთვის იყენებს მხოლოდ ციფრულ ხელმოწერებს. ცხადია, ეს საკმარისი არ არის - Microsoft-ის პროგრამული უზრუნველყოფის ნებისმიერ მომხმარებელს შეუძლია დაადასტუროს, რომ ცნობილი მწარმოებლების პროგრამები ხშირად იშლება, რითაც ქმნის მონაცემთა კორუფციის რისკს. უსაფრთხოების სისტემა Java ენაზე ბევრად უფრო ძლიერია ვიდრე ActiveX ტექნოლოგია, რადგან ის აკონტროლებს აპლიკაციას დაწყების მომენტიდან და არ აძლევს მას ზიანის მიყენების საშუალებას.

დამოუკიდებელი არქიტექტურა

შემდგენელი ქმნის ობიექტის ფაილს, რომლის ფორმატი არ არის დამოკიდებული კომპიუტერის არქიტექტურაზე - კომპილირებული პროგრამა შეიძლება შესრულდეს ნებისმიერ პროცესორზე Java პროგრამის შესრულების სისტემის კონტროლის ქვეშ. ამისათვის ჯავის ენის შემდგენელი წარმოქმნის ბრძანებებს, ბაიტიკოდებს, რომლებიც არ არის დამოკიდებული კონკრეტულ კომპიუტერულ არქიტექტურაზე. ბაიტეკოდი შექმნილია ისე, რომ მისი მარტივად ინტერპრეტაცია შესაძლებელია ნებისმიერი მანქანით ან თარგმნილი მანქანაზე დამოკიდებულ კოდში.

Არ არის ახალი იდეა. 20 წელზე მეტი ხნის წინ Niclaus Wirth-ის მიერ შემუშავებული Pascal-ის იმპლემენტაციის სისტემაც და UCSD Pascal-ის სისტემაც იყენებდნენ იგივე ტექნოლოგიას. ბაიტეკოდების გამოყენება დიდ მოგებას იძლევა პროგრამის შესრულებაში (თუმცა სინქრონული კომპილაცია ხშირ შემთხვევაში ანაზღაურებს მას). Java ენის დეველოპერებმა დიდი სამუშაო გააკეთეს ბაიტეკოდის ინსტრუქციების ნაკრების შემუშავებაში, რომლებიც საუკეთესოდ მუშაობს თანამედროვე კომპიუტერები, ადვილად ითარგმნება მანქანის რეალურ ინსტრუქციებში.

მანქანა დამოუკიდებელი

C და C++ ენებისგან განსხვავებით, არ არსებობს Java სპეციფიკაციის ასპექტები, რომლებიც დამოკიდებულია იმპლემენტაციის სისტემაზე. მონაცემთა ძირითადი ტიპების ზომა და მათზე არითმეტიკული ოპერაციები კარგად არის განსაზღვრული.

მაგალითად, ტიპი int Java ენაზე ყოველთვის ნიშნავს 32-ბიტიან მთელ რიცხვს. C და C++-ში, ტიპი int შეიძლება ნიშნავდეს 16-ბიტიან მთელ რიცხვს, 32-ბიტიან ან თვითნებური ზომის მთელ რიცხვს, როგორც ეს არჩეულია კონკრეტული შემდგენელის შემქმნელის მიერ. ერთადერთი შეზღუდვა ის არის, რომ int-ის ზომა არ შეიძლება იყოს მოკლე ინტ-ის ზომაზე ნაკლები და გრძელი ინტის ზომაზე დიდი. რიცხვითი ტიპების ფიქსირებული ზომა თავიდან აიცილებს ბევრ გაღიზიანებას, რომელიც დაკავშირებულია პროგრამების გაშვებასთან სხვადასხვა კომპიუტერები. ორობითი მონაცემები ინახება და გადაიცემა ფიქსირებულ ფორმატში, რაც ასევე თავიდან აიცილებს გაუგებრობას, რომელიც დაკავშირებულია სხვადასხვა ბაიტის წესრიგთან სხვადასხვა პლატფორმაზე (კონფლიქტი „დიდი ენდიანი/პატარა ენდიანი“). ხაზები ინახება სტანდარტული ფორმატი Unicode.

ბიბლიოთეკები, რომლებიც სისტემის ნაწილია, განსაზღვრავენ მანქანიდან დამოუკიდებელ ინტერფეისს. მაგალითად, ენა უზრუნველყოფს აბსტრაქტულ Window კლასს და მის განხორციელებებს Unix, Windows და Macintosh ოპერაციული სისტემებისთვის.

ყველამ, ვინც ოდესმე სცადა დაწერა პროგრამა, რომელიც ერთნაირად კარგად მუშაობს Windows-ზე, Macintosh-ზე და Unix-ის ათ გემოვნებაზე, იცის, რომ ეს ძალიან რთული ამოცანაა. ჯავის ვერსიამ გმირული მცდელობა გააკეთა ამ პრობლემის გადასაჭრელად მარტივი ინსტრუმენტების ნაკრების მიწოდებით, რომელიც ადაპტირებს მომხმარებლის საერთო ინტერფეისის ელემენტებს პროგრამული უზრუნველყოფის პლატფორმების დიდ რაოდენობაზე. სამწუხაროდ, ბიბლიოთეკამ, რომელზედაც დიდი შრომა დაიხარჯა, სხვადასხვა პლატფორმაზე მისაღები შედეგების მიღწევის საშუალება არ მოგვცა. (ამავდროულად, სხვადასხვა პლატფორმაზე გრაფიკულ პროგრამებში სხვადასხვა შეცდომები გამოჩნდა.)

თუმცა, ეს მხოლოდ დასაწყისი იყო. ბევრ აპლიკაციაში, მანქანის დამოუკიდებლობა ბევრად უფრო მნიშვნელოვანია, ვიდრე გრაფიკული მომხმარებლის ინტერფეისის დახვეწილობა. სწორედ ამ აპლიკაციებმა ისარგებლეს Java 1.0-ის დანერგვით. თუმცა, GUI ინსტრუმენტარიუმი ახლა მთლიანად შეიცვალა და აღარ არის დამოკიდებული მასპინძელი კომპიუტერის მომხმარებლის ინტერფეისზე. ახალი ვერსიაუფრო მნიშვნელოვანი და, ჩვენი აზრით, უფრო მიმზიდველი მომხმარებლისთვის, ვიდრე წინა.

ინტერპრეტირებულია

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

შესაძლოა, ეს არის უპირატესობა აპლიკაციის შემუშავებაში, მაგრამ ციტატა აშკარა გაზვიადებულია. ნებისმიერ შემთხვევაში, Java ენის შემდგენელი, რომელიც შედის JSDK-ში (Java Software Development Kit) საკმაოდ ნელია. (ზოგიერთი მესამე სახის შემდგენელი, როგორიცაა IBM, ბევრად უფრო სწრაფია.) ხელახალი კომპილაციის სიჩქარე პროგრამირების გარემოს ეფექტურობის მხოლოდ ერთი ფაქტორია. Java და Visual Basic პროგრამირების გარემოს სიჩქარის შედარება, შესაძლოა იმედგაცრუებული დარჩეთ.

მაღალი დონის შესრულება

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

თუ თარჯიმანი გამოიყენება ბაიტეკოდების შესასრულებლად, არ უნდა გამოიყენოთ ფრაზა " მაღალი დონის შესრულებათუმცა, ბევრ პლატფორმაზე შესაძლებელია სხვა სახის კომპილაცია, რომელსაც უზრუნველყოფს სინქრონული შემდგენელები (Just-in-time compilers-JIT). ისინი თარგმნიან ბაიტიკოდს მანქანაზე დამოკიდებულ კოდში, ინახავენ შედეგს მეხსიერებაში და შემდეგ უწოდებენ მას. როდესაც ეს ინტერპრეტაცია შესრულებულია მხოლოდ ერთხელ, ეს მიდგომა ბევრჯერ ზრდის სიჩქარეს.

მიუხედავად იმისა, რომ სინქრონული შემდგენელები ჯერ კიდევ უფრო ნელია ვიდრე მანქანას სპეციფიკური შემდგენელები, ისინი მაინც ბევრად უფრო სწრაფია ვიდრე ინტერპრეტატორები, რაც უზრუნველყოფს ზოგიერთი პროგრამის 10x ან თუნდაც 20x სიჩქარეს. ეს ტექნოლოგია მუდმივად იხვეწება და საბოლოოდ შეუძლია მიაღწიოს სიჩქარეებს, რომლებსაც ტრადიციული შემდგენელები ვერასოდეს გადააჭარბებენ. მაგალითად, სინქრონულ შემდგენელს შეუძლია განსაზღვროს რომელი კოდის ნაწილი უფრო ხშირად სრულდება და ოპტიმიზაცია მოახდინოს შესრულების სიჩქარისთვის.

მრავალწახნაგოვანი

უზრუნველყოფს უკეთეს ინტერაქტიულობას და პროგრამის შესრულებას.

თუ ოდესმე გიცდიათ მრავალსართულიანი პროგრამირების სხვა ენაზე, სასიამოვნოდ გაგიკვირდებათ, რამდენად ადვილია ამის გაკეთება Java-ში. ჯავის ენაზე ძაფებს შეუძლიათ ისარგებლონ მრავალპროცესორული სისტემებით, თუ ოპერაციული სისტემა ამის საშუალებას იძლევა. სამწუხაროდ, ძაფების დანერგვა უმეტეს პლატფორმებზე ძალიან განსხვავებულია და Java ენის დიზაინერები არ ცდილობენ ერთგვაროვნების მისაღწევად. მხოლოდ ძაფების გამოძახების კოდი რჩება იგივე ყველა აპარატისთვის; ჯავის ენა მრავალთრეადინგის განხორციელებას უტოვებს ფუძემდებლურ ოპერაციულ სისტემას ან threading ბიბლიოთეკას. (ნაკადები აღწერილია მე-2 ტომში.) ამის მიუხედავად, ეს არის ორგანიზების სიმარტივე მრავალძაფიანი გამოთვლაჯავის ენას მიმზიდველს ხდის სერვერის პროგრამული უზრუნველყოფის განვითარებისთვის.

დინამიური

მრავალი თვალსაზრისით, Java უფრო დინამიურია ვიდრე C ან C++. იგი შექმნილია იმისთვის, რომ ადვილად მოერგოს მუდმივად ცვალებად გარემოს. თქვენ შეგიძლიათ თავისუფლად დაამატოთ ახალი მეთოდები და ობიექტები ბიბლიოთეკებში ზიანის მიყენების გარეშე. Java ენა აადვილებს ინფორმაციის მიღებას პროგრამის პროგრესის შესახებ.

ეს ძალიან მნიშვნელოვანია, როდესაც გსურთ დაამატოთ კოდი უკვე გაშვებულ პროგრამაში. ამის მთავარი მაგალითია კოდი, რომელიც ჩამოტვირთულია ინტერნეტიდან ბრაუზერის მიერ შესასრულებლად. Java 1.0-ში ინფორმაციის მიღება შემსრულებელი პროგრამის პროგრესის შესახებ სულაც არ იყო ადვილი, მაგრამ Java ენის ამჟამინდელი ვერსია პროგრამისტს ავლენს შემსრულებელ პროგრამაში ობიექტების სტრუქტურასა და ქცევას.
ეს ძალიან ღირებულია სისტემებისთვის, რომლებმაც უნდა გააანალიზონ ობიექტები პროგრამის შესრულების დროს. ეს სისტემები მოიცავს GUI ინსტრუმენტებს, ჭკვიან გამართულებს, დანამატებს და ობიექტების მონაცემთა ბაზებს.

ჯავის ენა და ინტერნეტი

იდეა მარტივია - მომხმარებლები ინტერნეტიდან ჩამოტვირთავენ Java ბაიტეკოდებს და ამუშავებენ მათ მანქანებზე. Java პროგრამებს, რომლებიც მუშაობს ვებ ბრაუზერებზე, ეწოდება აპლეტები. აპლეტის გამოსაყენებლად გჭირდებათ ვებ ბრაუზერი, რომელიც მხარს უჭერს Java ენას და შეუძლია ბაიტეკოდების ინტერპრეტაცია. Java-ს წყაროს კოდი ლიცენზირებულია Sun-ის მიერ, რომელიც დაჟინებით მოითხოვს როგორც თავად ენის, ასევე მისი ძირითადი ბიბლიოთეკების სტრუქტურის უცვლელობას. სამწუხაროდ, რეალობა ასეთი არ არის. Netscape-ისა და Internet Explorer-ის ბრაუზერების სხვადასხვა ვერსია მხარს უჭერს Java ენის სხვადასხვა ვერსიებს და ზოგიერთი მათგანი საგრძნობლად მოძველებულია. ეს სამწუხარო ვითარება სულ უფრო და უფრო მეტ დაბრკოლებას ქმნის აპლეტების განვითარებაში, რომლებიც სარგებლობენ უახლესი ვერსიაჯავის ენა. ამ პრობლემის გადასაჭრელად Sun-მა შეიმუშავა Java Plug-in, რომელიც უზრუნველყოფს ყველაზე მოწინავე გარემოს Java პროგრამების გასაშვებად, რომელიც დაფუძნებულია Netscape და Internet Explorer ბრაუზერებზე.

აპლეტის ჩატვირთვა ჰგავს სურათის ვებ გვერდზე ჩასმას. აპლეტი ხდება გვერდის ნაწილი და ტექსტი ახვევს მის მიერ დაკავებულ სივრცეს. თუმცა, განსხვავება ისაა, რომ სურათი ახლა ცოცხალია. ის პასუხობს მომხმარებლის ბრძანებებს, ცვლის მას გარეგნობადა უზრუნველყოფს მონაცემთა გადაცემას კომპიუტერს შორის, რომელზედაც ჩანს აპლეტი და კომპიუტერს, რომელიც აკონტროლებს აპლეტს.

აპლეტის ჩატვირთვა ჰგავს სურათის ვებ გვერდზე ჩასმას. აპლეტი ხდება გვერდის ნაწილი და ტექსტი ახვევს მის მიერ დაკავებულ სივრცეს. ფაქტია, რომ გამოსახულება "ცოცხალია". ის პასუხობს მომხმარებლის ბრძანებებს, ცვლის მის გარეგნობას და გადასცემს მონაცემებს კომპიუტერს შორის, რომელიც მუშაობს აპლეტსა და კომპიუტერს შორის.

ნახ. სურათი 1.1 გვიჩვენებს დინამიური ვებ გვერდის კარგ მაგალითს, რომელიც ასრულებს კომპლექსურ გამოთვლებს და იყენებს აპლეტს მოლეკულების დასახატავად. მოლეკულის სტრუქტურის უკეთ გასაგებად, შეგიძლიათ დაატრიალოთ იგი ან გაადიდოთ მაუსის გამოყენებით. ასეთი მანიპულაციები არ შეიძლება განხორციელდეს სტატიკურ ვებ გვერდებზე, მაგრამ აპლეტები შესაძლებელს ხდის. (ეს აპლეტი შეგიძლიათ იხილოთ http://jmol.sourceforge.net.)

ბრინჯი. 1.1. ჯმოლის აპლეტი

აპლეტები შეიძლება გამოყენებულ იქნას ვებ გვერდზე ახალი ღილაკების და ტექსტური ველების დასამატებლად. თუმცა, ასეთი აპლეტები ნელა იტვირთება სატელეფონო ხაზით.

იგივე შეიძლება გაკეთდეს დინამიური HTML-ით, HTML-ის ფორმებით (ჰიპერტექსტის მარკირების ენა) ან სკრიპტირების ენით, როგორიცაა JavaScript. რა თქმა უნდა, პირველი აპლეტები გამიზნული იყო ანიმაციისთვის: დატრიალებული გლობუსი, მოცეკვავე მულტფილმის გმირები, მხატვრული ტექსტები და ა.შ. თუმცა, ზემოთ ჩამოთვლილთა უმეტესობას ასევე შეუძლია ანიმაციური GIF-ების შექმნა, ხოლო დინამიური HTML სკრიპტირებასთან ერთად ბევრად მეტს აკეთებს, ვიდრე აპლეტები.

ბრაუზერის შეუთავსებლობის და ჩამოტვირთვის პროცესის შეუსაბამობის შედეგად ნელი ქსელური კავშირებივებ გვერდებისთვის შექმნილი აპლეტები არ ყოფილა დიდი მიღწევა. ლოკალურ ქსელებში (ინტრანეტებში) სიტუაცია სრულიად განსხვავებულია. მათ ჩვეულებრივ არ აქვთ გამტარუნარიანობის პრობლემები, ამიტომ აპლეტის ჩატვირთვის დრო არ არის მნიშვნელოვანი. ლოკალურ ქსელში შეგიძლიათ აირჩიოთ სასურველი ბრაუზერი ან გამოიყენოთ Java Plug-In. თანამშრომლებს არ შეუძლიათ ქსელში მიწოდებული პროგრამის არასწორ ადგილას გადატანა ან არასწორად დაყენება და სისტემის ადმინისტრატორიარ არის საჭირო ყველა კლიენტის აპარატის გვერდის ავლით და მათზე პროგრამების განახლება. ინვენტარის მართვის, შვებულების დაგეგმვის, მოგზაურობის ანაზღაურებისა და მსგავსი პროგრამების დიდი რაოდენობა შემუშავებულია მრავალი კორპორაციის მიერ აპლტების სახით ბრაუზერების გამოყენებით.

სანამ ჩვენ ვწერდით ამ წიგნს, ქანქარა გადატრიალდა კლიენტის მხარის პროგრამირებიდან სერვერის პროგრამირებაზე. კერძოდ, აპლიკაციის სერვერებს შეუძლიათ გამოიყენონ მონიტორინგის შესაძლებლობები ვირტუალური ხელსაწყო Java ავტომატური დატვირთვის დაბალანსებისთვის, მონაცემთა ბაზის ბმულების გაერთიანებისთვის, ობიექტების სინქრონიზაციისთვის, უსაფრთხო გამორთვისა და გადატვირთვისთვის და სხვა პროცესებისთვის, რომლებიც საჭიროა მასშტაბირებადი სერვერის აპლიკაციებისთვის, რომელთა სწორად განხორციელება თითქმის შეუძლებელია. ამრიგად, პროგრამისტებს, რომლებიც ქმნიან აპლიკაციებს, აქვთ შესაძლებლობა იყიდონ ეს რთული მექანიზმები, ნაცვლად იმისა, რომ თავად განავითარონ ისინი. ამან გაზარდა პროგრამისტების პროდუქტიულობა - ისინი ყურადღებას ამახვილებდნენ თავიანთი პროგრამების ლოგიკაზე, არ აშორებდნენ ყურადღებას სერვერების მუშაობასთან დაკავშირებულ დეტალებს.

Java არის პროგრამირების ენა Sun microsystems-ისგან. თავდაპირველად შეიქმნა როგორც პროგრამირების ენა ელექტრონული მოწყობილობები, მაგრამ მოგვიანებით გამოიყენებოდა სერვერის პროგრამული აპლიკაციების დასაწერად. Java პროგრამები კროს-პლატფორმულია, ანუ მათ შეუძლიათ ნებისმიერ ოპერაციულ სისტემაზე გაშვება.

ჯავის პროგრამირების საფუძვლები

Java, როგორც ობიექტზე ორიენტირებული ენა, მიჰყვება OOP-ის ძირითად პრინციპებს:

• მემკვიდრეობა;
• პოლიმორფიზმი;
• კაფსულაცია.

"ჯავას" ცენტრში, ისევე როგორც სხვა OOP-ებში, არის ობიექტი და კლასი კონსტრუქტორებითა და თვისებებით. უმჯობესია Java პროგრამირების ენის სწავლა დაიწყოთ არა ოფიციალური რესურსებიდან, არამედ დამწყებთათვის სახელმძღვანელოებიდან. ასეთ სახელმძღვანელოებში დეტალურად არის აღწერილი მახასიათებლები, მოცემულია კოდის მაგალითები. წიგნები, როგორიცაა Java პროგრამირების ენა დამწყებთათვის, დეტალურად განმარტავს დასახელებული ენის ძირითად პრინციპებსა და თავისებურებებს.

თავისებურებები

Java პროგრამირების ენაში კოდი ითარგმნება ბაიტიკოდში და შემდეგ სრულდება JVM ვირტუალურ მანქანაზე. ბაიტეკოდში გადაყვანა ხდება Javac, Jikes, Espresso, GCJ. არსებობს შემდგენელები, რომლებიც თარგმნიან C ენას Java-ის ბაიტიკოდში. ამრიგად, C აპლიკაციას შეუძლია ნებისმიერ პლატფორმაზე გაშვება.

"ჯავას" სინტაქსი ხასიათდება შემდეგი მახასიათებლებით:

1. კლასების სახელები უნდა დაიწყოს დიდი ასოებით. თუ სახელი შედგება რამდენიმე სიტყვისგან, მაშინ მეორე უნდა დაიწყოს დიდი ასოებით.
2. თუ მეთოდის ფორმირებისთვის გამოყენებულია რამდენიმე სიტყვა, მაშინ მათგან მეორე უნდა დაიწყოს დიდი ასოთი.
3. დამუშავება იწყება main() მეთოდით - ის ყველა პროგრამის ნაწილია.

ტიპები

Java პროგრამირების ენას აქვს 8 პრიმიტიული ტიპი. ისინი წარმოდგენილია ქვემოთ.

• Boolean არის ლოგიკური ტიპი, რომელიც იღებს მხოლოდ ორ მნიშვნელობას "true" და "false".
• ბაიტი არის ყველაზე პატარა რიცხვის ტიპი, რომლის ზომაა 1 ბაიტი. იგი გამოიყენება ფაილებთან ან ნედლეულ ბინარულ მონაცემებთან მუშაობისას. აქვს დიაპაზონი -128-დან 127-მდე.
• Short-ს აქვს დიაპაზონი -32768-დან 32767-მდე და გამოიყენება რიცხვების წარმოსაჩენად. ამ ტიპის ცვლადების ზომაა 2 ბაიტი.
• Int ასევე ნიშნავს რიცხვებს, მაგრამ მისი ზომა არის 4 ბაიტი. ის ყველაზე ხშირად გამოიყენება მთელ რიცხვებთან სამუშაოდ, ხოლო ბაიტი და მოკლე ხანდახან დაწინაურებულია int-ზე.
• Long გამოიყენება დიდი რიცხვებისთვის. შესაძლო მნიშვნელობები მერყეობს -9223372036854775808-დან 9223372036854775807-მდე.
• Float და double გამოიყენება წილადების აღსანიშნავად. მათი განსხვავება იმაში მდგომარეობს, რომ ათწილადი მოსახერხებელია, როდესაც არ არის საჭირო მაღალი სიზუსტე რიცხვის ფრაქციულ ნაწილში.
• Double აჩვენებს ყველა სიმბოლოს „.“-ს შემდეგ, ხოლო float - მხოლოდ პირველს.
• სტრიქონი არის ყველაზე ხშირად გამოყენებული პრიმიტიული ტიპი, რომლითაც ხდება სიმების განსაზღვრა.

კლასები და ობიექტები

კლასები და ობიექტები მნიშვნელოვან როლს თამაშობენ დამწყებთათვის Java პროგრამირების ენის შესწავლაში.

კლასი განსაზღვრავს ობიექტის შაბლონს, მას უნდა ჰქონდეს ატრიბუტები და მეთოდები. მის შესაქმნელად გამოიყენეთ Class საკვანძო სიტყვა. თუ ის ცალკე ფაილშია შექმნილი, მაშინ კლასისა და ფაილის სახელი უნდა იყოს იგივე. თავად სახელი შედგება ორი ნაწილისაგან: სახელი და გაფართოება.ჯავა.

Java-ში შეგიძლიათ შექმნათ ქვეკლასი, რომელიც მემკვიდრეობით მიიღებს მშობლის მეთოდებს. ამისთვის გამოიყენება სიტყვა extensions:

• class classname აფართოებს superclassname();

კონსტრუქტორი ნებისმიერი კლასის წევრია, მაშინაც კი, თუ ის აშკარად არ არის მითითებული. ამ შემთხვევაში, შემდგენელი ქმნის მას დამოუკიდებლად:

• საჯარო კლასი კლასი( საჯარო კლასი()( ) საჯარო კლასი(სტრიქონის სახელი)( ))

კონსტრუქტორის სახელი იგივეა, რაც კლასის სახელი, ნაგულისხმევად მას აქვს მხოლოდ ერთი პარამეტრი:

• საჯარო ლეკვი (სტრიქონის სახელი)

ობიექტი იქმნება კლასიდან new() ოპერატორის გამოყენებით:

• წერტილი p = new Point()

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

წერტილი p = new Point()

კლასი ორი ქულა (

საჯარო სტატიკური სიცარიელე მთავარი (სტრიქონი არგები) (

წერტილი p1 = new Point();

წერტილი p2 = new Point();

ობიექტის ცვლადები და ობიექტები სრულიად განსხვავებული არსებებია. ობიექტის ცვლადები არის ბმულები. მათ შეუძლიათ მიუთითონ არაპრიმიტიული ტიპის ნებისმიერ ცვლადზე. C++-ისგან განსხვავებით, მათი ტიპის კონვერტაცია მკაცრად რეგულირდება.

სფეროები და მეთოდები

ველი არის ყველა ცვლადი, რომელიც დაკავშირებულია კლასთან ან ობიექტთან. ისინი ნაგულისხმევად ლოკალურია და მათი გამოყენება სხვა კლასებში შეუძლებელია. ოპერატორი "." გამოიყენება ველებზე წვდომისთვის:

• კლასის სახელის ცვლადი

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

განხორციელდა ცვლადების იმპორტის შესაძლებლობა სხვა პაკეტებიდან წვდომის მისაღებად:

• იმპორტი სტატიკური კლასის სახელი;

მეთოდი არის ქვეპროგრამა იმ კლასებისთვის, რომლებშიც ის დეკლარირებულია. აღწერილია იმავე დონეზე, როგორც ცვლადები. მითითებულია როგორც ფუნქცია და შეიძლება იყოს ნებისმიერი ტიპის, მათ შორის ბათილად:

• კლასის წერტილი ( int x, y;

  void init(int a, int b) (

ზემოთ მოყვანილ მაგალითში Point კლასს აქვს მთელი რიცხვი x და y, init() მეთოდი. მეთოდებზე წვდომა, ისევე როგორც ცვლადებზე, ხდება "." ოპერატორის გამოყენებით:

• წერტილი.init();

init თვისება არაფერს აბრუნებს, ამიტომ არის void ტიპის.

ცვლადები

Java პროგრამირების ენის სახელმძღვანელოში ცვლადები ცალკე ადგილს იკავებს. ყველა ცვლადს აქვს კონკრეტული ტიპი, ის განსაზღვრავს მნიშვნელობების შესანახად საჭირო ადგილს, შესაძლო მნიშვნელობების დიაპაზონს, ოპერაციების ჩამონათვალს. მნიშვნელობების მანიპულირებამდე, ცვლადები გამოცხადებულია.



შესაძლებელია რამდენიმე ცვლადის გამოცხადება ერთდროულად. მძიმით გამოიყენება მათი ჩამოთვლა:

• int a, b, c;

ინიციალიზაცია ხდება დეკლარაციის შემდეგ ან მის დროს:

int a = 10, b = 10;

არსებობს რამდენიმე ტიპი:

• ლოკალური ცვლადები (ლოკალური);
• ინსტანციის ცვლადები (ინსტანციის ცვლადები);
• სტატიკური ცვლადები (სტატიკური).

ლოკალური ცვლადები დეკლარირებულია მეთოდებში და კონსტრუქტორებში, ისინი იქმნება ამ უკანასკნელის გაშვებისას და განადგურებულია დასრულების შემდეგ. მათთვის აკრძალულია წვდომის მოდიფიკატორების მითითება და ხელმისაწვდომობის დონის კონტროლი. ისინი არ ჩანს დეკლარირებული ბლოკის გარეთ. Java-ში ცვლადებს არ აქვთ საწყისი მნიშვნელობა, ამიტომ ისინი პირველ გამოყენებამდე უნდა იყოს მინიჭებული.

ინსტანციის ცვლადები უნდა გამოცხადდეს კლასში. ისინი გამოიყენება როგორც მეთოდები, მაგრამ მათზე წვდომა შესაძლებელია მხოლოდ ობიექტის შექმნის შემდეგ. ცვლადი განადგურებულია ობიექტის განადგურებისას. ინსტანციის ცვლადებს, ლოკალური ცვლადებისგან განსხვავებით, აქვთ ნაგულისხმევი მნიშვნელობები:

• ნომრები - 0;
• ლოგიკა - ყალბი;
• მითითებები ნულოვანია.

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

• საბოლოო;
• კერძო;
• საჯარო.

გაუშვით პროგრამის დასაწყისში, განადგურებულია შესრულების შეწყვეტის შემდეგ. მაგალითად, ცვლადების მსგავსად, მათ აქვთ ნაგულისხმევი მნიშვნელობები, რომლებიც ენიჭება ცარიელ ცვლადებს. რიცხვებს აქვს მნიშვნელობა 0, ლოგიკურს აქვს მნიშვნელობა false, ობიექტის მითითებები თავდაპირველად ნულოვანია. სტატიკური ცვლადები ეწოდება შემდეგი ფორმით:

• ClassName.VariableName.

Მენაგვე

Java პროგრამირების ენა დამწყებთათვის სახელმძღვანელოში ყველაზე საინტერესოა ნაგვის შემგროვებლის ავტომატური განყოფილება.



ჯავაში, C ენისგან განსხვავებით, ეს შეუძლებელია ხელით მოხსნაობიექტი მეხსიერებიდან. ამისათვის დანერგილია ავტომატური წაშლის მეთოდი - ნაგვის შემგროვებელი. ტრადიციული წაშლით null-ით, მხოლოდ ობიექტის მითითება წაიშლება და თავად ობიექტი წაიშლება. არსებობს ნაგვის იძულებითი შეგროვების მეთოდები, თუმცა ისინი არ არის რეკომენდებული ნორმალური გამოყენებისთვის.

გამოუყენებელი ობიექტების ავტომატური წაშლის მოდული მუშაობს ფონზე და იწყება მაშინ, როდესაც პროგრამა არააქტიურია. მეხსიერებიდან ობიექტების გასასუფთავებლად, პროგრამა ჩერდება, მეხსიერების გათავისუფლების შემდეგ, შეწყვეტილი ოპერაცია განახლდება.

მოდიფიკატორები

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



დაცული მოდიფიკატორი მოქმედებით მსგავსია საჯარო - ის ხსნის წვდომას კლასის ველებზე. ორივე შემთხვევაში, ცვლადები შეიძლება გამოყენებულ იქნას სხვა კლასებში. მაგრამ საჯარო მოდიფიკატორი ხელმისაწვდომია აბსოლუტურად ყველასთვის, ხოლო დაცული მოდიფიკატორი ხელმისაწვდომია მხოლოდ მემკვიდრეობით მიღებული კლასებისთვის.

მოდიფიკატორი, რომელიც გამოიყენება მეთოდების შექმნისას, არის სტატიკური. ეს ნიშნავს, რომ გენერირებული მეთოდი არსებობს კლასის ინსტანციებისგან დამოუკიდებლად. საბოლოო მოდიფიკატორი არ აკონტროლებს წვდომას, მაგრამ მიუთითებს ობიექტის მნიშვნელობებით შემდგომი მანიპულირების შეუძლებლობაზე. ის კრძალავს ელემენტის შეცვლას, რომლისთვისაც არის მითითებული.

ველებისთვის საბოლოო შეუძლებელს ხდის ცვლადის პირველი მნიშვნელობის შეცვლას:

საჯარო სტატიკური სიცარიელის მეთოდი (სტრიქონი არგები) (

საბოლოო int სახელი = 1;

int Name = 2;// შეცდომას გაუშვებს

საბოლოო მოდიფიკატორის მქონე ცვლადები მუდმივებია. ისინი ჩვეულებრივ იწერება მხოლოდ დიდი ასოებით. CamelStyle და სხვა გზები არ მუშაობს.

მეთოდების საბოლოო ვერსია მიუთითებს მემკვიდრეობით კლასში მეთოდის შეცვლის აკრძალვაზე:

საბოლოო void myMethod() (

System.out.printIn("Hello World");

კლასებისთვის საბოლოო ნიშნავს, რომ თქვენ არ შეგიძლიათ შექმნათ კლასების შთამომავლები:

ბოლო საჯარო კლასის კლასი (

Abstract - მოდიფიკატორი აბსტრაქტული კლასების შესაქმნელად. ნებისმიერი აბსტრაქტული კლასი და აბსტრაქტული მეთოდები გამიზნულია სხვა კლასებში და ბლოკებში შემდგომი გაფართოებისთვის. მოდიფიკატორიგარდამავალი ეუბნება ვირტუალურ მანქანას არ დაამუშავოს მოცემული ცვლადი. ამ შემთხვევაში, ის უბრალოდ არ დაზოგავს. მაგალითად, გარდამავალი int Name = 100 არ შენარჩუნდება, მაგრამ int b იქნება.

პლატფორმები და ვერსიები

Java პროგრამირების ენების არსებული ოჯახები:

• სტანდარტული გამოცემა.
• Enterprise Edition.
• მიკრო გამოცემა.
• ბარათი.



1. SE - არის მთავარი, ფართოდ გამოიყენება ინდივიდუალური გამოყენებისთვის საბაჟო აპლიკაციების შესაქმნელად.
2. EE არის სპეციფიკაციების ნაკრები საწარმოს პროგრამული უზრუნველყოფის განვითარებისთვის. ის შეიცავს უფრო მეტ ფუნქციას, ვიდრე SE, ამიტომ გამოიყენება კომერციული მასშტაბით მსხვილ და საშუალო საწარმოებში.
3. ME - განკუთვნილია შეზღუდული სიმძლავრისა და მეხსიერების მქონე მოწყობილობებისთვის, მათ ჩვეულებრივ აქვთ ეკრანის მცირე ზომა. ასეთი მოწყობილობებია სმარტფონები და PDA, მიმღებები ციფრული ტელევიზია.
4. ბარათი - განკუთვნილია უკიდურესად შეზღუდული გამოთვლითი რესურსების მქონე მოწყობილობებისთვის, როგორიცაა სმარტ ბარათები, სიმ ბარათები, ბანკომატები. ამ მიზნებისათვის შეიცვალა ბაიტეკოდი, პლატფორმის მოთხოვნები და ბიბლიოთეკების კომპონენტები.

განაცხადი

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

აქტიურად გამოიყენება ანდროიდის აპლიკაციებისთვის. პროგრამა შედგენილია არასტანდარტულ ბაიტეკოდში და შესრულებულია ART ვირტუალურ მანქანაზე. Android Studio გამოიყენება კომპილაციისთვის. Google-ის ეს IDE არის Android-ის განვითარების ოფიციალური IDE.

Microsoft-მა შეიმუშავა Java Virtual Machine MSJVM-ის საკუთარი იმპლემენტაცია. მას ჰქონდა ისეთი განსხვავებები, რამაც დაარღვია კროს-პლატფორმის ფუნდამენტური კონცეფცია - არ არსებობდა ზოგიერთი ტექნოლოგიებისა და მეთოდების მხარდაჭერა, იყო არასტანდარტული გაფართოებები, რომლებიც მუშაობდნენ მხოლოდ Windows პლატფორმაზე. მაიკროსოფტმა გამოუშვა J# ენა, რომლის სინტაქსი და საერთო ოპერაცია ძალიან ჰგავს Java-ს. ის არ შეესაბამებოდა ოფიციალურ სპეციფიკაციას და საბოლოოდ ამოიღეს სტანდარტული Microsoft Visual Studio დეველოპერის ხელსაწყოთა ნაკრებიდან.

Java პროგრამირების ენა და გარემო

პროგრამული უზრუნველყოფის განვითარება ხორციელდება შემდეგ IDE-ებში:

1. NetBeans IDE.
2. Eclipse IDE.
3. IntelliJ IDEA.
4. jდეველოპერი.
5. ჯავა iOS-ისთვის.
6. გეანი.

JDK განაწილებულია Oracle-ის მიერ, როგორც Java Development Kit. მოყვება შემდგენელი, სტანდარტული ბიბლიოთეკები, კომუნალური საშუალებები, აღმასრულებელი სისტემა. თანამედროვე ინტეგრირებული განვითარების გარემო ეყრდნობა JDK-ს.

მოსახერხებელია კოდის ჩაწერა Java პროგრამირების ენაზე Netbeans-ში და Eclipse IDE-ში. ეს არის უფასო ინტეგრირებული განვითარების გარემო, ისინი შესაფერისია ყველა Java პლატფორმისთვის. ასევე გამოიყენება პროგრამირებისთვის Python, PHP, JavaScript, C++.

IntelliJ IDE Jetbrains-ისგან განაწილებულია ორ ვერსიად: უფასო და კომერციული. მხარს უჭერს კოდის დაწერას ბევრ პროგრამირების ენაზე, არის მესამე მხარის დანამატები დეველოპერებისგან, რომლებიც ახორციელებენ კიდევ უფრო მეტ პროგრამირების ენას.

JDeveloper არის Oracle-ის კიდევ ერთი განვითარება. მთლიანად Java-ზეა დაწერილი, ამიტომ მუშაობს ყველა ოპერაციულ სისტემაზე.

შესავალი

ეს ნამუშევარი ეძღვნება დღეს ერთ-ერთ ყველაზე პერსპექტიულ პროგრამირების ენას - Java ენას. ტექნოლოგიას სახელწოდებით "ჯავა", გაზვიადების გარეშე, შეიძლება ეწოდოს რევოლუციური პროგრამული უზრუნველყოფის განვითარების ინდუსტრიაში.

დახარისხება შეიძლება განხორციელდეს სხვა პროგრამირების ენებში, როგორიცაა PHP, C++ და ა.შ. ჯავაში უბრალოდ ბევრად მომგებიანია. დეტალები განიხილება ქვემოთ. სიახლე მდგომარეობს იმაში, რომ ამ ენაზე და ამ ინტერპრეტაციაში ადრე არ განხორციელებულა დახარისხების პროგრამა.

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

Java პროგრამირების ენის აღწერა

ჯავის ზოგადი მახასიათებლები

ჯავის ენა არჩეული იყო დამლაგებელი პროგრამის დასაწერად. Java არის ობიექტზე ორიენტირებული პროგრამირების ენა, რომელიც შეიქმნა Sun Microsystems-ის მიერ 1991 წლიდან და ოფიციალურად გამოვიდა 1995 წლის 23 მაისს. თავდაპირველად, ახალ პროგრამირების ენას ეწოდა Oak (ჯეიმს გოსლინგი) და შეიქმნა სამომხმარებლო ელექტრონიკისთვის, მაგრამ მოგვიანებით დაარქვეს Java და დაიწყო გამოყენება აპლეტების, აპლიკაციების და სერვერის პროგრამული უზრუნველყოფის დასაწერად.

Java პროგრამირების ენა არ ჰგავს სხვა არსებულს. ის შექმნილია იმისთვის, რომ გაადვილოს WWW-ში კომპიუტერებზე მუშაობა ბრაუზერების საშუალებით. დღესდღეობით, ყველა კომპიუტერს აქვს ბრაუზერი. თავის მხრივ, თითოეული ბრაუზერი მხარს უჭერს Java-ს. ეს ნიშნავს, რომ თქვენ შეგიძლიათ ნახოთ დოკუმენტები, რომლებიც ინახება მთელ მსოფლიოში და, ბმულზე დაწკაპუნებით, გაააქტიუროთ Java პროგრამა, რომელიც გადაიცემა ქსელში და იმუშავებს თქვენს კომპიუტერში.

Java ენის ერთ-ერთი მთავარი უპირატესობა არის მისი დამოუკიდებლობა პლატფორმისგან და კომპიუტერის ტიპისა, რომელზედაც მუშაობს პროგრამები. ამგვარად, იგივე კოდის გაშვება შესაძლებელია Windows, Linux, FreeBSD, Solaris, Apple Mac და ა.შ ოპერაციული სისტემებით. ეს ხდება ძალიან მნიშვნელოვანი, როდესაც პროგრამები იტვირთება გლობალური ინტერნეტით და გამოიყენება სხვადასხვა პლატფორმებზე. Java პროგრამირების ენას შეუძლია იმუშაოს არა მხოლოდ სტატიკურ ტექსტებთან და გრაფიკასთან, არამედ სხვადასხვა დინამიურ ობიექტებთან.

Java-ის კიდევ ერთი თანაბრად მნიშვნელოვანი უპირატესობა არის მისი დიდი მსგავსება C++ პროგრამირების ენასთან. ამიტომ, იმ პროგრამისტებისთვის, რომლებიც იცნობენ C და C ++ სინტაქსს, ადვილი იქნება Java-ს სწავლა.

ასევე, Java არის სრულიად ობიექტზე ორიენტირებული ენა, უფრო მეტიც, ვიდრე C++. Java ენის ყველა ერთეული არის ობიექტი, გარდა რამდენიმე პრიმიტიული ტიპისა, როგორიცაა რიცხვები.

ასევე მნიშვნელოვანია, რომ ბევრად უფრო ადვილია Java-ში პროგრამების შემუშავება, რომლებიც არ შეიცავს შეცდომებს, ვიდრე C ++-ში.

საქმე იმაშია, რომ Java ენის შემქმნელებმა Sun კომპანიისგან განახორციელეს პროგრამების ფუნდამენტური ანალიზი C ++ ენაზე. გაანალიზდა წყაროს კოდის „ბოსტნეები“, რაც იწვევს ძნელად ამოსაცნობი შეცდომების გამოჩენას. აქედან გამომდინარე, მიღებულ იქნა გადაწყვეტილება ჯავას ენის შემუშავების შესაძლებლობით, რათა შეიქმნას პროგრამები, რომლებიც მალავს ყველაზე გავრცელებულ შეცდომებს.

ამისთვის გაკეთდა შემდეგი:

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

მაგალითად, Java-ში მეხსიერება ავტომატურად თავისუფლდება ნაგვის შეგროვების გზით. გამოდის, რომ პროგრამისტი დაზღვეულია იმ შეცდომებისგან, რომლებიც წარმოიქმნება მეხსიერების არასწორი გამოყენებისგან.

ჭეშმარიტი მასივების დანერგვა და მაჩვენებლების აკრძალვა.

ახლა პროგრამისტებს არ შეუძლიათ მეხსიერებიდან მონაცემების წაშლა მაჩვენებლების არასწორი გამოყენების გამო.

გამორიცხული იყო მინიჭების ოპერატორის შედარების ოპერატორთან თანასწორობის აღრევის შესაძლებლობა. როგორც წესი, "=" ნიშნის პრობლემა ძალიან ხშირად იწვევს ლოგიკურ შეცდომებს C და C ++-ში, რომელთა აღმოჩენა არც ისე ადვილია. განსაკუთრებით დიდ პროგრამებში.

მრავალჯერადი მემკვიდრეობა სრულიად გამორიცხულია. იგი შეიცვალა ახალი კონცეფციით - ინტერფეისით, რომლის იდეაც Objective C ენიდან იყო ნასესხები.

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

უახლესი ვერსია არის ვერსია 1.6, რომელმაც გააუმჯობესა უსაფრთხოება, გაუმჯობესდა მხარდაჭერა Mozilla Rhino სკრიპტირების ენისთვის, გაუმჯობესდა დესკტოპის ინტეგრაცია და დაამატა რამდენიმე ახალი ფუნქცია გრაფიკული ინტერფეისების შესაქმნელად.

ჯავა და მაიკროსოფტი

შემდეგი კომპანიები ძირითადად ყურადღებას ამახვილებენ Java (J2EE) ტექნოლოგიებზე და არა .NET-ზე, თუმცა ამ უკანასკნელთანაც საქმე აქვთ: IBM, Oracle. კერძოდ, Oracle DBMS მოიცავს JVM-ს, როგორც მის კომპონენტს, რომელიც უზრუნველყოფს DBMS-ის პირდაპირ დაპროგრამების შესაძლებლობას Java ენაზე, მაგალითად, შენახული პროცედურების ჩათვლით.

ძირითადი მახასიათებლები

პროგრამის მაგალითი

პროგრამა, რომელიც ბეჭდავს "Hello, World!":

საჯარო კლასი HelloWorld (public static void main (String args) ( System .out .println ("Hello, World!") ;) )

შაბლონების გამოყენების მაგალითი:

java.util.* იმპორტი; საჯარო კლასის ნიმუში ( public static void main (string args) ( // შექმენით ობიექტი შაბლონიდან.სია strings = ახალი LinkedList () ; strings.add("გამარჯობა" ); strings.add("მსოფლიო" ); strings.add("!"); for (String s: strings) ( System .out .print (s) ; System .out .print (" " ) ;) ) )

ძირითადი იდეები

პრიმიტიული ტიპები

ჯავის ენაში არსებობს მხოლოდ 8 სკალარული ტიპი: ლოგიკური, ბაიტი, char, მოკლე, int, long, float, double.

შეფუთვის კლასები პრიმიტიული ტიპებისთვის

პრიმიტიული ტიპების სიგრძე და მნიშვნელობების დიაპაზონი განისაზღვრება სტანდარტით, და არა განხორციელება და მოცემულია ცხრილში. ლოკალიზაციის მოხერხებულობისთვის char ტიპი გაკეთდა ორ ბაიტად (ჯავას ერთ-ერთი იდეოლოგიური პრინციპი): როდესაც სტანდარტი ჩამოყალიბდა, Unicode-16 უკვე არსებობდა, მაგრამ არა Unicode-32. ვინაიდან შედეგში ერთი ბაიტის ტიპი არ დარჩა, დაემატა ახალი ბაიტი. float და double ტიპებს შეიძლება ჰქონდეთ სპეციალური მნიშვნელობები და "არ არის რიცხვი" (

ტიპი	სიგრძე (ბაიტებში)	დიაპაზონი ან მნიშვნელობების ნაკრები
ლოგიკური	განუსაზღვრელი	ჭეშმარიტი და ცრუ
ბაიტი	1	−128..127
char	2	0..2 16 -1, ან 0..65535
მოკლე	2	−2 15 ..2 15 -1, ან −32768..32767
ინტ	4	−2 31 ..2 31 -1, ან −2147483648..2147483647
გრძელი	8	−2 63 ..2 63 -1, ან დაახლოებით −9.2 10 18 ..9.2 10 18
ათწილადი	4	-(2-2 -23) 2 127 ..(2-2 -23) 2 127 , ანუ დაახლოებით −3.4 10 38 ..3.4 10 38 , ისევე როგორც , , NaN
ორმაგი	8	-(2-2 -52) 2 1023 ..(2-2 -52) 2 1023 , ან დაახლოებით −1,8 10 308 ..1,8 10 308 , და ასევე , , NaN

ასეთი ხისტი სტანდარტიზაცია აუცილებელი იყო ენის პლატფორმისგან დამოუკიდებელი გამხდარიყო, რაც ჯავის ერთ-ერთი იდეოლოგიური მოთხოვნა და მისი წარმატების ერთ-ერთი მიზეზია. მიუხედავად ამისა, ერთი პატარა პრობლემა პლატფორმის დამოუკიდებლობასთან დაკავშირებით მაინც დარჩა. ზოგიერთი პროცესორი იყენებს 10-ბაიტიან რეგისტრებს შედეგების შუალედური შესანახად ან სხვა გზით აუმჯობესებს გამოთვლების სიზუსტეს. იმისათვის, რომ ჯავა მაქსიმალურად თავსებადობა ყოფილიყო სხვადასხვა სისტემებს შორის, ადრეულ ვერსიებში აკრძალული იყო გამოთვლების სიზუსტის გაუმჯობესების ნებისმიერი გზა. თუმცა, ამან გამოიწვია ნელი შესრულება. გაირკვა, რომ ცოტას სჭირდება სიზუსტის გაუარესება პლატფორმის დამოუკიდებლობისთვის, მით უმეტეს, თუ მათ უნდა გადაიხადონ პროგრამების მუშაობის შენელებით. მრავალი პროტესტის შემდეგ, ეს აკრძალვა მოიხსნა, მაგრამ ზუსტი გაფართოების გასათიშად დაემატა მკაცრი fp საკვანძო სიტყვა.

გარდაქმნები მათემატიკურ ოპერაციებში

Java ენას აქვს შემდეგი წესები:

1. თუ ერთი ოპერანდი არის double ტიპის, მეორე ასევე გარდაიქმნება ტიპის double.
2. წინააღმდეგ შემთხვევაში, თუ ერთი ოპერანდი არის float ტიპის, მეორე ასევე გარდაიქმნება ტიპის float.
3. წინააღმდეგ შემთხვევაში, თუ ერთი ოპერანდი არის long ტიპის, მეორე ასევე გარდაიქმნება long type.
4. წინააღმდეგ შემთხვევაში, ორივე ოპერანდი გარდაიქმნება ტიპის int.

ბოლო წესი განასხვავებს Java-ს ძველი იმპლემენტაციებისგან და C++-ისგან და ხდის კოდს უფრო უსაფრთხოს. ასე, მაგალითად, ჯავის ენაზე, კოდის შესრულების შემდეგ

მოკლე x = 50 , y = 1000 ; int z = x*y;

z ცვლადს ენიჭება მნიშვნელობა 50000 და არა −15536, როგორც C და C++-ის უიმედოდ მოძველებული იმპლემენტაციების უმეტესობაში. პროგრამაში, რომელიც შედგენილია MS VC++-ის მიერ მე-7 ვერსიიდან, ისევე როგორც მრავალი სხვა თანამედროვე შემდგენელის მიერ (gcc, Intel C++, Borland C++, Comeau და ა.შ.), ღირებულება ასევე იქნება 50000.

ობიექტის ცვლადები, ობიექტები, ცნობები და მაჩვენებლები

Java ენას აქვს მხოლოდ დინამიურად შექმნილი ობიექტები. უფრო მეტიც, ობიექტის ტიპის ცვლადები და ობიექტები Java-ში სრულიად განსხვავებული ერთეულებია. ობიექტის ტიპის ცვლადები არის მიმართვები, ანუ იმპლიციტური მაჩვენებლები დინამიურად შექმნილ ობიექტებზე. ამას ხაზს უსვამს ცვლადების დეკლარაციის სინტაქსი. მაგალითად, ჯავაში არ შეგიძლიათ დაწეროთ:

ორმაგი a[10] [20]; Foo b(30) ;

Double a = ახალი ორმაგი [10] [20]; Foo b = new Foo(30) ;

დავალებების, ქვეპროგრამებზე გადასვლისა და შედარებების დროს, ობიექტის ცვლადები იქცევიან მაჩვენებლების მსგავსად, ანუ ხდება ობიექტების მისამართების მინიჭება, კოპირება და შედარება. და მონაცემთა ველებზე ან ობიექტის მეთოდებზე წვდომისას ობიექტის ცვლადის გამოყენებით, არ არის საჭირო სპეციალური გადამისამართების ოპერაციები - ეს წვდომა შესრულებულია ისე, თითქოს ობიექტის ცვლადი იყოს თავად ობიექტი.

ობიექტის ცვლადები არის ნებისმიერი ტიპის ცვლადები, გარდა მარტივი რიცხვითი ტიპებისა. ჯავაში არ არის აშკარა მითითებები. C, C++ და სხვა პროგრამირების ენების პოინტერებისგან განსხვავებით, Java-ში მითითებები ძალზედ დაცულია მათი გამოყენების მკაცრი შეზღუდვების გამო, კერძოდ:

• თქვენ არ შეგიძლიათ გადაიყვანოთ int ტიპის ან სხვა პრიმიტიული ტიპის ობიექტი პოინტერად ან მითითებად და პირიქით.
• აკრძალულია ბმულებზე ++, −−, +, − ან სხვა არითმეტიკული მოქმედებების შესრულება.
• ცნობებს შორის ტიპის კონვერტაცია მკაცრად რეგულირდება. გარდა მასივის მიმართვებისა, ნებადართულია მხოლოდ ცნობების გადაქცევა მემკვიდრეობით ტიპსა და მის შთამომავალს შორის, ხოლო მემკვიდრეობითი ტიპიდან მემკვიდრეობით ტიპზე გარდაქმნა ცალსახად უნდა იყოს მითითებული და შემოწმებული მნიშვნელოვნებისთვის გაშვების დროს. მასივის მიმართვის კონვერტაცია დასაშვებია მხოლოდ მაშინ, როდესაც მათი ძირითადი ტიპების კონვერტაცია დაშვებულია და არ არის განზომილების კონფლიქტები.
• ჯავაში არ არსებობს ოპერაციები აღების მისამართის (&) ან მისამართების აღებისას (*). ჯავაში ვარსკვლავი ნიშნავს გამრავლებას, სულ ესაა. ამპერსანდი (&) უბრალოდ ნიშნავს "ბიტიურად და" (ორმაგი ამპერსანდი არის "ლოგიკური და").

Java-ში სპეციალურად დანერგილი ასეთი შეზღუდვების გამო, მეხსიერების პირდაპირი მანიპულირება ფიზიკური მისამართების დონეზე შეუძლებელია (თუმცა არის ცნობები, რომლებიც არაფერზე მიუთითებს: ასეთი მითითების მნიშვნელობა აღინიშნება null-ით).

დუბლიკატი ბმულები და კლონირება

იმის გამო, რომ ობიექტის ცვლადები საცნობარო ცვლადებია, მინიჭება არ აკოპირებს ობიექტს. ასე რომ, თუ დაწერთ

ფუ ფუ, ბარი; ... ბარი = ფუ;

შემდეგ მისამართი დაკოპირდება ფუდან ბარამდე. ანუ, foo და bar მიუთითებს იმავე მეხსიერების არეალზე, ანუ იმავე ობიექტზე; foo-ს მიერ მითითებულ ობიექტის ველების შეცვლის მცდელობა შეიცვლება ბარით მითითებულ ობიექტს და პირიქით. თუ გჭირდებათ კიდევ ერთის მიღება კოპირებაწყარო ობიექტი, გამოიყენეთ მეთოდი (წევრის ფუნქცია, C++ ტერმინოლოგიაში) clone(), რომელიც ქმნის ობიექტის ასლს, ან ასლის კონსტრუქტორი.

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

ნაგვის შეგროვება

Java ენაზე შეუძლებელია ობიექტის ცალსახად ამოღება მეხსიერებიდან - ამის ნაცვლად განხორციელებულია ნაგვის შეგროვება. ტრადიციული ხრიკი ნაგვის შემგროვებელს მეხსიერების განაწილების "მინიშნების" მისაცემად არის ცვლადის ნულზე დაყენება. თუმცა, ეს არ ნიშნავს იმას, რომ ობიექტი შეიცვალა null, აუცილებლად და დაუყოვნებლივ წაიშლება. ეს ტექნიკა მხოლოდ ხსნის მითითებას ობიექტზე, ანუ ხსნის მაჩვენებელს მეხსიერებაში არსებული ობიექტიდან. ამ შემთხვევაში, გასათვალისწინებელია, რომ ობიექტი არ წაიშლება ნაგვის შემგროვებლის მიერ, სანამ გამოყენებული ცვლადებიდან ან ობიექტებიდან მინიმუმ ერთი მითითება მიუთითებს მასზე. ასევე არსებობს ნაგვის იძულებითი შეგროვების დაწყების მეთოდები, მაგრამ მათი გამოძახება გარანტირებული არ არის და არ არის რეკომენდებული ნორმალური გამოყენებისთვის.

კლასები და ფუნქციები

Java არ არის პროცედურული ენა: ნებისმიერი ფუნქცია შეიძლება არსებობდეს მხოლოდ კლასში. ამას ხაზს უსვამს Java ენის ტერმინოლოგია, სადაც არ არსებობს „ფუნქციის“ ან „წევრის ფუნქციის“ ცნებები (ინგლ. წევრის ფუნქცია), მაგრამ მხოლოდ მეთოდი. სტანდარტული ფუნქციები ასევე გახდა მეთოდები. მაგალითად, ჯავაში არ არსებობს sin() ფუნქცია, მაგრამ არსებობს Math.sin() მეთოდი Math კლასის (რომელიც, გარდა sin() , შეიცავს cos() , exp() , sqrt() , abs() და მრავალი სხვა მეთოდი).

სტატიკური მეთოდები და ველები

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

ორმაგი x = მათემატიკა .sin(1) ;

მათემატიკა m = new Math(); ორმაგი x = m.sin(1);

სტატიკური მეთოდების შეზღუდვა არის ის, რომ მათ შეუძლიათ მხოლოდ სტატიკურ ველებსა და მეთოდებზე წვდომა ამ ობიექტში.

სტატიკური ველებს აქვთ იგივე მნიშვნელობა, რაც C++-ში: თითოეული მათგანის მხოლოდ ერთი მაგალითია.

ფინალი

საბოლოო საკვანძო სიტყვა ნიშნავს სხვადასხვა რამეს ცვლადის, მეთოდის ან კლასის აღწერისას. საბოლოო ცვლადი (დასახელებული მუდმივი) ინიციალიზაცია ხდება მისი დეკლარაციისას და შემდგომი შეცვლა შეუძლებელია. საბოლოო მეთოდი არ შეიძლება გადალახოს მემკვიდრეობით. საბოლოო კლასს საერთოდ არ შეიძლება ჰყავდეს მემკვიდრეები.

აბსტრაქცია

Java-ში, მეთოდები, რომლებიც არ არის აშკარად გამოცხადებული საბოლოო ან კერძო, ვირტუალურია C++ ტერმინოლოგიაში: მეთოდის გამოძახებას, რომელიც განსხვავებულად არის განსაზღვრული საბაზო და მემკვიდრეობით კლასებში, ყოველთვის აქვს გაშვების შემოწმება.

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

ინტერფეისები

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

ჯავაში კლასს არ შეუძლია ერთზე მეტი კლასის მემკვიდრეობა, მაგრამ მას შეუძლია ნებისმიერი რაოდენობის ინტერფეისის დანერგვა.

ინტერფეისები შეიძლება გადაეცეს მეთოდებს, როგორც პარამეტრებს, მაგრამ მათი ტიპის ობიექტების შექმნა შეუძლებელია.

მარკერის ინტერფეისები

Java-ში არის რამდენიმე ინტერფეისი, რომელიც არ შეიცავს განსახორციელებელ მეთოდებს, მაგრამ სპეციალური გზით მუშავდება JVM-ის მიერ. ეს არის ინტერფეისები:

• java.lang.კლონირებადი
• java.io.Serializable
• java.rmi.დისტანციური

შაბლონები ჯავაში (გენერიკები)

Java 5-დან დაწყებული, ენას აქვს პროგრამირების ზოგადი მექანიზმი - შაბლონები, რომლებიც გარეგნულად ახლოსაა C++ შაბლონებთან. კლასების და მეთოდების აღწერილობაში სპეციალური სინტაქსის გამოყენებით, შეგიძლიათ მიუთითოთ ტიპის პარამეტრები, რომლებიც შეიძლება გამოყენებულ იქნას აღწერილობაში, როგორც ველების ტიპები, პარამეტრები და მეთოდების დაბრუნების მნიშვნელობები.

// ზოგადი კლასის დეკლარაციაკლასი GenericClass ( E getFirst() ( ... ) void add (E obj) ( ... ) ) // კოდში ზოგადი კლასის გამოყენება GenericClass var = ახალი GenericClass () ; var.add("qwerty"); სტრიქონი p = var.getFirst();

დასაშვებია კლასების, ინტერფეისების და მეთოდების ზოგადი დეკლარაცია. გარდა ამისა, სინტაქსი მხარს უჭერს პარამეტრების ტიპების შეზღუდულ დეკლარაციას: მითითება ფორმის კონსტრუქციის დეკლარაციაში. მოითხოვს T ტიპის პარამეტრს A, B, C და ა.შ. ინტერფეისების და კონსტრუქტის განსახორციელებლად მოითხოვს, რომ T ტიპის პარამეტრი იყოს C ტიპი ან მისი ერთ-ერთი წინაპარი.

C# შაბლონებისგან განსხვავებით, ჯავის შაბლონები არ არის მხარდაჭერილი გაშვების დროს - შემდგენელი უბრალოდ ქმნის ბაიტეკოდს, რომელიც არ შეიცავს შაბლონებს. შაბლონების დანერგვა Java-ში ფუნდამენტურად განსხვავდება C ++-ში მსგავსი მექანიზმების განხორციელებისგან: შემდგენელი არ ქმნის კლასის ან შაბლონის მეთოდის ცალკეულ ვარიანტს შაბლონის გამოყენების თითოეული შემთხვევისთვის, არამედ უბრალოდ ქმნის ერთი ბაიტიკოდის იმპლემენტაციას, რომელიც შეიცავს საჭირო ტიპის შემოწმებები და კონვერტაციები. ეს იწვევს უამრავ შეზღუდვას შაბლონების გამოყენებაზე Java პროგრამებში.

კლასის წევრობის შემოწმება

Java-ში შეგიძლიათ პირდაპირ შეამოწმოთ რომელ კლასს ეკუთვნის ობიექტი. გამოთქმა foo instance of Foo მართალია, თუ ობიექტი foo ეკუთვნის Foo კლასს ან მის შთამომავალს, ან ახორციელებს Foo ინტერფეისს (ან, ზოგადად, მემკვიდრეობით იღებს კლასს, რომელიც ახორციელებს ინტერფეისს, რომელსაც Foo მემკვიდრეობით იღებს).

შემდეგ, ყველა ობიექტისთვის განსაზღვრული getClass() ფუნქცია აბრუნებს კლასის ტიპის ობიექტს. ამ ობიექტების შედარება შესაძლებელია. მაგალითად, foo.getClass()==bar.getClass() იქნება ჭეშმარიტი, თუ ობიექტები foo და bar ეკუთვნის ზუსტად ერთ კლასს (მაგრამ ეს არ ნიშნავს, რომ ისინი ორი იდენტური ობიექტია).

გარდა ამისა, ნებისმიერი ტიპის Class ტიპის ობიექტი შეიძლება მივიღოთ ასე: Integer.class , Object.class .

თუმცა, კლასების პირდაპირი შედარება ყოველთვის არ არის საუკეთესო საშუალება კლასის წევრობის შესამოწმებლად. ხშირად, მის ნაცვლად გამოიყენება isAssignableFrom() ფუნქცია. ეს ფუნქცია განისაზღვრება კლასის ტიპის ობიექტზე და პარამეტრად იღებს Class ტიპის ობიექტს. ამრიგად, Foo.class.isAssignableFrom(Bar.class)-ის გამოძახება ჭეშმარიტად დაბრუნდება, თუ Foo არის ბარის კლასის წინაპარი. ვინაიდან ყველა ობიექტი არის Object ტიპის შთამომავალი, Object.class.isAssignableFrom()-ის გამოძახება ყოველთვის უბრუნდება true. Class ტიპის ობიექტის აღნიშნულ ფუნქციებთან ერთად გამოიყენება ფუნქციები isInstance() (ექვივალენტური instanceof) და cast() (აკონვერტებს პარამეტრს შერჩეული კლასის ობიექტად).

საკლასო ბიბლიოთეკები

პროგრამული უზრუნველყოფის განვითარების ინსტრუმენტები

• JDK - გარდა ბიბლიოთეკების ნაკრებისა Java SE და Java EE პლატფორმებისთვის, შეიცავს კომპილატორს ბრძანების ხაზი javac და კომუნალური საშუალებების ნაკრები, რომელიც ასევე მუშაობს ბრძანების ხაზის რეჟიმში.
• NetBeans IDE არის უფასო IDE ყველა Java პლატფორმისთვის - Java ME, Java SE და Java EE. დაწინაურებულია Sun Microsystems-ის მიერ, Java-ს დეველოპერი, როგორც საბაზისო პროგრამული უზრუნველყოფის შემუშავება Java-ში და სხვა ენებზე (, C++, Fortran და ა.შ.).
• Java SE და Java EE. მიმდინარეობს მუშაობა Java ME პლატფორმის მხარდასაჭერად Eclipse-ში. დაწინაურებულია C, C++, Fortran და ა.შ.)
• IntelliJ IDEA არის კომერციული განვითარების გარემო Java SE, Java EE და Java ME პლატფორმებისთვის.

შენიშვნები

1. java (ინგლისური) . Merriam-Webster ონლაინ ლექსიკონი. მერიამ ვებსტერი. - სიტყვა "ჯავას" ინგლისური გამოთქმა. წაკითხულია 2009 წლის 5 ივნისს.
2. რობერტ ტოლკსდორფი.პროგრამირების ენები Java ვირტუალური აპარატისთვის JVM. არის Research GmbH. - ალტერნატიული ენების ონლაინ კატალოგი და ენების გაფართოებები JVM-სთვის. წაკითხულია 2009 წლის 5 ივნისს.
3. Microsoft Java ვირტუალური აპარატის მხარდაჭერა. Microsoft (2003-09-12). - Microsoft-ის ოფიციალური განცხადება MSJVM მხარდაჭერის პროგრამის შესახებ. წაკითხულია 2009 წლის 5 ივნისს.
4. ტოდ ჰოფი Amazon Architecture (ინგლისური) (2007-09-18). - ამაზონის არქიტექტურის განხილვა ჯავის ტექნოლოგიების გამოყენებით. წაკითხულია 2009 წლის 6 ივნისს.
5. Amazon Elastic Compute Cloud (Amazon EC2). შპს Amazon Web Services. - Amazon EC2-ის, როგორც ვებ სერვისის ტექნოლოგიისა და შესაძლებლობების აღწერა. წაკითხულია 2009 წლის 6 ივნისს.
6. ტოდ ჰოფი eBay Architecture (ინგლისური) (2008-05-27). - eBay-ის არქიტექტურის განხილვა Java პლატფორმაზე. წაკითხულია 2009 წლის 6 ივნისს.
7. რენდი შუპი, დენ პრიჩეტი eBay Architecture (ინგლისური) (PDF). SD ფორუმი 2006 წელი(2006-11-29). - პრეზენტაცია eBay-ის არქიტექტურის განვითარების ისტორიის შესახებ. წაკითხულია 2009 წლის 6 ივნისს.
8. ალენ სტერნიექსკლუზიური ინტერვიუ Yandex-ის CTO ილია სეგალოვიჩთან (ინგლისური). CenterNetworks (2008-01-14). - ინტერვიუ Yandex-ის CTO ილია სეგალოვიჩთან. წაკითხულია 2009 წლის 6 ივნისს.
9. ანატოლი ორლოვი Yandex.Search არქიტექტურა (რუსული) (PowerPoint). ეკატერინბურგში JUG-ის შეხვედრის მასალები(2008-05-24). წაკითხულია 2009 წლის 6 ივნისს.
10. ბრაიან გუანი LinkedIn ბლოგი. ბლოგის არქივი. გრაალი LinkedIn-ში. (ინგლისური) . LinkedIn.com (2008-06-11). - Grails Java ტექნოლოგიაზე დაფუძნებული LinkedIn სისტემის შექმნის ისტორია. წაკითხულია 2009 წლის 5 ივნისს.
11. OracleJVM და Java შენახული პროცედურები. Oracle Inc.. - Oracle პორტალის განყოფილება, რომელიც ეძღვნება Java ტექნოლოგიებს, როგორც Oracle DBMS სერვერის ნაწილი. წაკითხულია 2009 წლის 5 ივნისს.
12. Object.clone() მეთოდის დოკუმენტაციის ბმული

ლიტერატურა

• მონახოვი ვადიმ Java პროგრამირების ენა და NetBeans გარემო, მე-2 გამოცემა. - სანკტ-პეტერბურგი .: "BHV-Petersburg", 2009. - S. 720. - ISBN 978-5-9775-0424-9
• ჯოშუა ბლოხი.ჯავა. ეფექტური პროგრამირება = ეფექტური ჯავა. - მ .: "ლორი", 2002. - S. 224. - ISBN 5-85582-169-2
• Java 2. Professional's Library, ტომი 1. საფუძვლები = Core Java™ 2, ტომი I -- საფუძვლები. - მე-7 გამოცემა. - M .: "უილიამსი", 2007. - S. 896. - ISBN 0-13-148202-5
• ქეი ს. ჰორსტმანი, გარი კორნელი. Java 2. პროფესიონალთა ბიბლიოთეკა, ტომი 2. პროგრამირების რჩევები = Core Java™ 2, ტომი II - დამატებითი ფუნქციები. - მე-7 გამოცემა. - M .: "უილიამსი", 2007. - S. 1168. - ISBN 0-13-111826-9
• ბრიუს ეკელი.ჯავის ფილოსოფია = ფიქრი ჯავაში. - მე-3 გამოცემა - სანკტ-პეტერბურგი: "პიტერი", 2003. - S. 976. - ISBN 5-88782-105-1
• ჰერბერტ შილდტი, ჯეიმს ჰოლმსი.ჯავის პროგრამირების ხელოვნება = ჯავის ხელოვნება. - მ .: "დიალექტიკა", 2005. - S. 336. - ISBN 0-07-222971-3
• ლუბოს ბრუგა.სწრაფი ჯავა: პრაქტიკული ექსპრეს კურსი = Luboš Brůha. Java Hotová řešení.. - M .: მეცნიერება და ტექნოლოგია, 2006. - გვ. 369. - ISBN 5-94387-282-5

Java არის პროგრამირების ენა, რომელიც შემუშავებულია SunMicrosystems-ის მიერ. Java აპლიკაციები, როგორც წესი, შედგენილია სპეციალურ ბაიტეკოდში, ასე რომ, ისინი შეიძლება მუშაობდნენ Java-ის ნებისმიერ ვირტუალურ მანქანაზე (JVM) კომპიუტერის არქიტექტურის მიუხედავად. ოფიციალური გამოშვების თარიღია 1995 წლის 23 მაისი. დღეს ჯავის ტექნოლოგია იძლევა საშუალებას გადააქციოს სტატიკური ვებ გვერდები ინტერაქტიულ, დინამიურ დოკუმენტებად და შექმნას განაწილებული, პლატფორმისგან დამოუკიდებელი აპლიკაციები.

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

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

ხშირად, ვირტუალური მანქანის კონცეფციის უარყოფითი მხარეები მოიცავს იმ ფაქტს, რომ ვირტუალური მანქანის მიერ ბაიტეკოდის შესრულებამ შეიძლება შეამციროს Java ენაზე განხორციელებული ალგორითმების პროგრამის შესრულება. ბოლო დროს განხორციელდა მთელი რიგი გაუმჯობესება, რომლებიც ოდნავ ზრდის Java პროგრამების შესრულების სიჩქარეს:

ბაიტეკოდის მანქანურ კოდში გადაყვანის ტექნოლოგიის გამოყენება უშუალოდ პროგრამის მუშაობის დროს (JIT ტექნოლოგია) მანქანურ კოდში კლასის ვერსიების შენახვის შესაძლებლობით,

პლატფორმაზე ორიენტირებული კოდის (მშობლიური კოდი) ფართო გამოყენება სტანდარტულ ბიბლიოთეკებში,

აპარატურა, რომელიც უზრუნველყოფს დაჩქარებული ბაიტეკოდის დამუშავებას (მაგალითად, Jazelle ტექნოლოგია, რომელსაც მხარს უჭერს ზოგიერთი ARM პროცესორი).

ენის ძირითადი მახასიათებლები:

მეხსიერების ავტომატური მართვა;

ექსტრემალურ სიტუაციებთან გამკლავების გაფართოებული შესაძლებლობები;

შეყვანის / გამომავალი ფილტრაციის ხელსაწყოების მდიდარი ნაკრები;

სტანდარტული კოლექციების ნაკრები, როგორიცაა მასივი, სია, დასტა და ა.შ.;

მარტივი ინსტრუმენტების არსებობა ქსელური აპლიკაციების შესაქმნელად (მათ შორის RMI პროტოკოლის გამოყენებით);

კლასების არსებობა, რომლებიც საშუალებას გაძლევთ გააკეთოთ HTTP მოთხოვნები და დაამუშავოთ პასუხები;

ჩაშენებული ენობრივი ხელსაწყოები მრავალნაკადიანი აპლიკაციების შესაქმნელად;

მონაცემთა ერთიანი წვდომა:

ინდივიდუალური SQL მოთხოვნების დონეზე - JDBC, SQLJ-ზე დაფუძნებული;

მონაცემთა ბაზაში შენახვის შესაძლებლობის მქონე ობიექტების კონცეფციის დონეზე - Java Data Objects-სა და Java Persistence API-ზე დაფუძნებული;

შაბლონების მხარდაჭერა (დაწყებული ვერსიიდან 1.5);

პროგრამების პარალელურად შესრულება.

1.4.3 C# პროგრამირების ენა

2000 წლის ივნისში ცნობილი გახდა ახალი პროგრამირების ენის შესახებ, რომელიც დაიბადა Microsoft-ის ნაწლავებში. ის ნაწილი გახდა ახალი ტექნოლოგიამაიკროსოფტმა უწოდა .NET (გამოითქმის "Dot Net"). ამ ტექნოლოგიის ფარგლებში, უზრუნველყოფილია სხვადასხვა პროგრამირების ენაზე დაწერილი პროგრამების (Common Language Runtime, CLR) შესრულების ერთიანი გარემო. ერთ-ერთი ასეთი ენა, მთავარი ამ გარემოში, არის C # (C #, წაიკითხეთ "C sharp", "C sharp"). ენის სახელწოდებით, რა თქმა უნდა, მათ სურდათ ხაზი გაესვათ მის ურთიერთობას C++-თან, რადგან # არის ორი გადამკვეთი პლუსი. მაგრამ ყველაზე მეტად, ახალი ენა ჯავის მსგავსია. და ეჭვგარეშეა, რომ მისი გამოჩენის ერთ-ერთი მიზეზი იყო Microsoft-ის სურვილი უპასუხა Sun-ის გამოწვევას.

მიუხედავად იმისა, რომ C#-ის ავტორები ოფიციალურად არ არის დასახელებული, ენის სახელმძღვანელოს ერთ-ერთი წინასწარი გამოცემის სათაურ გვერდზე მითითებულია ანდერს ჰეილსბერგი, Turbo Pascal-ისა და Delphi-ის შემქმნელი, რომელიც გადავიდა Microsoft-ში 1996 წელს და სკოტ ვილტამუტი.

პროგრამის შესრულების ერთიანი გარემო ეფუძნება შუალედური ენის გამოყენებას IL (Intermediate Language - შუალედური ენა), რომელიც ასრულებს თითქმის იგივე როლს, რასაც Java ვირტუალური მანქანის ბაიტიკოდი. .NET ტექნოლოგიის ფარგლებში გამოყენებული სხვადასხვა ენიდან შემდგენლები პროგრამებს თარგმნიან IL კოდში. Java bytecode-ის მსგავსად, IL კოდი წარმოადგენს ჰიპოთეტური სტეკის კომპიუტერის ინსტრუქციებს. მაგრამ ასევე არის განსხვავება IL-ის დიზაინსა და გამოყენებაში.

პირველი, JVM-ისგან განსხვავებით, IL არ არის მიბმული პროგრამირების ერთ ენაზე. Microsoft.NET-ის წინასწარი ვერსიები მოიცავს C++, C#, Visual Basic-ის შემდგენელებს. დამოუკიდებელ დეველოპერებს შეუძლიათ სხვა ენების დამატება ამ ენებიდან შემდგენელების შექმნით IL კოდში.

მეორეც, IL არ არის განკუთვნილი პროგრამული ინტერპრეტაციისთვის, არამედ მანქანურ კოდში შემდგომი შედგენისთვის. ეს საშუალებას გაძლევთ მიაღწიოთ მნიშვნელოვნად მაღალი ხარისხის პროგრამებს. IL კოდის შემცველი ფაილები შეიცავს საკმარის ინფორმაციას ოპტიმიზაციის შემდგენლის მუშაობისთვის.

C# არის მარტივი, თანამედროვე, ტიპზე უსაფრთხო ობიექტზე ორიენტირებული ენა, რომელიც მიღებულია C-დან და C++-დან. C# მოსახერხებელი და გასაგები იქნება პროგრამისტებისთვის, რომლებმაც იციან C და C++. C# აერთიანებს Visual Basic-ის პროდუქტიულობას C++-ის ძალასთან." ამ სიტყვებით იწყება C#-ის აღწერა.

განვიხილოთ ტექნიკური მახასიათებლებიენა:

კომპილაციის ერთეული არის ფაილი (როგორც C, C++, Java). ფაილი შეიძლება შეიცავდეს ერთი ან მეტი ტიპის აღწერილობას: კლასებს (კლასი), ინტერფეისებს (ინტერფეისი), სტრუქტურები (სტრუქტურა), აღრიცხვები (enum), დელეგატის ტიპები (delegate) სახელთა სივრცეებში მათი განაწილების მითითებით ან მის გარეშე;

სახელთა სივრცე (სახელთა სივრცე) არეგულირებს პროგრამის ობიექტების ხილვადობას (როგორც C++-ში). სახელთა სივრცეები შეიძლება იყოს ჩასმული. ნებადართულია პროგრამის ობიექტების გამოყენება სახელთა სივრცის მკაფიოდ მითითების გარეშე, რომელსაც ეკუთვნის ეს ობიექტი. საკმარისია მხოლოდ ზოგადი აღნიშვნა ამ სახელთა სივრცის გამოყენების შესახებ დირექტივაში (როგორც Turbo Pascal-ში). გამოყენების დირექტივაში არის სახელთა სივრცის სახელების მეტსახელები (როგორც ობერონის ენაში);

ელემენტარული მონაცემთა ტიპები: 8-ბიტიანი (სბაიტი, ბაიტი), 16-ბიტიანი (მოკლე, ushort), 32-ბიტიანი (int, uint) და 64-ბიტიანი (გრძელი, ულონი) ხელმოწერილი და ხელმოუწერელი მთელი რიცხვები, ერთეული რეალურიები (float ) და ორმაგი (ორმაგი) სიზუსტე, Unicode სიმბოლოები (char), ლოგიკური ტიპი (bool, შეუთავსებელია მთელ რიცხვებთან), ათობითი ტიპი, რომელიც უზრუნველყოფს სიზუსტის 28 მნიშვნელოვან ციფრს (ათწილადი);

სტრუქტურირებული ტიპები: კლასები და ინტერფეისები (როგორც Java-ში), ერთგანზომილებიანი და მრავალგანზომილებიანი (განსხვავებით Java-სგან) მასივები, სტრიქონები (სტრიქონი), სტრუქტურები (თითქმის იგივეა, რაც კლასები, მაგრამ განთავსებული არა გროვაზე და მემკვიდრეობის გარეშე), ნუმერაციები, შეუთავსებელი მთელი რიცხვებით (როგორც პასკალში);

დელეგატის ტიპები ან უბრალოდ „დელეგატები“ (როგორც პროცედურული ტიპები მოდულ-2-ში და ობერონში, ფუნქციის მაჩვენებლები C და C++-ში);

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

ნაგვის ავტომატური შეგროვება (როგორც Oberon-სა და Java-ში);

ოპერაციების ვრცელი ნაკრები 14 პრიორიტეტული დონით. ოპერაციების ხელახალი განსაზღვრა (როგორც Algol-68, Ada, C++). შემოწმებული და მოხსნილი ოპერატორებით შეგიძლიათ აკონტროლოთ გადადინების კონტროლი მთელ რიცხვებზე ოპერაციების შესრულებისას;

მეთოდები მნიშვნელობის პარამეტრებით, საცნობარო პარამეტრებით (ref) და გამომავალი პარამეტრებით (out). სიტყვები ref და out უნდა დაიწეროს პარამეტრამდე, არა მხოლოდ მეთოდის აღწერაში, არამედ გამოძახებისას. გამომავალი პარამეტრების არსებობა საშუალებას გაძლევთ აკონტროლოთ განმსაზღვრელი დავალებების შესრულება. ენის წესებით, ნებისმიერ ცვლადს უნდა ჰქონდეს მნიშვნელობის გარანტია, სანამ მცდელობა იქნება მისი გამოყენება;

საკონტროლო განცხადებები: if, switch, while, do, for, break, გაგრძელება (როგორც C, C++ და Java-ში). foreach განცხადება, რომელიც მოძრაობს "კოლექციის" თითოეულ ელემენტში, goto jump განაცხადის რამდენიმე სახეობას;

გამონაკლისის დამუშავება (როგორც Java-ში);

თვისებები - კლასების ელემენტები (ობიექტები), რომლებზედაც წვდომა ხორციელდება ისევე, როგორც ველები (შეგიძლიათ მივანიჭოთ ან მიიღოთ მნიშვნელობა), მაგრამ განხორციელებულია იმპლიციურად მოუწოდა get and set subroutines (როგორც Object Pascal-ში - შეყვანის ენა. დელფის სისტემის);

ინდექსატორები არის კლასების (ობიექტების) ელემენტები, რომლებიც საშუალებას გაძლევთ შეხვიდეთ ობიექტებზე ისევე, როგორც მასივები (ინდექსის მითითებით კვადრატული ფრჩხილები). ხორციელდება იმპლიციურად მოუწოდა get and set რუტინებით. მაგალითად, სტრიქონის სიმბოლოებზე წვდომა (წაკითხვისთვის) შეიძლება განხორციელდეს მასივის ელემენტებად, იმის გამო, რომ ინდექსატორი დანერგილია სტანდარტული სტრიქონების კლასისთვის;

მოვლენები არის პროცედურული ტიპის კლასების (ველები ან თვისებები) ელემენტები (დელეგატები), რომლებზეც, კლასის გარეთ, სადაც ისინი განსაზღვრულია, გამოიყენება მხოლოდ += და -= ოპერაციები, რაც საშუალებას გაძლევთ დაამატოთ ან წაშალოთ მოვლენის დამმუშავებლის მეთოდები ობიექტებისთვის. ამ კლასის;

არაუსაფრთხო (არაუსაფრთხო) კოდი პოინტერებისა და მისამართების არითმეტიკის გამოყენებით ლოკალიზებულია პროგრამის არაუსაფრთხო მოდიფიკატორით მონიშნულ ნაწილებში;

წინასწარი პროცესორი, რომელიც, განსხვავებით C და C++-ისგან, უზრუნველყოფს მხოლოდ პირობით კომპილაციის შესაძლებლობებს.

რა თქმა უნდა, C #-ის განხილული ნაკლოვანებები ენას პერსპექტივას საერთოდ არ ართმევს. ის მრავალი თვალსაზრისით სასურველია C++-ზე. ზოგადი უკმაყოფილება C++ ენით, რომელიც აღიარებულია ახალი ენის გარეგნობით, C#-ის წარმატების ერთ-ერთი მთავარი წინაპირობაა.

C#-ს Java-სთან შედარებისას შეგიძლიათ ნახოთ ბევრი მსგავსება. მართალია, თუ Java სისტემები მრავალპლატფორმულია, მაშინ C # იმპლემენტაცია არსებობს მხოლოდ ოპერაციული სისტემისთვის. ვინდოუსის სისტემებიდა მხოლოდ ერთი. მაგრამ, მიუხედავად სიმძიმისა, მოსალოდნელია, რომ ენა სხვა სისტემებისთვისაც დანერგილი იქნება. გარდა ამისა, თავად Microsoft .NET პლატფორმა ერთი პროგრამის შესრულების გარემოთი შეიძლება დაწინაურდეს ალტერნატიულ არქიტექტურებზე, პირველ რიგში UNIX სისტემებზე.

როგორც ჩანს, C# უფრო რეალისტური ენაა ვიდრე Java. ჯავისგან განსხვავებით, ის თვითკმარია. ანუ შეგიძლიათ დაწეროთ ნებისმიერი პროგრამა C#-ში სხვა ენების გამოყენების გარეშე. ეს შესაძლებელია კოდის „უსაფრთხო“ ბლოკების არსებობის გამო, რომლებიც ხსნიან უშუალოდ აპარატურაზე წვდომას. ჯავაში, დაბალი დონის ობიექტებზე წვდომამ უნდა გამოიყენოს "მშობლიური მეთოდები" (მშობლიური მეთოდები), რომლებიც უნდა იყოს დაპროგრამებული სხვა ენებზე.

და, რა თქმა უნდა, C #-ის პერსპექტივები, უპირველეს ყოვლისა, დაკავშირებულია იმ ძალისხმევასთან, რომელსაც, რა თქმა უნდა, მაიკროსოფტი გააკეთებს მის პოპულარიზაციაში.