Apostila Java

Conheça mais em
http://www.feltex.com.br
https://www.facebook.com/feltex.br
https://www.youtube.com/user/andrefelixbr/
http://feltex.com.br/moodle

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

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

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.

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.

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.

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

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

Euclides
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).

Euclides
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”.

Euclides
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/.

Euclides
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/

Euclides
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”.

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

Euclides
1. package br.com.feltex.jse.basico;
2. import javax.swing.JOptionPane;
3.
5.
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.

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

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

Euclides
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()

Euclides
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

Euclides
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;
Veja o exemplo de código abaixo:

Euclides
package br.com.feltex.jse.basico;
public class AloMundo2 {
String nome1 = "Maria da Silva";
String nome2 = "Ana Paula";
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

Euclides
Veja abaixo um programa com declaração de variáveis de tipo primitivo:
package br.com.feltex.jse.basico;
public class AloMundo2 {
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)

Euclides
• 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

Euclides
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 (==,<, >, <=, >=, !=, !)
= 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
|| 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

Euclides

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

Euclides
Veja a o código abaixo:
package br.com.feltex.jse.basico.instrucao;
public class InstrucaoIF {
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”

Euclides
Podemos ainda fazer o encadeamento de instruções IF com mais de uma condição.
public class InstrucaoIF2 {
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.
public class Loop1 {
for (int i = 0; i < 10; i++) {
System.out.println("O valor de i x:" + i);
}
}
}

Euclides
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.
public class LoopWhile {
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.
public class LoopDoWhile {
int i = 0;
do {
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:

Euclides
public class LoopWhileBreak {
System.out.println("Inicio");
int i = 0;
while (i <= 5) {
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.

Euclides
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 {
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.
public class LoopWhileContinue {
int i = 0;
while (i <= 5) {
i++;
if (i == 3){
continue;
}
System.out.print(" depois continue!!");
}
}
}
3.7. Exercícios resolvidos

Euclides
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”.
A A
A A
A A
A A
A A
A A
A A
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.

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

Euclides
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;
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;
10 27 4
0 1 2
double[] arrayDouble = new double[3]; // Criação do array de double
arrayDouble [0] = 2.9;
2.9 4.1 2.3

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

Euclides
package br.com.feltex.jse.basico.array;
public class Array01 {
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++) {“

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

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

Euclides
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class MinhaListaArrayList {
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);
Collections.reverse(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));
}
}
}

Euclides
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.
import java.util.HashSet;
import java.util.Set;
public class MeuSet {
Set<String> meuConjunto = new HashSet<>();
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:

Euclides
import java.util.Iterator;
import java.util.SortedSet;
import java.util.TreeSet;
public class MinhaListaSortedSet {
// Set<String> meuConjunto = new HashSet<>();
SortedSet<String> meuConjunto = new TreeSet<>();
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

Gottfried Leibniz
www.feltex.com.br Capítulo 4 – Estrutura de Dados e Coleções

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.

Carl Gauss
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.

Carl Gauss
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.

Carl Gauss
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;

Carl Gauss
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

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 {
Integer matricula = Integer.parseInt(JOptionPane
.showInputDialog("Digite sua matrícula"));
System.out.println("Matrícula digitada: " + matricula);
}
}

Leonhard Euler
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

Leonhard Euler
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

Leonhard Euler
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:

Leonhard Euler
Classe Pessoa Física
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;
}
}

Leonhard Euler
Classe PessoaJuridica
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.

Leonhard Euler
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");
}
return "Avo []";
}
}
Pai
public class Pai extends Avo{
public Pai(){
System.out.println("Criando o PAI");
}
@Override
return "Pai []";
}
}
Filho
public class Filho extends Pai {
public Filho() {
System.out.println("Criando o FILHO");
}
return "Filho []";
Avô
Pai
Filho

Leonhard Euler
}
}
Agora vamos instanciar a Classe filho para vermos como será o comportamento do Java nessa situação.
public class ConstrucaoObjetos {
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!

Leonhard Euler
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 ....");
}
}
public class Gato extends Felino {
System.out.println("Miado!");
}
}
public class Leao extends Felino {
System.out.println("Rugido!");
}
}
public class MeuAnimal {
Felino felino1 = new Gato();
Felino felino2 = new Leao();
felino1.emitirSom();
felino2.emitirSom();
}
}
Felino
Gato Leão

Leonhard Euler
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.

Leonhard Euler
package br.com.feltex.jse.overloading;
public class SomaNumeros {
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);
}
}

Leonhard Euler
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 telefone;
public Aluno() {
}
public Aluno(Long matricula) {
super();
this.matricula = matricula;
}
public Aluno(Long matricula, String nome) {
super();
this.nome = nome;
}
public Long getMatricula() {
return matricula;
}
return nome;
}
public String getTelefone() {
return telefone;
}
public void setMatricula(Long matricula) {
}
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

Leonhard Euler
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.
super();
}
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
public abstract class Felino {
public abstract void emitirSom();
}

Leonhard Euler
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

Leonhard Euler
@Override
public void buzinar() {
System.out.println("buzinar....");
}
@Override
public void passarMarcha() {
System.out.println("passarMarcha....");
}
}

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.

Louis leithold
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 {
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).

Louis leithold
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 {
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) );
}
}

Louis leithold
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.

Louis leithold
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;
public class MeuSimpleDateFormate {
Date minhaData = new Date();
DateFormat formatador = new SimpleDateFormat("dd/MM/yyyy EEEE");
System.out.println(formatador.format(minhaData));
formatador = DateFormat.getDateInstance(DateFormat.FULL);
formatador = DateFormat.getDateInstance(DateFormat.LONG);
formatador = DateFormat.getDateInstance(DateFormat.MEDIUM);
formatador = DateFormat.getDateInstance(DateFormat.SHORT);
}
}
package br.com.feltex.jse.text;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Locale;
public class MeuSimpleDateFormate2 {
Date minhaData = new Date();
Locale brasileiro = new Locale("PT", "br");
DateFormat formatador = new SimpleDateFormat("dd/MM/yyyy EEEE",
brasileiro);
Locale americano = new Locale("US", "en");
formatador = new SimpleDateFormat("MM//dd/yyyy EEEE", americano);
}
}

Louis leithold

Louis leithold
8.6. Formatação de Número

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

Robert Hooke
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.
import java.io.BufferedReader;
public class AcessoArquivoTexto {
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) {
}
}
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();
}
}
}

Robert Hooke
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.
public class MeuScanner {
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();
}
System.out.println("Fim MeuScanner");
}
}

Robert Hooke
9.4. Escrita de Dados na Saída Padrão
public class MeuPrintWriter {
//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();
}
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/

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.

RENÉ DESCARTES
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.

RENÉ DESCARTES
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/

RENÉ DESCARTES
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

RENÉ DESCARTES
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

RENÉ DESCARTES
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;

RENÉ DESCARTES
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

RENÉ DESCARTES
Crie um novo projeto. Adicione uma classe chamada AlunoJDBC com o seguinte conteúdo:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class AlunoJDBC {
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();
}
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/

RENÉ DESCARTES
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

RENÉ DESCARTES
10.4. Entidade Aluno
package br.com.feltex.academicnet.entidade;
import java.io.Serializable;
/**
*
* 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 telefone;
private String email;
private Date dataCadastro;
public Aluno() {
}
super();
}
public Aluno(Long matricula, String nome) {
super();
this.nome = nome;
}
public Date getDataCadastro() {
return dataCadastro;
}
public String getEmail() {
return email;
}
public Long getMatricula() {
return matricula;
}
return nome;
}
public String getTelefone() {
return telefone;
}
public void setDataCadastro(Date dataCadastro) {
this.dataCadastro = dataCadastro;
}
public void setEmail(String email) {
this.email = email;

RENÉ DESCARTES
}
public void setMatricula(Long matricula) {
}
this.nome = nome;
}
public void setTelefone(String telefone) {
this.telefone = telefone;
}
@Override
return "Aluno [matricula=" + matricula + ", nome=" + nome
+ ", telefone=" + telefone + ", email=" + email
+ ", dataCadastro=" + dataCadastro + "]";
}
}

RENÉ DESCARTES
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.
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);
}
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.
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());

RENÉ DESCARTES
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();
}
}
public void excluir(Aluno aluno) {
try {
PreparedStatement pstm =
conexao.prepareStatement("Delete from tbaluno where matricula = ? ");
pstm.setLong(1, aluno.getMatricula());
pstm.execute();
pstm.close();
conexao.close();
}
}
public boolean existe(Aluno aluno) {
boolean achou = false;
try {
conexao.prepareStatement("Select * from tbaluno where matricula = ?");
if (rs.next()) {
achou = true;
}
pstm.close();
conexao.close();
}
return achou;
}
public void inserir(Aluno aluno) {
try {
conexao.prepareStatement("Insert into tbaluno (matricula, nome, telefone, email, datacadastro) values
(?,?,?,?,?)");
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();
}
}

RENÉ DESCARTES
public List<Aluno> listar() {
List<Aluno> lista = new ArrayList<>();
try {
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();
}
return lista;
}
public Aluno consultar(Aluno aluno) {
try {
conexao.prepareStatement("Select * from tbaluno where matricula = ?");
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();
}
return aluno;
}
}

RENÉ DESCARTES
Por fim criaremos a classe AlunoCRUD que chamará a camada de acesso a dados AlunoDAO para fazermos a
manipulação dos dados no banco.
public class AlunoCRUD {
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);
}
}
}

RENÉ DESCARTES
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

Apostila Java

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (10)

Similar a Apostila Java

Similar a Apostila Java (20)

Último

Último (20)

Apostila Java