Jump to content

Search the Community

Showing results for tags 'java'.



More search options

  • Search By Tags

    Type tags separated by commas.
  • Search By Author

Content Type


Forums

  • ფორუმი
    • ფორუმი
    • ზოგადი დისკუსიები
    • ტუტორიალი/Tutorial
    • მათემატიკა
    • ბიბლიოთეკა
    • კრიპტოგრაფია
    • კიბერ უსაფრთხოება
    • ელექტროინჟინერია
  • პროგრამები
    • დიზანის & 3D მოდელირება
    • პროგრამები/ software
    • დაცვა
  • Visual Studio
    • Visual Studio
    • C#
    • C და C++
    • ASP.NET/WPF/MVC
    • WCF
    • Quick Basic / Visual Basic
  • Web Development
    • HTML & CSS
    • Bootstrap
    • PHP & MySQL
    • Javascript
    • AngularJS
    • სხვადასხვა
    • SEO
    • ძრავების მიმოხილვა
  • Development
    • JAVA
    • Perl
    • Python
    • ბაზები
    • Other
    • Game Developer
    • მობილურის დეველოპერი
  • IT-Support
    • Unix/Linux
    • MS Windows
    • Apple /MAC
    • Android
    • Network
    • კომპიუტერის არქიტექტურა
  • ყიდვა-გაყიდვა/შეკვეთები
    • ყიდვა-გაყიდვა
    • შეკვეთები

Find results in...

Find results that contain...


Date Created

  • Start

    End


Last Updated

  • Start

    End


Filter by number of...

Joined

  • Start

    End


Group


AIM


MSN


Website URL


ICQ


Yahoo


Jabber


Skype


ლოკაცია


ინტერესები

Found 14 results

  1. GHOST_FATHER

    GNU Compiler Collection

    GCC (GNU Compiler Collection, შემოკლებით) არის GNU პროექტის მიერ შექმნილი კომპილატორი. იგი შედგება სხვადასხვათავისუფალი პროგრამებისგან რომლებსაც შეუძლიათ რამდენიმე პროგრამული ენის კომპილირება, მათ შორის C, C++,Objective-C, Java, Ada და Fortran-ი.იგი ხშირად არის გამოყენებული თავისუფალი პროგრამების შექმნისთვის. მაგალითად, ლინუქსის ბირთვი GCC-ის შესაძლებლობებზე არის დამოკიდებული. GCC იქნა შექმნილი იუნიქსის სტანდარტული C კომპილატორის შესანაცვლად, რომელსაც ერქვა CC. თავის დროზე GCC ნიშნავდა GCC C Compiler-ს, ანუ GNU-ს C კომპილატორი. შემდეგ, სხვა პროგრამირების ენების მხარდაჭერის დამატების შედეგად სახელი შეიცვალა GNU Compiler Collection-ით (ყურადღება: Compiler-ის ბოლოში «s» არ არის).
  2. გამარჯობა, დამწყებებს გამოგადგებათ, ქართული ვიდეო კურსებია და მგონი არ გაგიჭირდებათ გაგება... C შესასწავლათ დააკლიკეთ აქ C++ შესასწავლად დააკლიკეთ აქ Java შესასწავლად დააკლიკეთ აქ წარმატებები ყველას...
  3. GHOST_FATHER

    java სწავლა

    სანამ ჯავაზე ვისაუბრებდი ჩამივარდა ხელში წიგნი რომელიც არის არაჩვეულებრივად აღწერილი , ამიტომაც ამ წიგნის მასალიდ "დაკოპირებას" ვაპირებ, ჩემდა სამწუხაროდ, ვორდის დოკუმენტს არ გააჩნია ავტორი თუ ვინ დაწერა ამიტომაც მომიტევოს ავტორმა რათა მის ინტელექტუალურ საკუთრებას ვისაკუთრებ, თუ ავტორი გამოჩნდება რათქმაუნდა ჩავასწორებ და დავწერ, არ მაქვს პრობლემა. ობიექტზე ორიენტირებული დაპროგრამების საწყისები პროგრამისტების წინაშე მდგარი ამოცანები სულ უფრო და უფრო მრავალფეროვანი ხდება. ამასთან მაღალი ტემპით იზრდება დასამუშავებელი ინფორმაციის ზომა. თუ ცოტა ხნის წინათ ინფორმაციის განზომილების ჩვეულებრივი ერთეული იყო კილობაიტი და მეგაბაიტი, დღეს უკვე ლაპა­რა­კია გიგაბაიტებსა და ტერაბაიტებზე. როგორც კი პროგ­რა­მის­ტები მოახდენენ მათ წინაშე მდგარი ამოცანის მეტნაკ­ლებად მისაღებ გადაწყვეტას, მაშინვე წარმოიშვება ახალი, უფრო რთული ამოცანები. პროგრამისტები იგონებენ და ამუშავებენ ახალ მეთოდებს, ქმნიან ახალ ენებს. პროგ­რამირების ნახევარსაუკუნოვანი ისტორიის განმავლო­ბაში წარმოიქმნა ასობით ენა, დამუშავებულია დაპროგრამების უამრავი მეთოდი და სტილი. ზოგიერთი მათგანი საყოველ­თაოდ მიღებული ხდება და გარკვეული პერიოდის განმავ­ლობაში წარმოადგენენ პროგრამირების პარადიგმას (ძირი­თად მიდგომას). პროგრამირების პარადიგმა განმარტებით ლექსიკონში განმარტებულია, როგორც კონცეპტუალიზა­ცი­ის მეთოდი, რომელიც განსაზღვრავს, როგორ ვაწარმოოთ გამოთ­ვლები და როგორ იყოს ორგანიზებული და სტრუქ­ტუ­რირებული კომპიუტერის მიერ შესრულებული სამუშა­ოები. პროგრამირების პარადიგმები თავიდან, მანქანურ კოდებში დაწერილი უმარტივესი პროგ­რა­მებიც კი, შეადგენდნენ ძნელად გასაგები, ასობით სტრი­ქო­ნის­აგან შემდგარ ტექსტს. დაპროგრამების დაჩქა­რებისა და გამარტივების მიზნით შეიქმნა მაღალი დონის ალგორით­მული ენები: Fortran, Algol და ასობით სხვა. ამ ენების გამო­ყე­ნე­ბით მანქანური ბრძანებების (კოდის) შექ­მნის რუტინული ოპერაციების განხორციელება დაეკისრა კომპილატორებს. მაღალი დონის ენებზე დაწერილი იგივე პროგრამები გახდა გაცილებით გასაგები და მოკლე. კომპი­უ­ტერული სისტე­მების მკვეთრმა განვითარებამ გამო­იწ­ვია უფრო რთული ამოცანების გადაწყვეტის აუცი­ლებლობა, რა­მაც კვლავ მოახ­დინა პროგრამების ზომების მნიშვნელო­ვანი გაზრდა. წარმოიქმნა იდეა: პროგრამა გაფორმდეს რამდენიმე, შეძლე­ბისდაგვარად მარტივი პროცედურის ან ფუნქციის სახით, რომლებიც გადაწყვეტენ თავის კონკრეტულ ამოცანას. მცირე ზომის პროცედურის დაწერა, კომპილაცია და გამართვა გაცილებით უფრო ადვილად და სწრაფად შეიძლება. შემდეგ საჭირო იქნება, მხოლოდ ყველა პროცედურის საჭირო მიმ­დევრობით, ერთ პროგრამად გაერთიანება. გარდა ამისა, ერთ­ხელ დაწერილი პროცედურები შეიძლება გამოყენე­ბუ­ლი იქნას სხვა პროგრამებში, როგორც „სამშენებლო აგურე­ბი“. პროცედურული პროგრამირება სწრაფად იქცა პარ­ა­დიგ­მად. ყველა მაღალი დონის ენაში მოხდა პროცედურებისა და ფუნქციების დაწერის საშუალებების ჩართვა. შეიქმნა სხვად­ასხვა საგნობრივი სფეროსათვის პროცედურებისა და ფუნქ­ცი­ების უამრავი ბიბლიოთეკა. პროგრამისტების წინაშე კვლავ დაისვა ახალი საკითხები: როგორ ჩამოყალიბდეს პროგრამის სტრუქტურა მისი პროცე­დურებად დასაყოფად, კოდის რა ნაწილი გამოიყოს ცალკე­ული პროცედურისათვის, როგორ გახდეს ამოცანის გადაწ­ყვეტის ალგორითმი მარტივი და აღქმადი, როგორაა მოსა­ხერხებელი პროცედურების ერთმანეთთან დაკავშირება. დაგ­­როვილი მრავალწლიანი გამოცდილების მიხედვით, პროგრამისტებმა შეიმუშავეს რეკომენდაციები, რომლებსაც დაერქვა სტრუქტურული პროგრამირება. სტრუქტურული პროგრამირება იმდენად მოსახერერხებელი და მნიშვნელო­ვანი გამოდგა, რომ იგი მალე გახდა პარადიგმა. შეიქმნა ახალი პროგრამირების ენები, მაგალითად Pascal, რომლებ­ზეც სტრუქტურული პროგრამების წერა გაცილებით მოსა­ხერ­ხებელია. უფრო მეტიც, არასტრუქტურირებული პროგ­რამების დაწერა ძალიან ძნელი გახდა. სტრუქტურული პროგრამირების ძირითადი მოთხოვნებია: მოდულურობა; კითხვადობა; პროგრამის შესრულების სტანდარტული მართვის სქემები; დოკუმენტირება; ტესტების შედგენა პროგრამის დამუშავების ადრეულ ეტაპზე. პროგრამისტების წინაშე მდგარი ამოცანების სირთულემ აქაც იჩინა თავი: დიდი პროგრამა შედგებოდა ასობით პრო­ცედურისაგან და იგი კვლავ გახდა ძნელად გასააზრებელი და გასამართი. აუცილებელი გახდა პროგრამირების ახალი სტილის შემუშავება. ამ დროისათვის გასაგები გახდა, რომ საწყისი მონაცემების სტრუქტურა დიდ გავლენას ახდენდა მათი დამუშავების ალგორითმებზე. ზოგიერთი საწყისი მონაცემი მოსახერ­ხე­ბელია წარმოდგენილი იქნას მასივის სახით, ზოგიერ­თი­სათ­ვის კი უფრო უპრიანია ხისებური (იერარქიული) სტრუქ­ტუ­რა ან სტეკური ორგანიზება. ამიტომ წარმოიქმნა იდეა ერთ მოდულში გაერთიანდეს საწყისი მონაცემები და მისი დამუშავების ყველა პროცედურა. მოდულური პროგრამი­რების ეს იდეა სწრაფად გახდა პოპულარული და რაღაც დროის განმავლობაში იგი გახდა პარადიგმა. პროგ­რამები იქმნებოდა ცალკეული მო­დუ­ლებისაგან, რომლე­ბიც ათო­ბით სხვადასხვა პროცე­დურისა და ფუნქციებისაგან შედ­გებოდა. ასეთი პროგ­რა­მების ეფექტურობა მით უფრო მაღა­ლია, რაც უფრო ნაკლე­ბადაა დამოკიდებული ცალკე­ული მოდულები ერთმანეთზე. მოდულების ავტონომი­უ­რობა საშუ­ა­ლებას იძლევა შეიქმნას მოდულების ბიბლიო­თეკა, რომელიც შემდგომში შეიძლება გამოყენებული იქნას პროგრამის ასაგებ ბლოკებად. მოდულების ერთმანეთის მიმართ მაქსიმალური ავტონომი­უ­რობის უზრუნველსაყოფად, საჭიროა მკაფიოდ გამოიყოს ის პროცედურები, რომლის გამოძახებაც შესაძლებელია სხვა მოდულებისგან - ანუ ღია (Public) პროცედურები, და დამ­ხმარე პროცედურები, რომლებიც ამუშავებენ ამ მოდულში მოთავსებულ მონაცემებს - ანუ დახურული (Private პრივა­ტული) პროცედურები. პირველი ტიპის პროცედურები ჩა­მოთ­ვლილია მოდულის ცალკე ნაწილში - ინტერფეისში (interface), მეორე ტიპის მონაწილეობენ მხოლოდ მოდულის რეალიზაციაში (implementation). მოდულში აღწერილი ცვლა­დებიც იყოფა ღიად (მითითებული ინტერფეისში და სხვა მოდულებიდან წვდომადი) და დახურულად (მათზე წვდომა შესაძლებელია მხოლოდ იმავე მოდულში შემავალი პროცედურებისაგან). პროგრამირების სხვადასხვა ენებში ეს დაყოფა სხვადსხვანაირად ხდება. Turbo Pascal-ში მოდული სპეციალურად იყოფა ინტერფეისად და რეალიზაციად. ალგორითმულ ენა C-ში ინტერფეისი გატანილია „სათაო“ (header) ფაილში. ენა C++ -ში, ამის გარდა, ინტერფეისის აღწერისათვის შესაძლებელია აბსტრაქტული კლასების გა­მო­ყენება. Java-ში არსებობს ინტერფეისის აღწერის სპე­ციალური კონსტრუქცია, რომელსაც ასევე ეწოდება - interface, მაგრამ შესაძლებელია აბსტრაქტული კლასების შექმნაც. ასე წარმოიშვა მონაცემებისა და მათი დამუშავების მეთო­დების დაფარვის, ინკაფსულაციის (incapsulation) იდეა. ინკაფსულაციის მიზანი არაა სხვა მოდულს დაუმალოს საჭირო კომპონენტი. მისი ორი მთავარი მიზანია: პირველი - უზრუნველყოს მოდულის გამოყენების უსაფრთხოება, ინ­ტერ­ფეისში გამოიტანოს და გახადოს საყოველთაოდ ხელმი­საწვდომი მხოლოდ ინფორმაციის დამუშავების ის მეთო­დები, რომლებსაც არ შეუძლიათ დააზიანოს ან წაშა­ლოს საწყისი მონაცემები; მეორე - შეამციროს სირთულე, გარე მოდულებისათვის რეალიზაციის წვრილმანი დეტალე­ბის დაფარვის გზით. კვლავ წარმოიშვა ამოცანა, რა გზით მოხდეს პროგრამის დაყოფა მოდულებად. ამ შემთხვევაში უფრო მისაღები აღმოჩნდა პროგრამირების ძველი ამოცანების გადაწყვეტები - ბუნებრივი და ხელოვნური ობიექტების მოქმედებების მოდელირება (ადამიანების, ცხოველების, ტექნოლოგიური პროცესების მართვის სისტემების, პროგრამული მართვის ჩარხების და სხვა). მართლაც, ყოველი ობიექტი - ადამიანი, ავტომობილი, ტექნოლოგიური პროცესი, ხასიათდება გარ­კ­ვე­ული პარამეტრებით. მაგალითად, გვარი, წლოვანება, წონა, სიმაღლე, მაქსიმალური სიჩქარე, ტვირთამწეობა და სხვა. ობი­ექტი შეიძლება ასრულებდეს სხვადსხვა მოქმედებებს: გადაადგილდებოდეს სივრცეში, იზრდებოდეს ან მცირდე­ბოდეს, ჭამოს, სვას, შეიცვალოს თავისი პირვანდელი პარა­მეტრები. მოსახერხებელია ობიექტის მოდელირება მოხდეს მოდულის სახით. მისი პარამეტრები, მახასიათებლები იქნე­ბა საწყისი მონაცემები - მუდმივი ან ცვლადები, ხოლო მოქ­მედებები - პროცედურები. მოსახერხებელი გამოდგა აგრეთვე საწინააღმდეგოც - პროგ­რამა ისე დაიყოს მოდულებად, რომ იგი გარდაიქმნას ურთი­ერთ­დაკავშირებულ ობიექტებად. ასე წარმოიშვა ობიექტზე ორიენტირებული დაპროგრამება (object-oriented program­ming - OOP), რომელიც პროგრამირების თანამედ­როვე პარადიგ­მას წარმოადგენს. ობიექტზე ორიენტირებული დაპროგრამების იდეის წარმო­შობას სხვა წანამძღვრებიც გააჩნია. ცნობილია, რომ ყოველი კომპიუტერული პროგრამა შედგება ორი ელემენ­ტისაგან: კოდი (პროგრამის ტექსტის პროცედურული ნაწი­ლი) და მონაცემები. კონცეპტუალურად პროგრამა ორგანი­ზებული შეიძლება იყოს თავისი კოდის ან მონაცემების გარშემო. ანუ, ზოგიერთი პროგრამის ორგანიზება განისაზ­ღვრება იმით, თუ „რა ხდება“, ხოლო სხვების „რაზე ხდება მოქმედებები“. არსებობს პროგრამების შედგენის ორი კონ­ცეფცია. პირველ მიდგომას უწოდებენ პროცესზე ორიენტირებულ მოდელს. ასეთი მიდგომისას პროგრამა ესაა წრფივი ბიჯების მიმდევ­რობა (ე.ი. კოდი). პროცესზე ორიენტირებული მოდელი, შეიძლება განვიხი­ლოთ, როგორც მონაცემების დამმუშავე­ბე­ლი კოდი. ამ მო­დელს იყენებენ პროცედურული ენები მაგალითად C, Pascal და სხვა. თუმცა, ასეთი მიდგომა წარმოშობს სხვადასხვა პრობლემებს პროგრამის ზომისა და სირთულის ზრდასთან დაკავშირებით. როგორც ზემოთ აღვნიშნეთ, სირთულის ზრდადი ხასიათის გადასალახად, დამუშავდა ობიექტზე ორიენტირებული მიდ­­გომა. ობიექტზე ორიენტირებული პროგრამირება ან­ხორ­ციელებს პროგრამის ორგანიზებას მისი მონაცემების (ანუ ობიექტების) გარშემო. ობიექტზე ორიენტირებული პროგ­რამირება ესაა მონაცემები, რომლებიც მართავენ კოდ­თან წვდომას. ობიექტების სახით შეიძლება წარმოვადგინოთ სხვადასხვა ცნებები. მაგალითად, ფანჯარა დისპლეის ეკრანზე - ესაა ობიექტი, რომელსაც აქვს სიგანე width და სიმაღლე hight, ეკრანზე მდებარეობა, ჩვეულებრივ აღიწერება მარცხენა ზე­და კუთხის (x,y) კოორდინატებით, შრიფტი, რომლითაც ფანჯარაში ტექსტი გამოდის, მაგალითად Times New Roman, ფონის ფერი color და სხვა პარამეტრები. ფანჯარა ეკრანზე შეიძლება გადაადგილდებოდეს move() მეთოდით, გაეზარ­დოს ან შეუმცირდეს ზომები მეთოდით size(), გარკვეული რეაგირება მოახდინოს მაუსის დაჭერაზე და სხვა. ფაქტი­ურად ესაა სრულყოფილი ობიექტი. ღილაკები, ლიფტები და ფანჯრის სხვა ელემენტებიც ობიექტებს წარმოადგენენ, რომ­ლე­ბსაც თავის მხრივ აქვთ თავისი ზომები, შრიფტები, შეუძ­ლით გადადგილება. ობიექტზე ორიენტირებული დაპროგრამების იდეა ძალიან ნაყოფიერი გამოდგა და იგი აქტიურად განვითარდა. აღმოჩ­ნდა, რომ უმჯობესია ამოცანა დაისვას მოქმედი ობიექტების ერთობლიობის სახით - ასე წარმოიშვა ობიექტზე ორიენ­ტირებული ანალიზი (OOA, object-oriented Analysis). შესაძ­ლე­ბელი გახდა რთული სისტემების დაპროექტება ობიექ­ტების სახით - წარმოიშვა ობიექზე ორიენტირებული დაპ­როექტება (OOD, object-oriented design). ობიექტზე ორიენტირებული დაპროგრამება უკვე 20 წელია ვითარდება. არსებობს რამდენიმე სკოლა, რომლებიც თავი­სებურად აყალიბებენ ძირითად პრონციპებს და ობიექ­ტებთან მუშაობის თავის პრინციპების ერთობლიობას გვთა­ვაზობენ. ობიექტზე ორიენტირებული დაპროგრამების მნიშვნელოვან ელემენტს წარმოადგენს აბსტრაქცია. რაიმე ობიექტის ქცევის აღწერისას, მაგალითად ავტომობილის, ჩვენ ვაგებთ მის მოდელს. როგორც წესი, მოდელი ობიექტს სრულად ვერ აღ­წერს, რეალური ობიექტები ძალიან რთულია. აირჩევა ობი­ექტის მხოლოდ ის თვისებები, რომლებიც მნიშვნე­ლოვანია დასმული ამოცანის გადასაწყვეტად. მაგალითად, ტვირთის გადაზიდვის ამოცანის აღწერისათვის მნიშვნელო­ვანია მან­ქა­ნის ტვირთამწეობა, ხოლო საავტომობილო რბო­ლე­ბის აღ­წე­რისას ეს პარამეტრი მნიშვნელოვანი არაა. რბო­ლე­­ბის მო­დე­ლირებისას უნდა აღიწეროს ავტომობილის მიერ სიჩ­ქარის აკრეფის მეთოდი, რაც ტვირთების გადაზიდვისას არაა მნიშ­ვ­ნელოვანი. ჩვენ უნდა მოვახდინოთ აბსტრაგირება ობიექტის ზოგი­ერთი კონკრეტული დეტალისაგან. ძალიან მნიშვნელოვანია აბსტრაქციის სწორი დონის შერჩევა. აბსტრაქციის ძლიან მაღალი დონე მოგვცემს ობიექტის ზოგად, ზერელე აღწერას, რაც არ მოგვცემს საშუალებას სწორად მოვახდინოთ ობი­ექტის ქცევის მოდელირება. აბსტრაქციის ძალიან დაბალი დონეს შემთხვევაში მოდელი გამოვა ძალიან რთული, გადა­იტვირთება დეტალებით და ამიტომ ის შეიძლება გამოუ­სა­დეგარი იყოს. აბსტრაქციის გამოყენების მძლავრ იარაღს წარმოადგენს იერარ­ქიული კლასიფიკაციები. ის საშუალებას იძლევა გავ­ა­მარტივოთ რთული სისტემების სემანტიკა (შინაარსი), მათი ფრაგმენტებად დაყოფის გზით, რომლებიც სამართავადაც უფრო ადვილი იქნება. მაგალითად, გარეგნულად ავტომო­ბილი ერთ ობიექტად აღიქმება. მაგრამ თუ შიგ ჩავიხედავთ, ვნახავთ, რომ იგი შედგება რამდენიმე ქვესისტემისაგან: საჭის მართვის სისტემა, მუხრუჭები, აუდი­ოსისტემა, გამათ­ბობელი და სხვა, თითოეული ეს ქვესისტემა აგებულია უფ­რო სპეციფიური კვანძებისაგან. მაგა­ლითად, აუდიო­სის­ტემა შედგება რადიომიმღებისაგან, კომპაქტ დისკებისა და/ან აუდიო კასეტების დამკვრე­ლისაგან. ამ მაგალითის არსი მდგომარეობს იმაში, რომ ავ­ტო­მობილის რთული სისტემა (ან ნებისმიერი სხვა რთული სისტემა) შეიძლება აღვწეროთ იერარქიული აბსტრაქ­ციის გზით. რთული სისტემების იერარქიული აბსტრაქცია შეიძლება გა­მოვიყენოთ კომპიუტერული პროგრამების მიმართაც. პრო­ცესზე ორიენტირებული პროგრამების მონაცემები აბსტრაქ­ციის გზით შეიძლება გარდაიქმნას შემადგენელ ობიექტე­ბად. ამასთან პროცესის მიმდევრობითი ბიჯები შეიძლება გარდაიქმნას შეტყობინებების კოლექციად, რომლებიც ამ ობიექტებს შორის გადაიცემა. ამგვარად, თითოეული ეს ობი­ექტი აღწერს თავის უნიკალურ მოქმედებას. ობიექტები შეიძ­ლება ჩავთვალოთ კონკრეტულ ელემენტებად, რომლე­ბიც პასუხობენ შეტყობინებებზე. შეტყობინებები კი მიუთი­თებენ, რაღაც ქმედების შესრულების აუცილებლობაზე. ფაქ­ტი­ურად ესაა ობიექტზე ორიენტირებული პროგრამი­რე­ბის არსი. ხშირად აგებენ დეტალიზაციის სხვადასხვა დონის რამდე­ნიმე მოდელს. მაგალითად, ზოგადად ავტომობილის მოდე­ლის აღწერისას არაა საჭირო ყველა იმ პარამეტრის გათვა­ლისწინება, რომლებიც აუცილებელია სატვირთო ავ­ტო­მო­ბილის ან სპორტული რბოლების ავტომობილის უფრო კონ­კრეტული და ზუსტი მოდელის აგებისას. ამასთან, უფრო ზუს­ტი მოდელი, რომელიც აბსტრაქციის უფრო დაბალი დო­ნით ხასიათდება, გამოიყენებს ნაკლებად ზუსტი მოდე­ლის უკვე არსებულ მეთოდებს. აქ შეიძლება დაისვას სხვადასხვა კითხვა: მსოფლიოში არსე­ბობს ათასობით სხვადასხვა მარკისა და ტიპის ავტომო­ბი­ლები, რა არის მათ შორის საერთო? ხომ არ ჯობია ყველა განსხვავებული ტიპის ავტომობილისათვის ავაგოთ განსხვა­ვებული კლასი? როგორ მოვახდინოთ ყველა ამ კლასის ორგანიზება? ამ კითხვებზე ობიექტზე ორიენტირებული დაპროგრამება პასუხობს ასე: უნდა მოვახდინოთ კლასების იერარქიის ორგანიზება. ობიექტზე ორიენტირებული დაპროგრამების სამი პრინციპი ობიექტზე ორიენტირებული დაპროგრამების ყველა ენას აქვს მექანიზმები, რომლებიც აადვილებენ ობიექტზე ორიენ­ტირებული მოდელების აგებას. ამ მექანიზმებს წარმოადგენს ინკაფსულაცია, მემკვიდრეობითობა და პოლიმორფიზმი. განვიხილოთ ეს კონცეფციები. ინკაფსულაცია ინკაფსულაცია - ესაა მექანიზმი, რომელიც კოდს აკავშირებს იმ მონაცემებთან, რომლებთანაც ის მუშაობს და ორივე ამ კომპონენტს იცავს გარე ჩარევებისაგან და უნებართვო მი­მარ­თვებისაგან. ინკაფსულაცია შეიძლება წარმოვიდგინოთ, როგორც დამცავი გარსი, რომელიც კოდსა და მონაცემებს იცავს სხვა, ამ გარსის გარეთ მყოფი კოდის მიერ თავი­სუფალი წვდომისაგან (მიმართვისაგან). გარსის შიდა კოდსა და მონაცემებზე წვდომა (მიმართვა) მკაცრად კონტროლ­დება წინასწარ განსაზღვრული ინტერფეისით. რეალურ სამყაროსთან ანალოგიის მიზნით, განვიხილოთ ავტომობი­ლის სიჩქარის გადაცემათა კოლოფი. მასში ინკაფსული­რე­ბულია სხვადასხვა ინფორმაცია ავტომობილის შესახებ, მაგა­ლითად, აჩქარება, სავალი გზის ზედაპირის დახრილობა, სიჩქარის კოლოფის რეჟიმის გადამრთველის მდგომარეობა. მომხმარებელს (მძღოლს) ამ რთულ ინკაფსუალციაზე ზე­მოქ­მედება შეუძლია მხოლოდ ერთი გზით: სიჩქარეთა გადამრთველის სხვადასხვა პოზიციაში გადატანით. სიჩქა­რეთა კოლოფზე შეუძლებელია ვიმოქმედოთ მაგალითად, მოხვევის ნათურის გადამრთველით ან შუშების გამწმენდის ბერკეტით. ამრიგად, სიჩქარის გადაცემათა კოლოფზე მოქმე­დი ერთადერთი ინტერფეისია სიჩქარეთა გადამრთველი. გადა­ცემათა კოლოფის შიგნით მიმავალი პროცესები ზეგავ­ლენას არ ახდენენ მის გარეთ მყოფ ობიექტებზე (მაგალი­თად, არ ანათებს ფარებს!?). ვინაიდან სიჩქარეთა გადართვის ფუნქცია ინკაფსულირებულია გადაცემათა კოლოფში, ავტო­მო­ბილების ათობით სხვადასხვა გამომშვებმა ფირმამ კოლო­ფის რეალიზაცია შეიძლება მოახდინოს თავისი მეთოდით. მძღოლის კუთხით ყველა გადაცემათა კოლოფი ერთნაირად მუშაობს. ანალოგიური მსჯელობა შეიძლება გამოვიყენოთ პროგრამი­რებაშიც. ინკაფსულირებული კოდის სიმძლავრე იმაში მდგო­­მარეობს, რომ ყველამ იცის როგორ მიმართოს მას და როგორ გამოიყენოს იგი რეალიზაციის ნიუანსების ცოდნის გარეშე. Java-ში ინკაფსულაციის განხორციელების საფუძველს წარ­მო­ადგენს კლასი. თითოეული მოდელის აღწერა ხდება ერთი ან რამდენიმე კლასის (classes) საშუალებით. კლასი შეიძლება ჩავთვალოთ პროექტად, მონახაზად, შაბლონად, რომლის მიხედვითაც შემდგომში შეიქმნება კონკრეტული ობიექ­ტები. კლასი შეიცავს ობიექტის დამახასიათებელ ცვლადე­ბისა და კონსტანტების აღწერას. მათ უწოდებენ კლასის ველებს ან თვისებებს (class fields). ობიექტის მოქმედებების აღმწერ პროცედურებს უწოდებენ კლასის მეთოდებს (class methods). კლასის მეთოდები ან მოკლედ მეთოდები - ესაა პროგრამის კოდი, რომელიც ახდენს მონაცემების დამუშა­ვებას. ე.ი. კლასის წევრები შეიძლება იყოს ველები (თვისე­ბები, ცვლადები) და მეთოდები (პროცედურები). სწორად დაწერილ Java პროგრამებში მეთოდები განსაზ­ღვ­რავს კლასის წევრი-ცვლადების გამოყენების ხერხს. ანუ კლასის ინტერფეისი და ურთიერთობა განისაზღვრება მე­თო­დებით, რომლებიც ახდენენ მოქმედებებს კლასის ეგზემ­პლარების მონაცემებზე. კლასის შიგნით შეიძლება აღიწეროს ჩადგმული კლასები (nested classes) და ჩადგმული ინტერფეისები. ველები, მეთოდები, ჩადგმული კლასები წარმოადგენენ კლასის წევრებს (class members). სხვადასხვა სკოლები (ალგორით­მული ენები) სხვადასხვა ტერმინებს იყენებენ. ჩვენ გამოვი­ყენებთ ალგორითმულ ენა Java-ში მიღებულ ტერმინებს. მაგალითად განვიხილოთ ავტომობილის აღწერის მონახაზი: class Automobile { [indent=1] int maxVelocity; // ველი, ავტომობილის მაქსიმალური სიჩქარე[/indent] int speed; // ველი, ავტომობილის მიმდინარე სიჩქარე int weight; // ველი, ავტომობილის მასა // ..... სხვა ველები void moveTo(int x, int y) { // მეთოდი, ავტომობილის // გადაადგილების მოდელირება // x და y პარამეტრები არაა ველები int a = 1; // ლოკალური ცვლადი, არაა ველი // ..... მეთოდის ტანი. აქ უნდა იყოს // ავტომობილის (x,y) წერტილში // გადაადგილების კანონის აღწერა } // სხვა მეთოდები } Pascal-ის მცოდნეებისათვის. Java-ში არ არსებობს ჩადგმული (შიდა) პროცედურები და ფუნქციები, მეთოდის ტანში არ შეიძლება სხვა მეთოდის აღწერა. კლასის აღწერის შემდეგ შესაძლებელია ამ კლასის კონკრე­ტული ობიექტების, ეგზემპლარების (instances) შექმნა. როგორც ზემოთ აღვნიშნეთ, კლასის დანიშნულებაა პროგრა­მის რთული სტრუქტურის ინკაფსულაცია, ამიტომ არსებობს მექანიზმი კლასის შიდა სტრუქტურის რეალიზაციის დასა­ფარად. კლასის შიგნით თითოეული მეთოდი ან ცვლადი შეიძლება მონიშნული იყოს როგორც პრივატული ან ყველა­სათვის წვდომადი (ღია). კლასის წევრებთან ღია, ყველასათ­ვის წვდომადი ინტერფეისი კლასის გარე მომხმა­რებლებს უფლებას აძლევს მიმართონ ამ წევრებს. კლასის პრივატული მეთოდები და ცვლადები წვდომადია მხოლოდ ამავე კლასის კოდისათვის. შესაბამისად, ნებისმიერო კოდი, რომელიც არაა იმავე კლასის წევრი ვერ მიიღებს უფლებას დაუკავ­შირდეს კლასის პრივატულ მეთოდს ან ცვლადს. ვინაიდან კლასის პრივატულ წევრებთან მიმართვა შესაძლებელია მხოლოდ კლასის ღია მეთოდების საშუა­ლებით, ამიტომ დარ­წმუნებული შეიძლება ვიყოთ, რომ შეუძლებელია პრი­ვა­ტულ წევრებზე უნებართვო მიმარ­თვები. ცხადია, ღია ინტერფეისი გააზრებულად უნდა იყოს დაპროექტებული, ვინაიდან ზომაზე მეტად არ გახსნას კლასის მუშაობის შიდა ნიუანსები (სურ. 1.). სურ.1. ინკაფსულაცია: ყველასათვის წვდომადი მეთოდები შეიძლება გამოყენებული იქნას პრივატული მონაცემების დასაცავად
  4. თემაში წარმოდგენილი იქნება jax-ws ვებ სერვისის დაწერა და გამართვა შემდეგი გამოყენებისთვის, რომელსაც ასევე შემოგთავაზებთ სხვა თემის სახით .NET გარემოში, ანუ ერთი სიტყვით რომ ვთქვა Java ში დაწერილ ვებ-სერვისს გამოვიძახებ .NET ში. სერვისს შემოგთავაზებთ docx4j ბიბლიოთეკის მაგალითზე, რომელიც docx დოკუმენტს გარდაქმნის pdf ფორმატში (MS Word -> PDF). პირველ რიგში დაგვჭირდება docx4j ბიბლიოთეკა, რომლის უფასო ვერსიაც შეგიძლიათ გადმოიწეროთ: https://www.dropbox.com/sh/4rxdqrmceih1h1t/AACbyDSv0tWoClgqWhnQZ2A8a ასევე დაგვჭირდება: Tomcat და Eclipse. 1. გავხსნათ Eclipse და შევქმნათ Dynamic Web Project. პროექტის ძირითადი სტრუქტურა ასე უნდა გამოიყურებიდეს, ანუ უნდა შექმნათ 2 package, ჩემ შემთხვევაში: pdf.converter და pdf.converter.jaxws და pdf.converter -> ში ერთი კლასი და ერთი ინტერფეისი, ჩემ შემთხვევაში: Converter (კლასი) და IConverter (ინტერფეისი), ხოლო pdf.converter.jaxws პაკეტში 2 კლასი როგორც: DocToPdf და DocToPdfResponse. WebContent -> WEB-INF ში შექმენით xml, ჩემ შემთხვევაში sun-jaxws.xml WebContent -> WEB-INF -> lib ში ჩაყარეთ jar ფაილები გადმოწერა: https://www.dropbox.com/sh/y8bpxhah1c81enr/AAD3dnzFe999vbk_d8dblnXqa გადავიდეთ კოდზე: pdf.converter -> IConverter ინტერფეისი package pdf.converter; import javax.jws.WebMethod; import javax.jws.WebService; @WebService public abstract interface IConverter { @WebMethod public abstract byte[] DocToPdf(byte[] paramArrayOfByte); } pdf.converter -> Converter კლასი package pdf.converter; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import javax.jws.WebService; import org.docx4j.Docx4J; import org.docx4j.convert.out.FOSettings; import org.docx4j.fonts.IdentityPlusMapper; import org.docx4j.fonts.Mapper; import org.docx4j.fonts.PhysicalFont; import org.docx4j.fonts.PhysicalFonts; import org.docx4j.openpackaging.exceptions.Docx4JException; import org.docx4j.openpackaging.packages.WordprocessingMLPackage; @WebService(endpointInterface="pdf.converter.IConverter") public class Converter implements IConverter { public byte[] DocToPdf(byte[] docBytes) { byte[] arg0 = new byte[4]; arg0 = docBytes; ByteArrayInputStream stream = new ByteArrayInputStream(arg0); ByteArrayOutputStream resultstream = new ByteArrayOutputStream(); WordprocessingMLPackage wordMLPackage = null; try { wordMLPackage = WordprocessingMLPackage.load(stream); } catch (Docx4JException e) { e.printStackTrace(); } Mapper fontMapper = new IdentityPlusMapper(); try { wordMLPackage.setFontMapper(fontMapper); } catch (Exception e) { e.printStackTrace(); } PhysicalFont font = (PhysicalFont)PhysicalFonts.getPhysicalFonts().get("Arial Unicode MS"); if (font != null) { fontMapper.getFontMappings().put("Times New Roman", font); } fontMapper.getFontMappings().put("Libian SC Regular", (PhysicalFont)PhysicalFonts.getPhysicalFonts().get("SimSun")); FOSettings foSettings = Docx4J.createFOSettings(); foSettings.setWmlPackage(wordMLPackage); try { Docx4J.toFO(foSettings, resultstream, 1); } catch (Docx4JException e) { e.printStackTrace(); } System.out.println("mmomdocdm"); byte[] p = resultstream.toByteArray(); return p; } } pdf.converter.jaxws -> DocToPdf კლასი package pdf.converter.jaxws; import javax.xml.bind.annotation.XmlAccessType; import javax.xml.bind.annotation.XmlAccessorType; import javax.xml.bind.annotation.XmlElement; import javax.xml.bind.annotation.XmlRootElement; import javax.xml.bind.annotation.XmlType; @XmlRootElement(name="DocToPdf", namespace="http://converter.pdf/") @XmlAccessorType(XmlAccessType.FIELD) @XmlType(name="DocToPdf", namespace="http://converter.pdf/") public class DocToPdf { @XmlElement(name="arg0", namespace="") private byte[] arg0; public byte[] getArg0() { return this.arg0; } public void setArg0(byte[] arg0) { this.arg0 = arg0; } } pdf.converter.jaxws -> DocToPdfResponse კლასი package pdf.converter.jaxws; import javax.xml.bind.annotation.XmlAccessType; import javax.xml.bind.annotation.XmlAccessorType; import javax.xml.bind.annotation.XmlElement; import javax.xml.bind.annotation.XmlRootElement; import javax.xml.bind.annotation.XmlType; @XmlRootElement(name="DocumentToPdfResponse", namespace="http://converter.pdf/") @XmlAccessorType(XmlAccessType.FIELD) @XmlType(name="DocumentToPdfResponse", namespace="http://converter.pdf/") public class DocToPdfResponse { @XmlElement(name="return", namespace="") private byte[] _return; public byte[] getReturn() { return this._return; } public void setReturn(byte[] _return) { this._return = _return; } } WebContent -> WEB-INF -> sun-jaxws.xml ფაილი <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE xml> <endpoints xmlns="http://java.sun.com/xml/ns/jax-ws/ri/runtime" version="2.0"> <endpoint name="ConverterWS" implementation="pdf.converter.Converter" url-pattern="/documentsToPdf"/> </endpoints> WebContent -> WEB-INF -> web.xml ფაილი <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4"> <listener> <listener-class> com.sun.xml.ws.transport.http.servlet.WSServletContextListener </listener-class> </listener> <servlet> <servlet-name>ConverterWS</servlet-name> <servlet-class> com.sun.xml.ws.transport.http.servlet.WSServlet </servlet-class> </servlet> <servlet-mapping> <servlet-name>ConverterWS</servlet-name> <url-pattern>/documentsToPdf</url-pattern> </servlet-mapping> </web-app> ახლა კი ისღა დაგვრჩენია ჩვენი პროექტი გავიტანოთ როგორც WAR (Web Archive): შედეგად მივიღებთ WAR რომელიც უნდა ავტვირთოთ სერვერზე, ამისთვის გავუშვათ Tomcat, შევიდეთ მისამართზე localhost: port რაზეც Tomcat დავაყნეთ: შევდივართ Manager App სადაც War File to Deploy -> Choose File ავირჩევთ WAR ფაილს და ავტვირთავთ, პროექტი ავტომატურად გაეშვება, შევდივართ მისამართზე: http://localhost:8080/ConvertToPDFService/documentsToPdf?wsdl სადაც ჩვენი სერვისია განთავსებული, სწორად გამართვის შემთხვევაში გვერდი უნდა გამოიყურებოდეს ასეთნაირად: P.S. სერვისი მზადაა გამოყენებისთვის, შემდეგ თემაში წარმოდგენილი იქნება მისი გამოყენება .NET ში.
  5. ავტორები: მ.კიკნაძე, ე.ჩიკაშუა, თ. კაიშაური, თ. ჟვანია, ლ. პეტრიაშვილი. გამომცემლობა: სტუ-ს რედაქცია ფორმატი: PDF გვერდების რაოდენობა: 70 ხარისხი: კარგად სკანირებული წელი: 2006 აღწერა: წიგნი წარმოადგენს დამხმარე სახელმძღვანელოს საგანში "ვებ გვერდების პროექტირება". მასში აღწერილია HTML (Hyper Text Markup Language) ჰიპერტექსტირების მარკირების ენის შესაძლებლობები, სტილების შექმნა და გამოყენება. CSS (Cascading Style Sheet) ენის საშუალებით და Java script დაპროგრამების ენის საფუძვლები. გადმოწერა: https://mega.co.nz/#!2A9HBbYD!mtGRJ7Nh01eG7XPXM2RRzmEClZ5kXA5gmaSxyJ-GbHY
  6. ავტორი: David Gassner; ენა: ინგლისური; გამოშვების თარიღი: 14/12/2011; გამომქვეყნებელი: Lynda.com; დონე: დამწყები; საერთო დრო: 7 საათი და 17 წუთი; ზომა: 485 MB (უარქივოთ 600 MB); აღწერა: Join author David Gassner as he explores Java SE (Standard Edition), the language used to build mobile apps for Android devices, enterprise server applications, and more. This course demonstrates how to install both Java and the Eclipse IDE and dives into the particulars of programming. The course also explains the fundamentals of Java, from creating simple variables, assigning values, and declaring methods to working with strings, arrays, and subclasses; reading and writing to text files; and implementing object oriented programming concepts. Topics include: Understanding the history and principles of Java Installing Eclipse and Java Compiling and running from the command line Managing memory and performing garbage collection Declaring and initializing variables Writing conditional code Building and parsing strings Debugging and exception handling Using simple arrays Creating custom classes Working with encapsulation, inheritance, and polymorphism Managing files Documenting code with Javadocs პირველი ვიდეოგაკვეთილი (შესავალი): P.S. როგორც ხედავთ აღწერა ინგლისურ ენაზეა, აღარ გადამითარგმნია (დროის უქონლობის გამო) და ვისაც შეუძლია რომ თარგმნოს ძალიან დიდ პატივს დამდებს თუ გადათარგმნის და აქვე დამიპოსტავს... მადლობა წინასწარ!
  7. ToQcHista

    Java-ში Java Developer Kit (JDK)

    ესეგიი ამ პოსტში დავაყენებთ JDK-ს ეს ჯავაპროგრამირებისთვის აუცილებელი არის რადკან კოდი რომ დაკომბილირდეს JDK არის საჭრო რომლის მერე მიღება ბაიტ კოდი ამ ბაიტ კოდს კიდე აღიქვამს JVM ვირტუალური მანქანები (ტელეფონი,PC,ნოუდბუქი და სხვა დევაისები) გადავდივართ საიტზე და ვეთანხმებით ლიცენზიას მერე ქვევიტ პირველივე ოფციაში ვირჩევთ რომელი ოპერაციული სისტემაც გვაქ და რომელი ბიტიც გვაქ ნუ ეს ეხლა მარტივი არის როცა გადმოიწერს დაყენეთ. და მერე შევდივართ c/programfile/java ში და იქნება მანდ jdk და ვერსია იქნება ნუ პირველში შედით მერე bin-ში ეს მისამართი უდნა დავაკოპიროთ და ეხლა წავიღოთ computer>profertis>advanced system setting>enviroment variables პირველში რაც დგას იდგეს მეორეში უნდა მოვძებნოთ pach მერე როცა გავხსნით პეჩს სულ ბოლოში გადადით და წერტილ მძიმე დასვით და ის დაკოპირებული ჩასვით მანდ მერე ოკ ოკ ოკ.. და ეგ არის მაგრამ ეხლა დავტესტოთ თუ მუშაობს CMD>ში ვწერთ javac ამის დაწერის მერე სიემდიმ თუ ესე ამოყარა კოდები მაშინ გამოვიდა რომ მუშაობს და კოდის დაკომბილირდება თუ ამოყარა ნოთ ნო და რაღაცები მაშინ რაღაც შეგეშალათ
  8. ავტორი: Бенджамин Эванс, Мартин Вербург დასახელება: Java. Новое поколение разработки წელი: 2014 ISBN: 978-5-496-00544-9 ფორმატი: PDF აღწერა: В этой книге представлен оригинальный и практичный взгляд на новые возможности Java 7 и новые языки для виртуальной машины Java (JVM), а также рассмотрены некоторые вспомогательные технологии, необходимые для создания Java-программ завтрашнего дня. https://www.dropbox.com/s/vgutrthcqkojye1/evans_b_verburg_m_java_novoe_pokolenie_razrabotki.pdf
  9. GHOST_FATHER

    Absolute Java (5th Edition)

    This book is designed to serve as a textbook and reference for programming in the Java language. For undergraduate students in Computer Science and Computer Programming courses. Praised for providing an engaging balance of thoughtful examples and explanatory discussion, best-selling author Walt Savitchs explain concepts and techniques in a straightforward style using understandable language and code enhanced by a suite of pedagogical tools. AThis book is appropriate for both introductory and intermediate programming courses introducing Java. Brief Contents Chapter 1 GETTING STARTED Chapter 2 CONSOLE INPUT AND OUTPUT Chapter 3 FLOW OF CONTROL Chapter 4 DEFINING CLASSES I Chapter 5 DEFINING CLASSES II Chapter 6 ARRAYS Chapter 7 INHERITANCE Chapter 8 POLYMORPHISM AND ABSTRACT CLASSES Chapter 9 EXCEPTION HANDLING Chapter 10 FILE I/O Chapter 11 RECURSION Chapter 12 UML AND PATTERNS Chapter 13 INTERFACES AND INNER CLASSES Chapter 14 GENERICS AND THE ArrayList CLASS Chapter 15 LINKED DATA STRUCTURES Chapter 16 COLLECTIONS, MAPS AND ITERATORS Chapter 17 SWING I Chapter 18 SWING II Chapter 19 JAVA NEVER ENDS Chapter 20 APPLETS AND HTML Appendix 1 KEYWORDS Appendix 2 PRECEDENCE AND ASSOCIATIVITY RULES Appendix 3 ASCII CHARACTER SET Appendix 4 FORMAT SPECIFICATIONS FOR printf Appendix 5 SUMMARY OF CLASSES AND INTERFACES INDEX Contents Chapter 1 Getting Started 1.1 INTRODUCTION TO JAVA 1.2 EXPRESSIONS AND ASSIGNMENT STATEMENTS 1.3 THE CLASS String 1.4 PROGRAM STYLE Chapter 2 Console Input and Output 2.1 SCREEN OUTPUT 2.2 CONSOLE INPUT USING THE Scanner CLASS 2.3 INTRODUCTION TO FILE INPUT Chapter 3 Flow of Control 3.1 BRANCHING MECHANISM 3.2 BOOLEAN EXPRESSIONS 3.3 LOOPS 3.4 DEBUGGING 3.5 RANDOM NUMBER GENERATION Chapter 4 Defining Classes I 4.1 CLASS DEFINITIONS 4.2 INFORMATION HIDING AND ENCAPSULATION 4.3 OVERLOADING 4.4 CONSTRUCTORS Chapter 5 Defining Classes II 5.1 STATIC METHODS AND STATIC VARIABLES 5.2 REFERENCES AND CLASS PARAMETERS 5.3 USING AND MISUSING REFERENCES 5.4 PACKAGES AND javadoc Chapter 6 Arrays 6.1 INTRODUCTION TO ARRAYS 6.2 ARRAYS AND REFERENCES 6.3 PROGRAMMING WITH ARRAYS 6.4 MULTIDIMENSIONAL ARRAYS Chapter 7 Inheritance 7.1 INHERITANCE BASICS 7.2 ENCAPSULATION AND INHERITANCE 7.3 PROGRAMMING WITH INHERITANCE Chapter 8 Polymorphism and Abstract Classes 8.1 POLYMORPHISM 8.2 ABSTRACT CLASSES Chapter 9 Exception Handling 9.1 EXCEPTION HANDLING BASICS 9.2 THROWING EXCEPTIONS IN METHODS 9.3 MORE PROGRAMMING TECHNIQUES FOR EXCEPTION HANDLING Chapter 10 File I/O 10.1 INTRODUCTION TO FILE I/O 10.2 TEXT FILES 10.3 THE File CLASS 10.4 BINARY FILES* 10.5 RANDOM ACCESS TO BINARY FILES* Chapter 11 Recursion 11.1 RECURSIVE Void METHODS 11.2 RECURSIVE METHODS THAT RETURN A VALUE 11.3 THINKING RECURSIVELY Chapter 12 UML and Patterns 12.1 UML 12.2 PATTERNS* Chapter 13 Interfaces and Inner Classes 13.1 INTERFACES 13.2 SIMPLE USES OF INNER CLASSES 13.3 MORE ABOUT INNER CLASSES Chapter 14 Generics and the ArrayList Class 14.1 THE ArrayList CLASS 14.2 GENERICS Chapter 15 Linked Data Structures 15.1 JAVA LINKED LISTS 15.2 COPY CONSTRUCTORS AND THE clone METHOD* 15.3 ITERATORS 15.4 VARIATIONS ON A LINKED LIST 15.5 HASH TABLES WITH CHAINING 15.6 SETS 15.7 TREES Chapter 16 Collections, Maps and Iterators 16.1 COLLECTIONS 16.2 MAPS 16.3 ITERATORS Chapter 17 Swing I 17.1 EVENT-DRIVEN PROGRAMMING 17.2 BUTTONS, EVENTS, AND OTHER SWING BASICS 17.3 CONTAINERS AND LAYOUT MANAGERS 17.4 MENUS AND BUTTONS 17.5 TEXT FIELDS AND TEXT AREAS Chapter 18 Swing II 18.1 WINDOW LISTENERS 18.2 ICONS AND SCROLL BARS 18.3 THE Graphics CLASS 18.4 COLORS 18.5 FONTS AND THE drawString METHOD Chapter 19 Java Never Ends 19.1 MULTITHREADING 19.2 NETWORKING WITH STREAM SOCKETS 19.3 JAVABEANS 19.4 JAVA AND DATABASE CONNECTIONS 19.5 WEB PROGRAMMING WITH JAVA SERVER PAGES Chapter 20 Applets and HTML Appendix 1 Keywords Appendix 2 Precedence and Associativity Rules Appendix 3 ASCII Character Set Appendix 4 Format Specifications for printf Appendix 5 Summary of Classes and Interfaces Index https://www.dropbox.com/s/5ot8g6ml5p1h3qh/Absolute%20Java%205th%20Edition.pdf
  10. წელი: 2004 ავტორი: O'Reilly გამომცემლობა: O'Reilly ფორმატი: HTML აღწერა: მოცემულია წიგნების კომპლექტი, წიგნების სია იხილავთ ქვემოთ The XML CD Bookshelf version 1.0 XML in a Nutshell, 2nd Edition By Elliotte Rusty Harold and W. Scott Means XSLT By Doug Tidwell XML Schema By Eric van der Vlist SAX2 By David Brownell Java & XML, 2nd Edition By Brett McLaughlin Java and XSLT By Eric M. Burke Perl & XML By Erik T. Ray and Jason McIntosh The Perl CD Bookshelf version 4.0 Perl in a Nutshell, 2nd Edition By By Nathan Patwardhan, Ellen Siever and Stephen Spainhour Perl Cookbook, 2nd Edition By Tom Christiansen and Nathan Torkington Learning Perl, 3rd Edition By Randal L. Schwartz and Tom Phoenix Programming Perl, 3rd Edition By Larry Wall, Tom Christiansen, and Jon Orwant Learning Perl Objects, References and Modules By Randal L. Schwartz, with Tom Phoenix Mastering Regular Expressions, 2nd Edition by Jeffrey Friedl - in Adobe PDF format The Perl CD Bookshelf version 3.0 * Perl in a Nutshell, 2nd Edition By Nathan Patwardhan, Ellen Siever and Stephen Spainhour * Programming Perl, 3rd Edition By Larry Wall, Tom Christiansen, and Jon Orwant * Learning Perl, 3rd Edition By Randal L. Schwartz and Tom Phoenix Perl Cookbook By Tom Christiansen and Nathan Torkington * Perl and XML By Erik T. Ray and Jason McIntosh Perl and LWP By Sean M. Burke Mastering Perl/Tk By Steve Lidie and Nancy Walsh The Perl CD Bookshelf version 2.0 Perl in a Nutshell By Ellen Siever, Stephen Spainhour & Nathan Patwardhan * Programming Perl, 3rd Edition By Larry Wall, Tom Christiansen & Jon Orwant Advanced Perl Programming By Sriram Srinivasan * Perl Cookbook By Tom Christiansen and Nathan Torkington Perl for System Administration By David N. Blank-Edelman The Perl CD Bookshelf version 1.0 * Perl in a Nutshell By Ellen Siever, Stephen Spainhour & Nathan Patwardhan Learning Perl, 2nd Edition By Randal Schwartz, Tom Christiansen & Larry Wall Learning Perl on Win32 Systems By Randal L. Schwartz, Erik Olson & Tom Christiansen Programming Perl, 2nd Edition By Larry Wall, Tom Christiansen & Randal L. Schwartz * Advanced Perl Programming By Sriram Srinivasan * Perl Cookbook By Tom Christiansen & Nathan Torkington Java Reference Library Java in a Nutshell, 2nd Edition By David Flanagan Java Language Reference, 2nd Edition By Mark Grand Java AWT Reference By John Zukowski Java Fundamental Classes Reference By Mark Grand and Jonathan Knudsen Exploring Java, 2nd Edition By Patrick Niemeyer & Joshua Peck The Java Enterprise CD Bookshelf version 1.0 Java Enterprise in a Nutshell By David Flanagan, Jim Farley, William Crawford, and Kris Magnusson Java in a Nutshell, 3rd Edition By David Flanagan Java Foundation Classes in a Nutshell By David Flanagan Enterprise JavaBeans, 2nd Edition By Richard Monson-Haefel Java Servlet Programming By Jason Hunter with William Crawford Java Security By Scott Oaks Java Distributed Computing By Jim Farley The Web Design CD Bookshelf version 1.0 Web Design in a Nutshell, 2nd Edition By Jennifer Niederst HTML & XHTML: The Definitive Guide, 4th Edition By Chuck Musciano and Bill Kennedy Designing Web Audio By Josh Beggs and Dylan Thede Cascading Style Sheets: The Definitive Guide By Eric A. Meyer ActionScript: The Definitive Guide By Colin Moock Information Architecture for the World Wide Web By Louis Rosenfeld and Peter Morville The Web Programming CD Bookshelf version 1.0 Webmaster in a Nutshell, 3rd Edition By Stephen Spainhour and Robert Eckstein Programming PHP By Rasmus Lerdorf and Kevin Tatroe with Bob Kaehms and Ric McGredy Web Database Applications with PHP & MySQL By Hugh E. Williams and David Lane PHP Cookbook By David Sklar and Adam Trachtenberg JavaScript: The Definitive Guide, 4th Edition By David Flanagan Dynamic HTML: The Definitive Reference, 2nd Edition By Danny Goodm Web Developer's Library HTML: The Definitive Guide, 2nd Edition By Chuck Musciano and Bill Kennedy CGI Programming on the World Wide Web By Shishir Gundavaram JavaScript: The Definitive Guide, 2nd Edition By David Flannagan * Programming Perl, 2nd Edition By Larry Wall, Tom Christiansen, & Randal Schwartz Web Master in a Nutshell By Stephen Spainhour & Valerie Quercia The Linux Web Server CD Bookshelf version 2.0 Linux in a Nutshell, 4th Edition By Ellen Siever, Stephen Figgins, and Aaron Weber Running Linux, 4th Edition By Matt Welsh, Matthias Kalle Dalheimer, Terry Dawson, and Lar Kaufman Managing & Using MySQL, 2nd Edition By George Reese, Randy Jay Yarger, and Tim King, with Hugh E. Williams Apache: The Definitive Guide, 3rd Edition By Ben Laurie and Peter Laurie Programming PHP By Rasmus Lerdorf and Kevin Tatroe, with Bob Kaehms and Ric McGredy Practical mod_perl By Stas Bekman and Eric Cholet The Linux Web Server CD Bookshelf version 1.0 Linux in a Nutshell, 3rd Edition By Ellen Siever, Stephen Spainhour, Stephen Figgins and Jessica P. Hekman Running Linux, 3rd Edition By Matt Welsh, Matthias Kalle Dalheimer and Lar Kaufman Apache: The Definitive Guide, 2nd Edition By Ben Laurie and Peter Laurie MySQL & mSQL By Randy Jay Yarger, George Reese and Tim King Programming the Perl DBI By Alligator Descartes and Tim Bunce CGI Programming with Perl, 2nd Edition By Scott Guelich, Shishir Gundavaram and Gunther Birznieks The UNIX CD Bookshelf version 3 Unix in a Nutshell, 3rd Edition By Arnold Robbins Unix Power Tools, 3rd Edition By Shelley Powers, Jerry Peek, Tim O'Reilly, and Mike Loukides Mac OS X for Unix Geeks By Brian Jepson and Ernest E. Rothman Learning the Korn Shell, 2nd Edition By Bill Rosenblatt and Arnold Robbins sed & awk, 2nd Edition By Dale Dougherty and Arnold Robbins Learning the Unix Operating System, 5th Edition By Jerry Peek, Grace Todino, and John Strang Learning the vi Editor, 6th Edition By Linda Lamb and Arnold Robbins The UNIX CD Bookshelf version 2.1 UNIX Power Tools, 2nd Edition By Jerry Peek, Tim O'Reilly & Mike Loukides * UNIX in a Nutshell: System V Edition, 3rd Edition By Arnold Robbins * Learning the vi Editor, 6th Edition By Linda Lamb & Arnold Robbins * sed & awk, 2nd Edition By Dale Dougherty & Arnold Robbins Learning the Korn Shell By Bill Rosenblatt Learning the UNIX Operating System, 4th Edition By Jerry Peek The Networking CD Bookshelf version 2.0 TCP/IP Network Administration, 3rd Edition By Craig Hunt SSH, The Secure Shell: The Definitive Guide By Daniel J. Barrett and Richard E. Silverman Managing NFS and NIS, 2nd Edition By Hal Stern, Mike Eisler and Ricardo Labiaga Essential SNMP By Doug Mauro and Kevin J. Schmidt Network Troubleshooting Tools By Joseph D. Sloan DNS and Bind, 4th Edition By Paul Albitz and Cricket Liu Building Internet Firewalls, 2nd Edition By Elizabeth B. Zwicky, Simon Cooper and D. Brent Chapman The Networking CD Bookshelf DNS & BIND, 3rd Edition By Cricket Liu & Paul Albitz TCP/IP Network Administration, 2nd Edition By Craig Hunt sendmail, 2nd Edition By Bryan Costales & Eric Allman sendmail Desktop Reference By Bryan Costales & Eric Allman Building Internet Firewalls By D. Brent Chapman & Elizabeth D. Zwicky Practical UNIX & Internet Security, 2nd Edition By Simson Garfinkel & Gene Spafford The Oracle PL/SQL CD Bookshelf version 1.0 Oracle PL/SQL Programming, 2nd Edition By Steven Feuerstein & Bill Pribyl Oracle PL/SQL: Guide to Oracle8i Features By Steven Feuerstein Oracle Built-in Packages By Steven Feuerstein, Charles Dye & John Beresniewicz Advanced Oracle PL/SQL Programming with Packages By Steven Feuerstein Oracle Web Applications: PL/SQL Developer's Introduction By Andrew Odewahn Oracle PL/SQL Language Pocket Reference By Steven Feuerstein, Bill Pribyl & Chip Dawes Oracle PL/SQL Built-ins Pocket Reference By Steven Feuerstein, John Beresniewicz & Chip Dawes :download: ან გადმოიწერე აქედან :download:
  11. ავტორი: Бенджамин Эванс, Мартин Вербургდასახელება: Java. Новое поколение разработки თარიღი (დაბეჭვდის): 2014 ~ ISBN: 978-5-496-00544-9 ფორმატი: PDF Описание: В этой книге представлен оригинальный и практичный взгляд на новые возможности Java 7 и новые языки для виртуальной машины Java (JVM), а также рассмотрены некоторые вспомогательные технологии, необходимые для создания Java-программ завтрашнего дня. :download:
  12. GHOST_FATHER

    Java Application Development on Linux

    Год выпуска: 2005 Автор: Carl Albing, Michael Schwarz Издательство: Prentice Hall Формат: PDF Качество: eBook (изначально компьютерное) Количество страниц: 597 Описание: Linux is the fastest-growing Java development platform because it saves money and time by serving as a platform for both development and deployment. But developers face significant platform-specific challenges when managing and deploying Java applications in a controlled production environment. Written for Java and Linux developers alike, Java™ Application Development on Linux®is the hands-on guide to the full Java application development lifecycle on Linux. Determined to spare other developers hours of trial and error, Albing and Schwarz demonstrate the platform, tools, and application development by showing realistic, easy-to-follow examples. After a simple command-line application introduces basic tools, this program leads readers through business-logic object analysis, database design, Java servlet UIs, Java Server Pages (JSP) UIs, Swing GUIs, and Standard Widget Toolkit (SWT) GUIs. Scaling up to the enterprise level provides the opportunity to use both the JBoss Application Server and the Apache Geronimo Application Servers, and Enterprise JavaBeans (EJB). Readers learn how to Use development tools available on Linux, such as the GNU Compiler for Java (gcj), Ant, the NetBeans IDE, IBM's Eclipse Java IDE, JUnit, and SunONE Studio Develop business logic layers using Java DataBase Connectivity (JDBC) Add a Web interface using servlets and JSPs Add a GUI using Sun's Abstract Window Toolkit (AWT) and IBM's SWT Deploy EJBs in Linux The authors conclude by demonstrating how a hierarchy of budgets can be created, tracked, and shared with Concurrent Versions System (CVS). A companion Website includes all source code and a link to each tool described. Java™ Application Development on Linux® can propel you from a standing start to the full-speed development and deployment of Java applications on Linux. :download:
  13. როგორც ვიცი, სამივე პროგრამირების ენა დამოკიდებულია სისტემაში დაყენებულ პლატფორმებზე. java - Java Runtime Environment C#.NET / VB.NET - .NET Framework აქედან გამომდინარე, ზემოთხსენებულ ენებში დაწერილი malware -ც არაა რეკომენდირებული. მაინტერესებს ამ ენებიდან რომელს აქვს უპირატესობა და რომელს არა. რა შეიძლება გაკეთდეს ერთ ენაში, რაც მეორე ენაში ვერ გაკეთდება და ა.შ. სამივე ენასთან მქონია შეხება, მაგრამ თქვენი აზრი მაინტერესებს.
  14. ოპერაციები ბიტებზე Java-ში შესაძლებელია განხორციელდეს გარკვეული ოპერა­ცი­ები long, int, short, char და byte მთელრიცხვა ტიპის ბიტებ­ზე. ცხრილში 5. ჩამთვლილია ეს ოპერაციები ბიტური ოპერაციები ვინაიდან ბიტური ოპერაციები მანიპულირებენ მთელრიც­ხვა მნიშვნელობების ბიტებზე, ამიტომ მნიშვნელოვანი გავიგოთ, როგორ იცვლება რიცხვების მნიშვნელობები ამ მანი­პულირების შედეგად. კერძოდ, მნიშვნელოვანია ვი­ცო­დეთ, როგორ ინახავს Java-ს შემსრულებელი გარემო მთელ­რიცხვა მნიშვნელობებს და როგორ ხდება უარყოფითი რიც­ხვე­ბის წარმოდგენა. ყველა მთელრიცხვა ტიპი მეხსიერებაში ჩაიწერება ორობით ფორ­მაში. მაგალითად byte ტიპის ცვლადში რიცხვი 42 ორო­ბით წარმოდგენაში ასე ჩაიწერება 00101010, სადაც თითო­ეუ­ლი თანრიგი 2-ის ხარისხს წარმოადგენს, დაწყებული 20 უკიდუ­რესი მარჯვენა ბიტიდან. შემდეგი ბიტი არის 21, შემდეგი 22, 23 და ა.შ. ამრიგად, 42=0*20+1*21+0*22+1*23+0*24+1*25+0*26+0*27=21+23+25=2+8+32 ყველა მთელრიცხვა ტიპი (char-ის გამოკლებით) ნიშნიანი მთელი რიცხვებია. ანუ მათი მნიშვნელობები შეიძლება იყო, როგორც დადებითი, ისე უარყოფითი რიცხვები. Java-ში რიც­ხვების წარმოსადგენად გამოყენებულია ორობითი რიც­ხვე­ბი დამატებით კოდში. დამატებით კოდში უარყოფითი რიცხვების წარმოსადგენად ჯერ ხდება რიცხვის ორობითი თანრიგების ინვერტირება (ანუ 0 მნიშვნელობის თანრიგები შეიცვლება 1-ით, ხოლო 1-ები 0-ით), ხოლო შემდეგ შედეგს ემატება 1. მაგალითად -42 დამატებითი კოდის მისაღებად ჯერ 42-ის ორობითი 00101010 მნიშვნელობის ყოველი თანრიგი შეიცვლება თავისი შებრუნებულით ე.ი მივიღებთ 11010101, შემდეგ 1 დამატებით მივიღებთ 11010110 ანუ -42-ს. პირიქით, უარყოფითი რიცხვის დეკოდირებისათვის (ორობითიდან ათობითი რიცხვის მისაღებად) ჯერ უნდა ინვერტირება გავუკეთოთ ყველა ბიტს, ხოლო შემდეგ შე­დეგს დავუმატოთ 1. მაგალითად, -42 ანუ 11010110 ინვენ­ტი­რე­ბით მივიღებთ 00101001 (ანუ 41), შემდეგ ვუმატებთ 1 და მივიღებთ 00101010 (ანუ 42). გასათვალისწინებელია, რომ ვინაიდან Java-ში ყველა მთელ რიცხვს ნიშნიანი მნიშვნელობა აქვს, ბიტური ოპერაციების შემ­დეგ შეიძლება მოულოდნელი შედეგები მივიღოთ. მაგა­ლი­თად, ყველაზე უფროსი ბიტის მნიშვნელობა თუ გახდება 1-ის ტოლი, მაშინ რიცხვი აღიქმება, როგორც უარყოფითი. უნ­და გვახსოვდეს, რა გზითაც არ უნდა გახდეს უფროსი ბი­ტი 1-ის ტოლი, იგი იქნება უარყოფითი რიცხვი. ბიტური ლოგიკური ოპერაციები ბიტური ლოგიკური ოპერაციებია: &, |, ^, ~. თითოეული ამ ოპე­­­რაციის შედეგი ნაჩვენებია შემდეგ ცხრილში. ბიტური ოპე­­რაციები ხორციელდება თითოეული ოპერანდის თი­თო­ეულ, ცალკეულ ბიტზე. ბიტური ლოგიკური ოპერაციები: ბიტური NOT (არა) ამ ოპერაციას უწოდებენ ლოგიკურ „არა“-ს ან ინვერსიას, აღი­ნიშ­ნება „~“ სიმბილოთი. ის არის უნარული (ერთ ოპე­რან­­­დიანი) ოპერაცია და ანხორციელებს თითოეული ბი­ტის ინ­ვერ­ტირებას (0-ს ცვლის 1-ით, 1-ს ცვლის 0-ით). მაგა­ლი­თად, 42 რომელიც ორობითში ასეთი ბიტების მიმდევრობით ჩაიწერება: 00101010 NOT ოპერაციის გამოყენების შემდეგ გარდაიქმნება ასე: 11010101 ბიტური AND (და) ამ ოპერაციას უწოდებენ ბიტურ და-ს ან კონიუნქციას, აღი­ნიშ­ნება სიმბოლო „&“-ით. ამ ოპერაციის შედეგად რომე­ლიმე თანრიგში მიღებული ბიტის მნიშვნელობა ტოლია 1-ის, თუ ოპერანდების შესაბამისი ბიტებიც ტოლია 1-ის. ყვე­ლა სხვა შემთხვევაში შედეგის ბიტი 0-ის ტოლია. მაგა­ლი­თად: 00101010 42 & 00001111 15 - - - - - - - - - - - - - - - - - - 00001010 10 ბიტური XOR ამ ოპერაციას უწოდებენ გამომრიცხავ ან-ს (exclusive OR) ან 2-ის მოდულის შეკრებას, აღინიშნება სიმბოლო „^“-ით. ამ ოპერა­ციის შედეგად რომელიმე თანრიგში მიღებული ბიტის მნიშ­ვნელობა ტოლია 1-ის, თუ მხოლოდ ერთ-ერთი ოპერან­დის შესაბამისი ბიტის მნიშვნელობა ტოლია 1-ის. ყველა სხვა შემთხვევაში 0-ის ტოლია. ანუ, თუ ოპერანდების შესა­ბა­მის თანრიგებში მნიშვნელობები განსხვავებულია შედეგის ბი­ტი ტოლია 1-ის, ხოლო თუ ერთნაირი მნიშვნელობები აქვთ, მაშინ შედეგია 0. მაგალითი: 00101010 42 ^ 00001111 15 - - - - - - - - - - - - - - - - - - 00100101 37 შემდეგ პროგრამაში დემონსტრირებულია ბიტური ლოგი­კური ოპერაციები // ბიტური ოპერაციების დემონსტრირებაc1ass BitLogic (public static void main(String args[]) {String binary [] =­ {"0000", "0001", "0010", "0011","0100", "0101", "0110", "0111","1000", "1001", "1010", "1011","1100", "1101", "1110", "1111"};int а =­ 3; // 0011 ორობით წარმოდგენაშიint b = ­ 6; // 0110 ორობით წარმოდგენაშიint с ­= а | b;int d =­ а & b;int е =­ а ^ b;int f =­ (­~a & B) | (а & ~­B);int g =­ ~­a & 0x0f;System.out.println(" а = ­"+ binary[a]);System.out.println(" b­ = " + binary[b]);System.out.println(" a|b ­ " + binary[c]);System.out.println(" a&b­" + binary[d]);System.out.println(" а^b ­ " + binary[e]);System.out.println("~a&b|a&~b =­ " + binary[f]);System.out.println(" ~а ­ " + binary[g]);}}[/CODE] ამ მაგალითში სტრიქონული მასივი binary[] შეიცავს 0 ÷ 15 რიც­ხვების ორობით კითხვად წარმოდგენას. ამ მაგალითში მასი­ვის ინდექსად ბიტური ოპერაციის შედეგის გამოყე­ნე­ბით შესაძლებელია ამ შედეგის ორობითი მნიშვნელობის დანახვა. მასივი ისეა აგებული, რომ n-ის ორობითი მნიშვნე­ლო­ბის სტრიქონული ფორმა ინახება მასივის [color=#008000][b]binary[n][/b][/color] ელემენ­ტად. [b][color=#006400]~a [/color][/b]შედეგის [b][color=#0000ff]binary[/color][/b] მასივით გამოსატანად შე­დე­გი [color=#0000cd][b]0x0F (00001111)[/b][/color] რიცხვთან კონიუნქციით დაიყვანება 16-ზე ნაკლებ რიცხვამდე. ამ პროგრამის შედეგად კონსოლზე გამოვა: [sql] а ­= 0011 b =­ 0110 a|b =­ 0111 а&b ­= 0010 а^b =­ 0101 ~а&b|а&~b =­ 0101 ~а =­ 1100 [/sql] [b]მარცხნივ ძვრა[/b] მარცხნივ ძვრის ოპერაცია << მნიშვნელობის ყველა ბიტს ძრავს მარცხნივ მითითებული პოზიციების რაოდენობით. მისი ზოგადი [b][u]ფორმა ასეთია:[/u][/b] [b][color=#008000]<მნიშვნელობა> << <რიცხვი>[/color][/b] [b][color=#008000]<რიცხვი>[/color][/b] აღნიშნავს იმ პოზიციების რაოდენობას, რამდე­ნი­თაც უნდა მოხდეს [b][color=#008000]<მნიშვნელობის>[/color][/b] ბიტების მარცხნივ ძვრა. მარცხნივ ძვრისას უფროსი თანრიგი იძვრება დასაშვები დიაპაზონის გარეთ და ამიტომ იკარგება, ხოლო მარჯვნიდან ხდება 0-ებით შევსება. ეს ნიშნავს, რომ[color=#0000ff][b] int [/b][/color]ტიპის რიცხვზე მარცხნივ ძვრის ოპერაციის გამოყენებით ყველა ის ბიტი რომე­ლიც 31-ე პოზიციას გაცილდება დაიკარგება. თუ ოპე­რან­დის ტიპი long-ია, მაშინ 63-ე პოზიციის გაცილების შემ­თხვე­ვაში დაიკარგება. გასათვალისწინებელია გამოსახუ­ლე­ბებში ოპერანდების ტიპის ამაღლების ეფექტი. [u][b]მაგალითად:[/b][/u] [php] // byte-ის ტიპის ძვრა მარცხნივ class ByteShift { public static void main(String args[]) byte а = 64, b; int i; i=a << 2; b = (byte) (а << 2); System.out.println ("а-ს საწყისი მნიშვნელობაა: " + а); System.out.println ("i and b: " + i + " " + B); } } [/php] [u]კონსოლზე გამოვა:[/u] а-ს საწყისი მნიშვნელობაა: [color=#4b0082][b]64[/b][/color] i and b: 256 0 ვინაიდან ერთი თანრიგით მარცხნივ ძვრა ფაქტიურად აორ­მა­­გებს საწყის მნიშვნელობას, ამიტომ პროგრამისტები მას ხშირად, ეფექტურობის გამო, 2-ზე გამრავლების მაგივ­რად იყენებენ, მაგრამ ამ დროს სიფრთხილეა საჭირო ვინა­იდან უფროს თანრიგში 1-ის მოხვედრით, რიცხვი უარყო­ფი­თი გახდება. [b]მარჯვნივ ძვრა[/b] მარჯვნივ ძვრის ოპერაცია >> ყველა ბიტს ძრავს მარჯვნივ მითი­თე­ბული პოზიციების რაოდენობით. ზოგადა ის ასე ჩაიწე­რება: [b][color=#008000]<მნიშვნელობა> << <რიცხვი>[/color][/b] [b][color=#008000]<რიცხვი>[/color][/b] მიუთითებს იმ პოზიციების რაოდენობას რამდე­ნი­თაც უნდა დაიძრას <მნიშვნელობის> თანრიგები. შემდეგ ფრაგ­მენტში 2 პოზიციით იძვრება რიცხვი 32, რის შედე­გა­დაც a ცვლადის მნიშვნელობა გახდება 8: int а = 32; а = а >> 2; // ახლა a-ს მნიშვნელობაა 8 განვიხილოთ ამ ოპერაციის შესრლება ორობით წარმოდ­გენაში 00100011 35 >> 2 00001000 8 ყოველი მარჯვნივ ძვრის დროს ხდება 2-ზე გაყოფა ნაშთის დაკარგვით. (წინა ოპერაციის ანალოგიურად მისი გამო­ყენება შესაძლებელია ეფექტური 2-ზე გაყოფის ოპერაციის განსახორციელებლად). მარჯვნივ ძვრის ოპერაციისას უფროსი თანრიგები (მარცხენა პოზი­ციები) ძვრის შედეგად თავისუფლდება და ისინი შეივ­სება უფროსი თანრიგის მნიშვნელობით. ამ ეფექტს უწო­დე­ბენ [b]ნიშნის თანრიგის გავრცელებას[/b] და ამ შემთხვევაში ხდება უარყოფითი რიცხვის ნიშნის შენარჩუნება. მაგალითად, -8 >> 1 ტოლია -4, რაც ორობით წარმოდგენაში ასეა: 11111000 -8 >>1 11111100 ­-4 უცნაურია, მაგრამ -1 -ის მარჯვნივ ძვრა 1-ით ისევ -1 -ის ტო­ლია. ზოგჯერ, მარჯვნივ ძვრისას არაა სასურველი ნიშნის თანრი­გის დამატებითი თანრიგების გაჩენა. მაგალითად: ამ პროგრამის შედეგია: [color=#ff0000][b]b = 0xf1[/b][/color] [b]მარჯვნივ ძვრა ნიშნის თანრიგის გაუთვალისწინებლად[/b] ზოგჯერ არაა სასურველი ნიშნის თანრიგის გავრცელება მარ­ჯვნივ ძვრის ოპერაციის დროს. ეს სიტუაცია ხშირად გვხვდე­ბა გრაფიკული ინფორმაციის ფიქსელებთან მუშა­ობის დროს. როგორც წესი, ამ დროს საჭიროა უფროსი თან­რი­გი შეივსოს 0-ით იმისდა მიუხედავად, რა ეწერა მასში მანამ­დე. ასეთ ოპერაციას უწოდებენ მარჯვნივ ძვრას ნიშნის გაუთ­ვალის­წინებლად. ამ ოპერაციის აღსანიშნავად გამო­იყე­ნება >>> სიმბოლოების მიმდევრობა და ასრულებს მარჯვნივ ძვრის ოპერაციას, ოღონდ უფროსი თანრიგის პოზიციაში ყოველ­თვის სვამს 0-ს. ეს ოპერაცია დემონსტრირებულია პროგ­რამის შემდეგ ფრაგმენტში: [b][color=#0000ff]int [/color][/b]a = -1; a = a >>> 24; ამ მაგალითში a-ს მნიშვნელობის ორობით წარმოდგენაში ყველა 32 თანრიგში წერია 1. შემდეგ ხდება მათი 24 თან­რიგით მარჯვნივ ძვრა ისე რომ, უფროს თანრიგებში ჩაიწე­რება 0. შედეგად a-ს მნიშვნელობა გახდება 255. ოპერაციის შესრულების უკეთ გასაგებად, [u]იგივე ოპერაცია ჩავწეროთ ორობითში:[/u] 11111111 11111111 11111111 11111111 //int ტიპის -1 ორობითში >>>24 00000000 00000000 00000000 11111111 // int ტიპის 255 ორობითში [color=#ff0000][b]ხშირად[/b][/color] >>> ოპერაცია იმდენად სასარგებლო არაა, ვინაიდან მას აზრი აქვს მხოლოდ 32 და 64 ბიტიანი მნიშვნე­ლო­ბებისთვის. უფრო ნაკლები ტიპების შემთხვევაში მათი გამო­სახულებაში გამოყენებისას, როგორც ზემოთ აღვნიშნეთ, ხდე­ბა მათი ამაღლება 32 თანრიგიანამდე და ოპერაცია მაინც სრულდება 32 თანრიგის მიმართ და არა 8 ან 16 თანრიგის მიმართ. [b]ბიტური ავტოასოციური ოპერაციები[/b] არითმეტიკული ოპრაციების მსგავსად, ყველა ბიტურ ოპერაციას აქვს ავტოასოციური ფორმაც, რომელიც აერთი­ანებს ძვრისა და მინიჭების ოპერაციებს. მაგალითად, შემ­დე­გი ორი ოპერატორი, რომლებიც ასრულებენ 4 თანრიგით მარჯვნივ ძვრას ერთმანეთის ეკვივალენტურია: [php] a = a >> 4; a >>=4; ასევე ეკვივალენტურია შემდეგი ორ ოპერატორიც: a = a | b; a |= b; შემდეგ პროგრამაში დემონსტრირებულია ატოასოციური ოპერაციები: с1аss OpBitEqua1s { public static void main(String args[]) { int а =­ 1; int b = ­2; int с ­= 3; а |= 4; b >>= 1; с <<= 1; а ^= с; System.out.print1n("a =­ "+ а); System.out.print1n("b ­= " + B); System.out.print1n("c ­= " + с); } } [/php] [u]ამ პროგრამის შედეგია:[/u] a = 3 b = 1 c = 6 [b]შედარების ოპერაციები[/b] შედარების ოპერაციებით ხდება ოპერანდების მნიშვნელო­ბები ტოლობისა და მათი ერთმანეთის მიმართ მეტობის ან ნაკლებობის განსაზღვრა. ეს ოპერაციები ჩამოთვლილია [b]ოპერაცია[/b] [b]აღწერა[/b] == ტოლი != არაა ტოლი > მეტი < ნაკლები >= მეტი ან ტოლი <= ნაკლები ან ტოლი ამ ოპერაციების შესრულების შედეგი ყოველთვის boolean-ის ტიპისაა. შედარების ოპერაციებს ხშირად იყენებენ პირობით და ციკლის ოპერატორებში. Java-ში შესაძლებელია ნებისმიერი ტიპის მნიშვნელობების შედარება == და != ოპერაციებით. ყურადღება გაამახვილეთ, რომ ტოლობაზე შემოწმება აღინიშნება ორი „==“ ნიშნით (ერთი ნიშანი „=“ მინიჭებას აღნიშნავს). მეტობაზე (ან ნაკ­ლე­ბო­ბაზე) შემოწმება დასაშვებია მხოლოდ რიცხვითი მნიშვ­ნე­ლო­ბის მქონე ტიპებზე. ანუ მეტობის/ნაკლებობის ოპერა­ციის შესრულება შესაძლებელია მთელტიპებზე, ნამ­დვილ ტიპებზე ან სიმბოლირ ტიპებზე. როგორც აღნიშნული იყო, შედარების ოპერაციის შედეგი boolean-ის ტიპისაა, ამიტომ დასაშვებია ასეთი ფრაგმენტი: [color=#0000ff][b]int а =­ 4;[/b][/color] [color=#0000ff][b]int b ­= 1;[/b][/color] boolean с =­ а < b; მიაქციეთ ყურადღება, რომ ასეთი ჩანაწერი [xml] int done; // ...... if(!done) . . . // დასაშვებია c/c++ ში, მაგრამ if(done) . . . // არაა დასაშვები Java-ში Java-ში ეს ოპერატორები ასე იწერება: if(done == 0) . . . // ესაა Java-ს სტილი if(done != 0) . . . [/xml] [b]ბულის ლოგიკური ოპერაციები[/b] ბულის ლოგიკის ოპერაციები სრულდება მხოლოდ [color=#0000ff][b]boolean-[/b][/color]ის ტიპის ოპერანდებზე. ბულის ლოგიკის ოპერაციები ჩამოთ­ვლილია & ლოგიკური AND (და) | ლოგიკური OR (ან) ^ ლოგიკური XOR (გამომრიცხავი ან) || მოკლე OR && მოკლე AND ! ლოგიკური უნარული NOT (არა) &= ავტოასოციური AND (მინიჭებით) |= ავტოასოციური OR (მინიჭებით) ^– ავტოასოციური XOR (მინიჭებით) == ტოლი != არაა ტოლი > ტერნერული ოპერაცია if-then-else ბულის ლოგიკის ოპერაციები &, | და ^ ბულის ტიპის მნიშ­ვნე­ლობებზე მოქმედებენ ისეთნაირედ, როგორც მთელ­რიც­ხვა მნიშვნელობების ბიტებზე. ბულის ოპერაცია ! ინვერტი­რებას უკეთებს ბულის მდგომარეობას: !true == false და !false == true. თითოეული ლოგიკური ოპერაციის შედეგი ნაჩვე­ნე­ბია [center][color=#008000][b]A B A|B A&B A^B ~A[/b][/color][/center] [center][color=#ff0000]============================================[/color][/center] [center]false false false false false true[/center] [center]true false true false true false[/center] [center]false true true false true true[/center] [center]true true true true false false[/center] ქვემოთ ნაჩვენებია პროგრამის ფრაგმენტი, რომელიც პრაქ­ტი­კულად იგივე მოქმედებებს აკეთებს, რასაც ზემოთ მოტა­ნილი პროგრამა BitLogic, ოღონდ იმ განსხვავებით, რომ აქ მოქ­მ­ედებები ხდება boolean-ის ტიპის მნიშვნელობებზე და არა ბიტურ მნიშვნელობებზე. [xml] // ბულის ლოგიკური ოპერაციების დემონსტრირება class BoolLogic { public static void main (String args [] ) { boolean а =­ true; boolean b ­= false; boolean с =­ а | b; boolean d ­= а & b; boolean е =­ а ^ b; boolean f =­ (!а&B) | (а& !B); bооlеаn g =­ !а; Sуstеm.оut.рrintln(“ а =­ " + а); Sуstеm.оut.рrintln(" b =­ " + B); Sуstеm.оut.рrintln(" a | b ­ " + с); System.out.println(" а & b ­" + d); System.out.println(" а ^ b ­"+ е); Sуstеm.оut.рrintln("!а&b | а&!b =­ " + f); System.out.println(" !а =" + g); } }[/xml] ამ პროგრამის მუშაობის შედეგი იქნება: а ­= true b =­ false a|b =­ true а&b =­ false а^b =­ true а&b|а&!b = true !а =­ false [b]მოკლე ლოგიკური ოპერაციები[/b] Java-ში განხორციელებულია ორი საინტერესო ბულის ოპე­რაცია, რომლის მსგავსი სხვა ენებში არ გვხვდება. ესაა AND და OR ოპერაციების მეორე ვერსიები, რომლებსაც მოკლე ლოგიკურ ოპერაციებს უწოდებენ. როგორც ზემოთ ნაჩვე­ნები ცხრილიდან ჩანს OR ოპერაციის შესრულების შედეგი არის true, როდესაც A-ს მნიშვნელობა არის true, იმისდა მიუხე­დავად, რა მნიშვნელობა აქვს B ცვლადს. ანალო­გი­ურად, AND ოპერაციის შესრულებისას შედეგია false, თუ A ოპე­რანდის მნიშვნელობაა false, B-ს მნიშვნელობის მიუხე­და­ვად. || და && ოპერაციების გამოყენებისას | და & ოპერა­ცი­ების მაგივრად, არ მოხდება მარჯვენა ოპერანდის გამოთ­ვლა, თუ გამოსახულების მნიშვნელობის დადგენა შესაძლე­ბე­ლია მარტო მარცხენა ოპერანდის საშუალებით. ეს თვისება განსაკუთ­რებით მოსახერხებელია, როდესაც მარჯვენა ოპე­რან­დის მნიშვნელობა დამოკიდებულია მარცხენა ოპერან­დის მნიშვნელობაზე. [u]მაგალითად,[/u] if(denom != 0 && num / denom > 10) მოკლე ფორმის (&&) გამოყენების წყალობით გამოირიცხება განსაკუთრებული სიტუაციის წარმოქმნის რისკი, როდესაც denom იქნება 0-ის ტოლი. AND და OR ოპერაციების მოკლე ფორმა უფრო ხშირად გამო­იყენება ბულის ლოგიკის დროს, ხოლო ერთსიმ­ბო­ლო­იანი ვერსიები ბიტური ოპერაციების დროს, თუმცა არსე­ბობს გამონაკლისებიც. მაგალითად: [color=#006400][b]if(c == 1 & e++ < 100) d = 100;[/b][/color] ამ შემთხვევაში & ერთმაგი სიმბოლო უზრუნველყოფს, რომ e ცვლადის მიმართ ინკრემენტის ოპერაცია აუცილებლად შესრულდება იმისდა მიუხედავად ტოლია თუ არა ის 1-ის. [b]მინიჭების ოპერაცია[/b] ამ ოპერაციას მაგალითებში ჩვენ ხშირად ვიყენებდით, ახლა განვიხილოთ ის ფორმალურად. მონოჭების ოპერაციის აღსა­ნიშ­ნავად გამოიყენება სიმბოლო =. ამ ოპერაციას ასეთი ზო­გა­დი ფორმა აქვს: [color=#0000cd][b]<ცვლადი> = <გამოსახულება>;[/b][/color] ამ ოპერატორში <ცვლადი>-ის ტიპი უნდა შეესაბამებოდეს <გამოსახულების> ტიპს. მინიჭების ოპერაციით შესაძლებელია მინიჭების ოპერაცი­ების ჯაჭვი განვახორციელოთ. [u]მაგალითად:[/u] int x, y, z; x = y = z = 100; // x,y,z ცვლადების მნიშვნელობები გახდება 100 ეს ხდება იმიტომ, რომ = ოპერციის შედეგია მარჯვენა გამო­სა­ხულების მნიშვნელობა, ანუ z = 100 -ის მნიშვნელობაა 100, რომელიც შემდეგ მიენიჭება y-ს, ხოლო შემდეგ ანალოგიური მსჯელობით x-ს. ეს ფორმა საკმაოდ მოსახერხებელია რამო­დე­ნიმე ცვლადისათვის ერთიდაიგივე მნიშვნელობის მისა­ნიჭებლად. [b]ტერნარული ოპერაცია[/b] Java-ში რეალიზებულია სპეციალური სამოპერანდიანი ოპე­რა­ცია, რომელმაც გარკვეულწილად შეიძლება ჩაანაცვლოს ზოგჯერ If-then-else ოპერატორი. ესაა ოპერაცია „?:“. ამ ოპე­რა­ციის ზოგადი ფორმა ასე შეიძლება წარმოვადგინოთ: <გამოსახულება1> ? <გამოსახულება2> : <გამოსახულება3> აქ <გამოსახულება1> ნებისმიერი boolean-ის ტიპის შედეგის მომ­ცემი გამოსახულებაა. თუ <გამოსახულება1>-ის მნიშვნე­ლობა ტოლია true, მაშინ მოხდება <გამოსახულება2>-ის გამოთვ­ლა, წინააღმდეგ შემთხვევაში გამოითვლება <გამოსა­ხუ­ლება3>. „?:“ ოპერაციის შედეგი სწორედ გამოთვლილი გამო­სახულების მნიშვნელობაა. <გამოსახულება2> და <გამო­სახულება3> უნდა აბრუნებდნენ ერთიდაიგივე ტიპის მნიშ­ვნელობებს და არ შეიძლება მისი ტიპი void იყოს. მაგალითი: ratio = denom == 0 ? 0 : num /demon; ამ მინიჭების ოპერატორის შესრულებისას, თავიდან მოწ­მდება კითხვის ნიშნამდე („?“) ჩაწერილი გამოსახულება. თუ denom-ის მნიშ­ვნელობა 0-ის ტოლია (ანუ გამოსახულების მნიშვნელობაა true), მაშინ გამოითვლება „?“ ნიშანსა და “:“ ნიშანს შორის ჩაწერილი გამოსახულება და ამ გამოსა­ხუ­ლების მნიშვნელობა იქნება მთლიანი „?:“ ოპერაციის მნიშვნელობა. თუ denom-ის მნიშვნელობა არაა 0-ის ტოლი (ანუ გამოსახულების მნიშვნელობაა false), მაშინ გამოითვლება „:“ სიმბოლოს შემდეგ ჩაწერილი გამოსახულება და მისი მნიშვნელობა აიღება მთლიანი „?:“ ოპერაციის მნიშვნელობად. შემდეგ, „?:“ ოპერაციის მნიშ­ვნე­ლობა მიენიჭება ratio-ს. შემდეგ პროგრამაში ხდება ამ ოპერაციის დემონსტრირება: [xml] // ? : ოპერაციის დემონსტრირება class Ternary { public static void main(String args[]) { int i, k; i =­ 10; k =­ i < 0 ?- ­i : i; // i ცვლადის აბსოლუტური მნიშვნელობა Sуstеm.оut.рrint("აბსოლუტური მნიშვნელობა "); System.out.println(i +"-ის ტოლია " + k); i ­= -­10; k ­= i < 0 ? -­i : i; // i ცვლადის აბსოლუტური მნიშვნელობა System.out.print ("აბსოლუტური მნიშვნელობა "); System.out.println (i + "-ის ტოლია " + k); } }[/xml] ამ პროგრამის შედეგად კონსოლზე გამოვა: აბსოლუტური მნიშვნელობა 10-ის ტოლია 10 აბსოლუტური მნიშვნელობა -10-ის ტოლია 10 [b]ოპერაციების პრიორიტეტი[/b] ცხრილში??? ნაჩვენებია ოპერაციების პრიორიტეტები მაღა­ლი­დან დაბლისაკენ. პირველ სტრიქონში მითითებულია გამყოფები, რომლებიც მართალია არაა ოპერაციები, მაგრამ გამოსახულებებში ხშირად მონაწილეობენ და ოპერაციის მსგავსად მოქმედებენ. მრგვალი ფრჩხილები გამოიყენება ოპერაციების პრიორიტეტის შესაცვლელად, ხოლო კვადრა­ტული ფრჩხილები მასივების ინდექსირებისათვის. მრგვალი ფრჩხილების გამოყენება უმატებს ოპერაციების პრი­ორიტეტს. ხშირად მათი გამოყენება საჭიროა საჭირო შედე­გის მისაღებად.[u] მაგალითად:[/u] a >> b + 3 ამ გამოსახულებაში ჯერ 3 დაემატება b-ს, შემდეგ მიღებული მნიშვნელობის შესაბამისი თანრიგების რაოდენობით a-ს მნიშ­ვნელობა დაიძვრება მარჯვნივ. ჭარბი ფრჩხილების გამოყენებით იგივე გამოსახულება ასე[u] ჩაიწერება:[/u] a >> (b + 3) თუ თავიდან საჭიროა a ცვლადის მნიშვნელობის დაძვრა b რაოდე­ნობის პოზიციით და შემდეგ შედეგზე 3-ის დამატება, მაშინ საჭიროა ფრჩხილების ასეთნაირი[u] გამოყენება:[/u] (a >> B) + 3 [center][b]ოპერაციათა პრიორიტეტები Java-ში [/b][/center] [center]მაღალი პრიორიტეტი[/center] [center][/center] [center][b]დაბალი პრიორიტეტი[/b][/center] ზოგჯერ ფრჩხილები გამოიყენება რთულად გასაგები გამო­სა­ხულების აღქმის გასაადვილებლად. მაგალითად: а | 4 + с >> b & 7 (а | (((4 + с) >> B) & 7)) ჭარბი ან არაჭარბი მრგვალი ფრჩხილების გამოყენება არ იწვევს პროგრამის შესრულების ეფექტურობის შემცირებას. ამიტომ, კითხვადობის ამაღლების მიზნით ფრჩხილების დამა­ტება, პროგრამის შესრულებაზე უარყოფითად არ მოქ­მედებს.
×