მასივები

მასივები არის ტიპების ერთობა,  რომელსაც გააჩნია განსაზღვრული სიდიდე, რომლის შეცვლაც შეუძლებელია. მასივი შეიძლება იყოს ყველა ტიპი როგორც პრიმიტიული ისე რეფერენტული, (byte,short, String, boolean და ა.შ) მისი ძირითადი მოვალეობა არის მოახდინოს შენახვა მეხსიერებაში ერთი და იგივე ტიპის, რომელსაც გააჩნია უამრავი ღირებულება, მაგალითისთვის, წარმოიდგინეთ შეფასების სისტემა, სადაც ყველა შემფასებელს განსხვავებული აზრი აქვს მაგრამ ერთი შეფასების სტილი, (ციფრებით აფასებს) ამ შემთხვევაში ყურადღებას იპყრობს არა პროცესი არამედ ის თუ რით ხდება შეფასება. ციფრი ჩვენთვის არის int type, ამიტომ თუ შემფასებელი არის 10 კაცი, 10 ინტს ხომ არ დავწერთ? ცოტა მოუქნელი და მოსაწყენი იქნება ხო? ამიტომაც გვაქვს მასივი სადაც ვწერთ  int[] shemfasebeli= new int[10]-ს. როგორც მაღლა ავღნიშნეთ თუ მოვახდენთ სიდიდის დეფინირებას მას მერე ვეღარ შევცვლით, გვაქ მასივი 10 ინტეჯერით, 1 ცვლადით და 1 ტიპით.  10 თავისუფალ ადგილზე შეგვიძლია შეივყვანოთ 10 სხვა და სხვა ციფრი რომელსაც ცვლადი shemfasebeli შეინახავს. შეყვანა ხდება შემდეგ ნაირად. Shemfasebeli[0] = 7; Shemfasebeli[1] = 27;  Shemfasebeli[8] = Shemfasebeli[0]  + Shemfasebeli[1]; და ასე შემდეგ.

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

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

რა არის ინდექსი: ინდექსი არის პოზიცია სადაც ინახება ელემენტი. ათვლა ინდექსურ სისტემაში იწყება ნულიდან, შესაბამისად თუ გვინდა მასივის მესამე ელემენტის ნახვა უნდა გამოვიძახოთ ინდექის მეშვეობით რომელიც გამოიყურება შემდეგნაირად. Shemfasebeli[2]; ალბათ მიხვდით 2 რატომაც. (0,1,2). თუ მოვახდინეთ გამოძახება ინდექის რომელიც არ არსებობს ჯავა გვიჩვენეს ერორ მესიჯს, სათაურით IndexOutOfBoundException.

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

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

მასივის სტანდარტული ღირებულება არის Null:

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

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

• Int [] anArray - ერთ განზომილებიანი:
• Int [] [] anArray - ორ განზომილებიანი:
• Int [] [] [] anArray - მრავალ განზომილებიანი:

რომელიმე გვერდზე შეიძლება წააწყდეთ დეფინირების მსგავს სტილს int anArray [] სადც ლიტერალები მოთავსებულია ბოლოში, ეს სრულიად მართებული დეფინირება არის და ჯავამ ის მართებულად ცნო იმისთვის რომ მოეზიდა მომხმარებლები სხვა და სხვა ენებისგან, როგორიც არის c++, c# და ა.შ მაგრამ ჯავას ლიტერალი არის Int [] anArray  სადაც ლიტერალი შუაშია მოქცეული ტიპსა დ ცვლადს შორის.

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

არსებობს დეფინირების სხვა სტილიც. მაგალითად გვინდა შევქმნათ მასივი 5 ელემენტით, String [] names = new String [5]; სადაც ყველა სახელის შეყვანა მოგვიწევს პოზიციებზე. შორთქათით დეფინირება ხდება შემდეგნაირად, String [] names = {“გიორგი”, „ლაშა“, „დათო“, „ანა“, „მარია“}; ასე დეფინირება უფრო მოსახერხებელია, კოდი უფრო წაკითხვადია და დეფინირება ხდება პროცესში.  როგორც ნახეთ {} გამოიყენება როგორც ლიტერალი, გახსოვთ ალბათ რო ის ასევე ახდენს ბლოკირებას, (აზრების გრუპირებას) მაგრამ მასივის შემთხვევაში ის უბრალოდ ლიტერალია და იწერება ერთ ველზე.

ელემენტებთან წვდომა:

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

თუ გვუსრს დაწერა არსებულ ინდექსზე. მაშინ გამოვიძახებთ ინდექს და პირდაპირ შეუცვლით ღირებულებას, თუ anArray[0] = 7;  იგივე ინდექს anArray[0]= 12;  გახდება 12;

შესაძლებელია მთლიანი მასივის წაკითხვაც, length:დანართის დახმარებით.

რომელიც ეკრანზე გამოგვიტანს ყველა ელემენტს, რომელიც მასივში იმყოფება.

როგორც შეამჩნევდით length არის ფრჩხილების () გარეშე, იგივე

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

უშვებს ამ შეცდომას, (length: - Array.  length() -String).

მასივის წაკითხვა ასევე შესაძლებელია, Arrays.toString() მეთოდის დახმარებით, პირდაპირ კომპილირების დროს. მისი გამოყენება თუ გსურთ უნდა მოახდინოთ იმპორტირება Arrays. (import java.util.Arrays;)

მასივს გააჩნია უამრავი გამოსადეგი მეთოდი, რომელიც ხელს გვიწყობს სხვა და სხვა ოპერაციების წარმოებაში. ესენია: sort(), remove(), addAll(), copyFrom(), copyTo() და ა.შ მათ ათვისებას და გამოყენებას კოდის წერის დროს შეძლებთ. ამ ბლოგში მეთოდებს არ განვიხილავთ.


2 განზომილებიანი მასივი:

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

3 არის დიაგონალი და 4 არის ვერტიკალი, ელემენტის შეყვანა პოზოციაზე ორი ინდექსის მეშვეობით ხდება. მაგალითი : matrix[1][2] = 25; ელემენტებს შორის შესაძლებელია ნებისმიერი ოპერაციის წარმოება. გამრავლება, გაყოფა, მიმატება, გამოკლება და ა.შ ორ განზომილებიანი მასივის დეფინირება შესაძლებელია {} ფრჩხილებით, მსგავსად ერთ განზომილებიანისა.  შემდეგ ფოტოზე ნახავთ 

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

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

მაგალითები: ერთ განზომილებიანი მასივი.

კომპილირების შემდგომ:

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

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

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

ვიძახებთ არ არსებულ ელემენტს, მაგრამ Exception-ის დახმარებით პროგრამა პრობელამს უმკლავდება, ის არ წყვეტს მუშაობას და გვეუბნება სად არის შეცდომა. public static void main-ის გასვრივ ხედავთ  throws საკვანძო სიტყვას რის მეშვეობითაც მანქანას ვეუბნებით რო პროგრამას შესაძლებელია შეცდომები ექნეს და აუცილებელია მას გაუმკლავდეთ. გამკლავების უამრავი გზა და ხერხი არსებობს, ფოტოზე ერთ-ერთია ნაჩვენები. Exception არის უზარმაზარი პაკეტი, უამრავი სასარგებლო ხელსაწყოთი, რომელიც თითქმის ყველაფერს უმკლავდება,  სკრინზე ნახეთ კომპილირების შემდგომ როგორ აგრძელებს პროგრამა მუშაობას. 

პატარა მაგალითებზე საკმაოდ მარტივად გამოიყურება მასივი, მაგრამ წარმოიდგინე გაქვთ მასივი N რაოდენობის ელემენტით, როგორ გინდათ მონახოთ მსგავს მასივში სასურველი ელემენტი, ვთქვათ მუშაობთ დიდ კომპანიაში სადაც მოსანახი გაქვთ ინფორმაცია მასივში, ქექვას ხომ არ დავიწყებთ და სათითაოდ ხომ არ გამოვიტანთ ეკრანზე მილიონობით ინფორმაციას? (ამის აუცილებლობა არ არის, მსგავსი რამ სამსახურიდან დათხოვნით სრულდება ხოლმე), რომც გამოვიტანოთ ბევრი კომპიუტერი მსგავს ოპერაციას ვერც გაუძლებს, თუ გაუძლო შედეგი რამოდენიმე საათში დადგება მინიმუმ, ან რამოდენიმე დღეში. ამიტომ მინიმუმ საჭიროა იცოდეთ დასახელება ან ღირებულება ელემენტის. არის სიტუაცია როდესაც იცით დასახელება და მოთხოვნა არის გაიგოთ ადგილმდებარეობა დასახელებული ობიეკტის, არის შემთხვევა როდესაც დასახელებაც იცით და ინდექსიც მაგრამ თქვენი ამოცანა არის ელემენტი 1678 პოზიციიდა გადასვათ 569 პოზიციაზე, როგორ უნდა გადასვათ როდესაც ადგილი უკვე დაკავებულია? როგორ უნდა მოვახდინოთ მთლიანი მასივის რევერსირება? ან თუნდაც რამოდენიმე ელემენტის რევერსირება, ამ და უამრავ მსგავს კითხევბზე პასუხი მუდმივად მზად უნდა გქონდეთ, მზა პასუხის ქონაში ოპერატორების და Conditional Statements and loops კარგად ცოდნა დაგეხმარებათ. 

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

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

ამით ერთ განზომილებიან მასივზე საუბარი მორჩა. ვნახოთ 2 განზომილებიანის მაგალითიც. 

მოვახდინეთ ორი ინდენტური 2 განზომილებიანი მასივის შექმნა, რომლებიც შევადარეთ. Arrays.deepEquals() მეთოდის მეშვეობით. ის ძირითადად გამოიყენება ორ განზომილებიანი და ობიეკტური მასივების შედარებისთვის.  ერთ განზომილებიანი მასივის შედარება ხდება Arrays.equals() მეთოდის მეშვეობით. კომპილირების შემდგომ:

ამით მასივებზე საუბარს მოვრჩით:

პირობითი განცხადებები

                             პირობითი განცხადებები და მარყუჟები

    ჯავას ამ ნაწილში ვისაუბრებთ if, if-else, while, do-while, switch-case და for საკვანძო ბგერებზე, if, if-else, switch-case არის  conditional statement.  For და while, do-while  არის loop, მათი მოვალეობაა დაგვეხმაროს  კოდის ეფეკტურ მართვაში, მათი გამოყენებით პროგრამს ვეუბნებით თუ რომელი ნაწილი კოდის არის გამოყენებადი.

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

Speed –

ლოგიკურად ჟღერს ხო?

     რა მოხდება თუ ეს ნაწილი კოდი არ შეესაბამება სიმართლეს და ავტომობილი არ მოძრაობს, მაშინ ვიყენებთ else საკვანძო ბგერას, სადაც პირველი ნაწილის მცდარად დასრულების შემთხვევაში გვაქ გაგრძელება სადაც პროგრამა გვეტყვის რომ ავტომობილი გაჩერებულია. if, if-else ტრანსპორმაციას განიცდის boolean-დე, რადგან მის მიერ მოწოდებული ლოგიკა მართალია ან მცდარია, true or false. ყველა if, if-else შემდგომ აუცილებელია გამოვიყენოთ {}, რომელიც საშუალებას მოგვცემს თავიდან ავირიდოთ ორაზროვნება, გამოიყენეთ else ყველა if-ის შემდგომ სადაც შესაძლებელია, ოპერაცია რომლის შესრულებაც გსურთ შექმენით პირველი, მოახდინეთ კოდის ფორმატირება დაუყოვნებლივ რათა გადაამოწმოთ მუშაობს თუ არა თქვენი ლოგიკური კოდი გამართულად, უკეთესია გამოიყენოთ swith-case როდესაც ამის საშუალებას ხედავთ, ყველაფერი მაღლა ნათქვამი არის კარგი პრაკტიკა პროგრამირებისთვის.

   Switch-case. განსხვავებით if, if-else-ან მას შეუძლია ექნეს ზუსტად განსაზღვრული რაოდენობა შესასრულებელი ოპერაციების. (1.4, თუ 400) Switch Statement მუშაობს, byte, int, short, char პრიმიტიულ ტიპებთან. Java s7 გამოსვლის შემდეგ ის მუშაობს აგრეთვე enum და string ტიპებთან. მისი დანიშნულება არის მაოხდინოს ტესტირება ცვლადის რომელსაც იკავებს Switch ველი, ტესტირებას კი ახდენს case ველის მეშვეობით. ცვლადი case ველზე უნდა შეესაბამებოდეს ცვლადს Switch ველში,  სხვა და სხვა ტიპების ტესტირებას ვეღარ მოახდენთ. შესაძლებელია შესამოწმებელი ტიპი იყოს კონსტანტური ან ლიტერალი.  როდესაც შესამოწმებელი ცვლადი გადამოწმებულ იქნება ქეის ველის მიერ და თუ შეესაბამება სიმართლეს, მაშინ მოხდება კომპილირება, რის შედეგადაც ეკრანზე გამოვა ის შედეგი რა შედეგის გადაცემაც მოვახდინეთ print მეთოდისთვის. ყველა ქეის ველის შემდგომ უნდა გამოვიყენოთ break ველი, რითაც ოპერაციას ვამცნობებთ რო სასურველ შედეგამდე მივედით და უნდა შეწყვიტოს ძიება, თუ არ ვამცნობებთ რო უნდა გაჩერდეს მაშინ ის გაუთავებლად გააგრძელებს ძიებას მანამ სანამ არ მონახავს break საკვანძო სიტყვას, მრავალ გვერდზე წაიკითხავთ რო არ არის აუცილებელი ყველა ქეის ველის შემდგომ იქონიოთ break ველი, ეგ ეგრე არ არის, სიცრუეა და ძალიან ცუდი პრაკტიკა პროგრამირების დროს, დაბალი ხარისხის კოდი,  მსგავსად break ველისა ქეის ველის შემდგომ შესაძლებელია ვიქონიოთ continue ველი, მისი მეშვეობით პროგრამას ვეუბნებით, რომ სასურველი შედეგის დადგომის შემდგომ გააგრძელოს მუშაობა.  არის შემთხვევები როცა მსგავს სიტუაციაში ძიების გაგრძელება საკმაოდ მოსახერხებელია, დაუშვათ გვაქ „რამე“ რომელსაც იყენებს „ვინმე“, ჩვენი დანიშნულება არის მოვძებნოთ „რამე“, მაგრამ მოძებნის შემდგომ(სასურველი შედეგის დადგომის შემდგომ) ვაგრძელებთ ძიებას continue, სადაც უკვე ვინმეს ვეძებთ, მაგალითისთვის შალვას, რომელიც იყენებს ცეცხლსასროლ იარაღს უკანონოდ. მიხვდით ხომ ლოგიკას? მოვძებნეთ ცეცხლსასროლი იარაღი და ვაგრძელებთ ძიებას პიროვნებამდე.

Switch Statement-ს აქვს ერთი დამატებითი ფუნქცია, default, რომლის შედმგომაც არ არის აუცილებელი ვიქონიოთ break ველი, რას აკეთებს   default ველი?! მისი მეშვეობით ვახდენთ სტანდართული პასუხის მიღებას სასურველი შედეგის არ დადგომის შემთხვევაში, ძიების შედეგად N ველზე თუ ვერ მოხერხდა შედეგის მიღება მაშინ default ველი ახდენს კომპილირებას მიუხედავად ყველაფისა. ლოგიკას უკეთ რომ ჩავწვდეთ: წარმოიდგინეთ დგახართ ყავის მანქანასთან, რომლის ოპერაციაც იწყება switch(getCoin) მეთოდიდან, შემდეგ გვაქ ქეისები სტანდარტულად, ქეის1 ლატე, ქეის2 კაპუჩინო, ქეის3 ფრაპე და ა.შ თუ მოხდა ისე რო სასურველი ქეისის ყავა არ იქნა მადუღარაში მაშინ პროგრამა ავტომატურად წყვეტს ყველა ველის წაკითხვას და გადადის default ველზე, რომელიც გვეტყვის რო მადუღარაში ჩვენს მიერ მოთხოვნილი ყავა დასრულდა, დაგვიბრუნებს მონეტებს და შემოგვთავაზებს სხვა ყავის არჩევას. 

.

Switch Statement აქვს საზღვრები, ლიმიტები, მაგრამ საკმაოდ მოქნილი და ელეგანტური ოპერაცია არის ჩემი აზრით.  ოპერატორებზე საუბრის დროს ვისწავლეთ თუ როგორ უნდა შევქმნათ ესა თუ ის ოპერაცია, რა ტიპის და ღირებულების მატარებლები არიან ოპერატორები, conditional stetement-ის საშუალებით კი ვსწავლობთ თუ როგორ უნდა გამოვიყენოთ ჩვენს მიერ შექმნილი ოპერაცია, დამატებითი ფუნქცია მას არ გაჩნია, არც ღირებულება აქვს და არც ტიპი.  კარგი პრაკტიკა არის თუ ლოგიკური ოპერაციების გადასამოწმებლად არ გამოიყენებთ Switch Statement, მსგავსი ოპერაციების გადამოწმება როგორც წესი if-else statement-ის მოვალეობა არის. ოპერაცია რომლის შესრულებაც მოუწევს ქეის ველს ყველაზე ხშირად, დააყენეთ დანარჩენ ოპერაციებზე მაღლა, (ანუ შექმენით პირველი) შესაბამისად ყველაზე ნაკლებად გამოყენებადი ველი დააყენეთ ბოლო ადგილზე. თუ არ მუშაობთ ციფრებთან უმჯობესი იქნება თუ ქეისებს არ დანომრავთ, უბრალოდ ალფავეტური თანმიმდევრობა გამოიყენეთ (ა,ბ,გ,დ). როცა ახდენთ ციფრებთან მუშაობას კარგი იქნება თუ ქეისებს დააყენებთ მზარდობითი პრინციპით, ყველაზე დაბალი ციფრიდან დაიწყებთ მუშაობს და ბოლოში ყველაზე მაღალ ციფრს გამოიყენებთ.

განვიხილოთ მაგალითებზე if-else და switch-case :

If-else

კომპილირების შემდგომ:

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

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

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

თუ კოდის გამოყენებას გადაწყვიტავთ 12-ე დასრულეთ და ბოლოში default ველი გამოიყენეთ:

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

                                                       Loops

ოპერაცია რომელიც კომპილირებას ახდენს ზუსტად იმდენჯერ რამდენჯერაც გსურთ ან გაუთავებლად, ის აგრძელებს მუშაობას მანამ სანამ ლოგიკური ოპერაციის შესრულება ძალაშია.  ის ახდენს შედეგის გამოტანას თანმიმდევრულად ეკრანზე (პირველი ოპერაცია, მეორე, მესამე და ა.შ) პროგრამირების ენა გვთავაზობს 2 ვარიანტს მსგავსი ოპერაციის წარმოებისთვის, ესენია, For loops და Do-While loop.  მათი დახმარებით ჩვენი ლოგიკური ნაწილი კოდის ან რამოდენიმე ლოგიკური ერთობა კოდის (conditional stetement) ახდენს კომპილირებას მრავალჯერ. ეს არის ძირითადი ფუნქცია პროგრამირებაში რომელიც ერთნაირად გამოყენებადია ყველა ენაში, ჯავა, პითონი, სიშარპი თუ ნებისმეირი სხვა.

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

მისი მოქმედება სამი ოპერაციისგან შედგება, for (initialization; condition; update). სადაც initialization; არის საწყისი წერტილი ათვლისა, ის წაკითხულ იქნება კომპილატორის მიერ ერთხელ რის შემდგომაც დაიწყებს ოპერაციის წარმოებას, condition; არის დასასრული ათვლისა, (შეიძლება დასასრულის საერთოდ არ ექნეს) , მუშაობას წყვეტს მაშინ როცა condition შიგთავსი ევოლუციას განიცდის ცრუ შედეგამდე. Update კი არის მიმთითებლი თუ რომელი მიმართულებით უნდა იმოძრაოს ძიებამ, მას ხშირად increment/decrement ფუნქციას ეძახიან, სადაც increment ზრდის ციფრს (ანუ ძიებას აგრძელებს შემდეგ ციფრზე) და decrement ამცირებს ციფრს.

არსებობს მეორე სახის for loop, რომელსაც enhanced for loop-ს ეძახიან, ის ჯავას დაემატა ჯავა5-ან, საკმაოდ მოქნილი და მარტივია, მისი წინამორბედისგან განსხვავებით იჭერს 2 არგუმენტს, სადაც მარცხენა არგუმენტი ახდენს მარჯვენა არგუმენტის შიგთავსის მითვისებას. For(declaration:expression), წარმოიდგინეთ expression არის ციფრების ერთობა, რომელიც ინახვს მაგალითისთვის 10 ციფრს, ამ 10 ციფრის ეკრანზე გამოტანა თუ გვინდა declaration : საშუალებით მის ღირებულებას მივითვისებთ, რის შემდგომაც მოავხდენთ კომპილირებას ცვლადის რომელიც declaration ადგილზე მოვათავსეთ. მასზე დეტალურად მასივებთან ვილაპარაკებთ.

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

Do-while მსგავსია While loop-ის, ერთი განსხვავებით, ის ამოწმებს მიწოდებულ ოპერაციას კოდის ბოლოში, ახდენს კომპილირებას პროგრამის ერთხელ მაინც, (მიზეზი ნათელია, მიწოდებული ინფორმაცია მოწმდება ბოლოში)

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

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

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

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

განვიხილოთ რამოდენიმე მაგალითი.

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

მაგრამ რა მოხდება თუ მოცემულ ციფრში ყველა ლუწი ციფრის ნახვა გვსურს? ვცადოთ:

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

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

კომპილირების შემდგომ გვიჩვენებს თუ რამდენჯერ გვხვდება სიტყვაში სასურველი ბგერა. ჩვენ შემთხვევაში 6-ჯერ. შემდეგ მაგალითზე განვიხილავთ რას ნიშნავს ჩაბუდებული for loop (nested for loop). როგორც ესეთი ჩაბუდებაზე ჯერ არც გვისაუბრია მაგრამ პროგრამირებაში ყველაფრის ჩაბუდება შეიძლება, (nested loop, nested conditional stetement, nested class და ა.შ) მას თავისი წესები აქვს ოპერაციის შესრულების, რომელსაც მოგვიანებით განვიხილავთ. ამ ეტაპზე ჩაბუდებული for loop-ის პრინციპია მაოხდინოს გარეთა პირველმა for loop=მა კონტროლი შიდა, მეორე for loop-ის. წარმოიდგინეთ ქმნით საათს, დღეში არის 24 საათი და საათში არის 60 წუთი, ეფეკტურად რომ შევძლოთ საათის მართვა ვქმნით გარეთა for loop-ს სადაც ათვლას ვიწყებთ ერთიდან და ვასრულებთ 24-ზე, ანუ შევქმენით 24 საათიანი ციკლი, ვაგრძელებთ მეორე, შიდა for loop-ის შექმნას სადაც ათვლას დავიწყებთ ნულიდან და დავასრულებთ 60-ზე. ყველა ჯერზე როდესაც გარეთა, პირველი for loop მოახდენს კომპილირებას ერთხელ, იმდენჯერ მოახდენს კომპილირებას მთლიანად შიდა, მეორე for loop, ანუ მოხდა 1 საათის დამუშავება + 60 წუთი დამუშავდა, მოხდა 2 საათის დამუშავება + 60 წუთი დამუშავდა და ა.შ. გარეთა პირველი for loop მთლიანად აკონტროლებს შიდა, ჩაბუდებულ for loop-ს. ჩაბუდება შეიძლება იმდენჯერ მოახდინოთ რამდენჯერაც გსურთ, გააჩნია რა მისია გაქვთ შესასრულებელი. 

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

სამა საათმა მაოხდინა კონტროლი ყველა წუთის, 1 საათი და 60 წუთი, 2 საატი და 60 წუთი, სამი საატი და 60 წუთი. ანუ პირველი თვლა მუშაობს step by step როდესაც მეორე ახდენს მთლიანად კომპილირებას. თუ გინდათ პირამიდაც გავაკეთოთ, ან რომბი, ამ ნებისმიერი სხვა ფიგურა, გასაუბრებებზე და გამოცდებზე განსაკუთრებით უყვართ მსგავსი დავალებების მოცემა. შევქმნათ პატერნი, იმ ზომის რა ზომისაც მომხმარებელს სურს მისი შექმნა.

კომპილირების შემდგომ:

While loop

სკრინზე მოცემული პროგრამა მუშაობს მანამ სანამ კონდიცია არ მივა ცრუ შედეგამდე. შესაბამისად დაგვითვლის 9 ციფრს. 1-9-დე.

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

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

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

ასე გამოიყურება ჩვენი კოდი სტრინგის გამოყენებით და ასე გამოიყურება კომპილირების შემდგომ:

1: რატომ არის შეყვანილი პაროლი არასწორი?

2; ამოდენა ველიდან რატომ მუშაობს მხოლოდ ბოლო ველი? (წესით ეგეც არ უნდა მუშაობდეს)

3; როგორ შეიძლება სიტუაციის გამოსწორება?

კითხვებზე პასუხი ძალიან მარტივია.

1: შეყვანილი პაროლი იმიტომ არის არასწორი რომ სტრინგი არის რეფერენციული ტიპის დატა, რეფერენციული ტიპის დატა ინფორმაციას არ ინახავს ის უბრალოდ მიგვითითებს თუ სად არის მეხსიერებაში ინფორმაცია შენახული. შესაბამისად როდესაც ვწერთ რომ პაროლი არის რემბო ერთ ველზე ის ინახება მეხსირებაში როგორც ჰეხსადეციმალური ციფრი, გახსოვთ ალბათ რომ RAM მეხსიერება მუშაობს ჰეხსადეციმალურ ციფრების სისტემასთან. ანუ ჩვენი რემბო მეხსირებაში არის, მაგალითისთვის E234F8GHV ალფანუმერაციული ციფრი. როდესაც მომხმარებლისგან ვითხოვთ ამ ალფანუმერაციის შეყვანას კოდური ბგერებით Rembo იგი ამ მოთხოვნას აკმაყოფილებს, თუმცა მის მიერ შეყვანილი რემბო აკუმილირებას ახდენს მეხსიერებაში და ხდება 9G9RT234 რაც საერთოდ არ უდრის ჩვენ მიერ მოთხოვნილ რემბოს. შესაბამისად გვაქ ორი რემბო სხვა და სხვა ადგილზე რომელიც არ არის კავშირში ერთმანეთან.

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

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

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

დაგვრჩა ერთი ოპერაცია განსახილველი ეგ არის do-while loop, მისი წინამორბედისგან განსხვავებით ის ერთხელ მაინც ასრულებს ოპერაციას. ანუ ეს რას ნიშნავს როდესაც ოპერაციას ვქმნით ვაილ ლუპი ეგრევე გვიმოწმებს კონდიციებს და იწყებს მუშაობს, ასრულებს მაშინ როცა კონდიცია მცდარია. do-while loop, კი კონდიციას კოდის ბოლოში გვიმოწმებს, მაგალითად. Do(გააკეთე რამე) while(სანამ) ესა თუ ის კონდიცია დადგება. შესაბამისად კონდიციის გადამოწმება ხდება ბოლოში. მაგალითი:

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

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