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

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

გამოყენების მაგალითები:

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

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

• საჭიროა -ის-- ურთიერთობა:
• მეთოდის სიგნატურა უნდა ემთხვეოდეს:
• შესვლის მოდიფიკატორი შეიძლება იყოს იგივე ან ნაკლებად მკაცრი, ვიდრე მშობელი მეთოდის:
• final ან static მეთოდებს ვერ გადაფარავთ (მეტწილად ენებში):

// Java-ის მაგალითი
class Animal {
    public void makeSound() {
        System.out.println("ზოოს ზოგადი ხმა");
    }
}

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

// გამოყენება
// Animal myAnimal = new Animal();
// myAnimal.makeSound(); // შედეგი: ზოოს ზოგადი ხმა
//
// Animal myDog = new Dog();
// myDog.makeSound(); // შედეგი: ჰაუ! (გადაფარებული მეთოდი გამოიძახება)

# Python-ის მაგალითი
class Animal:
    def make_sound(self):
        print("ზოოს ზოგადი ხმა")

class Dog(Animal):
    def make_sound(self): # გადაფარვა
        print("ჰაუ!")

# გამოყენება
# animal = Animal()
# animal.make_sound() # შედეგი: ზოოს ზოგადი ხმა
#
# dog = Dog()
# dog.make_sound() # შედეგი: ჰაუ!