Question

Implement a superclass person. Make two classes, Student and instructor, that inherit from person. A person has a name and a year of birth. A student has a major, and an instructor has a salary. Write the class declarations, the constructors, and the __repr. method for all classes. Supply a test program that tests these classes and methods.

Short answer

Define a superclass `Person` and subclasses `Student` and `Instructor`. Implement constructors and `__repr__` methods for each. Write a test program to ensure functionality.

Step-by-step solution

Define the Person Class

Begin by creating the superclass `Person`. This class should include the attributes for storing the name and year of birth. Implement the constructor `__init__` to initialize these attributes, and define the `__repr__` method to return a string representation of the class.

Define the Student Class

Create a `Student` class that inherits from `Person`. Add the additional attribute `major` which specifies the student's major. Define the `__init__` method to initialize the `Person` attributes using `super()` and the `major` attribute. Implement the `__repr__` method to include all attributes in the string representation.

Define the Instructor Class

Develop an `Instructor` class that also inherits from `Person`. The additional attribute required here is `salary`. Use the `__init__` method to initialize the `Person` attributes with `super()` and the `salary` attribute. Define the `__repr__` method to output a full description of the instructor.

Implement the Test Program

Write a test program to verify the functionality of the classes. Create instances of `Person`, `Student`, and `Instructor`, and print them out to check that all methods and class inheritance are working as expected.

Key concepts

Python Classes

Python classes serve as blueprints for creating objects. They allow developers to bundle data and functionality together. In the context of object-oriented programming, classes provide the organizational structure needed to mimic real-world objects. Entities such as a person, student, or instructor can be effectively represented using classes.
A class in Python is defined using the `class` keyword followed by the class name. The class body contains methods (functions that define behaviors) and attributes (variables that hold data specific to the object).
For example, in the person class, attributes like `name` and `year_of_birth` can be used to describe basic details about a person. This keeps code manageable and reusable, as additional real-world features or behaviors can be added to the class without overhauling the entire structure. By instantiating a class, you create an object, which you can then work with and apply different methods to manipulate its attributes or derive new information from it.

Inheritance in Python

Inheritance is a powerful feature in object-oriented programming that allows a class to inherit attributes and methods from another class. This establishes a parent-child relationship, where the child class (or subclass) carries over the functionality of the parent class (or superclass), while also adding or modifying aspects as necessary.
In Python, this is implemented using parentheses during class declaration. For example, in our exercise, `Student` and `Instructor` are subclasses of `Person`. This means they automatically derive the `name` and `year_of_birth` attributes from `Person`, avoiding code duplication.
With inheritance:

• You achieve code reusability, as common methods and attributes laid out in the superclass don't need to be rewritten in each subclass.
• It's easier to update and manage code. Changes in the superclass automatically propagate to subclasses, reducing the scope of potential bugs.
• Subclasses can implement or override existing methods to provide specialized functionality. This allows for flexibility and adaptation to specific requirements of subclasses.

In this way, inheritance helps in building complex systems where objects have natural hierarchical relationships.

Python Constructor Method

The constructor method in Python, known as `__init__`, plays a fundamental role in the lifecycle of an object. It's a special method used to initialize a new object when it is created. Every class can have a constructor method to set up attributes for the object at the point of its instantiation.
When defining the `__init__` method, you typically start with `self` as the first parameter, followed by other necessary parameters that the method will use to set object attributes.
For instance, in the `Person` class, `__init__` takes `name` and `year_of_birth` as parameters and assigns them to the object's attributes using `self`.
The importance of a constructor:

• It ensures that objects are always created in a valid state, with all necessary attributes initialized.
• It streamlines object creation, allowing for a consistent and easy-to-maintain approach to setting up new objects.
• By using `super()` in subclasses like `Student` and `Instructor`, the constructor method from the superclass (`Person`) can be efficiently called to initialize inherited attributes, while additional subclass-specific attributes can also be set.

Through its consistent approach to setting up objects, the constructor method aids in reliable and predictable object-oriented programming.