Re: Class.getMethod in class's static initializer block
On Aug 1, 12:07 pm, chucky <tomas.mik...@gmail.com> wrote:
On Aug 1, 8:27 pm, Daniel Pitts <googlegrou...@coloraura.com> wrote:
chucky wrote:
If I call A.class.getMethod() from static initializer block of class
A, I get NoSuchMethodException.
Example:
class A {
static Method m;
private static void method(String str) {
System.out.println(str);
}
static {
try {
m = A.class.getMethod("method", new Class[] {String.class});
} catch(NoSuchMethodException e) {
throw new ExceptionInInitializerError(e);
}
}
}
This code always throws the ExceptionInInitializerError caused by
NoSuchMethodException.
Why does this happen?
Actually, I would like to write something like this:
class A {
private static void method(String str) {
System.out.println(str);
}
static Method m = A.method;
}
Of course, this code is invalid, but my idea is that the presence of
method is known at compile time, so I don't want the overhead of
reflection and I'd rather get a compilation error if there is no such
method. Something similar is possible with function pointers in C, but
is there sth. like that in Java?
Thanks for any help!
Using reflection should be a last resort, and reserved for frameworks.
Have you considered creating a functor class? Something like the
following:
interface StringCall {
void call(String s);
}
class A {
private static void method(String b) {
System.out.println(b);
}
static StringCall call = new StringCall() { public call(String s)
{ method(s); } };
}
Perhaps if you explained your goal, rather than the approach you are
trying, we could offer you better advice.
Thanks for your reply. I think I could do what I want with functors.
Here is what I want to do.
I have a code like this:
String str;
// some code
if(str.equals("string1")){ method1() }
else if(str.equals("string2")){ method2() }
else if(str.equals("string3")){ method3() }
...
// maybe 10-20 possibilities
...
else { /* default code */ }
And because I don't like it, I wanted to put each methodN() into a
static Map<String, Method> in static initializer.
Then I would change the above code into:
String str;
// some code
Method m = map.get(str);
if(m != null)
m.invoke();
else{ /* default code */ }
Some suggestions on this?
Many thanks in advance.
A couple of suggestions. One, is there something you could use that
isn't a string? int perhaps, or enum? The Map<String, Functor> is one
way to go, as your basically just replacing the switch construct.
If you do this in more than one place, you can add more methods to
your functor class.
I would add a default value too, instead of special null handling
everwhere:
public interface Something {
void foo();
void bar();
}
public class DefaultSomething implements Something {
public void foo() { /* default foo */ }
public void bar() { /* default bar */ }
}
public class SomethingLookup {
private Map<String, Something> somethings = new HashMap<String,
Something>();
Something defaultSomething = new DefaultSomething();
/* initialize somethings in constructor... */
public Something get(String somethingName) {
Something something = somethings.get(somethingName);
return (something == null) ? defaultSomething : something;
}
}
public class MyClass {
SomethingLookup lookup;
/* Iniitalize lookup in constructor */
public void foo(String name) {
lookup.get(name).foo();
}
public void bar(String name) {
lookup.get(name).bar();
}
}
You're Something implementations can be Fly Weights, so you can pass
any state information into the methods as another class. That way you
don't have to keep different SomethingLookup and Something objects for
every object that you wish to affect.