Já pensou em validar os atributos de uma classe? Verificar se todos estão preenchidos, sem precisar ficar digitando os atributos um a um...?
Precisei fazer isso essa semana no trabalho, porem eu teria que fazer um código genérico, que iria funcionar em qualquer classe (bean) que eu tivesse criado..
Então depois de umas 6 horas pesquisando, e testanto, descobri o pacote "java.lang.reflect", que possui algumas classes interessantes.
Para validar os atributos utilizei a classe "Method", e como todos os classes (beans) que criei são encapsuladas (utilizam os métodos get e set para acessar os atributos) foi bem simples...

imagine que vc tenha um bean Pessoa

package src.bean;

/**
 *
 * @author Ugleiton
 */
public class Pessoa {
    private String  nome;
    private String  telefone;
    private String  email;
    private int     idade;

    public Pessoa() {
    }

    public Pessoa(String nome, String telefone, String email, int idade) {
        this.nome = nome;
        this.telefone = telefone;
        this.email = email;
        this.idade = idade;
    }

    
    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public int getIdade() {
        return idade;
    }

    public void setIdade(int idade) {
        this.idade = idade;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getTelefone() {
        return telefone;
    }

    public void setTelefone(String telefone) {
        this.telefone = telefone;
    }

}

Agora imagine que em alguma tela, antes de salvar no banco de dados, vc deseja verificar se alguns campos foram preenchidos corretamente, dai vc pode utilizar a seguinte classe para validar...

package teste;

import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import DAO.DAOParametrosValidacao;

/**
 * Classe utilizada para percorrer os metodos getters e verificando o retorno
 * Os valores retornados serão checados de acordo com os parametros do BD
 * @author Ugleiton
 */
public class ValidObject {
    /**
     * obj.getClass().getMethods() retorna um vetor de metodos
     * o for percorre esses métodos verificando os nomes de cada um
     * e valida o retorno de acordo com o tipo.
     * @param Bean que será utilizada para a validação
     * @return Lista com métodos inválidos.
     */
    public static List isValid(Object obj) {
        //utilize um DAO e pegue do banco de dados os parametros desejados, filtrando por nome de BEAN
        //obj.getClass().getSimpleName() é o nome do BEAN 
        List parametros = DAOParametrosValidacao.getParametros(obj.getClass().getSimpleName());
        List metodosInvalidos = new ArrayList();
        if (parametros.size() == 0) {
            return metodosInvalidos;
        }
        for (String p : parametros) {
            for (Method method : obj.getClass().getMethods()) {
                //o nome do métodos começa com get e termina com o nome do parametro do banco
                if (method.getName().startsWith("get") && method.getName().endsWith(p)) {
                    try {
                        //System.out.println("Campo : " + method.getName());
                        if(!isValidObject(method.invoke(obj))){
                            metodosInvalidos.add(method.getName().replace("get", ""));
                        }
                    } catch (Exception ex) {
                    }
                }
            }
        }
        return metodosInvalidos;
    }

    private static boolean isValidObject(Object obj){
        if(obj instanceof Integer){
            return isValidInteger(obj);
        }else if(obj instanceof String){
            return isValidString(obj);
        }else if(obj instanceof BigDecimal){
            return isValidBigDecimal(obj);
        }else{
            throw  new RuntimeException("Tipo não identificado");
        }
    }

    private static boolean isValidInteger(Object obj) {
        Integer valor = (Integer) obj;
        if (valor == 0) {
            return false;
        } else {
            //System.out.println("Preenchido com: " + valor);
            return true;
        }
    }

    private static boolean isValidBigDecimal(Object obj) {
        BigDecimal valor = (BigDecimal) obj;
        if (valor.compareTo(BigDecimal.ZERO) == 0) {
            return false;
        } else {
            //System.out.println("Preenchido com: " + valor);
            return true;
        }
    }

    private static boolean isValidString(Object obj) {
        String valor = (String) obj;
        if (valor == null || valor.isEmpty()) {
            return false;
        } else {
            //System.out.println("Preenchido com: " + valor);
            return true;
        }
    }
}

Como utilizar?

List l = ValidObject.isValid(p);
if (l.size() == 0) {
    System.out.println("campos preenchidos corretamente");
}else{
    String nome = "";
    for (String str : l) {
        nome += str + "\n";
    }
    System.out.println("Campos não Preenchidos corretamente \n" + nome);
}