Mastering Java Inheritance with a Vehicles Example in Java

Note: This article is AI generated.

1. Introduction ……………………………………. Page 1
2. Understanding Inheritance in Java ………………….. Page 3
    2.1 Object-Oriented Concepts and Inheritance Basics
    2.2 Pros and Cons of Inheritance
3. The Vehicles Hierarchy …………………………….. Page 7
    3.1 Overview of the Base Vehicle Class
    3.2 Derived Classes: Truck, Car, and Bike
    3.3 Comparison Table: Unique & Common Features
4. Code Walkthrough and Explanation ………………….. Page 11
    4.1 Inheriting from the Vehicle Class
    4.2 Detailed Code Example with Explanations
    4.3 Expected Output
5. Conclusion and Further Reading ……………………. Page 17

1. INTRODUCTION

Inheritance is a cornerstone of object-oriented programming (OOP) in Java. It allows developers to create a new class (subclass) that reuses, extends, and modifies the behavior defined in another class (superclass). In this guide, we walk through implementing inheritance using a real-world example based on vehicles—illustrating how common properties can be reused and how specialized characteristics can be introduced.

Key points that will be addressed:
• An overview of the main concepts of Java inheritance
• Understanding the vehicle class hierarchy
• Practical demonstration through code snippet examples
• Comparison of properties across vehicle types (Car, Truck, Bike)

Below is a tabular representation for a quick glance at key data ranges and attributes across different vehicle types:

Comparison Table: Vehicle Features

Feature	Vehicle (Base)	Car	Truck	Bike
Engine	Yes	Yes	Yes	Yes (if public)
Wheel	Yes	Yes	Yes	Yes
Seat	Yes	Yes	Yes	N/A
Fuel Tank	Yes	Yes	Yes	N/A
Lights	Yes	Yes	Yes	N/A
Steering	N/A	Yes	Yes	No
Music System	N/A	Yes	Optional	No
Air Conditioner	N/A	Yes	Optional	N/A
Entertainment	N/A	Yes	N/A	N/A
Additional	N/A	Fridge (*)	Container	Handle

(*) A car might offer a mini-fridge in some advanced configurations.

When to use inheritance?
• Organize common attributes and behaviors once in a parent class.
• Extend or override functionality in child classes based on specific requirements.
• Improve code reusability and maintainability across similar types of objects.

2. UNDERSTANDING INHERITANCE IN JAVA

2.1 Object-Oriented Concepts and Inheritance Basics

Inheritance enables one class to acquire the properties and methods of another. In our example, the Vehicle class defines common attributes such as engine, wheel, seats, fuel tank, and lights that are shared among all vehicle types.

2.2 Pros and Cons of Inheritance

Pros:
– Code reuse and organization
– Simplified maintenance
– Logical grouping of shared behaviors

Cons:
– Can lead to tightly coupled code if not managed carefully
– Overuse may result in a complex class hierarchy

3. THE VEHICLES HIERARCHY

3.1 Overview of the Base Vehicle Class

The Vehicle class acts as the parent class. It includes the default properties that every vehicle should have (e.g., engine type, wheel). All extended classes—Truck, Car, and Bike—automatically obtain these properties.

3.2 Derived Classes: Truck, Car, and Bike

• Truck and Car classes inherit from the Vehicle class and add or modify their own attributes, such as container for trucks and entertainment systems for cars.
• The Bike class, despite being a simpler form, also extends Vehicle so it can access essential properties (e.g., the engine) while introducing its unique attribute: the handle.

3.3 Visual Diagram of the Vehicle Inheritance Hierarchy

              Vehicle (Base Class)
                     │
     ┌─────────────┼─────────────┐
     │             │             │
   Truck          Car           Bike
(Unique: Container,   (Unique: Entertainment,
  Power Steering)      Air Conditioner)
                    (Unique: Handle, Limited functionalities; no steering)

Vehicle (Base Class)

│

┌─────────────┼─────────────┐

│ │ │

Truck Car Bike

(Unique: Container, (Unique: Entertainment,

Power Steering) Air Conditioner)

(Unique: Handle, Limited functionalities; no steering)

4. CODE WALKTHROUGH AND EXPLANATION

4.1 Inheriting from the Vehicle Class

Below is an example that depicts how the Bike class extends the common properties of the Vehicle class. Notice that initially the Bike class had its handle variable declared as private. It was then changed to public to enable direct access as inherited in our demonstration.

4.2 Detailed Code Example with Explanations

// File: Bike.java
package org.studyeasy.vehicles;

// Bike class extends Vehicle to inherit common properties like engine, wheels, and fuel tank.
public class Bike extends Vehicle {  
    // Changed from private to public to allow direct access
    public String handle;
    
    // Constructor initializes the Bike-specific property
    public Bike() {
        this.handle = "Short Handle";  // Initializing the handle property
    }
    
    // Optionally, you could have additional methods specific to Bike
}

// Assume that Vehicle.java looks similar to the following:

package org.studyeasy.vehicles;

public class Vehicle {
    // Public properties for simplicity; typically, these would be private with accessor methods.
    public String engine;
    public int wheels;
    public String fuelTank;
    public String lights;
    
    // Constructor initializing default values
    public Vehicle() {
        this.engine = "petrol";   // Default engine type is petrol
        this.wheels = 4;          // Default number of wheels (for a generic vehicle)
        this.fuelTank = "Standard Tank";
        this.lights = "LED Lights";
    }
}

// File: Bike.java

package org.studyeasy.vehicles;

// Bike class extends Vehicle to inherit common properties like engine, wheels, and fuel tank.

public class Bike extends Vehicle {

// Changed from private to public to allow direct access

public String handle;

// Constructor initializes the Bike-specific property

public Bike() {

this.handle = "Short Handle"; // Initializing the handle property

}

// Optionally, you could have additional methods specific to Bike

}

// Assume that Vehicle.java looks similar to the following:

package org.studyeasy.vehicles;

public class Vehicle {

// Public properties for simplicity; typically, these would be private with accessor methods.

public String engine;

public int wheels;

public String fuelTank;

public String lights;

// Constructor initializing default values

public Vehicle() {

this.engine = "petrol"; // Default engine type is petrol

this.wheels = 4; // Default number of wheels (for a generic vehicle)

this.fuelTank = "Standard Tank";

this.lights = "LED Lights";

}

4.3 Step-by-Step Code Explanation and Expected Output

Step 1: Object Creation
• A Bike object is instantiated using:
Bike bike = new Bike();

Step 2: Accessing Properties
• The Bike class automatically inherits public properties from Vehicle.
    System.out.println(bike.handle);
    → Outputs: “Short Handle”
• Accessing the inherited engine property (if the property in Vehicle is public):
    System.out.println(bike.engine);
    → Outputs: “petrol”

Explanation:
– The Bike class demonstrates the concept of “extends,” where it inherits properties from the Vehicle class.
– By converting the handle property from private to public, we ensure that it can be used wherever a Bike instance is referenced.
– The output confirms that Bike not only carries its specific property (handle) but also accesses inherited properties like engine.

5. CONCLUSION AND FURTHER READING

In summary, Java inheritance simplifies code structure by allowing common properties and behaviors to be defined in a base class and then reused or extended by derived classes. Using the vehicle example, we saw how the Bike class extends the Vehicle class to inherit properties such as engine attributes and also defines its unique attributes like handle. This model is applicable to many real-world programming scenarios, especially when creating a hierarchy of related objects.

Key takeaways:
– Inheritance promotes code reuse and logical organization.
– Modifying property access (using public, protected, or private) plays a crucial role in inheritance and encapsulation.
– A structured class hierarchy simplifies maintenance and extends functionality as needed.

For beginners and developers with basic Java knowledge, exploring inheritance through practical examples like vehicles can significantly reinforce core OOP principles.

Thank you for reading this eBook-style article. We hope it provides you with a clear and concise understanding of inheritance in Java. Happy coding!

S06L09 – Inheritance 02 – Inheritance in Java