Are anonymous inner classes private by default? Can I make them public?
I need to access methods by reflection.
1
-
1If its an anonymous inner class how would the compiler know where to look to call those methods? Why are you not just creating a public class and using it in the places you need to instead of using an anonymous class?jzworkman– jzworkman2012-03-23 15:33:55 +00:00Commented Mar 23, 2012 at 15:33
Add a comment
|
4 Answers
Anonymous inner classes are anonymous for a reason: they aren't meant to be accessed directly from the outside world, only via a referring variable / method parameter. (And for the same reason, they are private too.)
I guess you may try to access such a class via reflection using its compiler-generated name (e.g. OuterClass$1), however that is implementation specific and may change the moment you add another anonymous inner class to the same outer class, or in the next JVM version. So such a solution would be very brittle.
Why would you actually want to do this? If you explain your actual problem, we may be able to offer a better alternative.
6 Comments
Dims
I disagree. The only difference between non-anonymous and anonymous inner classes is that latter ones have no name. The reason for this is brevity, not security. So the reason for anonymous classes can't be public is just the syntax was not proposed. IMHO.
Xavi López
+1 Not necessary to use the compiler-generated class name if you've got an instance, though (which is inherent to an anonymous inner class).
Péter Török
@XaviLópez, indeed. If you do have the instance, why do you need reflection?
Xavi López
We should definitely have some context on this matter to give a reasonable answer
Ted Hopp
@PéterTörök - You'd use reflection to gain access to methods declared in the anonymous class.
|
You can access an anonymous inner class' methods with reflection. See getDeclaredMethods().
Remember to call setAccessible(true) on the Method in order to avoid an IllegalAccessException.
Object testObject = new Object() {
private void testMe() {
System.out.println("testme");
}
};
Method m = testObject.getClass().getDeclaredMethod("testMe");
m.setAccessible(true);
m.invoke(testObject); // prints out "testme"
Also notice that if there's a SecurityManager this won't be possible, see What is the security risk of object reflection?
Warning: Take into account that anonymous inner classes are kind of disposable class definitions. Once used, you'll never need them elsewhere again. Just like @PéterTörök said, it's hard to tell without more context on your problem, but, if you've got control over that class, it would probably be better to deanonymize that class (making a private inner class, or even public), and expose that method to the classes that need it.
Comments
Anonymous inner classes are private by default. For use with reflection you can have a look here - Java reflection: How can I retrieve anonymous inner classes?
1 Comment
Ted Hopp
Anonymous inner classes have default (package private) access, not private.
Anonymous inner classes have package private (default) access. In Java 6, they are final if declared in a static context but not final in other contexts. (I believe, but have not tested, that this has changed in Java 7 so that they are always final; see Section 15.9.5 of the Java Language Specification.)
For example, this class has four anonymous inner classes:
public class InnerTest {
public Runnable foo1 = new Runnable() {
public void run() {foo1();}
void foo1() {}
};
private Runnable foo2 = new Runnable() {
public void run() {foo2();}
void foo2() {}
};
public static Runnable foo3 = new Runnable() {
public void run() {foo3();}
void foo3() {}
};
private static Runnable foo4 = new Runnable() {
public void run() {foo4();}
void foo4() {}
};
}
When compiled with javac (version 1.6.0_26) it generates four anonymous inner classes. Decompiling with javap -c reveals:
InnerTest$1(foo1) — package privateInnerTest$2(foo2) — package privateInnerTest$3(foo3) — package private and finalInnerTest$4(foo4) — package private and final
Note that the access of the variable to which the anonymous inner class instance is being assigned is irrelevant.