Lecture 24 Inheritance I

(Selected materials from https://www.python-course.eu/python3_inheritance.php)

1. Introduction


Every object-oriented programming language would not be worthy to look at or use, if it weren't to support inheritance. Of course, Python supports inheritance, it even supports multiple inheritance.Classes can inherit from other classes. A class can inherit attributes and behaviour methods from another class, called the superclass. A class which inherits from a superclass is called a subclass, also called heir class or child class. Superclasses are
sometimes called ancestors as well. There exists a hierarchy relationship between classes. It's similar to relationships or
categorizations that we know from real life. Think about vehicles, for example. Bikes, cars, buses and trucks are vehicles. pick-ups, vans, sports cars, convertibles and estate cars are all cars and by being cars they are vehicles as well. We could implement a vehicle class in Python, which might have methods like accelerate and brake. Cars, Buses and Trucks and Bikes can be implemented as subclasses which will inherit these methods from vehicle.

The syntax for a subclass definition looks like this:


Of course, usually we will have an indented block with the class attributes and methods instead of merely a pass statement. The name BaseClassName must be defined in a scope containing the derived class definition. With all this said, we can implement our Person and Employee class:
This is a GREAT example:


The object 'y' inherited the methods from class 'Person' (which makes sense since an employee is also a person and has names), so it doesn't have to have the attibutes claimed in the class 'Person' claimed in its class 'Employee'.

The __init__ method of our Employee class explicitly invokes the __init__method of the Person class. We could have used super instead. super().__init__(first, last) is automatically replaced by a call to the superclasses method, in this case __init__:
Notes that the 'self' argument doesn't exist in 'super().__init__(first, last)'.

Please note that we used super()) without arguments. This is only possible in Python3. We could have written "super(Employee, self).__init__(first, last, age)" which still works in Python3 and is compatible with Python2.

2. Overloading and overrideing
Instead of using the methods "Name" and "GetEmployee" in our previous example, it might have been better to put this functionality into the "__str__" method. In doing so, we gain a lot, especially a leaner design. We have a string casting for our classes and we can simply print out instances. Let's start with a __str__ method in Person:



Now, let's look at a code that was created to reach the same result but failed. Can you tell why it is not working?


One last note: The following doesn't work:


The Employee class inherits the 'self.firstname and the self.lastname' feature form the Person class by 'super().__init__(fisrt, last)'. So in the child class, you can selectively inherit some of the features in the parent class. Which is great. You don't want to inherit the ones you don't need.

However, the 'super().__init__(first, last)' call doesn't have 'self' as one of the arguments. Because you are calling the function __init__(self, first, last) in the Person class. and this function already has self in there and when you call it, you don't need to put 'self' in there. 'self' is kind of a default argument, you only have it when you define the function but you don't need it when you call this function.

The '__str__(self)' function doesn't have all the firstname, lastname, stuffnumber arguments. Why?
The '__str()' function is called when you have 'print()' called at the end of the script (outside of the class and function). If you print the entire object as 'print(freshMan)', then the argument 'freshMan' includes all the fisrtname, lastname, and stuffnumber in it, so including all these arguments in this call is redundant.

We have overridden the method __str__ from Person in Employee. By the way, we have overridden __init__ also. Method overriding is an object-oriented programming feature that allows a subclass to provide a different implementation of a method that is already defined by its superclass or by one of its superclasses. The implementation in the subclass overrides the implementation of the superclass by providing a method with the same name, same parameters or signature, and same return type as the method of the parent class.

3. The Car example:
Let's make the Car class first. We all know that the major attributes of a car can be: make, model, year, and odometer. We didn't put the odometer in the '__init__()' function since it is actually being changed along the way. But I still created a 'self.odometer_reading = 0' in the __init__() function to assign an initial value to the odometer. (it is a new car)



Then let's start making subclasses to this Car class:


Oops! Something is wrong. The '2016' in my 'ElectricCar("tesla", 'model s", 2016)' is an int variable. However, in the 'get_descriptive_name()' function, I didn't convert it into a string in order to be printed out later. So simply force it to a str variable there and you will fix it.



Thank Goodness! Objective-oriented programming is so fun!!!!



Tasks:

1. According to the given structure of the code and the given results, complete the following code and verify your results.


2.
According to the given structure of the code and the given results, complete the following code and verify your results.