Difference between early binding and late binding in Java

In object-oriented programming, a method that connects a strategy call to its execution. Java is an object-oriented programming language that supports early authority and late authority, known as inactive authority and active authority respectively. Both forms of binding have advantages and applications. In this article we will introduce the syntax, explanation, and differences between early binding and late binding in Java.

grammar

The syntax of early binding in Java is as follows.

<ClassName> <objectName> = new <ClassName>();

The syntax of late binding in Java is as follows.

<ClassName> <objectName> = new <DerivedClassName>();

Glossary explanation

The type of the class is determined at compile time during early binding, and the implementation of the method is selected based on the specified type of the object. This means that the compiler knows the specific class of the object and can tie method calls directly to method implementations.

Late binding, on the other hand, determines the class type at runtime and selects method implementations based on the actual type of the object. This indicates that the compiler does not know the precise class of the object and must rely on the runtime environment to find the correct method implementation.

Method 1: Early Binding

In early binding, method calls are resolved at compile time. Let us consider the following early binding algorithm -

• Declare a class named Shape and use a method named draw().

• Create a subclass named Circle to extend the Shape class.

• Implement the draw() method in the Circle class.

• Use early binding to create an object of Circle class.

• Call the draw() method of the object.

Example

class Shape {
   public void draw() {
      System.out.println("Drawing a shape");
   }
}

class Circle extends Shape {
   @Override
   public void draw() {
      System.out.println("Drawing a circle");
   }
}

public class Main {
   public static void main(String[] args) {
      Shape shape = new Circle();
      shape.draw();
   }
}

Output

Drawing a circle

Code description in method 1

We have a Shape class with a draw() function which prints "draw shape" in this code. We also have a Circle class which extends the Shape class and overrides the draw() function to output "draw a circle". In the Main class, we created an object of Circle class using early binding by declaring it as a Shape type. When we call the draw() function of a shape object, the result will be "draw a circle". This is because the method call is tied to the implementation of the Circle class at build time.

Method 2: Late binding

In late binding, method calls are resolved at runtime. Let us consider the following late binding algorithm -

• Declare a class named Animal and use a method named makeSound().

• Create two subclasses named Dog and Cat to extend the Animal class.

• Implement the makeSound() method in the Dog and Cat classes.

• Use late binding to create an object of Dog class.

• Call the makeSound() method of the object.

Example

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

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

class Cat extends Animal {
   @Override
   public void makeSound() {
      System.out.println("Cat meows");
   }
}

public class Main {
   public static void main(String[] args) {
      Animal animal = new Dog();
      animal.makeSound();
   }
}

Output

Dog barks

Code description in method 2

In this code, we have an Animal class, which has a makeSound() method that prints "Animal gets a sound". We also have two subclasses, Dog and Cat, which extend the Animal class and override the makeSound() method to print "Dog barks" and "Cat meows" respectively. In the Main class, we created an object of Dog class using late binding and declared it as Animal type. When we call the makeSound() method on the animal object, the output will be "Dog barks". This is because the method call is bound to the implementation of the Dog class at runtime based on the actual type of the object.

The difference between early binding and late binding in Java

Differences	Early Binding	Late Binding
Parse time	Compilation time	Runtime
Method implementation	Determined based on the declared type of the object	Determine based on the actual type of the object
flexibility	Limited flexibility in dynamically changing method implementation	Provides flexibility through dynamic method dispatch and polymorphism
performance	Faster performance since method calls are parsed at compile time	Performance is slightly slower since method calls are parsed at runtime
Object declaration	Object declaration uses class type	Object declaration uses derived class type

in conclusion

Early binding and late binding are two important concepts in Java, which determine how to parse method calls. Late binding resolves method calls based on the actual type of the object at runtime, while early binding links method calls to its implementation at compile time. Each method has its own unique advantages and uses. Although early binding provides better performance because method calls are resolved at compile time, it does not allow dynamic changes to method implementations. Late binding, on the other hand, allows dynamic method dispatching, enabling polymorphism and flexibility in method invocations. Understanding the difference between early binding and late binding is crucial to writing efficient and flexible Java programs.

The above is the detailed content of Difference between early binding and late binding in Java. For more information, please follow other related articles on the PHP Chinese website!