Ի՞նչ է վերագրանցումը (Overriding) ծրագրավորման մեջ։

Overriding (Ավելացնել) — դա հնարավոր է ենթասինֆում տալ իր սեփական իրականացման մեթոդը, որը արդեն սահմանված է նրա ծնողական դասում: Օգտագործելով վերագրած մեթոդի սինտաքսը (անունը, պարամետրերի քանակը և տեսակները) ենթասինֆում պետք է լրիվ համընկնի ծնողական դասի մեթոդի սինտաքսին: Վերադարձվող արժեքի տիպը նույնպես պետք է լինի կամ նույնը, կամ կովարիանտ (մասնույն) տիպը ծնողական մեթոդի վերադարձվող տիպի:

Հիմնական կողմերը վերագրումից.

• Ներառում: Վերագրումը հնարավոր է միայն ժառանգության հարաբերությունների շրջանակում, որտեղ ենթասինֆը ժառանգում է մեթոդը վերին դասից:
• Պոլիմորֆիզմ: Վերագրումը հանդիսանում է ժամանակի ռնտիմ պոլիմորֆիզմի (runtime polymorphism) իրականացման մի մեխանիզմ: Դա նշանակում է, որ կախված օբյեկտի իրական տիպից, որը կանչվում է ծնողական տիպի հղումով, կիրականացվի համապատասխան մեթոդի իրականացումը (կամ ծնողականից կամ ենթասինֆից):
• @Override բանալի բառը: Որոշ լեզուներում (օրինակ, Java) օգտագործվում է @Override նշումը: Դա պարտադիր չէ վերագրումի ճիշտ աշխատանքի համար, բայց խորհուրդ է տրվում կոդի ընթեռնելիությունը բարելավելու և սխալների կանխարգելման համար, եթե մեթոդը չի համապատասխանում վերագրումի կանոններին:
• Ծնող մեթոդին մուտք գործելու հնարավորություն: Վերագրած մեթոդի ներսում հաճախ անհրաժեշտ է կանչել նույն մեթոդի իրականացումը ծնողական դասից: Դրա համար օգտագործվում է super բանալի բառը (օրինակ, super.metod()).

Java-ի օրինակ:

// Ծնող դաս
class Animal {
    // Մեթոդ ծնողական դասում
    void makeSound() {
        System.out.println("Համայն կենդանին հանում է ձայն");
    }
}

// Որդական դաս, որը ժառանգում է Animal-ից
class Dog extends Animal {
    // Overriding մեթոդ 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):
    # Overriding մեթոդ 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() # Արդյունք: Կենդանին ուտում է. 
# Համայն կենդանին հանում է ձայն

Վերագրումը օգտագործվում է հիմնական դասի վարքագծին համապատասխանեցնելու համար ենթասինֆի առանձնահատկություններին, միաժամանակ պահելով ընդհանուր ինտերֆեյսը: Սա օբյեկտ-կենտրոնացված նախագծման հիմնական տարրերից է։