Linguagens de Programação - Java

Prévia do material em texto

1Java Básico
Java
2Java Básico
Módulos do curso
66. . Herança, Herança, 
Poliformismo e Poliformismo e 
Ligação Ligação 
DinâmicaDinâmica
66. . Herança, Herança, 
Poliformismo e Poliformismo e 
Ligação Ligação 
DinâmicaDinâmica
1. Introdução1. Introdução1. Introdução1. Introdução
4. 4. Classes e Classes e 
Objetos: Objetos: 
Atributos e Atributos e 
MétodosMétodos
4. 4. Classes e Classes e 
Objetos: Objetos: 
Atributos e Atributos e 
MétodosMétodos
3. 3. Sintaxe Sintaxe 
BásicaBásica
3. 3. Sintaxe Sintaxe 
BásicaBásica
55. . Tipos de Tipos de 
Referência, Referência, 
Strings e Strings e 
ArraysArrays
55. . Tipos de Tipos de 
Referência, Referência, 
Strings e Strings e 
ArraysArrays
77. . Modelagem Modelagem 
em Camadasem Camadas
77. . Modelagem Modelagem 
em Camadasem Camadas
88. . Classes Classes 
Abstratas e Abstratas e 
InterfacesInterfaces
88. . Classes Classes 
Abstratas e Abstratas e 
InterfacesInterfaces
99. . ExceçõesExceções99. . ExceçõesExceções
22. JSDK. JSDK22. JSDK. JSDK
1100. . PacotesPacotes1100. . PacotesPacotes
3Java Básico
Introdução
4Java Básico
Tópicos do curso
Conceitos básicos da linguagem
Fundamentos da linguagem
Operadores
Modificadores
Controle de fluxo
Conversão de tipos
Ambiente de desenvolvimento Java 
 
 J2SE SDK (Java 2 Standard Edition Software 
Development Kit)
IDE (Integrated Development Environment)
5Java Básico
Tópicos do curso
Conceitos de OO
Classes, objetos, atributos e métodos
Herança
Classes abstratas e interfaces
Exceções
Criação
Levantamento
Tratamento
Pacotes
Nomes
Importação
Pacotes e diretórios
6Java Básico
Tópicos do curso
APIs
Como consultar a documentação (API)
Pacote java.lang
Pacote java.util
7Java Básico
Um pouco de história...
� Origem de Java
− Java surgiu do projeto Green, em 1990, na Sun Microsystems, 
que tinha como objetivo desenvolver softwares que fizessem 
diferentes dispositivos comunicarem entre si.
� A primeira versão da linguagem foi lançada em 1996
� O uso de Java cresceu rapidamente com o crescimento 
da Internet
� Mais de 5,000,000 de pessoas possuem o software de 
desenvolvimento Java
8Java Básico
Adoção de Java
� O número de desenvolvedores Java passou de
 3 milhões3 milhões
� Já há mais desenvolvedores Java que 
desenvolvedores C++
� Há um forte movimento OpenSource com Java
− Bibliotecas completas
− Aplicações e ferramentas gratuitas
− Padrões abertos
� Java está se transformando em uma linguagem 
largamente utilizada para o desenvolvimento de 
aplicações web e aplicações para dispositivos 
móveis
9Java Básico
Adoção de Java
� Empresas que apóiam fortemente Java
SunSun OracleOracleIBMIBM
NetscapeNetscape BEABEA
...
...
10Java Básico
A plataforma Java
� O que é a plataforma Java?
− É uma infra-estrutura para programação baseada 
no poder das redes de computadores e na idéia 
de que uma mesma aplicação possa executar em 
diferentes máquinas, aparelhos e dispositivos 
eletrônicos.
“Write once, run anywhere.”
11Java Básico
Porque utilizar Java?
� Simplicidade
� Portabilidade
� Distribuição
� Robustez
� Concorrência
� Performance
� Paradigma de Orientação a Objetos
12Java Básico
� Sintaxe familiar a vários programadores 
(baseada em C e C++)
� Elimina várias redundâncias de C++
� Não é necessário gerenciar memória 
explicitamente
− Destruição de objetos em memória
� Simples para muitas aplicações, desde que 
se conheça algumas APIs
Java é Simples
13Java Básico
Java é Portável
� Redução de custos com migração, 
instalação, treinamento, etc.
� Algumas vezes ainda é necessário depurar 
programas antes de migrar para outra 
plataforma
� Java tem se tornado cada vez mais portável: 
aplicações desenvolvidas e testadas uma 
única vez têm rodado em dezenas de 
plataformas sem alteração
14Java Básico
� Oferece suporte de alto nível para acesso à 
Internet/Web
� Objetos distribuídos com RMI, CORBA e EJB
� Suporte para acesso a arquivos remotos, 
banco de dados, etc.
Java é Distribuída
15Java Básico
� Ausência de ponteiros
� Fortemente tipada
� Coleta de lixo automática (garbage 
collection)
� Exceções tipadas
� Variáveis (member variables) são 
inicializadas automaticamente
Java é Robusta
16Java Básico
� Facilidade em criar aplicações com 
concorrência
� Métodos sincronizados
� Monitores (construções essenciais para o 
controle de concorrência)
Java é Concorrente
17Java Básico
� Código no cliente pode ser interpretado
 Compiladores JIT aumentam performance
 Cliente universal 
 Código móvel, carregado pela rede, evitando 
instalações, conflito entre versões, etc.
� Código no servidor pode ser compilado para 
código de máquina
 Performance similar a C++
� A performance de Java vem aumentando 
rapidamente!
Alta Performance
18Java Básico
� Objetos e classes
� Encapsulamento de dados e operações
� Herança e Subtipos 
� Polimorfismo
� Ligações dinâmicas (dynamic binding)
� Criação e remoção dinâmica de objetos
� Exceções
Java é Orientada a Objetos
19Java Básico
Plataformas Java
J2ME
J2SE
J2EE
Micro Edition
Standard Edition
Enterprise Edition
PalmsPalms
CelularesCelulares
Dispositivos inteligentesDispositivos inteligentes
Aplicações convencionaisAplicações convencionais
AppletsApplets
Aplicações WebAplicações Web
Aplicações DistribuídasAplicações Distribuídas
Aplicações TransacionaisAplicações Transacionais
20Java Básico
Dispositivos que rodam Java
21Java Básico
A plataforma Java
� Java Virtual Machine (JVM)
− Componente da plataforma Java que assegura a 
independência das aplicações entre diferentes 
plataformas
− É uma espécie de tradutor existente nos 
dispositivos para traduzir comandos da 
linguagem Java para a linguagem da máquina 
nativa.
� Plataformas compatíveis com Java
− Implementam o tradutor da linguagem Java para 
sua linguagem de máquina
22Java Básico
Código
Java
Compilador
Java bytecode
Interpretador
Windows
Interpretador
Linux
Interpretador
Mac
Dispositivos
Portáteis
Como funciona um compilador 
e um interpretador Java?
23Java Básico
� O que são bytecodes?
− Instruções de código de máquina específicas 
para a máquina virtual Java
� A máquina virtual transforma os bytecodes 
em instruções da máquina que está 
executando o programa
Bytecodes
24Java Básico
Máquina Virtual JavaMáquina Virtual Java
Sistema OperacionalSistema Operacional
CompilaçãoCompilação
Bytecodes
Programa
Compilado
Código
Fonte
Interpretador
Plataforma Java
Programa JavaPrograma Java
Arquitetura Java
25Java Básico
Execução de Aplicações Java
Sistema Operacional
Aplicação Java
Máquina Virtual
26Java Básico
O JSDK
27Java Básico
Java Software Development KitJava Software Development Kit
� Conjunto de ferramentas, bibliotecas e 
exemplos para o desenvolvimento em Java
� Ferramentas para desenvolvimento de 
aplicações Java usam o JSDK como base
− Eclipse, Net beans, IntelliJ IDEA, Borland 
JBuilder, WSAD, entre outros
O que é o JSDK?
28Java Básico
Ferramentas e Recursos 
disponibilizados com o JSDK
� Ferramentas para compilação, execução e 
depuração de programas Java
� Bibliotecas compiladas
� Código fonte completo das bibliotecas
� Exemplos em Java
29Java Básico
� Essenciais
− javac: compila programas Java
− java: executa programas Java
� Importantes
− javadoc: gera documentação automática
− jar: manipula arquivos “Java Archive” (JAR)
� Outras
− javap
− appletviewer
Exemplos de Ferramentasdo 
JSDK
30Java Básico
Comando “javac”
� Compila arquivos .java transformando-os em 
.class (bytecodes)
javac javac Nome_ArquivoNome_Arquivo.java.java
Ferramenta de compilação JavaFerramenta de compilação JavaFerramenta de compilação JavaFerramenta de compilação Java
Nome do arquivo JavaNome do arquivo Java
 (Programa Java)(Programa Java)
Nome do arquivo JavaNome do arquivo Java
 (Programa Java)(Programa Java)
Extensão de um arquivo JavaExtensão de um arquivo JavaExtensão de um arquivo JavaExtensão de um arquivo Java
31Java Básico
Exemplos do comando “javac”
� Compilação de um arquivo Java específico
� Compilação de todos os arquivos Java, em um 
mesmo diretório 
javac *.javajavac *.java
javac Conta.javajavac Conta.java
32Java Básico
Exemplos do comando “javac”
� Compilação de mais de um arquivo Java
� Especificando o diretório no qual os arquivos .class 
devem ser gerados
javac Conta.java Cliente.javajavac Conta.java Cliente.java
javac *.java –d c:\MinhasClasses javac *.java –d c:\MinhasClasses 
33Java Básico
Comando “java”
� Interpretador Java
� Utilizado para:
− Executar arquivos .class (gerados após a compilação, a 
partir dos arquivos .java)
− Executar arquivos .jar
� Um arquivo Java precisa conter um método main 
para poder ser executado:
public static void main (String[] args) {
/*código Java que deve ser executado */
}
34Java Básico
java java ContaConta
Exemplos do comando “java”
java java Nome_ArquivoNome_Arquivo
java -jar bancoDatasus.jarjava -jar bancoDatasus.jar
Interpretador JavaInterpretador JavaInterpretador JavaInterpretador Java
Nome do arquivoNome do arquivo
(a extensão (a extensão .class.class
 não deve ser fornecida)não deve ser fornecida)
Nome do arquivoNome do arquivo
(a extensão (a extensão .class.class
 não deve ser fornecida)não deve ser fornecida)
35Java Básico
Comando “javadoc”
� Extrai toda a documentação no estilo 
“javadoc” (/** ... */)
� Gera um site completo com a documentação
javadoc Nome_Arquivo.javajavadoc Nome_Arquivo.java
Ferramenta para geração de documentação htmlFerramenta para geração de documentação htmlFerramenta para geração de documentação htmlFerramenta para geração de documentação html
Nome do arquivo com a extensão .javaNome do arquivo com a extensão .javaNome do arquivo com a extensão .javaNome do arquivo com a extensão .java
36Java Básico
Exemplos do comando 
“javadoc”
� Gera a documentação para todos os arquivos Java, 
no mesmo diretório onde estes estão localizados
� Gera a documentação em um diretório diferente da 
localização dos arquivos .java
javadoc *.javajavadoc *.java
jjavadocavadoc –d nome_do_diretorio –d nome_do_diretorio *.java*.java
37Java Básico
Comando “jar”
Para criar um arquivo .jar
Para listar o conteúdo de um arquivo .jar
Para extrair o conteúdo de um arquivo .jar
jar cf arquivo.jar *.class
jar cf arquivo.jar *.java
jar cf arquivo.jar *.class
jar cf arquivo.jar *.java
jar tf arquivo.jarjar tf arquivo.jar
jar xf arquivo.jar jar xf arquivo.jar 
38Java Básico
Comando “javap”
� Java class disassembler (decompilador)
� Analisa um arquivo .class e retorna um 
código Java correspondente
� Pode também retornar os bytecodes para os 
métodos da classe
javap MinhaClassejavap MinhaClassejavap MinhaClassejavap MinhaClasse
javap -c MinhaClassejavap -c MinhaClassejavap -c MinhaClassejavap -c MinhaClasse
mostra definição 
dos métodos
mostra definição 
e bytecodes
39Java Básico
Comando “appletviewer”
� Usado para testar Applets sem a necessidade 
de um browser
� Permite maior controle sobre a execução de 
Applets do que em um browser
appletviewer pagina.htmlappletviewer pagina.htmlappletviewer pagina.htmlappletviewer pagina.html
40Java Básico
� Java 2 Plataform, Standard Edition v1.5
� Java 2 Plataform, Standard Edition v1.4
� Java 2 Plataform, Standard Edition v1.3
� Java 2 Plataform, Standard Edition v1.2
� Java 2 Plataform, Standard Edition v1.1
� Java 2 Plataform, Standard Edition v1.0
Evolução das versões do JSDK
41Java Básico
Sintaxe básica de Java
Sintaxe Básica de Java
42Java Básico
Comentários
// Este é um comentário de uma única linha// Este é um comentário de uma única linha
/* Este comentário pode ocupar várias /* Este comentário pode ocupar várias 
linhas sem problemas */linhas sem problemas */
/** Este é um comentário especial do tipo /** Este é um comentário especial do tipo 
 * “javadoc” que é usado para geração * “javadoc” que é usado para geração 
 * automática de documentação * automática de documentação 
 */ */
// Este é um comentário de uma única linha// Este é um comentário de uma única linha
/* Este comentário pode ocupar várias /* Este comentário pode ocupar várias 
linhas sem problemas */linhas sem problemas */
/** Este é um comentário especial do tipo /** Este é um comentário especial do tipo 
 * “javadoc” que é usado para geração * “javadoc” que é usado para geração 
 * automática de documentação * automática de documentação 
 */ */
/** Este é um comentário especial do tipo /** Este é um comentário especial do tipo 
 * “javadoc” que é usado para geração * “javadoc” que é usado para geração 
 * automática de documentação * automática de documentação 
 */ */
 ----------
 ----------
 ----------
comentários Javacomentários Java
código Javacódigo Java
arquivo Javaarquivo Java
43Java Básico
Identificadores
� Identificam elementos de um programa Java
− métodos, atributos, rótulos, …
� Regras para identificadores
− Devem iniciar por uma letra, um “sublinhado” 
(_) ou o símbolo do dólar ($). Caracteres 
subseqüentes podem ser letras, dígitos, 
sublinhados ou $.
− São “Case sensitive”:
� Maiúsculas são diferenciadas de minúsculas
44Java Básico
Identificadores
� Identificadores válidos
− soma
− temp01
− _numClientes
− $fortuna
− nomeLongoDeVariavel
� Identificadores inválidos
− 102dalmatas
− 123
− #x
45Java Básico
Palavras reservadas
abstract
assert
boolean
break
byte
case
catch
char
class
const
continue
default
do
double
else
enum
extends
false
final
finally
float
for
goto
if
implements
import
instanceof
int 
interface
long
native
new
null
package
private
protected
public
return
short
static
strictfp
super
switch
synchronized
this
throw
throws
transient
true
try
void
volatile
while
Não podem ser usadas como identificador!!!
46Java Básico
Tipos Primitivos
boolean true ou false
char caractere (16 bits Unicode)
byte inteiro (8 bits)
short inteiro (16 bits)
int inteiro (32 bits)
long inteiro (64 bits)
float ponto flutuante (32 bits)
double ponto flutuante (64 bits)
47Java Básico
Hierarquia dos Tipos
Tipos primitivos
Tipo booleano
boolean
Tipos numéricos
Tipos integrais
Tipo caractere Tipos inteiros
Tipos ponto-flutuante
char byte short int long float double
48Java Básico
Declaração de Variáveis
int LIMITE_MAXIMO;
double saldo = 100.5;
int quantidade, idade;
float saldo = 100.5f;
int quantidadeMaxima;
 Padrão para nome de variáveis:
 começam com letras minúsculas;
 em caso de palavras compostas a primeira letra da palavra 
seguinte é maiúscula.
Padrão de codificação. Não é 
restrição da sintaxe de Java
49Java Básico
Operadores
50Java Básico
Tipos de operadores
� Aritméticos
� Concatenação
� Comparação
� Lógicos 
� Atribuição
� Unários 
� Condicional (ternário)
51Java Básico
Operadores aritméticos
 + - * / %
� O operador / é também utilizado para calcular 
divisõesinteiras
� O operador % calcula o resto de uma divisão 
inteira 
1/2 => 01/2 => 01/2 => 01/2 => 0
16/5 => 316/5 => 316/5 => 316/5 => 3
16%5 =>116%5 =>116%5 =>116%5 =>1
1%2 => 11%2 => 11%2 => 11%2 => 1
52Java Básico
Operador de concatenação
� + (aplicado a Strings)
String nomeCompleto = nome + sobrenome;String nomeCompleto = nome + sobrenome;String nomeCompleto = nome + sobrenome;String nomeCompleto = nome + sobrenome;
mensagem = “Este é o cliente número ” + x;mensagem = “Este é o cliente número ” + x;mensagem = “Este é o cliente número ” + x;mensagem = “Este é o cliente número ” + x;
System.out.println(“Total: “ + total);System.out.println(“Total: “ + total);System.out.println(“Total: “ + total);System.out.println(“Total: “ + total);
A concatenação também faz uma
 conversão implícita para String
53Java Básico
Operadores de Comparação
� Operadores de comparação
− >
− <
− >=
− <=
− ==
− !=
54Java Básico
Operadores lógicos
� Operadores booleanos
− short-circuit
� && (E lógico)
� || (OU lógico)
55Java Básico
Operadores lógicos
� Operadores booleanos
− bitwise
� & (E lógico ou bit-a-bit)
� | (OU lógico ou bit-a-bit)
� ^ (OU-EXCLUSIVO bit-a-bit)
56Java Básico
Atribuição
� Atribuição
− =
− +=,-=,*=,/=
x = 0;x = 0;x = 0;x = 0;
a = b = c = -1;a = b = c = -1;a = b = c = -1;a = b = c = -1;
x += 1;x += 1;x += 1;x += 1; x = x + 1;x = x + 1;x = x + 1;x = x + 1;
y -= k;y -= k;y -= k;y -= k; y = y - k;y = y - k;y = y - k;y = y - k;
y -= X + 5;y -= X + 5;y -= X + 5;y -= X + 5; y = y – (x + 5);y = y – (x + 5);y = y – (x + 5);y = y – (x + 5);
57Java Básico
Unários
� ++, --
-,!
y = x++ y = x--
y = ++x y = --x
Usar esses operadores
com cuidado!
y = -xy = -x y = !xy = !x
58Java Básico
Condicional
� Conhecido também como operador ternário
− ?:
a = x ? b : c
x é uma expressão booleanax é uma expressão booleanax é uma expressão booleanax é uma expressão booleana
b e c são expressões que b e c são expressões que 
poderão ser atribuídas à poderão ser atribuídas à 
variável avariável a
b e c são expressões que b e c são expressões que 
poderão ser atribuídas à poderão ser atribuídas à 
variável avariável a
59Java Básico
Uso dos Operadores
� Ordem de avaliação dos operadores
� Associatividade
60Java Básico
Ordem de avaliação dos 
operadores
� Ordem de precedência (maior para menor):
 expr++, expr--
 ++expr, --expr, +expr, -expr
 (tipo) expr
 *, /, %
 +, -
 <, > >=,<=
 ==, !=
 &&
 ||
 =, +=, -=, *=, /=
61Java Básico
Associatividade
� Quando os operadores possuem a mesma precedência, 
avalia-se primeiro o operador mais a esquerda
 Exemplo: a + b + c equivale a (a + b) + c
� (exceção) Todos os operadores binários de Java são 
associativos a esquerda, exceto a atribuição
 Exemplo: a = b = c equivale a a = (b = c)
� Precedência e associatividade podem ser redefinidas 
através de parênteses
 Exemplo: a*(b+c), a + (b + c)
62Java Básico
Conversão de Tipos
63Java Básico
Conversões entre tipos, e Casts, 
acontecem freqüentemente quando 
programamos em Java
doubledouble d1 = 10.0d; d1 = 10.0d;
System.out.println("Soma: " + (d1 + 10));System.out.println("Soma: " + (d1 + 10));
......
bytebyte b = ( b = (bytebyte) 32.0d;) 32.0d;
......
doubledouble d1 = 10.0d; d1 = 10.0d;
System.out.println("Soma: " + (d1 + 10));System.out.println("Soma: " + (d1 + 10));
......
bytebyte b = ( b = (bytebyte) 32.0d;) 32.0d;
......
Introdução
64Java Básico
Entre tipos primitivos
 Atribuição
 Passagem de parâmetros
 Promoções aritméticas
Entre objetos
 Atribuição
 Passagem de parâmetros
Conversões ocorrem
65Java Básico
Conversões entre tipos 
primitivos
� Widening conversion
− Conversão para um tipo de maior capacidade
� Narrowing conversion
− Conversão para um tipo de menor capacidade
− Pode haver perda de informação 
� Essas conversões podem ser
− Implícitas
− Explícitas
66Java Básico
É sempre possível quando a 
conversão ocorre de um tipo "menor" 
para um tipo "maior" (widening 
conversion)
byte
char
short
int long doublefloat
As setas indicam a direção 
das conversões possíveis
Atribuição e passagem de 
parâmetros
67Java Básico
Acontece quando valores de tipos 
diferentes são operandos de uma 
expressão aritmética
Operadores binários:
 O tipo do operando de menor tamanho 
(bits) é promovido para o tipo do operando 
de maior tamanho
 Os tipos short, char e byte são sempre 
convertidos para o tipo int em operações 
envolvendo apenas esses tipos
Promoção aritmética
68Java Básico
Operadores unários:
 Os tipos short, char e byte são sempre 
convertidos para o tipo int (exceto 
quando usados ++ e --)
 Demais tipos são convertidos de acordo 
com o maior tipo sendo utilizado na 
mesma expressão
short s = 9;short s = 9;
int i = 10;int i = 10;
float f = 11.1f;float f = 11.1f;
double d = 12.2d;double d = 12.2d;
if (-s * i >= f / d) {if (-s * i >= f / d) {
......
}}
......
short s = 9;short s = 9;
int i = 10;int i = 10;
float f = 11.1f;float f = 11.1f;
double d = 12.2d;double d = 12.2d;
if (-s * i >= f / d) {if (-s * i >= f / d) {
......
}}
......
Promoção aritmética
69Java Básico
Exemplo de promoção 
aritmética
byte b = 1;
int i = 1;
float f = 5.2f;
double d = 7.5;
int
float
double
double
double
((b + i) * f) / (d + i)
70Java Básico
intint a = 1234; a = 1234;
longlong b = a; b = a;
shortshort d = 10; d = 10;
intint c = ( c = (intint) b;) b;
shortshort c = ( c = (shortshort) a; ) a; 
O operador “cast”
� Usado para conversões
� Sintaxe
 (<tipo>) <expressão>
conversão implícita
conversão explícita
}}
}}
71Java Básico
Casts podem ser realizados entre quaisquer 
tipos primitivos, exceto boolean
Cast entre tipos primitivos
Casts envolvendo o tipo boolean
não são permitidos! 
Casts envolvendo o tipo boolean
não são permitidos! 
double d = 10.0d;double d = 10.0d;
int i = (int) d;int i = (int) d;
double d = 10.0d;double d = 10.0d;
int i = (int) d;int i = (int) d;
72Java Básico
Estruturas de Controle
73Java Básico
Estruturas de Controle
� if
� if-else
� if-else-if
� switch-case
� while
� do-while
� for
74Java Básico
if
� Declaração condicional mais simples em 
Java
if (expressão booleana){
 comando
}
if (nomeUsuario == null){ 
nomeUsuario = “indefinido”;
}
if (nomeUsuario == null){ 
nomeUsuario = “indefinido”;
}
if (vendas >= meta){ 
 desempenho = “Satisfatório”;
 bonus = 100;
}
if (vendas >= meta){ 
 desempenho = “Satisfatório”;
 bonus = 100;
}
75Java Básico
if-else
if (expressão booleana){
 comando1
}else{
 comando2
}
if (media < 5){
 resultado = “Reprovado”;
}else {
 resultado = “Aprovado”;
}
if (media < 5){
 resultado = “Reprovado”;
}else {
 resultado = “Aprovado”;
}
if (vendas >= meta){ 
 desempenho = “Satisfatório”;
 bonus = 100+ 0.01*(vendas-meta);
}else {
 desempenho = “Não Satisfatório”;
 bonus = 0;
}
if (vendas >= meta){ 
 desempenho = “Satisfatório”;
 bonus = 100+ 0.01*(vendas-meta);
}else {
 desempenho = “Não Satisfatório”;
 bonus = 0;
}
76Java Básico
if-else-if
ifif ( (expressão booleanaexpressão booleana){){
 
 bloco de comandosbloco de comandos
}}elseelse ifif (expressão booleana){ (expressão booleana){
 
 bloco de comandosbloco de comandos
}}else {else {
 
 bloco de comandosbloco de comandos
}}
if (vendas >= 2*meta){ 
 desempenho = “Excelente”;
 bonus = 1000;
} else if (vendas >= 1.5*meta){
 desempenho = “Boa”;
 bonus= 500;
} else if (vendas >= meta){
 desempenho = “Satisfatório”;
 bonus = 100;
} else {
 System.out.println(“Você está em apuros”);
}
if (vendas >= 2*meta){ 
 desempenho = “Excelente”;
 bonus = 1000;
} else if (vendas >= 1.5*meta){
 desempenho = “Boa”;
 bonus = 500;
} else if (vendas >= meta){
 desempenho = “Satisfatório”;
 bonus = 100;
} else {
 System.out.println(“Você está em apuros”);
}
77Java Básico
switchswitch(<(<expressão inteira>expressão inteira>) {) {
casecase 1: 1:
 
 // Bloco de código 1// Bloco de código 1
 
 break;break;
casecase 2: 2:
 
 // Bloco de código 2// Bloco de código 2
 
 breakbreak;;
casecase 3: 3:
 
 // Bloco de código 3// Bloco de código 3
 
 break;break;
defaultdefault::
 
 // Bloco de código // Bloco de código 
}}
Tipo da expressão deve ser
byte, char, short ou int
switch-case
Executado somente
quando todos os outros
cases falham
78Java Básico
switch-case
boolean analisarResposta(boolean analisarResposta(charchar resposta) resposta) 
{{
 
 switchswitch((respostaresposta) {) {
 
 casecase ‘s’: ‘s’:
 
 casecase ‘S’: return true; ‘S’: return true;
 
 casecase ‘n’: ‘n’:
 
 casecase ‘N’: return false; ‘N’: return false;
 
 defaultdefault: : 
 
 System.out.println(System.out.println(
 “ “Resposta inválida!”);Resposta inválida!”);
 
 returnreturn false; false;
 
 }}
}}
return também
pode ser 
usado para sair
do case
79Java Básico
whilewhile (true) (true) 
System.out.println(“Casa Forte”);System.out.println(“Casa Forte”);
whilewhile (true) (true) 
System.out.println(“Casa Forte”);System.out.println(“Casa Forte”);
while
whilewhile ( (expressão booleanaexpressão booleana){){
 
 comandocomando
}}
pode ser executado
 0 vezes!
x = 10;x = 10;
whilewhile ( (x < 10x < 10))
 
 x = x + 1;x = x + 1;
x = 10;x = 10;
whilewhile ( (x < 10x < 10))
 
 x = x + 1;x = x + 1;
loop infinito
int contador = 0;int contador = 0;
whilewhile (contador < 10) { (contador < 10) {
 
 System.out.println(contador);System.out.println(contador);
 
 contador++;contador++;
}}
int contador = 0;int contador = 0;
whilewhile (contador < 10) { (contador < 10) {
 
 System.out.println(contador);System.out.println(contador);
 
 contador++;contador++;
}}
Teste é feito no início
80Java Básico
do-while
do{
 comando
}while(expressão booleana);
int contador = 0;int contador = 0;
dodo { {
 
 System.out.println(contador);System.out.println(contador);
 
 contador++;contador++;
}}
whilewhile (contador < 10); (contador < 10);
int contador = 0;int contador = 0;
dodo { {
 
 System.out.println(contador);System.out.println(contador);
 
 contador++;contador++;
}}
whilewhile (contador < 10); (contador < 10);
Teste é feito no final
comandos são 
executados pelo 
menos uma vez
String resposta;String resposta;
dodo { {
 
 resposta = “Resposta Incorreta!”;resposta = “Resposta Incorreta!”;
}}
whilewhile (ehInvalida(resposta)); (ehInvalida(resposta));
String resposta;String resposta;
dodo { {
 
 resposta = “Resposta Incorreta!”;resposta = “Resposta Incorreta!”;
}}
whilewhile (ehInvalida(resposta)); (ehInvalida(resposta));
81Java Básico
for
forfor ( (inicializaçãoinicialização; ; condiçãocondição; ; 
incrementoincremento){){
 
 comandocomando
}}forfor ( (int contador = 0int contador = 0; ; contador < 10contador < 10; ; contador++contador++){){
 
 System.out.println(contador);System.out.println(contador);
}}
forfor ( (int contador = 0int contador = 0; ; contador < 10contador < 10; ; contador++contador++){){
 
 System.out.println(contador);System.out.println(contador);
}}
void void tabuada() {tabuada() {
 
 intint x,y; x,y;
 
 forfor (x=1, y=1; x<=10; x++, y++) { (x=1, y=1; x<=10; x++, y++) {
 
 System.out.print(x + “ X ” + y + “ = “);System.out.print(x + “ X ” + y + “ = “);
 
 System.out.println(x*y);System.out.println(x*y);
 
 }}
}}
void void tabuada() {tabuada() {
 
 intint x,y; x,y;
 
 forfor (x=1, y=1; x<=10; x++, y++) { (x=1, y=1; x<=10; x++, y++) {
 
 System.out.print(x + “ X ” + y + “ = “);System.out.print(x + “ X ” + y + “ = “);
 
 System.out.println(x*y);System.out.println(x*y);
 
 }}
}}
82Java Básico
break
� Usado para terminar a execução de um bloco for, while, do ou 
switch 
intint procurar(String nome) { procurar(String nome) {
 
 intint indice = -1; indice = -1;
 
 forfor ( (intint i = 0; i < 50; i++) { i = 0; i < 50; i++) {
 
 ifif (i < MAXIMO ) { (i < MAXIMO ) {
 
 indice = i;indice = i;
 
 breakbreak;;
 
 }}
 
 }}
 
 returnreturn indice; indice;
}}
intint procurar(String nome) { procurar(String nome) {
 
 intint indice = -1; indice = -1;
 
 forfor ( (intint i = 0; i < 50; i++) { i = 0; i < 50; i++) {
 
 ifif (i < MAXIMO ) { (i < MAXIMO ) {
 
 indice = i;indice = i;
 
 breakbreak;;
 
 }}
 
 }}
 
 returnreturn indice; indice;
}}
83Java Básico
continue
� Termina a execução da iteração atual do loop e 
volta ao começo do loop.
forfor ( (intint k = 0; k < 10; k++) { k = 0; k < 10; k++) {
 
 ifif (k == 5) { (k == 5) {
 
 continuecontinue;;
 
 }}
 
 System.out.println(“k = ” + k);System.out.println(“k = ” + k);
}}
forfor ( (intint k = 0; k < 10; k++) { k = 0; k < 10; k++) {
 
 ifif (k == 5) { (k == 5) {
 
 continuecontinue;;
 
 }}
 
 System.out.println(“k = ” + k);System.out.println(“k = ” + k);
}}
84Java Básico
return
� Termina a execução de um método e retorna a 
chamada ao invocador
� É obrigatório quando o tipo de retorno do método não 
é void
� O resultado da avaliação de expressão deve poder 
ser atribuído ao tipo de retorno do método
int somar (int x, int y) {
 return x + y;
} 
void atualizarDados() {
 ...
 if (dadosAtualizados) 
 return;
 ...
} 
o tipo de retorno deve ser compatível 
com o tipo de retorno do método
métodos sem retorno
também podem usar return
85Java Básico
Classes e Objetos:
atributos e métodos
86Java Básico
Programação Orientada a Objetos
� Olhar o mundo como se tudo pudesse ser 
representado por objetos
� Estruturação do programa é baseada na 
representação de objetos do mundo real 
(estados + comportamento)
� Vantagens
− Facilidade de manutenção
− Maior extensibilidade
− Maior reuso
87Java Básico
Objeto DVD
parar()parar()
pausar()pausar()
avancar()avancar()
voltar()voltar()
tempoDecorridotempoDecorrido
horaAtualhoraAtual
tipoSistematipoSistema
alterarHora()alterarHora()
duracaoDiscoduracaoDisco
tocar()tocar()
carregarDisco()carregarDisco()
88Java Básico
Classes e Objetos
� Classes especificam a estrutura e o 
comportamento dos objetos
� Classes são como "moldes" para a criação de 
objetos
� Objetos são instâncias de classes.
89Java Básico
Objetos
� Um objeto representa uma entidade do 
mundo real
� Todo objeto tem
Identidade
Estado
Comportamento
90Java Básico
Objetos
� Identidade
− Todo objeto é único e pode ser distinguido de 
outros objetos
� Estado
− Todo objeto tem estado, que é determinado 
pelos dados contidos no objeto
� Comportamento
− O comportamento de um objeto é definido pelos 
serviços/operações que ele oferece
91Java BásicoNúmero Saldo
 21.342-7 875,32
creditar
debitar
Objeto Conta Bancária
92Java Básico
Estados do Objeto Conta
creditar(20.00)
 Número Saldo
 21.342-7 875,32
creditar
debitar
 Número Saldo
 21.342-7 895,32
creditar
debitar
93Java Básico
Classe e objeto Conta Bancária
 Número Saldo
 String double
creditar
debitar
 Número Saldo
 21.342-7 875,32
creditar
debitar
 Número Saldo
 89.342-X105,33
creditar
debitar
classeclasse
objetosobjetosinstanciaçãoinstanciação
94Java Básico
Definição de Classes em Java
class NomeDaClasse {
 CorpoDaClasse 
}
class NomeDaClasse {
 CorpoDaClasse 
}
O corpo de uma classe pode conter 
• atributos
• métodos
• construtores
• outras classes... 
95Java Básico
Estrutura básica de uma classe 
Java
class NomeDaClasse {
 atributo1;
 atributo2;
 ...
 método1 {
 Corpo do método1
 }
 método2 {
 Corpo do método2
 }
}
class Conta {
 CorpoDaClasse
}
class Conta {
 CorpoDaClasse
}
96Java Básico
Atributos
97Java Básico
Declaração de atributos
double LIMITE_MAXIMO;double LIMITE_MAXIMO;
private static String numero;private static String numero;
double saldo;double saldo;
modificadores tipo nome ;
private String nome, sobrenome;private String nome, sobrenome;
Vários atributos podem ser
 declarados na mesma linha
int numEstoque = 8;int numEstoque = 8; Um atributo pode ser 
inicializado na declaração
98Java Básico
Exemplos de atributos
class Livro {
 int anoDePublicacao;
 int numeroDePaginas;
 String titulo;
 ...
} class Conta {
 String numero;
 double saldo;
 ...
}
class Cabine {
 int nivel;
 String codigo;
 int codCategoria
 int lotacaoMaxima;
 ...
}
99Java Básico
Métodos
100Java Básico
O que são métodos? 
Métodos são operações que realizam ações
 e modificam os valores dos atributos do objeto 
responsável pela sua execução
Métodos são operações que realizam ações
 e modificam os valores dos atributos do objeto 
responsável pela sua execução
101Java Básico
Declaração de métodos
modificadores tipo de retorno nome ;( )parâmetros
private double obterRendimento(String numConta, int mes);
nomeDoMetodo()nomeDoMetodo() { {
 
 Corpo do métodoCorpo do método
 
 }}
102Java Básico
O corpo do método
� O corpo do método contém os comandos que 
determinam as ações do método
� Esses comandos podem
− realizar simples atualizações dos atributos de um objeto
− retornar valores
− executar ações mais complexas como chamar métodos de 
outros objetos
� O corpo do método também pode conter 
declarações de variáveis
− Variáveis cuja existência e valores são válidos somente 
dentro do método em que são declaradas.
103Java Básico
Exemplo de Método
class Conta {
 String numero;
 double saldo;
 void creditar(double valor) {
 saldo = saldo + valor;
 } 
 ... 
}
104Java Básico
Métodos e tipo de retorno
class Conta {
 String numero;
 double saldo;
 
 String getNumero() {
 return numero;
 }
 double getSaldo() {
 return saldo;
 }
 ...
}
Os métodos que retornam valores como
resultado usam o comando return
Os métodos que retornam valores como
resultado usam o comando return
105Java Básico
Mais sobre métodos
class Conta {class Conta {
 
 ......
 
 voidvoid debitar(double valor) { debitar(double valor) {
 
 saldo = saldo - valor;saldo = saldo - valor;
 
 }}
}}
Por que o debitar não tem como parâmetro
o número da conta?
Por que o debitar não tem como parâmetro
o número da conta?
Usa-se void para indicar que o método não retorna nenhum valor,
 apenas altera os valores dos atributos de um objeto
106Java Básico
Chamada de métodos
� Métodos são invocados em instâncias (objeto) de alguma 
classe.
− Podem também ser invocados a partir da própria classe 
(métodos estáticos). 
� Os objetos se comunicam para realizar tarefas
� Parâmetros são passados por “cópia”
� A comunicação é feita através da chamada de métodos
conta.creditar(45.30)
variável contendo
referência para 
objeto
nome do 
método a ser
executado
operador de chamada 
de método
107Java Básico
Modificadores
108Java Básico
Modificadores
� Modificadores de acesso
− public
− protected
− private
− default (friendly)
� Outros modificadores
− static
− final
− native
− transient
− synchronized
Valor padrão quando nenhum 
modificador de acesso é 
especificado
109Java Básico
Modificadores de Acesso
� Controlam o acesso aos membros de uma 
classe
� Membros de uma classe:
− A própria classe
− Atributos
− Métodos e construtores (um tipo especial de 
métodos)
� Não são aplicados à variáveis
110Java Básico
public
� Uma classe public pode ser instanciada por qualquer classe
� Atributos public podem ser acessados (lidos, alterados) por 
objetos de qualquer classe
� Métodos public podem ser chamados por métodos de qualquer 
classe
public class Conta {
 public String numero;
 public double saldo;
 public void creditar(double valor) {
 saldo = saldo + valor;
 } 
 ... 
}
public class Conta {
 public String numero;
 public double saldo;
 public void creditar(double valor) {
 saldo = saldo + valor;
 } 
 ... 
}
111Java Básico
protected
� Usado somente para atributos e métodos
� Atributos protected podem ser acessados (lidos, alterados) 
por objetos de classes dentro do mesmo pacote ou de 
qualquer subclasse da classe ao qual ele pertence
� Métodos protected podem ser chamados por objetos de 
classes dentro do mesmo pacote ou de qualquer subclasse da 
classe ao qual ele pertence
public class Conta {
 protected String numero;
 protected double saldo;
 protected void creditar(double valor) {
 saldo = saldo + valor;
 } 
 ...
 
 
}}
public class Conta {
 protected String numero;
 protected double saldo;
 protected void creditar(double valor) {
 saldo = saldo + valor;
 } 
 ...
 
 
}}
112Java Básico
default (friendly)
� A classe é visível somente por classes do mesmo pacote
� Se um atributo não tem nenhum modificador de acesso 
associado, ele é “implicitamente” definido como friendly, e 
só é visível para objeto de classes do mesmo pacote
� Se um método não tem nenhum modificador de acesso 
associado, ele é “implicitamente” definido como friendly, e 
só pode ser chamado a partir de objetos de classes do mesmo 
pacote
class Conta {class Conta {
 
 String numero;String numero;
 
 double saldo;double saldo;
 
 void creditar(double valor) {void creditar(double valor) {
 
 saldo = saldo + valor;saldo = saldo + valor;
 
 } } 
 
 ... ... 
}}
class Conta {class Conta {
 
 String numero;String numero;
 
 double saldo;double saldo;
 
 void creditar(double valor) {void creditar(double valor) {
 
 saldo = saldo + valor;saldo = saldo + valor;
 
 } } 
 
 ... ... 
}}
113Java Básico
private e encapsulamento
class Pessoa {class Pessoa {
 
 privateprivate int anoDeNascimento; int anoDeNascimento;
 
 privateprivate String nome, sobrenome; String nome, sobrenome;
 
 privateprivate boolean casada = false; boolean casada = false;
 
 ......
}}
class Pessoa {class Pessoa {
 
 privateprivate int anoDeNascimento; int anoDeNascimento;
 
 privateprivate String nome, sobrenome; String nome, sobrenome;
 
 privateprivateboolean casada = false; boolean casada = false;
 
 ......
}}
� Java não obriga o uso de private, mas vários 
autores consideram isso essencial para a 
programação orientada a objetos
� Impacto em coesão e acoplamento
� Use private para atributos!
atributos private podem ser acessados somente por 
objetos da mesma classe
114Java Básico
private
� Métodos private só podem ser chamados por 
métodos da classe onde são declarados
class class PessoaPessoa { {
 
 
 
 privateprivate int anoDeNascimento; int anoDeNascimento;
 
 ......
 
 int getAnoDeNascimento(){int getAnoDeNascimento(){
 
 return formatarAno(); return formatarAno(); 
 
 }}
 
 private private int formatarAno(){int formatarAno(){
 
 //código para formatar o ano//código para formatar o ano
 
 }}
 
 
 
 ... ... 
}}
class class PessoaPessoa { {
 
 
 
 privateprivate int anoDeNascimento; int anoDeNascimento;
 
 ......
 
 int getAnoDeNascimento(){int getAnoDeNascimento(){
 
 return formatarAno(); return formatarAno(); 
 
 }}
 
 private private int formatarAno(){int formatarAno(){
 
 //código para formatar o ano//código para formatar o ano
 
 }}
 
 
 
 ... ... 
}}
115Java Básico
Outros modificadores
� final
− Pode ser utilizado para em qualquer membro de uma 
classe
− Torna o atributo constante
− O atributo não pode ser alterado depois de 
inicializado
− Métodos final não podem ser redefinidos
− Classes final não podem ser estendidas
116Java Básico
Outros modificadores
� final
class ConstantesBanco {class ConstantesBanco {
 
 public static public static finalfinal int NUM_MAXIMO_CONTAS; int NUM_MAXIMO_CONTAS;
 
 private static private static finalfinal double LIMITE_MIN_CHEQUES; double LIMITE_MIN_CHEQUES;
 
 private static private static finalfinal int NUM_CHEQUES_TALAO; int NUM_CHEQUES_TALAO;
 
 ......
}}
Pelo padrão de codificação, constantes devem
 ter seus nomes em maiúsculas
Atributos final 
geralmente são 
declarados como 
static também
117Java Básico
Outros modificadores
� static
− Pode ser usado somente em atributos e métodos
− Atributos static pertencem à classe e não aos 
objetos
− Só existe uma cópia de um atributo static de 
uma classe, mesmo que haja vários objetos da 
classe
− Atributos static são muito usados para 
constantes
− O acesso é feito usando o nome da classe:
int numCheques = numTaloes * int numCheques = numTaloes * 
 
 ConstantesBanco.NUM_CHEQUES_TALAOConstantesBanco.NUM_CHEQUES_TALAO; ; 
118Java Básico
Outros modificadores
� static
− Métodos static pertencem a classes e não a 
objetos
− Podem ser usados mesmo sem criar os objetos
− Só podem acessar diretamente atributos 
estáticos
− O acesso é feito usando o nome da classe:
x = x = MathMath.random();.random();
media = media = FuncoesFuncoes.calcularMedia(valores);.calcularMedia(valores);
119Java Básico
Outros modificadores
� native
− Usado somente em métodos
− Código nativo
� transient
− Usado somente em atributos
− Não é armazenado como parte persistente do 
objeto
� synchronized
− Usado somente em métodos
− Acesso concorrente
120Java Básico
Criação e remoção de objetos
121Java Básico
Criação de objetos
� Objetos precisam ser criados antes de serem 
utilizados
� Construtores precisam ser definidos na 
classe
� A criação é feita com o operador new
Conta c = Conta c = newnew Conta(); Conta();Conta c = Conta c = newnew Conta(); Conta();
construtor
122Java Básico
Construtores
� Além de métodos e atributos, uma classe pode conter construtores
� Construtores definem como os atributos
de um objeto devem ser inicializados
� São semelhantes a métodos, mas não têm tipo de retorno
� O nome do construtor deve ser exatamente o nome da classe.
� Uma classe pode ter diversos construtores, diferenciados pelos 
parâmetros
nome da classe parâmetros( )
corpo do construtor
{
}
modificador
public Navio(String umNome, int umNumero) {public Navio(String umNome, int umNumero) {
 
 nome = umNome;nome = umNome;
 
 numCabines = umNumero;numCabines = umNumero;
}}
public Navio(String umNome, int umNumero) {public Navio(String umNome, int umNumero) {
 
 nome = umNome;nome = umNome;
 
 numCabines = umNumero;numCabines = umNumero;
}}
123Java Básico
Construtor default
public Conta() {public Conta() {
}}
public Conta() {public Conta() {
}}
� Caso não seja definido um construtor, um 
construtor default é fornecido 
implicitamente
� O construtor default inicializa os atributos 
com seus valores default
� O construtor default não tem parâmetros:
124Java Básico
Valores default para atributos
TipoTipo Valor DefaultValor Default
byte, short, int, long 0
float 0.0f
double 0.0
char `\u0000`
Tipos referência (Strings, arrays, 
objetos em geral)
null
boolean false
125Java Básico
Outros construtores
class Conta {class Conta {
 
 String numero;String numero;
 
 double saldo;double saldo;
 
 public public Conta(String numeroConta, double Conta(String numeroConta, double 
saldoInicial){saldoInicial){
 
 numero = numeroConta;numero = numeroConta;
 
 saldo = saldoInicial;saldo = saldoInicial;
 
 }}
 
 ......
}}
class Conta {class Conta {
 
 String numero;String numero;
 
 double saldo;double saldo;
 
 public public Conta(String numeroConta, double Conta(String numeroConta, double 
saldoInicial){saldoInicial){
 
 numero = numeroConta;numero = numeroConta;
 
 saldo = saldoInicial;saldo = saldoInicial;
 
 }}
 
 ......
}}
Quando é definido um construtor com parâmetros,
o construtor default não é mais gerado
• Podem ser criados novos construtores, 
com parâmetros
126Java Básico
Conta c;Conta c;
......
c = c = newnew Conta(“12345”,100); Conta(“12345”,100);
responsável por 
inicializar os 
atributos do 
objeto criado
Mais sobre criação de objetos
responsável por 
criar um objeto do 
tipo Conta em 
memória
Atribui à variável 
c a referência 
criada para o 
novo objeto
127Java Básico
Remoção de objetos
� Não existe mecanismo de remoção explícita de objetos 
da memória em Java (como o free() de C++)
� O Garbage Collector (coletor de lixo) de Java elimina 
objetos da memória quando eles não são mais 
referenciados
� Você não pode obrigar que a coleta de lixo seja feita
� A máquina virtual Java decide a hora da coleta de lixo
128Java Básico
Referências
Objetos são manipulados através de referências
c == nullConta c = null;
c = new Conta(“1287”,0);
c.getSaldo();
c
chama o método getSaldo() do 
objeto referenciado pela 
variável c
129Java Básico
Mais de uma variável pode armazenar referências 
para um mesmo objeto (aliasing)
Conta Conta aa = new Conta(“123-4”,340.0); = new Conta(“123-4”,340.0);
Conta Conta bb;;
b = ab = a; ; 
b.creditar(100);b.creditar(100);
System.out.println(System.out.println(a.getSaldo());a.getSaldo());
a e b passam a referenciar
a mesma conta
qualquer efeito via b
é refletido via a
Referências
1Java Básico
Tipos referência,
Strings e Arrays
2Java Básico
Tipos referência
� Em Java há dois conjuntos de tipos 
− Tipos primitivos
− Tipos referência
� Tipos primitivos
− int, long, double, float, ...
� Tipos referência
− classes, interfaces e arrays
3Java Básico
Tipos de referência
� Em Java não se trabalha diretamente com os 
objetose sim com
referências a objetosreferências a objetos
� Isso tem implicações na maneira em que 
objetos são comparados e copiados
4Java Básico
Strings
5Java Básico
Strings
� São seqüências de caracteres
� Não há um tipo primitivo para Strings em 
Java
� Em Java, Strings são objetos
String mensagem = “Operação concluída com sucesso”;String mensagem = “Operação concluída com sucesso”;String mensagem = “Operação concluída com sucesso”;String mensagem = “Operação concluída com sucesso”;
Aqui Java cria um novo objeto
 do tipo String e o armazena na 
variável mensagem
6Java Básico
Concatenação de Strings
� Operador + é usado para concatenação
String nome = "George"; String nome = "George"; 
String sobrenome = "Bush";String sobrenome = "Bush";
String nomeCompleto = nome + " " + sobrenome;String nomeCompleto = nome + " " + sobrenome;
int anos = 10;int anos = 10;
double rendimento = 1270.49;double rendimento = 1270.49;
String s = "Em " + anos + " anos o " +String s = "Em " + anos + " anos o " +
 
 "rendimento será de " + rendimento;"rendimento será de " + rendimento;
System.out.println(s);System.out.println(s);
A conversão para 
String é feita 
automaticamente
7Java Básico
Strings são tipos referência
String s1 = 
"George";
String s2 = 
"George";
s1s1
s2s2
Geo r ge
s1s1
s2s2
Geo r geGeo r ge
Bush
Geo r ge
Bush
s1 = s1 + " Bush";
s2 = s2 + " Bush"; Ao manipular um String, 
um novo String é gerado!
8Java Básico
Igualdade de Strings
� Para testar se dois Strings são iguais, não 
deve ser usado ==
� Deve-se usar o método equals:
s1 == s2s1 == s2
s1.equals(s2)s1.equals(s2)
9Java Básico
Igualdade de Strings
//Cria dois novos Strings //Cria dois novos Strings 
String s1 = "George"; String s1 = "George"; 
String s2 = "George";String s2 = "George";
// Nesse momento, s1==s2 é verdadeiro!// Nesse momento, s1==s2 é verdadeiro!
 
 
s1 = s1 + " Bush"; // Cria um novo string e o atribui para s1 = s1 + " Bush"; // Cria um novo string e o atribui para 
s1s1
s2 = s2 + " Bush"; // Cria um novo string e o atribui para s2 = s2 + " Bush"; // Cria um novo string e o atribui para 
s2s2
 
 
ifif (s1 == s2) (s1 == s2) 
 
 System.out.println("s1 e s2 sao os mesmos objetos.");System.out.println("s1 e s2 sao os mesmos objetos.");
elseelse
 
 System.out.println("s1 e s2 NAO sao os mesmos objetos.");System.out.println("s1 e s2 NAO sao os mesmos objetos.");
 
 
ifif (s1.equals(s2)) (s1.equals(s2)) 
 
 System.out.println("s1 e s2 possuem o mesmo conteúdo.");System.out.println("s1 e s2 possuem o mesmo conteúdo.");
elseelse
 
 System.out.println("s1 e s2 NAO possuem o mesmoSystem.out.println("s1 e s2 NAO possuem o mesmo
 
 conteúdo.");conteúdo.");
 
 
//Cria dois novos Strings //Cria dois novos Strings 
String s1 = "George"; String s1 = "George"; 
String s2 = "George";String s2 = "George";
// Nesse momento, s1==s2 é verdadeiro!// Nesse momento, s1==s2 é verdadeiro!
 
 
s1 = s1 + " Bush"; // Cria um novo string e o atribui para s1 = s1 + " Bush"; // Cria um novo string e o atribui para 
s1s1
s2 = s2 + " Bush"; // Cria um novo string e o atribui para s2 = s2 + " Bush"; // Cria um novo string e o atribui para 
s2s2
 
 
ifif (s1 == s2) (s1 == s2) 
 
 System.out.println("s1 e s2 sao os mesmos objetos.");System.out.println("s1 e s2 sao os mesmos objetos.");
elseelse
 
 System.out.println("s1 e s2 NAO sao os mesmos objetos.");System.out.println("s1 e s2 NAO sao os mesmos objetos.");
 
 
ifif (s1.equals(s2)) (s1.equals(s2)) 
 
 System.out.println("s1 e s2 possuem o mesmo conteúdo.");System.out.println("s1 e s2 possuem o mesmo conteúdo.");
elseelse
 
 System.out.println("s1 e s2 NAO possuem o mesmoSystem.out.println("s1 e s2 NAO possuem o mesmo
 
 conteúdo.");conteúdo.");
 
 
10Java Básico
Strings: Comparação e 
comprimento
� boolean equals(umString)
� boolean equalsIgnoreCase(umString)
� int length()
String a = "Sharon Stone";String a = "Sharon Stone";
String b = "sharon stone";String b = "sharon stone";
int int comprimentocomprimento = a.length(); = a.length();
boolean boolean resposta1resposta1 = a.equals(b); = a.equals(b);
boolean boolean resposta2resposta2 = a.equalsIgnoreCase(b); = a.equalsIgnoreCase(b);
boolean boolean resposta3resposta3 = b.equalsIgnoreCase(a); = b.equalsIgnoreCase(a);
Qual o valor das respostas?
11Java Básico
String: tratamento
� String toLowerCase()
� String toUpperCase()
� String trim()
String x = " Bom Dia! ";String x = " Bom Dia! ";
String y = x.toUpperCase();String y = x.toUpperCase();
String z = x.toLowerCase();String z = x.toLowerCase();
String w = x.trim();String w = x.trim();
System.out.println(y);System.out.println(y);
System.out.println(z);System.out.println(z);
System.out.println(w);System.out.println(w);
 
 BOM DIA! BOM DIA! 
 
 bom dia!bom dia!
 
 Bom Dia!Bom Dia!
12Java Básico
Strings: índices e substrings
� int indexOf(umString)
� String substring(int indiceInicio, int indiceFinal)
� char charAt(int indice)
String x = "Pernambuco";String x = "Pernambuco";
String y = x.substring(0,5);String y = x.substring(0,5);
String z = x.substring(6,10);String z = x.substring(6,10);
int indice = x.indexOf("na");int indice = x.indexOf("na");
char letra = x.charAt(5);char letra = x.charAt(5);
System.out.println(x); System.out.println(y);System.out.println(x); System.out.println(y);
System.out.println(z); System.out.println(indice);System.out.println(z); System.out.println(indice);
System.out.println(letra);System.out.println(letra);
Qual é a saída?
Retorna um substring de 
indiceInicio até indiceFinal-1
Índices em Java 
começam a partir de 0
13Java Básico
Arrays
14Java Básico
Arrays
� São tipos especiais de Java. Objetos 
especiais
� Arrays também são tipos referência
� Todos os elementos de um array são do 
mesmo tipo
� Arrays têm tamanho fixo depois de criados
15Java Básico
Declaração e criação de arrays
int[] a = new int[100];int[] a = new int[100];
String[] nomes = new String[200];String[] nomes = new String[200];
int[] a;int[] a;
double[] x;double[] x;
Cliente[] clientes; Cliente[] clientes; 
Primeiro item: a[0]
Último item: a[99]
16Java Básico
Inicialização de Arrays
int[] primosPequenos = {2, 3, 5, 7, 11, int[] primosPequenos = {2, 3, 5, 7, 11, 
13};13};
String[] cores = {"Vermelho", "Azul", "Amarelo"};String[] cores = {"Vermelho", "Azul", "Amarelo"};
doubledouble[][] salarios = new double[5]; salarios = new double[5];
for (int i = 0; i<5; i++) {for (int i = 0; i<5; i++) {
 
 salarios[i] = i * 1000;salarios[i] = i * 1000;
}}
17Java Básico
Arrays multidimensionais
int[][] matriz;int[][] matriz;
int[][] matriz = new int[10][5];int[][] matriz = new int[10][5];
for (int i=0; i<10; i++)for (int i=0; i<10; i++)
 
 for (int j=0; j<5; j++)for (int j=0; j<5; j++)
 
 matriz[i][j] = 100;matriz[i][j] = 100;
long[][] x = { {0,1}, {2,3}, {4,5} };long[][] x = { {0,1}, {2,3}, {4,5} };
Cria um array
de 3 por 2
x[0][0] x[0][1]
x[2][0]
Declaração não 
especifica dimensões
Cria e inicializa 
um array bidimensional
18Java Básico
Acesso inválido
� Se é feito acesso a um elemento indefinido 
de um array, é gerada uma exceção:
-IndexOutOfBoundsExceptionIndexOutOfBoundsException
String nomes[] = {"José", "João", "Maria"};String nomes[] = {"José", "João", "Maria"};
System.out.println(nomes[5]);System.out.println(nomes[5]);
Gera um erro em 
tempo de execução
19Java BásicoColeção de contas com array
� Uma classe que guarda contas num array de 
contas 
− Repositorio ou conjunto de contas
� Métodos para inserção, procura, remoção e 
atualização dos objetos
20Java Básico
RepositorioContasArray
public class RepositorioContasArray {
private Conta[] contas;
private int indice;
private final static int tamCache = 100;
public RepositorioContasArray() {
 indice = 0;
 contas = new Conta[tamCache];
}
 public void inserir(Conta c){
 contas[indice] = c;
 indice = indice + 1;
}
 ...
21Java Básico
RepositorioContasArray
private int procurarIndice(String num) {
 int i = 0;
 int ind = -1;
 boolean achou = false;
 while ((i < indice) && !achou) {
 if ((contas[i].getNumero()).equals(num)) {
ind = i;
achou = true;
 }
 i = i + 1;
 }
 return ind;
}
22Java Básico
RepositorioContasArray
public boolean existe(String num) {
 boolean resp = false;
 int i = this.procurarIndice(num);
 if(i != -1){
resp = true;
 }
 return resp;
}
 
23Java Básico
RepositorioContasArray
public void atualizar(Conta c){
 int i = procurarIndice(c.getNumero());
 if (i != -1) {
 contas[i] = c;
 } else {
 System.out.printlnSystem.out.println("Conta nao encontrada");
 }
}
public Conta procurar(String num){
 Conta c = null;
 if (existe(num)) {
 int i = this.procurarIndice(num);
 c = contas[i];
 } else {
 System.out.printlnSystem.out.println("Conta nao encontrada");
 }
 return c;
}
 
24Java Básico
RepositorioContasArray
public void remover(String num){
 if (existe(num)) {
 int i = this.procurarIndice(num);
 contas[i] = contas[indice - 1];
 contas[indice - 1] = null;
 indice = indice - 1;
 } else {
 System.out.printlnSystem.out.println("Conta nao encontrada");
 }
}
 
 
Arquitetura em camadasArquitetura em Camadas:
Uma abordagem para 
estruturação de aplicações
 
Benefícios
● Modularidade:
● Dividir para conquistar
● Separação de conceitos 
– Coesão
– Melhor estruturação do sistema
– Melhor entendimento
● Reusabilidade
● Extensibilidade
● Facilidade de manutenção:
● Custos de manutenção representam em média 70% do custo 
total do software
● Mudanças em uma camada não afetam as outras, desde que 
as interfaces sejam preservadas (plug and play)
 
 
Benefícios
● Uma mesma versão de uma camada 
trabalhando com diferentes versões de 
outra camada
● várias GUIs para a mesma aplicação
● vários mecanismos de persistência 
suportados pela mesma aplicação
● várias plataformas de distribuição para 
acesso a uma mesma aplicação
 
Características
● Propósito geral de cada camada: 
● Fornecer suporte para alguma camada 
superior
● Abstrair as camadas superiores de detalhes 
específicos
● Propósito específico de cada camada:
● Preocupar-se com os detalhes específicos 
que serão ‘escondidos’ das camadas 
superiores
 
Estrutura de Camadas
Interface com o usuário
(GUI)
Comunicação
Negócio
Dados
 
Camada de negócios
● Responsável por implementar a lógica do 
negócio
● Classes do domínio da aplicação
● classes básicas do negócio
● coleções de negócio
● fachada do sistema
 
Classes básicas do negócio
● Representam conceitos básicos do 
domínio da aplicação
Conta Cliente
 
Coleções de negócio
● Representam conjuntos de objetos
● Responsáveis pela inclusão, remoção, atualização e 
consultas a instâncias das classes básicas
● Encapsulam as verificações e validações relativas ao 
negócio
● Utilizam coleções de dados como suporte para o 
armazenamento de objetos
Conta CadastroContas
 
Fachada do sistema
● Segue o padrão de projeto Facade
● Representa os serviços oferecidos pelo 
sistema
● Centraliza as instâncias das coleções de 
negócio
● Realiza críticas de restrição de integridade
● Gerencia as transações do sistema
Fachada
CadastroContas CadastroClientes
 
Camada de dados
● Responsável pela manipulação da estrutura de 
armazenamento dos dados
● Isola o resto do sistema do mecanismo de persistência 
utilizado
● Classes de coleções de dados
● Executam inclusões, remoções, atualizações e consultas no 
meio de armazenamento usado
CadastroContas
RepositórioContasBDR
RepositórioContasBDOO
RepositórioContasArquivo
Conta
Vamos adicionar 
uma interface 
depois
 
ClienteConta
CadastroContas CadastroClientes
GUI
Fachada
RepositorioContasArray RepositorioClientesArray
GUI
NEGÓCIO
DADOS
Visão geral da arquitetura
 
Exemplos de código
(sem interface)
 
public class CadastroContas {
 private RepositorioContasArray contas;
 public CadastroContas(RepositorioContasArray r) {
 this.contas = r;
 }
 public void atualizar(Conta c) {
 contas.atualizar(c);
 }
 public void cadastrar(Conta c){
 if (!contas.existe(c.getNumero())) {
 contas.inserir(c);
 } else { 
 System.out.printlnSystem.out.println("Conta já cadastrada");
 }
 }
Coleção de Negócio
 
 public void creditar(String n, double v) {
 Conta c = contas.procurar(n);
 c.creditar(v);
 }
 public void debitar(String n, double v) {
 Conta c = contas.procurar(n);
 c.debitar(v);
 }
 public void descadastrar(String n) {
 contas.remover(n);
 }
Coleção de Negócio
 
 public Conta procurar(String n) {
 return contas.procurar(n);
 }
 public void transferir(String origem, 
 String destino, 
 double val) {
 Conta o = contas.procurar(origem);
 Conta d = contas.procurar(destino);
 o.transferir(d, val);
 }
}
Coleção de Negócio
 
Fachada
public class Fachada {
 private static Fachada instancia;
 private CadastroContas contas;
 private CadastroClientes clientes;
 
 public static Fachada obterInstancia() {
 if (instancia == null) {
 instancia = new Fachada();
 }
 return instancia;
 }
 private Fachada() {
 initCadastros();
 }
 
 
Fachada
private void initCadastros() {
 RepositorioContasArray rep = 
 new RepositorioContasArray();
 contas = new CadastroContas(rep);
 RepositorioClientesArray repClientes = 
 new RepositorioClientesArray();
 clientes = new CadastroClientes(repClientes);
}
 
Fachada
//metodos para manipular clientes
 public void atualizar (Cliente c) {
 clientes.atualizar(c);
 }
 public Cliente procurarCliente(String cpf) {
 return clientes.procurar(cpf);
 }
 public void cadastrar(Cliente c) {
 clientes.cadastrar(c);
 }
 public void descadastrarCliente(String cpf) {
 clientes.remover(cpf);
 }
 
Fachada
//metodos para manipular contas
 public void atualizar (Conta c) {
 contas.atualizar(c);
 }
 public Conta procurarConta(String n) {
 return contas.procurar(n);
 }
 public void cadastrar(Conta c) {
 Cliente cli = c.getCliente();
 if (cli != null) {
 clientes.procurar(cli.getCpf());
 contas.cadastrar(c);
 } else {
 System.out.printlnSystem.out.println("cliente nulo");
 }
 }
 
Fachada
 public void removerConta(String n) {
 contas.remover(n);
 }
 public void creditar(String n, double v) {
 contas.creditar(n, v);
 }
 public void debitar(String n, double v) {
 contas.debitar(n, v);
 }
 public void transferir(String origem, 
String destino, double val) { 
 contas.transferir(origem, destino, val);
 }
}
154Java Básico
Herança, polimorfismo 
e ligação dinâmica
155Java Básico
 Número Saldo
 21.342-7 875,32
creditar
debitardebitar
renderJurosrenderJuros
Objeto poupança
156Java Básico
creditar(20.00)
 Número Saldo
 21.342-7 875,32creditar
debitardebitar
renderJurosrenderJuros
 Número Saldo
 21.342-7 895,32
creditar
debitardebitar
renderJurosrenderJuros
Estados do Objeto Poupança
157Java Básico
renderJuros(0.01)
 Número Saldo
 21.342-7 875,32
creditar
debitardebitar
renderJurosrenderJuros
 Número Saldo
 21.342-7 884,07
creditar
debitardebitar
renderJurosrenderJuros
Estados do Objeto Poupança
158Java Básico
class Conta {
 public Conta(String n) {} 
 public void creditar(double valor) {}
 public void debitar(double valor) {}
 public String getNumero() {}
 public double getSaldo() {}
}
Classe de Contas: Assinatura
159Java Básico
class Poupanca {
 public Poupanca(String n) {} 
 public void creditar(double valor) {}
 public void debitar(double valor) {}
 public String getNumero() {}
 public double getSaldo() {}
 public void renderJuros(double t) {}
}
Classe de Poupanças: Assinatura
160Java Básico
class Poupanca {
 private String numero;
 private double saldo;
 
 void creditar(double valor) {
 saldo = saldo + valor;
 } 
 String getNumero() {
 return numero;
 }
 ...
 void renderJuros(double t) {
 this.creditar(saldo * t);
 }
}
Classe de Poupanças: Descrição
161Java Básico
� Duplicação desnecessária de código:
− A definição de Poupanca é uma simples 
extensão da definição de Conta
− Clientes de Conta que precisam trabalhar 
também com Poupanca terão que ter código 
especial para manipular poupanças
� Falta refletir relação entre tipos do “mundo 
real”: uma poupança também é uma conta!
Problemas
162Java Básico
� O mecanismo de herança permite reutilizar 
o código de classes existentes
� Apenas novos atributos ou métodos precisam 
ser definidos
� Herança introduz os conceitos de:
− Superclasse e Subclasse
− Redefinição de Métodos
− Polimorfismo de subtipo
Herança
163Java Básico
class Poupanca class Poupanca extendsextends Conta { Conta {
 
 
 
 public Poupanca (String numpublic Poupanca (String num, Cliente c, Cliente c) {) {
 
 super(numsuper(num, c, c););
 
 }}
 
 public void renderJuros(double taxa) { public void renderJuros(double taxa) { 
 
 double saldoAtual = getSaldo();double saldoAtual = getSaldo();
 
 creditar(saldoAtual * taxa);creditar(saldoAtual * taxa);
 
 }}
 
 //E nada mais!//E nada mais!
}}
subclasse subclasse extendsextends superclasse superclasse
Nova classe Poupança 
(com herança)
164Java Básico
� Reuso de Código:
− tudo que a superclasse tem, a subclasse também 
tem
− o desenvolvimento pode se basear em o que já 
está pronto
� Extensibilidade:
− algumas operações da superclasse podem ser 
redefinidas na subclasse
Herança
165Java Básico
� Comportamento: 
− objetos da subclasse comportam-se como os 
objetos da superclasse 
� Princípio da Substituição: 
− objetos da subclasse podem ser usados no lugar 
de objetos da superclasse
− Toda Poupanca é uma Conta mas nem toda conta 
é uma Poupança
Herança
166Java Básico
......
Poupanca p;Poupanca p;
p = new Poupanca(“21.342-7”);p = new Poupanca(“21.342-7”);
p.creditar(500.87);p.creditar(500.87);
p.debitar(45.00);p.debitar(45.00);
System.out.println(p.getSaldo());System.out.println(p.getSaldo());
......
......
Conta c;Conta c;
c = new Poupanca(“21.342-7”);c = new Poupanca(“21.342-7”);
c.creditar(500.87);c.creditar(500.87);
c.debitar(45.00);c.debitar(45.00);
System.out.println(c.getSaldo());System.out.println(c.getSaldo());
......
Os métodos 
creditar e 
debitar são 
herdados de 
Conta 
Uma poupança
pode ser usada 
no lugar de uma 
conta
Princípio da substituição
167Java Básico
� Nos contextos onde contas são usadas pode-
se usar poupanças
− Onde Conta é aceita, Poupanca também será
� Nos contextos onde poupanças são usadas 
pode-se usar contas com o uso explícito de 
casts 
Substituição e Casts
168Java Básico
......
Conta c;Conta c;
c = new Poupanca(“21.342-7”); c = new Poupanca(“21.342-7”); 
... ... 
(((Poupanca)(Poupanca) c).renderJuros(0.01); c).renderJuros(0.01);
System.out.println(c.getSaldo());System.out.println(c.getSaldo());
......
cast
renderJuros só está disponível 
na classe Poupança. Por isso o 
cast para Poupança é essencial.
Casts
169Java Básico
......
Conta c = procura("123.45-8");Conta c = procura("123.45-8");
if (c if (c instanceofinstanceof Poupanca) Poupanca) 
 
 ((Poupanca) c).renderJuros(0.01);((Poupanca) c).renderJuros(0.01);
elseelse
 
 System.out.print(“Poupança inexistente!”)System.out.print(“Poupança inexistente!”)
......
• O operador instanceof verifica a classe de um 
objeto (retorna true ou false)
• Recomenda-se o uso de instanceof antes de se 
realizar um cast para evitar erros
instanceof
170Java Básico
Herança e a classe Object
� Toda classe que você define tem uma superclasse
� Se não for usado "extends", a classe estende a 
classe "Object" de Java.
� A classe Object é a única classe de Java que não 
estende outra classe
class Cliente class Cliente extends Objectextends Object {} {}
class Cliente {}class Cliente {}
São equivalentes!
171Java Básico
Construtores e subclasses
class ContaBonificada class ContaBonificada extendsextends Conta { Conta {
 
 private double bonus;private double bonus;
 
 ......
 
 public contaBonificada(String num,Cliente c) {public contaBonificada(String num,Cliente c) {
 
 supersuper(num,c);(num,c);
 
 }}
}}
super chama o construtor da superclasse
se super não for chamado, 
o compilador acrescenta 
uma chamada ao construtor 
default: super()
se não existir um 
construtor default na 
superclasse, haverá 
um erro de compilação
172Java Básico
Overriding
173Java Básico
 Número Saldo
 21.342-7 875,32
Bônus
11,80
creditar
debitardebitar
renderBonusrenderBonus
Objeto Conta Bonificada
174Java Básico
creditar(20.0)
 Número Saldo
 21.342-7 875,32
Bônus
11,80
creditar
debitardebitar
renderBonusrenderBonus
 Número Saldo
 21.342-7 895,32
Bônus
12.00
creditar
debitardebitar
renderBonusrenderBonus
Estados de uma Conta 
Bonificada
175Java Básico
Estados de uma Conta 
Bonificada
renderBonus()
 Número Saldo
 21.342-7 875,32
Bônus
11,80
creditar
debitardebitar
 Número Saldo
 21.342-7 887,12
Bônus
0,00
creditar
debitardebitar
renderBonusrenderBonusrenderBonusrenderBonus
176Java Básico
class ContaBonificada extends Conta {class ContaBonificada extends Conta {
 
 public void renderBonus() {}public void renderBonus() {}
 
 public double getBonus() {}public double getBonus() {}
 
 public void creditar(double valor) {} public void creditar(double valor) {} 
 
 public ContaBonificada(String numpublic ContaBonificada(String num, , 
Cliente cCliente c) {}) {}
}}
Contas Bonificadas: Assinatura
177Java Básico
class ContaBonificada extends Conta {class ContaBonificada extends Conta {
 
 private double bonus; private double bonus; 
 
 
 
 public ContaBonificada(String numpublic ContaBonificada(String num, Cliente c, Cliente c) {) {
 
 super(numsuper(num,c,c););
 
 }}
 
 
 
 public void creditar(double valor) {public void creditar(double valor) {
 
 bonus = bonus + (valor * 0.01);bonus = bonus + (valor * 0.01);
 
 super.creditar(valor);super.creditar(valor);
 
 }}
 
 public void renderBonus() {public void renderBonus() {
 
 super.creditar(bonus); super.creditar(bonus); 
 
 bonus = 0;bonus = 0;
 
 }}public double getBonus() {public double getBonus() {
 
 return bonus;return bonus;
 
 }}
 
 
}}
Redefinição do
método creditar
Contas Bonificadas: Descrição
178Java Básico
public static void main(String args[]){public static void main(String args[]){
 
 ContaBonificada cb;ContaBonificada cb;
 
 cb = new ContaBonificada("21.342-7");cb = new ContaBonificada("21.342-7");
 
 cb.creditar(200.00); cb.creditar(200.00); 
 
 cb.debitar(100.00);cb.debitar(100.00);
 
 cb.renderBonus();cb.renderBonus();
 
 System.out.print(cb.getSaldo());System.out.print(cb.getSaldo());
}}
Usando Contas Bonificadas
179Java Básico
Overrinding
� Redefinição de métodos herdados da superclasse
� Para que haja a redefinição de métodos, o novo 
método deve ter a mesma assinatura (nome e 
parâmetros) que o método da super classe
� Se o nome for o mesmo, mas os parâmetros forem 
de tipos diferentes haverá overloading e não 
redefinição
� Redefinições de métodos devem preservar o 
comportamento (semântica) do método original
− a semântica diz respeito ao estado inicial e estado final do 
objeto quando da execução do método
180Java Básico
� Dois métodos com o mesmo nome e tipo: 
− qual versão do método usar?
� O método é escolhido dinamicamente (em 
tempo de execução), não estaticamente (em 
tempo de compilação)
� A escolha é baseada no tipo do objeto que 
recebe a chamada do método e não da 
variável
Polimorfismo e Ligações 
Dinâmicas
181Java Básico
......
Conta c1, c2;Conta c1, c2;
c1 = new ContaBonificada("21.342-7");c1 = new ContaBonificada("21.342-7");
c2 = new Conta("12.562-8");c2 = new Conta("12.562-8");
c1.creditar(200.00); c1.creditar(200.00); 
c2.creditar(100.00);c2.creditar(100.00);
c1.debitar(100.00);c1.debitar(100.00);
c2.debitar(60.00);c2.debitar(60.00);
(((ContaBonificada)(ContaBonificada) c1).renderBonus();c1).renderBonus();
System.out.println(c1.getSaldo());System.out.println(c1.getSaldo());
System.out.println(c2.getSaldo());System.out.println(c2.getSaldo());
......
Ligações Dinâmicas
Qual é o creditar
 chamado?
182Java Básico
Overloading
183Java Básico
Overloading
� Quando se define um método com mesmo nome, 
mas com parâmetros de tipos diferentes, não há 
redefinição e sim
overloading ou sobrecarga
� Overloading permite a definição de vários métodos 
com o mesmo nome em uma classe. O mesmo vale 
para construtores
� A escolha do método a ser executado é baseada no 
tipo dos parâmetros passados
184Java Básico
Overloading
class Formatacao {class Formatacao {
 
 static String formatar(double d, int static String formatar(double d, int 
precisao){...}precisao){...}
 
 static String formatar(double d) {...}static String formatar(double d) {...}
 
 static String formatar(int d) {...}static String formatar(int d) {...}
 
 ......
}}
Aqui o método formatar
tem três versões
 "overloaded"
//chama o primeiro método//chama o primeiro método
String s1 = formatar(10.0, 2);String s1 = formatar(10.0, 2);
//chama o terceiro método//chama o terceiro método
String s2 = formatar(99);String s2 = formatar(99);
185Java Básico
Herança e 
Modificadores
186Java Básico
Uso de protected e private em 
Herança
� Atributos e métodos com o modificador 
protected podem ser acessados na classe 
em que são declarados e nas suas subclasses
� Os membros private de uma superclasse 
são acessíveis apenas em métodos dessa 
superclasse
187Java Básico
Classes e métodos final
� Classes declaradas com o modificador final não 
podem ter subclasses
− Usado por segurança
− String são exemplos de classes final
� Um método que é declarado final não pode ser 
redefinido em uma subclasse
finalfinal class GeradorSenhas { class GeradorSenhas {
}}
208Java Básico
Classes Abstratas e Interfaces
209Java Básico
numerosaldo
21.342-7 875,32
creditarcreditar
debitardebitar
Objeto Conta Imposto
210Java Básico
 Número getSaldo
 21.342-7 875,32
Crédito
numerosaldo
 21.342-7 875,00
debitar(20)creditar
 Número getSaldo
 21.342-7 875,32
Crédito
numerosaldo
 21.342-7 854,98
creditar
debitardebitar
Desconta 0,1% sobre o saque
Estados do Objeto Conta 
Imposto
211Java Básico
Classe ContaImposto
public class ContaImposto extends public class ContaImposto extends Conta Conta {{
 
 public static final double TAXA = 0.001; //0,1%public static final double TAXA = 0.001; //0,1%
 
 
 
 public ContaImposto (String npublic ContaImposto (String n,Cliente c,Cliente c) { ) { 
 
 super (nsuper (n,c,c););
 
 } } 
 
 public void debitar(double valor){ public void debitar(double valor){ 
 
 double imposto = valor * TAXA;double imposto = valor * TAXA;
 
 super.debitar(valor + imposto)super.debitar(valor + imposto)
 
 }}
}}
212Java Básico
� Objetos da subclasse devem se comportar 
como os objetos da superclasse
� Redefinições de métodos devem preservar o 
comportamento (semântica) do método 
original
� Grande impacto sobre manutenção e 
evolução de software
Subclasses e Comportamento
213Java Básico
Subclasses e Evolução de 
Software
Conta
Poupança ContaImposto
 ContaEspecial
Não recomendado! Não 
preserva o comportamento da 
superclasse.
214Java Básico
Subclasses e Evolução de 
Software
ContaAbstrata
ContaImposto
Conta
Poupanca
ContaBonificada
SIM! ContaAbstrata 
não implementa o 
método debitar. 
Portanto, não podemos 
dizer que ContaImposto 
fere a semântica do 
supertipo.
ContaBonificada define um método para 
render bônus. O bônus só é incorporado ao 
saldo após a execução dele. O método 
creditar, portanto, respeita a definição do 
supertipo.
215Java Básico
Classes Abstratas
� Devem ser declaradas com a palavra-chave 
abstract
� Podem declarar métodos abstratos
− Métodos sem implementação
− Implementação fornecida na subclasse
� Podem declarar métodos concretos
− Métodos com implementação
216Java Básico
Definição de Classes Abstratas
� Uma classe abstrata é declarada com o modificador abstract
� Um método é definido abstrato também usando o modificado 
abstract
publicpublic abstract abstract class class Nome_da_ClasseNome_da_Classe { { 
 
 atributo1atributo1;; 
 
 atributo2atributo2;; 
 
 ......
 
 public void metodo1(){public void metodo1(){
 
 // código do método 1// código do método 1
 
 }}
 
 ......
 
 public abstract void public abstract void metodoAbstratometodoAbstrato();();
 
 
}}
publicpublic abstract abstract class class Nome_da_ClasseNome_da_Classe { { 
 
 atributo1atributo1;; 
 
 atributo2atributo2;; 
 
 ......
 
 public void metodo1(){public void metodo1(){
 
 // código do método 1// código do método 1
 
 }}
 
 ......
 
 public abstract void public abstract void metodoAbstratometodoAbstrato();();
 
 
}}
217Java Básico
public abstract class ContaAbstrata {
private String numero;
private double saldo;
private Cliente cliente;
public ContaAbstrata(String num, Cliente c) {
 numero = num;
 cliente = c;
}
public ContaAbstrata(String num, double s, Cliente c) 
{
 numero = num;
 saldo = s;
 cliente = c;
}
Definindo uma Conta abstrata
218Java Básico
public Cliente getCliente(){
 return cliente;
}
public String getNumero() {
 return numero;
}
public double getSaldo() {
 return saldo;
}
public void setCliente(Cliente cliente) {
 this.cliente = cliente;
}
public void setNumero(String num) {
 this.numero = num;