Java Introdução

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

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

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/

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

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

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 (==, <, >, <=, >=, !=, !) Operador Descrição Exemplo Resultado = Atribuição de um valor X = 5 5 == Comparação de valores 5 == 5 true > Relação de superioridade 6 > 5 true < Relação de inferioridade 2 < 5 true >= Relação de superioridade ou igualdade 6 >= 5 true <= Relação de inferioridade 10 <= 5 false != Relação de diferenças 6 != 5 true
 Booleanos Operador Descrição Exemplo Resultado || Verifica se um dos operandos é verdadeiro true || true true && Verifica se TODOS operandos são verdadeiro true && true true ! Nega o valor da variável booleana !true false
• ou (||): Operador que resulta VERDADEIRO quando um dos seus operandos lógicos for verdadeiro.
• e (&&): Operador que resulta VERDADEIRO somente se seus dois operandos lógicos forem verdadeiros.
• não (!): Operador unário de negação.
não VERDADEIRO = FALSO
não FALSO = VERDADEIRO

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.
Exercícios
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”.
A A
A A
A A
A A
A A
A A
A A
2. Crie um programa que desenhe na console um novo retângulo com a primeira e última letra do seu nome. Sendo que as bases (linhas superior e inferior) use a primeira letra. Para as laterais use a última letra. Se as letras forem iguais mude uma delas a seu critério!
O que vimos...
 Neste ponto já devemos saber o que é um “if” e quando utilizamos um “else”.
 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;
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;
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.
Exercícios
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

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

Java Introdução

Recomendados

Recomendados

Más contenido relacionado

Similar a Java Introdução

Similar a Java Introdução (20)

Java Introdução