CODEWITHSUNDEEP
javainheritanceinner-classes
sal
sal

Reputation: 23623

Subclassing Inner Class from Outer Class versus other Inner Class

I am befuddled why this is allowed

public class Foo {
    class Bar extends Foo {
    }
}

Yet this is not allowed

public class Foo {
    class Bar extends Foo {
    }

    class Fooey extends Bar {
    }
}

The compiler informed that it can not reference Fooey.this before supertype constructor has been called.

And this is allowed

public class Foo {
    static class Bar extends Foo {
    }

    class Fooey extends Bar {
    }
}

What is going on here? And where can I go to find more information on how inner class inheritance works?

EDIT I came upon both rather poor ideas; inner class extends outer class and inner class extends other static inner class. I wasn't sure what exactly was going and how I should refactor this. I ended up just yanking out the inner classes and encapsulating them in the outer class.

Upvotes: 7

Views: 3226

Answers (4)

chharvey
chharvey

Reputation: 9326

(Can't comment yet - I need 50 rep)

I'm also befuddled that this is allowed. A (non-static) inner class of an outer class is actually a member of that outer class. Read: an inner object is a member of its outer object. (Incidentally, every outer object must own an inner object but this is besides the point.)

The analogy I like to use is this: let Car be the outer class and let Wheel be the inner class. Every instance of Car must, and does, have at least one instance of Wheel as a member.

Now it doesn't make conceptual sense for an inner class to extend an outer class. I can't think of any real-world situations that call for an object being both a member and a type of another object. Set Theorists will recall the Axiom of Regularity and its consequences.

Think of it this way: Let Honda extend Car, and let Honda be an inner class nested inside Car. What you're saying here is that every Honda object is a Car object (duh), and every Car object has a Honda object. Only one of these statements makes sense, but both are allowed to be true in Java.

Or back to the previous analogy, you shouldn't let Wheel extend Car because then a Wheel would be a Car, and by definition must have another Wheel, which by the way is a Car and so must have a Wheel and forever and ever Amen. Constructing a Car object would result in an infinite loop of nested objects.

I'm upset that this is legal and does not produce a compile-time error.

Upvotes: 1

vdr
vdr

Reputation: 988

Tom Hawtin answer is correct.

Have also a look at java puzzler. The sample chapter contains this case and a few other "interesting" case you may want to have a look at.

Upvotes: 1

Tom Hawtin - tackline
Tom Hawtin - tackline

Reputation: 147154

First of all: Don't do this sort of thing. It's evil. Really, Java 1.1 should have been specified very much more restrictively, IMO.

There is confusion about which this to use from the Foo.Fooey constructor. The outer this (Foo.this) would work. But the actual this is a Foo but it can't be passed to the superconstructor because of rules about using this before the superconstructor returns (and besides having an outer instance the same instance as the inner instance is fecked up). The outer this on the superclass "((Bar)this).this$0" (IIRC), is also inaccessible due to restrictions on use of this.

The solution is to be explicit. Explicit is usually a good thing in my book (unless it becomes boilerplate).

public class Foo {
    class Bar extends Foo {

    }

    class Fooey extends Bar {
        Fooey() {
            Foo.this.super();
        }
    }
}

Better yet, don't have an inner class extend its own outer class, or extend any inner class.

Upvotes: 6

jitter
jitter

Reputation: 54605

I guess the JLS and the answers to this question are a starting point

Java inner class and static nested class

Inner Classes and Enclosing Instances

Upvotes: 1

Related Questions