მეტოდების გადატვირთვის წესების შესახებ მომიყევი.

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

მეთოდების გადატვირთვის ძირითადი წესები:

სიგნატურებში განსხვავება: მეთოდის სიგნატურა მოიცავს მეთოდის სახელს და მისი პარამეტრების ტიპების სიის შესაბამის წესრიგში. იმისათვის, რომ მეთოდები ჩაითვალოს გადატვირთულად, მათი სიგნატურები უნდა განსხვავდებოდეს.
```
// განსხვავებული სიგნატურების მაგალითები
void print(int i) { }
void print(String s) { }
void print(int i, String s) { }
void print(String s, int i) { } // პარამეტრების წესრიგი განსხვავებულია
```
მეთოდის სახელმა უნდა იყოს ერთნაირი: გადატვირთული მეთოდები უნდა ჰქონდეთ ერთნაირი სახელი.
```
// სწორი მაგალითი გადატვირთვის
class Example {
    void process(int a) { }
    void process(double b) { }
}
```
დაბრუნების ტიპი სიგნატურის ნაწილი არ არის: მხოლოდ დაბრუნების ტიპის ცვლილება არ ქმნის მეთოდების გადატვირთვას. კომპილატორი ვერ შეძლებს განსაზღვროს, რომელი მეთოდი უნდა გამოიძახოს, თუ სიგნატურები ერთნაირია:
```
// არ არის გადატვირთვა - კომპილაციის შეცდომა
int calculate() { return 1; }
String calculate() { return "error"; }
```
წვდომის მოდიფიკატორები და გამონაკლისების სპეციფიკატორები არ ახდენენ გავლენას გადატვირთვაზე: ასევე, მხოლოდ დაბრუნების ტიპის ცვლილება, წვდომის მოდიფიკატორების (public, private, protected, default) ან გამონაკლისების სიების (throws) ცვლილება, არ იწვევს გადატვირთვას:
```
// არ არის გადატვირთვა - კომპილაციის შეცდომა, თუ სიგნატურები ერთნაირია
public void doSomething() { }
private void doSomething() { }
```

პარამეტრების წესრიგი მნიშვნელოვანია: პარამეტრების ტიპების ცვლილება ქმნის განსხვავებულ სიგნატურებს:

// არის გადატვირთვა
void setup(int width, int height) { }
void setup(int height, String unit) { } // განსხვავდება მეორე პარამეტრით
void setup(String unit, int size) { } // განსხვავდება ტიპით და წესრიგით

პარამეტრების რაოდენობა მნიშვნელოვანია: სხვადასხვა რაოდენობის პარამეტრები ქმნის განსხვავებულ სიგნატურებს:
```
// არის გადატვირთვა
void log(String message) { }
void log(String message, int level) { }
```

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