Scribd
Upload
11 views6 pages

Java Inheritance Explained with Examples

The document provides a comprehensive overview of inheritance in Java, detailing its types including single, multiple (via interfaces), and multilevel inheritance. It explains the use of the 'super' keyword, method overriding, constructor execution order, dynamic method dispatch, abstract classes, and the 'final' keyword in inheritance. Additionally, it includes code examples and outputs to illustrate these concepts effectively.

Uploaded by

sowmyasai944
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
11 views6 pages

Java Inheritance Explained with Examples

The document provides a comprehensive overview of inheritance in Java, detailing its types including single, multiple (via interfaces), and multilevel inheritance. It explains the use of the 'super' keyword, method overriding, constructor execution order, dynamic method dispatch, abstract classes, and the 'final' keyword in inheritance. Additionally, it includes code examples and outputs to illustrate these concepts effectively.

Uploaded by

sowmyasai944
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

VTU – Java Inheritance (Complete Solutions)

1. Inheritance in Java
Inheritance is a mechanism in Java by which one class (subclass/child) acquires the properties and
behaviors (fields and methods) of another class (superclass/parent). It promotes code reusability, method
overriding, and runtime polymorphism.

Syntax:

class SubClass extends SuperClass {


// members
}

Types of Inheritance

(a) Single Inheritance

One child class inherits from one parent class.

class Animal {
void eat() {
[Link]("Animal eats");
}
}

class Dog extends Animal {


void bark() {
[Link]("Dog barks");
}
}

(b) Multiple Inheritance

Java does not support multiple inheritance using classes to avoid ambiguity. It is supported using
interfaces.

interface A {
void show();
}

1
interface B {
void display();
}

class C implements A, B {
public void show() {
[Link]("Show method");
}
public void display() {
[Link]("Display method");
}
}

(c) Multilevel Inheritance

Inheritance involving more than one level.

class A {
void showA() {
[Link]("Class A");
}
}

class B extends A {
void showB() {
[Link]("Class B");
}
}

class C extends B {
void showC() {
[Link]("Class C");
}
}

2. Account, SavingsAccount and CurrentAccount

class Account {
int accountNumber;
double balance;

Account(int accNo, double bal) {

2
accountNumber = accNo;
balance = bal;
}

void display() {
[Link]("Account Number: " + accountNumber);
[Link]("Balance: " + balance);
}
}

class SavingsAccount extends Account {


SavingsAccount(int accNo, double bal) {
super(accNo, bal);
}
}

class CurrentAccount extends Account {


CurrentAccount(int accNo, double bal) {
super(accNo, bal);
}
}

class TestAccount {
public static void main(String[] args) {
SavingsAccount sa = new SavingsAccount(101, 5000);
CurrentAccount ca = new CurrentAccount(102, 10000);
[Link]();
[Link]();
}
}

3. super Keyword in Java


The super keyword refers to the immediate parent class object.

Uses:

1. Access parent class variables


2. Call parent class methods
3. Call parent class constructors

class A {
int x = 10;
}

3
class B extends A {
int x = 20;
void show() {
[Link](super.x);
}
}

4. Method Overriding and super

class Parent {
void show() {
[Link]("Parent method");
}
}

class Child extends Parent {


void show() {
[Link]();
[Link]("Child method");
}

public static void main(String[] args) {


Child obj = new Child();
[Link]();
}
}

5. Order of Constructor Execution


Constructors are executed from parent to child.

class A {
A() {
[Link]("A Constructor");
}
}

class B extends A {
B() {
[Link]("B Constructor");
}

4
}

class C extends B {
C() {
[Link]("C Constructor");
}

public static void main(String[] args) {


new C();
}
}

Output: A Constructor → B Constructor → C Constructor

6. Dynamic Method Dispatch


It is a mechanism by which a call to an overridden method is resolved at runtime.

class A {
void show() {
[Link]("Class A");
}
}

class B extends A {
void show() {
[Link]("Class B");
}
}

class Test {
public static void main(String[] args) {
A obj = new B();
[Link]();
}
}

7. Abstract Classes
An abstract class cannot be instantiated and may contain abstract methods.

5
abstract class Shape {
abstract void draw();
}

class Circle extends Shape {


void draw() {
[Link]("Drawing Circle");
}
}

8. final Keyword in Inheritance

(a) final class

Cannot be inherited.

final class A {}

(b) final method

Cannot be overridden.

class A {
final void show() {}
}

(c) final variable

Value cannot be changed.

final int x = 10;

✔ VTU-ready answers with definitions, programs, and outputs

Common questions

Powered by AI

The 'final' keyword in Java provides certain limitations in inheritance. A final class cannot be subclassed; hence, it's prevented from being extended. A final method cannot be overridden by any subclasses, which ensures that the method's behavior remains consistent across the class hierarchy. Similarly, a final variable's value cannot be modified once initialized. These constraints help enforce immutability and prevent alteration of essential features in subclasses .

Using abstract methods within an abstract class in Java obliges subclasses to implement these methods, thus enforcing a certain structure across all subclasses. This ensures that all derived classes provide implementations for the abstract methods, maintaining consistency in the expected behaviors. The abstract class acts as a blueprint providing fundamental capabilities that subclasses can expand upon, fostering a robust inheritance hierarchy design pattern, which supports flexibility while ensuring cross-class consistency .

Method overriding in Java is crucial for implementing polymorphism, allowing subclasses to provide specific implementations of methods defined in their superclass. This means that an instance of a subclass can be treated as an instance of the superclass, but will call the subclass's method. It enables dynamic method dispatch, allowing the method calls to be resolved at runtime, thus providing flexibility for code to interact with objects in a consistent yet extensible manner .

The 'super' keyword in Java refers to the immediate parent class object and is used to access the parent class's variables, invoke parent class methods, and call parent class constructors. This ensures that a child class can access and override or extend the functionality provided by the parent class without redefining it. For example, 'super.show()' would invoke the 'show' method in a parent class even if it's overridden in the child class .

In Java, constructor execution order in inheritance hierarchy begins from the parent class down to the child class. This ensures that any initializations required by the ancestral classes are completed before constructing the child class. This process underscores the principle that each derived class is founded on a fully initialized base class, thus ensuring stability and consistency in the object-oriented model of software design .

Abstract classes in Java are classes that cannot be instantiated on their own and are designed to be subclassed. They may contain abstract methods, which are methods declared without an implementation, requiring subclasses to provide concrete implementations. This design enforces a contract for subclasses, ensuring they provide specific behaviors, thereby supporting a common framework for related classes while leaving specific implementations to be defined by subclasses .

Dynamic method dispatch in Java is a mechanism where the call to an overridden method is determined at runtime instead of compile-time. When a superclass reference variable holds a subclass object, the overriding method in the subclass is called. This facilitates run-time polymorphism, providing the flexibility to execute the appropriate method according to the actual object’s class, enhancing the system's flexibility and scalability in dealing with different class variations .

Inheritance in Java allows a subclass to acquire properties and behaviors from a superclass, which promotes code reusability and an organized class structure. It supports method overriding where a subclass can provide a specific implementation of a method already defined in its parent class. This enables runtime polymorphism, allowing the program to decide at runtime which method implementation to execute, thus enhancing flexibility and maintainability .

Single inheritance in Java involves a subclass inheriting the properties and behaviors from one superclass, while multilevel inheritance entails a chain of inheritance where a class is derived from another derived class. For example, in single inheritance, 'class Dog extends Animal' inherits directly from Animal. In contrast, multilevel inheritance could resemble 'class C extends B extends A,' where C inherits from B, which in turn inherits from A, creating a multi-tier inheritance structure .

Java does not support multiple inheritance through classes to prevent ambiguity; however, it achieves multiple inheritance using interfaces. An interface in Java can be implemented by any class, and a class can implement multiple interfaces, thereby inheriting behaviors from multiple sources. This approach avoids the diamond problem associated with multiple class inheritance, providing a safer alternative where method conflicts are explicitly resolved by implementing classes .

You might also like