Can You Instantiate an Abstract Class in Java?

Instantiation of Abstract Classes

In an interview scenario, the question of whether we can instantiate an abstract class may arise. Traditionally, the answer is that we cannot instantiate abstract classes, as they represent concepts or incomplete definitions. However, a recent interview anecdote challenges this notion.

The Interview Puzzle

During an interview, the candidate was asked if it was possible to instantiate an abstract class. The initial response was "No," but the interviewer countered with a demonstration. The following code was presented:

abstract class My {
    public void myMethod() {
        System.out.print("Abstract");
    }
}

class Poly {
    public static void main(String[] a) {
        My m = new My() {};
        m.myMethod();
    }
}

Anonymous Subclasses

The key to the puzzle lies in the instantiation line:

My m = new My() {};

Here, we are not directly creating an instance of the abstract class My. Instead, we are creating an instance of an anonymous subclass of My. An anonymous subclass is an unnamed subclass that is created on-the-fly by the compiler. This anonymous subclass implements the abstract method myMethod().

Object Creation Process

To understand this behavior, let's refer to the Java Language Specification (JLS). Section 12.5 describes the object creation process. When a new object is created, memory is allocated for instance variables in the object and all its superclasses. Before returning the object reference, the constructor is processed to initialize the object.

Compilation Evidence

To further demonstrate the existence of the anonymous subclass, we can compile the code. The following class files will be generated:

• My.class
• Poly$1.class (anonymous subclass)
• Poly.class

The anonymous subclass class file (Poly$1.class) is evidence that we are creating an instance of a subclass, not the abstract class itself.

Conclusion

While it may seem counterintuitive, we can instantiate abstract classes by creating anonymous subclasses. This behavior is enabled by the Java Virtual Machine (JVM), which allows for the creation of anonymous subclasses on the fly. However, it's important to remember that the object we create is still an instance of the anonymous subclass, not the abstract class directly.

The above is the detailed content of Can You Instantiate an Abstract Class in Java?. For more information, please follow other related articles on the PHP Chinese website!