Scribd
Upload
14 views9 pages

Dynamic Method Dispatch in Java

java

Uploaded by

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

Dynamic Method Dispatch in Java

java

Uploaded by

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

Dynamic Method Dispatch in Java is a runtime polymorphism mechanism that

determines which version of an overridden method will be executed at


runtime, not at compile time.

🔹 Key Idea:

 When a parent class reference variable points to a child class object,


and if the method is overridden, then the child class version of the
method is called at runtime.
 This decision happens dynamically (hence the name).

🔹 Example Code:

class Animal {
void sound() {
[Link]("Animal makes a sound");
}
}

class Dog extends Animal {


@Override
void sound() {
[Link]("Dog barks");
}
}

class Cat extends Animal {


@Override
void sound() {
[Link]("Cat meows");
}
}

public class DynamicDispatchDemo {


public static void main(String[] args) {
Animal a; // reference variable of parent class

a = new Dog(); // parent reference -> child object


[Link](); // calls Dog's version
a = new Cat(); // parent reference -> another child object
[Link](); // calls Cat's version
}
}

🔹 Output:

Dog barks
Cat meows

🔹 Important Points:

1. Works only with overridden methods, not with variables (variables are
resolved at compile time).
2. The method call is resolved at runtime depending on the actual object.
3. Enables polymorphism → "one interface, multiple implementations".

4.

What is an Abstract Class in Java?

 An abstract class in Java is a class that is declared with the abstract


keyword.
 It cannot be instantiated (you cannot create objects directly from it).
 It may contain abstract methods (methods without a body) and concrete
methods (methods with implementation).
 It is mainly used to provide a base class that other classes can extend and
implement according to their needs.
🔹 Syntax:
abstract class ClassName {
// abstract method (no body)
abstract void method1();

// concrete method (has body)


void method2() {
[Link]("This is a concrete method");
}
}

🔹 Example:
// Abstract Class
abstract class Animal {
// Abstract method (no implementation)
abstract void sound();

// Concrete method
void sleep() {
[Link]("Sleeping...");
}
}

// Child class Dog


class Dog extends Animal {
@Override
void sound() {
[Link]("Dog barks");
}
}

// Child class Cat


class Cat extends Animal {
@Override
void sound() {
[Link]("Cat meows");
}
}

// Main class
public class AbstractDemo {
public static void main(String[] args) {
Animal a; // reference variable of abstract class

a = new Dog(); // parent reference, child object


[Link](); // calls Dog’s implementation
[Link]();

a = new Cat();
[Link](); // calls Cat’s implementation
[Link]();
}
}

🔹 Output:
Dog barks
Sleeping...
Cat meows
Sleeping...

🔹 Key Points to Remember:

1. Abstract class cannot be instantiated directly.


2. It can have abstract methods and concrete methods.
3. Subclasses must implement all abstract methods of the abstract class
(unless they are also abstract).
4. Abstract class can have constructors, variables, and normal methods.
5. It is mainly used when you want to enforce certain common methods
in child classes.

✅ In short:
An abstract class provides a template for subclasses, enforcing them to define
their own version of certain methods.
The final keyword with inheritance in Java is very important for understanding
restrictions in OOP. Let’s break it down:

🔹 1. final Keyword in Java

The final keyword can be used with:

1. Variables → makes them constants (value cannot be changed).


2. Methods → prevents method overriding.
3. Classes → prevents inheritance (class cannot be extended).

🔹 2. final with Inheritance

(a) Final Class

 If a class is declared as final, it cannot be extended (no child classes).


 Example:

final class Vehicle {


void run() {
[Link]("Vehicle is running");
}
}

// ❌ Error: Cannot inherit from final Vehicle


class Car extends Vehicle {
void run() {
[Link]("Car is running");
}
}

👉 Output: Compilation Error (cannot inherit from final Vehicle)

(b) Final Method

 If a method is declared final in a parent class, it cannot be overridden in a child


class.
 Example:

class Vehicle {
final void run() { // final method
[Link]("Vehicle is running");
}
}

class Car extends Vehicle {


// ❌ Error: Cannot override final method
void run() {
[Link]("Car is running");
}
}

👉 Output: Compilation Error (run() in Car cannot override run() in Vehicle)

(c) Final Variable

 If a variable is declared final, its value cannot be modified once assigned.


 Example:

class Vehicle {
final int speed = 100;

void display() {
// ❌ Error: Cannot assign a value to final variable
// speed = 200;
[Link]("Speed = " + speed);
}
}

👉 Output: Prints

Speed = 100

🔹 3. Key Points

 final class → No inheritance allowed.


 final method → No overriding allowed.
 final variable → Acts as a constant.
 final increases security and stability of the code (useful in core library classes like
String, Math which are final).
Passing and Returning Objects in Java

In Java, objects are always passed by reference (actually, the reference value is passed
by value).
This means when you pass an object to a method, you are passing the reference to that object,
not a copy of the object itself.

✅ 1. Passing an Object as a Parameter

You can pass objects of a class as arguments to methods.


The method can then access or modify the fields of that object.

Example: Passing Object

class Student {
String name;
int age;

Student(String n, int a) {
name = n;
age = a;
}

void display() {
[Link]("Name: " + name + ", Age: " + age);
}
}

class Main {
// Method that accepts an object as parameter
static void printStudent(Student s) {
[Link]("Student Details -> Name: " + [Link] + ", Age: "
+ [Link]);
}

public static void main(String[] args) {


Student st = new Student("Arun", 20);
// Passing object to method
printStudent(st);
}
}

✅ 2. Returning an Object from a Method

A method can also return an object reference.

Example: Returning Object

class Calculator {
int num;

Calculator(int n) {
num = n;
}

// Method returning an object


Calculator square() {
return new Calculator(num * num);
}
}

class Main {
public static void main(String[] args) {
Calculator c1 = new Calculator(5);

// Getting new object returned by method


Calculator c2 = [Link]();

[Link]("Original: " + [Link]);


[Link]("Square: " + [Link]);
}
}

✅ 3. Passing and Returning Together

Sometimes we pass an object to a method, and the method modifies or returns a new object.

Example:

class Box {
int length;

Box(int l) {
length = l;
}

// Method accepts object and returns new object


Box enlarge(Box b) {
return new Box([Link] * 2);
}
}

class Main {
public static void main(String[] args) {
Box b1 = new Box(10);

// Passing object and getting returned object


Box b2 = [Link](b1);

[Link]("Original Length: " + [Link]);


[Link]("Enlarged Length: " + [Link]);
}
}

⚡ Key Points to Remember

 Java does not pass objects themselves, it passes the reference (memory address).
 If you modify the object inside the method, the changes reflect outside.
 Methods can return objects, which is very useful in factory methods, cloning, and
method chaining.

Common questions

Powered by AI

Method overriding in Java enables dynamic method dispatch, allowing the runtime to resolve calls to overridden methods in subclasses, which facilitates polymorphism. However, declaring a method as 'final' avoids overriding, thus disabling dynamic dispatch for that method since the method's implementation is locked at the superclass level. This ensures critical methods remain unchanged, enhancing program reliability, albeit at the cost of flexibility traditionally provided by polymorphism .

Dynamic method dispatch in Java is a runtime mechanism that determines which version of an overridden method will be executed. This decision occurs at runtime and not at compile time. When a parent class reference points to a child class object, the method overridden in the child class gets called, enabling polymorphism. This allows for 'one interface, multiple implementations', as different child objects can provide different implementations for the same method interface defined in the parent .

The 'final' keyword in Java restricts certain OOP capabilities. A final class cannot be extended, thus preventing inheritance and creating closed hierarchies. A final method cannot be overridden, restricting polymorphism by preventing dynamic method dispatch for that method. Final variables are constants, ensuring their values remain unchanged. By using 'final', developers can increase code security and stability, especially in core library classes like String and Math .

In Java, objects are passed by reference, not by copying the actual object. This means methods receive and can modify the object directly. For instance, when you pass an object as a method parameter, you are passing the reference to that object. Methods can also return object references, enabling object creation and modification to be handled within methods. An example is the 'Calculator' class where an instance method squares a number and returns a new 'Calculator' object with the new value .

Yes, an abstract class in Java can have a constructor. The purpose of this constructor is not to instantiate the abstract class itself—since that's prohibited—but to allow an initialization phase for instance variables or to perform setup tasks when a subclass instance is created. When a constructor in a subclass is invoked, it implicitly calls the constructor of its abstract superclass, ensuring that the base class's setup logic is executed .

Understanding Java's model of passing object references by value is essential to ensure correct object manipulation across method calls. This allows changes to the object within methods to be reflected outside, potentially affecting program state if not properly managed. When designing methods, developers must account for object mutability and side-effects, ensuring methods don't inadvertently alter the objects they receive or prematurely expose internal states by returning mutable objects .

Dynamic method dispatch allows Java applications to use references of a superclass type to interact with objects of various subclass types, enabling polymorphism. This abstraction layer allows for writing flexible and scalable code as system behaviors can be modified or extended by simply overriding methods in subclasses without changing existing code, thus supporting the open/closed principle. This design is crucial in building frameworks and libraries, where the specific subclass to use is decided at runtime, promoting loose coupling and adherence to design patterns like the Strategy pattern .

In Java, method overriding is crucial for implementing abstract methods and employing dynamic method dispatch. An abstract class can define abstract methods, which must be overridden by subclasses, providing specific implementations. Dynamic method dispatch leverages this structure: a reference of the abstract class type pointing to subclass objects resolves method calls to the subclass's overridden version at runtime. This binding enables polymorphic behavior, allowing programs to invoke methods on objects of many types through a single interface .

Abstract classes in Java can include both abstract methods (without body) and concrete methods (with implementation), and they offer a template for subclasses to implement. In contrast, interfaces can only declare methods (with Java 8 and later allowing default and static methods with bodies). Abstract classes allow shared code and fields between classes, while interfaces provide a means to achieve multiple inheritance since a class can implement multiple interfaces but can only extend one class. This makes interfaces ideal for defining capabilities that can be added to any class .

The 'final' keyword enhances Java applications' security and stability by preventing modification of variables, methods, and classes. Final variables are constants, ensuring their values are not altered after assignment, which aids in preventing accidental changes and potential security breaches. Final methods cannot be overridden, protecting the integrity of core method logic from being changed by subclasses. Final classes cannot be subclassed, creating sealed hierarchies that prevent extensions, thus limiting potential areas where errors could propagate or security might be compromised .

You might also like