Desenvolvimento
Parabéns mais uma vez aos meus parceiros Boaglio e Edu pela matéria na revista MundoJ edição de aniversário 10 anos. Dessa vez teve a foto hein… não queimou a impressão, kkkkkkkkkkkkk
Use as redes sociais no seu sistema Play e faça o deploy nas nuvens de maneira totalmente gratuita. Por Eduardo Cerqueira e Fernando Boaglio
Aproveitando mais uma vez para dizer que passamos dos 3.400 acessos. Espero ter ajudado alguém nessa terra. rs
7º Passo: Executar a aplicação.
Ao executarmos a classe TestaConexão.java o programa irá entrar no “public static void main(String[] args)” que conforme ja mencionado é o ponto inicial de execução do programa, criar uma instância na classe ConexaoManutencao através do “new ConexaoManutencao();” e depois ao entrar no try-catch que é necessário para que o código tenha uma saida em caso de erro e vai para o nosso getConexao. Seguindo o método getConexao nosso programa vai rodar o que tem lá dentro e… e… vai dar erro, putz… teremos algo assim:
java.sql.SQLException: Driver nao encontrado at br.com.aula.dao.ConexaoManutencao.getConexao(ConexaoManutencao.java:28) at br.com.aula.beans.TestaConexao.main(TestaConexao.java:20) Caused by: java.lang.ClassNotFoundException: com.mysql.jdbc.Driver at java.net.URLClassLoader$1.run(Unknown Source) at java.net.URLClassLoader$1.run(Unknown Source) at java.security.AccessController.doPrivileged(Native Method) at java.net.URLClassLoader.findClass(Unknown Source) at java.lang.ClassLoader.loadClass(Unknown Source)...
O programa vai dar erro porque falta o driver de conexão entre a aplicação e o banco de dados, mas para facilitar a vida de nós programadores, os fornecedores dos bancos de dados são obrigados, e também para não perderem mercado, a disponibilizar um driver de conexão entre seu sistema e as linguagens de programação existentes, assim temos um arquivo .jar que basta adicionar ao sistema e zás, todo o código fonte entre a Java e MySQL, por exemplo, já pronto. Então vamos ao próximo passo.
8º Passo: Baixar o driver .jar do MySQL na página: http://dev.mysql.com/downloads/connector/j/ e carregá-lo na aplicação: Botão direito do mouse sobre a aplicação –> Properties –> Java Build Path –> “Libraries” –> Add External JARS e localizar o driver, no meu caso “mysql-connector-java-5.1.25.jar”.
9º Passo: Executar novamente aplicação.
Se a conexão for bem sucedida com o banco iniciado, tabela, etc teremos o seguinte log:
Obtendo conexao…
Conexao OK!
Conexao Fechada.
Caso o banco esteja parado por algum motivo ou o servidor não esteja acessivel teremos o seguinte log:
java.sql.SQLException: Erro ao obter a conexao at br.com.aula.dao.ConexaoManutencao.getConexao(ConexaoManutencao.java:31) at br.com.aula.beans.TestaConexao.main(TestaConexao.java:20) Caused by: java.lang.ClassNotFoundException: com.mysql.jdbc.Driver at java.net.URLClassLoader$1.run(Unknown Source) at java.net.URLClassLoader$1.run(Unknown Source) at java.security.AccessController.doPrivileged(Native Method) at java.net.URLClassLoader.findClass(Unknown Source) at java.lang.ClassLoader.loadClass(Unknown Source)...
Não sei se o exemplo foi muito claro ou simples demais, a idéia foi exibir um pequeno exemplo de conexão entre o Java e o MySQL, estou a disposição em caso de dúvidas e logo postarei outros exemplos com banco de dados. Até lá.
Irei apresentar neste post uma forma simples de conectar a aplicação java com um banco de dados, o exemplo de banco será o MySQL que é um banco gratuito, de simples instalação e bem aceito no mercado principalmente para aplicações de baixo nivel.
1º Passo: Instalar o MySQL e criar um database. (Não faz parte do meu exemplo ensinar passo-a-passo como instalar o MySQL, mas é facilmente encontrado na internet, para download: http://dev.mysql.com/downloads/installer/). Depois criar um database. Exemplo: “Produtos”.
2º Passo: Criar um novo projeto Java. File –> new –> java project. Exemplo: “ConexãoJDBC”.
3º Passo: Criar os pacotes que terão nossas classes java. Exemplo: br.com.aula.beans e br.com.aula.dao (data access object é um design pattern para conexões a banco de dados, mas não vou aprofundar nesse assunto, o nome do pacote “dao” é apenas um exemplo).
Então temos algo assim: 
4º Passo: Criar no pacote dao a classe ConexaoManutencao.java e no pacote beans a classe TestaConexao.java.
5º Passo: A classe ConexaoManutencao:
public class ConexaoManutencao {
private static final String STR_DRIVER = "com.mysql.jdbc.Driver";
// identificacao url do driver do banco de dados
private static final String USER = "root"; // usuario do database
private static final String PASSWORD = "root"; // senha do database
private static final String IP = "localhost";
// "localhost ou 192.168.0.1" para banco de dados em maquina local
// ou o ip ou nome da maquina servidor de banco de dados
private static final String DATABASE = "Produtos";
// Nome do banco de dados que ainda nao sera usado
private static final String STR_CON =
"jdbc:mysql://" + IP + ":3306/" + DATABASE;
// Aqui é criado uma string str_com que tem o endereco completo
// da conexao
public static Connection getConexao() throws SQLException {
Connection conn = null;
try {
Class.forName(STR_DRIVER);
conn = DriverManager.getConnection(STR_CON, USER, PASSWORD);
System.out.println("Obtendo conexao...");
return conn;
// acima obtenho uma conexao passando os parametros do database, usuario e senha
} catch (ClassNotFoundException e) {
String errorMsg = "Driver nao encontrado";
throw new SQLException(errorMsg, e);
// acima faco uma excessao para o driver do MySQL nao encontrado
} catch (SQLException e) {
String errorMsg = "Erro ao obter a conexao";
throw new SQLException(errorMsg, e);
// acima tenho uma excessao caso dê outro problema de conexao da
// aplicacao com o banco como problemas de rede, servico mysql parado, etc
}
}
// observe que para criar uma conexao é necessário um ter um try catch
// que permite dar outra saida ao codigo em caso de erro, parecido com IF/ELSE
public static void closeAll(Connection conn) {
try {
if (conn != null) {
conn.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
// acima tenho um metodo que fecha a conexao, importante para nao ficar
// com instancias desnecessarias conectadas ao banco de dados.
}
6º Passo: Testar a conexão com o banco de dados, classe TestaConexao.java
public class TestaConexao {
public static void main(String[] args) {
// TODO Auto-generated method stub
ConexaoManutencao cm = new ConexaoManutencao();
Connection conn = null;
try {
cm.getConexao();
System.out.println("Conexao OK!");
cm.closeAll(conn);
System.out.println("Conexao Fechada.");
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
Parabéns aos meus colegas Eduardo Cerqueira e Fernando Boaglio pela matéria na edição de jan/fev. da revista MundoJ.
Muito sucesso a vocês, sei que não foi fácil e o processo foi lento.
Abraços
Obs.: Faltou a foto novamente, fala sério.
Bem agora que o básico dos básicos já esta na ponta da língua acho necessário a instalação de uma IDE para ajudar na escrita dos nossos códigos, compilar e executar os programas, digo isso visando a agilidade. Pois bem, as duas mais famosas são o NetBeans e o Eclipse, muitos programadores, professores, etc evitam fazer comparações e arriscar um palpite para dizer qual dos dois é melhor, para não ficar em cima do muro, eu que já testei ambos afirmo que é o Eclipse por alguns motivos: não precisa de instalação, é mais leve para executar, mais fácil de se obter atualizações, mais utilizado no mercado, mais fácil de configurar e instalar programas auxiliares.
A última versão lançada do Eclipse é o Juno.
Para baixá-lo basta acessar o link: Eclipse e escolher o download de acordo com seu sistema operacional.
No Windows por exemplo basta extrair do zip, colocar em qualquer diretório, ex.: C:\ e clicar no executável dentro da pasta para abrir o programa da IDE ex.: C:\Eclipse\eclipse.exe.
Antes de abrir o programa o Eclipse pergunta onde é o diretório que você deseja salvar seus projetos, nos nossos exemplos é C:\Sistemas\
A missão agora é configurar o JDK que já está instalado na máquina para que o Eclipse reconheça, então acesse o caminho: Window -> Preferences -> Java -> Installed JREs, clicar em Add -> Selecionar Standart VM -> JRE Home: (apontar o caminho onde o JDK esta instalado) C:\Program Files\Java\jdk1.6.0_35 -> JRE Name: (Qualquer nome, geralmente é usado JDK+a versão do mesmo ex.: 6.0_35) -> Finish.
Pronto seu Java já esta configurado no Eclipse.
Agora para criar um projeto basta acessar -> File -> New -> Java Project -> Nome do Projeto e next, next, next, next, next… depois é só clicar com o botão direito do mouse no projeto criado -> New Class -> Nome da Classe -> next, next, next, next, next… para executar a classe que tem o método main é só clicar com o botão direito do mouse dentro da classe -> Run AS -> Java Application.
Agora é só criar muitos pacotes, classes, etc e etc.
O Fernando Boaglio já havia publicado dois posts sobre o Eclipse. 2003: http://www.boaglio.com/index.php/tutoriais/instalando-o-eclipse-no-windows/ e 05/2012: http://www.boaglio.com/index.php/category/eclipse/
—
Para estudar vou deixar uma dica legal, o vídeo 025 das video-aulas que já publiquei tem um exercicio de dado interessante, tente faze-lo conforme as indicações.
Até o próximo post, vlw 🙂
Neste exemplo além de criar as classes em pacotes(diretórios) diferentes serão exercitados lógica, métodos, conversão de String para Integer, formatação de data e hora e importação de classes em API´s e mais O.O.
Primeiro devemos criar os diretórios, que neste exemplo será: C:\workspace\ExercicioParse\br\com\util
No diretório(pacote) util criar a classe Datas.java e no pacote br criar a classe Principal.java
Datas.java
// aqui eu indico em qual pacote esta minha classe
package br.com.util;
// aqui eu importo uma classe da API que fica no endereço indicado para formatar a data
import java.text.SimpleDateFormat;
// aqui eu importo outra classe da API que fica no endereço indicado para buscar a data e hora atual
import java.util.Date;
public class Datas {
//criando o método obterDataAtual como publico para poder utilizar em outras classes do nosso sistema
public String obterDataAtual(){
//criando um formato para minha data
SimpleDateFormat formatoBrasileiro = new SimpleDateFormat("dd/MM/yyyy");
//recebendo a data atual e colocando na variavel data
Date data = new Date();
//aqui eu pego a data, coloco no formato que foi especificado pelo meu formatoBrasileiro e retorno a instrucao
return formatoBrasileiro.format(data);
}
public String obterHoraAtual(){
//aqui crio um formato para a hora
SimpleDateFormat formatoBrasileiro = new SimpleDateFormat("hh:mm:ss");
//recebo a hora atual e coloco na variavel hora
Date hora = new Date();
//aqui eu pego a hora, coloco no formato que foi especificado pelo meu formatoBrasileiro e retorno a instrucao
return formatoBrasileiro.format(hora);
}
}
package br;
// aqui eu importo a classe que eu mesmo criei para utilizar nesta classe
import br.com.util.Datas;
public class Principal {
// metodo main que sera executado
public static void main(String[] args) {
// criando uma instancia para a classe Datas
Datas datas = new Datas();
// aqui eu exercito um exemplo real de uso, como faco para saber quantos segundos tem a hora atual, entao eu obtenho a hora atual, coloco na variavel string teste e retiro os dois pontos, exemplo de 12:34:56 ficaria: teste = 123456
String teste = datas.obterHoraAtual().replace(":", "");
// calculo dos segundos
// aqui crio a variavel que recebe os campos 5 e 6 da variavel teste atraves do comando substring
String teste1 = teste.substring(4, 6);
// abaixo eu crio uma variavel inteira que recebe a string teste1 sendo convertido atraves do comando Integer.parseInt e como resultado tenho os segundos
int seg1 = Integer.parseInt(teste1);
// calculo dos minutos
String teste2 = teste.substring(2, 4);
int seg2 = Integer.parseInt(teste2);
// abaixo eu tenho os minutos sendo multiplicados por 60 para transformar em segundos dos minutos
seg2 *= 60;
// calculo das horas
// aqui eu crio uma variavel string teste3 diretamente do metoto obterHoraAtual sem nenhum tratamento
String teste3 = datas.obterHoraAtual();
// abaixo eu crio um array com o nome de "s" que vai receber as partes da minha hora separados por dois pontos através do comando slit
String s[] = teste3.split("\\:");
// aqui eu crio a variavel inteira seg3 que vai receber a posição 0 do meu array que tem as minhas horas
int seg3 = Integer.parseInt(s[0]);
// abaixo eu tenho os minutos sendo multiplicados por 3600 para transformar em segundos das horas
seg3 *= 3600;
// abaixo eu crio uma variavel inteira com a soma de todos os segundos contabilizados
int resultado = seg1 + seg2 + seg3;
// aqui eh impresso a data atual formatada
System.out.println("A data atual é: " + datas.obterDataAtual() );
// aqui eh impresso a hora atual formatada
System.out.println("A hora atual é " + datas.obterHoraAtual() );
// aqui eh impresso a duracao atual em segundos
System.out.println("A duracao de " + datas.obterHoraAtual() + " corresponde ha " + resultado + " segundos." );
}
}
Assim teremos essa saída:
Veja que para compilar e executar as classes também tem uma diferença.
Para conhecer mais as classes de API´s, como utilizar e também sobre substring, split, replace etc vale a pena conferir a documentação do java 7: http://docs.oracle.com/javase/7/docs/api/ , até o próximo post.
Até este momento todas as vezes que queremos imprimir algo como “Olá Mundo” a frase esta fixa no código, mas existem algumas formas de interação com o usuário, onde o próprio insere as informações e recebe uma resposta, assim como digitar dois números e receber a soma deles, neste post irei utilizar o JOptionPane que é uma função que o Java faz mas que fica dentro de uma biblioteca do Java, futuramente irei falar sobre bibliotecas Java e como utilizá-las, mas por enquanto vou passar apenas essa do JOptionPane que irei usar.
Todo o código será o mesmo da Fase 2, a mudança esta apenas na classe VeiculoTeste que possui nosso método “main” e que é utilizado na impressão.
import javax.swing.JOptionPane;
// aqui eu importo a biblioteca que contém o JOptionPane
public class VeiculoTeste {
public static void main(String args[]) {
// classe VeiculoTeste continua com o "main" para imprimir o resultado do meu programa.
// Imprimindo o Carro
Carro c = new Carro();
String nome = null, cavalos = null, cilindradas = null, roda = null, combustivel = null, desloca = null, volante = null, cor = null, modelo = null;
// Aqui eu crio variaveis do tipo String para receber os valores digitados
nome = JOptionPane.showInputDialog("Qual é o Nome?");
modelo = JOptionPane.showInputDialog("Qual é o Modelo?");
cor = JOptionPane.showInputDialog("Qual é a Cor?");
cavalos = JOptionPane.showInputDialog("Quantos Cavalos?");
cilindradas = JOptionPane.showInputDialog("Quantas Cilindradas?");
roda = JOptionPane.showInputDialog("Qual é a Roda?");
combustivel = JOptionPane.showInputDialog("Qual é o Combustivel?");
desloca = JOptionPane.showInputDialog("Qual é o Deslocamento?");
volante = JOptionPane.showInputDialog("Qual é o Volante?");
// Acima eu usei o JOptionPane com uma caixa de dialogo para perguntar ao usuário a descrição do Carro.
// Abaixo estou setando o que o usuário escrever dentro de cada Carro.Descrição
c.setNome(nome);
c.setModelo(modelo);
c.setCor(cor);
long cavalosLong = Long.parseLong(cavalos);
c.m.setCavalos(cavalosLong);
// Como cavalos é do tipo Long fui obrigado a converter de string para long
int cilindradasInt = Integer.parseInt(cilindradas);
c.m.setCilindradas(cilindradasInt);
// Convertendo cilindradas para Integer
c.setRoda(roda);
c.setCombustivel(combustivel);
c.setDesloca(desloca);
c.setVolante(volante);
JOptionPane.showMessageDialog(null, c);
// Aqui eu imprimo o "c" que esta no ToString da classe Carro também usando o JOptionPane
// Aqui começo a imprimir o Barco
Barco b = new Barco();
nome = JOptionPane.showInputDialog("Qual é o Nome?");
cavalos = JOptionPane.showInputDialog("Quantos Cavalos?");
cilindradas = JOptionPane.showInputDialog("Quantas Cilindradas?");
combustivel = JOptionPane.showInputDialog("Qual é o Combustivel?");
desloca = JOptionPane.showInputDialog("Qual é o Deslocamento?");
volante = JOptionPane.showInputDialog("Qual é o Volante?");
b.setNome(nome);
b.m.setCavalos(cavalosLong);
b.m.setCilindradas(cilindradasInt);
b.setCombustivel(combustivel);
b.setDesloca(desloca);
b.setVolante(volante);
JOptionPane.showMessageDialog(null, b);
}
}
Maiores detalhes sobre entrada de dados estão nas video aulas 11 e 12 do link ja postado anteriormente.
Sobre bibliotecas existe uma documentação no site da Oracle que detalha o que cada biblioteca tem, com exemplos e funções especificas.
Obs.: Este humilde blog passou dos 1.500 acessos, espero ter ajudado alguém ou pelo menos incentivado o estudo. Até o próximo post.
🙂
Neste “post” utilizo o mesmo exemplo da primeira fase, porém com um código mais limpo, complexo e reaproveitável.
public class Veiculo {
// veja que a nossa Veiculo sofreu algumas modificações:
// foram incluidos os metodos: volante, nome, material e desloca; (antes eles estavam sendo instanciados dentro de cada tipo de veiculo sem necessidade uma vez que os mesmos metodos são comuns entre eles)
// retirado os metodos: *motor e **roda; (*o motor terá uma classe separada para receber maiores detalhes e a **roda é um item que só existia no carro)
private String volante;
private String combustivel;
private String nome;
private String material;
private String desloca;
public String getVolante() {
return volante;
}
public void setVolante(String volante) {
this.volante = volante;
}
public String getCombustivel() {
return combustivel;
}
public void setCombustivel(String combustivel) {
this.combustivel = combustivel;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getMaterial() {
return material;
}
public void setMaterial(String material) {
this.material = material;
}
public String getDesloca() {
return desloca;
}
public void setDesloca(String desloca) {
this.desloca = desloca;
}
}
public interface Acao {
void ligar();
}
public class Motor {
// aqui eu tenho uma classe *motor que por sua vez tem cilindradas e cavalos, essa especificação será utilizada futuramente e pode ser usado por qualquer tipo de veiculo ou não.
int Cilindradas;
long Cavalos;
public int getCilindradas() {
return Cilindradas;
}
public void setCilindradas(int cilindradas) {
Cilindradas = cilindradas;
}
public long getCavalos() {
return Cavalos;
}
public void setCavalos(long cavalos) {
Cavalos = cavalos;
}
}
public class VeiculoAquatico extends Veiculo {
// aqui foi criado um subtipo de Veiculo, trata-se de veiculo aquatico, essa classe esta bem simples e tem apenas o que o Veiculo tem (volante, combustivel, nome, material e desloca), mas poderia ter outras coisas como hélice, remos, velas, etc
}
public class VeiculoTerrestre extends Veiculo {
// aqui eu tenho outro subtipo de Veiculo, trata-se de veiculo terrestre, essa classe esta bem simples e além dos métodos do Veiculo tem também a **roda que foi transferido para os veiculos terrestres exclusivamente.
private String roda;
public String getRoda() {
return roda;
}
public void setRoda(String roda) {
this.roda = roda;
}
}
public class Barco extends VeiculoAquatico implements Acao {
// aqui eu tenho uma grande mudança, o Barco agora extends do VeiculoAquatico mas continua implements com a Acao
Motor m = new Motor();
// neste ponto eu digo que o tipo de veiculo aquatico barco tem um motor, este new motor() mostra que posso utilizar os métodos do motor através do apelido "m".
// outra grande mudança é o uso do toString na classe Barco, com ela eu informo qual tipo de informação a classe Barco vai imprimir quando for solicitado um print da mesma, isso será usado em todas as classes que imprimirem o Barco.
public String toString(){
return ("\n Nome: " + getNome()
+ "\n Motor: " + m.getCavalos() + " - Cavalos " + m.getCilindradas() + " - Cilindradas " // ja estou usando itens do motor()
+ "\n Combustivel: " + getCombustivel()
+ "\n Desloca: " + getDesloca()
+ "\n Comando: " + getVolante()
+ "\n Ligando..." );
}
// a Acao de ligar() não foi alterado
@Override
public void ligar() {
System.out.println("Tectectectectec...");
}
}
public class Carro extends VeiculoTerrestre implements Acao {
// Agora Carro passou a ser um VeiculoTerrestre que implements a Acao
// Possui motor()
Motor m = new Motor();
// Para mudar um pouco o exemplo foi colocado um particularidade para o Carro, ele terá também cor e modelo
String cor;
String modelo;
public String getCor() { // get and set da cor
return cor;
}
public void setCor(String cor) {
this.cor = cor;
}
public String getModelo() { // get and set do modelo
return modelo;
}
public void setModelo(String modelo) {
this.modelo = modelo;
}
// Aqui também utilizo o toString para impressão
public String toString(){
return ("\n Nome: " + getNome()
+ "\n Motor: " + m.getCavalos() + " - Cavalos " + m.getCilindradas() + " - Cilindradas "
+ "\n Roda: " + getRoda()
+ "\n Combustivel: " + getCombustivel()
+ "\n Desloca: " + getDesloca()
+ "\n Comando: " + getVolante()
+ "\n Cor: " + getCor() //cor
+ "\n Modelo: " + getModelo() //modelo
+ "\n Ligando..." );
}
//aqui esta o metodo da acao
@Override
public void ligar() {
System.out.println("Vrummmmmmmmmmm...");
}
}
public class VeiculoTeste {
public static void main(String args[]) {
// classe VeiculoTeste continua com o "main" para imprimir o resultado do meu programa.
// Imprimindo o Carro
Carro c = new Carro();
// New Carro - colocando os valores.
c.setCombustivel("Gasolina");
c.setNome("Fusca");
c.setDesloca("Asfalto");
c.setVolante("Volante Preto");
c.setRoda("Aro 15");
//Traduzindo: carro.motor.cavalos = 97 ; carro.motor.cilindradas = 1000;
c.m.setCavalos(97);
c.m.setCilindradas(1000);
// Imprime o que o toString do Carro estiver mandando com os valores que eu coloquei acima
System.out.println(c);
// Faz minha Acao
c.ligar();
// pula
System.out.println(" ");
// pula
// Idem para imprimir o Barco
Barco b = new Barco();
b.setCombustivel("Gasolina");
b.setNome("Mercure 200");
b.setDesloca("Agua");
b.setVolante("Manche Azul");
b.m.setCavalos(500);
b.m.setCilindradas(5200);
System.out.println(b);
b.ligar();
}
}
Essa é a saída do meu programa:
Continuando com exemplos de códigos para quem esta estudando Java resolvi criar um caso de uso simples para fazer um programa fácil que vai evoluir conforme o tempo, mudando e melhorando o código, explicando ponto a ponto cada item.
Nosso programa será um sistema para cadastro de veículos, este veículo terá caracteristicas, ações e particularidades que vai diferenciar um veículo de outro.
A primeira classe chama-se Veículo, ela contém métodos comuns para todos os futuros veículos do programa. Segue modelo abaixo:
Abaixo é criado uma interface com a função de ‘ligar’, todos os veículos que implementarem dela deverá ter o método para essa interface:
Aqui eu crio meu primeiro veículo, trata-se de um Barco, veja que barco “é um” veículo (extends) e “tem uma” ação (implements), maiores detalhes no exemplo abaixo:
Outro veículo, agora eu tenho um carro:
Por fim a classe teste que será executada (main), aqui os atributos ganham suas descrições e logo mando imprimir (System.out.print) :
A saída do meu código será essa:
Dica: Quem quiser saber mais a fundo a teoria sobre encapsulamento, polimorfismo e herança… GOOGLE !
No próximo post será mostrado uma das formas de se melhorar esse código, minha idéia é usar esse mesmo exemplo em pelo menos 3 posts, mostrando alguns exemplos práticos do nosso querido Java, dúvidas, sugestões e reclamações são bem vindos, até lá !
Recebi uma excelente dica de um amigo Alex Ferraresi e compartilho agora para quem realmente quer aprender Java, no youtube existem 116 vídeos de uma universidade que mostram passo a passo como programar. Estou no vídeo 005 e achando muito prático todos os exemplos, o mesmo segue a linha deste blog porém vendo e ouvindo o aprendizado torna-se melhor.
Logo postarei mais exemplos e lógicas, até…
Aprendendo a Linguagem Java! 