ინფორმაციის ტიპების კონტექსტში მემკვიდრეობა და პოლიმორფიზმი რა არის?

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

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

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

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

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

// შვილი კლასი 1
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("ჰაუ-ჰაუ");
    }
}

// შვილი კლასი 2
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("მიო-მიო");
    }
}

class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // ცვლადი ტიპი Animal მიუთითებს Dog-ზე
        Animal myCat = new Cat(); // ცვლადი ტიპი Animal მიუთითებს Cat-ზე

        myDog.makeSound(); // გამოიძახება Dog-ის მეთოდი (პოლიმორფიზმი)
        myCat.makeSound(); // გამოიძახება Cat-ის მეთოდი (პოლიმორფიზმი)
    }
}

ამ მაგალითში myDog და myCat აქვთ ლინკის ტიპი Animal, მაგრამ პოლიმორფიზმის წყალობით, როდესაც გამოიძახება makeSound(), შესრულდება შესაბამისი რეალიზაცია Dog და Cat-დან.