4-new-methods.md

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

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

მარჯვნივ მოხვევის მეთოდი შემდეგნაირად გამოიყურება

private void turnRight() {
    turnLeft();
    turnLeft();
    turnLeft();
}

ამ კოდში private void turnRight() მეთოდის თავია. მეთოდის თავი შედგება მეთოდის თვისებების აღწერისგან, ესენია private და void, და ასევე მეთოდის სახელისგან turnRight. მეთოდის თვისებები შეგიძლია ცოტა ხნით დაიკიდო, ამას მალე მიუბრუნდები. მეთოდის სახელს რაც შეეხება - სახელად, ცხადია, ნებისმიერი სხვა რამ შეგეძლო შეგერჩია მაგალითად moukhvieMarjvniv ან marjvnisaken თუმცა სტილისტურად turnRight უფრო ემთხვევა სხვა მეთოდების სახელებს და ამიტომაც სხვებს ეს სჯობს. სახელის შემდეგ გახსნილი და დახურული ფრჩხილიც () აუცილებელია და ესევ მეთოდის თავში შედის.

თუკი წინა მაგალითში მარჯვნივ მოხვევის მეთოდს გამოიყენებ ასეთ კოდს მიიღებ:

import stanford.karel.*;

public class FirstProgram extends Karel {
    public void run() {
        move();
        pickBeeper();
        turnLeft();
        move();
        turnRight();
        move();
        move();
        putBeeper();
        move();
    }

    private void turnRight() {
        turnLeft();
        turnLeft();
        turnLeft();
    }
}

მეთოდი აუცილებლად კლასის შიგნით უნდა ეწეროს და სხვა მეთოდების გარეთ. ამ შემთხვევაში ჩვენს FirstProgram კლასში 2 მეთოდი წერია run მეთოდი და turnRight მეთოდი. ყურადღებას თუ მიაქცევ public void run()-იც ჩვეულებრივი მეთოდია, უბრალოდ ცოტა განსხვავებული თვისებები აქვს და სხვა ყველა დანარჩენი მეთოდებისგან იმით განსხვავდება, რომ run მეთოდი აუცილებლად პირველი სრულდება, მეტიც თუკი პროგრამაში run მეთოდს არ დაწერ პროგრამა არაფერსაც არ გააკეთებს. მეთოდების მიმდევრობას არანაირი მნიშვენლობა არ აქვს. მაგალითად ჯერ შეიძლება turnRight მეთოდი ეწეროს და მერე run ან პირიქით.

რას აკეთებს კარელი ამ პროგრამის შესრულების დროს? კარელი პროგრამის გაშვების შემდეგ პირველ რიგში ეძებს run მეთოდს და იწყებს run მეთოდში არსებული ბრძანებების შესრულებას. პირველი ბრძანება არის move(), შესაბამისად კარელი გადაადგილდება ერთი ნაბიჯით წინ, შემდეგ pickBeeper - კარელი აიღებს ბრილიანტს, შემდეგ turnLeft - მოტრიალდება მარცხნივ, move - გადაადგილდება ერთი ნაბიჯით წინ, შემდეგ შეხვდება ბრძანება turnRight კარელმა ეს ბრძანება ავტომატურად არ იცის, ეს რაღაც ახალი ბრძანებაა, დაიწყებს ამ ბრძანების ძებნას კოდში, მიაგნებს turnRight მეთოდის განმარტებას და დაიწყებს მის შესრულებას, შესაბამისად გააკეთებს turnLeft - მოტრიალდება მარცხნივ, მერე turnLeft - მოტრიალდება მარცხნივ და ისევ turnLeft - მოტრიალდება მარცხნივ. ამით turnRight მეთოდის ბრძანებები ამოიწურა, შესაბამისად turnRight მეთოდი დასრულდება(სრულად შესრულდება) და კარელი გააგრძელებს run მეთოდში დაწერილი მორიგი ბრძანების შესრულებას. ანუ შემდეგი ბრძანება იქნება move - კარელი წავა წინ, move - ისევ წინ, putBeeper - დადებს ბრილიანტს, move - ისევ წინ. ახლა უკვე კარელმა run მეთოდში აღწერილი ყველა ბრძანება შეასრულა(მიმდევრობით) და run მეთოდი მთავრდება რაც ნიშნავს, რომ პროგრამაც ასრულებს მუშაობას.

რაში გვჭირდება ახალი მეთოდები?

მეთოდების შექმნის რამდენიმე მიზეზია.

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