Question

I came across the expression ‘subclasses of the containing class’ when I read a paper. What does that containing class mean in Java? This is the excerpt from the paper.

Primarily, this entailed three things: (i) studying the implementation of the entity, as well as its usage, to reason about the intent behind the functionality; (ii) performing static dependency analysis on the entity, and any other types, methods, or fields referenced by it, including constants; and (iii) examining the inheritance hierarchy and subclasses of the containing class. This approach took considerable time and effort to apply.

Answer 1

This example has a subclass of the containing class:

class Parent {
    class Child {
    }
}

class ParentSubclass extends Parent {
    void whatever() {
        new Child(); // Creates an instance of Parent.Child
    }
}

ParentSubclass is a subclass of the containing class of Child. Note that outside of Parent (or its subclasses), new Child() will not work, as you need to have a containing (“outer”) class to instantiate a non-static “inner” class.

Things get a bit crazy when you now add a method doSomething to Parent, invoke it in Child but override it in ParentSubclass.

class Parent {
    void doSomething() {
        System.out.println("Not doing anything");
    }

    class Child {
        void whatever() {
            doSomething(); // actually: Parent.this.doSomething()
        }
    }
}

class ParentSubclass extends Parent {
    void doSomething() {
        System.out.println("I'm just slacking.");
    }

    void whatever() {
        Child a = new Child(); // Creates an instance of Parent.Child
        a.whatever(); // will print "I'm just slacking".
    }
}

Situations like this make static code analysis a quite hard problem.