Why interfaces are used in Java - Visual Breakdown

Concept Flow - Why interfaces are used

Define Interface

↓

Implement Interface in Classes

↓

Use Interface Type to Refer Objects

↓

Call Methods via Interface

↓

Achieve Polymorphism & Flexibility

↓

Easier Code Maintenance & Extensibility

Interfaces define a contract. Classes implement it. Code uses interface types to work with any implementing class, enabling flexible and maintainable design.

Execution Sample

Java

interface Animal {
    void sound();
}
class Dog implements Animal {
    public void sound() { System.out.println("Bark"); }
}
class Cat implements Animal {
    public void sound() { System.out.println("Meow"); }
}
public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.sound();
        a = new Cat();
        a.sound();
    }
}

This code shows how an interface Animal is used to refer to different animal objects and call their sound method.

Execution Table

Step	Action	Variable	Value	Output
1	Create Dog object and assign to Animal reference	a	Dog instance
2	Call sound() on a (Dog)	a.sound()		Bark
3	Assign Cat object to Animal reference a	a	Cat instance
4	Call sound() on a (Cat)	a.sound()		Meow
5	End of main method

💡 Program ends after calling sound() on Dog and Cat objects via Animal interface reference.

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
a	null	Dog instance	Cat instance	Cat instance

Key Moments - 3 Insights

Why can the variable 'a' hold objects of both Dog and Cat?

Because 'a' is declared as type Animal (the interface), it can refer to any object of classes that implement Animal, as shown in execution_table steps 1 and 3.

Why does calling a.sound() produce different outputs?

The actual method called depends on the object's class that 'a' refers to at runtime (Dog or Cat), demonstrating polymorphism (see execution_table steps 2 and 4).

Why use an interface instead of concrete classes directly?

Using the interface type allows writing flexible code that can work with any future classes implementing Animal without changing existing code, improving maintainability.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of variable 'a' after step 3?

A Cat instance

B Dog instance

C null

D Animal instance

💡 Hint

Check the 'Variable' and 'Value' columns at step 3 in execution_table.

At which step does the program output "Meow"?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Output' column in execution_table for the "Meow" output.

If we add a new class Bird implementing Animal, how would the variable 'a' behave?

A It must be changed to Bird type

B It can refer to Bird objects as well

C It cannot refer to Bird objects

D It will cause a compile error

💡 Hint

Refer to key_moments about interface flexibility and variable 'a' type.

Concept Snapshot

Interfaces define method contracts without implementation.
Classes implement interfaces to provide behavior.
Variables of interface type can hold any implementing class object.
This enables polymorphism and flexible, maintainable code.
Use interfaces to write code that works with many types interchangeably.

Full Transcript

Interfaces in Java are used to define a set of methods that classes must implement. This allows different classes to be treated the same way through the interface type. In the example, the interface Animal has a method sound(). Classes Dog and Cat implement Animal and provide their own sound() method. In the main method, a variable 'a' of type Animal is assigned a Dog object, then a Cat object. Calling a.sound() calls the correct method depending on the actual object. This shows polymorphism. Using interfaces allows writing flexible code that can work with any class implementing the interface, making code easier to maintain and extend.