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

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

Versão: 1.0

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

http://www.oracle.com/technetwork/java/javase/tech/index.html

http://www.oracle.com/technetwork/java/javase/downloads/index.html

http://www.eclipse.org/downloads/

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

http://youtu.be/njSO8oxyNvU

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/

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

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

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

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;

int matricula2 = 334122;

Veja o exemplo de código abaixo:

Euclides


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

Euclides


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)

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 { 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”

Euclides


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

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.

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:

Euclides


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.

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 { 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

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

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;

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

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 { 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++) {“

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

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


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

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.

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:

Euclides


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

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 { public static void main(String[] args) { 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

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

Leonhard Euler


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.

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

Leonhard Euler


} }

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!

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 ...."); } }

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

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

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

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.

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

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

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

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

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

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.

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 texto\n"); // 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(); } } }

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.

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

Robert Hooke


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/


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 [email protected]

5541 Maria da Silva 4474-5563 [email protected]

4412 Antonia Ferreira 7745-78844 [email protected]

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.

mailto:[email protected]



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/

http://dev.mysql.com/downloads/

http://www.postgresql.org/download/

http://www.oracle.com/index.html

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

http://youtu.be/fLDv31U_fkw

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','[email protected]');

insert into tbaluno (matricula,nome, telefone, email) values (2, 'Jose da silva','2223-3222','[email protected]'); insert into tbaluno (matricula,nome, telefone, email) values (3, 'Bruna silva','4412-2234','[email protected]');

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:

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/

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

RENÉ DESCARTES


} 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 + "]"; } }

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.

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

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

RENÉ DESCARTES


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

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.

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("[email protected]"); 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(); } } }

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

Education

Transcript of Apostila Java