Acessando variáveis através de strings

acho que o que vc procura é reflection. aqui no guj tem um tutorial bem interessante sobre o reflection.

Carregue suas constantes num mapa, que relaciona o nome da constante ao seu valor.
Nada pode ser mais fácil e flexível do que isso.

A sintaxe vai ser um pouco mais chata de usar:
String valor = Constantes.get("CONSTANTE1");

Você pode prover métodos úteis como:
int valor = Constantes.getInt("CONSTANTE1");

A classe constantes ficaria assim:

public class Constantes { 
    private Map<String, String> constantes = new HashMap<String, String>();

    public static String get(String name) {
       return constantes.get(name);
    }

    public static Map<String, String> asMap() {
       return Collections.unmodifiableMap(constantes);
    }

    public static int getInt(String name) {
       return Integer.parseInt(get(name));
    }

    public static int getDougle(String name) {
       return Double.parseDouble(get(name));
    }
}

Também não custa dar uma olhada na classe Properties, que já faz esse tipo de coisa.

Reflection está entre as piores soluções possíveis para o seu caso.

Obrigado, ViniGodoy, a sua solução parece a que vai funcionar, já que estou usando J2ME e não tenho reflection. Porém, vai dar um bom trabalho popular o Map, já que a minha classe de constantes é beeeem grande, e provavelmente vai ficar bem travada, pois toda vez que eu criar uma constante nova, vou ter que mudar o código, a não ser que tenha uma idéia melhor.

palmadias, a idéia de reflection é perfeita! Fiz um teste aqui com J2SE e é exatamente o que procuro! Porém, com J2ME tenho acesso bem limitado a isso. Consigo no máximo usar o forname e conseguir a instância da classe, mas não tenho acesso a métodos e fields.

Ainda busco um meio termo a isso =)

Mudar o código? Por que? Você pode adicionar os objetos ao mapa dinamicamente… você pode fazer essa classe carregar as constantes do xml diretamente. E bem grande quanto? Duvido muito que seja grande o suficiente para você sequer perceber qualquer problema de performance. Se houver um problema, vai ser com o xml, não com o map.

Novamente, volto a afirmar que reflection não é o caminho. Pelo menos, não para essa situação. Reflection gera um código complexo, inseguro e geralmente difícil de manter.

ViniGodoy, obrigado novamente pela ajuda. Talvez tenha me expressado mal. Já tenho uma classe com as constantes definidas, e já tenho um XML que utiliza essas constantes pelo nome. O que eu queria fazer é ler o nome da variável do xml, acessar a classe de constantes e conseguir o valor da mesma. Logo, o que eu pensei com a sua solução seria:

public static final int CONSTANTE1 = 1;
public static final int CONSTANTE2 = 1;

Map<String, String> map = new HashMap<String, String>();
map.put("CONSTANTE1", "1");
map.put("CONSTANTE2", "2");

E em razão do código grande, digo ter que fazer a primeira parte com cada constante do arquivo, e ter que atualizar toda vez que uma constante nova é criada. A respeito de performance, também não acho que vá dificultar muito.

Quando disse que o reflection parecia ser o melhor caminho, acho que seria mais simples ler do xml, e já procurar logo de cara pelo valor da constante. É um código simples (2 ou 3 linhas já resolvo isso), e não preciso me preocupar com ter que carregar todas as constantes para um hash.

Agradeço qualquer idéia =)