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

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

    ჯავას ამ ნაწილში ვისაუბრებთ 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-ზე საუბარს მოვრჩით. ერთ-ერთი ყველაზე მნიშვნელოვანი ოპერაციების კრებულია ეგ თავი. მის გარეშე კოდი ფაკტიურად არ არსებობს, დაწერთ რამეს მაგრამ აზრს ვერ შეუქმნით, ლოგიკას ვერ დაუხვეწავთ და სულს ვერ ჩაბერავთ თქვენ ნამოქმედარს. ბევრი შეცდომის გამოსწორება შეიძლება პროცესში მაგრამ ამას ვერ გამოასწორებთ, თუ არ იცით ნიშნავს იმას რომ კოდის წერა არ იცით, შესაბამისად არ ხართ პროგრამისტი.