Methods in Classes

One Object, Two Class Levels

Inheritance lets you create a child class that extends a parent class. The child receives the parent class's variables and methods, then can add variables and methods of its own. This means one child-class instance can combine inherited functionality with child-specific functionality.

The Inheritance Declaration

To define a child class, place the parent class name in parentheses after the child class name. The pattern is class ChildClass(ParentClass):. In the source example, CricketFan is the child class and PartyAnimal is the parent class, so CricketFan extends PartyAnimal.

class CricketFan(PartyAnimal):
    pass

Initialization Through super()

A child class may need to initialize both the parent class's variables and its own variables. The child class's __init__ method can call super().__init__() to run the parent class's __init__ method. Call super().__init__() before setting child-specific variables so the parent is initialized first.

class CricketFan(PartyAnimal):
    def __init__(self, name):
        super().__init__(name)
        self.points = 0

Inherited and Added Functionality

class CricketFan(PartyAnimal):
    def __init__(self, name):
        super().__init__(name)
        self.points = 0

    def six(self):
        self.points = self.points + 6

Inheritance does not replace the child class's ability to define its own behavior. The child extends the parent by adding new variables and methods while retaining access to the inherited ones.

Finding an Inherited Method

A child-class object can use a method that the child class did not define itself because the method was inherited from the parent. For example, a CricketFan instance can use party(), which comes from PartyAnimal, while also using six(), which is defined in CricketFan.

Initialization Checklist

1. Declare the child class with the parent class in parentheses.
2. Define the child class's __init__ method when the child needs its own initialization.
3. Call super().__init__() from the child initializer.
4. Set up the child-specific variables after the parent initializer returns.
5. Add child-specific methods while retaining access to inherited methods.

• Defining the child class without naming its parent in parentheses.

  This does not express that CricketFan extends PartyAnimal.

  Fix: Use the inheritance form class CricketFan(PartyAnimal):.

• Setting child-specific variables without calling the parent initializer.

  The parent class's required initialization may not be completed.

  Fix: Call super().__init__() before setting child-specific variables.

• Assuming the child has only its newly defined methods and variables.

  A child instance also has access to inherited parent functionality.

  Fix: Include both inherited members, such as name and party(), and child members, such as points and six().

• Assuming inheritance works in both directions.

  The hierarchy is one-way from parent to child.

  Fix: Remember that CricketFan inherits from PartyAnimal; PartyAnimal does not inherit from CricketFan.

Practice the Extension Pattern

What to Remember

1. Use class ChildClass(ParentClass): to define a child class that extends a parent class.
2. A child class inherits the parent class's variables and methods.
3. Use super().__init__() inside the child initializer to run the parent initializer.
4. Call the parent initializer before setting child-specific variables.
5. A child-class instance combines inherited functionality with new functionality defined by the child.