Parent and child classes in Java - Deep Dive

Overview - Parent and child classes

What is it?

Parent and child classes are a way to organize code where one class (the child) inherits properties and behaviors from another class (the parent). This means the child class can use or change what the parent class has without rewriting everything. It helps to create a clear relationship between general and specific things in your program. This concept is a key part of object-oriented programming.

Why it matters

Without parent and child classes, programmers would have to repeat the same code many times for similar things, making programs longer and harder to fix. This concept saves time and effort by letting child classes reuse and customize what parent classes provide. It also helps keep programs organized and easier to understand, which is important when many people work on the same code.

Where it fits

Before learning parent and child classes, you should understand basic classes and objects in Java. After this, you can learn about more advanced topics like polymorphism, interfaces, and abstract classes, which build on inheritance to make programs even more flexible.

Mental Model

Core Idea

A child class inherits and can extend or change the features of its parent class, creating a family-like relationship in code.

Think of it like...

Think of a child inheriting traits from their parents, like eye color or height, but also developing their own unique skills or habits that make them different.

Parent Class
  ├─ Properties and Methods
  ↓
Child Class
  ├─ Inherits Parent's Properties and Methods
  ├─ Adds or Changes Features
  ↓
Used in Program

Build-Up - 7 Steps

1

Foundation

Understanding Basic Classes and Objects

Concept: Learn what classes and objects are in Java as the building blocks for inheritance.

A class is like a blueprint for creating objects. For example, a class Car can describe properties like color and speed, and actions like drive(). An object is an actual car made from that blueprint. Example: class Car { String color; void drive() { System.out.println("Driving"); } } Car myCar = new Car(); myCar.color = "red"; myCar.drive();

Result

The program creates a Car object with color red and prints "Driving" when drive() is called.

Understanding classes and objects is essential because inheritance builds on these concepts to share and extend behavior.

2

Foundation

Introducing Inheritance Syntax in Java

Concept: Learn how to declare a child class that inherits from a parent class using the 'extends' keyword.

In Java, a child class uses 'extends' to inherit from a parent class. Example: class Animal { void eat() { System.out.println("Eating"); } } class Dog extends Animal { void bark() { System.out.println("Barking"); } } Dog myDog = new Dog(); myDog.eat(); // inherited method myDog.bark(); // child class method

Result

The Dog object can both eat (inherited) and bark (its own method).

Knowing the 'extends' keyword is the key to creating child classes that reuse parent code.

3

Intermediate

Overriding Parent Methods in Child Classes

🤔Before reading on: do you think a child class can change how a parent method works by writing its own version? Commit to your answer.

Concept: Child classes can replace a parent's method with their own version to change behavior.

Method overriding means the child class writes a method with the same name and parameters as the parent, changing what it does. Example: class Animal { void sound() { System.out.println("Some sound"); } } class Cat extends Animal { @Override void sound() { System.out.println("Meow"); } } Cat myCat = new Cat(); myCat.sound(); // prints "Meow" instead of "Some sound"

Result

The Cat's sound() method replaces the parent's, so it prints "Meow".

Understanding overriding lets you customize inherited behavior without changing the parent class.

4

Intermediate

Using super to Access Parent Class Features

🤔Before reading on: do you think a child class can call the parent’s version of a method it has overridden? Commit to your answer.

Concept: The 'super' keyword lets a child class call the parent’s methods or constructors even if overridden.

When a child overrides a method but still wants to use the parent's version, it uses super.methodName(). Example: class Animal { void sound() { System.out.println("Some sound"); } } class Dog extends Animal { @Override void sound() { super.sound(); // calls parent method System.out.println("Bark"); } } Dog myDog = new Dog(); myDog.sound(); // Output: // Some sound // Bark

Result

The Dog's sound() method calls the parent's sound() first, then adds its own.

Knowing how to use super helps combine parent and child behaviors smoothly.

5

Intermediate

Constructors and Inheritance Interaction

Concept: Understand how constructors work with inheritance and how child constructors call parent constructors.

When creating a child object, the parent’s constructor runs first to set up inherited parts. Example: class Vehicle { Vehicle() { System.out.println("Vehicle created"); } } class Car extends Vehicle { Car() { super(); // calls Vehicle constructor System.out.println("Car created"); } } Car myCar = new Car(); // Output: // Vehicle created // Car created

Result

Creating a Car runs Vehicle’s constructor first, then Car’s constructor.

Understanding constructor chaining prevents bugs when initializing inherited objects.

6

Advanced

Inheritance and Access Modifiers

🤔Before reading on: do you think a child class can access all parent class members regardless of their access level? Commit to your answer.

Concept: Access modifiers (private, protected, public) control what child classes can see and use from parents.

Private members are hidden from child classes, protected members are visible to child classes and package, and public members are visible everywhere. Example: class Parent { private int secret = 1; protected int shared = 2; public int open = 3; } class Child extends Parent { void show() { // System.out.println(secret); // Error: private System.out.println(shared); // OK System.out.println(open); // OK } }

Result

Child can access protected and public members but not private ones.

Knowing access rules helps design safe inheritance hierarchies and avoid accidental misuse.

7

Expert

Multiple Inheritance Limitations and Interfaces

🤔Before reading on: can Java classes inherit from more than one parent class at the same time? Commit to your answer.

Concept: Java does not allow multiple inheritance of classes but uses interfaces to achieve similar flexibility.

Java classes can only extend one parent class to avoid complexity and ambiguity. Instead, Java uses interfaces to let classes promise to provide certain methods. Example: interface Flyer { void fly(); } interface Swimmer { void swim(); } class Duck implements Flyer, Swimmer { public void fly() { System.out.println("Flying"); } public void swim() { System.out.println("Swimming"); } } Duck d = new Duck(); d.fly(); d.swim();

Result

Duck can do both fly and swim by implementing multiple interfaces, even though it extends only one class.

Understanding Java’s design choice avoids confusion and shows how interfaces provide flexible behavior sharing.

Under the Hood

When a child class is created, the Java runtime sets up an object that contains all fields and methods from the parent class plus any new ones from the child. Method calls first look in the child class; if not found, they go up to the parent class. This lookup is done at runtime using a method table (vtable) for efficiency. Constructors run in order from parent to child to ensure proper setup.

Why designed this way?

Java was designed to avoid the complexity and errors caused by multiple inheritance of classes, which can create conflicts. Instead, it uses single inheritance with interfaces to keep the system simpler and safer. This design balances code reuse with clarity and maintainability.

┌───────────────┐
│   Parent      │
│ ┌───────────┐ │
│ │ Fields    │ │
│ │ Methods   │ │
│ └───────────┘ │
└─────┬─────────┘
      │ extends
┌─────▼─────────┐
│   Child       │
│ ┌───────────┐ │
│ │ Fields    │ │
│ │ Methods   │ │
│ └───────────┘ │
└───────────────┘

Method call → check Child methods → if missing, check Parent methods

Myth Busters - 4 Common Misconceptions

Quick: Does a child class automatically copy all private fields from its parent? Commit to yes or no.

Common Belief: A child class inherits all fields and methods from the parent, including private ones.

Reality: Private fields and methods are not accessible or inherited by child classes; they are hidden and only usable inside the parent class.

Why it matters: Assuming private members are inherited can cause errors when trying to access or override them, leading to confusion and bugs.

Quick: Can a child class override a parent's static method? Commit to yes or no.

Common Belief: Child classes can override any method from the parent, including static methods.

Reality: Static methods belong to the class, not instances, so child classes cannot override them; they can only hide them, which behaves differently.

Why it matters: Misunderstanding static method behavior can cause unexpected results and bugs in polymorphic code.

Quick: If a child class does not define a constructor, does it still call the parent's constructor? Commit to yes or no.

Common Belief: If a child class has no constructor, the parent's constructor is not called.

Reality: If no constructor is defined in the child, Java automatically calls the parent's no-argument constructor when creating a child object.

Why it matters: Not knowing this can lead to confusion about object initialization and unexpected behavior.

Quick: Can Java classes inherit from multiple classes at once? Commit to yes or no.

Common Belief: Java allows a class to inherit from multiple parent classes simultaneously.

Reality: Java does not support multiple inheritance of classes to avoid complexity; it uses interfaces instead.

Why it matters: Expecting multiple inheritance can lead to design mistakes and misunderstandings about Java’s capabilities.

Expert Zone

1

Overriding methods with covariant return types allows child classes to return more specific types, improving type safety.

2

The order of constructor calls can affect initialization, especially when parent constructors call overridden methods, which can cause subtle bugs.

3

Using 'final' on methods or classes prevents overriding or inheritance, which is a powerful tool to enforce design constraints.

When NOT to use

Avoid inheritance when classes do not share a clear 'is-a' relationship; prefer composition (has-a) to build flexible and maintainable code. Also, avoid deep inheritance hierarchies as they can become hard to understand and maintain.

Production Patterns

In real-world Java projects, inheritance is used to create base classes with common logic, while child classes add specific features. Frameworks like Spring use inheritance for configuration and behavior extension. Interfaces combined with inheritance enable flexible plugin systems and polymorphic behavior.

Connections

Polymorphism

Builds-on

Understanding inheritance is essential to grasp polymorphism, where child classes can be treated as their parent type, enabling flexible and reusable code.

Composition over Inheritance

Alternative approach

Knowing when to use composition instead of inheritance helps design cleaner systems by favoring object collaboration over rigid hierarchies.

Biological Genetics

Analogous pattern

Inheritance in programming mirrors genetic inheritance in biology, where offspring inherit traits from parents but can also have unique variations, helping to understand the concept intuitively.

Common Pitfalls

#1 Trying to access private parent fields directly in the child class.

Wrong approach:

class Parent {
private int secret = 42;
}
class Child extends Parent {
void reveal() {
System.out.println(secret); // Error: secret is private
}
}

Correct approach:

class Parent {
private int secret = 42;
int getSecret() { return secret; }
}
class Child extends Parent {
void reveal() {
System.out.println(getSecret()); // Access via method
}
}

Root cause:

Misunderstanding that private members are hidden and require accessor methods to be used by child classes.

#2 Overriding a static method expecting polymorphic behavior.

Wrong approach:

class Parent {
static void show() { System.out.println("Parent"); }
}
class Child extends Parent {
static void show() { System.out.println("Child"); }
}
Parent p = new Child();
p.show(); // Prints "Parent", not "Child"

Correct approach:

Use instance methods for polymorphism:
class Parent {
void show() { System.out.println("Parent"); }
}
class Child extends Parent {
@Override
void show() { System.out.println("Child"); }
}
Parent p = new Child();
p.show(); // Prints "Child"

Root cause:

Confusing static method hiding with instance method overriding and polymorphism.

#3 Not calling the parent constructor explicitly when needed.

Wrong approach:

class Parent {
Parent(int x) { System.out.println("Parent " + x); }
}
class Child extends Parent {
Child() {
System.out.println("Child");
}
}
Child c = new Child(); // Error: no default constructor in Parent

Correct approach:

class Parent {
Parent(int x) { System.out.println("Parent " + x); }
}
class Child extends Parent {
Child() {
super(10); // Call parent constructor
System.out.println("Child");
}
}
Child c = new Child(); // Works

Root cause:

Forgetting that if the parent has no default constructor, the child must call a parent constructor explicitly.

Key Takeaways

Parent and child classes let you reuse and extend code by creating a clear relationship between general and specific classes.

The 'extends' keyword in Java creates this inheritance, allowing child classes to use or override parent methods.

Access modifiers control what child classes can see and use from their parents, with private members hidden from children.

Java avoids multiple inheritance of classes to keep code simple, using interfaces to add flexible behavior instead.

Understanding inheritance deeply helps write cleaner, more maintainable programs and avoid common bugs related to method overriding and constructors.