Array af metoder??

det kan du ikke

men du kan lave et array af et interface som har en bestemt metode, hvilket i en del
tilfælde vil kunne opnå samme funktionalitet

og ud fra mit eksempel, hvordan ville det så se ud?

Hvis du nu har en person klasse:

Method[] metoder = new Method[20];
int i=0;
for (Method m : Person.class.getMethods()) {
metoder[i] = m;
i++;}

public class ArrayOfMethods {
    public static void main(String[] args) {
        MethodContainer[] m = new MethodContainer[] { new A(), new B() };
        m[0].doSomething();
        m[1].doSomething();
    }
}

interface MethodContainer {
    public void doSomething();
}

class A implements MethodContainer {
    public void doSomething() {
        System.out.println("I am an A");
    }
}

class B implements MethodContainer {
    public void doSomething() {
        System.out.println("I am a B");
    }
}

0k, jeg prøver med arne_v's forslag.... tak for hjælpen, kast et svar!

gerne

winners79's forslag kan dog også bruges som en generel løsning, men invoke syntaxen
der skal bruges for at kalde er nok lidt tung

hvis den skulle operationaliseres tror jeg at den skulle laves som Map:

import java.lang.reflect.*;
import java.util.*;

public class ArrayOfMethodsReflection {
    public static void main(String[] args)throws Exception  {
        Map<String, Method> m = new HashMap<String, Method>();
        for (Method met : ArrayOfMethodsReflection.class.getMethods()) {
            m.put(met.getName(), met);
        }
        m.get("a").invoke(null, new Object[] { });
        m.get("b").invoke(null, new Object[] { });
    }
    public static void a() {
        System.out.println("I am a");
    }
    public static void b() {
        System.out.println("I am b");
    }

}

bare et spørgsmål, hvis man kender positionen i arrayet har den ikke den samme asymptotiske kompleksitet som et opslag i HashMap, altså O(1) ?

jo - det var ikke et effektivitets spørgsmpl men et læsbarheds spørgsmål

import java.lang.reflect.*;
import java.util.*;

public class ArrayOfMethodsReflection2 {
    public static void main(String[] args)throws Exception  {
        List<Method> lst = new ArrayList<Method>();
        for (Method met : ArrayOfMethodsReflection2.class.getMethods()) {
            lst.add(met);
        }
        lst.get(2).invoke(null, new Object[] { });
        lst.get(1).invoke(null, new Object[] { });
    }
    public static void a() {
        System.out.println("I am a");
    }
    public static void b() {
        System.out.println("I am b");
    }
}

is not obious that it will call a first and b last

ahh ja så giver jeg dig helt ret :)

og jeg ved faktisk heller ikke om for each iteratoren er lineær