Java Fundamentals

A tecnologia Java e
configuração do ambiente
 O que é Java?
Java é uma especificação bem definida de uma Linguagem de
Programação Orientada a Objetos, desenvolvida pela Sun
Microsystems.

Usa-se, ainda, o nome “Java” para identificar:

– Ambientes de execução de software, presentes em SO, Browsers,
celulares, PDA, cartões inteligentes e eletrodomésticos.

– Uma coleção de classes, componentes e frameworks (APIs) para o

desenvolvimento de aplicações multiplataforma.

– O conjunto de ferramentas que permite o desenvolvimento de

aplicativos Java (JDK – Java Development Kit)

Em teoria, Java não é um software: é a especificação da linguagem.

 O que é a Plataforma Java?

Plataforma é um ambiente de software e/ou hardware

onde os programas são executados.

Plataforma Java
– JVM (Java Virtual Machine)
– Java API
 Por que usar Java?
Por ser um ambiente de desenvolvimento OO
– OO é o paradigma mais forte atualmente
– Java é uma linguagem que atende os requisitos OO

Pela portabilidade do código produzido

– Programe em Windows e execute no Linux
– Sem necessidade de recompilar

Pelas características de segurança

– Web: applets não acessam os arquivos do sistema
– Desktop: sem endereçamento direto de memória
 Por que usar Java?
Pela facilidade de integração a outros ambientes
– Java nasceu junto com a Internet
– API para integração com sistemas legados

Linguagem e ferramentas em constante aperfeiçoamento

– Rumos da linguagem ditados pela comunidade Java
– JCP – Java Community Process

JDK é Free Software, assim como diversas ferramentas

– Java pode ser usada sem nenhum custo
– Diversas ferramentas disponíveis gratuitamente
 Como começou?

Em 1991 foi lançado o Green Project pela Sun

Microsystems.

A linguagem inicialmente sugerida foi o C++.

Surge Oak: nome pelo qual Java foi chamado na época.

 Como começou?

Em 1992 o projeto Green lança um pequeno dispositivo

portátil, um controle remoto extremamente inteligente.

Dotado de uma pequena tela, o usuário interagia com os

eletrodomésticos através de uma representação
animada de uma casa.

Foi chamado Star-7.

 Como começou?

Java foi apresentada formalmente pela Sun no

SunWorld’95 com o navegador HotJava.

Em setembro/1995, a Netscape Corp. lança a versão 2.0

de seu browser também capaz de efetuar o download e
a execução de pequenas aplicações Java, então
denominadas applets.

Assim se iniciou a história

de sucesso do Java.
São programas escritos em Java que
podem ser adicionados em documentos
hipertexto. Suportam efeitos de
multimídia como sons, interações com o
usuário (mouse, teclado), imagens,
animações, gráficos.
 Evolução da tecnologia Java

1995 (mai) : Lançamento da tecnologia

1997 (fev) : Lançado o JDK 1.1
1997 (mar) : Tecnologia servlet lançada
1998 (dez) : Lançado Java 2 e JDK 1.2
1999 (jun) : Tecnologia JSP lançada
1999 (out) : Celulares baseados em Java
1999 (dez) : Disponibilizada Plataforma J2EE
2000 (mai) : Lançado o J2SE 1.3
2001 (set) : Lançado o J2EE 1.3
2002 (mai) : Lançado o J2SE 1.4
2003 (nov) : Lançado o J2EE 1.4
2004 (out) : Lançado o J2SE 5.0 (Tiger)
2006 (metade do ano) : Java SE 6.0 (Mustang)
 Utilização de Java no Brasil
Banco do Brasil: desenvolve aplicativos e serviços web
com tecnologia J2EE para ambiente corporativo.
http://www.bb.com.br

Globo.com
http://www.globo.com

BrasilTelecom
http://brasiltelecom.com.br

Telemig:
– Controla em torno de 1 milhão de celulares com tecnologia
Java
 Utilização de Java no Mundo
BankBoston
– Todo Internet Banking feito em Java

Nasa
– Telescópio Hubble e sonda espacial Pathfinder.

Nokia
– Não só nos aparelhos, mas nos servidores da empresa.

American Express, Visa

– Utilizam a tecnologia JavaCard.
 O que é aprender Java?

Conhecer a sintaxe da linguagem Java

– Tipos, controles, estruturas condicionais.

Aprender as APIs, suas classes e seus métodos

– java.lang; java.io; java.util; java.sql; javax.swing.

Conhecer a teoria da Orientação a Objeto

– Classes, Objetos, Métodos, Atributos, Herança.

Dominar Ferramentas e Tecnologias auxiliares

– IDEs, UML, XML, Design Patterns.
 Algumas características
Case-sensitive:
– Em java maiúsculas de minúsculas são diferentes.

Não existem variáveis globais ou funções independentes:

– Toda variável ou método pertence a uma classe ou objeto.

Arquivo fonte tem extensão .java

Classe compilada tem extensão .class

Classes podem ser agrupadas em arquivos .jar

 JVM (Java Virtual Machine)

JVM é responsável pela execução do byte-code,

independente de plataforma.
JVM (Java Virtual Machine)
Execução em Java
 Garbage Collector
Thread de baixa prioridade que libera da memória
automaticamente objetos não mais referenciados no
escopo do programa.

Vantagem direta: libera o programador da

responsabilidade de destruir objetos criados.

Reside na JVM. Em próximas versões, espera-se que seja

possível escolher qual algoritmo de coletor de lixo
utilizar durante a execução de um programa.
 Distribuições Java

Java 2 Standard Edition - J2SE

– APIs essenciais para qualquer aplicação java
• Core Java, Desktop Java

Java 2 Enterprise Edition - J2EE

– APIs para o desenvolvimento de aplicações
distribuídas
• JSP (Java Server Page),
• EJB (Enterprise Java Beans)

Java 2 Micro Edition - J2ME

– APIs para o desenvolvimento de aplicações p/
portáteis
• PDA (Personal Digital Assistant), PalmTop, Celulares
Aplicação feita em J2SE
Aplicação feita em J2EE
Aplicação feita em J2ME
 Como começar com Java

Instalar JDK.
– Download em http://java.sun.com

JDK - não é ambiente visual (IDE), é um conjunto de

ferramentas para desenvolvimento Java.

Composto por:
– javac.exe – Compilador Java
– java.exe – Máquina virtual Java (JVM)
– jre.exe – Java Runtime Environment
– appletviewer.exe – Visualizador de Applets
– javadoc.exe - Composição de documentação
– jdb.exe – Depurador de programas
 JDK – Instalação

Variáveis de ambiente:
– JAVA_HOME = c:\Arquivos de
programas\Java\jdk1.5.0_06

– CLASSPATH = %JAVA_HOME%\jre\lib\rt.jar;.

– PATH = %JAVA_HOME%\bin

Teste:
– Digite no prompt: java
– Digite no prompt: javac
O ponto é muito importante,
pois indica ao JDK que o
diretório atual também faz
parte do classpath.
 SwingSet2
Software demonstrativo que permite verificar
funcionalidades de Java, como Interface Gráfica,
Multithread e Look and Feel.

SwingSet2.jar
 2

Tipos e Operadores
 Objetivos

• Compreender Constantes, Variáveis e Literais

• Compreender os tipos de dados primitivos:

– char, boolean, byte, short, int, long, float e double

• Compreender os tipos de dados referência.

• Apreender conversões de tipos

– casting
 Declaração de Variáveis
• Variáveis em Java são os atributos dos objetos ou da
classe.

• Regras:
– Podem iniciar com letra, “_” ou $
– Não podem ter espaços em branco
– Não pode ser palavra-chave
– Primeiro identifica-se o tipo; depois o nome.

• Exemplo:
int idade;
String nome;
 Tipos Primitivos
Não são objetos e tem acesso mais rápido.
• Tipos inteiros:
byte: 8 bits [-128 a 127]
short: 16 bits [-32.768 a 32.767]
int: 32 bits [-2.147.483.648 a 2.147.483.647]
long: 64 bits [-9.224.372.036.854.775.808 a 9.224.372.036.854.775.807]

• Tipos de ponto flutuante: Tipo Lógico:

float: 32 bits boolean: true / false
double: 64 bits

• Tipo caracter: void:

char: 16 bits (UNICODE) [32.768] Ausência de valor.
Tipos Primitivos
 Tipo char

• O tipo char representa caracteres Unicode:

www.unicode.org

• Um caractere em Java sempre vem entre aspas simples.

– Exemplo: ‘c’

• Você pode utilizar qualquer caractere Unicode como um

literal caractere. Para isso é necessário o emprego de
seqüências de escape.
– Exemplo: ‘\uxxxx’
Exemplos char
Seqüências de Escape
 Tipo boolean

• Há somente dois valores possíveis para este tipo: true e

false

• O valor booleano não é um tipo inteiro, onde false é

representado por 0 e true por qualquer valor diferente de 0.
 Tipos Inteiros
byte, short, int e long

• Os tipos inteiros diferem exclusivamente no número de bits

usados e, portanto, na extensão da faixa de números que
conseguem representar.

• Qualquer literal inteiro pode ser precedido por um operador

unário menos, a fim de indicar um número negativo.
– Exemplo: -12
 Notação Octal e Hexadecimal

• Um literal que começa com 0x ou 0X é interpretado como

um número Hexadecimal (de 0 a f).

• Literais inteiros que têm um dígito 0 em seu início são

interpretados como números Octais.

• Java não permite que literais inteiros sejam expressos em

notação binária (base 2).
Exemplos de Inteiros
 Aritmética com Inteiros

• Exemplo de expressão byte com aritmética circular.

 Tipos de Ponto Flutuante
float e double
• Números reais são representados em Java com os tipos float e
double.

• O tipo float representa um valor de ponto flutuante, de 32 bits.

• O tipo double representa um valor de ponto flutuante de 64

bits.

• Literais de ponto flutuante também podem ser representados

através de notação científica.
Exemplos de Ponto Flutuante
 Literais

• Constantes para cada um dos tipos primitivos de uma

linguagem

• Como devem ser escritos os tipos primitivos da linguagem:

 Conversões de tipos - casting

 Conversão de tipos implica em Ampliação/Redução de

representação.

 Redução:
– Conversão implícitas entre tipos primitivos do menor para o maior.
Ex: de int para short

 Ampliação
– Conversão explícita entre tipos primitivos do maior para o menor.
Ex: de short para long

 Boolean não pode ser convertido.

Conversões de Tipos
 Tipo Referência

Além dos oito tipos primitivos, Java define duas outras

categorias de tipos: Classes e Vetores.
 Tipo Referência
Todos os objetos Java são do tipo referência.

java.lang.Object obj
java.lang.String string
java.lang.Integer integer
java.lang.Double double
javax.swing.JButton button
javax.swing.JFrame frame
Pessoa pessoa
Endereco[] endereco
 Tipo Referência

Código Java Referências Conteúdo da Memória RAM

-----------------------------------------------------------------------
Pessoa p; p  null
p = new Pessoa(); p  @123456 @123456  Cod: 0 Nome: null
p.setCodigo(12); p  @123456 @123456  Cod: 12 Nome: null
p.setNome(“Diego”); p  @123456 @123456  Cod: 12 Nome: “Diego”
p = null; p  null @123456  [Liberado pelo GC]
p = new Pessoa(); p  @345678 @345678  Cod: 0 Nome: null
p.setCodigo(13); p  @345678 @345678  Cod: 13 Nome: null
p.setNome(“Fulano”); p  @345678 @345678  Cod: 13 Nome: “Fulano”
Pessoa p2 = null; p2  null
p2 = p; p2  @345678 @345678  Cod: 13 Nome: “Fulano”
p2.seCodigo(19); p2  @345678 @345678  Cod: 19 Nome: “Fulano”
-----------------------------------------------------------------------
 Tipo referência
String

• String não é tipo primitivo

• Pode conter seqüências de escapes.

Operadores
 Sumário de Operadores

• Ver tabela página: 2-22

 Expressões
Estruturas para determinação de um valor.
 Precedência

• Compatível com C

• Podemos alterar as precedências com o uso de parênteses

 Associatividade

Quando uma expressão contém vários operadores que têm a mesma

precedência.

A associatividade dos operadores indica a ordem na qual as operações

serão executadas.

int a = 5;
int b = 4;
int c = a++ + b++;
--------------------------------------------
a = 6
b = 5
c = 9
 3

Criando Classes e Objetos

 Objetivos
• Definir classes e criar objetos

• Trabalhar com pacotes

• Conhecer os padrões para codificação

• Aplicar visibilidade a classes, atributos e operações

• Comentar os códigos fonte

• Gerar documentação do código fonte

• Estudar o escopo das variáveis

 Padrões
Nomes de arquivos
– Extensão de código-fonte deve ser .java
– Classe compilada tem extensão .class

Nomes de classes
– Nome significativo, com a inicial maiúscula.

Nomes de métodos
– setX(), getX()

Nomes de atributos/variáveis Case-sensitive:

– Minúsculo Java diferencia
maiúsculas e
Nomes de constantes minúsculas:
– Todas as letras MAIÚCULAS
“Pessoa” e “pessoa”
são diferentes.
Nomes de pacotes
– Não podem usar o caractere “_”
 Criando uma classe

class Produto {

}
 Criando uma classe
Hello World
class HelloWorld {

public static void main(String args[]) {

System.out.println(“Hello World.”);
}

C:\javac HelloWorld.java
C:\java HelloWorld
 Pacotes
• Permite agrupar classes.
• Pacotes em Java são diretórios do SO.
• Separados por “.”
 Pacotes - Exemplo
package com.targettrust.java;

class HelloWorld {
public static void main(String args[]) {
System.out.println(“Hello World.”);
}
}

C:\javac –d . HelloWorld.java
C:\java HelloWorld
 Criando uma classe
Visibilidades
package / default

Exemplo:
class Pessoa {

A classe só poderá ser utilizada por outras

classes que estiverem no mesmo package.
 Criando uma classe
Visibilidades
public

Exemplo:
public class Pessoa {

A classe poderá ser utilizada por qualquer

outras classes independente do package.

Cada .java poderá ter somente uma classe

public
 Criando Objetos
Produto prod = null;
prod = new Produto();

OU

Produto prod = new Produto();

-----------------------------------------

null: objeto sem referência.

new: objeto com referência
 Operações / Métodos

public class Pessoa {

public void calcularIdade(int ano) {
// código do método
}
}

Uma operação ou método é a parte do código java capaz

de executar ações.

Semelhante a procedure e function em outras linguagens.

 Operações / Métodos
Visibilidades
public
Os métodos public poderão ser chamados por outros
objetos.

package
Os métodos default poderão ser chamados apenas por
objetos de classes no mesmo package da classe.

protected
Usada em herança de classes. Permite que classes-
filhas acessem ou modifiquem métodos na classe-pai.

private
Os métodos private somente poderão ser acessados
internamente pela própria classe.
 Operações / Métodos
Tipo de retorno, assinatura e parâmetros do método

public void calcularIdade(int ano) {

idade = ano – anoNascimento;
}

String getNome() {
return nome;
}

protected void verificarSenha(String senhaDigitada) {

// código para verificar a senha do usuário...
}

private double calcularSalario(double horasExtras) {

return salarioBase + valorHora * horasExtras;
}
 Operações / Métodos
return

public class Produto {

public String getDescricao() {

String s = “Nome: “ + nome + “ Preço: R$ “ + preco;
return s;
}

public void setNome(String n) {

nome = n;
return;
}
}
 Atributos

public class Produto {

String descricao;
float preco;
boolean emVenda = true;

Atributo inicializado com

valor default
 Atributos
Visibilidades
private
Os atributos private somente poderão ser modificados
internamente pela própria classe (encapsulamento).

package
Os atributos default poderão ser modificados apenas
por objetos de classes no mesmo package da classe.

protected
Usada em herança de classes. Permite que classes-
filhas acessem ou modifiquem atributos na classe-pai.

public
Os atributos public poderão ser acessados por outros
objetos (quebra do encapsulamento).
 Atributos
Escopo

Escopo de classe
Escopo de Método
Escopo de bloco

public class Produto {

private float preco;
public float getPreco() {
if (x < 10) {
int y = 15;
}
}
}
 Comentários
Permitem descrever o código-fonte

Exemplos:
// comentário de uma linha

/* comentário de
múltiplas linhas. */

/** comentário de documentação.

@param
@return
*/
 Classe
Exemplo completo

/** Classe que define a estrutura para o conceito Produto. */

public class Produto {

private int codigo;

private String descricao;
private float preco;

public void setCodigo(int c) { codigo = c; }

public int getCodigo() { return codigo; }

public void setDescricao(String d) { descricao = d; }

public String getDescricao() { return descricao; }

public void setPreco(float p) { preco = p; }

public float getPreco() { return preco; }
}
 Atributos
Passagem de parâmetros
Tipos primitivos:

int preco = 100;

obj.calcular(preco);
System.out.println(preco); ======= 100

public void calcular(int p) {

p = 50;
System.out.println(p); ======= 50
}
 Atributos
Passagem de parâmetros
Tipo referência:

Produto p = new Produto(“CD”);

alterarNome(p);
System.out.println(p.getNome()); ===== “DVD”

public void alterarNome(Produto p) {

p.setNome(“DVD”);
System.out.println(p.getNome()); === “DVD”
}
Exercícios
 4

Comandos da Linguagem
 Objetivos
Conhecer os comandos da linguagem Java:

Comandos de decisão:
– If-else
– Operador ternário
– Switch

Comandos de repetição:
– while
– do-while
– for
– for-each

Comandos de desvio:
– break
– continue
Classe para Testes
Comandos de Decisão

if-else
 Comandos de Decisão

(expressão lógica) ? (true) : (false)

Comandos de Decisão

switch
Comandos de Repetição

while
Comandos de Repetição

do-while
Comandos de Repetição

for
Comandos de Repetição

for-each
 Comandos de Desvio
Usados junto com a estrutura de repetição.
– break: finaliza o laço da repetição.

for (int i=0; i < 10; i++) {

System.out.println(i);
if (i == 5)
break;
}

// Irá imprimir até i=5.

– continue: continua na próxima iteração do laço.

for (int i=0; i < 10; i++) {
if (i == 5)
continue;
System.out.println(i);
}

// Não irá imprimir quando i=5.

Exercícios
 5

Aprofundando o estudo
sobre Classes
 Objetivos
Overloading

Overriding

Referência this

Método finalize

Operações da Classe e Objeto

Herança

Polimorfismo

Modificador final

Enumarations
 Overloading de método
Permite definir métodos com nomes iguais desde que possuam
parâmetros diferentes

Parâmetros diferentes
• Tipo do parâmetro diferente
• Número de parâmetros

public class BuscarCliente {

public Cliente[] getClientes(String nome) {
...
}
public Cliente[] getClientes(int sexo) {
...
}
public Cliente[] getClientes(int idade, String sexo) {
...
}
}
Overloading de método construtor

Método construtor é um método especial que sempre possui o mesmo nome da

classe, porém sem retorno.

Chamado quando o objeto está sendo criado.

Uma classe pode ter n métodos construtores.

public class Produto {

public Produto() {
...
}
public Produto(int codigo, String nome) {
...
}
public Produto(int codigo, String nome, String tipo) {
...
}
}
 Referência this
Referência this representa o objeto atual.

Todo objeto possui a referência this.

Usado também para passar o objeto atual como parâmetro para outro
método.

public class Produto {

private String nome;

public void setNome(String nome) {

nome = nome; // ERRADO
this.nome = nome; // CERTO
}
}
 Método destrutor – finalize()
Método chamado somente quando Garbage Collector for acionado.

Permite liberar recursos como arquivos, fechar conexões de banco de

dados ou rede.

Não é possível prever quando será chamado.

public class Produto {

public void finalize() {

System.out.println(“Liberado pelo Garbage Collector.”);
}
}
Variáveis e métodos de instância

Instância significa Objeto.

Variáveis de instância são mais conhecidas como atributos.

Cada objeto possui o seu valor específico.

 Variáveis e métodos de classe

Usam a palavra-chave static

Todos os objetos da classes podem acessar.

Possui um único valor para todos os objetos da classe.

Pág 5-18
 Bloco static
Usado para iniciar uma classe.

public class Carro {

static {
System.out.println(“Carregando a classe carro.”);
}

private String nome;

public Carro(String nome) { this.nome = nome; }
public String getNome() { return nome; }

public static void main(String args[]) {

Carro p = new Carro(“PALIO”);
Carro c = new Carro(“CORSA”);
Carro g = new Carro(“GOLF”);
}
}
 Herança
Permite reutilizar código de uma classe.

Somente utilize quando responder: “é um tipo de”

Palavra-chave: extends

Todas as classes herdam implicitamente de Object.

Java não permite herança múltipla

public class PessoaFisica extends Pessoa {

...
}
 Herança - overriding
Técnica usada para reescrever um método herdado da classe-pai.

public class Produto {

public double getPreco() {

return 10.0;
}

public class DVD extends Produto {

public double getPreco() {

return 5.0;
}

}
 Herança – super()
Referência usada para chamar métodos da classe-pai.

public class Produto {

public Produto() {
preco = 10.0;
}
}

public class DVD extends Produto {

public DVD() {
super();
Método construtor
genero = “Filmes de ação”;
}

}
 Herança – super()
Referência usada para chamar métodos da classe-pai.

public class Produto {

public double getPreco() {

return 10.0;
}

public class DVD extends Produto {

public double getPreco() { Outros métodos

super.getPreco();
}

}
 Varargs
Permite definir um método com um número variável de parâmetros.
 Modificador final

Em Atributos:
- Define uma constante
public final float PRECO_MAXIMO = 100.0;

Em Métodos:
- Define que o método não poderá ser sobreescrito por classes-filhas
public final void getSenha() { … }

Em classes:
- Define que a classe não pode ser herdada por outras classes.
public final class String {
...
}
 Enums
Estrutura que permite definir domínios conhecidos.
 6

Collections, Arrays,
StringBuffer e Wrappers
 Objetivos

Estudar a API collection

Utilizar arrays

Compreender o mecanismo de autoboxing

Utilizar generics
 Arrays
Coleção de variáveis do mesmo tipo.

Comprimento fixo.

Um array é um objeto.
public class ArrayTest {

public static void main(String[] args) {

String[] nomes = new String[5];
nomes[0] = “Fernando”;
nomes[1] = “Maiki”;
nomes[2] = “Jardel”;
nomes[3] = “Carine”;

for (int i=0; i<nomes.length; i++) {

System.out.println(nomes[i]);
}
}
 Arrays multidimensionais
public class ArrayTest2 {

public static void main(String[] args) {

int nomes = 3;
int times = 2;
String[][] pessoas = new String[nomes][times];
pessoas[0][0] = “João”;
pessoas[0][1] = “Grêmio”;
pessoas[1][0] = “Jorge”;
pessoas[1][1] = “Inter”;
pessoas[2][0] = “Mario”;
pessoas[2][1] = “Grêmio”;

for (int i=0; i<nomes; i++) {

for (int j=0; j<times; j++) {
System.out.print(pessoas[i][j] + “ “);
}
System.out.println(“”);
}
}
 API Collection
• É um framework.

• Classes no package java.util

• Classes:
– Map, Set, List, Tree, ArrayList, HashTable, etc.

Principais Métodos

boolean add(Object element);

boolean remove(Object element);
void clear();
int size();
boolean isEmpty();
Object[] toArray();
 ArrayList e Iterator
ArrayList:
• Classe mais usada da API collection.

Iterator:
• Objeto utilizado para percorrer collections.
import java.util.*;

public class IteratorTest {

public static void main(String args[]) {

ArrayList list = new ArrayList();
list.add(“Diego”);
list.add(“Pedro”);
Iterator it = list.iterator();
while (it.hasNext()) {
String s = (String)it.next();
}
}
}
 Hashtable
Armazena valores baseado em chaves.

Uma das mais rápidas estruturas para pesquisar dados.

import java.util.*;

public class HashtableTest {

public static void main(String args[]) {

Hashtable t = new Hashtable();
t.put(new Integer(1), “Diego”);
t.put(new Integer(2), “Pedro”);
t.put(new Integer(3), “João”);

System.out.println(t.get(new Integer(3));
}
}
 Generics
Introduzida no Java 5.0.

Permite parametrizar tipos.

import java.util.*;

public class GenericsTest {

public static void main(String args[]) {

ArrayList<Aluno> alunos = new ArrayList<Aluno>();
alunos.add(new Aluno(“Diego”));
alunos.add(new Aluno(“Pedro”));
alunos.add(new Aluno(“João”));

Aluno x = alunos.get(1);
System.out.println(x.getNome());
}
}
 Autoboxing
Conversão automática de tipos.

Ocorre entre tipos primitivos e suas classes Wrapper.

public class AutoboxingTest {

public static void main(String args[]) {

int i = new Integer(9);
float f = new Float(1.0);
Double d = 9.0;
}
}
 StringBuffer e StringBuilder

Representam Strings modificáveis.

public class StringBuilderTest {

public static void main(String args[]) {

StringBuilder sb = new StringBuilder();

sb.append(“Java\n”);
sb.append(“Oracle\n”);
sb.append(“Postgres”);
System.out.println(sb);
}
 7

Tratamento de Exceções
 Objetivos

Compreender as vantagens em se usar

Exceptions em Java.

Exception:
- Objeto contendo as mensagens do erro em
questão.

Manipular, tratar, propagar, capturar e criar

exceptions.
 1ª vantagem:
Separação de código
Forma tradicional X Tratamento de exceções
public void lerArquivo() {
public int lerArquivo() {
try
int {codigoErro = 0;
abrirArquivo();
abrirArquivo();
if (erroAberturaArquivo()) {
lerArquivo();
codigoErro = -1;
fecharArquivo();
} else {
lerArquivo();
} catch (Exception ex) {
if (erroLeituraArquivo()) {
// trata o erro...
codigoErro = -2;
}
}
fecharArquivo();
}
if (erroFechamentoArquivo()) {
codigoErro = -3;
}
}
return codigoErro;
}
 2ª vantagem:
Propagação de Erros
Permite propagar o erro para ser tratado da forma mais adequada.

public void lerArquivo() throws Exception {

abrirArquivo();
lerArquivo();
fecharArquivo();

}
 3ª vantagem:
Agrupar tipos de erros
Através de exceptions erros podem ser enquadrados em categorias ou
grupos.

public void lerArquivo() {

try {

abrirArquivo();
lerArquivo();
fecharArquivo();

} catch (FileNotFoundException ex) {

// tratar erro de “arquivo não encontrado”...
} catch (IOException ex2) {
// tratar erro de “IO”...
} catch (Exception ex3) {
// tratar todos os outros tipos de erros...
}
}
 4ª vantagem:
Exceções não são ignoradas

Após um método lançar uma Exception ela obrigatoriamente deve ser

capturada e tratada.
 Tratando Exceções
try / catch
public class Cliente {

public int codigo;

public class Cliente {
public void setCodigo(int c) throws Exception {
if (c <int
public 0) codigo;
throw new Exception(“Código inválido.”);
codigo void
public = c; setCodigo(int c) {
} if (c < 0)
System.out.println(“Código inválido.”);
public
elsestatic void main(String args[]) {
try codigo
{ = c;
} Cliente c = new Cliente();
c.setCodigo(-5);
} catch
public (Exception
static ex) {
void main(String args[]) {
System.out.println(ex.getMessage());
Cliente c = new Cliente();
} c.setCodigo(-5);
} }
} }
 Garantindo a execução
try / finally
Comando que permite garantir a execução de um bloco de código,
mesmo que tenha ocorrido uma Exception

public class FinallyTest {

public static void calcularIR(double v) throws Exception {

if (v < 0)
throw new Exception(“Valor inválido.”);
}

public static void main(String[] args) throws Exception {

try {
calcularIR(-5);
} finally {
System.out.println(“Estou executando.”);
}
}
}
 8

Classes abstratas e interfaces

 Objetivos

Criar classes abstratas

Definir interfaces
 Classe Abstrata

É uma classe especial que não permite ter

objetos (não pode ser instanciada).

Utilizada para herança.

public abstract class Produto {

private float preco;

public void setPreco(float p) { preco = p; }

public static void main(String args[]) {

Produto p = new Produto(); => ERRO
}
}
 Método Abstrato

Método definido na classe que não possui a sua

implementação (codificação).

Utilizado para herança.

public abstract class Produto {

private float preco;

public abstract void setPreco(float p);

public static void main(String args[]) {

Produto p = new Produto();
p.setPreco(); => ERRO
}
}
 Interfaces
Similar a uma classe abstrata.
Possui métodos sem implementação.

Utilizada na herança, para garantir que as classes

possuam os métodos definidos na interface.
public interface Produto {

public void setPreco(float p);

public float getPreco();

}
Na classe DVD estão public class DVD implements Produto {
faltando os métodos
da interface.
public static void main(String args[]) {
DVD dvd = new DVD();
}

}
Exercícios