The terms ‘super’ and ‘extends’ play crucial roles in object-oriented programming languages like Java and Python,notably in the context of inheritance and generics. While they serve different purposes and are used in distinct ways across these languages,understanding their core functionality is essential for writing robust and maintainable code.

In Java,’extends’ is primarily used to establish an inheritance relationship between classes,while ‘super’ is used to access members (methods and fields) of the superclass from within a subclass. In the context of Java Generics,’super’ and ‘extends’ define upper and lower bounds for type parameters,adding a layer of flexibility and type safety [[1]].

Python’s ‘super()’ function provides a way to call methods from a parent class, especially useful in multiple inheritance scenarios. It avoids explicitly naming the base class,making code more adaptable to changes in the inheritance hierarchy [[2]].

‘extends’ and ‘super’ in Java

In Java, the keyword ‘extends’ is used to create a subclass that inherits properties and behaviors from a superclass. for example:

class Animal {
    String name;
}

class Dog extends Animal {
    string breed;
}
            

Here,’Dog’ extends ‘animal’,inheriting the ‘name’ property. the ‘super’ keyword allows the subclass to access the superclass’s members,such as its constructor or methods.

“When you put an Object to the List, all you care about is that the object is of a type that is compatible with type held by the list.” [[1]]

Java Generics use ‘extends’ and ‘super’ to define type boundaries. ‘extends’ specifies an upper bound (the type must be a subclass of the specified class), while ‘super’ specifies a lower bound (the type must be a superclass of the specified class) [[1]].

‘super()’ in Python

Python’s ‘super()’ function is used to call methods from a parent class. This is particularly useful when dealing with multiple inheritance,where the order of inheritance matters.

class Animal:
    def __init__(self, name):
        self.name = name

class Dog(Animal):
    def __init__(self,name,breed):
        super().__init__(name)
        self.breed = breed
            

In this example, ‘super().__init__(name)’ calls the constructor of the ‘animal’ class, ensuring that the ‘name’ attribute is initialized correctly. ‘super()’ promotes code reuse and simplifies complex inheritance structures [[2]].