interface inter {
		static final int INTER_ONE = base.one();
	}
	class base {
		static final int ONE = one();
		static int one(){
			System.out.println("base.one() called");
			return 1;
		}
	}
	class sub extends base implements inter{
		static {
			System.out.println("static block of sub called");
		}
		/*static int one(){
			System.out.println("sub.one() called");
			return 10;
		}*/
    }
	class test  {
		static{
			System.out.println("static block of test called");
	 	}
		public static void main(String[] args){
				System.out.println(sub.one());
	    }
	}

with comments
static block of test called
base.one() called
base.one() called
1

If the comment is removed??
static block of test called
base.one() called
static block of sub called
sub.one() called
10

After the decision is made,Now it has to load and initilize 'base'. So the static final int ONE has to be initialized first. For this , it is calling it's own one() method so it prints 'base.one() called' the 1st time. Then, sine we are calling this method again from the main() method, 2nd time 'base.one() called' is printed.
Without the comments
In this case the subclass hides the static method one().
So the JVM decides that the called method sub.one() from the main(..) does indeed call the subclass's one() method not the 'base' class's one() method. So It does all the process which I have explained in previous case above. Apart from that it loads class 'sub' also and calls the subclass's version of one() method whenever one() is called.

I hope this gives a fair view of what's happening.What I found interesting was, for the first case, since the one() method was inherited to sub from base, eventhough we call as 'sub.one()' from main(), JVM decides to load only base class and it doesn't load sub at all.

regds
maha anna

IMO, since the JVM sees that method one() is existing in sub class, it won't load the base class, right ? So how does the second line get printed ? What about the execution of final
static variable in the interface inter in both cases?

The bottom line is this. When a static method is called on a class, ALL the classes upto which class actually defines that method WILL be initialized. JVM leaves the rest of the subclasses in that hirearchy.
I am sorry if I am still not clear to you. Please refer to this chapter Execution in JLS.
regds
maha anna

The Moose is strong in Maha Anna!

------------------
May the Moose be with you.

Eventhough the decisions are made at compile time, these decisions are verified at run time by resolving the symbolic refs by checking if they obey certain rules. These allow the binary compatiblity of classes. There are some pre-defined rules for which the binary compatiblity is ok/not.

While doing the symbolic ref resolution, if the JVM finds out that the decisions made at compile time are violated, then it throws Error.(Ex. abstractMethodError/VerifyError/NoSuchFieldError etc)

with comment:
static block of test called
base.one() called
base.one() called
static block of sub called
sub.one() called
10