It basically means: Catch “SomeExceptionType” into the variable “e” with the promise that we won’t assign a different exception to “e” during the processing of the exception. Mostly this is overkill, as if I’m catching an exception into a temporary variable name (e only is valid for the exception handling block), I don’t have to … Read more
Not that anyone does this, but: $ scala -Yoverride-objects Welcome to Scala version 2.11.2 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_11). Type in expressions to have them evaluated. Type :help for more information. scala> trait A { object O } ; trait B extends A { override object O } defined trait A defined trait … Read more
Method #2 is your best option. The problem is that if you have an assignment in a private method there is nothing preventing other code in the class outside the constructor calling it, which would then create an issue with an attempted second assignment to the final field. Java has no construct of a separate … Read more
Note that the wording in the JLS of that particular section has changed significantly since then. It now (JLS 11) reads: 15.9.5. Anonymous Class Declarations: An anonymous class is never final (§8.1.1.2). The fact that an anonymous class is not final is relevant in casting, in particular the narrowing reference conversion allowed for the cast … Read more
It will be available since 1.4, you can check the Announcing TypeScript 1.4 article, “Let/Const” support section: “TypeScript now supports using ‘let’ and ‘const’ in addition to ‘var’. These currently require the ES6 output mode, but we’re are investigating relaxing this restriction in future versions.” Const should be implemented according to the article. You can … Read more
You can easily make it public static final, but that won’t stop people from changing the contents. The best approach is to safely publish the “constant” by: wrapping it in an unmodifiable list using an instance block to populate it Resulting in one neat final declaration with initialization: public static final List<String> list = Collections.unmodifiableList( … Read more
Let me suggest you a little bit more elegant decision. First variant (without throwing an exception): public class Example { private Long id; // Constructors and other variables and methods deleted for clarity public long getId() { return id; } public void setId(long id) { this.id = this.id == null ? id : this.id; } … Read more
If you don’t like static blocks (some people don’t) then an alternative is to use a static method. IIRC, Josh Bloch recommended this (apparently not in Effective Java on quick inspection). public static final ObjectName OBJECT_NAME = createObjectName(“foo:type=bar”); private static ObjectName createObjectName(final String name) { try { return new ObjectName(name); } catch (final SomeException exc) … Read more
The main difference between an immutable object (all properties final) and an effectively immutable object (properties aren’t final but can’t be changed) is safe publication. You can safely publish an immutable object in a multi threaded context without having to worry about adding synchronization, thanks to the guarantees provided by the Java Memory Model for … Read more
Compile time constant must be: declared final primitive or String initialized within declaration initialized with constant expression So private final int x = getX(); is not constant. To the second question private int y = 10; is not constant (non-final in this case), so optimizer cannot be sure that the value would not change in … Read more