jls

I've always been wondering about some weird aspect of Java generics and the use of wildcards. Let's say, I have the following API: public interface X<E> { E get(); E set(E e); } And then, let's say we declare the following methods: public class Foo { public void foo(X<?> x) { // This does not compile: x.set(x.get()); } public <T> void bar(X<T> x) { // This compiles: x.set(x.get()); } } From my "intuitive" understanding, X<?> is in fact the same as X<T> , except that the unknown <T> is formally unknown to client code. But inside of foo() , I would guess that the compiler could infer (pseudo JLS

Here is some code that calls static method A.f() on class that is not initialized yet. Can someone explain behavior of this code in terms of JLS? class A { final static Object b = new B(); final static int S1 = 1; final static Integer S2 = 2; static void f() { System.out.println(S1); System.out.println(S2); } } class B { static { A.f(); } } public class App { public static void main( String[] args ) { A.f(); } } Output: 1 null 1 2 A.f() in App.main() triggers initialization of class A . All constant variables are initialized. The only constant variable is S1 , which now is 1 . Then, the other

The term inner class is conventionally taken to mean "a nested class which requires an enclosing instance". However, the JLS states as follows: 8.1.3. Inner Classes and Enclosing Instances [...] Inner classes include local (§14.3), anonymous (§15.9.5) and non-static member classes (§8.5). [...] An instance of an inner class whose declaration occurs in a static context has no lexically enclosing instances. Also, 15.9.5. Anonymous Class Declarations [...] An anonymous class is always an inner class (§8.1.3); it is never static (§8.1.1, §8.5.1). And it is well-known that an anonymous class may be

I wonder if it's reliable to use a construction like: private static final Map<String, String> engMessages; private static final Map<String, String> rusMessages; static { engMessages = new HashMap<String, String> () {{ put ("msgname", "value"); }}; rusMessages = new HashMap<String, String> () {{ put ("msgname", "значение"); }}; } private static Map<String, String> msgSource; static { msgSource = engMessages; } public static String msg (String msgName) { return msgSource.get (msgName); } Is there a possibility that I'll get NullPointerException because msgSource initialization block will be

In Effective Java inside the item "Item 22: Favor static member classes over nonstatic" Josh Bloch says: Each instance of a nonstatic member class is implicitly associated with an enclosing instance of its containing class. Within instance methods of a nonstatic member class, you can invoke methods on the enclosing instance or obtain a reference to the enclosing instance using the qualified this construct. What does he mean by Qualified This Construct ? Without the qualifier, x() would recurse. With the qualifier, the enclosing instance's x() method is invoked instead. class Envelope { void x(

Given the following class: class Foo { public volatile int number; public int method1() { int ret = number = 1; return ret; } public int method2() { int ret = number = 2; return ret; } } and given multiple threads calling method1() and method2() concurrently on the same Foo instance, can a call to method1() ever return anything other than 1? The JLS 15.26 specifies: There are 12 assignment operators; all are syntactically right-associative (they group right-to-left). Thus, a=b=c means a=(b=c), which assigns the value of c to b and then assigns the value of b to a. Ted Hopp's answer shows that