Relfection + Cast

private static String primeiraLetraMaiuscula (String nomeAtributo) {
		return nomeAtributo.substring(0,1).toUpperCase() + nomeAtributo.substring(1);
	}
	// Aqui supomos que o nome do atributo começa por minúscula ("abacaxiAbacate") e o 
	// getter segue exatamente as normas para getters ("getAbacaxiAbacate").
	// Isso é feito para evitar procurar em todos os métodos,
	// acelerando bastante o processamento. 
	// Também supomos que é um getter sem parâmetros (nas normas é possível ter 
	// getters "indexados" também).
	public static Object getRetornoMetodoReflectionByAtributo (Object obj, String nomeAtributo) {
		// Vamos ver se o objeto pertence a uma classe que tem esse getter
		try {
			Class klass = obj.getClass();
			Method meth = klass.getMethod("get" + primeiraLetraMaiuscula(nomeAtributo), new Class[]{});
			return meth.invoke(obj, new Object[]{});
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) { // se o getter tiver mais de um argumento
			e.printStackTrace();
		} catch (NoSuchMethodException e) { // se não existir o getter
			e.printStackTrace();
		} catch (IllegalAccessException e) { // se o getter não for public
			e.printStackTrace();
		} catch (InvocationTargetException e) { // se o getter lançar uma exceção durante sua execução
			e.printStackTrace();
		}
	}

OcorrenciaRestricaoRegraBean ocorrenciaRestricaoRegraBean = new OcorrenciaRestricaoRegraBean ();
//... Preencher o bean
// Agora digamos que "nome" seja um atributo desse bean, e exista um getter chamado "getNome", com o retorno do tipo String.
String nomeCliente = (String) getRetornoMetodoReflectionByAtributo (ocorrenciaRestricaoRegraBean, "nome");

//Isto é somente um exemplo....

HashMap hmClassesObj = new HashMap();
classeObj.put("001", ocorrenciaRestricaoAcessoDadoBean) // Bean ja alimentado
classeObj.put("002", moduloAcessoDadoBean) // Bean ja alimentado
classeObj.put("003", avaliacaoAcessoDadoBean) // Bean ja alimentado

Iterator iterClasses = hmClasseObj.values().iterator();
while(iterClasses.hasNext()){
    //Vamos dizer que ja tenho o atributo...
    Class classeAtual = Class.forName((iterClasses.next()).getClass().getName());
    System.out.prinln(getRetornoMetodoReflectionByAtributo (classeAtual, nomeAtributo));
}

package exemplos;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.LinkedHashMap;
import java.util.Map;

public class CallGetter {
/*
	public static Object getRetornoMetodoReflectionByAtributo(Class classeMetodo, String nomeAtributo){
		Object objRetorno = new Object();
		try {
			Method[] metodosClasse = classeMetodo.getDeclaredMethods();
			for(Method metodo : metodosClasse){
				if(metodo.getName().toUpperCase().indexOf("GET" + nomeAtributo.toUpperCase()) > -1){
					if(classeMetodo.getSimpleName().equalsIgnoreCase("ModuloAcessoDadoBean")){
						ModuloAcessoDadoBean  classeModulo = ((ModuloAcessoDadoBean)classeMetodo.cast(classeMetodo.getClass())) = classeMetodo;
						ModuloAcessoDadoBean modBean = classeModulo;
						
						objRetorno = metodo.invoke(modBean, null);
						System.out.println(modBean.getNmModuloAcessoDado() + " - " + metodo.getName() + " = " + objRetorno);
						
					}else if(classeMetodo.getSimpleName().equalsIgnoreCase("AvaliacaoSqlAcessoDadoBean")){
						AvaliacaoSqlAcessoDadoBean AvaliacaoAcessoBean = (AvaliacaoSqlAcessoDadoBean)classeMetodo.cast(new AvaliacaoSqlAcessoDadoBean());
						objRetorno = metodo.invoke(AvaliacaoAcessoBean, null);
						
					}else if(classeMetodo.getSimpleName().equalsIgnoreCase("OcorrenciaRestricaoRegraBean")){
						OcorrenciaRestricaoRegraBean ocorrenciaRestricaoRegraBean = (OcorrenciaRestricaoRegraBean)classeMetodo.cast(new OcorrenciaRestricaoRegraBean());
						objRetorno = metodo.invoke(ocorrenciaRestricaoRegraBean, null);
					}
				}
			}
		}catch (IllegalArgumentException ilegal){
			System.out.println("Erro");
		}catch (Throwable e) {
			System.err.println("-->" + e);
		}
		return objRetorno;
	}

 */
	
	private static String primeiraLetraMaiuscula (String nomeAtributo) {
		return nomeAtributo.substring(0,1).toUpperCase() + nomeAtributo.substring(1);
	}
	// Aqui supomos que o nome do atributo começa por minúscula ("abacaxiAbacate") e o 
	// getter segue exatamente as normas para getters ("getAbacaxiAbacate").
	// Isso é feito para evitar procurar em todos os métodos,
	// acelerando bastante o processamento. 
	// Também supomos que é um getter sem parâmetros (nas normas é possível ter 
	// getters "indexados" também).
	public static Object getRetornoMetodoReflectionByAtributo (Object obj, String nomeAtributo) {
		// Vamos ver se o objeto pertence a uma classe que tem esse getter
		try {
			Class klass = obj.getClass();
			Method meth = klass.getMethod("get" + primeiraLetraMaiuscula(nomeAtributo), new Class[]{});
			return meth.invoke(obj, new Object[]{});
		} catch (SecurityException e) {
			return null;
		} catch (IllegalArgumentException e) { // se o getter tiver mais de um argumento
			return null;
		} catch (NoSuchMethodException e) { // se não existir o getter
			return null;
		} catch (IllegalAccessException e) { // se o getter não for public
			return null;
		} catch (InvocationTargetException e) { // se o getter lançar uma exceção durante sua execução
			return null;
		}
	}
	

	private static String primeiraLetraMinuscula (String nomeAtributo) {
		return nomeAtributo.substring(0,1).toLowerCase() + nomeAtributo.substring(1);
	}

	/**
	 * Chama todos os getters de um determinado objeto.
	 * @param obj
	 * @return
	 */
	public static Map<String,Object> callAllGetters (Object obj) {
		Class klass = obj.getClass();
		Method[] methods = klass.getDeclaredMethods();
		Map<String,Object> valores = new LinkedHashMap<String,Object>();
		for (Method meth : methods) {
			String methName = meth.getName();
			if (methName.startsWith ("get") && !methName.equals("getClass")) {
				String nomeAtributo = primeiraLetraMinuscula(methName.substring(3));
				// Agora vamos ver se o tal método não tem argumentos
				// Se tiver, então não é um getter, e não iremos chamá-lo
				if (meth.getParameterTypes().length > 0)
					continue;
				// Se o getter não for público, não vamos chamá-lo
				if (!Modifier.isPublic(meth.getModifiers()))
					continue;
				// Agora vamos chamar o tal getter
				try {
					Object value = meth.invoke(obj, new Object[]{});
					// Acrescentando o resultado ao map de retorno
					valores.put(nomeAtributo, value);
				} catch (IllegalArgumentException e) { // não deve ocorrer
					e.printStackTrace();
				} catch (IllegalAccessException e) { // não deve ocorrer
					e.printStackTrace();
				} catch (InvocationTargetException e) { // se houver exception dentro do getter
					e.printStackTrace();
				}
			}
		}
		return valores;
	}

	/** Esta classe está bem simplficada, só para você ter uma idéia. */
	static class ModuloAcessoDadoBean {
		private String nome;
		private double saldo;
		public ModuloAcessoDadoBean (String nome, double saldo) {
			this.nome = nome; this.saldo = saldo;
		}
		public String getNome () { return nome; }
		public double getSaldo () { return saldo; }
		public void setNome (String nome) { this.nome = nome; }
		public void setSaldo (double saldo) { this.saldo = saldo; }
	}
	
	public static void main(String[] args) {
		Map<String,Object> valores = callAllGetters (new ModuloAcessoDadoBean ("Jose da Silva", 12345.67));
		System.out.println (valores);
	}
}