პროგრამირებაში რა არის გადაფარვა (Overriding)?

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

ძირითადი ასპექტები:

• მემკვიდრეობა: გადაფარვა შესაძლებელია მხოლოდ მემკვიდრეობის ურთიერთობაში, სადაც ქვესკლასი მემკვიდრეობს მეთოდს მშობელ კლასიდან.
• პოლიმორფიზმი: გადაფარვა არის ერთ-ერთი მექანიზმი დროის შესრულების პოლიმორფიზმის (runtime polymorphism) განხორციელებისთვის. ეს ნიშნავს, რომ რეალურად, თუ რა ტიპის ობიექტია, რომელიც გამოიძახება მშობელ ტიპზე მიმთითებელი ბმულით, შესრულდება შესაბამისი მეთოდის რეალიზაცია (მშობელიდან ან ქვესკლასიდან).
• @Override საკვანძო სიტყვა: ზოგი ენაში (მაგალითად, Java) გამოიყენება ანოტაცია @Override. იგი არ არის აუცილებელი გადაფარვის სწორად მუშაობისთვის, მაგრამ რეკომენდებულია კოდის უკეთ წაკითხულობის და კომპილაციის შეცდომების თავიდან აცილებისთვის, თუ მეთოდი არ ემთხვევა გადაფარვის წესებს.
• მშობელ მეთოდზე წვდომა: გადაფარვილი მეთოდის შიგნით ხშირად საჭიროა გამოიძახოს იგივე მეთოდის რეალიზაცია მშობელ კლასიდან. ამისთვის გამოიყენება super საკვანძო სიტყვა (მაგალითად, super.მეთოდი()).

Java-ს მაგალითი:

// მშობელ კლასი
class Animal {
    // მეთოდი მშობელ კლასში
    void makeSound() {
        System.out.println("ცხოველი ხმას გამოსცემს");
    }
}

// ქვესკლასი, რომელიც მემკვიდრეობს Animal-დან
class Dog extends Animal {
    // `makeSound()` მეთოდის გადაფარვა
    @Override
    void makeSound() {
        System.out.println("ვუ ვუ!");
    }

    // მაგალითი მშობელ მეთოდზე წვდომის
    void eat() {
        System.out.println("ძაღლი ჭამს.");
        super.makeSound(); // მშობელ კლასის მეთოდის გამოძახება
    }
}

class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog(); // პოლიმორფიზმი

        myAnimal.makeSound(); // გამოიტანს: ცხოველი ხმას გამოსცემს
        myDog.makeSound();   // გამოიტანს: ვუ ვუ! (გადაფარვილი მეთოდი)

        Dog specificDog = new Dog();
        specificDog.eat(); // გამოიტანს: ძაღლი ჭამს. 
 // ვუ ვუ! (მშობელ მეთოდის გამოძახება)
    }
}

Python-ის მაგალითი:

# მშობელ კლასი
class Animal:
    # მეთოდი მშობელ კლასში
    def make_sound(self):
        print("ცხოველი ხმას გამოსცემს")

# ქვესკლასი, რომელიც მემკვიდრეობს Animal-დან
class Dog(Animal):
    # `make_sound()` მეთოდის გადაფარვა
    def make_sound(self):
        print("ვუ ვუ!")

    # მაგალითი მშობელ მეთოდზე წვდომის
    def eat(self):
        print("ძაღლი ჭამს.")
        super().make_sound() # მშობელ კლასის მეთოდის გამოძახება

# დემონსტრაცია
my_animal = Animal()
my_dog = Dog() # პოლიმორფიზმი

my_animal.make_sound() # გამოიტანს: ცხოველი ხმას გამოსცემს
my_dog.make_sound()   # გამოიტანს: ვუ ვუ!

specific_dog = Dog()
specific_dog.eat() # გამოიტანს: ძაღლი ჭამს. 
 # ვუ ვუ! (მშობელ მეთოდის გამოძახება)

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