final

When declaring a local inner class inside a method, why is it legal to include final static Strings or ints but not legal to include other objects? For instance: class Outer { void aMethod() { class Inner { final static String name = "compiles"; final static int ctr = 10; // compiles final static Integer intThree = Integer.valueOf(3); // does not compile! final static obj objConst = new Object(); // does not compile! } Inner inner = new Inner(); } } When I compile this, I get the following: InnerExample.java:6: inner classes cannot have static declarations final static Integer outer = Integer

I have a variable that is not supposed to change its value after it's been initialized, so I want to define it as a final variable. the problem is that the variable has to be initialized inside a try block, so I get the following troubles: I have the following code: Connection conn = null; try { conn = getConn(prefix); [...do some stuff with conn...] } catch (Exception e) { throw new DbHelperException("error opening connection", e); } finally { closeConnection(conn); } If I declare the variabale as final, without initializing it to null, I get a 'The local variable conn may not have been

I happen to come across a Java code at my work place. Here's the scenario: There are 2 classes - ClassA and ClassB . ClassA has nothing except 4 public static final string values inside it. Its purpose is to use those values like ClassA.variable (don't ask me why, it's not my code). ClassB imports ClassA . I edited the string values in ClassA and compiled it. When I ran ClassB I could see it was using the old values - not the new values. I had to recompile ClassB to make it use new values from ClassA ! (I had to recompile other classes that imports ClassA !) Is this just because of JDK 1.6 or

Please refer to the below code. When I run the code, I am able to change the value of a final non-static variable. But if I try to change the value of a final static variable then it throws java.lang.IllegalAccessException . My question is why doesn't it throw an exception in case of non-static final variable also or vice versa. Why the difference? import java.lang.reflect.Field; import java.util.Random; public class FinalReflection { final static int stmark = computeRandom(); final int inmark = computeRandom(); public static void main(String[] args) throws SecurityException,

When in debug (eclipse), I cannot see variables content in the variables view, nor in Expressions view, nor in Display view - if the variables are defined outside an anonymous class but the debug is inside the anonymous class. When I try to see the content in debug, I get the error: x cannot be resolved to a variable . In the following example, x cannot be resolved: private void someMethod(final Object x) { new Runnable() { public void run() { Log.i(x); // x is printed correctly but cannot be resolved when in Debug } }.run(); } This question regards the eclipse development environment -

class Temp { private: ~Temp() {} friend class Final; }; class Final : virtual public Temp { public: void fun() { cout<<"In base"; } }; class Derived : public Final { }; void main() { Derived obj; obj.fun(); } The above code tries to achieve non-inheritable class (final). But using above code the object of derived can still be created, why? The desired functionality is achieved only if ctor made private, my question is why it is not achievable in case of dtor private? Well, for this program (pleasse provide correct, compilable examples) #include <iostream> class Temp { private: ~Temp() {}

Take the following example: public void init() { final Environment env = new Environment(); Runtime.getRuntime().addShutdownHook(new Thread() { public void run() { env.close(); } }); } Firstly, where is env stored? Is it: copied by the compiler into a hidden member variable of the inner class that references it copied to, and referenced on, the heap left on the stack and somehow referenced there something else My guess is the first option. Secondly, do any performance issues that arise from doing this (rather than simply creating env as a member variable of the class and referencing it as such

C++11 will allow to mark classes and virtual method to be final to prohibit deriving from them or overriding them. class Driver { virtual void print() const; }; class KeyboardDriver : public Driver { void print(int) const final; }; class MouseDriver final : public Driver { void print(int) const; }; class Data final { int values_; }; This is very useful, because it tells the reader of the interface something about the intent of the use of this class/method. That the user gets diagnostics if he tries to override might be useful, too. But is there an advantage from the compilers point of view?

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? NINCOMPOOP 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 implicitly public, static, and final . It is permitted to redundantly specify any or all of these