[quote]pra ajudar a fazer validações e executar algumas rotinas comuns no Brasil, isso de colocar banco de dados no meio, ainda mais incompleto, não me parece uma boa idéia.
[/quote]
Cara, ninguem vai botar bd no meio de nada.Vai continuar a ser uma API de Validações e Rotinas Comuns a usuários(brasileiros ou não).
Eu jah falei, criar um banco de CEPs requer direitos PERTENCENTES aos Correios.Eu jah sei uma página onde tem um banco integral para download, mas nem posso por o link aqui pois seria infringir uma regra de direito de propriedade.
A idéia de como validar ainda é válida(e atéh mesmo uma forma de armazená-la).Poderemos ter até o meio de fazê-lo,o que é diferente de armazená-la. 
Tudo bem que a base eh protegida por direito autoral. Ofereca aos usuarios a opcao de compra-la, e tenha codigo prontinho pra falar com ela
Pra nao ficar chato, ofereca uma “versao demo” da base com uns 10 registros inventados, so pros desenvolvedores poderem garantir que tudo funciona antes de comprar a base. Simples, eficiente, e se bem documentado, fica duca 
Puxa, o correio não é uma empresa pública? O CEP não é uma informação pública? Não?
Bom, esse cadastro deveria ser publicamente acessível na minha opinião, ou possível de ser adquirido com uma taxa de custo.
[quote]Puxa, o correio não é uma empresa pública? O CEP não é uma informação pública? Não?
Bom, esse cadastro deveria ser publicamente acessível na minha opinião, ou possível de ser adquirido com uma taxa de custo. [/quote]
Renato manipular o CEP não tem problemas.Mas TODA a base é de propriedade dos correios.(Eles devem comercializá-la ou algo assim para o caixa2 dos funcionários… :twisted: )
Li num fórum(acho que foi o do PosgreSQL), que tinha um bando de empecilhos em usá-la(a base completa).
Mas quem precisa, é só pesquisar q acha.São uns 10MB zipados(+ de 30 no total- Ei,VC!Eu nao estou estimulando ninguém a baixá-la, aviso de isenção TOTAL de responsabilidade! 
).
Só disse que ela existe…
Bom galera, também quero participar!
Logo, logo mandarei alguns fontes!
Turma, acabei de fazer um código que ele irá converter o tipo de logradouro para sem extensão.
Ex:
“Av. São Miguel” para “Avenida São Miguel”
você aida poderá escolher o tipo de retorno, se será em upper, lower ou normal case.
O código segue abaixo, criei mais uma classe como teste, para vê o resultado.
Você cria uma instância da classe logradouro passando para o seu construtor o endereço e o tipo de retorno, e em um método getter, você pega o valor alterado. Mesmo que o seu endereço não tenha nada o que alterar, não dará problema.
Classe para o BrazilUtils
[code]import java.util.StringTokenizer;
/**
-
Classe para transformação de padrões de logradouros. Ex:
-
Você digita como endereço, “Av. Sete de Setembro” e então transformado para Avenida Sete de Setembro
-
você poderá perdir o retorno em normal case, upper case ou lower case.
-
@author Inocêncio T. de Oliveira
-
@nick Grinvon
*/
public class logradouro
{
public static final int RETURN_NORMALCASE = 0;
public static final int RETURN_UPPERCASE = 1;
public static final int RETURN_LOWERCASE =2;private String end;
private String retorno = new String();
private String tok[] = null;
private StringTokenizer tokens = null;
private int fRetorno;/**
- Construtor que receberá o endereço e o formato de saída de texto
- @param endereco
-
@param formatoRetorno
*/
public logradouro(String endereco, int formatoRetorno)
{
this.end = endereco;
this.fRetorno = formatoRetorno;
transformar();
}
/**
-
Método privado que faz a transformação do logradouro
*/
private void transformar()
{
tokens = new StringTokenizer(end);
tok = new String[tokens.countTokens()];
int x=0;while (tokens.hasMoreTokens())
{
String logr = tokens.nextToken();logr = transLogradouro(logr); tok[x] = logr; x++;}
montarSaida(tok);
}
/**
-
Transforma um logradouro em sua forma não extensa
-
@param logradouro
-
@return
*/
private String transLogradouro(String logradouro)
{//caso seja Avenida
if ((logradouro.equalsIgnoreCase(“AV.”)) || (logradouro.equalsIgnoreCase(“AV”)))
if (fRetorno == this.RETURN_NORMALCASE)
logradouro = new String(“Avenida”);
else if (fRetorno == this.RETURN_LOWERCASE)
logradouro = new String(“avenida”);
else if (fRetorno == this.RETURN_UPPERCASE)
logradouro = new String(“AVENIDA”);//novos casos de logradouro serão aqui implementados
return logradouro;
}
/**
-
Monta a saída para ser pega em um método getter
-
@param tokens
*/
private void montarSaida(String[] tokens)
{
if (fRetorno == this.RETURN_NORMALCASE)
{
for (int i=0; i < tokens.length; i++)
{
if (i != tokens.length -1)
retorno += tokens[i] + " ";
else
retorno += tokens[i];
}
}if (fRetorno == this.RETURN_LOWERCASE)
{
for (int i=0; i < tokens.length; i++)
{
if (i != tokens.length -1)
retorno += tokens[i].toLowerCase() + " ";
else
retorno += tokens[i].toLowerCase();
}
}if (fRetorno == this.RETURN_UPPERCASE)
{
for (int i=0; i < tokens.length; i++)
{
if (i != tokens.length -1)
retorno += tokens[i].toUpperCase() + " ";
else
retorno += tokens[i].toUpperCase();
}
}
}
/**
- Método getter para obter o logradouro modificado
-
@return
*/
public String getLogradouro()
{
return retorno;
}
}[/code]
Classe que usei de teste
[code]public class teste
{
public teste()
{
String endereco = "Av. Sete de Setembro n1766";
logradouro logr = new logradouro(endereco,logradouro.RETURN_UPPERCASE);
System.out.println("Endereco: " + logr.getLogradouro() + ".X");
}
public static void main(String[] args)
{
new teste();
}
}[/code]
Algumas melhorias ainda pode vim, como você não precisar criar uma objeto da classe para cada tipo de retorno, podendo nessa mesma instância definir retornos diferentes, mas isso não é tão importante assim.
Bom espero ter ajudo, e espero que esse código esteja lá. Pelo menos a idéia dele
[quote=Grinvon]Turma, acabei de fazer um código que ele irá converter o tipo de logradouro para sem extensão.
Ex:
“Av. São Miguel” para “Avenida São Miguel”
você aida poderá escolher o tipo de retorno, se será em upper, lower ou normal case.
Algumas melhorias ainda pode vim, como você não precisar criar uma objeto da classe para cada tipo de retorno, podendo nessa mesma instância definir retornos diferentes, mas isso não é tão importante assim.
Bom espero ter ajudo, e espero que esse código esteja lá. Pelo menos a idéia dele [/quote]
Legal pra caramba…
Soh tenho uma critiva, vai ter de ser feito uma “engenharia” maior…
Sente só o número de logradouros possíveis:
[quote]Aeroporto
Alameda
Área
Avenida
Campo
Chácara
Colônia
Condomínio
Conjunto
Distrito
Esplanada
Estação
Estrada
Favela
Fazenda
Feira
Jardim
Ladeira
Lago
Lagoa
Largo
Loteamento
Morro
Núcleo
Parque
Passarela
Pátio
Praça
Quadra
Recanto
Residencial
Rodovia
Rua
Setor
Sítio
Travessa
Trecho
Trevo
Vale
Vereda
Via
Viaduto
Viela
Vila
[/quote]
Algumas sugestoes para a classe Logradouro:
:arrow: O nome da classe tem que comecar com letra maiuscula (Logradouro)
:arrow: A instrucao
if ((logradouro.equalsIgnoreCase("AV.")) || (logradouro.equalsIgnoreCase("AV")))pode ser simplificada para
String l = logradouro.toUpperCase();
if (l.equals("AV") || l.equals("AV.")):arrow: new String(“xxx”) eh redundante. Somente
logradouro = "Avenida";ja basta.
:arrow: Usar StringBuffer no metodo montarSaida. Ou seja, trocar
retorno += tokens[i] + " ";por
StringBuffer retorno = new StringBuffer(tokens.length * 2);
...
retorno.append(tokens[i]).append(" ");Um ultimo detalhe: fazer no braco, um-a-um, os if() para verificar as abreviacoes e entao tomar uma acao eh trabalho pra xuxu.
Rafael
[quote=Rafael Steil]:arrow: A instrucao
if ((logradouro.equalsIgnoreCase("AV.")) || (logradouro.equalsIgnoreCase("AV")))pode ser simplificada para
String l = logradouro.toUpperCase();
if (l.equals("AV") || l.equals("AV."))[/quote]
Ou ainda:
String l = logradouro.toUpperCase();
if ("AV".equals(l) || "AV.".equals(l))[]'s
Grivon,
Dei uma rápida olhada no código e gostaria de sugerir algumas coisas:
Dentro do método transLogradouro() deveria ter um else final retornando um tipo de logradouro padrão caso passe algo não presente nas possibilidades.
Acho que você deveria criar um constructor Logradouro(String endereco) e dentro dele chame Logradouro(String endereco, int formatoRetorno) passando o formato padrão, senão você obriga o programador a colocar um parâmetro eventualmente desnecessário.
Acho que você deveria usar duas variáveis internas para receber o endereço (variável end) como: tipo e nome, para oi tipo e o nome dologradouro. Em uma delas você coloca a primeira palavra antes do espaço. Essa é o tipo do logradouro (um dos presentes na lista que o velo postou). Na outra você coloca o que sobrou, que é o nome da rua ou avenida etc. Na hora dce transformat você trabsforma só a variável tipo, e no Get você devolve tipo + nome;
Observe o que o velo disse pois também estava pensando am algo assim e vi que deverá ter, dentro da classe, toda aquela lista que ele mostrou.
Vou conversar com o IronLinx e vamos criar um pacote “endereco” ou similar. Acho que a classe Logradouro deve fazer parte de uma maior chamada Endereco onde teria ainda o número e um complemento. Se tem Bairro, Cidade e o resto ainda devemos discutir.
Obrigado galera pelas sugestões,
Como eu tava no trabalho, fiz o código rápido, e então não deu tempo de da uma aperfeiçoada melhor.
Sim eu poderia usar StringBuffer, alias adoro SB, vou pensar em substituir e fazer algumas alterações, de qualquer forma estou feliz galera. Tendo mais tempo faço todas as modificações e posso criar coisas novas.
Legal Grinvon! :thumbup:
Junte-se a nós!
Aproveitando o barco, peguei um código para converter nums por extenso aqui no: http://www.portaljava.com/home/downloads/Extenso.java
Meu objetivo é quando tiver 3 casas depois da vírgula imprimir tipo:
12.123 (doze reais e cento e vinte três milésimos de real), mas tô tomando um couro do código… :x
//package brazilutils.currency.br
import java.math.BigInteger;
import java.math.BigDecimal;
import java.util.*;
import java.text.DecimalFormat;
/**
* Titulo: NumeroPorExtenso <p>
* Note:This class was writen in portuguese
* Descrição: Programa converte um numero para o valor em extenso <p>
*
*
*@author Ironlynx based on code found on PortalJava(www.portaljava.com)
* owned by Sérgio Eduardo Rodrigues
*@version 0.1
*@created 20/04/2005
*/
public class NumeroPorExtenso {
private List numeroLista;
private BigInteger num;
private String Qualificadores[][] = {//array de 2 linhas e 14 colunas[2][14]
{"milésimo de real","milésimos de real"},//[0][0] e [0][1]
{"centavo", "centavos"},//[1][0] e [1][1]
{"", ""},//[2][0],[2][1]
{"mil", "mil"},
{"milhão", "milhões"},
{"bilhão", "bilhões"},
{"trilhão", "trilhões"},
{"quatrilhão", "quatrilhões"},
{"quintilhão", "quintilhões"},
{"sextilhão", "sextilhões"},
{"setilhão", "setilhões"},
{"octilhão","octilhões"},
{"nonilhão","nonilhões"},
{"decilhão","decilhões"}
};
private String Numeros[][] = {
{"zero", "um", "dois", "três", "quatro", "cinco", "seis", "sete", "oito", "nove", "dez",
"onze", "doze", "treze", "quatorze", "quinze", "dezesseis", "dezessete", "dezoito", "dezenove"},
{"vinte", "trinta", "quarenta", "cinqüenta", "sessenta", "setenta", "oitenta", "noventa"},
{"cem", "cento", "duzentos", "trezentos", "quatrocentos", "quinhentos", "seiscentos",
"setecentos", "oitocentos", "novecentos"}
};
/**
* Construtor
*/
public NumeroPorExtenso() {
numeroLista = new ArrayList();
}
/**
* Construtor
*
*@param dec valor para colocar por extenso
*/
public NumeroPorExtenso(BigDecimal dec) {
this();
setNumero(dec);
}
/**
* Constructor for the Extenso object
*
*@param dec valor para colocar por extenso
*/
public NumeroPorExtenso(double dec) {
this();
setNumero(dec);
}
public void setNumero(BigDecimal dec) {
// Converte para inteiro arredondando os centavos
num = dec
.setScale(2,BigDecimal.ROUND_HALF_UP)// até 3 casas depois da vírgula
.multiply(BigDecimal.valueOf(100))
.toBigInteger();
// Adiciona valores
numeroLista.clear();
if (num.equals(BigInteger.ZERO)) {
// Centavos
numeroLista.add(new Integer(0));
// Valor
numeroLista.add(new Integer(0));
}
else {
// Adiciona centavos
addRemainder(100);
// Adiciona grupos de 1000
while (!num.equals(BigInteger.ZERO)) {
addRemainder(1000);
}
}
}
public void setNumero(double dec) {
setNumero(new BigDecimal(dec));
}
/**
* Description of the Method
*
*@return Description of the Returned Value
*/
public String toString() {
StringBuilder buf = new StringBuilder();
int numero = ((Integer) numeroLista.get(0)).intValue();
int count;
for (count = numeroLista.size() - 1; count > 0; count--) {
// Se ja existe texto e o atual não é zero
if (buf.length() > 0 && ! ehGrupoZero(count)) {
buf.append(" e ");
}
buf.append(numToString(((Integer) numeroLista.get(count)).intValue(), count));
}
if (buf.length() > 0) {
if (ehUnicoGrupo())
buf.append(" de ");
while (buf.toString().endsWith(" "))
buf.setLength(buf.length()-1);
if (ehPrimeiroGrupoUm())
buf.insert(0, "h");
if (numeroLista.size() == 2 && ((Integer)numeroLista.get(1)).intValue() == 1) {
buf.append(" real");
} else {
buf.append(" reais");
}
if (((Integer) numeroLista.get(0)).intValue() != 0) {
buf.append(" e ");
}
}
if (((Integer) numeroLista.get(0)).intValue() != 0) {
buf.append(numToString(((Integer) numeroLista.get(0)).intValue(), 0));
}
return buf.toString();
}
private boolean ehPrimeiroGrupoUm() { //milhar
if (((Integer)numeroLista.get(numeroLista.size()-1)).intValue() == 1)
return true;
return false;
}
/**
* Adds a feature to the Remainder attribute of the Extenso object
*
*@param divisor The feature to be added to the Remainder attribute
*/
private void addRemainder(int divisor) {
// Encontra newNum[0] = num modulo divisor, newNum[1] = num dividido divisor
BigInteger[] newNum = num.divideAndRemainder(BigInteger.valueOf(divisor));
// Adiciona modulo
numeroLista.add(new Integer(newNum[1].intValue()));
// Altera numero
num = newNum[0];
}
/**
* Description of the Method
*
*@param ps Description of Parameter
*@return Description of the Returned Value
*/
private boolean temMaisGrupos(int ps) {
for (; ps > 0; ps--) {
if (((Integer) numeroLista.get(ps)).intValue() != 0) {
return true;
}
}
return false;
}
/**
* Description of the Method
*
*@param ps Description of Parameter
*@return Description of the Returned Value
*/
private boolean ehUltimoGrupo(int ps) {
return (ps > 0) && ((Integer)numeroLista.get(ps)).intValue() != 0 && !temMaisGrupos(ps - 1);
}
/**
* Description of the Method
*
*@return Description of the Returned Value
*/
private boolean ehUnicoGrupo() {
if (numeroLista.size() <= 3)
return false;
if (!ehGrupoZero(1) && !ehGrupoZero(2))
return false;
boolean hasOne = false;
for(int i=3; i < numeroLista.size(); i++) {
if (((Integer)numeroLista.get(i)).intValue() != 0) {
if (hasOne)
return false;
hasOne = true;
}
}
return true;
}
boolean ehGrupoZero(int ps) {
if (ps <= 0 || ps >= numeroLista.size())
return true;
return ((Integer)numeroLista.get(ps)).intValue() == 0;
}
/**
* Description of the Method
*
*@param numero Description of Parameter
*@param escala Description of Parameter
*@return Description of the Returned Value
*/
private String numToString(int numero, int escala) {
int unidade = (numero % 10);
int dezena = (numero % 100); //* nao pode dividir por 10 pois verifica de 0..19
int centena = (numero / 100);
//int milhar= (numero%1000);
StringBuilder buf = new StringBuilder();
if (numero != 0) {//se zero não for digitado!!!
if (centena != 0) {
if (dezena == 0 && centena == 1) {
buf.append(Numeros[2][0]);//cem!
}
else {
buf.append(Numeros[2][centena]); //todos as demais centenas
}
}
if ((buf.length() > 0) && (dezena != 0)) {
buf.append(" e ");
}
if (dezena > 19) {
dezena /= 10;
buf.append(Numeros[1][dezena - 2]);
if (unidade != 0) {
buf.append(" e ");
buf.append(Numeros[0][unidade]);
}
}
else if (centena == 0 || dezena != 0) {
buf.append(Numeros[0][dezena]);
}
buf.append(" ");
if (numero == 1) { //até 1
buf.append(Qualificadores[escala][0]);//singular
}
else { //maior do que 1 adiciono o plural
buf.append(Qualificadores[escala][1]);//plural
}
}
return buf.toString();
}
public static void main(String[] args) {
if (args.length == 0) {
System.out.println("Digitar no console : java NumeroPorExtenso <numero>");
return;
}
NumeroPorExtenso teste = new NumeroPorExtenso(new BigDecimal(args[0]));
System.out.println("Numero : " + (new DecimalFormat().format(Double.valueOf(args[0]))));
System.out.println("Extenso : " + teste.toString());
}
}//fim da classe NumeroPorExtenso Se alguém quiser tentar,valeuzzz…
PS. Em último caso acho q converto tudo para String e vou testando casa a casa(e as vírgulas), mas ficaria um código 10x mais chato de ler do q esse…
Iron,
Eu tinha criado um programa desse em pascal, do qual ele convertia até o milhar, mas infelizmente não o tenho mais, mas acho que irei tentar fazer uma conversão dessa em Java.
Iron,
Só mais uma coisa! Já está criado a área no CVS?
Bom galera, fiz algumas modificações e acho que agora ficou melhor. Inclusive criei uma interface para colocar os tipos de logradouro, agora ficou melhor:
Class Logradouro
[code]
import java.util.StringTokenizer;
/**
-
Classe para transformação de padrões de logradouros. Ex:
-
Você digita como endereço, “Av. Sete de Setembro” e então transformado para Avenida Sete de Setembro
-
você poderá perdir o retorno em normal case, upper case ou lower case.
-
@author Inocêncio T. de Oliveira
-
@nick Grinvon
*/
public class Logradouro implements LogradouroIf
{
public static final int RETURN_NORMALCASE = 0;
public static final int RETURN_UPPERCASE = 1;
public static final int RETURN_LOWERCASE =2;private String end;
private String retorno = new String();
private String tok[] = null;
private StringTokenizer tokens = null;
private int fRetorno;/**
- Construtor que receberá o endereço e o formato de saída de texto
- @param endereco
-
@param formatoRetorno
*/
public Logradouro(String endereco, int formatoRetorno)
{
this.end = endereco;
this.fRetorno = formatoRetorno;
}
/**
-
Método privado que faz a transformação do logradouro
*/
private void transformar()
{
tokens = new StringTokenizer(end);
tok = new String[tokens.countTokens()];
int x=0;while (tokens.hasMoreTokens())
{
String logr = tokens.nextToken();logr = transLogradouro(logr); tok[x] = logr; x++;}
montarSaida(tok);
}
/**
-
Transforma um logradouro em sua forma não extensa
-
@param logradouro
-
@return
*/
private String transLogradouro(String logradouro)
{// o logradouro, a condicao, e o logradouro de saida
logradouro = converterLogradouro(logradouro,“AV”,LGR_AVENIDA);
logradouro = converterLogradouro(logradouro,“AV.”,LGR_AVENIDA);//novos casos de logradouro serão aqui implementados
return logradouro;
}
/**
-
Monta a saída para ser pega em um método getter
-
@param tokens
*/
private void montarSaida(String[] tokens)
{
if (fRetorno == RETURN_NORMALCASE)
{
for (int i=0; i < tokens.length; i++)
{
if (i != tokens.length -1)
retorno += tokens[i] + " ";
else
retorno += tokens[i];
}
}if (fRetorno == RETURN_LOWERCASE)
{
for (int i=0; i < tokens.length; i++)
{
if (i != tokens.length -1)
retorno += tokens[i].toLowerCase() + " ";
else
retorno += tokens[i].toLowerCase();
}
}if (fRetorno == RETURN_UPPERCASE)
{
for (int i=0; i < tokens.length; i++)
{
if (i != tokens.length -1)
retorno += tokens[i].toUpperCase() + " ";
else
retorno += tokens[i].toUpperCase();
}
}
}
/**
-
Pega o tokem do logradouro e o converte
-
@param logradouro
-
@param saidaLogradouro
-
@return
*/
private String converterLogradouro(String logradouro, String condicao, String saidaLogradouro)
{
if (logradouro.equalsIgnoreCase(condicao))
if (fRetorno == this.RETURN_NORMALCASE)
logradouro = saidaLogradouro;
else if (fRetorno == this.RETURN_LOWERCASE)
logradouro = saidaLogradouro.toLowerCase();
else if (fRetorno == this.RETURN_UPPERCASE)
logradouro = saidaLogradouro.toUpperCase();return logradouro;
}
/**
- Método getter para obter o logradouro modificado
-
@return
*/
public String getLogradouro()
{
transformar();
return retorno;
}
public void setTipoRetorno(int tipoRetorno)
{
retorno = “”;
this.fRetorno = tipoRetorno;
}
}[/code]
Interface de logradouros
/**
* Interface contendo os logradouros padrões
* @author Inocêncio T. de Oliveira
* @nick Grinvon
*/
public interface LogradouroIf
{
public static final String LGR_AVENIDA = "Avenida";
}Classe usada como teste
public class TesteLogradouro
{
public TesteLogradouro()
{
String end = "Av. Sete de Setembro";
Logradouro logr = new Logradouro(end, Logradouro.RETURN_NORMALCASE);
System.out.println("Endereco: " + logr.getLogradouro());
logr.setTipoRetorno(Logradouro.RETURN_UPPERCASE);
System.out.println("Endereco: " + logr.getLogradouro());
logr.setTipoRetorno(Logradouro.RETURN_LOWERCASE);
System.out.println("Endereco: " + logr.getLogradouro());
}
/**
*
* @param args
*/
public static void main(String[] args)
{
TesteLogradouro testeLogradouro = new TesteLogradouro();
}
}Boa Grinvon!!
Mais tarde eu olho legal isso, pois tô tendo que ler um pouco de UML para um trabalho…
Se associe como coder lah no projeto.
Quanto ao CVS, eu ainda não aprendi a mexer direito nesse troço( :roll: ),
Mas vou configurar esse WinCVS direito para ver o que dah…
Só lançaremos um “release” depois que fizermos uma reunião via lohis(provavelmente lah para Quarta da Semana que vem pois o pessoal tah viajando), definindo todos os passos a serem seguidos…
Quanto a classe de nums por extenso, ela só funciona até centavos(eu quero até milésimos de real),além de ter um Bug em números grandes.Eu jah tô começando a fazer só com String(ainda tah cons uns erros) e transformando em CharArray, mas fica muuuito difícil de ler devido que há muitos if´s aninhados… se tiver solução melhor, pode postar.!
Se vc quise eu lhe ajudo no CVS.
Certo, talvez eu tente fazer ainda hj uma solução para números extensos!
Pergunta: de onde veio o requisito de ter 3 tipos de casing diferentes? O usuario da API nao pode chamar toUpperCase e toLowerCase se quiser? :?
Eh vero…
Fica até mais facil…
C passa um default pra ele… Lah ele faz o q qr…
VELO
Pessoal, aqui segue uma proposta para a interface da classe Endereço. Observem que o retorno para UF, CEP e Logradouro é Object, pois retornará a UF já implementada, a classe CEP que está sendo feita e uma classe Logradouro baseada na que o grivon está fazendo.
public interface Endereco {
/**
* @return Returns the bairro.
*/
public abstract String getBairro();
/**
* @return Returns the cep.
*/
public abstract Object getCep();
/**
* @return Returns the cidade.
*/
public abstract String getCidade();
/**Aveniva Rio Branco 156, sala 1010
* ^-------^
* @return Returns the complemento.
*/
public abstract String getComplemento();
/**
* @return Returns the endereco.
*/
public abstract String getEndereco();
/** tipoLogradouro + nomeLogradouro
* @return The Complete Logradouro
*/
public abstract Object getLogradouro();
/**Aveniva Rio Branco 156, sala 1010
* ^--------^
* @return Returns the nomeLogradouro.
*/
public abstract String getNomeLogradouro();
/**Aveniva Rio Branco 156, sala 1010
* ^-^
* @return Returns the numero.
*/
public abstract String getNumero();
/**Aveniva Rio Branco 156, sala 1010
* ^-----^
* @return Returns the tipoLogradouro.
*/
public abstract String getTipoLogradouro();
/**
* @return Returns the uf.
*/
public abstract Object getUf();
/**
* @param bairro The bairro to set.
*/
public abstract void setBairro(String bairro);
/**
* @param cep The cep to set.
*/
public abstract void setCep(Object cep)throws EnderecoException;
/**
* @param cidade The cidade to set.
*/
public abstract void setCidade(String cidade);
/**Aveniva Rio Branco 156, sala 1010
* ^-------^
* @param complemento The complemento to set.
*/
public abstract void setComplemento(String complemento);
/** tipoLogradouro + nomeLogradouro
* @param logradouro The complete Logradouro to set.
*/
public abstract void setLogradouro(Object logradouro);
/**Aveniva Rio Branco 156, sala 1010
* ^--------^
* @param nomeLogradouro The nomeLogradouro to set.
*/
public abstract void setNomeLogradouro(String nomeLogradouro);
/**Aveniva Rio Branco 156, sala 1010
* ^-^
* @param numero The numero to set.
*/
public abstract void setNumero(String numero);
/**Aveniva Rio Branco 156, sala 1010
* ^-----^
* @param tipoLogradouro The tipoLogradouro to set.
*/
public abstract void setTipoLogradouro(String tipoLogradouro);
/**
* @param uf The uf to set.
*/
public abstract void setUf(Object uf) throws EnderecoException;
}Para CEP e UF há ainda a obrigatoriedade de tratar um possível erro, pois pode-se passar uma UF ou CEP inválidos. Aguardo sugestões.