Aufrufen den Superkonstruktor der Elternklasse in Python

Vererbung ist ein leistungsstarkes Konzept der objektorientierten Programmierung in der Informatik, das uns hilft, das Schreiben von redundantem Code zu vermeiden, und gut mit der goldenen DRY-Regel der Programmierung (Don't repeat yourself) vereinbar ist. Mittels Vererbung kann eine Klasse alle Eigenschaften und Funktionen einer anderen Klasse in sich vererben. Die Klasse, von der die Funktionalität geerbt wird, ist die übergeordnete Klasse, und die Klassen, die die Funktionalität erben, sind untergeordnete Klassen.

Vererbung hilft Programmierern und Entwicklern beim Schreiben von skalierbarem, wiederverwendbarem und wartbarem Code, was die Produktivität und Effizienz verbessert.

Um alle Attribute und Methoden zu erben, müssen wir den Konstruktor der übergeordneten Klasse von den untergeordneten Klassen ausführen. In diesem Artikel erfahren Sie, wie Sie den Superkonstruktor der übergeordneten Klasse in Python aufrufen.

Aufrufen den Superkonstruktor der Elternklasse in Python

Der Konstruktor der Elternklasse oder der Superkonstruktor wird in den Konstruktoren der Kindklassen aufgerufen. Die Syntax dafür ist wie folgt.

super().__init__(*args, **kwargs)

Alle von der übergeordneten Klasse benötigten Argumente werden innerhalb der Methode __init__() übergeben. In der obigen Syntax deckt *args, **kwargs alle Argumente ab, aber man kann auch alle Argumente wie folgt einzeln erwähnen.

super().__init__(argument1, argument2, argument3, ...)

Nun, da wir mit der Theorie fertig sind, wollen wir das Konzept praktisch verstehen. Sehen Sie sich den folgenden Python-Code an, um das Konzept der Vererbung zu verstehen und wie ein Superkonstruktor aufgerufen wird.

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def get_name(self):
        return self.name

    def set_name(self, name):
        if isinstance(name, str):
            self.name = name

    def get_age(self):
        return self.age

    def set_age(self, age):
        if isinstance(age, int):
            self.age = age

    def get_gender(self):
        return self.gender

    def set_gender(self, gender):
        if isinstance(gender, str):
            self.gender = gender


class Student(Person):
    def __init__(self, name, age, gender, roll_number):
        super().__init__(name, age, gender)  # Important
        self.roll_number = roll_number

    def get_roll_number(self):
        return self.roll_number

    def set_roll_number(self, roll_number):
        if isinstance(roll_number, int):
            self.roll_number = roll_number


adam = Student("Adam", 21, "M", 5)
emma = Student("Emma", 23, "F", 18)
print("Name:", adam.get_name())
print("Age:", adam.get_age())
print("Gender:", adam.get_gender())
print("Roll Number:", adam.get_roll_number())
print()
print("Name:", emma.get_name())
print("Age:", emma.get_age())
print("Gender:", emma.get_gender())
print("Roll Number:", emma.get_roll_number())

Ausgabe:

Name: Adam
Age: 21
Gender: M
Roll Number: 5

Name: Emma
Age: 23
Gender: F
Roll Number: 18

Die Klasse Person ist die übergeordnete Klasse und die Klasse Student die untergeordnete Klasse. Die Eltern- und Kindklassen haben Setter und Getter für alle ihre Attribute. Die Kindklasse erbt alle Attribute und Methoden der Elternklasse. Diese Anweisung super().__init__(name, age, gender) hat den Konstruktor der Klasse Person aufgerufen. Beachten Sie, dass der Konstruktor der übergeordneten Klasse aufgerufen werden muss; andernfalls bricht der Code.