Uma das coisas que mais gosto de fazer é ensinar a programação as pessoas. Imagine então, quando você encontra um site que tem esse propósito? :) O site code.org tem essa ideia e oferece uma oportunidade para aprender a programação, porém, de forma lúdica, ou seja, divertida.
Esse video acima mostra vários profissionais e pessoas conhecidas que falam da importância de aprender a programação. Eu já falei aqui no blog do porque isso é relevante [O que aprendi com a programação hoje: dia 6 - por que programar?], e não é somente eu quem está dizendo.
Estou utilizando o site do code.org para estimular alunos a gostarem da programação. Muitas vezes aprender a programar não é uma tarefa fácil para alunos, e nem para quem ensina. Mas quando tornamos o processo mais divertido: porque ELE pode SER assim, há bons resultados.
O vídeo acima demonstra um exemplo do que você pode encontrar no site indicado neste post.
Certificado de sucesso.
Ao final dos módulos, quando supera os desafios, você ganha o certificado e vai se sentir estimulado ir em frente ainda mais. :)
Esse post faz parte de uma série: o que aprendi com a programação, e tudo começou no dia 1.
Um grande aprendizado que me permitiu rever os meus "preconceitos" com a linguagem javascript foi entender como testar o meu código usando o Browser, e foi a série do vídeo abaixo que me ajudou.
Recomendo assistir:
Depois de assistir esse vídeo comecei a compreender como fazer a depuração usando o ambiente DevTool, que inclusive me permiti escrever um post sobre ele aqui [dia 3].
Neste post abordamos a continuidade da aula anterior (parte 1) sobre o conceito do Polimorfismo aplicado na prática. Desta vez mostramos como criar as próprias classes para utilizar o conceito.
Neste post abordaremos o conceito de programação orientada a objetos conhecido como Polimorfismo. Como aplicar o conceito na prática usando a linguagem Java. Para entendermos estou organizando alguns vídeos para ilustrar melhor duas formas de utilização:
Usando as classes da linguagem Java de algumas bibliotecas que já estão disponíveis;
Construir nossos próprios tipos e então entender como tirar proveito do Polimorfismo.
Neste pequeno artigo veremos o primeiro caso.
Polimorfismo precisa ter uma hierarquia de classes com herança. Fonte imagem
De acordo com a Wikipédia (fonte), podemos considerar o conceito de Polimorfismo:
"Na programaçãoorientada a objetos, o polimorfismo permite que referências de tipos de classes mais abstratas representem o comportamento das classes concretas que referenciam. Assim, é possível tratar vários tipos de maneira homogênea (através da interface do tipo mais abstrato). O termo polimorfismo é originário do grego e significa "muitas formas" (poli = muitas, morphos = formas).
O polimorfismo é caracterizado quando duas ou mais classes distintas tem métodos de mesmo nome, de forma que uma função possa utilizar um objeto de qualquer uma das classes polimórficas, sem necessidade de tratar de forma diferenciada conforme a classe do objeto.[1]"
Vejamos o exemplo que fiz no vídeo:
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class Polimorfismo_parte1 {
/**
* POLIMORFISMO (aula pr‡tica - parte 1)
*
* Objetivos:
*
* 1) Entender o conceito de Polimorfismo na pr‡tica
* usando as classes j‡ existentes no Java
*
* @author Douglas Frari
* @see http://profdouglas.blogspot.com
*/
public static void main(String[] args) {
ArrayList lista1 = new ArrayList();
List lista2 = new ArrayList();
List lista3 = new LinkedList();
lista1.add("Elemento 1");
lista1.add("Elemento 2");
lista1.add("Elemento 3");
lista2.add("Elemento 1.1");
lista2.add("Elemento 2.1");
lista2.add("Elemento 3.1");
lista3.add("Elemento 1.1.1");
lista3.add("Elemento 2.1.1");
lista3.add("Elemento 3.1.1");
// imprimir elementos
imprimirLista(lista1);
imprimirLista(lista2);
imprimirLista(lista3);
}
static void imprimirLista(final List lista) {
for (String itemLista : lista) {
System.out.println(itemLista);
}
}
}
Conclusões
O conceito de polimorfismo em programação orientada a objetos é bastante útil para compreender como os objetos podem assumir diferentes responsabilidades no programa, dependendo de como foram declarados e como são instanciados pode-se reusar estruturas e operações. O resultado disso pode não ser tão útil assim, mas é. Quando se entende o conceito começamos a pensar de forma a favorecer o reuso e assim minimizamos a quantidade de linhas de código programáveis.
Alguns anos atrás fiz um post relacionado sobre o processo de depuração no Eclipse. Desta vez resolvi criar uma vídeo aula para exemplificar o processo passo a passo.
No contexto de programação como podemos entender o que é a depuração e como fazê-la acontecer na prática? Quase sempre quando trabalho com novas turmas vejo uma grande maioria dos alunos ainda não utilizou esse precioso recurso do programador. O objetivo deste post é dar uma noção básica e mostrar como fazer na prática usando a IDE Eclipse. (fonte do post original Depuração no Eclipse (debugger))
Em resumo, depuração (do inglês debugging) é um processo de acompanhamento do programa a fim de acompanhar o fluxo de execução passo a passo, seguindo as linhas de codificação do ponto inicial até o ponto final do algoritmo que está sendo interpretado pelo computador. Minha percepção do porquê depurar o código... Podemos acompanhar o ciclo de vida do aplicativo (do início ao fim), procurando verificar o valor de variáveis, de expressões, acessando métodos entre outras possibilidades.
"Na minha opinião a principal vantagem é permitir o acompanhamento em tempo real. Já resolvi muitos bugs em menor tempo por utilizar esse recurso. Na prática, percebemos nosso erro de lógica quando podemos entender o que o computador está fazendo em determinada situação. A maioria das vezes o erro é do próprio programador que não previu determinada situação. Ao perceber isso, com ajudada da depuração, temos mais probabilidade de corrigir o bug alterando a lógica do programa."
Neste post abordarei sobre a instalação do Android SDK e a instalação do plugin ADT para desenvolver com a IDE Eclipse, bem como algumas dicas para atualizações automáticas dos seus componentes.
Pré-requisitos para instalação e configuração dos ambientes:
1) Eclipse IDE (versão + recente) - usei a JUNE 4.2 de 32 bits;
2) Android SDK (versão + recente);
3) JDK 1.6 ou superior;
4) JRE (no path do SO)
5) Página com instruções para instalação do Plugin ADT
Configurações mínimas do hardware e software do sistema operacional
Inicialmente você deve baixar todos os programas indicados acima. Pode ser que você já tenha o interpretador Java (JRE), entretanto, vai precisar o JDK para programar para Android. Veja a figura (1) destacando que não basta a JRE.
Siga as dicas do vídeo ou então siga os passos seguintes:
Baixe o Eclipse IDE [pré-requisito é o item (1)];
Baixe e instale o Android (no caso do Mac OS é apenas um zip);
Rode o Eclipse e instale o plugin ADT (URL download abaixo):
https://dl-ssl.google.com/android/eclipse/
Baixe os pacotes do emulador Android (siga essas dicas);
Configure o Eclipse para fazer checagem automáticas de atualizações do plugin (veja o vídeo acima)
Crie um atalho para um emulador AVD (Android Virtual Device) (dicas aqui);
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.
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),
para personalização dos níveis de logs existentes da plataforma Android
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:
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).
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
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:
Por que encapsular informações em nosso programa?
Como fazemos isso na prática usando Java?
É 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 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 SIMencapsular 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.
Compreende as diferenças de usar uma classe pronta da linguagem Java e definir a sua própria?
O que os objetos tem haver com isso?
Assista, pratique e descubra! :)
Objetivos vistos na aula 2:
1 - Entender o conceito de classe;
- discutido na aula 1;
2 - Criar uma classe para fazer algo;
2.1) mostrar na prática classe chamada Teste
2.2 - escrever na saída de dados um texto qualquer;
2.3 - Entender o processo Codificar/Compilar/Executar sem IDE :)
import java.util.Date;
public class Teste {
public static void main(String[] argumentos) {
// o programa ira comecar por essa classe
System.out.println("Oi JAVA!! ");
Date dataAtual = new Date();
System.out.println("Data Atual é: " + dataAtual.toString());
// criar um cliente
// criar um objeto do tipo Cliente
Cliente cliente1;
cliente1 = new Cliente();
cliente1.nome = "Douglas Frari";
cliente1.CPF = "721.XXX.XXX.XX";
cliente1.efetuarPedidoCompra();
cliente1.efetuarPedidoCompra();
cliente1.efetuarPedidoCompra();
cliente1.efetuarPedidoCompra();
// definicao do objeto
Cliente cliente2;
// instanciando objeto cliente
cliente2 = new Cliente();
// escrita no objeto (write)
cliente2.nome = "Maria Eduarda";
cliente2.CPF = "543.323.321.12";
System.out.println("Nome do cliente 1: " + cliente1.toString());
System.out.println("Nome do cliente 2: " + cliente2.toString());
}
}
public class Cliente {
// atributos para representar
// um cliente no sistema ATUAL
String nome;
String CPF;
int quantidadePedidos;
// operacoes que o cliente poderá
// fazer neste sistema
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;
}
}
Conclusão parcial
Programar sem uma IDE é essencial. É claro que utilizar IDE torna o trabalho mais produtivo e a ideia é exatamente essa. Porém, como pretende ser um bom programador se não compreender o que essas ferramentas fazem sem que você perceba? Outro aspecto destacado foi o uso de classes em duas abordagens distintas. Veremos mais sobre isso nos próximas aulas. O código fonte refere-se as aulas 2, 3, 4 e 5. Porém, somente publiquei até o momento de hoje a aula 2. Em breve mais!
