Video summary

Java Anonymous Inner Classes Explained in 6 Minutes

Main summary

Key takeaways

Educational

Main ideas / lessons

  • Anonymous inner classes in Java sound complex, but they’re a practical way to define a class without giving it a name.
  • An anonymous inner class is a class created and instantiated at the same time in one Java statement.
  • It’s especially useful when you need:
    • A one-off subclass of an existing class (e.g., one special Animal instance like “Bigfoot”).
    • A one-off implementation of an interface (e.g., a single Runnable instance) without creating a separate .java file/class.

What an anonymous inner class is

  • Definition: “A class with no name” used to instantiate only one object ever.
  • Key property: You can’t instantiate it again later by name—because it has no class name. It’s one-time use.

How it works (core patterns)

1) Anonymous subclass of an existing class (extends a class)

Concept shown with Animal:

  • Start with a normal instantiation: java Animal myAnimal = new Animal();

  • If you want special behavior for exactly one instance (e.g., “Bigfoot” makes a different sound), you create an anonymous subclass in place: java Animal bigfoot = new Animal() { // ... };

  • Override the method inside the anonymous class (e.g., makeNoise()), providing the custom implementation (e.g., printing "growl").

Result:

  • myAnimal uses the base Animal behavior (e.g., prints "yappy yappy app").
  • bigfoot uses the overridden behavior (e.g., prints "growl"), because its type is the anonymous subclass, not plain Animal.

2) Anonymous implementation of an interface (implements an interface)

Concept shown with Runnable:

  • Normally, you’d write a separate class file implementing the interface.
  • With an anonymous inner class, you can do it inline.

Pattern:

  • The video contrasts this:

    • Runnable x = new Runnable(); → invalid because interfaces can’t be instantiated.

  • Instead, define an anonymous class that implements the interface inline.

Required method implementation:

  • For Runnable, you must implement:

    • run()

  • The example uses @Override as good practice for interface methods and overridden parent methods.

Result:

  • You obtain a single Runnable object with your custom run() logic, without creating another named class.

When to use (explicit takeaways)

Use an anonymous inner class when:

  • You need a single instance of a specialized subclass and don’t want a separate named class.
  • You need a single object implementing an interface, and you want to avoid creating an extra class file.

The “bigfoot” and “anonymous runnable” examples emphasize that the “type” of these objects is actually the unnamed anonymous subclass/implementation, even though the variable is typed as the parent (Animal or Runnable).

Speakers / sources featured

  • John — “My name’s John,” lead Java software engineer; presenter of the tutorial.

Original video