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

Understanding Methods in Java

  What is a Method? In Java, a method is a block of code that performs a specific task. Methods are used to define the behavior of objects created from a class. They encapsulate code that can be reused and invoked whenever needed, making programs more modular and manageable. Defining a Method A method consists of a method declaration and a method body. The method declaration provides the method's name, return type, and parameters, while the method body contains the code to be executed. Syntax: returnType methodName (parameters) { // method body } Example: public class Example { // Method to add two numbers public int add ( int a, int b) { return a + b; } public static void main (String[] args) { Example example = new Example (); int sum = example.add( 5 , 3 ); System.out.println( "Sum: " + sum); // Output: Sum: 8 } } Method Components Access Modifiers: Define the visibility of the method (e....
Post a Comment
Read more

Configuring Static NAT for Any Network Scenario

Introduction Network Address Translation (NAT) is a fundamental technique used in networking to translate private IP addresses to public IP addresses and vice versa. Static NAT is a method where a specific private IP address is mapped to a specific public IP address.  Configuration Steps Router Configuration Enable NAT Service Router(config)# ip nat inside source static [inside-local] [inside-global] Replace [inside-local] with the private IP address to be translated. Replace [inside-global] with the public IP address to translate to. Configure Interfaces Router(config)# interface [inside-interface] Router(config-if)# ip address [inside-ip-address] [subnet-mask] Router(config-if)# ip nat inside Router(config-if)# no shutdown Router(config-if)# exit Router(config)# interface [outside-interface] Router(config-if)# ip address [outside-ip-address] [subnet-mask] Router(config-if)# ip nat outside Router(config-if)# no shutdown Router(config-if)# exit Replace [inside-interf...
Post a Comment
Read more

Understanding Access Modifier

Java Program package LAB_Report; /* 2. Write a program in Java to demonstrate the usage of access modifiers: public, private, protected and default. */ class AccessModifier{ int defaultValue ; // this is visible within the package only public int publicValue ; // this is visible everywhere protected int protectedValue ; // this is visible within the package and subclasses private int privateValue ; // this is visible within the class only public void setPrivateValue ( int privateValue) { this . privateValue = privateValue; } public int getPrivateValue () { return privateValue ; } } class AccessModifierProtected extends AccessModifier{ public void setValue ( int value2){ this . protectedValue = value2; } public int getValue2 (){ return protectedValue ; } } public class Lab_2 { public static void main (String[] args) { AccessModifier am = new AccessModifier(); ...
Post a Comment
Read more