In which Java Oops feature one object can acquire all the properties and Behaviours of the parent object Mcq?

Overview

• Learn about Inheritance in Object Oriented Programming and various forms of Inheritance
• Understand Method Overriding and super() function in the world of Object Oriented Programming

Introduction

Inheritance is one of the most important aspects of Object Oriented Programming (OOP). The key to understanding Inheritance is that it provides code re-usability. In place of writing the same code, again and again, we can simply inherit the properties of one class into the other.

This, as you can imagine, saves a ton of time. And time is money in data science!

OOP is all about real-world objects and inheritance is a way of representing real-world relationships. Here’s an example – car, bus, bike – all of these come under a broader category called Vehicle. That means they’ve inherited the properties of class vehicles i.e all are used for transportation.

We can represent this relationship in code with the help of inheritance.

Another intriguing thing about inheritance is that it is transitive in nature. But what does this mean? We’ll see in detail later in this article. Python also supports various types of inheritance which I will cover in detail in this article.

This is the second article in the series of articles related to Object Oriented Programming. Please go through the first article as well:

•  Basic Concepts of Object Oriented Programming.

Table of Contents

1. What is Inheritance in Object Oriented Programming?
2. Different Forms of Inheritance in Object Oriented Programming
   • Single Inheritance
   • Multiple Inheritance
   • Multi-level Inheritance
   • Hierarchical Inheritance
   • Hybrid Inheritance
3. Method Overriding
4. The super() function

Inheritance is the procedure in which one class inherits the attributes and methods of another class. The class whose properties and methods are inherited is known as the Parent class. And the class that inherits the properties from the parent class is the Child class.

The interesting thing is, along with the inherited properties and methods, a child class can have its own properties and methods.

You may use the following syntax:\ to implement inheritance in Python:

Let’s see the implementation:
Python Code:

We have created two child classes namely “BMW” and “Audi” that have inherited the methods and properties of the parent class “Car”.  We have provided no additional features and methods in the class BMW. Whereas there is one additional method inside the class Audi.

Notice how the instance method description() of the parent class is accessible by the objects of child classes with the help of obj1.description() and obj2.description(). And the separate method of class Audi is also accessible using obj2.audi_desc().

We can check the base or parent class of any class using a built-in class attribute __bases__

print(BMW.__bases__, Audi.__bases__)

As we can here, the base class of both sub-classes is Car. Now, let’s see what happens when using __base__ with the parent class Car:

Whenever we create a new class in Python 3.x, it is inherited from a built-in basic class called Object. In other words, the Object class is the root of all classes.

Forms of Inheritance in Object Oriented Programming

There are broadly five forms of inheritance based on the involvement of parent and child classes.

1. Single inheritance

This is a form of inheritance in which a class inherits only one parent class. This is the simple form of inheritance and hence also referred to as simple inheritance.

class Parent: def f1(self): print("Function of parent class.") class Child(Parent): def f2(self): print("Function of child class.") object1 = Child() object1.f1() object1.f2()

Here the class Child is inheriting only one class Parent, hence this is an example of Single inheritance.

2. Multiple Inheritance

An inheritance becomes multiple inheritances when a class inherits more than one parent class. The child class after inheriting properties from various parent classes has access to all of their objects.

class Parent_1: def f1(self): print("Function of parent_1 class.") class Parent_2: def f2(self): print("Function of parent_2 class.") class Parent_3: def f3(self): print("function of parent_3 class.") class Child(Parent_1, Parent_2, Parent_3): def f4(self): print("Function of child class.") object_1 = Child() object_1.f1() object_1.f2() object_1.f3() object_1.f4()

Here we have one Child class which is inheriting properties of three-parent classes Parent_1, Parent_2, and Parent_3. All the classes have different functions and all of the functions are called using the object of the Child class.

But suppose a child class inherits two classes having the same function:

class Parent_1: def f1(self): print("Function of parent_1 class.") class Parent_2: def f1(self): print("Function of parent_2 class.") class Child(Parent_1, Parent_2): def f2(self): print("Function of child class.")

Here, the classes Parent_1 and Parent_2 have the same function f1(). Now, when the object of Child class calls f1(), since Child class is inheriting both the parent classes, what do you think should happen?

But why not the function f1() of the class Parent_2 was inherited?

In multiple inheritance, the child class first searches the method in its own class. If not found, then it searches in the parent classes depth_first and left-right order. Since this was an easy example with just two parent classes, we can clearly see that class Parent_1 was inherited first so the child class will search the method in Parent_1 class before searching in class Parent_2.

But for complicated inheritance problems, it gets tough to identify the order. So the actual way of doing this is called Method Resolution Order (MRO) in Python. We can find the MRO of any class using the attribute __mro__

This tells that the Child class first visited the class Parent_1 and then Parent_2, so the f1() method of Parent_1 will be called.

Let’s take a bit complicated example in Python:

class Parent_1: pass class Parent_2: pass class Parent_3: pass class Child_1(Parent_1,Parent_2): pass class Child_2(Parent_2,Parent_3): pass class Child_3(Child_1,Child_2,Parent_3): pass

Here, the class Child_1 is inheriting two classes – Parent_1 and Parent_2. The class Child_2 is also inheriting two classes – Parent_2 and Parent_3. Another class Child_3 is inheriting three classes – Child_1, Child_2 and Parent_3.

Now, just by looking at this inheritance, it is quite hard to determine the Method Resolution Order for class Child_3. So here is the actual use of __mro__-

We can see that first, the interpreter searches Child_3, then Child_1 followed by Parent_1, Child_2, Parent_2, and Parent_3 respectively.

3. Multi-level Inheritance

For example, a class_1 is inherited by a class_2 and this class_2 also gets inherited by class_3 and this process goes on. This is known as multi-level inheritance. Let’s understand with an example:

class Parent: def f1(self): print("Function of parent class.") class Child_1(Parent): def f2(self): print("Function of child_1 class.") class Child_2(Child_1): def f3(self): print("Function of child_2 class.") obj_1 = Child_1() obj_2 = Child_2() obj_1.f1() obj_1.f2() print("\n") obj_2.f1() obj_2.f2() obj_2.f3()

Here, the class Child_1 is inheriting the Parent class and the class Child_2 is inheriting the class Child_1. In this Child_1 has access to functions f1() and f2() whereas Child_2 has access to functions f1(), f2() and f3(). If we’ll try to access the function f3() using the object of class Class_1 then an error will occur stating:

‘Child_1’ object has no attribute ‘f3’

4- Hierarchical inheritance

In this, various Child classes inherit a single Parent class. The example given in the introduction of the inheritance is an example of Hierarchical inheritance since classes BMW and Audi inherit class Car.

For simplicity let’s look at another example:

class Parent: deff1(self): print("Function of parent class.") class Child_1(Parent): deff2(self): print("Function of child_1 class.") class Child_2(Parent): deff3(self): print("Function of child_2 class.") obj_1 = Child_1() obj_2 = Child_2() obj_1.f1() obj_1.f2() print('\n') obj_2.f1() obj_2.f3()

Here two child classes are inheriting the same Parent class. The class Child_1 has access to functions f1() of Parent class and function f2() of itself. Whereas the class Child_2 has access to functions f1() of Parent class and function f3() of itself.

5- Hybrid Inheritance

When there is a combination of more than one form of inheritance, it is known as hybrid inheritance. It will be more clear after this example:

class Parent: def f1(self): print("Function of parent class.") class Child_1(Parent): def f2(self): print("Function of child_1 class.") class Child_2(Parent): def f3(self): print("Function of child_2 class.") class Child_3(Child_1, Child_2): def f4(self): print("Function of child_3 class.") obj = Child_3() obj.f1() obj.f2() obj.f3() obj.f4()

In this example, two classes ‘Child_1′ and ‘Child_2’ are derived from base class ‘Parent’ using hierarchical inheritance. Another class ‘Child_3’ is derived from classes ‘Child_1’ and ‘Child_2’ using multiple inheritances. The class ‘Child_3’ is now derived using hybrid inheritance.

Method Overriding

The concept of overriding is very important in inheritance. It gives the special ability to the child/subclasses to provide specific implementation to a method that is already present in their parent classes.

class Parent: def f1(self): print("Function of Parent class.") class Child(Parent): def f1(self): print("Function of Child class.") obj = Child() obj.f1()

Here the function f1() of the Child class has overridden the function f1() of the Parent class. Whenever the object of Child class will invoke f1(), the function of Child class gets executed. However, the object of the Parent class can invoke the function f1() of the parent class.

The super() function

The super() function in Python returns a proxy object that references the parent class using the super keyword. This super() keyword is basically useful in accessing the overridden methods of the parent class.

1. In a class hierarchy with single inheritance, super helps to refer to the parent classes without naming them explicitly, thus making the code more maintainable.

   For example-

   class Parent: def f1(self): print("Function of Parent class.") class Child(Parent): def f1(self): super().f1() print("Function of Child class.") obj = Child() obj.f1()

   

   Here, with the help of super().f1(), the f1() method of the super class of Child class i.e Parent class has been called without explicitly naming it.

   One thing to note here is that super() class can accept two parameters- first is the name of the subclass and second is an object that is an instance of that subclass.  Let’s see how-

   class Parent: def f1(self): print("Function of Parent class.") class Child(Parent): def f1(self): super( Child, self ).f1() print("Function of Child class.") obj = Child() obj.f1()

   

   The first parameter refers to the subclass Child, while the second parameter refers to the object of Child which, in this case, is self. You can see the output after using super() and super( Child, self) is the same because, in Python 3, super( Child, self) is equivalent to self().

   Now let’s see one more example using the __init__ function.

   class Parent(object): def__init__(self, ParentName): print(ParentName, 'is derived from another class.') class Child(Parent): def__init__(self, ChildName): print(name,'is a sub-class.') super().__init__(ChildName) obj = Child('Child')

   

   What we have done here is that we called the __init__ function of Parent class (inside the Child class) using super().__init__( ChildName ). And as the __init__ method of the Parent class requires one argument, it has been passed as “ChildName”.  So after creating the object of the Child class, first the __init__ function of Child class got executed, and after that the __init__ function of Parent class.

2. The second use case is to support cooperative multiple inheritances in a dynamic execution environment.

   class First(): def __init__(self): print("first") super().__init__() class Second(): def __init__(self): print("second") super().__init__() class Third(Second, First): def __init__(self): print("third") super().__init__() obj = Third()

   
   
   The super() call finds the next method in the MRO at each step, which is why First and Second have to have it too, otherwise, execution stops at the end of first().__init__.

   Note that the super-class of both First and Second is Object.

   Let’s find the MRO of Third() as well-

   Third.__mro__
   

   The order is Third > Second > First and the same is the order of our output.

End Notes

To conclude, in this article I’ve taken forward the concept of Inheritance in Object Oriented Programming in Python. I covered various forms of Inheritance and some of the common concepts in Inheritance such as Method Overriding and the super() function.

I hope you understood the concepts explained in this article. Let me know in the comments below if you have any queries.