Apostila Java
3 gostaram5,379 visualizações
O documento é uma apostila sobre a linguagem de programação Java, destinada a estudantes que desejam uma abordagem prática para aprender a linguagem. Ele inclui capítulos sobre a configuração do ambiente de desenvolvimento, conceitos de programação orientada a objetos, manipulação de arquivos e interações com banco de dados (JDBC). A apostila também contém exercícios resolvidos e propostos para consolidar o aprendizado.
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
2.5. O meu Alô Mundo
Agora chegou a hora de fazermos o nosso primeiro programa. Será um exemplo bem simples. Ele exibirá uma
mensagem de saudação na console do Eclipse.
1. Você deve abrir o seu Eclipse. Acessar File >> New >> Project. No campo Wizard digite: “Java Project”
Aperte Next >> Digite o nome “AloMundo”. Pressione Finish.
2. Acessar File >> New >> Classs.
No campo nome digite: “AloMundo”.
No campo package digite: “br.com.feltex.alomundo”.
3. Pronto. Agora digite o valor abaixo na sua classe.
1. package br.com.feltex.alomundo;
2.
3. public class AloMundo {
4.
5. public static void main(String[] args) {
6. System.out.println("Alo Mundo!!!");
7. }
8. }
Após isso clique com o botão direito na sua Classe AloMundo. Acesse Run >> “Run As Java Application”.
Saída
"Alo Mundo!!!"
Altere o programa anterior e faça a impressão da mensagem: “Batatinha quando nasce!”.
Exemplo disponível em: http://www.feltex.com.br/felix/hello-world/](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-14-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
Pare e revise
Seu código não funcionou? Veja o que pode ter ocorrido.
Mensagem Solução
Syntax error, insert "}" to complete
ClassBody
Esqueceu o último fechamento de chaves. Adicione “}” no final da
classe.
Syntax error on token ""Alo Mundo!!!"",
delete this token
O código System.out.println("Alo Mundo!!!"); foi adicionado fora do
método public static void main(String[] args) {
The public type Alomundo must be
defined in its own file
O nome da classe está diferente do arquivos. O Java é Case
Sensitive. Alomundo é diferente de AloMundo.
2.6. Formas de Entrada de dados
Podemos utilizar várias formas de entrada de dados em Java. As mais comuns são a classe Scanner e
JOptionPane.
Uma das tarefas mais comuns na programação é solicitar ao usuário alguns dados de entrada. Imagine um
sistema que realiza o cadastro de alunos. Nesse sistema é necessário que haja uma interface onde possamos
informar matrícula, nome, endereço, telefone, e-mail, data de nascimento entre outros dados do aluno.
Para isso precisamos de classes específicas que nos permitam realizar essas tarefas tão simples.
Vamos realizar a leitura do nome de um usuário:
package br.com.feltex.jse.lista1;
import javax.swing.JOptionPane;
public class Nomes {
public static void main(String[] args) {
String nome = "";
nome = JOptionPane.showInputDialog("Digite o nome:");
System.out.println("O nome digitado foi: " + nome);
}
}
2.7. Exibindo minhas mensagens
Há 2 formas básicas de exibirmos dados para o usuários. Uma utilizando os seguintes comandos:
System.out.println(“Minha mensagem”);
Não se esqueça da assinatura
correta do método “main”.](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-15-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
1. package br.com.feltex.jse.basico;
2. import javax.swing.JOptionPane;
3.
4. public class AloMundo {
5.
6. public static void main(String[] args) {
7. System.out.println("Minha mensagem");
8. System.out.print("Minha mensagem");
9. System.out.print("Minha mensagem");
10. JOptionPane.showMessageDialog(null, "Minha Mensagem");
11. }
12. }
2.8. Exercícios resolvidos
Exercícios
Escreva programas para:
1. Ler nome, idade e telefone de uma pessoa.
2. Ler o endereço e e-mail.
3. Calcular a idade a partir do ano de nascimento.
4. Ao final de cada programa imprimir uma mensagem com o dado lido.](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-17-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
package br.com.feltex.jse.basico;
public class AloMundo2 {
public static void main(String[] args) {
String nome1 = "Maria da Silva";
String nome2 = "Ana Paula";
int matricula1 = 2234;
int matricula2 = 334122;
System.out.println(nome1);
System.out.println(nome2);
System.out.println(matricula1);
System.out.println(matricula2);
}
}
Além desses tipos temos outros que chamamos de primitivos. Os tipos de armazenamento mais simples. Existem
8 tipos que podem ser visto no quadro abaixo. Observe que “String” apesar de ser um tipo muito utilizado não se
enquadra nesta lista. Veja que todos os tipos primitivos iniciam com letra minúscula. A palavra String começa
com letra Maiúscula. Use essa dica para lembrar quais são os tipos primitivos.
Nome Tipo Decimal inicial Tamanho
byte Numérico NÃO 0 8 bits
short Numérico NÃO 0 16 bits
int Numérico NÃO 0 32 bits
long Numérico NÃO 0 64 bits
float Decimal SIM 0.0f 32 bits
double Decimal SIM 0.0 64 bits
boolean Boleano -- false 16 bits
char Caracter -- /000 16 bits](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-23-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
Veja abaixo um programa com declaração de variáveis de tipo primitivo:
package br.com.feltex.jse.basico;
public class AloMundo2 {
public static void main(String[] args) {
byte idade = 10;
short sala = 105;
int ano = 2013;
long total = 334532;
char letra = 'A';
boolean diaUtil = true;
float media = 2.3f;
double salario = 22000.52;
String nome = "Maria da Silva";
System.out.println("Alo mundo!");
System.out.println("Idade: " + idade);
System.out.println("Sala: " + sala);
System.out.println("Ano: " + ano);
System.out.println("Total: " + total);
System.out.println("letra: " + letra);
System.out.println("diaUtil: " + diaUtil);
System.out.println("media: " + media);
System.out.println("salario: " + salario);
System.out.println("nome: " + nome);
}
}
Classes Wrapper
Para cada tipo primitivo temos as chamadas classes Wrapper (tipo de referência). Essas classes possuem métodos
auxiliam na manipulação dos valores primitivos.
Primitivo Wrapper
byte Byte
short Short
Int Integer
Long Long
float Float
double Double
boolean Boolean
• As principais funções dessas classes são:
• Constantes (MAX_VALUE, MIN_VALUE)
• Integer.MAX_VALUE, Integer.MIN_VALUE
• “valueof” (transformam um valor String em no tipo desejado)](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-24-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
Veja a o código abaixo:
package br.com.feltex.jse.basico.instrucao;
public class InstrucaoIF {
public static void main(String[] args) {
int x = 10;
int y = 30;
if (x > y) {
System.out.println("Verdadeiro");
} else {
System.out.println("Falso");
}
}
}
Neste programa é verificado se a variável x que tem o valor de 10 unidades é maior que o y que tem o valor de
30 unidades.
A saída “Falso”, pois “10 > 30”](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-29-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
Podemos ainda fazer o encadeamento de instruções IF com mais de uma condição.
package br.com.feltex.jse.basico.instrucao;
public class InstrucaoIF2 {
public static void main(String[] args) {
int x = 10;
int y = 30;
if (x > y) {
System.out.println("X é maior que Y!");
} else if (x < y) {
System.out.println("X é menor que Y!");
} else {
System.out.println("X é igual a Y!");
}
}
}
Neste código estamos verificando se X é maior, menor ou igual a Y.
3.6. Laços de repetição
Vamos falar código que criamos para executar algumas instruções de código por várias vezes.
Existem 3 formas de fazermos isso: for, while e do While.
O “for” é um caso de loop que utilizamos quando sabemos o número de iterações devemos executar em nosso
programa.
package br.com.feltex.jse.basico.instrucao;
public class Loop1 {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
System.out.println("O valor de i x:" + i);
}
}
}](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-30-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
O comando while realiza uma validação boolean no início de sua execução e continuará suas repetições
enquanto a condição for verdadeira. O bloco interno ao while pode nunca ser executado se a condição inicial for
falsa.
package br.com.feltex.jse.basico.instrucao;
public class LoopWhile {
public static void main(String[] args) {
int i = 0;
while (i <= 10) {
System.out.println("Valor de i: " + i);
i++;
}
}
}
Por último falaremos do loop do{ }while() a esse sempre executará as instruções dentro do laço, pelo menos
uma vez, pois a avaliação da condição de repetição só é validada no final.
package br.com.feltex.jse.basico.instrucao;
public class LoopDoWhile {
public static void main(String[] args) {
int i = 0;
do {
System.out.println("Valor de i: " + i);
i++;
} while (i <= 10);
}
}
As instruções de Loop possuem 2 comando que nos auxiliam a mudar o fluxo natural do código. São elas
continue e break.
O break realiza uma interrupção do laço e faz passa a ação para a primeira linha de código fora do loop. Veja o
exemplo abaixo:](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-31-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
package br.com.feltex.jse.basico.instrucao;
public class LoopWhileBreak {
public static void main(String[] args) {
System.out.println("Inicio");
int i = 0;
while (i <= 5) {
System.out.println("Valor de i: " + i);
i++;
if (i == 3){
break;
}
System.out.print(" depois do break!!");
}
System.out.println("Fim");
}
}
Quando a variável tiver o valor de 5 será executado o comando break que fará a quebra do laço de repetição e
próxima execução será a linha 15.](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-32-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
Para saber mais...
Existe uma forma de fazer o “for” incrementar por um valor diferente de “1”
Veja o exemplo a baixo e Observe que a variável “i” receber a adição de 2 a cada iteração.
package br.com.feltex.jse.basico.loop;
public class LoopForStep {
public static void main(String[] args) {
for (int i = 0; i <= 20; i += 2) {
System.out.println("Valor i: " + i);
}
}
}
O comando continue faz com que a execução volte para o início do loop sem executar as linhas logo abaixo
dele.
package br.com.feltex.jse.basico.instrucao;
public class LoopWhileContinue {
public static void main(String[] args) {
System.out.println("Inicio");
int i = 0;
while (i <= 5) {
System.out.println("Valor de i: " + i);
i++;
if (i == 3){
continue;
}
System.out.print(" depois continue!!");
}
System.out.println("Fim");
}
}
3.7. Exercícios resolvidos](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-33-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
Neste capítulo vamos trabalhar com as estruturas que armazenam vários dados em um mesmo objeto. É o que
podemos chamar de coleção.
4.1. Arrays
Começaremos com um array.
Desde o nosso primeiro programa fizemos uso de Array, mas não fomos oficialmente apresentados. Então agora
faremos as honras.
1. package br.com.feltex.jse.basico;
2. public class AloMundo {
3. public static void main(String[] args) {
4. System.out.println("Alo mundo!");
5. }
6. }
Observe que na linha 3, temos a declaração “String[] args”. O tipo definido é “String” e observe que temos um par
de colchetes. Isso define que teremos um array de String.
Podemos então
String[] arrayString = new String[5]; // Estamos criando um array de String com 5 posições
arrayString[0] = “Felix”;
arrayString[1] = “Maria”;
arrayString[2] = “Joana”;
arrayString[3] = “Marta”;
arrayString[4] = “Flavia”;
Nosso array fica preenchido assim:
Felix Maria Joana Marta Flavia
0 1 2 3 4
Atribuimos valores para todas as posições. Observe que começamos o índice do valor “0” (zero). Logo a
última posição vai ser 4 (quatro).
Vamos agora declarar um array de inteiros e um de double:
int[] arrayInteito = new int[3]; // Criação do array de inteiros
arrayInteito[0] = 10;
arrayInteito[1] = 27;
arrayInteito[2] = 4;
10 27 4
0 1 2
double[] arrayDouble = new double[3]; // Criação do array de double
arrayDouble [0] = 2.9;
arrayDouble [1] = 4.1;
arrayDouble [2] = 2.3;
2.9 4.1 2.3](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-36-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
0 1 2
Existem ainda outras formas de declararmos um array. Veja a seguir:
int[] arrayNumero = {5, 7, 90, 334}; // Criação do array com 4 posições.
int arrayNumero [] = {5, 7, 90, 334}; //Observe que mudamos a posição do par de colchetes
Isso é possível porque o Java nos permite criar muitas variáveis em uma mesma linha. Vejamos isso:
int arrayNumero[], x ; // Desta forma estamos declarando que arrayNumero é um array de inteiros e que x é um
número inteiro.
Int[] arrayNumero, x ; // Desta forma estamos declarando que tanto arrayNumero quanto x são arrays de
inteiro.
Viu como é fácil trabalhar com arrays? Vamos fazer um exemplo.](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-37-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
package br.com.feltex.jse.basico.array;
public class Array01 {
public static void main(String[] args) {
String[] arrayString = new String[5]; // Estamos criando um array de String com 5 posições
arrayString[0] = "Felix";
arrayString[1] = "Maria";
arrayString[2] = "Joana";
arrayString[3] = "Marta";
arrayString[4] = "Flavia";
for (int i = 0; i < arrayString.length; i++) {
System.out.println(arrayString[i]);
}
}
}
Pare e revise
Seu código não funcionou? Veja o que pode ter ocorrido.
Mensagem Solução
Exception in thread "main"
java.lang.ArrayIndexOutOfBoundsException: 0 at
br.com.feltex.jse.basico.array.Array01.main(Array01.java:14)
Verifique se você declarou o array certo dentro do
“for”
Não pode ser este “args[i]” tem que ser
arrayString[i]
Exception in thread "main"
java.lang.ArrayIndexOutOfBoundsException: 5 at
br.com.feltex.jse.basico.array.Array01.main(Array01.java:14)
Isto significa que está sendo procurada a posição
“5” do Array. Não existe a posição 5. Ele vai de
0...4. Verifique se seu for está assim:
“for (int i = 0; i < arrayString.length; i++) {“](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-38-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
4.2. Maps
Agora vamos ao uso dos maps. Map é uma estrutura no Java responsável por guardar pares de chave e
valor. Ele tem uma estrutura parecida com a imagem abaixo:
21 Rio de
Janeiro
11 São Paulo
83 João Pessoa
31 Belo
Horizonte
Na tabela acima temos as chaves os DDDs e no valor correspondente o nome da cidade. Isso também poderia
ser utilizado para definir os meses do ano:
1 Janeiro
2 Fevereiro
3 Março
4 Abril
No java declaramos os mas da seguinte forma4
:
Map<tipoDaChave, tipoValor> meuMapa = new HashMap< >();
Map< Integer, String> meuMapa = new HashMap< >();
Map<String, String> meuMapa2 = new HashMap< >();
Map< Integer, Integer> meuMapa3 = new HashMap< >();
Das formas apresentadas. Segue um exemplo de como utilizar os mapas.
package br.com.feltex.jse.colecao;
import java.util.HashMap;
import java.util.Map;
public class MeuMapa {
public static void main(String[] args) {
Map<Integer, String> meuMapa = new HashMap<>();
meuMapa.put(21, "Rio de Janeiro");
meuMapa.put(11, "São Paulo");
meuMapa.put(83, "João Pessoa");
meuMapa.put(31, "Belo Horizonte");
// Nao existe nenhum registro com a chave 45
System.out.println(meuMapa.get(21));
System.out.println(meuMapa.get(45));
System.out.println(meuMapa.get(31));
}
}
4
Apenas a partir da versão do Java 7 é possível usar a sintaxe “Map< Integer, String> meuMapa = new HashMap< >();” Antes era necessário
informar o tipo de dados do lado direito do = Map<Integer, String> meuMapa = new HashMap<Integer, String >();](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-39-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
package br.com.feltex.jse.colecao;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class MinhaListaArrayList {
public static void main(String[] args) {
List<String> lista = new ArrayList<>();
lista.add("Maria");
lista.add("Ana");
lista.add("Tatiana");
lista.add("Fernanda");
lista.add("Tatiana");
System.out.println(lista);
// Realiza a ordenação dos itens
Collections.sort(lista);
System.out.println(lista);
Collections.reverse(lista);
System.out.println(lista);
System.out.println(lista.get(1));
for (String item : lista) {
System.out.println(item);
}
for (int i = 0; i < lista.size(); i++) {
System.out.println(lista.get(i));
}
}
}](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-41-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
4.4. Set
O set é um tipo de coleção onde não há valores repetidos.
Veja o Exemplo abaixo onde adicionaremos nomes repetidos e o conjunto aceitará apenas uma entrada para os
valores em duplicidade.
package br.com.feltex.jse.colecao;
import java.util.HashSet;
import java.util.Set;
public class MeuSet {
public static void main(String[] args) {
Set<String> meuConjunto = new HashSet<>();
meuConjunto.add("Ana");
meuConjunto.add("Ana");
meuConjunto.add("Ana");
meuConjunto.add("Ana");
meuConjunto.add("Maria");
meuConjunto.add("Valeria");
meuConjunto.add("Fernanda");
System.out.println("Total de itens: " + meuConjunto.size());
for (String item : meuConjunto) {
System.out.println(item);
}
}
}
A saída será assim:
Total de itens: 4
Fernanda
Maria
Valeria
Ana
Agora utilizaremos uma variação do Set que além de não aceitar itens repetidos cria uma ordem natural para os
itens incluídos. Veja como funciona a classe SortedSet:](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-42-320.jpg)
![Euclides
www.feltex.com.br Capítulo 3 – Convenções e Padrões
package br.com.feltex.jse.colecao;
import java.util.Iterator;
import java.util.SortedSet;
import java.util.TreeSet;
public class MinhaListaSortedSet {
public static void main(String[] args) {
// Set<String> meuConjunto = new HashSet<>();
SortedSet<String> meuConjunto = new TreeSet<>();
meuConjunto.add("Ana");
meuConjunto.add("Ana");
meuConjunto.add("Ana");
meuConjunto.add("Ana");
meuConjunto.add("Maria");
meuConjunto.add("Valeria");
meuConjunto.add("Fernanda");
//Iterator: Objeto especial que só navega para frente;
Iterator<String> i = meuConjunto.iterator();
while (i.hasNext()) {
String texto = i.next(); // leitura do texto
System.out.println(texto);
}
}
}
Observe que desta vez não utilizamos o foreach para navegar entre os itens da nossa coleção. Fizemos uso do
iterator.
O que vimos...
Quais o tipos de coleções existentes no Java.
Qual a diferença entre um List e um Set.
A utilização prática de um MAP](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-43-320.jpg)
![Leonhard Euler
www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos
6. Tratamento de exceção
Metas do capítulo
Tratar erros na aplicação;
Diferencias erros negócio de erros de ambiente;
Tipos de exceção (obrigatórios e opcionais);
Validar entrada de dados
6.1. O que é uma exceção
Em nossos sistemas podemos ter ocorrências fora do domínio desejado. Imagina para o nosso sistema
acadêmico, imagine que solicitamos a matrícula que é numérica e o usuário digita um valor textual. O que
aconteceria com o nosso sistema?
package br.com.feltex.jse.excecao;
import javax.swing.JOptionPane;
public class MinhaExceao01 {
public static void main(String[] args) {
Integer matricula = Integer.parseInt(JOptionPane
.showInputDialog("Digite sua matrícula"));
System.out.println("Matrícula digitada: " + matricula);
}
}](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-50-320.jpg)
![Leonhard Euler
www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos
package br.com.feltex.jse.oo.heranca;
import java.util.Date;
public class Pessoa {
private String nome;
private Date dataCadastro;
private int codigo;
public int getCodigo() {
return codigo;
}
public Date getDataCadastro() {
return dataCadastro;
}
public String getNome() {
return nome;
}
public void setCodigo(int codigo) {
this.codigo = codigo;
}
public void setDataCadastro(Date dataCadastro) {
this.dataCadastro = dataCadastro;
}
public void setNome(String nome) {
this.nome = nome;
}
@Override
public String toString() {
return "Pessoa [nome=" + nome + ", dataCadastro=" + dataCadastro
+ ", codigo=" + codigo + "]";
}
}
As classes PessoaFisica e PessoaJurídica possuem todas as características de pessoa. Elas também trazem as
especializações que não são atributos particulares. Analise as classes abaixo:](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-53-320.jpg)
![Leonhard Euler
www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos
Outra situação de herança é a relação entre Avô, Pai e filho.
O filho herdou as características do pai que herdou as características do avô. Criamos um código de exemplo
para deixar claro como isso funciona.
Avô
package br.com.feltex.jse.oo.hierarquia;
public class Avo {
public Avo(){
System.out.println("Criando o AVO");
}
public String toString() {
return "Avo []";
}
}
Pai
package br.com.feltex.jse.oo.hierarquia;
public class Pai extends Avo{
public Pai(){
System.out.println("Criando o PAI");
}
@Override
public String toString() {
return "Pai []";
}
}
Filho
package br.com.feltex.jse.oo.hierarquia;
public class Filho extends Pai {
public Filho() {
System.out.println("Criando o FILHO");
}
public String toString() {
return "Filho []";
Avô
Pai
Filho](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-56-320.jpg)
![Leonhard Euler
www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos
}
}
Agora vamos instanciar a Classe filho para vermos como será o comportamento do Java nessa situação.
package br.com.feltex.jse.oo.hierarquia;
public class ConstrucaoObjetos {
public static void main(String[] args) {
Filho meuFilho = new Filho();
System.out.println(meuFilho.toString());
}
}
A saída será a seguinte:
Criando o AVO
Criando o PAI
Criando o FILHO
Filho []
Você consegue entender por que isso acontece? Vamos lá, pense no mundo real... 1, 2, 3 e EUREKA!
É possível um filho existir ser o pai ter nascido? A resposta é: não! E da mesma forma é necessário o avô ter
nascido para o par nascer! Então, seguindo esse raciocínio lógico temos que sempre que criamos um objeto do
tipo filho teremos a criação de avô e depois pai para somente em seguida ser criado o filho.
Tudo como funciona no mundo real!](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-57-320.jpg)
![Leonhard Euler
www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos
7.2. Mais um pouco de Orientação a Objetos Overriding (sobrescrita)
Esse é o caso de escrevermos o método na classe filha para ter um comportamento diferente do
original. Imagine a classe animal. Todo animal emite um som. Então teríamos na classe animal o método:
emitirSom(). Considerando que todo animal tem que ter um método assim devemos
sobrescrever/reescrever esse método para gato, leão, cachorro e lobo que são classe que herdam de
animal.
package br.com.feltex.jse.oo.hierarquia3;
public class Felino {
public void emitirSom() {
System.out.println("Felino ....");
}
}
package br.com.feltex.jse.oo.hierarquia3;
public class Gato extends Felino {
public void emitirSom() {
System.out.println("Miado!");
}
}
package br.com.feltex.jse.oo.hierarquia3;
public class Leao extends Felino {
public void emitirSom() {
System.out.println("Rugido!");
}
}
package br.com.feltex.jse.oo.hierarquia3;
public class MeuAnimal {
public static void main(String[] args) {
Felino felino1 = new Gato();
Felino felino2 = new Leao();
felino1.emitirSom();
felino2.emitirSom();
}
}
Felino
Gato Leão](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-58-320.jpg)
![Leonhard Euler
www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos
package br.com.feltex.jse.overloading;
public class SomaNumeros {
public static void main(String[] args) {
calcularSoma(10, 4);
calcularSoma(3, 3, 6);
calcularSoma(10, 4, 6, 2);
}
public static void calcularSoma(int a, int b) {
System.out.println(a + b);
}
public static void calcularSoma(int a, int b, int c) {
System.out.println(a + b + c);
}
public static void calcularSoma(int a, int b, int c, int d) {
System.out.println(a + b + c + d);
}
}](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-60-320.jpg)
![Louis leithold
www.feltex.com.br Capítulo 7 – Classes Utilitárias
8.1. Pacote java.lang
O java.lang é o pacote essencial do Java. Não é necessário realizar a importação das classes nele contidas.
Classes como String, Integer, Double, Float, Boolean entre outras que estão disponíveis nesse pacote.
Vamos dar destaque neste capítulo para a classe String. Ela é a grande estrela da manipulação de texto no Java. A
esta altura da apostila todos já sabem instanciar uma String.
Se não souber releia o capítulo de “Introdução ao Java” para ter um melhor aproveitamento do material. Então
conheça alguns métodos:
8.2. Classe String
package br.com.feltex.utilitarias;
public class MinhaString {
public static void main(String[] args) {
String meuTexto = "Batatinha quando nasce espalha a rama pelo chao!";
System.out.println(meuTexto.toUpperCase());
//BATATINHA QUANDO NASCE ESPALHA A RAMA PELO CHAO!
System.out.println(meuTexto.toLowerCase());
//batatinha quando nasce espalha a rama pelo chao!
System.out.println(meuTexto.substring(2));
//tatinha quando nasce espalha a rama pelo chao!
System.out.println(meuTexto.substring(2,10));
//tatinha
// Retorna verdadeiro se o texto terminar com a string informada
System.out.println(meuTexto.endsWith("chao!"));
// Retorna verdadeiro se o texto começar com a string informada
System.out.println(meuTexto.startsWith("Bata"));
}
}
Procure fazer uso apenas de Letras e números para nomear uma varíavel.
Operações
Em java quando estamos fazendo uma operação (soma, subração, divisão e um dos elementos for String o
resultado será do tipo em String).](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-66-320.jpg)
![Louis leithold
www.feltex.com.br Capítulo 7 – Classes Utilitárias
8.3. Classe Math
Classe Math possui métodos para realizarmos várias operações matemáticas. Podemos destacar geração de
números raiz quadrada, maior e menor número, logaritmos, aleatórios, seno, cosseno, tangente, transformações
de graus em radianos e o inverso.
package br.com.feltex.jse.util;
public class MeuMath {
public static void main(String[] args) {
double x = 9;
double y = 5;
System.out.println("Maior número: " + Math.max(x, y));
System.out.println("Menor número: " + Math.min(x, y));
System.out.println("Raiz quadrada: " + Math.sqrt(x));
System.out.println("Número Aleatório: " + Math.random() * 100 );
System.out.println("Valor Absoluto: " + Math.abs(-222) );
System.out.println("Raíz cúbica: " + Math.cbrt(27) );
System.out.println("Eleva um número a potência desejada: " + Math.pow(x,y) );
System.out.println("Log na base 2: " + Math.log(32) );
System.out.println("Log na base 10: " + Math.log10(1000) );
}
}](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-67-320.jpg)
![Louis leithold
www.feltex.com.br Capítulo 7 – Classes Utilitárias
8.5. DateFormat
DateFormat é uma classe que auxilia na formatação de datas. Podemos fazer a conversar de padrões como o
padrão Brasileiro de Dada 20/05/2014 (DD/MM/YYYY) para o padrão dos Estados Unidos da América
05/20/2014 (MM/DD/YYYY). Veja os exemplos abaixo:
package br.com.feltex.jse.text;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MeuSimpleDateFormate {
public static void main(String[] args) {
Date minhaData = new Date();
DateFormat formatador = new SimpleDateFormat("dd/MM/yyyy EEEE");
System.out.println(formatador.format(minhaData));
formatador = DateFormat.getDateInstance(DateFormat.FULL);
System.out.println(formatador.format(minhaData));
formatador = DateFormat.getDateInstance(DateFormat.LONG);
System.out.println(formatador.format(minhaData));
formatador = DateFormat.getDateInstance(DateFormat.MEDIUM);
System.out.println(formatador.format(minhaData));
formatador = DateFormat.getDateInstance(DateFormat.SHORT);
System.out.println(formatador.format(minhaData));
}
}
package br.com.feltex.jse.text;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
public class MeuSimpleDateFormate2 {
public static void main(String[] args) {
Date minhaData = new Date();
Locale brasileiro = new Locale("PT", "br");
DateFormat formatador = new SimpleDateFormat("dd/MM/yyyy EEEE",
brasileiro);
System.out.println(formatador.format(minhaData));
Locale americano = new Locale("US", "en");
formatador = new SimpleDateFormat("MM//dd/yyyy EEEE", americano);
System.out.println(formatador.format(minhaData));
}
}](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-69-320.jpg)
![Robert Hooke
www.feltex.com.br Capítulo 8 – Manipulação de Arquivos
9. Manipulação de Arquivos
9.1. Classe File
É uma das classes mais básicas para manipulação de arquivos. Temos nela os métodos e propriedades que
nos auxiliam na manipulação de arquivos. Métodos como o “exists” nos informam a existem ou não do arquivos.
Um fato importante a destacar é que a classe fila não faz distinção entre arquivos e diretório, todos são File.
Para isso existe um método chamado “isDirectory” que retorna true se o apontamento é um diretório e false no
caso contrário.
package br.com.feltex.jse.io;
import java.io.File;
public class LeituraPropriedadesArquivo {
public static void main(String[] args) {
try {
// Este Path está definido para funcionar no Windows
File arquivo = new File("C:/relatorio.txt");
// Para uso no linux apenas descomente a linha abaixo.
// arquivo = new File("relatorio.txt");
System.out.println("Permite leitura: " + arquivo.canRead());
System.out.println("Permite escrita: " + arquivo.canWrite());
System.out.println("Permite Execução: " + arquivo.canExecute());
System.out.println("Está oculto: " + arquivo.isHidden());
System.out.println("É um diretório: " + arquivo.isDirectory());
System.out.println("É um arquivo: " + arquivo.isFile());
System.out
.println("Caminho Absoluto: " + arquivo.getAbsolutePath());
System.out.println("Diretório pai: " + arquivo.getParent());
System.out.println("Tamanho em bytes: " + arquivo.length());
System.out.println("Cria um diretório: " + arquivo.mkdir());
System.out.println("Cria um caminho de diretórios: "
+ arquivo.mkdirs());
} catch (Exception e) {
e.printStackTrace();
}
}
}](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-72-320.jpg)
![Robert Hooke
www.feltex.com.br Capítulo 8 – Manipulação de Arquivos
9.2. Lendo e Gravando Dados em Arquivos
Uma tarefa muito comum em programação é quando precisamos realizar a leitura ou gravação de dados em um
arquivo texto.
package br.com.feltex.jse.io;
import java.io.BufferedReader;
public class AcessoArquivoTexto {
public static void main(String[] args) {
System.out.println("Inicio AcessoArquivoTexto");
// Escreve o conteúdo no arquivo Texto
escreverArquivo("Meu texton");
// Realiza a leitura do conteúdo do arquivo texto
lerArquivo();
System.out.println("Fim AcessoArquivoTexto");
}
public static void lerArquivo() {
try {
FileReader reader = new FileReader("C:/temp/meuArquivo.txt");
BufferedReader br = new BufferedReader(reader);
String linha = "";
while ((linha = br.readLine()) != null) {
System.out.println(linha);
}
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void escreverArquivo(String texto) {
try {
FileWriter writer = new FileWriter("C:/temp/meuArquivo.txt", true);
BufferedWriter bw = new BufferedWriter(writer);
bw.append(texto);
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-73-320.jpg)
![Robert Hooke
www.feltex.com.br Capítulo 8 – Manipulação de Arquivos
9.3. Classes Scanner e PrintWriter
Essas classes facilitam a leitura e escrita de arquivos com conteúdo textuais.
A classe Scanner pode ser utilizada para fazer iterações por linhas considerando um delimitador. É uma
classe muito aplicada para fazer a leitura linha a linha de um arquivo. Usamos também para ler a cada
delimitador como em arquivos “csv” que utilizam o “;” como delimitar de cada campo.
package br.com.feltex.jse.io;
import java.io.File;
public class MeuScanner {
public static void main(String[] args) {
System.out.println("Inicio MeuScanner");
try {
File arquivo = new File( "C:/temp/meuArquivo.txt");
Scanner scanner = new Scanner(arquivo);
scanner.useDelimiter("n");
while (scanner.hasNext()) {
System.out.println(scanner.next());
}
scanner.close();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("Fim MeuScanner");
}
}](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-74-320.jpg)
![Robert Hooke
www.feltex.com.br Capítulo 8 – Manipulação de Arquivos
9.4. Escrita de Dados na Saída Padrão
package br.com.feltex.jse.io;
import java.io.File;
public class MeuPrintWriter {
public static void main(String[] args) {
//Escreve uma linha em uma arquivo texto
System.out.println("Inicio MeuPrintWriter");
try {
File arquivo = new File("C:/temp/meuArquivo.txt");
PrintWriter pw = new PrintWriter(arquivo);
pw.append("Mensagem do Dia!!");
pw.close();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("Fim MeuPrintWriter");
}
}
Manipulando arquivos no Java
Existem vários post no nosso site sobre o assunto de arquivos! Indicamos que vocês acessem para terem mais
conteúdos para estudarem e verem outros exemplos.
Publicamos semanal mente artigos sobre Java no blog: www.feltex.com.br
Segue o tutorial de manipulação de arquivos:
http://www.feltex.com.br/felix/manipulacao-de-arquivos/](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-75-320.jpg)
![RENÉ DESCARTES
www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC)
Crie um novo projeto. Adicione uma classe chamada AlunoJDBC com o seguinte conteúdo:
package br.com.feltex.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class AlunoJDBC {
public static void main(String[] args) {
System.out.println("Inicio AlunoJDBC");
try {
String usuario = "root";
String senha = "";
// Aqui é criada a conexão com o Banco de Dados
Connection conexao = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/bdacademicnet", usuario, senha);
//Criação de um objeto para executar o comando SQL
PreparedStatement pstm = conexao
.prepareStatement("select * from tbaluno");
// Será retornada a lista de registros existentes no banco
ResultSet rs = pstm.executeQuery();
//Loop para ler cada registro
while (rs.next()) {
String nome = rs.getString("nome");
String telefone = rs.getString("telefone");
System.out.println("nome: " + nome + " telefone: " + telefone);
}
//É necessário fechar o PreparedStatement e a Conexão
pstm.close();
conexao.close();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("Fim AlunoJDBC");
}
}
Conexão JDBC
Há um tutorial sobre conexão com diversos Bancos de dados em nosso blog: Acesse
http://www.feltex.com.br/felix/tutorial-jdbc/](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-83-320.jpg)
![RENÉ DESCARTES
www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC)
}
public void setMatricula(Long matricula) {
this.matricula = matricula;
}
public void setNome(String nome) {
this.nome = nome;
}
public void setTelefone(String telefone) {
this.telefone = telefone;
}
@Override
public String toString() {
return "Aluno [matricula=" + matricula + ", nome=" + nome
+ ", telefone=" + telefone + ", email=" + email
+ ", dataCadastro=" + dataCadastro + "]";
}
}](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-86-320.jpg)
![RENÉ DESCARTES
www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC)
Por fim criaremos a classe AlunoCRUD que chamará a camada de acesso a dados AlunoDAO para fazermos a
manipulação dos dados no banco.
package br.com.feltex.jdbc;
import java.util.Date;
public class AlunoCRUD {
public static void main(String[] args) {
System.out.println("Inicio");
try {
Aluno aluno = new Aluno();
aluno.setMatricula(123123L);
aluno.setNome("Maria da Silva");
aluno.setEmail("Maria@feltex.combr");
aluno.setTelefone("224112");
aluno.setDataCadastro(new Date());
AlunoDAO alunoDAO = new AlunoDAO();
alunoDAO.inserir(aluno);
for (Aluno novoAluno : alunoDAO.listar()) {
System.out.println(novoAluno);
}
aluno.setNome("Maria da Silva e Santos");
alunoDAO.alterar(aluno);
for (Aluno novoAluno : alunoDAO.listar()) {
System.out.println(novoAluno);
}
alunoDAO.excluir(aluno);
System.out.println("Fim");
} catch (Exception e) {
e.printStackTrace();
}
}
}](https://image.slidesharecdn.com/apostila-java-basico-140709231721-phpapp01/85/Apostila-Java-90-320.jpg)
Apostila Java
- 3. www.feltex.com.br Sumário 1. Introdução ao Java............................................................................................................................................................1 1.1. Sobre o material ............................................................................................................................................................1 1.2. Divisão dos capítulos....................................................................................................................................................2 2. Mundo do Java ..................................................................................................................................................................3 2.1. A Linguagem..................................................................................................................................................................4 Então se divirta com o Java! ...................................................................................................................................................4 2.2. O que é uma IDE? ........................................................................................................................................................6 2.3. A sopa de letras do Java..............................................................................................................................................6 2.4. Configurando o ambiente.............................................................................................................................................7 2.5. O meu Alô Mundo .........................................................................................................................................................9 2.6. Formas de Entrada de dados....................................................................................................................................10 2.7. Exibindo minhas mensagens ....................................................................................................................................10 2.8. Exercícios resolvidos..................................................................................................................................................12 2.9. Exercícios propostos ..................................................................................................................................................13 3. Convenção e padrões ....................................................................................................................................................14 3.1. Padrão de nomenclatura............................................................................................................................................15 3.7. Exercícios resolvidos..................................................................................................................................................28 3.8. Exercícios propostos ..................................................................................................................................................29 4. Estrutura de Dados e Coleções....................................................................................................................................30 4.1. Arrays............................................................................................................................................................................31 4.2. Maps..............................................................................................................................................................................34 4.3. Coleções.......................................................................................................................................................................35 4.4. Set .................................................................................................................................................................................37 5. Orientação a Objeto........................................................................................................................................................40 5.1. O que são objetos?.....................................................................................................................................................41 5.2. Instâncias da Classe...................................................................................................................................................42 5.3. Atributos da Classe.....................................................................................................................................................43 5.4. Diagrama de Classes .................................................................................................................................................43 5.5. Atributos Estáticos ......................................................................................................................................................43 5.6. Construtores da Classe..............................................................................................................................................44 6. Tratamento de exceção..................................................................................................................................................45 6.1. O que é uma exceção ................................................................................................................................................45 7. Mais um pouco de Orientação a Objetos....................................................................................................................46 7.1. Herança ........................................................................................................................................................................47 7.2. Mais um pouco de Orientação a Objetos Overriding (sobrescrita) .....................................................................53 7.3. Overloading (Sobrecarga)..........................................................................................................................................54
- 4. www.feltex.com.br 7.4. Referenciando atributos da classe atual .................................................................................................................56 7.5. Referenciando atributos da classe superior............................................................................................................57 7.6. Polimorfismo ................................................................................................................................................................57 7.7. Classes Abstratas .......................................................................................................................................................57 7.8. Métodos Abstratos ......................................................................................................................................................57 7.9. Interfaces......................................................................................................................................................................58 8. Classes Utilitárias............................................................................................................................................................60 8.1. Pacote java.lang..........................................................................................................................................................61 8.2. Classe String................................................................................................................................................................61 8.3. Classe Math .................................................................................................................................................................62 8.4. Locale............................................................................................................................................................................63 8.5. DateFormat ..................................................................................................................................................................64 8.6. Formatação de Número .............................................................................................................................................66 9. Manipulação de Arquivos...............................................................................................................................................67 9.1. Classe File....................................................................................................................................................................67 9.2. Lendo e Gravando Dados em Arquivos...................................................................................................................68 9.3. Classes Scanner e PrintWriter..................................................................................................................................69 9.4. Escrita de Dados na Saída Padrão..........................................................................................................................70 10. Banco de Dados (JDBC)............................................................................................................................................71 10.1. Introdução.................................................................................................................................................................72 10.1.1. Estabelecendo a Conexão.................................................................................................................................73 10.1.2. Trabalhando com Instruções SQL....................................................................................................................75 10.1.3. Para criar uma tabela: ........................................................................................................................................75 10.1.4. Para incluir um registro na tabela.....................................................................................................................76 10.1.5. Para listar os registros existentes na tabela ...................................................................................................76 10.1.6. Para alterar um registro na tabela ....................................................................................................................76 10.1.7. Para excluir um registro na tabela....................................................................................................................76 10.2. Apresentação...........................................................................................................................................................79 10.3. Código de Exemplo.................................................................................................................................................79 10.4. Entidade Aluno ........................................................................................................................................................80 10.5. Cadastro de Aluno ..................................................................................................................................................82 10.5.1. Classe DAO..........................................................................................................................................................82 10.5.2. AlunoDAO.............................................................................................................................................................82 11. Exercícios proposto ....................................................................................................................................................86 11.1. Executar o exemplo completo...............................................................................................................................86 11.2. Alteração do exemplo.............................................................................................................................................86
- 5. Versão: 1.0
- 6. Isaac Newton 1 1. Introdução ao Java 1.1. Sobre o material Após mais de 8 anos em sala de aula como professor de informática em especial Java decidi fazer uma apostila que ajudasse meus alunos a entenderem um pouco mais dessa poderosa linguagem de programação. Os livros sempre possuem mais conteúdos do que deve ser lecionado em blocos de 50 ou 60 horas de aula. Eles são bons como material de apoio complementar. Esta apostila não vem a ser um material para esgotar o assunto. Serve mais para estudantes que querem seguir uma linha prática e objetiva de estudos para conseguirem entrar no mercado de trabalho com Java. O material é também para aqueles que querem consolidar os conhecimentos da linguagem fazendo exercícios, atualizando o que aprenderam, revisando alguns assuntos e utilizando nossas referências para aprofundamento no conhecimento do Java. Também é feita muita referência às mídias criadas no blog www.feltex.com.br como vídeo aulas, tutoriais e aplicações completas, cursos em nosso site.
- 7. Isaac Newton 2 1.2. Divisão dos capítulos Os capítulos seguirão o seguinte padrão: Ícone Descrição Metas do capítulo – O que será abordo. Conteúdo – Material explicativo do assunto abordado. Exercícios – Lista de tarefas que devem ser feitas para avaliar a compreensão do leitor. Dicas do autor – links, explicações e mais detalhes sobre o assunto. Desafios – Exercícios que com exigem maior dedicação estudos dos alunos. Pare e revise – Há algo de errado com o código. Vamos revisá-lo.
- 8. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 2. Mundo do Java Metas do capítulo Conheceremos uma breve história do Java, seus criadores e como é utilizado hoje. O que é JRE, JDK, JSE, JEE, JME. Faremos a configuração do ambiente de desenvolvimento. Criaremos nosso primeiro programa Java. Aprenderemos a ler e exibir dados em um programa Simples.
- 9. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 2.1. A Linguagem Java é uma linguagem de programação e plataforma de computação lançada pela Sun Microsystems em 1995. Há muitos aplicativos e sites que só funcionam quando você tem o Java instalado em seu computador. Java é rápido, seguro e confiável. De laptops, datacenters, consoles de jogo, supercomputadores científicos, telefones celulares e claro até na Internet, Java está em toda parte! Hoje a tecnologia faz parte da nossa vida diária. Por causa do Java temos dispositivos digitais mais inteligentes, mais funcionais, e de bem mais divertidos. No início da década de 90, estendendo-se o poder da computação em rede para as atividades da vida cotidiana era uma visão radical. Em 1991, um pequeno grupo de engenheiros da Sun chamado "Green Team" acreditou que a próxima onda na computação seria a união de dispositivos de consumo digitais e computadores. Liderado por James Gosling, a equipe trabalhou duramente e criou a linguagem de programação que iria revolucionar o nosso mundo – Java. A Equipe Verde, em tradução livre, demonstrou a sua nova linguagem em um handheld controlador de uma casa de entretenimento interativo que foi originalmente voltado para o setor de televisão a cabo digital. Infelizmente, o conceito era muito avançado para a eles naquele momento. No entanto era o ideal para a Internet, que estava apenas começando a decolar. Em 1995, a equipe anunciou que o navegador de Internet Netscape Navigator iria incorporar a tecnologia Java. Nos anos seguintes a linguagem foi se espalhando em diversos sistemas operacionais e dispositivos. Hoje, Java não só permeia a Internet, mas também é a força invisível por trás de muitas das aplicações e dispositivos que alimentam nossas vidas. A partir de telefones móveis para dispositivos portáteis, jogos e sistemas de navegação para E-Business, sistemas embarcados em televisões, carros, geladeiras e equipamentos da indústria. Há Java está em toda parte! Uma das características mais marcantes do Java é que ele é multiplataforma, ou seja, o mesmo código que você cria em Windows poderá ser rodado sem alteração em Sistemas Operacionais como Linux, Mac OS, Solaris ou Solaris. O que torna isso possível é que devemos sempre instalar uma JVM – Máquina Virtual Java no Sistema Operacional para que possamos rodar os programas em Java. Então se divirta com o Java!
- 10. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões Linguagem de programação Uma linguagem de programação é uma linguagem artificial projetado para enviarmos instruções a uma máquina, especialmente um computador. Linguagens de programação podem ser utilizadas para criar os programas que controlam o comportamento de uma máquina e/ou para expressar algoritmos – comandos encandeados para um fim comum. Um programa é escrito como uma série de instruções de computador compreensíveis por humanos que podem ser lidos por um compilador e traduzidos em código de máquina, de modo que um computador possa entender e executar.
- 11. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 2.2. O que é uma IDE? IDE – (Integrated Development Environment), ou Ambiente de Desenvolvimento Integrado, é um software com a finalidade de facilitar e nos auxiliar na construção de programas de computador. As principais características desses softwares são: interface gráfica para criação de componentes, formatação do texto em um padrão pré- definido, autocompletar de texto ao digitar, pré-compilação antes da execução e possibilidade de realizar depuraçao de código – execução passo-a-passo do programa para análise. 2.3. A sopa de letras do Java O Java possui vários acrônimos para as divisões internas na linguagem. A maioria dos nomes dessas partes é iniciada com “J” de Java. Isso costuma causar grandes dúvidas nos programadores iniciantes. Veja que na imagem abaixo a linguagem Java tem várias divisões lógicas (definidas por células e agrupadas por cores).
- 12. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões Linguagem Java e seus módulos: http://www.oracle.com/technetwork/java/javase/tech/index.html Explicaremos o que significam as siglas mais utilizadas no dia-a-dia de um programador. Os outros itens veremos ao longo dos capítulos. Sigla Significado Descrição JVM Java Virtual Machine Programa básico para a execução do Java em qualquer sistema operacional. JRE Java Runtime Envireoment Programa necessário para executar programas Java. JDK Java Development Kit Programa necessário para desenvolvermos programas na linguagem Java. JSE Java Standart Edition É a versão do Java para desenvolvimento de aplicações básicas. JEE Java Enterprise Edition É a versão do Java para desenvolvimento de aplicações Web e corporativas. JME Java Micro Edition É a versão do Java para desenvolvimento de aplicativos móveis. 2.4. Configurando o ambiente Para iniciarmos o desenvolvimento de Java precisamos instalar as ferramentas adequadas no nosso computador. Existe o que chamamos de Java Development Kit – Kit de desenvolvimento Java. Esse é o conjunto de ferramentas que possibilita a nossa criação de programa nessa linguagem. Acesse o Link: http://www.oracle.com/technetwork/java/javase/downloads/index.html e faça o download da versão “JDK”. Ao concluir o download faça a instalação seguindo o winzard do programa. Ao final você já terá o Java instalado e então deverá fazer a instalação do Eclipse. Eclipse é a ferramenta que utilizaremos para criar nossos programas. Considere que para criar um arquivo “.doc” precisamos utilizar o MS Word. Em paralelo a essa visão utilizamos a IDE Eclipse para criar os arquivos java. O Eclipse assim como o Java é uma ferramenta gratuita. Acesse o site http://www.eclipse.org/downloads/. Selecione a versão do “Eclipse Standard” adequada para o seu Sistema Operacional (32 ou 64 bits). Após o término do download basta descompactar o Eclipse e executar o programa no caso do Windows “eclipse.exe”.
- 13. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões Vídeo aula Deixamos disponível em nosso canal no youtube uma vídeo-aula de como configura o ambiente Java completo. Acreditamos que isso ajudará bastante! http://youtu.be/njSO8oxyNvU Segue um post em nosso blog sobre configuração do Eclipse: http://www.feltex.com.br/felix/configurando-o-eclipse-keppler/.
- 14. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 2.5. O meu Alô Mundo Agora chegou a hora de fazermos o nosso primeiro programa. Será um exemplo bem simples. Ele exibirá uma mensagem de saudação na console do Eclipse. 1. Você deve abrir o seu Eclipse. Acessar File >> New >> Project. No campo Wizard digite: “Java Project” Aperte Next >> Digite o nome “AloMundo”. Pressione Finish. 2. Acessar File >> New >> Classs. No campo nome digite: “AloMundo”. No campo package digite: “br.com.feltex.alomundo”. 3. Pronto. Agora digite o valor abaixo na sua classe. 1. package br.com.feltex.alomundo; 2. 3. public class AloMundo { 4. 5. public static void main(String[] args) { 6. System.out.println("Alo Mundo!!!"); 7. } 8. } Após isso clique com o botão direito na sua Classe AloMundo. Acesse Run >> “Run As Java Application”. Saída "Alo Mundo!!!" Altere o programa anterior e faça a impressão da mensagem: “Batatinha quando nasce!”. Exemplo disponível em: http://www.feltex.com.br/felix/hello-world/
- 15. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões Pare e revise Seu código não funcionou? Veja o que pode ter ocorrido. Mensagem Solução Syntax error, insert "}" to complete ClassBody Esqueceu o último fechamento de chaves. Adicione “}” no final da classe. Syntax error on token ""Alo Mundo!!!"", delete this token O código System.out.println("Alo Mundo!!!"); foi adicionado fora do método public static void main(String[] args) { The public type Alomundo must be defined in its own file O nome da classe está diferente do arquivos. O Java é Case Sensitive. Alomundo é diferente de AloMundo. 2.6. Formas de Entrada de dados Podemos utilizar várias formas de entrada de dados em Java. As mais comuns são a classe Scanner e JOptionPane. Uma das tarefas mais comuns na programação é solicitar ao usuário alguns dados de entrada. Imagine um sistema que realiza o cadastro de alunos. Nesse sistema é necessário que haja uma interface onde possamos informar matrícula, nome, endereço, telefone, e-mail, data de nascimento entre outros dados do aluno. Para isso precisamos de classes específicas que nos permitam realizar essas tarefas tão simples. Vamos realizar a leitura do nome de um usuário: package br.com.feltex.jse.lista1; import javax.swing.JOptionPane; public class Nomes { public static void main(String[] args) { String nome = ""; nome = JOptionPane.showInputDialog("Digite o nome:"); System.out.println("O nome digitado foi: " + nome); } } 2.7. Exibindo minhas mensagens Há 2 formas básicas de exibirmos dados para o usuários. Uma utilizando os seguintes comandos: System.out.println(“Minha mensagem”); Não se esqueça da assinatura correta do método “main”.
- 16. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões Comando que imprime a frase “Minha mensagem” e em seguida pula uma linha. Observe que o comando println tem uma terminação em “ln” que significa “line new”(nova linha). O comando abaixo imprime um o mesmo texto, contudo não criará uma nova linha. System.out.print(“Minha mensagem”); JOptionPane.showMessageDialog(null, "Minha Mensagem"); O comando acima exibirá um formulário modal1 com o texto “Minha Mensagem”; Veja o exemplo de como isso funciona. Digite o código abaixo no Eclipse e verifique os resultados. 1 Forma de exibição de tela que não permite ao usuário selecionar outras telas do sistema antes de fechar a visualização atual.
- 17. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 1. package br.com.feltex.jse.basico; 2. import javax.swing.JOptionPane; 3. 4. public class AloMundo { 5. 6. public static void main(String[] args) { 7. System.out.println("Minha mensagem"); 8. System.out.print("Minha mensagem"); 9. System.out.print("Minha mensagem"); 10. JOptionPane.showMessageDialog(null, "Minha Mensagem"); 11. } 12. } 2.8. Exercícios resolvidos Exercícios Escreva programas para: 1. Ler nome, idade e telefone de uma pessoa. 2. Ler o endereço e e-mail. 3. Calcular a idade a partir do ano de nascimento. 4. Ao final de cada programa imprimir uma mensagem com o dado lido.
- 18. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 2.9. Exercícios propostos Desafio 1. Crie um programa que desenhe na console2 um retângulo com a letra “A”. AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA A A A A A A A A A A A A A A AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 2. Crie um programa que desenhe na console um novo retângulo com a primeira e última letra do seu nome. Sendo que as bases (linhas superior e inferior) use a primeira letra. Para as laterais use a última letra. Se as letras forem iguais mude uma delas a seu critério! O que vimos... Como está dividida a linguagem Java. O Básico do mundo java. Forma de exibir os dados para o usuário. Como criar programa na linguagem Java Sintaxe básica de um programa. 2 Tela de exibição de dados textuais do eclipse.
- 19. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 3. Convenção e padrões Metas do capítulo Veremos a tratamento condicional, convenções da linguagem. Principais tipos de dados. Controles de fluxo. Para que servem os Loops.
- 20. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 3.1. Padrão de nomenclatura O mais importante de sabermos como iniciante é que Java é Case Sensitive. Isto significa que ela diferencia maiúscula de minúscula. Veja: Casa <> CASA <> CaSa <> cASA <> casa <> Casa <> casa Escrevemos várias vezes a palavra casa, mas para o Java são valores por terem letras maiúsculas e minúsculas. Temos convenções para nomear os componentes de nossos sistemas. Vamos às explicações: Classes – os nomes de classe devem iniciar em maiúsculo. Se houver mais de uma palavra no nome da classe cada primeira letra das novas palavras seguintes devem ser escritas em maiúsculo. Devemos utilizar substantivos. Professor Aluno Cadastro AcessoLogin NomeMinhaClasse Variáveis – os nomes de variáveis devem iniciar em minúsculo. Se houver mais de uma palavra no nome da variável cada primeira letra das novas palavras seguintes devem ser escritas em maiúsculo. idade nome enderecoCobranca marcaRegistrada Constantes – os nomes de constantes devem ser sempre em maiúsculo. Se houver mais de uma palavra no nome da constante deve haver um “_” entre as palavras. PI COMISSAO NOME_APLICACAO ALTURA_MAXIMA Métodos – os nomes de métodos seguem as convenções de variáveis. A cada nova palavra a letra inicial deve ser Maiúscula. Devemos utilizar verbos, pois são ações que o nosso sistema executa. fechar() exibir() calcularMedia() abrirArquivo()
- 21. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões Evite utilizar acentuação. Não podemos utilizar caracteres especiais com )(*&¨%$#@!,.{}^?:><+. Procure fazer uso apenas de Letras e números. Site oficial Existe um oficial com todas as convenções oficiais da linguagem Java. Inclusive é até possível fazer download desse material. http://www.oracle.com/technetwork/java/index-135089.html
- 22. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 3.2. Comentários É uma boa prática quando estamos programando fazer alguns comentários em nossas classes para que sejam melhor entendidas por outros programadores ou até mesmo por nós em uma leitura futura. No Java há 3 formas de comentários: //Comentário de uma linha /* Comentário de várias linhas onde descrevemos o que a rotina faz.*/ /** Isso é um JavaDoc. Esse é um tipo especial de comentário que poderá ser utilizado na geração de um documento. HTML com navegação, índice de busca e referências cruzadas entre as páginas.*/ É importante saber que quaisquer comentários que são criados dentro de métodos não são incluídos no JavaDocs. Outra curiosidade interessante é que ao gerar os arquivos compilados do Java, ou seja, os arquivos “.class” os comentários não são adicionados a esses arquivos. 3.3. Tipos de dados – as famosas variáveis Para construir programa precisamos de componentes onde guardemos os dados de entrada. Vamos considerar que precisamos criar um cadastro de aluno. Precisaremos dos dados como Matrícula, nome, telefone, e-mail, endereço. Chamamos cada componente que armazenará esses valores de variáveis. O nosso programa terá no mínimo 5 variáveis para guardar os dados de aluno. Toda variável tem que ter um nome e um tipo. Cada variável tem um tipo específico. “Nome” é do tipo texto (Maria da Silva, Ana Paula) já Matrícula será numérica (22341, 334122) Endereço é um tipo texto. Os campos texto são chamados de “String” e os campos inteiro chamamos de int. Basicamente precisamos de 2 tipos no nosso exemplo. Vamos escrever um código para isso. String nome1 = “Maria da Silva”; String nome2 = “Ana Paula”; int matricula1 = 2234; int matricula2 = 334122; Veja o exemplo de código abaixo:
- 23. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões package br.com.feltex.jse.basico; public class AloMundo2 { public static void main(String[] args) { String nome1 = "Maria da Silva"; String nome2 = "Ana Paula"; int matricula1 = 2234; int matricula2 = 334122; System.out.println(nome1); System.out.println(nome2); System.out.println(matricula1); System.out.println(matricula2); } } Além desses tipos temos outros que chamamos de primitivos. Os tipos de armazenamento mais simples. Existem 8 tipos que podem ser visto no quadro abaixo. Observe que “String” apesar de ser um tipo muito utilizado não se enquadra nesta lista. Veja que todos os tipos primitivos iniciam com letra minúscula. A palavra String começa com letra Maiúscula. Use essa dica para lembrar quais são os tipos primitivos. Nome Tipo Decimal inicial Tamanho byte Numérico NÃO 0 8 bits short Numérico NÃO 0 16 bits int Numérico NÃO 0 32 bits long Numérico NÃO 0 64 bits float Decimal SIM 0.0f 32 bits double Decimal SIM 0.0 64 bits boolean Boleano -- false 16 bits char Caracter -- /000 16 bits
- 24. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões Veja abaixo um programa com declaração de variáveis de tipo primitivo: package br.com.feltex.jse.basico; public class AloMundo2 { public static void main(String[] args) { byte idade = 10; short sala = 105; int ano = 2013; long total = 334532; char letra = 'A'; boolean diaUtil = true; float media = 2.3f; double salario = 22000.52; String nome = "Maria da Silva"; System.out.println("Alo mundo!"); System.out.println("Idade: " + idade); System.out.println("Sala: " + sala); System.out.println("Ano: " + ano); System.out.println("Total: " + total); System.out.println("letra: " + letra); System.out.println("diaUtil: " + diaUtil); System.out.println("media: " + media); System.out.println("salario: " + salario); System.out.println("nome: " + nome); } } Classes Wrapper Para cada tipo primitivo temos as chamadas classes Wrapper (tipo de referência). Essas classes possuem métodos auxiliam na manipulação dos valores primitivos. Primitivo Wrapper byte Byte short Short Int Integer Long Long float Float double Double boolean Boolean • As principais funções dessas classes são: • Constantes (MAX_VALUE, MIN_VALUE) • Integer.MAX_VALUE, Integer.MIN_VALUE • “valueof” (transformam um valor String em no tipo desejado)
- 25. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões • Ex: Integer.valueOf("10") • “parse...” (valida se um valor é pode ser transformado no tipo desejado) • Ex: Integer.parse("10") • Transformações Hex X Binário X Octal • Ex.: System.out.println(Integer.toOctalString(10)); Saída = 12 • System.out.println(Integer.toBinaryString(10)); Saída = 1010 Site oficial Existe um site oficial com todas as convenções oficiais da linguagem Java. Inclusive é até possível fazer download desse material. http://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html Existem palavras reservadas para uso da linguagem Java que não podem ser utilizadas como identificadores dos nossos programas (variáveis, métodos, classes, pacotes etc). abstract continue for new switch assert *** default goto * package synchronized boolean do if private this break double implements protected throw byte else import public throws case enum **** instanceof return transient catch extends int short try char final interface static void class finally long strictfp ** volatile const * float native super while * Não utilizadas ** incluída na versão 1.2 *** Incluída na versão 1.4 **** Incluída na versão 5.0 http://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
- 26. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 3.4. Operadores Operadores são elementos da linguagem que executam ações com 2 ou mais operandos e retornam um resultados. Temos os Operadores: Matemáticos (+, -, *, /, ++, --) Operador Descrição Exemplo Resultado + Adiciona um valor a variável 5 +5 10 - Adiciona um valor da variável 8 -2 6 * Realizar a multiplicação de um valor 2 *2 4 / Realizar a divisão de um valor 10 /2 5 % Retorna o resto de uma divisão (5 % 2) 1 ++ Pós incremento/Pré Incremento X++ ou ++X (X +1) ou X -- Pós Decremento/Pré Decremento X-- ou X-- (X -1) ou X Relacionais (==,<, >, <=, >=, !=, !) Operador Descrição Exemplo Resultado = Atribuição de um valor X = 5 5 == Comparação de valores 5 == 5 true > Relação de superioridade 6 > 5 true < Relação de inferioridade 2 < 5 true >= Relação de superioridade ou igualdade 6 >= 5 true <= Relação de inferioridade 10 <= 5 false != Relação de diferenças 6 != 5 true Booleanos Operador Descrição Exemplo Resultado || Verifica se um dos operandos é verdadeiro true || true true && Verifica se TODOS operandos são verdadeiro true && true true ! Nega o valor da variável booleana !true false • ou (||): Operador que resulta VERDADEIRO quando um dos seus operandos lógicos for verdadeiro. • e (&&): Operador que resulta VERDADEIRO somente se seus dois operandos lógicos forem verdadeiros. • não (!): Operador unário de negação. não VERDADEIRO = FALSO não FALSO = VERDADEIRO Tabela verdade
- 27. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões
- 28. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 3.5. Controle condicional Existem momentos nos quais precisamos tomar decisões a partir dos dados recebidos e mudar o fluxo normal de nossa aplicação. Veja a imagem abaixo: Os losangos representam tomadas de decisão. “Se” a lâmpada estiver enroscada então... “Se” a lâmpada estiver fundida então...
- 29. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões Veja a o código abaixo: package br.com.feltex.jse.basico.instrucao; public class InstrucaoIF { public static void main(String[] args) { int x = 10; int y = 30; if (x > y) { System.out.println("Verdadeiro"); } else { System.out.println("Falso"); } } } Neste programa é verificado se a variável x que tem o valor de 10 unidades é maior que o y que tem o valor de 30 unidades. A saída “Falso”, pois “10 > 30”
- 30. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões Podemos ainda fazer o encadeamento de instruções IF com mais de uma condição. package br.com.feltex.jse.basico.instrucao; public class InstrucaoIF2 { public static void main(String[] args) { int x = 10; int y = 30; if (x > y) { System.out.println("X é maior que Y!"); } else if (x < y) { System.out.println("X é menor que Y!"); } else { System.out.println("X é igual a Y!"); } } } Neste código estamos verificando se X é maior, menor ou igual a Y. 3.6. Laços de repetição Vamos falar código que criamos para executar algumas instruções de código por várias vezes. Existem 3 formas de fazermos isso: for, while e do While. O “for” é um caso de loop que utilizamos quando sabemos o número de iterações devemos executar em nosso programa. package br.com.feltex.jse.basico.instrucao; public class Loop1 { public static void main(String[] args) { for (int i = 0; i < 10; i++) { System.out.println("O valor de i x:" + i); } } }
- 31. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões O comando while realiza uma validação boolean no início de sua execução e continuará suas repetições enquanto a condição for verdadeira. O bloco interno ao while pode nunca ser executado se a condição inicial for falsa. package br.com.feltex.jse.basico.instrucao; public class LoopWhile { public static void main(String[] args) { int i = 0; while (i <= 10) { System.out.println("Valor de i: " + i); i++; } } } Por último falaremos do loop do{ }while() a esse sempre executará as instruções dentro do laço, pelo menos uma vez, pois a avaliação da condição de repetição só é validada no final. package br.com.feltex.jse.basico.instrucao; public class LoopDoWhile { public static void main(String[] args) { int i = 0; do { System.out.println("Valor de i: " + i); i++; } while (i <= 10); } } As instruções de Loop possuem 2 comando que nos auxiliam a mudar o fluxo natural do código. São elas continue e break. O break realiza uma interrupção do laço e faz passa a ação para a primeira linha de código fora do loop. Veja o exemplo abaixo:
- 32. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões package br.com.feltex.jse.basico.instrucao; public class LoopWhileBreak { public static void main(String[] args) { System.out.println("Inicio"); int i = 0; while (i <= 5) { System.out.println("Valor de i: " + i); i++; if (i == 3){ break; } System.out.print(" depois do break!!"); } System.out.println("Fim"); } } Quando a variável tiver o valor de 5 será executado o comando break que fará a quebra do laço de repetição e próxima execução será a linha 15.
- 33. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões Para saber mais... Existe uma forma de fazer o “for” incrementar por um valor diferente de “1” Veja o exemplo a baixo e Observe que a variável “i” receber a adição de 2 a cada iteração. package br.com.feltex.jse.basico.loop; public class LoopForStep { public static void main(String[] args) { for (int i = 0; i <= 20; i += 2) { System.out.println("Valor i: " + i); } } } O comando continue faz com que a execução volte para o início do loop sem executar as linhas logo abaixo dele. package br.com.feltex.jse.basico.instrucao; public class LoopWhileContinue { public static void main(String[] args) { System.out.println("Inicio"); int i = 0; while (i <= 5) { System.out.println("Valor de i: " + i); i++; if (i == 3){ continue; } System.out.print(" depois continue!!"); } System.out.println("Fim"); } } 3.7. Exercícios resolvidos
- 34. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões Exercícios Escreva programas para: 1. Imprimir na console 10 vezes a palavra “Java”. Não se esqueça de pular linha em cada comando. 2. Exiba a estação do ano quando informado o número do mês. 3. Exiba se um número é par ou ímpar. 4. Exiba um número é primo ou não. 5. Pare um loop quando o número da iteração for a metade do total do loop a 3.8. Exercícios propostos Desafio 1. Crie um programa que desenhe na console3 um retângulo com a letra “A”. AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA A A A A A A A A A A A A A A AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 2. Crie um programa que desenhe na console um novo retângulo com a primeira e última letra do seu nome. Sendo que as bases (linhas superior e inferior) use a primeira letra. Para as laterais use a última letra. Se as letras forem iguais mude uma delas a seu critério! O que vimos... Neste ponto já devemos saber o que é um “if” e quando utilizamos um “else”. Uma alternativa simples ao if é o “switch” Sabemos que existem vários tipos de loop: While, for, do While Existe comando que alteram o fluxo do loop break e continue 3 Tela de exibição de dados textuais do eclipse.
- 35. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 4. Estrutura de Dados e Coleções Metas do capítulo Conhecer as estruturas de coleções de dados em Java. Como o Java trabalha com Vetores (Arrays). Conjuntos, listas, filas e mapas. Aprenderemos a ler e exibir dados de um arquivo em um programa Simples.
- 36. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões Neste capítulo vamos trabalhar com as estruturas que armazenam vários dados em um mesmo objeto. É o que podemos chamar de coleção. 4.1. Arrays Começaremos com um array. Desde o nosso primeiro programa fizemos uso de Array, mas não fomos oficialmente apresentados. Então agora faremos as honras. 1. package br.com.feltex.jse.basico; 2. public class AloMundo { 3. public static void main(String[] args) { 4. System.out.println("Alo mundo!"); 5. } 6. } Observe que na linha 3, temos a declaração “String[] args”. O tipo definido é “String” e observe que temos um par de colchetes. Isso define que teremos um array de String. Podemos então String[] arrayString = new String[5]; // Estamos criando um array de String com 5 posições arrayString[0] = “Felix”; arrayString[1] = “Maria”; arrayString[2] = “Joana”; arrayString[3] = “Marta”; arrayString[4] = “Flavia”; Nosso array fica preenchido assim: Felix Maria Joana Marta Flavia 0 1 2 3 4 Atribuimos valores para todas as posições. Observe que começamos o índice do valor “0” (zero). Logo a última posição vai ser 4 (quatro). Vamos agora declarar um array de inteiros e um de double: int[] arrayInteito = new int[3]; // Criação do array de inteiros arrayInteito[0] = 10; arrayInteito[1] = 27; arrayInteito[2] = 4; 10 27 4 0 1 2 double[] arrayDouble = new double[3]; // Criação do array de double arrayDouble [0] = 2.9; arrayDouble [1] = 4.1; arrayDouble [2] = 2.3; 2.9 4.1 2.3
- 37. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 0 1 2 Existem ainda outras formas de declararmos um array. Veja a seguir: int[] arrayNumero = {5, 7, 90, 334}; // Criação do array com 4 posições. int arrayNumero [] = {5, 7, 90, 334}; //Observe que mudamos a posição do par de colchetes Isso é possível porque o Java nos permite criar muitas variáveis em uma mesma linha. Vejamos isso: int arrayNumero[], x ; // Desta forma estamos declarando que arrayNumero é um array de inteiros e que x é um número inteiro. Int[] arrayNumero, x ; // Desta forma estamos declarando que tanto arrayNumero quanto x são arrays de inteiro. Viu como é fácil trabalhar com arrays? Vamos fazer um exemplo.
- 38. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões package br.com.feltex.jse.basico.array; public class Array01 { public static void main(String[] args) { String[] arrayString = new String[5]; // Estamos criando um array de String com 5 posições arrayString[0] = "Felix"; arrayString[1] = "Maria"; arrayString[2] = "Joana"; arrayString[3] = "Marta"; arrayString[4] = "Flavia"; for (int i = 0; i < arrayString.length; i++) { System.out.println(arrayString[i]); } } } Pare e revise Seu código não funcionou? Veja o que pode ter ocorrido. Mensagem Solução Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0 at br.com.feltex.jse.basico.array.Array01.main(Array01.java:14) Verifique se você declarou o array certo dentro do “for” Não pode ser este “args[i]” tem que ser arrayString[i] Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5 at br.com.feltex.jse.basico.array.Array01.main(Array01.java:14) Isto significa que está sendo procurada a posição “5” do Array. Não existe a posição 5. Ele vai de 0...4. Verifique se seu for está assim: “for (int i = 0; i < arrayString.length; i++) {“
- 39. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 4.2. Maps Agora vamos ao uso dos maps. Map é uma estrutura no Java responsável por guardar pares de chave e valor. Ele tem uma estrutura parecida com a imagem abaixo: 21 Rio de Janeiro 11 São Paulo 83 João Pessoa 31 Belo Horizonte Na tabela acima temos as chaves os DDDs e no valor correspondente o nome da cidade. Isso também poderia ser utilizado para definir os meses do ano: 1 Janeiro 2 Fevereiro 3 Março 4 Abril No java declaramos os mas da seguinte forma4 : Map<tipoDaChave, tipoValor> meuMapa = new HashMap< >(); Map< Integer, String> meuMapa = new HashMap< >(); Map<String, String> meuMapa2 = new HashMap< >(); Map< Integer, Integer> meuMapa3 = new HashMap< >(); Das formas apresentadas. Segue um exemplo de como utilizar os mapas. package br.com.feltex.jse.colecao; import java.util.HashMap; import java.util.Map; public class MeuMapa { public static void main(String[] args) { Map<Integer, String> meuMapa = new HashMap<>(); meuMapa.put(21, "Rio de Janeiro"); meuMapa.put(11, "São Paulo"); meuMapa.put(83, "João Pessoa"); meuMapa.put(31, "Belo Horizonte"); // Nao existe nenhum registro com a chave 45 System.out.println(meuMapa.get(21)); System.out.println(meuMapa.get(45)); System.out.println(meuMapa.get(31)); } } 4 Apenas a partir da versão do Java 7 é possível usar a sintaxe “Map< Integer, String> meuMapa = new HashMap< >();” Antes era necessário informar o tipo de dados do lado direito do = Map<Integer, String> meuMapa = new HashMap<Integer, String >();
- 40. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 4.3. Coleções Essas classes são diferentes dos Arrays por serem dinâmicas, ou seja, podemos adicionar e remover itens durante a execução do nosso programa. Na declaração de uma coleção não precisamos informar qual o tamanho da coleção. Vamos falar de uma interface muito utilizada que é a List. Nela temos a definição dos métodos mais importantes que precisamos: add e remove, que são responsáveis pela inclusão e remoção de atributos respectivamente. Veja um exemplo prático:
- 41. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões package br.com.feltex.jse.colecao; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class MinhaListaArrayList { public static void main(String[] args) { List<String> lista = new ArrayList<>(); lista.add("Maria"); lista.add("Ana"); lista.add("Tatiana"); lista.add("Fernanda"); lista.add("Tatiana"); System.out.println(lista); // Realiza a ordenação dos itens Collections.sort(lista); System.out.println(lista); Collections.reverse(lista); System.out.println(lista); System.out.println(lista.get(1)); for (String item : lista) { System.out.println(item); } for (int i = 0; i < lista.size(); i++) { System.out.println(lista.get(i)); } } }
- 42. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões 4.4. Set O set é um tipo de coleção onde não há valores repetidos. Veja o Exemplo abaixo onde adicionaremos nomes repetidos e o conjunto aceitará apenas uma entrada para os valores em duplicidade. package br.com.feltex.jse.colecao; import java.util.HashSet; import java.util.Set; public class MeuSet { public static void main(String[] args) { Set<String> meuConjunto = new HashSet<>(); meuConjunto.add("Ana"); meuConjunto.add("Ana"); meuConjunto.add("Ana"); meuConjunto.add("Ana"); meuConjunto.add("Maria"); meuConjunto.add("Valeria"); meuConjunto.add("Fernanda"); System.out.println("Total de itens: " + meuConjunto.size()); for (String item : meuConjunto) { System.out.println(item); } } } A saída será assim: Total de itens: 4 Fernanda Maria Valeria Ana Agora utilizaremos uma variação do Set que além de não aceitar itens repetidos cria uma ordem natural para os itens incluídos. Veja como funciona a classe SortedSet:
- 43. Euclides www.feltex.com.br Capítulo 3 – Convenções e Padrões package br.com.feltex.jse.colecao; import java.util.Iterator; import java.util.SortedSet; import java.util.TreeSet; public class MinhaListaSortedSet { public static void main(String[] args) { // Set<String> meuConjunto = new HashSet<>(); SortedSet<String> meuConjunto = new TreeSet<>(); meuConjunto.add("Ana"); meuConjunto.add("Ana"); meuConjunto.add("Ana"); meuConjunto.add("Ana"); meuConjunto.add("Maria"); meuConjunto.add("Valeria"); meuConjunto.add("Fernanda"); //Iterator: Objeto especial que só navega para frente; Iterator<String> i = meuConjunto.iterator(); while (i.hasNext()) { String texto = i.next(); // leitura do texto System.out.println(texto); } } } Observe que desta vez não utilizamos o foreach para navegar entre os itens da nossa coleção. Fizemos uso do iterator. O que vimos... Quais o tipos de coleções existentes no Java. Qual a diferença entre um List e um Set. A utilização prática de um MAP
- 44. Gottfried Leibniz www.feltex.com.br Capítulo 4 – Estrutura de Dados e Coleções
- 45. Carl Gauss www.feltex.com.br Capítulo 5 – Orientação a Objeto 5. Orientação a Objeto Metas do capítulo Como trabalhar com objetos. Conceitos de Classe, Interfaces, atributos. Métodos construtores.
- 46. Carl Gauss www.feltex.com.br Capítulo 5 – Orientação a Objeto 5.1. O que são objetos? É uma de forma de criação de Sistemas pensando como é a interação entre objetos no mundo real. Imagina a situação de pagar uma conta. Existem vários objetos envolvidos nesta situação: conta, pagador, recebedor, banco, beneficiário. Além disso temos também as ações (pagar, registrar, emitir comprovante,) e propriedades (data vencimento, valor, juros). Isso tudo é claro para o nosso dia-a-dia, mas para a programação é uma das formas diferente de abordar um problema. Vamos dividir assim: substantivos objetos verbos métodos atributos estados Tudo o que fazemos está relacionado aos objetos. Toda ação e todos os atributos estão ligados de uma forma inseparável. Os objetos têm estado. Uma televisão, por exemplo, é um objeto. Ela terá métodos (ações) e estado (atributos). Pensando nas ações da minha televisão: ligar, deligar, mudar canal, mudar volume, alterar contraste e muitos outros que podemos lembrar. Mais ainda, o que definiria o estado dela após cada ação? Seriam os estados (ligada ou desligada, canal atual, volume atual) Isso nos permite criar nossas aplicações sempre com o foco na construção dos objetos.
- 47. Carl Gauss www.feltex.com.br Capítulo 5 – Orientação a Objeto 5.2. Instâncias da Classe Vamos falar agora do conceito de classe. Elas são as definições básicas para construção dos nossos objetos. As classes são as definições de um objeto. Quando falamos que temos um carro. Sabemos exatamente o que é um carro, não precisamos necessariamente saber qual a marca e o modelo. Carros têm características específicas de carro. Seriam elas: motor, volante, porta, rodas, assentos. Então classe é apenas uma definição daquilo que pode ser um objeto. O objeto é uma realização da classe. Planta baixa (Classe) Casa (Objeto) Projeto Veículo (Classe) Carro (Objeto) A cada arquivo que geramos de código damos o nome de classe. A classe: Carro, Aluno, Professor, Conta. As definições de código são criadas nesses arquivos. Para usarmos essas classes em nossos sistemas criamos os objetos. Em um sistema acadêmico, por exemplo, temo apenas uma classe Aluno, mas teremos várias instâncias (objetos) dessa classe.
- 48. Carl Gauss www.feltex.com.br Capítulo 5 – Orientação a Objeto 5.3. Atributos da Classe São os estados que as classes podem possuir. Em uma classe Aluno teremos vários atributos (matrícula, nome, data nascimento, e-mail e telefone). Essas características são os atributos. 5.4. Diagrama de Classes Na UML dizemos que são representações gráficas das relações entre as classes. 5.5. Atributos Estáticos São os atributos que não estão associados aos objetos e sim à classe. Podemos tem várias instâncias (objetos) de uma classe, mas os atributos estáticos terão apenas um. Não é necessário criar uma instância de uma classe de para utilizar um atributo estático. Ele já estará disponível assim que o seu programa for carregado na memória. Forma de declaração: public static String nome;
- 49. Carl Gauss www.feltex.com.br Capítulo 5 – Orientação a Objeto Além de atributos também podemos ter métodos estáticos. Outros exemplos que já utilizamos são os métodos da classe JOptionPanel. Métodos que podem ser utilizados em criar instância das classes. Vamos a um exemplo prático: Math.max(10,20); Não precisamos instanciar um objeto da classe Math para usar seus métodos. Todos eles são estáticos. Isso também ocorre para o nossa classe JOptionPanel. showConfirmDialog Exibe uma janela com um pergunta e 3 botoões "yes/no/cancel" showInputDialog Solicita um valor de entrada, sempre será retornado como String. showMessageDialog Exibe uma mensagem de aviso. 5.6. Construtores da Classe Construtores são métodos utilizados para construir e ao mesmo tempo inicializar os atributos das classes. Os construtores mais comuns que utilizamos são os construtores padrões. Há algumas regras para um método ser um construtor: Não podem ter retorno, nem mesmo a palavra void Tem que ter o mesmo nome da classe Se não for criado nenhum construtor o Java disponibiliza o construtor padrão. o Se pelo menos um construtor for criado o Java não executará mais essa etapa. Aluno aluno = new Aluno(); // Usando o construtor Padrão Aluno aluno = new Aluno(“Maria da Silva”); // Construtor com nome Aluno aluno = new Aluno(1232); // Construtor com matrícula
- 50. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos 6. Tratamento de exceção Metas do capítulo Tratar erros na aplicação; Diferencias erros negócio de erros de ambiente; Tipos de exceção (obrigatórios e opcionais); Validar entrada de dados 6.1. O que é uma exceção Em nossos sistemas podemos ter ocorrências fora do domínio desejado. Imagina para o nosso sistema acadêmico, imagine que solicitamos a matrícula que é numérica e o usuário digita um valor textual. O que aconteceria com o nosso sistema? package br.com.feltex.jse.excecao; import javax.swing.JOptionPane; public class MinhaExceao01 { public static void main(String[] args) { Integer matricula = Integer.parseInt(JOptionPane .showInputDialog("Digite sua matrícula")); System.out.println("Matrícula digitada: " + matricula); } }
- 51. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos 7. Mais um pouco de Orientação a Objetos Metas do capítulo O que é herança? Como fazer sobrecarga Sobre escrita e suas vantagens Polimorfismo
- 52. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos 7.1. Herança Existem muito objetos que compartilham características entre sim. Se pensarmos no reino animal podemos verificar que os gatos têm semelhanças com os leões e que o cachorros têm comportamento e estados dos lobos. A isso chamamos de herança. Onde um objeto recebe atributos que podemos classificá-los. O gato é um mamífero assim como o leão. Os 2 também são categorizados como felinos. Eles tem 4 patas, rabo e garras. Essas são algumas semelhanças. Além disso, temos o que chamamos de especialização. O Leão tem um grande porte, possui muita força e é selvagem. Os gatos são de menor porte, tem garras pequenas e são domesticados. Em nosso sistema podemos fazer cadastros de tipo de pessoa. Uma pessoa sempre possui: nome, telefone, endereço, e-mail. Vamos especializar e mostrar as diferenças: Pessoa Física (CPF, Sexo, RG, Estado Civil) Pessoa Jurídica (CNPJ, Inscrição estadual, Inscrição Municipal). Veja a imagem abaixo: Classe Pessoa Animal Mamífero Felino Gato Leão Canino Cachorro Lobo Pessoa Pessoa Fisica Pessoa Juridica
- 53. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos package br.com.feltex.jse.oo.heranca; import java.util.Date; public class Pessoa { private String nome; private Date dataCadastro; private int codigo; public int getCodigo() { return codigo; } public Date getDataCadastro() { return dataCadastro; } public String getNome() { return nome; } public void setCodigo(int codigo) { this.codigo = codigo; } public void setDataCadastro(Date dataCadastro) { this.dataCadastro = dataCadastro; } public void setNome(String nome) { this.nome = nome; } @Override public String toString() { return "Pessoa [nome=" + nome + ", dataCadastro=" + dataCadastro + ", codigo=" + codigo + "]"; } } As classes PessoaFisica e PessoaJurídica possuem todas as características de pessoa. Elas também trazem as especializações que não são atributos particulares. Analise as classes abaixo:
- 54. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos Classe Pessoa Física package br.com.feltex.jse.oo.heranca; public class PessoaFisica extends Pessoa { private String cpf; private String sexo; public String getCpf() { return cpf; } public void setCpf(String cpf) { this.cpf = cpf; } public String getSexo() { return sexo; } public void setSexo(String sexo) { this.sexo = sexo; } }
- 55. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos Classe PessoaJuridica package br.com.feltex.jse.oo.heranca; public class PessoaJuridica extends Pessoa { private String cnpj; private String nomeFantasia; public String getCnpj() { return cnpj; } public void setCnpj(String cnpj) { this.cnpj = cnpj; } public String getNomeFantasia() { return nomeFantasia; } public void setNomeFantasia(String nomeFantasia) { this.nomeFantasia = nomeFantasia; } } Preste atenção que as classes filhas de pessoa possuem a palavra extends na declaração da classe. Isso define que a existe uma ligação de herança entre essas 2 classes. Herança Múltipla Em algumas linguagens como C++ ou Python permitem que uma classe herde características de 2 os mais classes ao mesmo tempo. Em Java isso não é permitido! Existe apenas uma classe a qual podemos estender as funcionalidades por vez! Classe pai É importante saber que toda classe é filha da classe padrão Objetct.
- 56. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos Outra situação de herança é a relação entre Avô, Pai e filho. O filho herdou as características do pai que herdou as características do avô. Criamos um código de exemplo para deixar claro como isso funciona. Avô package br.com.feltex.jse.oo.hierarquia; public class Avo { public Avo(){ System.out.println("Criando o AVO"); } public String toString() { return "Avo []"; } } Pai package br.com.feltex.jse.oo.hierarquia; public class Pai extends Avo{ public Pai(){ System.out.println("Criando o PAI"); } @Override public String toString() { return "Pai []"; } } Filho package br.com.feltex.jse.oo.hierarquia; public class Filho extends Pai { public Filho() { System.out.println("Criando o FILHO"); } public String toString() { return "Filho []"; Avô Pai Filho
- 57. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos } } Agora vamos instanciar a Classe filho para vermos como será o comportamento do Java nessa situação. package br.com.feltex.jse.oo.hierarquia; public class ConstrucaoObjetos { public static void main(String[] args) { Filho meuFilho = new Filho(); System.out.println(meuFilho.toString()); } } A saída será a seguinte: Criando o AVO Criando o PAI Criando o FILHO Filho [] Você consegue entender por que isso acontece? Vamos lá, pense no mundo real... 1, 2, 3 e EUREKA! É possível um filho existir ser o pai ter nascido? A resposta é: não! E da mesma forma é necessário o avô ter nascido para o par nascer! Então, seguindo esse raciocínio lógico temos que sempre que criamos um objeto do tipo filho teremos a criação de avô e depois pai para somente em seguida ser criado o filho. Tudo como funciona no mundo real!
- 58. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos 7.2. Mais um pouco de Orientação a Objetos Overriding (sobrescrita) Esse é o caso de escrevermos o método na classe filha para ter um comportamento diferente do original. Imagine a classe animal. Todo animal emite um som. Então teríamos na classe animal o método: emitirSom(). Considerando que todo animal tem que ter um método assim devemos sobrescrever/reescrever esse método para gato, leão, cachorro e lobo que são classe que herdam de animal. package br.com.feltex.jse.oo.hierarquia3; public class Felino { public void emitirSom() { System.out.println("Felino ...."); } } package br.com.feltex.jse.oo.hierarquia3; public class Gato extends Felino { public void emitirSom() { System.out.println("Miado!"); } } package br.com.feltex.jse.oo.hierarquia3; public class Leao extends Felino { public void emitirSom() { System.out.println("Rugido!"); } } package br.com.feltex.jse.oo.hierarquia3; public class MeuAnimal { public static void main(String[] args) { Felino felino1 = new Gato(); Felino felino2 = new Leao(); felino1.emitirSom(); felino2.emitirSom(); } } Felino Gato Leão
- 59. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos O código mostrado acima é um exemplo de como o método com a mesma assinatura “emitirSom” pode ter funcionamento diferente a partir da implementação de cada classe. Isso é a sobrescrita. 7.3. Overloading (Sobrecarga) A sobrecarga sempre foi um assunto que assusta muitos programadores que utilizam orientação a objetos. Vamos pensar no nosso dia-a-dia. Quando ocorrem as seguintes situações: houve uma sobre carga elétrica na padaria da esquina ou aquele caminhão está com sobrecarregado. O que entendemos de sobrecarga nesses momentos? É que foram passados mais carga aos objetos (mais carga elétrica para a padaria e mais carga para o caminhão). Se os 2 estiverem devidamente preparados eles conseguirão trabalhar com as cargas normais e suportar as cargas extras. Nos métodos temos os métodos que recebem 1 parâmetro, recebem 2 parâmetros, 3 ou mais parâmetros. calcularSoma(10,4); calcularSoma(3,3, 6); calcularSoma(10,4, 6,2); São métodos que possuem o mesmo nome e mesmo tipo de retorno só que com numero e tipos de parâmetros diferentes.
- 60. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos package br.com.feltex.jse.overloading; public class SomaNumeros { public static void main(String[] args) { calcularSoma(10, 4); calcularSoma(3, 3, 6); calcularSoma(10, 4, 6, 2); } public static void calcularSoma(int a, int b) { System.out.println(a + b); } public static void calcularSoma(int a, int b, int c) { System.out.println(a + b + c); } public static void calcularSoma(int a, int b, int c, int d) { System.out.println(a + b + c + d); } }
- 61. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos 7.4. Referenciando atributos da classe atual Palavra reservada this faz referência a sua própria instância. Isso permite passar parâmetros com todos os seus valores a um método. Ela é muito utilizada nos construtores para inicializar as variáveis de instância. package br.com.feltex.jdbc; import java.io.Serializable; public class Aluno implements Serializable { private static final long serialVersionUID = -309513637403441918L; private Long matricula; private String nome; private String telefone; public Aluno() { } public Aluno(Long matricula) { super(); this.matricula = matricula; } public Aluno(Long matricula, String nome) { super(); this.matricula = matricula; this.nome = nome; } public Long getMatricula() { return matricula; } public String getNome() { return nome; } public String getTelefone() { return telefone; } public void setMatricula(Long matricula) { this.matricula = matricula; } public void setNome(String nome) { this.nome = nome; } public void setTelefone(String telefone) { this.telefone = telefone; } } Observe a ocorrência nos métodos “Set...” e nos construtores. Nesses casos temos variáveis com o mesmo nome. Veja o exemplo de “setMatricula(Long matricula)” quando estamos dentro do método a qual matrícula estamos nos referindo (parâmetro ou atributo de classe?). Quando utilizamos o nome simples é ao parâmetro quando utilizamos a palavras this é referência ao atributo de classe
- 62. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos 7.5. Referenciando atributos da classe superior Palavra reservada super. Ela serve para fazer referência ao objeto pai. Ela é muito utilizada nos construtores para chamar outros construtores da classe pai. Nas chamadas de construtores o super() deve ser a primeira instrução de um método construtor, caso contrário teremos um erro de compilação. public Aluno(Long matricula) { super(); this.matricula = matricula; } 7.6. Polimorfismo É a característica de um objeto poder ser transformado em outro. Existe uma velha história do calçar o sapato. Uma criança consegue calçar o sapato do pai, contudo o inverso não acontece. Isso é bem claro, pois o sápado de um adulto é maior que o de uma criança. 7.7. Classes Abstratas São classes que possuem alguns métodos concretos como de qualquer outra classe e que também possuem métodos abstratos. Esses métodos não possuem código. Eles existe apenas para obrigar as classes filhas, que são concretas, a implementar tais métodos. Uma classe abstrata não pode ser instanciada. 7.8. Métodos Abstratos É um tipo de método que não tem corpo, apenas uma assinatura; Ok, tudo muito legal, tudo muito bom, mas para que mesmo serve isso aí? public void emitirSom(); public void saltar(); O nosso exemplo da classe Felino, não precisaríamos de implementação para o método emitirSom(). Isso deveria ficar a cargo das classes Gato e Leão. É nesse caso que entram os métodos abstratos: A classe ficaria assim package br.com.feltex.jse.oo.hierarquia3; public abstract class Felino { public abstract void emitirSom(); }
- 63. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos Onde o métodos emitirSom() tem apenas uma assinatura. Veja também que a classe passou a ser abstrata. Quando há pelo menos um método abstrato necessariamente a classe tem que ser abstrata! A saber: uma classe abstrata também pode ter métodos dinâmicos. E uma classe abstrata não pode ser instanciada. 7.9. Interfaces No mundo real quando pensamos em interface nos remetemos automaticamente naquilo que é visual: as interfaces gráficas. Tudo que está visível e disponível para nós. O que pensamos quando lemos a palavra veículo? Seriam objetos que podemos utilizar para dirigir, buzinar, acender faróis! As interfaces são arquivos Java que criam conceitos de alto nível. Elas definem as características e ações que devem existir em uma classe, mas não detalham como devem ser implementadas. package br.com.feltex.jse.oo.minhainterface; public interface Veiculo { public void dirigir(); public void buzinar(); public void passarMarcha(); } Todos esses métodos são comuns para as classes que implementam a interface veículo. Na prática a interface é uma classe que possui apenas métodos abstract. Não é possível instanciar uma Interface. package br.com.feltex.jse.oo.minhainterface; public class MeuCarro implements Veiculo { @Override public void dirigir() { System.out.println("Dirigir...."); } Veículo Carro Ônibus Caminhonete
- 64. Leonhard Euler www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos @Override public void buzinar() { System.out.println("buzinar...."); } @Override public void passarMarcha() { System.out.println("passarMarcha...."); } }
- 65. Louis leithold www.feltex.com.br Capítulo 7 – Classes Utilitárias 8. Classes Utilitárias Metas do capítulo Classe para manipulação de texto. Métodos especiais para operações matemáticas. Internacionalização. Formatação de Datas e valores monetátios.
- 66. Louis leithold www.feltex.com.br Capítulo 7 – Classes Utilitárias 8.1. Pacote java.lang O java.lang é o pacote essencial do Java. Não é necessário realizar a importação das classes nele contidas. Classes como String, Integer, Double, Float, Boolean entre outras que estão disponíveis nesse pacote. Vamos dar destaque neste capítulo para a classe String. Ela é a grande estrela da manipulação de texto no Java. A esta altura da apostila todos já sabem instanciar uma String. Se não souber releia o capítulo de “Introdução ao Java” para ter um melhor aproveitamento do material. Então conheça alguns métodos: 8.2. Classe String package br.com.feltex.utilitarias; public class MinhaString { public static void main(String[] args) { String meuTexto = "Batatinha quando nasce espalha a rama pelo chao!"; System.out.println(meuTexto.toUpperCase()); //BATATINHA QUANDO NASCE ESPALHA A RAMA PELO CHAO! System.out.println(meuTexto.toLowerCase()); //batatinha quando nasce espalha a rama pelo chao! System.out.println(meuTexto.substring(2)); //tatinha quando nasce espalha a rama pelo chao! System.out.println(meuTexto.substring(2,10)); //tatinha // Retorna verdadeiro se o texto terminar com a string informada System.out.println(meuTexto.endsWith("chao!")); // Retorna verdadeiro se o texto começar com a string informada System.out.println(meuTexto.startsWith("Bata")); } } Procure fazer uso apenas de Letras e números para nomear uma varíavel. Operações Em java quando estamos fazendo uma operação (soma, subração, divisão e um dos elementos for String o resultado será do tipo em String).
- 67. Louis leithold www.feltex.com.br Capítulo 7 – Classes Utilitárias 8.3. Classe Math Classe Math possui métodos para realizarmos várias operações matemáticas. Podemos destacar geração de números raiz quadrada, maior e menor número, logaritmos, aleatórios, seno, cosseno, tangente, transformações de graus em radianos e o inverso. package br.com.feltex.jse.util; public class MeuMath { public static void main(String[] args) { double x = 9; double y = 5; System.out.println("Maior número: " + Math.max(x, y)); System.out.println("Menor número: " + Math.min(x, y)); System.out.println("Raiz quadrada: " + Math.sqrt(x)); System.out.println("Número Aleatório: " + Math.random() * 100 ); System.out.println("Valor Absoluto: " + Math.abs(-222) ); System.out.println("Raíz cúbica: " + Math.cbrt(27) ); System.out.println("Eleva um número a potência desejada: " + Math.pow(x,y) ); System.out.println("Log na base 2: " + Math.log(32) ); System.out.println("Log na base 10: " + Math.log10(1000) ); } }
- 68. Louis leithold www.feltex.com.br Capítulo 7 – Classes Utilitárias 8.4. Locale Classe Locale nos ajuda a configurar informação como Idioma, configuração de moeda, data, hora, padrão de separadores de número (decimal e milhar). São muito utilizadas na formação de datas. Essas classes são utilizadas em conjunto com as classes de manipulação de datas.
- 69. Louis leithold www.feltex.com.br Capítulo 7 – Classes Utilitárias 8.5. DateFormat DateFormat é uma classe que auxilia na formatação de datas. Podemos fazer a conversar de padrões como o padrão Brasileiro de Dada 20/05/2014 (DD/MM/YYYY) para o padrão dos Estados Unidos da América 05/20/2014 (MM/DD/YYYY). Veja os exemplos abaixo: package br.com.feltex.jse.text; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; public class MeuSimpleDateFormate { public static void main(String[] args) { Date minhaData = new Date(); DateFormat formatador = new SimpleDateFormat("dd/MM/yyyy EEEE"); System.out.println(formatador.format(minhaData)); formatador = DateFormat.getDateInstance(DateFormat.FULL); System.out.println(formatador.format(minhaData)); formatador = DateFormat.getDateInstance(DateFormat.LONG); System.out.println(formatador.format(minhaData)); formatador = DateFormat.getDateInstance(DateFormat.MEDIUM); System.out.println(formatador.format(minhaData)); formatador = DateFormat.getDateInstance(DateFormat.SHORT); System.out.println(formatador.format(minhaData)); } } package br.com.feltex.jse.text; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Locale; public class MeuSimpleDateFormate2 { public static void main(String[] args) { Date minhaData = new Date(); Locale brasileiro = new Locale("PT", "br"); DateFormat formatador = new SimpleDateFormat("dd/MM/yyyy EEEE", brasileiro); System.out.println(formatador.format(minhaData)); Locale americano = new Locale("US", "en"); formatador = new SimpleDateFormat("MM//dd/yyyy EEEE", americano); System.out.println(formatador.format(minhaData)); } }
- 70. Louis leithold www.feltex.com.br Capítulo 7 – Classes Utilitárias
- 71. Louis leithold www.feltex.com.br Capítulo 7 – Classes Utilitárias 8.6. Formatação de Número
- 72. Robert Hooke www.feltex.com.br Capítulo 8 – Manipulação de Arquivos 9. Manipulação de Arquivos 9.1. Classe File É uma das classes mais básicas para manipulação de arquivos. Temos nela os métodos e propriedades que nos auxiliam na manipulação de arquivos. Métodos como o “exists” nos informam a existem ou não do arquivos. Um fato importante a destacar é que a classe fila não faz distinção entre arquivos e diretório, todos são File. Para isso existe um método chamado “isDirectory” que retorna true se o apontamento é um diretório e false no caso contrário. package br.com.feltex.jse.io; import java.io.File; public class LeituraPropriedadesArquivo { public static void main(String[] args) { try { // Este Path está definido para funcionar no Windows File arquivo = new File("C:/relatorio.txt"); // Para uso no linux apenas descomente a linha abaixo. // arquivo = new File("relatorio.txt"); System.out.println("Permite leitura: " + arquivo.canRead()); System.out.println("Permite escrita: " + arquivo.canWrite()); System.out.println("Permite Execução: " + arquivo.canExecute()); System.out.println("Está oculto: " + arquivo.isHidden()); System.out.println("É um diretório: " + arquivo.isDirectory()); System.out.println("É um arquivo: " + arquivo.isFile()); System.out .println("Caminho Absoluto: " + arquivo.getAbsolutePath()); System.out.println("Diretório pai: " + arquivo.getParent()); System.out.println("Tamanho em bytes: " + arquivo.length()); System.out.println("Cria um diretório: " + arquivo.mkdir()); System.out.println("Cria um caminho de diretórios: " + arquivo.mkdirs()); } catch (Exception e) { e.printStackTrace(); } } }
- 73. Robert Hooke www.feltex.com.br Capítulo 8 – Manipulação de Arquivos 9.2. Lendo e Gravando Dados em Arquivos Uma tarefa muito comum em programação é quando precisamos realizar a leitura ou gravação de dados em um arquivo texto. package br.com.feltex.jse.io; import java.io.BufferedReader; public class AcessoArquivoTexto { public static void main(String[] args) { System.out.println("Inicio AcessoArquivoTexto"); // Escreve o conteúdo no arquivo Texto escreverArquivo("Meu texton"); // Realiza a leitura do conteúdo do arquivo texto lerArquivo(); System.out.println("Fim AcessoArquivoTexto"); } public static void lerArquivo() { try { FileReader reader = new FileReader("C:/temp/meuArquivo.txt"); BufferedReader br = new BufferedReader(reader); String linha = ""; while ((linha = br.readLine()) != null) { System.out.println(linha); } br.close(); } catch (IOException e) { e.printStackTrace(); } } public static void escreverArquivo(String texto) { try { FileWriter writer = new FileWriter("C:/temp/meuArquivo.txt", true); BufferedWriter bw = new BufferedWriter(writer); bw.append(texto); bw.close(); } catch (IOException e) { e.printStackTrace(); } } }
- 74. Robert Hooke www.feltex.com.br Capítulo 8 – Manipulação de Arquivos 9.3. Classes Scanner e PrintWriter Essas classes facilitam a leitura e escrita de arquivos com conteúdo textuais. A classe Scanner pode ser utilizada para fazer iterações por linhas considerando um delimitador. É uma classe muito aplicada para fazer a leitura linha a linha de um arquivo. Usamos também para ler a cada delimitador como em arquivos “csv” que utilizam o “;” como delimitar de cada campo. package br.com.feltex.jse.io; import java.io.File; public class MeuScanner { public static void main(String[] args) { System.out.println("Inicio MeuScanner"); try { File arquivo = new File( "C:/temp/meuArquivo.txt"); Scanner scanner = new Scanner(arquivo); scanner.useDelimiter("n"); while (scanner.hasNext()) { System.out.println(scanner.next()); } scanner.close(); } catch (Exception e) { e.printStackTrace(); } System.out.println("Fim MeuScanner"); } }
- 75. Robert Hooke www.feltex.com.br Capítulo 8 – Manipulação de Arquivos 9.4. Escrita de Dados na Saída Padrão package br.com.feltex.jse.io; import java.io.File; public class MeuPrintWriter { public static void main(String[] args) { //Escreve uma linha em uma arquivo texto System.out.println("Inicio MeuPrintWriter"); try { File arquivo = new File("C:/temp/meuArquivo.txt"); PrintWriter pw = new PrintWriter(arquivo); pw.append("Mensagem do Dia!!"); pw.close(); } catch (IOException e) { e.printStackTrace(); } System.out.println("Fim MeuPrintWriter"); } } Manipulando arquivos no Java Existem vários post no nosso site sobre o assunto de arquivos! Indicamos que vocês acessem para terem mais conteúdos para estudarem e verem outros exemplos. Publicamos semanal mente artigos sobre Java no blog: www.feltex.com.br Segue o tutorial de manipulação de arquivos: http://www.feltex.com.br/felix/manipulacao-de-arquivos/
- 76. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) 10. Banco de Dados (JDBC) Metas do capítulo O que é JDBC. Comandos Básicos de SQL (DDL e DML). Classes e interfaces utilizadas para conectar com o Banco de Dados. Vários tipos de conexão com Banco de dados. CRUD de uma entidade.
- 77. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) 10.1. Introdução Primeiro devemos saber do que estamos falando. O que seria um banco de dados? Imagine um sistema de Controle de uma escola. É necessário realizar vários cadastros (Alunos, Professores, Diretores, turmas). Ok, entendido. Para isso precisamos de um local onde possamos armazenar isso. Para cada classe mencionada criaremos uma tabela, que nada mais é uma estrutura como linhas e colunas... uma matriz. JDBC – Java Database Connectivity. É a tecnologia Java para conexão com banco de Dados Tabela aluno: Matrícula Nome Telefone Email 1141 Jose da Silva 2251-4471 jose@feltex.com.br 5541 Maria da Silva 4474-5563 maria@feltex.com.br 4412 Antonia Ferreira 7745-78844 antonia@feltex.com.br Simples assim. Para o conjunto dessas tabelas armazenadas em um software centralizados chamamos de Banco de Dados. Existem muitos Bancos de Dados famosos por aí: Oracle, MySQL, SQL Server, PostgreSQL, IBM DB2 entre outros.
- 78. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) 10.1.1. Estabelecendo a Conexão Nos nossos exemplos trabalharemos com o Banco de Dados MySQL. Ele é um software free que podemos baixar do site da Oracle. Banco de dados Existem muitos banco de dados no mercado. Acesse os links abaixo e veja mais informações sobres eles: MySQL – http://dev.mysql.com/downloads/ PostgreSQL – http://www.postgresql.org/download/ Oracle – http://www.oracle.com/index.html SQL Server: http://www.microsoft.com/
- 79. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) Assista aos vídeos e configure seu banco de dados MySQL (Instalação e Configuração do Banco de Dados MySQL) http://youtu.be/fLDv31U_fkw PostGreSQL Instalação e Configuração do Banco de Dados PostGreSQL – http://youtu.be/lXq_hzf1-yM
- 80. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) 10.1.2. Trabalhando com Instruções SQL 10.1.3. Para criar uma tabela: CREATE TABLE tbaluno ( matricula INT NOT NULL , nome VARCHAR(45) NULL , telefone VARCHAR(45) NULL , email VARCHAR(45) NULL , datanascimento DATETIME NULL , tbalunocol VARCHAR(45) NULL ); Quando precisamos realizar uma inclusão no banco de dados utilizamos comandos específicos. Vamos fazer os comandos DML – Data Manipulation Language (Linguagem de Manipulação de Dados). Esses comandos são basicamente Consultar, Incluir, Alterar e Excluir registros na base de dados. Isso é mais conhecido no mundo da informática como CRUD – Create Read Update and Delete.(Criar, ler, atualizar e deletar). Vejamos esses comandos básicos
- 81. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) 10.1.4. Para incluir um registro na tabela insert into tbaluno (matricula,nome, telefone, email) values (1, 'maria da silva','5555- 9887','maria.silva@feltex.com.br'); insert into tbaluno (matricula,nome, telefone, email) values (2, 'Jose da silva','2223- 3222','jose.silva@feltex.com.br'); insert into tbaluno (matricula,nome, telefone, email) values (3, 'Bruna silva','4412-2234','bruna.silva@feltex.com.br'); 10.1.5. Para listar os registros existentes na tabela Select * from tbaluno; 10.1.6. Para alterar um registro na tabela update tbaluno set nome = 'Maria da Silva Pereira' where matricula = 1; Error Code: 1175. You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column. To disable safe mode, toggle the option in Preferences -> SQL Queries and reconnect. 0.000 sec Se você receber essa mensagem de erro no MySQL Workbench 10.1.7. Para excluir um registro na tabela Delete from tbaluno where matricula = 1;
- 82. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) Agora que já conhecemos os comandos básicos vamos ver como utilizá-los em Java. Veja o passo a passo de como ocorre a execução de um Comando no banco de dados Figura 1gfdgsfgd Figura 2asdasdasd Conexao Comando SQL Execução Resultado Connection PreparedStatment executeQuery ResultSet
- 83. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) Crie um novo projeto. Adicione uma classe chamada AlunoJDBC com o seguinte conteúdo: package br.com.feltex.jdbc; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; public class AlunoJDBC { public static void main(String[] args) { System.out.println("Inicio AlunoJDBC"); try { String usuario = "root"; String senha = ""; // Aqui é criada a conexão com o Banco de Dados Connection conexao = DriverManager.getConnection( "jdbc:mysql://localhost:3306/bdacademicnet", usuario, senha); //Criação de um objeto para executar o comando SQL PreparedStatement pstm = conexao .prepareStatement("select * from tbaluno"); // Será retornada a lista de registros existentes no banco ResultSet rs = pstm.executeQuery(); //Loop para ler cada registro while (rs.next()) { String nome = rs.getString("nome"); String telefone = rs.getString("telefone"); System.out.println("nome: " + nome + " telefone: " + telefone); } //É necessário fechar o PreparedStatement e a Conexão pstm.close(); conexao.close(); } catch (Exception e) { e.printStackTrace(); } System.out.println("Fim AlunoJDBC"); } } Conexão JDBC Há um tutorial sobre conexão com diversos Bancos de dados em nosso blog: Acesse http://www.feltex.com.br/felix/tutorial-jdbc/
- 84. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) Teremos como resultado as linhas registradas na nossa tabela. Veja a saída da console abaixo: Inicio AlunoJDBC nome: maria da silva telefone: 5555-9887 nome: Jose da silva telefone: 2223-3222 nome: Bruna silva telefone: 4412-2234 Fim AlunoJDBC 10.2. Apresentação Apostila com exercícios de Acesso a banco de dados em Java com JDBC. Ela é um material de apoio para apresentação em sala de aula. Tem como objetivo utilizar um código fonte JAVA para fixar o conteúdo teórico. 10.3. Código de Exemplo Teremos um exemplo completo de como fazer um cadastro de aluno utilizando o Padrão de Projeto DAO – Data Access Object. Veja o passo a passo a seguir. Faça a criação da entidade aluno que conterá os atributos do aluno. •Instâciará Aluno •AlunoDAO AlunoCRUD •matricula •nome •telefone Aluno •CRUD •incluir •alterar AlunoDAO •Conexão Banco de Dados DAO •Executar SQL Comando
- 85. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) 10.4. Entidade Aluno package br.com.feltex.academicnet.entidade; import java.io.Serializable; import java.util.Date; /** * * Classe de entidade que possui os atributos do aluno * */ public class Aluno implements Serializable { private static final long serialVersionUID = -309513637403441918L; private Long matricula; private String nome; private String telefone; private String email; private Date dataCadastro; public Aluno() { } public Aluno(Long matricula) { super(); this.matricula = matricula; } public Aluno(Long matricula, String nome) { super(); this.matricula = matricula; this.nome = nome; } public Date getDataCadastro() { return dataCadastro; } public String getEmail() { return email; } public Long getMatricula() { return matricula; } public String getNome() { return nome; } public String getTelefone() { return telefone; } public void setDataCadastro(Date dataCadastro) { this.dataCadastro = dataCadastro; } public void setEmail(String email) { this.email = email;
- 86. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) } public void setMatricula(Long matricula) { this.matricula = matricula; } public void setNome(String nome) { this.nome = nome; } public void setTelefone(String telefone) { this.telefone = telefone; } @Override public String toString() { return "Aluno [matricula=" + matricula + ", nome=" + nome + ", telefone=" + telefone + ", email=" + email + ", dataCadastro=" + dataCadastro + "]"; } }
- 87. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) 10.5. Cadastro de Aluno 10.5.1. Classe DAO Esta classe contém o código de acesso ao banco de dados. No nosso exemplo trabalharemos com o banco de dados MySQL. package br.com.feltex.jdbc; import java.sql.Connection; import java.sql.DriverManager; /** * Classe responsável pela Conexão com o Banco de dados. É utilizada por outras * classes de persistência de dados. * */ public class DAO { public Connection getConexao() { Connection conexao = null; String usuario = "root"; String senha = "teco01"; String nomeBancoDados = "bdacademicnet"; try { conexao = DriverManager.getConnection( "jdbc:mysql://localhost:3306/" + nomeBancoDados, usuario, senha); } catch (Exception e) { e.printStackTrace(); } return conexao; } } 10.5.2. AlunoDAO Classe que fará as ações de acesso a banco de dados o famoso CRUD. Observe que os objetos recebem como parâmetro um Aluno, objeto que contém todos os atributos que precisamos. Veja que também utilizamos herança entre AlunoDAO e a classe DAO. package br.com.feltex.jdbc; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.Statement; import java.util.ArrayList; import java.util.List; public class AlunoDAO extends DAO{ public void alterar(Aluno aluno) { try { Connection conexao = getConexao(); PreparedStatement pstmt = conexao .prepareStatement("Update tbaluno SET nome = ?, telefone = ?, email = ?, datacadastro = ?" + " WHERE matricula = ? "); pstmt.setString(1, aluno.getNome()); pstmt.setString(2, aluno.getTelefone());
- 88. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) pstmt.setString(3, aluno.getEmail()); pstmt.setDate(4, new java.sql.Date(aluno.getDataCadastro().getTime())); pstmt.setLong(5, aluno.getMatricula()); pstmt.execute(); pstmt.close(); conexao.close(); } catch (Exception e) { e.printStackTrace(); } } public void excluir(Aluno aluno) { try { Connection conexao = getConexao(); PreparedStatement pstm = conexao.prepareStatement("Delete from tbaluno where matricula = ? "); pstm.setLong(1, aluno.getMatricula()); pstm.execute(); pstm.close(); conexao.close(); } catch (Exception e) { e.printStackTrace(); } } public boolean existe(Aluno aluno) { boolean achou = false; try { Connection conexao = getConexao(); PreparedStatement pstm = conexao.prepareStatement("Select * from tbaluno where matricula = ?"); pstm.setLong(1, aluno.getMatricula()); ResultSet rs = pstm.executeQuery(); if (rs.next()) { achou = true; } pstm.close(); conexao.close(); } catch (Exception e) { e.printStackTrace(); } return achou; } public void inserir(Aluno aluno) { try { Connection conexao = getConexao(); PreparedStatement pstm = conexao.prepareStatement("Insert into tbaluno (matricula, nome, telefone, email, datacadastro) values (?,?,?,?,?)"); pstm.setLong(1, aluno.getMatricula()); pstm.setString(2, aluno.getNome()); pstm.setString(3, aluno.getTelefone()); pstm.setString(4, aluno.getEmail()); pstm.setDate(5, new java.sql.Date(aluno.getDataCadastro() .getTime())); pstm.execute(); pstm.close(); conexao.close(); } catch (Exception e) { e.printStackTrace(); } }
- 89. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) public List<Aluno> listar() { List<Aluno> lista = new ArrayList<>(); try { Connection conexao = getConexao(); Statement stm = conexao.createStatement(); ResultSet rs = stm.executeQuery("Select * from tbaluno"); while (rs.next()) { Aluno aluno = new Aluno(); aluno.setMatricula(rs.getLong("matricula")); aluno.setNome(rs.getString("nome")); aluno.setTelefone(rs.getString("telefone")); aluno.setEmail(rs.getString("email")); aluno.setDataCadastro(new java.util.Date(rs.getDate("datacadastro").getTime())); lista.add(aluno); } stm.close(); conexao.close(); } catch (Exception e) { e.printStackTrace(); } return lista; } public Aluno consultar(Aluno aluno) { try { Connection conexao = getConexao(); PreparedStatement pstm = conexao.prepareStatement("Select * from tbaluno where matricula = ?"); pstm.setLong(1, aluno.getMatricula()); ResultSet rs = pstm.executeQuery(); if (rs.next()) { aluno.setMatricula(rs.getLong("matricula")); aluno.setNome(rs.getString("nome")); aluno.setTelefone(rs.getString("telefone")); aluno.setEmail(rs.getString("email")); aluno.setDataCadastro(new java.util.Date(rs.getDate("datacadastro").getTime())); } pstm.close(); conexao.close(); } catch (Exception e) { e.printStackTrace(); } return aluno; } }
- 90. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) Por fim criaremos a classe AlunoCRUD que chamará a camada de acesso a dados AlunoDAO para fazermos a manipulação dos dados no banco. package br.com.feltex.jdbc; import java.util.Date; public class AlunoCRUD { public static void main(String[] args) { System.out.println("Inicio"); try { Aluno aluno = new Aluno(); aluno.setMatricula(123123L); aluno.setNome("Maria da Silva"); aluno.setEmail("Maria@feltex.combr"); aluno.setTelefone("224112"); aluno.setDataCadastro(new Date()); AlunoDAO alunoDAO = new AlunoDAO(); alunoDAO.inserir(aluno); for (Aluno novoAluno : alunoDAO.listar()) { System.out.println(novoAluno); } aluno.setNome("Maria da Silva e Santos"); alunoDAO.alterar(aluno); for (Aluno novoAluno : alunoDAO.listar()) { System.out.println(novoAluno); } alunoDAO.excluir(aluno); System.out.println("Fim"); } catch (Exception e) { e.printStackTrace(); } } }
- 91. RENÉ DESCARTES www.feltex.com.br Capítulo 9 – Banco de Dados (JDBC) 11. Exercícios proposto Nesse exercício devemos considerar que as tabelas já foram criadas no banco de dados e focaremos apenas na codificação Java. 11.1. Executar o exemplo completo Devemos executar o exemplo da apostila que utiliza as funções de consultar, incluir, alterar e excluir um aluuno no banco de dados. Comece o exemplo pela classe AlunoCRUD. 11.2. Alteração do exemplo Neste passo devemos criar novos atributos (CPF, observação, nota) para a entidade Aluno e gravá-los no banco de dados. Veja como deve ficar a tabela Desafio 1. Crie no nosso banco de dados a tabela tbcurso(Codigo inteiro, Nome Texto) 2. Criar a operação de inclusão de curso tbcurso para uma nova entidade no Banco de dados. Será necessário criar também a classe Curso, CursoDAO, CursoCRUD. 3. Após a execução do CRUD faça a associação do aluno a um curso. NOME TIPO ACEITA NULO? Matrícula Inteiro NÃO Nome Texto (100) NÃO Data Cadastro Data NÃO CPF Texto(11) SIM e-mail Texto SIM telefone Texto SIM Observação Texto Sim Nota Decimal Sim