O documento resume uma aula sobre pacotes e tratamento de erros em Java. O documento discute como organizar classes em pacotes, importar classes de outros pacotes, criar arquivos JAR, tratar erros e exceções. O documento também discute classes utilitárias como String, wrappers, Date e Calendar.

1. Java Básico
Aula 04
Natanael Fonseca - Arquiteto de Software

2. Ementa
• Pacotes, tratamento de erros;
• Classes utilitárias: String, Wrappers, Date e
Calendar;

3. Pra que servem os pacotes ?
Imagine um projeto com 100 ou mais classes, como organizar isso tudo ? Pois
bem, a linguagem Java oferece uma maneira bem interessante de arrumar o
projeto, separando as classes em diretórios específicos chamados de pacotes.
De fato, a própria API do java está organizada dessa forma, conforme pode
ser visto na JavaDoc API (http://docs.oracle.com/javase/8/docs/api/):
Pacotes, tratamento de erros 3

4. Analisando o arquivo rt.jar
No diretório %JAVA_HOME%jrelibrt.jar é possível encontrar o
jar que contem as classes da API do Java, podemos abrir e
analisa-lo.
Pacotes, tratamento de erros 4

5. Declarando o pacote das classes
A primeira instrução de um arquivo .java é a declaração de
pacote, desta forma podemos declarar o pacote a qual uma
determinada classe pertence usando a palavra reservada
package.
Exemplo:
******************************
package br.com.treinamento;
public class Pessoa{
//Codigo da classe
}
Pacotes, tratamento de erros 5
Incluir a classe no diretório br/com/treinamento

6. Convenção
Convenciona-se declarar o nome de pacotes utilizando uma URL
invertida: normalmente a URL do “proprietario” da classe como,
por exemplo, o site comercial da empresa.
Exemplo:
Se o site da empresa for:
www.tabajara.com.br
O pacote deve ser:
br.com.tabajara
Pacotes, tratamento de erros 6

7. Compilando classes que estão em
pacotes
Apesar de no código fonte nos referirmos ao pacote utilizando
ponto, na hora de compilar devemos seguir o padrão do sistema
operacional.
Exemplo (Windows):
c:java> javac brcomtreinamentoPessoa.java
E para executar a classe:
c:java> java br.com.treinamento.Pessoa
Pacotes, tratamento de erros 7

8. Utilizando classes de outro pacote
Uma classe não tem automaticamente acesso a classes de outros
pacotes. Para utilizar uma classe que esta em outro pacote e,
consequentemente, em outro diretório há duas opções:
1- Utilizar o nome completo da classe (fully qualified name), que inclui
também o nome do pacote (Ex: br.com.treinamento.Exemplo)
2- importar a classe através da instrução import. Desta forma, não é
necessário utilizar o nome completo da classe no código.
Exemplo:
import java.útil.ArrayList;
Pacotes, tratamento de erros 8

9. Dicas
• Para melhorar a legibilidade do código, é conveniente declarar
explicitamente o import individual das classes;
• Caso seu código necessite utilizar duas classes com mesmo
nome mas pacotes diferentes, você precisará referenciar as
classes utilizando seu nome totalmente qualificado.
• Além das classes do próprio pacote, as únicas classes que
podem ser utilizadas diretamente no código sem a
necessidade de importação são aquelas do pacote java.lang.
Neste pacote estão as classes consideradas fundamentais da
linguagem, como a classe System e String, entre outras.
Pacotes, tratamento de erros 9

10. Importação estática
Até antes do Java 5, quando o programador queria acessar um
atributo estativo de uma classe, ele era obrigado a incluir o
nome da classe antes do atributo estático. Ex: Pessoa.STATUS.
Mas a partir do Java 5 foi incluído o suporte a importação de
elementos estáticos de uma classe, melhorando a legibilidade do
código fonte.
Sintaxe para importação estática
Import static nomeCompletoDaClasse.nomeMembro
ou
Import static nomeCompletoDaClasse.*;
Pacotes, tratamento de erros 10

11. Java Archive
O software desenvolvido em Java pode ser um aplicativo ou uma biblioteca
utilitária, que deve ser instalado ou distribuído para ser utilizado em outros
computadores. Existe um padrão de empacotamento das classes em um
único arquivo chamado JAR (Java Archive).
Existe um utilitário do próprio JDK chamado jar que facilita a criação destes
arquivos.
Comando para criar um jar simples:
jar –cvf nomeDoJar.jar raizDoPacote
Onde as opções cvf significam create, verbose e file, respectivamente.
vale lembrar que o arquivo jar possui o mesmo formato de um arquivo zip
qualquer, portanto, podemos abrir este tipo de arquivo no winrar, 7zip ou
quaisquer outros utilitários que trabalhem com o formato zip.
Pacotes, tratamento de erros 11

12. Criação de um Jar executavel
Para criar um JAR executável é necessário indicar no arquivo
MANIFEST.MF o nome da classe, cujo método main, deverá ser
executado em decorrência da chamada ao JAR.
Exemplo:
******************************
Manifest-Version: 1.0
Created-By: Criador do Arquivo
Main-Class: Nome totalmente qualificado da classe que queremos executar.
******************************
Pacotes, tratamento de erros 12

13. Executando um Arquivo Jar
Para executar um arquivo JAR usa-se o utilitário java, passando –jar como
argumento, assim como nome do arquivo que se quer executar.
Sintaxe
java –jar nomeJar.jar
E caso o arquivo jar possua como dependências outras bibliotecas devemos
informar no classpath os jars necessários para a execução.
Exemplo:
java –classpath commons-logging.jar –jar meujarexecutavel.jar
Pacotes, tratamento de erros 13

14. Tratamento de Erros
Característica fundamental para sistemas de software, porque é praticamente
impossível criar uma aplicação totalmente livre de erros.
Erros não são necessariamente causados por falhas no desenvolvimento.
Alguns exemplos:
• Um servidor de banco de dados pode estar fora do ar;
• Um arquivo de configuração pode ter sido removido acidentalmente;
• O usuário pode ter digitado um valor não aceitável.
Importante dar atenção ao tratamento de erros em aplicações. Por isso, é
importante reforçar aqui a necessidade do planejamento no tratamento de
erros.
Pacotes, tratamento de erros 14

15. Exceções
Uma exceção é a indicação de que algum problema ocorreu durante a
execução do programa. Chama-se de tratamento de exceções ou tratamento
de erros o mecanismo de sinalização de erros na plataforma Java.
Java define um conjunto de classes que representam erros. O pacote java.io,
por exemplo, possui uma família de classes de exceção derivadas de
IOException e o pacote java.sql contém uma família derivada de
SQLException.
Através da extensibilidade oferecida pela linguagem é possível criar tipos
próprios de exceções e para isso basta estender a classe java.lang.Exception.
Pacotes, tratamento de erros 15

16. Hierarquia
Existe uma super classe de Exception denominada Throwable que, como diz o
próprio nome, representa algo que pode ser lançado, interrompendo a
exceção de um método.
Error – representa condições anormais
Graves e geralmente irrecuperáveis;
Runtime Exception – representa erros
do próprio programador (unchecked).
Exception – representa erros que fogem
ao controle do programador (checked).
Pacotes, tratamento de erros 16

17. Tratamento de Exceções
Ao estudar a linguagem no que tange os aspectos de tratamento de exceções é
importante entender : como criar, como lançar e por último como trata-las.
1) Criando exceptions:
 Estendendo a classe Exception;
Class MyException extends Exception{}
 Instanciando a classe criada;
MyException ex = new MyException();
2) Lançando exceptions:
 Indicando que o método irá lançar a exception
public void metodoQueLancaException() throws Exception{}
 Utilizando a instrução throw
throw ex;
3) Tratando exceptions:
 Utiliza-se a instrução try-catch
Try{
obj.metodoquelancaexception();
}catch( MyException ex){
//codigo que faz alguma coisa.
}
Pacotes, tratamento de erros 17

18. Métodos uteis da classe throwable
A classe throwable define alguns métodos herdados pela classe Exception,
que são uteis no tratamento de exceções.
Método printStackTrace()
Fornece uma visão detalhada do erro, indicando qual o o método que
originou a exceção, assim como, cada um dos métodos que a chamaram,
além de mostrar a localização da linha responsável pelo lançamento da
exceção. Essa informação é impressa no console, chamada de stack trace.
Método getMessage()
Recupera a mensagem da exceção que é definida no momento da construção
da Exception, utilizando o construtor que recebe uma String como parâmetro.
Pacotes, tratamento de erros 18

19. Instrução Finally
Usualmente, este bloco é utilizado para códigos clean-up. Operações como
fechar um arquivo ou uma conexão com o servidor são exemplos de
operações de clean-up.
Sintaxe :
try{
//instruções que podem gerar/lançar exceções
}catch(TipoException e){
//codigo que devera ser executado caso uma excecao seja lancada
}finally{
//liberação de recursos, log, etc.
}
O bloco finally é sempre executado !
Pacotes, tratamento de erros 19

20. Capturando múltiplas exceções
Em muitos casos cada tipo de erro terá um tratamento diferente. Para conseguir este
tratamento diferenciado são utilizadas diversas instruções catch, uma para cada exceção.
Sintaxe para captura de múltiplas exceções
try{
//instruções que podem gerar/lançar exceptions
}catch(TipoDaExcecao1 e){
//logs, codigo
}catch(TipoDaExcecao2 e){
//logs, codigo
}finally{
//liberação de recursos, log, etc....
}
 Não é permitido colocar instruções catch para checked expcetions que não tem
possibilidade de serem lançadas, ou seja, não foram declaradas por nenhum método;
 Declaram-se primeiramente as exceções mais especificas, isto é, as classes filhas e,
depois, as mais genericas.
20Pacotes, tratamento de erros

21. Exercício
Crie um pacote chamado br.com.<<seunome>>
e inclua uma classe chamada Principal com
método main que ao ser executado, exibe por
meio de um JOptionpane uma mensagem de
boas vindas. Tente criar um Jar executável do
programa criado, por meio de um pen drive,
passe o jar para o colega ao lado para que ele
teste o seu programa.
21Pacotes, tratamento de erros

22. Wrapper Classes
Foram projetadas para encapsular valores de tipo primitivo
dentro de suas instancias. Existe uma wrapper class para cada
tipo primitivo, conforme podemos ver na tabela a seguir:
22
Classes utilitárias: String, Wrappers, Date e
Calendar
Tipo Primitivo Wrapper Class
boolean java.lang.Boolean
char java.lang.Character
byte java.lang.Byte
short java.lang.Short
int java.lang.Integer
long java.lang.Long
float java.lang.Float
double java.lang.Double

23. Características comuns as
Wrapper Classes
Todas as wrapper classes que representam tipos primitivos
numéricos são sub-classes de java.lang.Number.
Todas as wrapper classes tem um construtor que recebe como
parâmetro um valor do tipo primitivo correspondente.
Exemplo:
Double d = new Double(10.8);
Integer i = new Integer(20);
Float f = new Float(4.2F);
23
Classes utilitárias: String, Wrappers, Date e
Calendar

24. Classe Date
Classe utilizada para representar o tempo, que é
composto por ano, mês, dia atual, minuto, entre
outras propriedades.
Hoje a maioria dos métodos da classe Date
estão classificados como deprecated, ou seja,
são métodos que não são mais utilizados, por
isso essa classe foi substituída pela classe
Calendar, para haver suporte correto a
internacionalização do sistema de datas.
24
Classes utilitárias: String, Wrappers, Date e
Calendar

25. Testando a Classe Date
import java.util.Date;
public class TestDate{
public static void main(String[] args){
Date data = new Date();
Sytem.out.println(“Data agora:” + data );
}
}
25
Classes utilitárias: String, Wrappers, Date e
Calendar

26. Classe Calendar
Classe mais completa e pode produzir valores de
todos os campos de calendário necessários para
implementar a formatação de data e hora, para
uma determinada língua e estilo de calendário.
Por exemplo, japonês, americano, italiano,
brasileiro entre outros.
Por ser uma classe abstrata, para obter um
calendário é necessário chamar o método
estático getInstance().
26
Classes utilitárias: String, Wrappers, Date e
Calendar

27. Testando a Classe Calendar
import java.util.Calendar;
public class TestCalendar{
public static void main(String[] args){
Calendar c = Calendar.getInstance();
System.out.println(“Data e hora atual” + c.getTime());
}
}
27
Classes utilitárias: String, Wrappers, Date e
Calendar

28. Classe DateFormat
Permite converter informações do tipo String
para data do tipo Date, permitindo seguir um
formato. Consegue-se trabalhar ao contrário,
convertendo um dado do tipo Date para uma
String.
Como acontece com Calendar, está classe
também é abstrata, ou seja, para obter uma
instancia dela o programador deve chamar o
método estático getDateInstance().
28
Classes utilitárias: String, Wrappers, Date e
Calendar

29. Utilizando DateFormat
import java.util.Calendar;
import java.util.DateFormat;
Import java.util.Date;
public class TestDateFormat{
public static void main(String[] args){
Calendar c = Calendar.getInstance();
Date data = c.getTime();
DateFormat formataData = DateFormat.getDateInstance();
System.out.println( formataData.format( data ) );
}
} 29
Classes utilitárias: String, Wrappers, Date e
Calendar

30. Fim da Quarta Aula
Obrigado.