Skip to main content

Understanding Inheritance in Java

 


Inheritance is one of the fundamental concepts of Object-Oriented Programming (OOP) in Java. It allows a new class (child or subclass) to inherit the properties and behaviors (fields and methods) of an existing class (parent or superclass). This promotes code reuse and establishes a natural hierarchical relationship between classes.

Types of Inheritance in Java

  1. Single Inheritance: A class inherits from one superclass.
  2. Multilevel Inheritance: A class inherits from another class, which in turn inherits from another class.
  3. Hierarchical Inheritance: Multiple classes inherit from one superclass.

    Note: Java does not support multiple inheritance (a class inheriting from more than one class) directly to avoid complexity and ambiguity. However, it can be achieved using interfaces.

Examples of Inheritance

Single Inheritance

In single inheritance, a class inherits from one superclass.

// Parent class
class Vehicle {
    String brand = "Ford";

    void honk() {
        System.out.println("Beep! Beep!");
    }
}

// Child class
class Car extends Vehicle {
    String model = "Mustang";

    void display() {
        System.out.println("Brand: " + brand + ", Model: " + model);
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.honk();        // Output: Beep! Beep!
        car.display();     // Output: Brand: Ford, Model: Mustang
    }
}

Multilevel Inheritance

In multilevel inheritance, a class inherits from another class, which in turn inherits from another class.

Example:

// Base class
class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

// Derived class
class Dog extends Animal {
    void bark() {
        System.out.println("Barking...");
    }
}

// Further derived class
class Puppy extends Dog {
    void weep() {
        System.out.println("Weeping...");
    }

    public static void main(String[] args) {
        Puppy puppy = new Puppy();
        puppy.eat();    // Output: Eating...
        puppy.bark();   // Output: Barking...
        puppy.weep();   // Output: Weeping...
    }
}

Hierarchical Inheritance

In hierarchical inheritance, multiple classes inherit from one superclass.

Example:

// Superclass
class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

// Subclass 1
class Dog extends Animal {
    void bark() {
        System.out.println("Barking...");
    }
}

// Subclass 2
class Cat extends Animal {
    void meow() {
        System.out.println("Meowing...");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();

        dog.eat();   // Output: Eating...
        dog.bark();  // Output: Barking...

        cat.eat();   // Output: Eating...
        cat.meow();  // Output: Meowing...
    }
}

Method Overriding in Inheritance

Method overriding occurs when a subclass provides a specific implementation for a method already defined in its superclass. The subclass method should have the same name, return type, and parameters.

Example:

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }

    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.sound();  // Output: Dog barks
    }
}

The super Keyword

The super keyword in Java is used to refer to the immediate parent class object. It can be used to access parent class methods, constructors, and fields.

Example:

class Animal {
    String color = "white";

    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    String color = "black";

    void displayColor() {
        System.out.println("Dog color: " + color);         // Output: black
        System.out.println("Animal color: " + super.color); // Output: white
    }

    @Override
    void eat() {
        super.eat(); // Calling parent class method
        System.out.println("Dog is eating");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.displayColor();
        dog.eat();
        // Output:
        // Animal is eating
        // Dog is eating
    }
}

Constructor Chaining

Constructor chaining refers to the process of calling one constructor from another constructor using the this() or super() keywords.

Example:

class Animal {
    Animal() {
        System.out.println("Animal is created");
    }
}

class Dog extends Animal {
    Dog() {
        super(); // Calls the parent class constructor
        System.out.println("Dog is created");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        // Output:
        // Animal is created
        // Dog is created
    }
}
Labels:

Comments

Post a Comment

Popular posts from this blog

Java Variables and Data Types

   Variables in Java Variables are the containers to store the data values in the memory.  Variables are naming entities and must follow naming conventions. These rules typically include starting with a letter or underscore, using letters, numbers, or underscores (no spaces or special characters), avoiding reserved keywords, and using naming conventions such as CamelCase or snake_case for readability. These conventions help keep the code organized and understandable.                         Syntax:                                   data_type      variable_name;                                   data_type     variable_name     =     value;       ...
Post a Comment
Read more

String Function

  package StringLearning; class Display { public static void print (String s) { System. out .println(s); } } public class StringFunc { public static void main (String[] args) { String s = "Java Programming" ; // Display original string Display. print (s); // Converts all characters to lower case Display. print ( "LowerCase: " + s.toLowerCase()); // Converts all characters to upper case Display. print ( "UpperCase: " + s.toUpperCase()); // Concatenates the specified string to the end of the original string Display. print ( "Concatenation: " + s.concat( " is easy." )); // Replaces each occurrence of a character with a new character Display. print ( "Replace 'a' with 'b': " + s.replace( 'a' , 'b' )); // Replaces each occurrence of a substring with a new substring Displ...
Post a Comment
Read more

How to write and run Hello world program in Java?

 QuickStart Every program must begin with the class name,  and the class must match the filename. Hello world program In above program, First class is created and file is saved as First.java same as class name.              Now, to run the program First.java, we need to compile it and it will run     To compile the java file, open cmd and locate the java file.     Type: javac filename.java     This will compile the java file and class file will be created  Now to run the java file. Type: java filename We can write java code in IDE  such as VS code, Intellj Idea, to write and run the program.
Post a Comment
Read more