Como fazer um update e uma consulta?

package projetomail.cadastroCliente;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import projetomail.conexao.GerenciadorBancoDados;

/**
 *
 */
public class CadClienteDb {
    
       /* Padrão singleton
     *
     * Na engenharia de software, o padrão de projetos singleton é utilizado para restringir
     * a instância de uma classe para um (ou poucos) objeto. Singleton é útil quando exatamente
     * um objeto é necessário para coordenar as ações entre sistemas ou camadas de um sistema.
     * Também é util para otimizar o uso de recursos de hardware (ex. memória). É considerado um anti-padrão se utilizado para simular variáveis globais.
     *
     * O padrão singleton é implementado através da criação de classes com um método que cria
     * uma nova instância do objeto, caso não exista nenhuma. Se uma instância já existe, ele
     * simplesmente retorna a referência ao objeto. Para termos certeza que o objeto não será
     * instanciado mais de uma vez, o construtor é declarado privado ou protegido. 
     */
    
    /* início da implementação do padrão singleton */
    
    /*
     *construtor privado
     *previne a instancia do objeto
     */
    
    private CadClienteDb() {
    }
    
    /*
     *Metodo estático que deve ser chamado para instanciar um objeto da classe
     */
    public static CadClienteDb  getInstance(){
        return CadClienteDb.unicaInstancia.instance;
    } 
    
     /*
     *classe interna (inner class), estática com o objeto que deverá ser usado
     */
    private static class unicaInstancia{
        private static CadClienteDb instance = new CadClienteDb();
    }
    
    /* fim da implementação do padrão singleton */
    
    /* inicio da estrutura de persistencia */
    
    /* 
     * Lista ordenada dos objetos obtidos do banco de dados 
     */
     private LinkedHashMap listaObjetos = atualizaListaObjetos();
    
    /*
     * Método sincronizado (somente uma chamada por vez) utilizado para
     * realizar a atualização da lista de objetos
     */
    private synchronized LinkedHashMap atualizaListaObjetos(){
        LinkedHashMap retorno = new LinkedHashMap(); //instancia objeto de retorno
        try{
            Connection conexao = GerenciadorBancoDados.obterConexao(); //obtem o objeto de conexão
            ResultSet resultado; // declara variável que receberá o resultado da consulta
            String sql = "select codigo, cnpj, email from cliente order by codigo"; // monta string de consulta
            PreparedStatement ps = conexao.prepareStatement(sql); // prepara a consulta para execução

            resultado = ps.executeQuery(); // executa consulta e armazena resultado no objeto resultado

            // percorre os registros retornados
            while (resultado.next()){
                CadClienteMd clienteMd = new CadClienteMd(); //instancia um objeto modelo
                clienteMd.setCodigo(resultado.getInt("CODIGO")); //Atribui o valor do campo código retornado no sql para o atributo codigo do modelo
                clienteMd.setCnpj(resultado.getString("CNPJ")); //Atribui o valor do campo cnpj retornado no sql para o atributo cnpj do modelo
                clienteMd.setEmail(resultado.getString("EMAIL"));//Atribui o valor do campo email retornado no sql para o atributo email do modelo
               
                // lPadrao.setListaItens(itensPadraoDb.getInstance().obterLista(lPadrao.getCodigo(),true));
                
                retorno.put(String.valueOf(clienteMd.getCodigo()),clienteMd); //insere objeto na lista de objetos (linkedhashmap), parâmetros: código e objeto
            }
            
        } catch (Exception e){
            System.out.println(e.getMessage());
        } finally{
            return retorno;
        }
    }
    
     /*
     * Método responsável por atualizar os dados da lista com os dados do banco
     */
    private void atualizarLista(){
        listaObjetos.clear();
        listaObjetos = atualizaListaObjetos();
    }
    
    /* fim da estrutura de persistencia */
    
    /* início dos metodos públicos para interação com a camada de controle */
    
    /*
     * Método responsável por inserir um objeto na lista de objetos existentes e 
     * executar a persistencia no banco
     * Parâmetros:
     * pObjeto: objeto de modelo com os dados que devem ser inseridos
     * Retorno:
     * true no caso de sucesso e false no caso de falha
     */
    public boolean salvarObjeto(CadClienteMd clienteMd){
        boolean retorno = false;
        try{
            Connection conexao = GerenciadorBancoDados.obterConexao(); //obtem objeto de conexao
            String sql = "insert into cliente (codigo,cnpj,email) values (?,?,?)";  //sql de inserção na tabela, no lugar dos valores utiliza-se "?", 
                                                                            //sendo que os valores serão passados depois
            PreparedStatement ps = conexao.prepareStatement(sql); //prepara o sql para execução
            ps.setInt(1, clienteMd.getCodigo()); //insere o valor do atributo código na posição 1
            ps.setString(2, clienteMd.getCnpj()); //insere o valor do atributo cnpj na posição 2
            ps.setString(3, clienteMd.getEmail()); //insere o valor do atributo email na posição 3
           
            //itensPadraoDb.getInstance().atualizarListaObjetos(pObjeto.getListaItens());
            
            ps.execute(); // executa o sql, inserindo o registro na tabela
            listaObjetos.put(String.valueOf(clienteMd.getCodigo()),clienteMd); //insere o objeto na lista de objetos
            retorno = true;
        }catch(Exception e){
            System.out.println(e.getMessage());
            retorno = false;
        }finally{
            return retorno;
        }
    }
    
     /*
     * Método responsável por atualizar (alterar) um objeto na lista de objetos existentes e 
     * executar a persistencia no banco
     * Parâmetros:
     * pObjeto: objeto de modelo com os dados que devem ser inseridos
     * Retorno:
     * true no caso de sucesso e false no caso de falha
     */
    public boolean atualizarObjeto(CadClienteMd clienteMd){
        boolean retorno = false;
        try{
            Connection conexao = GerenciadorBancoDados.obterConexao();//obtem objeto de conexao
            String sql = "update cliente set cnpj = ?, email = ? where codigo = ?"; //sql de alteração do registro, no lugar dos valores utiliza-se "?", 
                                                                        //sendo que os valores serão passados depois
            PreparedStatement ps = conexao.prepareStatement(sql);//prepara o sql para execução
            ps.setString(1, clienteMd.getCnpj());//insere o cnpj do atributo cnpj na posição 1
            ps.setString(2, clienteMd.getEmail());//insere o email do atributo email na posição 2
            ps.setInt(3,clienteMd.getCodigo());//insere o valor do atributo código na posição 3
            ps.execute();// executa o sql, alterando o registro na tabela
           
            //itensPadraoDb.getInstance().atualizarListaObjetos(pObjeto.getListaItens());
            
            listaObjetos.put(String.valueOf(clienteMd.getCodigo()),clienteMd); //sobrepoe o objeto da lista de objetos com o objeto alterado
            retorno = true;
        }catch(Exception e){
            System.out.println(e.getMessage());
            retorno = false;
        }finally{
            return retorno;
        }                               
    } 
    
     /*
     * Método responsável por excluir um objeto na lista de objetos existentes e 
     * executar a persistencia no banco
     * Parâmetros:
     * pObjeto: objeto de modelo com os dados que devem ser inseridos
     * Retorno:
     * true no caso de sucesso e false no caso de falha
     */    
    public boolean excluirObjeto(CadClienteMd clienteMd){
        boolean retorno = false;
        try{
            Connection conexao = GerenciadorBancoDados.obterConexao();//obtem objeto de conexao
            String sql = "delete from cliente where codigo = ?"; //sql de exclusão do registro, no lugar dos valores utiliza-se "?", 
                                                                //sendo que os valores serão passados depois
            PreparedStatement ps = conexao.prepareStatement(sql);//prepara o sql para execução
            ps.setInt(1,clienteMd.getCodigo());//insere o valor do atributo código na posição 1
            ps.execute();// executa o sql, excluindo o registro na tabela
            listaObjetos.remove(String.valueOf(clienteMd.getCodigo()));//remove o objeto da lista de objetos
            retorno = true;
        }catch(Exception e){
            System.out.println(e.getMessage());
            retorno = false;
        }finally{
            return retorno;
        }
    }   
    
     /*
     * Método responsável por retornar um objeto da lista de objetos existentes 
     * Parâmetros:
     * pCodigo: chave do objeto que deseja retornar
     * pAtualizar: indica se quer realizar a atualização da lista com os dados do banco antes de localizar um objeto
     * Retorno:
     * Objeto solicitado ou null caso não encontre
     */    
    public CadClienteMd procurarObjeto(int pCodigo, boolean pAtualizar){
        if (pAtualizar)
            atualizarLista();
        if (listaObjetos.containsKey(String.valueOf(pCodigo)))
            return (CadClienteMd) listaObjetos.get(String.valueOf(pCodigo));
        else
            return null;
    }
    
     /*
     * Método responsável por retornar a lista de objetos existentes
     * Parâmetros:
     * pAtualizar: indica se deve ser chamado o método que atualiza a lista com os dados do banco
     * Retorno:
     * ArrayList de objetos
     */
     public ArrayList obterLista(boolean pAtualizar){
        if (pAtualizar)
            atualizarLista();
        return new ArrayList(listaObjetos.values());
    }    
    
    /* fim dos metodos públicos para interação com a camada de controle */

    
    
}