Designing Classes and Using Inheritance
Say we wanted to design some classes that represent Cars, Trucks, and Buses. Each one has a variable, let’s call it
repair_cost that represents the amount of money required to repair that object. Each class has a different
repair_cost, but each object in the class has the same
repair_cost. So, each Car object has a
repair_cost of 10, Trucks cost 20, and Buses cost 30.
>>> c1 = Car() >>> t1 = Truck() >>> b1 = Bus() >>> c1.repair_cost 10 >>> t1.repair_cost 20 >>> b1.repair_cost 30
How many classes should we make to minimize the amount of code?
After we have determined the number of classes to make, let’s make them! Implement the Car, Truck, Bus, and any other classes (which could be none!) that you feel are necessary to create this situation in a way that makes the most sense (making use of inheritance, overridding, etc.). Let’s also set a variable on all the vehicles that states how many wheels it has (let’s just say that all of our vehicles have 4 wheels).
Once you have your classes made, implement a function that takes in an
amount_paid and compares that to the
repair_cost. If the
amount_paid is greater than or equal to the
repair_cost, then the item is allowed to be fixed and it should print out a message indicating that it has been fixed. If it cannot be fixed, then it should print out a different message indicating so. Try to minimize the amount of code that is required for this problem using inheritance.
There are many ways to answer this question. Here is the solution that I came up with.
class Vehicle(object): num_wheels = 4 def repair(self, amount_paid): if amount_paid >= self.repair_cost: print("The " + type(self).__name__ + " has been fixed!") else: print("The " + type(self).__name__ + " was not fixed :( Please pay more money.") class Car(Vehicle): repair_cost = 10 class Truck(Vehicle): repair_cost = 20 class Bus(Vehicle): repair_cost = 30
type(self).__name__ is something that is not important, all it does is grab the name of the class of self and convert it to string form.
The important parts here are the fact that we do not have any
__init__ statements, anywhere! The reason is because our objects themselves do not have any instance variables, they only have class variables. So, we simply make a generic object (becuase the class Vehicle inherites from the generic object class) that allows us to assign some class variables.
For the subclasses, Car, Truck, and Bus, we only need to set the
repair_cost because that is the only thing that changes between the different classes. The
repair method that we definied in the Vehicle class still works. Do you see why?
The answer lies in the fact that the
repair method checks
self.repair_cost instead of
Car.repair_cost. The result is that whichever object this method is called on, it will use the type of the object to determine which
repair_cost to use. The result is that we can now make one general method that works for multiple different subclasses.
I don't claim to be perfect so if you find an error on this page, please send me an email preferably with a link to this page so that I know what I need to fix!