jls

问题 What does "fresh type variable" mean in the JLS Conversions and Promotions chapter? 回答1: Fresh is the common designation for a variable that must not have been used before. 来源： https://stackoverflow.com/questions/3733644/java-fresh-type-variable

问题 This ugly piece of code does compile but throws NPE if s == null public static boolean isNullOrEmpty(String s) { return s != null ? s.isEmpty() : null; } while this does not (as expected): public static boolean isNullOrEmpty(String s) { if(s != null) return s.isEmpty(); else return null; } I know both of them are plainly wrong, but as I found the first piece of code in our sources, I was quite surprised it did compile. Edit: Here's the relevant part of the JLS from Java 7. I guessed the first

问题 There is only one official Java Language Specification and all Java implementations must comply with it. How about the API documentation: do all Java implementations need to comply with this version or could an implementation define the behaviour of some methods and classes differently, as long as it's compatible with the JLS? Let's throw a concrete example: could a Java implementation include a HashMap that doesn't accept null elements? 回答1: I believe, that, yes it is. Upon closer

问题 Can someone explain why String and Class annotation parameters are expected differently? Why does the compiler require literals for Classes, wherby accepting constants for Strings as well? Working example with Spring's @RequestMapping: public class MyController { public static final String REQUEST_MAPPING = "/index.html"; @RequestMapping(MyController.REQUEST_MAPPING) // ALL OK! ... } WTF example with TestNG's @Test: public class MyControllerTest { public static final Class TEST_EXCEPTION =

问题 I am wondering why in the Java language a class cannot extend an enum . I'm not talking about an enum extending an enum (which can't be done, since java doesn't have multiple inheritance, and that enum s implicitly extend java.lang.Enum ), but a class that extends an enum in order to only add extra methods, not extra enumeration values. Something like: enum MyEnum { ASD(5), QWE(3), ZXC(7); private int number; private asd(int number) { this.number=number; } public int myMethod() { return this

问题 Today I tried to write a class with a generic method that uses intersection types and got confused by the different error messages depending on the intersected types. Let's assume that we have an interface and a class and define generic methods in a generic interface: class ClassType { } interface InterfaceType { } interface I<T> { public <X extends InterfaceType & InterfaceType> void foo(); public <X extends ClassType & ClassType> void foo1(); public <X extends ClassType & InterfaceType>

问题 When I try to write a postfix/prefix in/decrement, followed by a post/prefix in/decrement, I get the following error: Invalid argument to operation ++/-- . But, according to JLS: PostIncrementExpression: PostfixExpression ++ and PostfixExpression: Primary ExpressionName PostIncrementExpression PostDecrementExpression so writing: PostfixExpression ++ ++ should be possible... Any thoughts? 回答1: Note that the raw grammar lacks any semantics. It's just syntax, and not every syntactically valid

问题 I recently installed Checkstyle plugin for Eclipse and personally think that it is awesome. But one of the warnings it gives me is a bit obscure. The exact warning is "Using ++ is not allowed". It is about postfix ++ in some row like for(int i = 0; i < SOMETHING; i++) Ok, I 'm aware that foreach is the better construction for iteration, but it can't be applied everywhere, sometimes old-school ++ is the only alternative. When I change the row to for(int i = 0; i < SOMETHING; ++i) the warning

问题 Consider the following code: public interface A { public A another(); } public interface B { public B another(); } public interface AB extends A,B { public AB another(); } This leads to a compile error on AB : types B and A are incompatible; both define another(), but with unrelated return types I've seen this SO question, and follow the incompatibility example in the the accepted answer - i.e. public interface C { public void doSomething(); } public interface D { public boolean doSomething()

问题 This code: interface Config { int MAX_CONN = 20; } compiled and worked as I expected. It looks like this is the same as: interface Config { public static final int MAX_CONN = 20; } Is "public static final" redundant for a constant in a Java interface? Is this true for Java 1.1, 1.2, 1.3, 1.4,..., 1.8 or did it change in a Java release? 回答1: Variables declared in Interface are implicitly public static final . This is what JLS 9.3 says : Every field declaration in the body of an interface is