Apostila java

ç

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

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

2.6. Formas de Entrada de dados ...................................................................................................................................... 9

2.7. Exibindo minhas mensagens .................................................................................................................................... 10

2.8. Exercícios resolvidos .................................................................................................................................................. 10

2.9. Exercícios propostos .................................................................................................................................................. 11

3. Convenção e padrões .................................................................................................................................................... 12

3.1. Padrão de nomenclatura ............................................................................................................................................ 13



4. Estrutura de Dados e Coleções .................................................................................................................................... 28

4.1. Arrays ............................................................................................................................................................................ 29

4.2. Maps .............................................................................................................................................................................. 32

4.3. Coleções ....................................................................................................................................................................... 33

4.4. Set ................................................................................................................................................................................. 35



5. Orientação a Objeto ........................................................................................................................................................ 39

5.1. O que são objetos? ..................................................................................................................................................... 40

5.2. Instâncias da Classe ................................................................................................................................................... 41

5.3. Atributos da Classe ..................................................................................................................................................... 42

5.4. Diagrama de Classes ................................................................................................................................................. 42

5.5. Atributos Estáticos ...................................................................................................................................................... 42

5.6. Construtores da Classe .............................................................................................................................................. 43

6. Tratamento de exceção .................................................................................................................................................. 46

6.1. O que é uma exceção ................................................................................................................................................ 46

6.2. try{...} catch(...){} finally{} ............................................................................................................................................ 48

7. Mais um pouco de Orientação a Objetos .................................................................................................................... 55

7.1. Herança ........................................................................................................................................................................ 56


www.feltex.com.br

7.2. Mais um pouco de Orientação a Objetos Overriding (sobrescrita) ..................................................................... 63

7.3. Overloading (Sobrecarga) .......................................................................................................................................... 64

7.4. Referenciando atributos da classe atual ................................................................................................................. 66

7.5. Referenciando atributos da classe superior ............................................................................................................ 67

7.6. Polimorfismo ................................................................................................................................................................ 67

7.7. Classes Abstratas ....................................................................................................................................................... 67

7.8. Métodos Abstratos ...................................................................................................................................................... 67

7.9. Interfaces ...................................................................................................................................................................... 68

8. Classes Utilitárias ............................................................................................................................................................ 70

8.1. Pacote java.lang .......................................................................................................................................................... 71

8.2. Classe String ................................................................................................................................................................ 71

8.3. Classe Math ................................................................................................................................................................. 72

8.4. Locale ............................................................................................................................................................................ 73

8.5. DateFormat .................................................................................................................................................................. 74

8.6. Formatação de Número ............................................................................................................................................. 75

9. Manipulação de Arquivos ............................................................................................................................................... 77

9.1. Classe File .................................................................................................................................................................... 77

9.2. Lendo e Gravando Dados em Arquivos................................................................................................................... 79

9.3. Classes Scanner e PrintWriter .................................................................................................................................. 80

9.4. Escrita de Dados na Saída Padrão .......................................................................................................................... 81

10. Banco de Dados (JDBC) ............................................................................................................................................ 82

10.1. Introdução ................................................................................................................................................................. 83

10.1.1. Estabelecendo a Conexão ................................................................................................................................. 84

10.1.2. Trabalhando com Instruções SQL .................................................................................................................... 85

10.1.3. Para criar uma tabela: ........................................................................................................................................ 85

10.1.4. Para incluir um registro na tabela ..................................................................................................................... 86

10.1.5. Para listar os registros existentes na tabela ................................................................................................... 86

10.1.6. Para alterar um registro na tabela .................................................................................................................... 86

10.1.7. Para excluir um registro na tabela .................................................................................................................... 86

10.2. Código de Exemplo ................................................................................................................................................. 89

10.3. Entidade Aluno ........................................................................................................................................................ 90

10.4. Cadastro de Aluno .................................................................................................................................................. 92

10.4.1. Classe DAO .......................................................................................................................................................... 92

10.4.2. AlunoDAO ............................................................................................................................................................. 92

10.5. Exercícios resolvidos .............................................................................................................................................. 96

10.6. Alteração do exemplo ............................................................................................................................................. 96

http://www.oracle.com/technetwork/java/index-135089.html ............................................... Erro! Indicador não definido.


www.feltex.com.br

11. Apêndice A ....................................................................................................................... Erro! Indicador não definido.

11.1. Respostas dos exercícios .......................................................................................... Erro! Indicador não definido.

11.1.1. Capítulo 2 ................................................................................................................. Erro! Indicador não definido.








11.1.9. Capítulo 10 ............................................................................................................... Erro! Indicador não definido.

12. Apêndice B ....................................................................................................................... Erro! Indicador não definido.

12.1. Configuração do Eclipse ............................................................................................ Erro! Indicador não definido.

13. Apêndice C ....................................................................................................................... Erro! Indicador não definido.


Versão: 2.1

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 para

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, aplicações

completas e 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á abordado.

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

Faremos a configuração do ambiente de desenvolvimento.

Criaremos nosso primeiro programa em 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. 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. Java é utilizado de laptops,

datacenters, consoles de jogo, supercomputadores científicos, telefones celulares e claro até na Internet, Java está

em toda parte!

No início da década de 90, estender 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. Liderada por James Gosling,

a equipe trabalhou duramente e criou a linguagem de programação que iria revolucionar o nosso mundo – Java.

The Green Team – 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 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 ou Solaris

SPARC. 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 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ção 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 da 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 wizard do programa. Ao final você já terá o Java

instalado e então deverá fazer a instalação do Eclipse que é a ferramenta que utilizaremos para criar nossos

programas.

Uma analogia é que para criar um arquivo com extensão “.doc” precisamos utilizar o MSWord. 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”.

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://www.oracle.com/technetwork/java/javase/tech/index.html

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

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

http://youtu.be/njSO8oxyNvU

http://www.feltex.com.br/felix/configurando-o-eclipse-keppler/

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

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!”. Aproveita e veja um 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 arquivo. 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:

Digite o código acima no eclipse no mesmo projeto que foi criado anteriormente: 1. Acessar o menu File >> New >> Class.

No campo package digite: “br.com.feltex.jse.lista1”.

2. No campo nome digite: “Nomes”.

3. Pronto. Agora digite o valor abaixo na sua classe.

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

4. Após isso clique com o botão direito na sua Classe Nomes. Acesse Run >> “Run As Java Application”.

Não se esqueça da assinatura

correta do método “main”.


Euclides


2.7. Exibindo minhas mensagens Há 2 formas básicas de exibirmos dados para os usuários. System.out.println e JOptionPane.

System.out.println(“Minha mensagem”);

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. 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. Exibir a mensagem “Meu Super programa!” com System.out.println.

2. Exibir a mensagem “Meu Super programa!” com JOptionPane.

3. Ler nome, idade e telefone de uma pessoa.

4. Ler o endereço e e-mail.

5. Ao final de cada programa imprimir uma mensagem.

1 Modal – 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


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

O básico do mundo Java.

Como está dividida a linguagem Java.

Como criar programas simples na linguagem Java

Forma de exibir os dados para o usuário.

Sintaxe básica de um programa.

2 Console – 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 a sabermos como iniciantes é que Java é Case Sensitive. Isto significa que ela diferencia

letras maiúsculas de minúsculas. Veja: Casa ≠ CASA ≠ CaSa ≠ cASA ≠ casa ≠ Casa ≠ casa

Escrevemos várias vezes a palavra casa, mas para a linguagem Java são valores distintos por terem letras

maiúsculas e minúsculas. Além, disso existem 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 deve ser escrita em maiúsculo. Devemos utilizar substantivos. Veja

os exemplos:

Professor

Aluno

Cadastro

AcessoLogin

NomeMinhaClasse

Variáveis – os nomes de variáveis devem iniciar em minúsculo. Se houver mais de uma palavra cada primeira

letra das palavras seguintes deve ser escrita em maiúsculo. Veja os exemplos:

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 sua 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, ainda que a linguagem permita o uso, não consideramos uma boa prática seu uso. Não

podemos utilizar caracteres especiais com )(*&¨%$#@!,.{}^?:><+.

Procure fazer uso apenas de Letras, números ou _.

Site oficial

Existe um site 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

Comentários são boas práticas quando estamos programando. Devemos fazer alguns comentários em nossas

classes para que sejam 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 de índice de busca e referências

cruzadas entre as páginas.*/

É importante saber que quaisquer comentários criados dentro de métodos não são incluídos no JavaDoc. 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 um programa precisamos de componentes onde guardaremos os dados de entrada.

Vamos considerar que precisamos criar um cadastro de alunos. Precisaremos dos dados como matrícula, nome,

telefone, e-mail e endereço. Dessa forma chamamos cada componente que armazenará esses valores de variáveis e

o nosso programa terá no mínimo 5 variáveis para guardar os dados de aluno. Por isso 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 (Rua São João, Avenida Brasil). Os campos texto são

chamados de “String” e os campos do tipo inteiro chamamos de “int” ou “Integer”.

Para iniciarmos precisamos de 2 tipos no nosso exemplo. Vamos escrever um código para isso.

TipoDados NomeVariável = valor;

String nome1 = “Maria da Silva”;

String nome2 = “Ana Paula”;

int matricula1 = 2234;

int matricula2 = 334122;


Euclides


Crie uma nova classe com o nome de “AloMundo2” e digite o código abaixo:

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 vistos no quadro abaixo. Observe que “String” apesar de ser um tipo muito utilizado não se

enquadra nesta lista de primitivos. Veja que todos os tipos primitivos têm o nome iniciado 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 Tabela 1. Os 8 tipos primitivos de dados


Euclides


Veja abaixo um programa com declaração de variáveis de tipos primitivos:

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 classes Wrapper (tipo de referência). Essas classes possuem métodos que auxiliam na manipulação (conversão, constantes máximas e mínimas) dos valores primitivos.

Primitivo Wrapper

byte Byte

short Short

Int Integer

Long Long

float Float

double Double

boolean Boolean

char Character

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

• Ex: Integer.valueOf("10");


Euclides


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

Para saber um pouco mais sobre Classes Wrappers você acesse o site oficial da Oracle com mais detalhes sobre o uso desse tipo de classe: http://docs.oracle.com/javase/tutorial/java/data/autoboxing.html

Palavras reservadas

Existem palavras reservadas para uso da linguagem Java. Elas são palavras 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


http://docs.oracle.com/javase/tutorial/java/data/autoboxing.html

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

resultado. Veja as tabelas abaixo:

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


Euclides


Tabela verdade


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 (10) é maior que o y (30). A saída tem o valor de “Falso”, pois “10 > 30”. 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.


Euclides


Podemos também utilizar um outro comando para fluxo condicional. Além do if-then e das declarações if-then-

else, a instrução switch pode ter um número de possíveis caminhos de execução. Um switch funciona com

alguns tipos de dados byte, short, char, e tipos primitivos de dados int. Ele também funciona com tipos

enumerados, a classe String3, e algumas classes especiais (Wrappers) dos tipos primitivos informados envolvem

certos tipos primitivos: Character, Byte, Short, e Integer.

O seguinte exemplo de código declara uma variável numérica cujo valor representa um mês. O código exibe o

nome do mês, com base no valor do mês informado pelo usuário, usando a instrução switch.

package br.com.feltex.jse.basico.condicional; import javax.swing.JOptionPane; public class MeuSwitch { public static void main(String[] args) { int mes = Integer.valueOf(JOptionPane .showInputDialog("Informe o número do mês:")); switch (mes) { case 1: System.out.println("Janeiro"); break; case 2: System.out.println("Fevereiro"); break; case 3: System.out.println("Março"); break; case 4: System.out.println("Abril"); break; case 5: System.out.println("Maio"); break; case 6: System.out.println("Junho"); break; case 7: System.out.println("Julho"); break; case 8: System.out.println("Agosto"); break; case 9: System.out.println("Setembro"); break; case 10: System.out.println("Outubro"); break; case 11: System.out.println("Novembro"); break; case 12: System.out.println("Dezembro"); break; default:

3 A classe String só foi introduzida para uso no Swtich a partir da versão 7 do Java.


Euclides


System.out.println("Mês inválido!"); break; } } }

3.6. Laços de repetição Vamos falar de códigos que criamos para executar algumas instruções de código por várias vezes. Imagine que precisamos solicitar várias notas de um aluno para cadastrar no sistema. 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 que precisamos executar em nosso programa. No exemplo abaixo executaremos um loop por 10 vezes e exibiremos o valor da variável x a cada iteração.

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

O comando while realiza uma validação booleana 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(). Este exemplo de loop sempre executará as instruções dentro do laço,

pelo menos uma vez, pois a avaliação da condição de repetição só é feita 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++;


Euclides


} while (i <= 10); } }

Existem momentos que precisamos finalizar um laço de repetição por algumas condições. Para essas situações

existem 2 comandos que nos auxiliam a mudar o fluxo natural do código. São elas o continue e break.

O break realiza uma interrupção do laço e envia a ação para a primeira linha de código fora do bloco do loop.

Veja o exemplo abaixo:

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 a

próxima execução será a linha ”System.out.println("Fim");”.

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


Euclides


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

Digite todos os exemplos anteriores e veja a execução para entender o que ocorre em cada programa. Isso

fará você aprender de forma mais fácil.



1. Imprimir na console 10 vezes a palavra “Java”. Não se esqueça de pular linha em cada comando.

2. Calcular a idade a partir do ano de nascimento.

3. Exiba a estação do ano quando informado o número do mês.

4. Leia e exiba se um número é par ou ímpar.

5. Leia e exiba um número é primo ou não.

6. Pare um loop de 100 repetições quando o número da iteração for a metade do total do loop.

7. Faça um programa que exiba os números múltiplos de 5.

8. Faça um programa que leia um número do usuário e informe se o número é maior ou menor que 20.


Euclides



Desafio

1. Crie um programa que desenhe na console4 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”.

Conhecemos 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

4 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 texto 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 grupo de dados. Esses grupos podem ser divididos em Array, Collection e Map.

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 explicar que o Array é um contêiner de dados do mesmo tipo. 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:

Valor Felix Maria Joana Marta Flavia

Índice 0 1 2 3 4

Atribuímos valores para todas 5 as posições do nosso array. Observe que começamos com o índice “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;

Valor 10 27 4

Índice 0 1 2 double[] arrayDouble = new double[3]; // Criação de um array de double


Euclides


arrayDouble [0] = 2.9; arrayDouble [1] = 4.1; arrayDouble [2] = 2.3;

Valor 2.9 4.1 2.3

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


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:

Chave Valor

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 correspondente ao código. Essa abordagem também poderia ser utilizado para definir os meses do ano:

Chave Valor

1 Janeiro

2 Fevereiro

3 Março

4 Abril

No java declaramos um Map da seguinte forma5:

Map<tipoDaChave, tipoValor> meuMapa = new HashMap<>(); Map< Integer, String> meuMapa = new HashMap< >(); Map<String, String> meuMapa2 = new HashMap< >(); Map< Integer, Integer> meuMapa3 = new HashMap< >(); 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)); } }

5 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 da seguinte forma: Map<Integer, String> meuMapa = new HashMap<Integer, String >();


Euclides


Pare e revise


Mensagem Solução

'<>' operator is not allowed for source level below 1.7

Clique com o botão direito no seu projeto >> properties >> Project Facets >> Selecione a opção Java na combo “Version” selecione 1.7 ou superior. Selecione OK.

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



1. Dado o programa:

public class Array03 { 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"; System.out.println(arrayString[2]); } }

Qual será o resultado:


Euclides


a) Felix b) Maria c) Joana d) Marta e) Flavia

2. Dada a seguinte linha programa, para um array de inteiros:

int[] arrayInteito = new Double[3]; Qual é a resposta correta:

a) O código está correto. b) Há um problema na sintaxe. O Correto é: Integer[] arrayInteito = new Double[3]; c) Há um problema na sintaxe. O correto é: int[] arrayInteito = new int[3]; d) Há um problema na sintaxe. O correto é: int[] arrayInteito = new String[3]; e) Nenhuma das opções anteriores

3. Crie um array de Double com 4 posições. Os valores devem ser definidos na construção do array. Em seguida faça um loop para exibir todos os valores.

4. Crie um array de String com 3 posições. Solicite a entrada de dados do usuário e após o recebimento dos dados imprima os valores na console.

5. Crie um array de 10 posições de inteiros. Faça um loop e solicite que o usuário informe 10 números. Após o recebimento dos dados imprima os valores na console.


Euclides



Desafio

1. Crie um array com 5 posições. Solicite ao usuário 10 números inteiros quaisquer. Armazene os 5 maiores

números no array e depois imprima todos em ordem decrescente. Não permita a gravação de números iguais no array.

2. Crie um array com 3 posições. Solicite ao usuário 10 números quaisquer. Armazene apenas os números primos. Se ao final das 10 digitações o array ainda estiver vazio informe exiba uma mensagem de alerta para o usuário: “Nenhum número foi armazenado, pois não eram números primos!”. Não permita a gravação de números iguais no array.

O que vimos...

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


Leonhard Euler

www.feltex.com.br Capítulo 6 – Mais um pouco de Orientação a Objetos

5. Orientação a Objeto

Metas do capítulo

Como trabalhar com objetos.

Conceitos de Classe, Interfaces e propriedades.

Métodos construtores.


Leonhard Euler


5.1. O que são objetos?

É uma forma de criação de Sistemas pensando como é a interação entre objetos no mundo real. Imagine 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). Isto tudo é bastante 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 e ações.

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


Leonhard Euler


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 algumas delas: motor, volante, portas, rodas e 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, temos apenas uma classe Aluno, mas teremos várias instâncias

(objetos) dessa classe.


Leonhard Euler


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


Leonhard Euler


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 a 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 instanciar um objeto e pode inicializar os atributos com valores

passados como parâmetros.

Os construtores mais comuns que utilizamos são os construtores padrões. São os métodos que não recebem

parâmetros. Veja alguns exemplos:

String();

Aluno();

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 disponibilizará 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 passando o valor do atributo nome

Aluno aluno = new Aluno(1232); // Construtor passando o valor do atributo matrícula.


Leonhard Euler


package br.com.feltex.jdbc; import java.io.Serializable; import java.util.Date; public class Aluno implements Serializable { private static final long serialVersionUID = -309513637403441918L; private Long matricula; private String nome; private String telefone; private String email; private String endereco; 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; } @Override public String toString() { return "Aluno [matricula=" + matricula + ", nome=" + nome + ", telefone=" + telefone + ", email=" + email + ", dataCadastro=" + dataCadastro + "]"; } }


Leonhard Euler


O que vimos...

Construção de objetos

A

A


Leonhard Euler


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 comportamentos fora desejado. Imagine para o nosso sistema acadêmico,

quando solicitamos a matrícula que é numérica e o usuário digita um valor textual como “a”. O que aconteceria?

Execute o código a baixo:

package br.com.feltex.jse.excecao; import javax.swing.JOptionPane; public class MinhaExcecao01 { public static void main(String[] args) { Integer matricula = Integer.parseInt(JOptionPane .showInputDialog("Digite sua matrícula")); System.out.println("Matrícula digitada: " + matricula); } }

Veja o resultado:

Exception in thread "main" java.lang.NumberFormatException: For input

string: "a"

Neste caso é informado que o valor “a” não é válido para valores numérico. Além disso, veja que a linha que

exibe a mensagem final não é exibida.


Leonhard Euler


package br.com.feltex.jse.excecao; import javax.swing.JOptionPane; public class MinhaExcecao02 { public static void main(String[] args) { Integer matricula = 0; try { matricula = Integer.parseInt(JOptionPane.showInputDialog("Digite sua matrícula")); System.out.println("Matrícula digitada: " + matricula); } catch (Exception e) { System.err.println("Matrícula inválida: " + e.getMessage()); } } }

Adicionamos um bloco try{} ... catch(){} que captura uma exceção caso ela ocorra. Desta forma o nosso programa

não para quando o usuário informar um valor inválido.

No exemplo abaixo criaremos um programa que ficará em loop solicitando uma matrícula válida. Assim enquanto

não for recebida uma matrícula válida o programa não terminará.

package br.com.feltex.jse.execao; import javax.swing.JOptionPane; public class MinhaExcecao03 { public static void main(String[] args) { Integer matricula = 0; // Enquanto o valor da matrícula for 0 // o programa solicitará novo número while (matricula == 0) { try { matricula = Integer.parseInt(JOptionPane.showInputDialog("Digite sua matrícula")); System.out.println("Matrícula digitada: " + matricula); // Captura a exceção } catch (Exception e) { System.err.println("Matrícula inválida: " + e.getMessage()); } } } }


Leonhard Euler


6.2. try{...} catch(...){} finally{}

Existem 2 tipos de exceção: Unchecked Exceptions e Checked Exceptions. As Unchecked são exceções que

não nos abrigam a serem tratadas através do uso de try{ ... } catch(...){}.

As Checked são exceções que nos obrigam a ter tratamento sempre que um método lançar uma exceção desse

tipo.

Para saber mais

Leia mais sobre uso de Exceptions no site oficial da Oracle:

http://docs.oracle.com/javase/tutorial/essential/exceptions/advantages.html

Gráfico 1 Hierarquia de classes de Exceção

Object

Throwable

Error Exception

SQLException ClassNotFoundException IOException RuntimeException

NullPointerException NumberFormatException


http://docs.oracle.com/javase/tutorial/essential/exceptions/advantages.html

Leonhard Euler


Palavras reservadas utilizadas no tratamento de exceção:

try – bloco que indica onde poderá ocorrer a exceção.

catch – bloco onde a exceção será capturada e poderá ser tratada.

finally – bloco que é executado sempre, havendo ou não uma exceção.

throw – utilizada para lançar uma exceção.

throws – utilizada na assinatura do método para indicar que uma exceção é lançada.

| – (multi-catch) Utilizada no catch para indicar a captura de mais de uma exceção de diferentes

hierarquias.

No código abaixo apresentamos o uso do try{...} catch(...){ } finally{}


Leonhard Euler


package br.com.feltex.jse.execao; import javax.swing.JOptionPane; public class MinhaExcecao04 { public static void main(String[] args) { Integer matricula = 0; // Enquanto o valor da matrícula for 0 while (matricula == 0) { try { matricula = Integer.parseInt(JOptionPane.showInputDialog("Digite sua matrícula")); System.out.println("Matrícula digitada: " + matricula); } catch (Exception e) { // Captura a exceção System.err.println("Matrícula inválida: " + e.getMessage()); } finally { // Esta parte é sempre executada, havendo ou não uma exceção. System.out.println("Executando o finally."); } } } }


Leonhard Euler


Temos também a apresentação do lançamento e captura de exceção em Java.

package br.com.feltex.jse.execao; import javax.swing.JOptionPane; public class MinhaExcecao04 { public static void main(String[] args) { Integer matricula = 0; // Enquanto o valor da matrícula for 0 while (matricula == 0) { try { matricula = Integer.parseInt(JOptionPane.showInputDialog("Digite sua matrícula")); System.out.println("Matrícula digitada: " + matricula); } catch (Exception e) { // Captura a exceção System.err.println("Matrícula inválida: " + e.getMessage()); } finally { // Esta parte é sempre executada, havendo ou não uma exceção. System.out.println("Executando o finally."); } } } }


Leonhard Euler


Inclusão do “|” para informar que há mais de uma exceção no catch.

package br.com.feltex.jse.execao; import java.sql.SQLException; public class MinhaExcecao06 { // Lança uma exceção se a senha estiver errada public static void conectarBanco(String senha) throws SQLException { // Se a senha for diferente de 123456 //é lançada uma exceção // de acesso ao banco de dados if (!senha.equals("123456")) { throw new SQLException("Erro no acesso ao BD"); } } public static void formatarNumero(String numero) throws NumberFormatException { // Se campo número estiver vazio é //lançada uma exeção de número inválido. if (numero.length() == 0) { throw new NumberFormatException("Numero invalido"); } } public static void main(String[] args) { try { conectarBanco("1241"); formatarNumero(""); // A partir do Java 7 é possível gerenciar // mais de uma exceção de hierarquia diferente em um bloco catch. } catch (NumberFormatException | SQLException e) { //Será capiturada a primeira exceção que ocorrer. System.err.println(e.getMessage()); } } }

Dica importante Um try tem sempre que ter pelo menos um catch ou um finally.


Leonhard Euler


Dica importante Podemos utilizar o método printStackTrace da classe exception para verificar onde ocorreu a exceção e qual foi a

ordem de classes e métodos chamados.

Veja o exemplo abaixo:

java.lang.NumberFormatException: For input string: "a" at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65) at java.lang.Integer.parseInt(Integer.java:580) at java.lang.Integer.parseInt(Integer.java:615) at br.com.feltex.jse.execao.MinhaExcecao02B.main(MinhaExcecao02B.java:9)

Exceções mais conhecidas:

IOException – Lançada quando ocorre uma operação falhou ou interrompido. Dois subtipos de

IOException são comuns e EOFException.

FileNotFoundException – Lançada quando é feita uma tentativa de abrir um arquivo que não pode ser

encontrado.

SQLException – Lançada quando há um erro de banco de dados.

InterruptedException – Lançada quando uma thread é interrompida.

NoSuchMethodException – Lançada quando um método chamado não pode ser encontrado.

ArithmeticException – Lançado para indicar que uma condição excepcional aritmética ocorreu.

ArrayIndexOutOfBoundsException – Lançado para indicar que o índice está fora do intervalo.

ClassCastException – Lançado para indicar uma tentativa de converter um objeto para uma subclasse de

que ele não é um pertence a hierarquia.

IllegalArgumentException – Lançado para indicar que um argumento inválido foi passado para um

método.

IllegalStateException – Lançado para indicar que um método tem sido chamado no momento

inadequado.


Leonhard Euler


O que vimos...

Qual é a hierarquia de exceções

Como podemos lançar exceções em nossos métodos.

Diferença entre Checked e Unchecked Exceptions

Algumas das exceções mais conhecidos no Java


Leonhard Euler


7. Mais um pouco de Orientação a Objetos

Metas do capítulo

O que é herança?

Como fazer sobrecarga e sobre-escrita

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, têm 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 PessoaFí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 PessoaFisica extends Pessoa { private String cpf; private String sexo; public String getCpf() { return cpf; } public String getSexo() { return sexo; } public void setCpf(String cpf) { this.cpf = cpf; } public void setSexo(String sexo) { this.sexo = sexo; } @Override public String toString() { return "PessoaFisica [cpf=" + cpf + ", sexo=" + sexo + "]"; } }

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.

Veja o exemplo de como utilizar a

package br.com.feltex.jse.oo.heranca; import java.util.Date; public class PessoaTeste { public static void main(String[] args) { PessoaFisica pessoaFisica = new PessoaFisica(); pessoaFisica.setCodigo(10); pessoaFisica.setNome("Jose da Silva"); pessoaFisica.setCpf("64172574289"); pessoaFisica.setDataCadastro(new Date()); pessoaFisica.setSexo("Masculino"); System.out.println(pessoaFisica); PessoaJuridica pessoaJuridica = new PessoaJuridica(); pessoaJuridica.setCodigo(234); pessoaJuridica.setNome("Feltex"); pessoaJuridica.setCnpj("05251970000180"); pessoaJuridica.setDataCadastro(new Date()); pessoaJuridica.setNomeFantasia("Feltex Web Development"); System.out.println(pessoaJuridica);


Leonhard Euler


} }

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


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, subtraçã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


8.6. Formatação de Número

package br.com.feltex.jse.text; import java.text.DecimalFormat; import java.text.NumberFormat; public class FormatadorNumero { public static void main(String[] args) { NumberFormat formatter; String meuNumero; // 0 --> adicionar um dígito ou 0 se não houver valor formatter = new DecimalFormat("00000"); meuNumero = formatter.format(-1234.567); System.out.println("Numero 1: " + meuNumero); formatter = new DecimalFormat("0000.000"); meuNumero = formatter.format(-1234.567); System.out.println("Numero 2: " + meuNumero); formatter = new DecimalFormat("##"); meuNumero = formatter.format(-1234.567); System.out.println("Numero 3: " + meuNumero); formatter = new DecimalFormat("##00"); meuNumero = formatter.format(0); System.out.println("Numero 4: " + meuNumero); // . --> Separador decimal formatter = new DecimalFormat(",00"); meuNumero = formatter.format(-0.123); System.out.println("Numero 5: " + meuNumero); formatter = new DecimalFormat("0.00"); meuNumero = formatter.format(-0.123); System.out.println("Numero 6: " + meuNumero); formatter = new DecimalFormat("#.#"); meuNumero = formatter.format(-1234.567); System.out.println("Numero 7: " + meuNumero); formatter = new DecimalFormat("#.######"); meuNumero = formatter.format(-1234.567); System.out.println("Numero 8: " + meuNumero); formatter = new DecimalFormat(".######"); meuNumero = formatter.format(-1234.567); System.out.println("Numero 9: " + meuNumero); formatter = new DecimalFormat("#.000000"); meuNumero = formatter.format(-1234.567); System.out.println("Numero 10: " + meuNumero); // , --> Separadores de milhar formatter = new DecimalFormat("#,###,###"); meuNumero = formatter.format(-1234.567); System.out.println("Numero 11: " + meuNumero); meuNumero = formatter.format(-1234567.890); System.out.println("Numero 12: " + meuNumero); // '--> Utilização de símbolos formatter = new DecimalFormat("'#'#");


Louis leithold


meuNumero = formatter.format(-1234.567); System.out.println("Numero 13: " + meuNumero); formatter = new DecimalFormat("'text'#"); meuNumero = formatter.format(-1234.567); System.out.println("Numero 14: " + meuNumero); } }


Robert Hooke

www.feltex.com.br Capítulo 8 – Manipulação de Arquivos

9. Manipulação de Arquivos

Metas do capítulo

aaa

aaaa

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


} }


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 semanalmente 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 bancos de dados no mercado. Acesse os links abaixo e veja mais informações sobre eles:

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

SQL Server: http://www.microsoft.com/

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

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

Assista aos vídeos e configure seu banco de dados preferido

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://www.oracle.com/index.html

http://www.microsoft.com/

http://www.postgresql.org/download

http://dev.mysql.com/downloads

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 , datacadastro DATETIME 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.

Execute o seguinte comando na console SQL:

SET SQL_SAFE_UPDATES = 0;

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 1 Fluxo de um comando SQL

Figura 2 Componentes Java envolvidos em um comando SQL

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

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


RENÉ DESCARTES


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/

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


http://www.feltex.com.br/felix/tutorial-jdbc/

RENÉ DESCARTES


10.3. 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.4. Cadastro de Aluno

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




1. Devemos considerar que as tabelas já foram criadas no banco de dados e focaremos apenas na

codificação Java.

2. Devemos executar o exemplo da apostila que utiliza as funções de consultar, incluir, alterar e excluir um aluno no banco de dados. Comece o exemplo pela classe AlunoCRUD.

3. Crie um método que só listará os registros de alunos que têm o campo e-mail vazio.

4. Crie um método para contar o tal de registro na tabela aluno.

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


RENÉ DESCARTES



Apostila java

Documents

Transcript of Apostila java