Criação de Janelas Gráficas (GUI) com NetBeans (sobre a série vídeo aulas)

Neste post comento da série que chamei de Curso Básico de Criação de Janelas Gráficas (GUI) com NetBeans, que foi produzido um total de 10 vídeo aulas, contabilizando 2h:12m:30s de conteúdos para o YouTube, inteiramente gratuito.  No final deste post tem o link para baixar o código fonte.



Foi a minha primeira experiência na produção de vídeos para a internet e creio que aprendi muito. Recebi vários feedbacks de pessoas que nem conheço, no qual fico muito agradecido e motivado a tentar melhorar. Tenha certeza que nos próximos vídeos eu levarei em consideração as dicas sugeridas nos comentários de vocês, bem como espero contribuir cada vez mais nesta iniciativa.

Meus agradecimentos a todos que contribuem e contribuíram. Lembrem-se que é ajudando que se é ajudado, não é mesmo? :)

Um pouco sobre a série... 

Esta série de vídeo aulas objetiva ajudar alunos da disciplina de Programação Orientada a Objetos entender como criar janelas visuais usando NetBeans.

Endereço da série no canal do YouTube (com os 10 vídeos):
http://www.youtube.com/playlist?list=PLEA1EF325BD74F0E7

Endereço para baixar o projeto completo (versão do NetBeans 7.1.2 ou superior):
https://sites.google.com/site/douglasfrari/arquivos/SistemaCadastroProdutos.zip

Criando atalhos para geração de LOGs no Android usando templates do editor de código da IDE Eclipse

Este post objetiva compartilhar uma dica simples para geração de logs, que permitiu aumentar a produtividade na programação durante a realização desta atividade. Trata-se do uso do editor de templates do Eclipse para geração de código automático (famoso Ctrl+space+template

Tenho hábito e prática de utilizar logs na programação. De forma simples, isso nada mais é do que prover uma saída de dados textual na tela do console para visualizar o fluxo atual em execução no programa. Assim, podemos de forma rápida comprovar nossas hipóteses que o algoritmo está se comportando exatamente como o imaginamos. J Isso não é lindo? Para termos certeza que tudo vai correr bem é necessário fazer esse tipo de processo de validação N vezes até que tenhamos certeza absoluta que vai funcionar.

Geralmente através de testes de unidade, ou simplesmente para constatar se os comandos dados e as ordens programadas (formalmente escritas na forma de código fonte) foram percorridos como se esperava dentro do programa em execução, permitindo estruturar e validar o percurso do algoritmo e da lógica de programação como um todo. Dependendo da complexidade do software, podemos criar cenários não desejados – conhecidos como bugs. Nem tudo é perfeito minha gente! J

Percebo também que eu não sou o único que tem esse hábito de usar logs. Todos os programadores que conheço fazem isso.  Fazer logs é uma boa prática. No entanto, para fazê-lo precisamos escrever uma linha de código utilizando a criatividade, que varia de programador para programador. Se perder o controle e ficar criando log de tudo, pode poluir demasiadamente o código com comentários inúteis ou não mais necessários. Normalmente se usa algo como isso:

System.out.println(“*Classe*.metodo() - comentário opcional”);

System.out.println(“TelaCadastroCliente.salvar() – registrando dados ...”);

Na prática temos um exemplo concreto sem padrão algum, apenas para ver o valor da variável na saída:

public class Teste {

       static char caracter = 170;

      

       public static void main(String[] args) {

             

              System.out.println("valor = "+caracter);

              System.out.println("valor (int) = "+(int)caracter);

       }

}

Escrever a linha de comando System.out.println usando o Eclipse se torna fácil quando conhecemos o nome que chama o template para preenchimento automático. Por exemplo, se eu digitar “sysout + (Crtl+SPACE), o editor do Eclipse irá substituir a palavra “sysout” pelo comando System.out.println(), e ainda deixar o cursor dentro dos parênteses. Para quem não sabe você acabou de usar o template de código do editor Eclipse para códigos da linguagem Java. Isso não é show de bola? Os programadores sabem que isso torna o trabalho mais eficaz. Eu pelo menos me sinto muito animado quando uso editores assim.

Criando templates para geração de LOG automático para uso no emulador Android

O SDK do emulador Android oferece a saída de dados usando a janela do LogCat (Windows/Show View/Other/Android/LogCat), que fica disponível após instalar o plugin ADT. Nesta janela podemos visualizar os logs de acordo com o seu nível. Veja a tabela:

Nível	Sigla	Cor
Debug	D	azul
Verbose	V	preto
Info - Informação	I	verde
Warn - alerta	W	laranja
Error - erro	E	vermelho

Níveis de logs e suas cores

Assim, no Android temos que usar a classe android.util.Log para escrever os logs de acordo com os níveis disponíveis da tabela. Temos então no código:

Por exemplo, vamos criar o código abaixo e sua tecla de atalho correspondente:

Exemplo uso android.util.Log	Nome do Atalho pretendido
Log.d("SUA_TAG", "log DEBUG");	dbg
Log.i("DOUGLAS", "log INFORMATION");	dbgi
Log.e("DOUGLAS", "log ERROR");	dbge

Crie as tags acima no Eclipse usando uma tecla de atalho

Acesse a opção de preferências no menu principal do Eclipse, no caso do sistema operacional ser o Windows, use o atalho Windows/Preferences/. Na figura abaixo (A), observe o campo para digitar a busca. Digite o termo “templates” para filtrar a quantidade de opções disponíveis. Veja a imagem (B). Acesse opção Java/Editor/Templates/

(A)

(B)

Agora basta inserir novas entradas clicando no botão “New...”. (B) Crie 3 ou mais entradas de acordo com o código abaixo. Veja também a imagem (C).

(C)

Name	Description	Pattern
dbg	Log.DEBUG level (default)	Log.d("DOUGLAS","${enclosing_type}.${enclosing_method}${cursor}");
dbgi	Log.INFORMATION level	Log.i("DOUGLAS","${enclosing_type}.${enclosing_method}${cursor}");
dbge	Log.ERROR level	Log.e("DOUGLAS","${enclosing_type}.${enclosing_method}${cursor}");
…	…	…

Esse código é uma linguagem de expressão do Eclipse e faz com que o nome da classe atual seja obtida ( ${enclosing_type} ), e o nome do método atual seja obtido e substituído (${enclosing_method} ), e por fim, sete o cursor para o final deste comentário ( ${cursor} ).  Se desejar poderá criar outros templates estudando essa linguagem de expressão do Eclipse.

Após criar seus templates poderá utilizá-los durante a codificação do seu aplicativo no Android, e usar as teclas de atalho criadas. Ex. digite dbg + (Crtl+Space) e poderá ver as opções disponíveis do template. Assim que escolher um, o código será gerado automaticamente obtendo o nome da classe, o nome do método e você poderá ainda testar seu código neste trecho sem a necessidade de digitar todo o código.

Espero que essa dica seja útil para você tanto quanto está sendo para mim. J

Conceito de Encapsulamento em POO (java)

Oi pessoal! Antes de mais nada, se desejar me seguir no twitter está aqui (@douglasddf)

Neste post vou comentar o conceito chamado Encapsulamento relativo a programação orientada a objetos (POO). Observem as perguntas iniciais:

1. Por que encapsular informações em nosso programa? 
2. Como fazemos isso na prática usando Java?
3. É realmente necessário encapsular?

Essas questões são abordadas no vídeo que fiz (veja abaixo) para tentar responder as duas primeiras perguntas acima. Porém, a terceira pergunta é mais difícil de explicar. Alguém poderia dar uma resposta ou opinar sobre isso?

---

---

Encapsulamento, segundo Wikipédia (fonte: http://pt.wikipedia.org/wiki/Encapsulamento):

"Encapsulamento vem de encapsular, que em programação orientada a objetos significa separar o programa em partes, o mais isoladas possível. A idéia é tornar o software mais flexível, fácil de modificar e de criar novas implementações."

Ou seja, é uma forma de tornar visível para o usuário as funcionalidades que são importante para o sistema e somente isso. Em nosso exemplo, temos a classe Cliente que na prática, adicionou o tipo de acesso private do Java nos atributos e o tipo de acesso público nos métodos da classe. Só que foram criados um par de métodos (GET e SET) para recuperar e alterar, respectivamente, para cada atributo.

public class Cliente {

 // atributos para representar o cliente com acesso PRIVATE
 private String nome;
 private String CPF;
 private int quantidadePedidos;

 // para que se possa acessar os dados, criamos métodos PÚBLICOS get e set
 // para
 // cada atributo que se pretenda dar esse acesso

 /**
  * @return the nome
  */
 public String getNome() {
  return nome;
 }

 /**
  * @return the cPF
  */
 public String getCPF() {
  return CPF;
 }

 /**
  * @return the quantidadePedidos
  */
 public int getQuantidadePedidos() {
  return quantidadePedidos;
 }

 /**
  * @param nome the nome to set
  */
 public void setNome(String nome) {
  this.nome = nome;
 }

 /**
  * @param cPF the cPF to set
  */
 public void setCPF(String cPF) {
  CPF = cPF;
 }

 /**
  * @param quantidadePedidos the quantidadePedidos to set
  */
 public void setQuantidadePedidos(int quantidadePedidos) {
  this.quantidadePedidos = quantidadePedidos;
 }
 
 // operacoes que o cliente poderá
 // fazer neste sistema
 public void efetuarPedidoCompra() {
  System.out.println("efetuando pedido de compra");
  quantidadePedidos++;
 }

 // imprimir os seus valores
 @Override
 public String toString() {
  String atributosClasse = "Nome: " + nome + ", CPF: " + CPF
    + " , quantidade pedidos: " + quantidadePedidos;
  return atributosClasse;
 }

}

Isso simplesmente porque ao mudar o tipo de acesso aos atributos o Java não terá mais acesso a referência direta para LER e ESCREVER. Logo, temos que criar métodos para cada atributo GET e SET (sujestão de nome do Java). Desta maneira, quando precisarmos acessar (LER) o atributo do objeto usaremos:

  Cliente c = new Cliente();
  // acesso para ESCREVER (write)
  c.setNome("Douglas Frari"); 
  c.setCPF("222.222.222.11");
  
  // acesso para LER (read)
  System.out.println("Nome: "+c.getNome());
  System.out.println("CPF: "+c.getCPF());
  
  
  // ACESSO direto NAO é permitido pelo comilador java 
  // se não for da mesma classe. Logo, é preciso usar os SETs neste caso
  c.nome = "Douglas Frari";
  c.CPF = "222.222.222.11";
  

E quanto a pergunta 3 (É realmente necessário encapsular?)

É importante perceber que não é necessário encapsular para que o programa funcione. Mas é uma boa prática SIM encapsular os dados (atributos), pois assim tornamos o acesso DIRETO às referências dos objetos "seguros" do ponto de visto de escrita e leitura. O acesso somente será permitido usando os métodos públicos GET e SET.