Integre Redes Sociais nas Nuvens com o Framework Play

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

Imagem

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

JDBC – Conexão Java + MySQL – 2ª Parte

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á.

JDBC – Conexão Java + MySQL – 1ª Parte

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: Imagem

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();
	}
	} 
}

IDE – Eclipse

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.

Imagem

 

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 🙂

Pacotes Java

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:
ExercicioParse
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.

Encapsulamento, Polimorfismo e Herança – Fase 3 – Entrada de Dados com JOptionPane

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.

🙂

Encapsulamento, Polimorfismo e Herança – Fase 2 – Melhorando nosso código

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:

Encapsulamento, Polimorfismo e Herança – Fase 1

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á !

Vídeo-Aulas

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.

Vídeo-Aulas (YouTube)

Logo postarei mais exemplos e lógicas, até…