0

I really want to know why instead of going to the documentation. Suppose I have class like this:

public class OuterClass{
public static void main(String[] args)throws Exception{
    System.out.println(OuterClass.InnerClass.yearOfBorn);//works ok
    System.out.println(OuterClass.InnerClass.returnYearOfBorn());//not works
    System.out.println(OuterClass.InnerClass.returnYearOfBornAsPublic());//not works
}    
private final class InnerClass{
    private static final int yearOfBorn=13;
    private static int returnYearOfBorn(){
        return yearOfBorn;
    }        
    public static int returnYearOfBornAsPublic(){
        return yearOfBorn;
    }            
}
}

Both static method is throwing a error stating that

modifier 'static' is only allowed in constant variable declarations

I know that the docs states that this is described in the Java Language Specification Section §8.1.3

8.1.3 Inner Classes and Enclosing Instances

An inner class is a nested class that is not explicitly or implicitly declared static. Inner classes may not declare static initializers (§8.7) or member interfaces. Inner classes may not declare static members, unless they are compile-time constant fields (§15.28).

But my question what is the difference between calling a simple value or property vs calling a static method not matter if is public or private? Why calling a property is possible but not a method?

Improve this question
4
  • "Inner classes may not declare static members". So returnYearOfBorn and returnYearOfBornAsPublic are both invalid members. This code should not compile. But maybe it compiles because you are using a somewhat forgiving compiler (like eclipse's). Commented Jun 24, 2019 at 22:50
  • yep it does not compile. But i want to know for the compiler what is the differences between calling a property and calling a method in this context? Commented Jun 24, 2019 at 22:56
  • So it doesn't 'throw an error'. The compiler prints an error. Exceptions are thrown. Error messages are printed. Don't misuse standard terminology. Commented Jun 24, 2019 at 23:00
  • 1
    The mentioned "property" is actually a constant, that the compiler replaces on each "calling" (so to say) site. No vtable lookup. Everything is actually static reference, even if you think it went through a dynamic reference. Commented Jun 24, 2019 at 23:04

1 Answer 1

Reset to default
2

Non-static inner classes have something special.

static inner classes do not have it. top-level classes don't have it. any inner interface or enum doesn't have it.

That special thing is an invisible field.

This invisible field is of type Outer, and it is final. It is initialized as first thing in its constructor, and, yes, EVERY constructor of a non-static inner class has a magic invisible parameter, of type Outer, to serve as this field.

So, when you write:

public class Outer {
    public class Inner {
    }
}

The compiler will compile this code as if you actually wrote:

public class Outer {
    public static class Inner {
        private final Outer I_AM_MAGIC;

        public Inner(Outer outer) {
            this.I_AM_MAGIC = outer;
        }
    }
}

You can see this hidden magic using the javap decompilation tool; pass in -verbose and -private and you'll see these. The reason this magic exists is that you can invoke instance methods of your outer from within your inner, but.. on what instance are you calling these outer methods? On that hidden instance!

Note that this exotic, seemingly weird code: someOuter.new Inner() is in fact legal java code. When calling new Inner() from within a non-static context in Outer, the this instance is passed as invisible parameter to that constructor, but if you're not there, the code simply does not compile at all... unless you use the outer.new Inner() syntax.

The reason the compiler will stop you from adding static methods to Inner is that it was believed to lead to some confusion. Basically, the answer to your question is: "No good reason.. just... the spec says that a java compiler must not allow it, therefore, javac does not allow it".

Note that in actual fact these non-static inner classes are the confusing thing. I strongly suggest you teach yourself to ALWAYS make your inner classes static unless you really know what you're doing. And even then, think twice. Then think twice again. Then maybe consider making a non-static inner class.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

'Non-static inner' is a tautology.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.