Programação Orientada a Objetos e Algoritmos em Java

Programao Orientada a
Objetos e Algoritmos em Java
Prof. Cristiano Camilo dos Santos de Almeida

Prof. Rafael Guimares Sakurai
2009
Programao Orientada a Objetos e Algoritmos em Java Universidade Metodista de So Paulo
ndice
1 - Introduo .................................................................................................................................. 6
1.1 - A Linguagem Java .................................................................................................................. 6
1.2 - Plataforma Java ....................................................................................................................... 7
1.3 - Viso geral do Java Standard Edition ..................................................................................... 8
1.4 - Java Virtual Machine .............................................................................................................. 9
1.5 - Compilando um cdigo em linha de comando ....................................................................... 9
1.6 - Linhas de comentrio em Java .............................................................................................. 11
2 - A linguagem Java ................................................................................................................... 12
2.1 - Palavras Chave...................................................................................................................... 12
2.2 - Variveis ............................................................................................................................... 12
2.3 - Tipos Primitivos.................................................................................................................... 13
2.4 - Tipos Inteiros (byte, short, int ou long) ................................................................................ 14
2.5 - Tipos Ponto Flutuante (float ou double) ............................................................................... 16
2.6 - Tipo Caractere (char) ............................................................................................................ 18
2.7 - Tipo Booleano (boolean) ...................................................................................................... 20
2.8 - Casting .................................................................................................................................. 20
2.9 - Scanner ................................................................................................................................. 22
2.10 - Operadores ............................................................................................................................ 25
2.10.1 - Operadores aritmticos .................................................................................................. 25
2.10.2 - Operadores de atribuio ............................................................................................... 31
2.10.3 - Operadores unrios ........................................................................................................ 41
2.10.4 - Operadores lgicos ........................................................................................................ 44
2.10.5 - Operadores relacionais .................................................................................................. 48
2.10.6 - Operador condicional .................................................................................................... 55
2.10.7 - Operadores bit a bit ....................................................................................................... 56
2.11 - Exerccios ............................................................................................................................. 64
3 - Estruturas de controle e repetio ................................................................................... 67
3.1 - if / else................................................................................................................................... 67
3.2 - switch .................................................................................................................................... 70
3.3 - while ..................................................................................................................................... 73
3.4 - do / while .............................................................................................................................. 75
3.5 - for .......................................................................................................................................... 76
3.6 - Enhanced for ou for-each .................................................................................................. 79
3.7 - A instruo break .................................................................................................................. 80
3.8 - A instruo continue ............................................................................................................. 81
Exerccios ............................................................................................................................................ 82
4 - Classe e Objeto........................................................................................................................ 85
4.1 - Objetos .................................................................................................................................. 87
4.2 - Utilizando os atributos da classe........................................................................................... 89
4.3 - Mtodos com retorno de valor .............................................................................................. 91
4.4 - Mtodos com recebimento de parmetro .............................................................................. 94
4.5 - Mtodos construtores ............................................................................................................ 97
Criado por Cristiano Camilo dos Santos de Almeida e Rafael Guimares Sakurai -2-
4.6 - Exerccios ........................................................................................................................... 101

5 - A Classe java.lang.String ................................................................................................... 103
5.1 - Converso para String (texto) ............................................................................................. 105
5.2 - Converso de String para tipos Primitivos ......................................................................... 105
5.3 - Recebendo Strings como parmetro diretamente no mtodo main .................................... 106
5.4 - Exerccios ........................................................................................................................... 109
6 - Identidade e Igualdade ....................................................................................................... 110
7 - Assinatura de Mtodos ....................................................................................................... 115
7.1 - Troca de Mensagens ........................................................................................................... 119
7.2 - Varargs ................................................................................................................................ 122
7.3 - Exerccios ........................................................................................................................... 126
8 - Plain Old Java Object POJO.......................................................................................... 129
9 - Pacotes ..................................................................................................................................... 132
9.1 - Exerccios ........................................................................................................................... 136
10 - Visibilidade ......................................................................................................................... 137
10.1 - Modificador de acesso: private ........................................................................................... 137
10.2 - Modificador de acesso: defaut ou package ......................................................................... 139
10.3 - Modificador de acesso: protected ....................................................................................... 141
10.4 - Modificador de acesso: public ............................................................................................ 144
10.5 - Exerccios ........................................................................................................................... 145
11 - Encapsulamento ............................................................................................................... 146
11.1 - Exerccios ........................................................................................................................... 154
12 - Interfaces ............................................................................................................................. 157
12.1 - Exerccios de Interface ....................................................................................................... 167
13 - Herana................................................................................................................................ 172
13.1 - Exercicios ........................................................................................................................... 180
14 - Classes Abstratas ............................................................................................................. 183
14.1 - Exerccios ........................................................................................................................... 189
15 - Excees em Java ............................................................................................................. 191
15.1 - Bloco try / catch .................................................................................................................. 192
15.2 - Palavra chave throw ............................................................................................................ 195
15.3 - Bloco finnaly ...................................................................................................................... 196
15.4 - Palavra chave throws .......................................................................................................... 198
15.5 - Hierarquia das Exceptions .................................................................................................. 200
15.6 - Checked Exceptions............................................................................................................ 200
15.7 - Unchecked Exceptions........................................................................................................ 201
15.8 - Errors .................................................................................................................................. 203
15.9 - Tratando mltiplas Excees .............................................................................................. 203
15.10 - Criando sua exceo........................................................................................................ 204
15.11 - Exerccios ........................................................................................................................ 206
16 - Polimorfismo....................................................................................................................... 210
16.1 - Casting de objetos ............................................................................................................... 218
16.2 - Exerccios ........................................................................................................................... 220
17 - Conexo com bancos de dados - J.D.B.C. ............................................................... 223
17.1 - Consulta de dados ............................................................................................................... 227
17.2 - Manipulao de dados ........................................................................................................ 229
17.3 - Relao de algumas bases de dados.................................................................................... 231

17.4 - Exemplo de aplicao C.R.U.D. (Create Read Update Delete).......................................... 231
17.5 - Exerccios ........................................................................................................................... 242
18 - Interfaces grficas - SWING .......................................................................................... 243
18.1 - Utilizando o JFrame............................................................................................................ 256
18.2 - Utilizando JTextField ......................................................................................................... 257
18.3 - Utilizando JButton .............................................................................................................. 259
18.4 - Utilizando o JLabel ............................................................................................................. 261
18.5 - Utilizando o JComboBox ................................................................................................... 263
18.6 - Imagens no Swing............................................................................................................... 264
18.7 - Exemplo de aplicao desktop............................................................................................ 267
18.8 - JFileChooser ....................................................................................................................... 272
18.9 - Utilizando o JMenuBar, JMenu e JMenuItem .................................................................... 276
18.10 - Exerccios ........................................................................................................................ 289
18.11 - Exemplos de aplicaes Swing ....................................................................................... 290
18.11.1 - Exemplo de tratamento de exceo usando Swing .................................................. 290
18.11.2 - Exemplo de aplicao C.R.U.D. com exibio em tela ........................................... 293
19 - Leitura de arquivos .......................................................................................................... 308
19.1 - Exemplo de leitura de arquivo ............................................................................................ 308
19.2 - Streams de caracteres .......................................................................................................... 312
19.2.1 - java.io.Reader .............................................................................................................. 312
19.2.2 - java.io.Writer ............................................................................................................... 314
19.3 - Streams de bytes ................................................................................................................. 316
19.3.1 - java.io.InputStream ..................................................................................................... 316
19.3.2 - java.io.OutputStream ................................................................................................... 316
19.4 - Serializao de objetos ....................................................................................................... 317
19.5 - Exerccios ........................................................................................................................... 321
20 - Recursos da Linguagem Java ....................................................................................... 323
20.1 - Arrays ou Vetores em Java ................................................................................................. 323
20.1.1 - Declarao do vetor ..................................................................................................... 323
20.1.2 - Inicializao de dados do vetor ................................................................................... 324
20.1.3 - Acesso aos elementos do vetor.................................................................................... 325
20.1.4 - Um pouco sobre a classe Arrays ................................................................................. 326
20.2 - Trabalhando com constantes............................................................................................... 326
20.3 - Enums ................................................................................................................................. 327
20.3.1 - Justificativas do uso de Enums a constantes ............................................................... 327
20.3.2 - Como criar uma Enum ................................................................................................ 329
21 - Recursividade..................................................................................................................... 333
21.1 - Exerccios ........................................................................................................................... 350
22 - Bubble Sort ......................................................................................................................... 351
22.1 - Execuo do algoritmo de Bubble Sort .............................................................................. 351
22.2 - Implementao do Bubble Sort .......................................................................................... 352
22.3 - Uma forma melhorada do Bubble Sort ............................................................................... 353
22.4 - Exemplo de ordenao de vetor de objetos ........................................................................ 354
22.5 - Exerccios ........................................................................................................................... 358
23 - Merge Sort ........................................................................................................................... 359
23.1 - Fluxo de execuo do Merge Sort ...................................................................................... 359

23.2 - Implementao do Merge Sort iterativo ............................................................................. 364
23.3 - Exemplo de Merge Sort usando recurso ........................................................................... 368
23.4 - Exemplo de Merge Sort com vetor de objetos.................................................................... 370
23.5 - Exerccios ........................................................................................................................... 374
24 - Quick Sort ........................................................................................................................... 375
24.1 - Conceitos do QuickSort ...................................................................................................... 375
24.2 - QuickSort in-place .............................................................................................................. 376
24.3 - Implementao do QuickSort in-place em Java ................................................................. 380
24.4 - Exerccios ........................................................................................................................... 384
25 - Pesquisa sequencial ......................................................................................................... 385
25.1 - Implementao do algoritmo de Pesquisa Seqencial ........................................................ 387
25.2 - Utilizando pesquisa seqencial com objetos ...................................................................... 388
25.3 - Outra forma de programar a pesquisa seqencial ............................................................... 389
26 - Pesquisa Binria ............................................................................................................... 390
26.1 - Implementao do algoritmo de Pesquisa Binria.............................................................. 392
26.2 - Pesquisa Binria utilizando objetos .................................................................................... 394
26.3 - Exerccios ........................................................................................................................... 397
27 - Collection............................................................................................................................. 398
27.1 - Um pouco sobre Generics ................................................................................................... 401
27.2 - Exerccios ........................................................................................................................... 402
Apndice A Boas prticas .......................................................................................................... 403
Apndice B Javadoc .................................................................................................................... 407
Apndice C Instalando e Configurando o Java .................................................................. 413
Apndice D Comandos para MySQL ...................................................................................... 426
Apndice E Primeira aplicao no NetBeans ...................................................................... 429
Bibliografia ........................................................................................................................................ 436
1- Introduo
1.1 - A Linguagem Java
A Linguagem JAVA surgiu a partir de uma pesquisa financiada pela Sun Microsystems
em 1991, iniciada sob o codinome de projeto Green.
Prottipo Star 7 [PROJECT GREEN]
Com o intuito de se tornar uma linguagem para dispositivos inteligentes destinados ao

usurio final e com a premissa de ser uma linguagem prxima as linguagem C e C++ e que
pudesse ser executado em diversos hardwares.
A princpio, o projeto no teve bons resultados devido lentido do crescimento da
rea de dispositivos eletrnicos inteligentes, porm com a grande revoluo da World Wide
Web em 1993, logo se notou o potencial da linguagem para gerao de contedo dinmico, o
que deu nova fora ao projeto.
Inicialmente Java foi batizada de Oak por seu criador (James Gosling), tempos mais
tarde, descobriu-se que j existia uma linguagem de programao chamada Oak. Com isso,
em uma visita da equipe de desenvolvimento a uma cafeteria local, o nome Java surgiu
(nome do caf) e logo foi denominada a linguagem.
Em maro de 1995 foi anunciado no evento SunWorld a tecnologia Java 1.0,

inicialmente o foco principal da tecnologia utilizado para divulgao foram os Applets,
pequenas aplicaes que poderiam ser executadas via web atravs de um browser.
Em 1998 foi lanado a verso 1.2 da linguagem Java, est nova verso trouxe uma
quantidade muito grande de novas funcionalidades, essa alterao foi to grande que a
pessoa do marketing comeou a chamar de Java 2.
As verses 1.3 e 1.4 continuaram sendo chamado de Java 2, pois houveram
alteraes e melhorias na linguagem mas no to grandes como na verso 1.2.
Na verso 1.5 lanada em 2004 o pessoal resolveu mudar novamente chamando de
Java 5 codinome Tiger, a partir desta verso foi padronizado as novas atualizaes e a
cada 10 updates ser lanado uma nova verso, ou seja, depois do Java 5 update 10, foi
lanado em 2006 o Java 6 codinome Mustang.
Atualmente o Java est na verso 6 update 10, e a verso 7 tem o codinome
Dolphin.
Java tambm uma linguagem Open Source e no possui um nico dono, todas
novas atualizaes da linguagem so feitas atravs da JCP (Java Community Process), a
JCP formada por diversas empresas.
1.2 - Plataforma Java
Atualmente possumos na linguagem Java os mais diferentes seguimentos, desde o

desenvolvimento de aplicaes console, desktop, at aplicaes Web e por fim os
dispositivos portteis, tais como celulares e pagers.
Plataforma Java [DEVMEDIA]
Java Standard Edition (Java SE)

Este pacote responsvel pelas APIs principais da linguagem Java, a partir
deste pacote podemos criar aplicaes console e desktop, utilizar conexo com banco
de dados, leitura e escrita de arquivos, comunicao atravs de rede de

computadores, etc.
Java Enterprise Edition (Java EE)

Este pacote possui tudo que o Java SE tem e adiciona as APIs principais para
desenvolvimento de aplicaes web, podemos criar componentes distribudos, criao
de paginas web dinmicas, utilizao de filas de mensageria, etc.
Java Micro Edition (Java ME)

Este um pacote mais compacto utilizado para desenvolvimento de aplicaes
moveis como celulares e pagers, como normalmente utilizado em hardwares de
pequeno porte, possui uma quantidade mais limitada de funcionalidades.
1.3 - Viso geral do Java Standard Edition
APIs utilizadas dentro da plataforma Java SE [JAVA SE]
H dois principais produtos dentro da plataforma Java SE: Java Runtime Environment
(JRE) e Java Development Kit (JDK).
- O JRE fornece a Java Virtual Machine, bibliotecas e outros componentes para
executar aplicaes escritas em Java.
- O JDK contm tudo que tem na JRE, mais ferramentas adicionais para desenvolver
(compilar e debugar) aplicaes feitas em Java.
1.4 - Java Virtual Machine
A Java Virtual Machine uma maquina imaginaria que implementada atravs da

emulao em software, existe uma JVM diferente para cada Sistema Operacional (SO) e
uma vez que sua aplicao criada, a mesma pode ser executada em diversos SO atravs
da JVM sem ter que ser recompilado.
O cdigo que executado pela JVM so os bytecodes, quando um arquivo .java
criado, o mesmo precisa ser compilado para .class essa compilao converte os cdigos
Java para bytecodes e a JVM se encarrega de executar os bytecodes e fazer a integrao
com o SO.
Fases da programao Java:
1.5 - Compilando um cdigo em linha de comando
Durante o desenvolvimento de aplicaes utilizando a linguagem Java, precisamos criar

arquivos com a extenso .java.
Vamos utilizar o seguinte exemplo, pertencente a um arquivo chamado
PrimeiraClasse.java:
Depois de criado este arquivo, acessando a linha de comando iremos executar o

seguinte comando para compilar a classe PrimeiraClasse.java:
javac PrimeiraClasse.java
A aplicao javac responsvel por compilar o arquivo .java gerando o arquivo .class
de bytecode.
Aps a execuo deste comando, um arquivo com bytecode Java ser criado em
disco, com o seguinte nome: PrimeiraClasse.class.
Um ponto importante da linguagem que ele case sensitive, ou seja, a letra a em
minsculo diferente da letra A em maisculo.
Caso escrevemos o cdigo Java, como por exemplo, Public com P maisculo ou
string com o s minsculo teremos um erro de compilao e para os iniciantes na
linguagem este um dos maiores problemas encontrados durante a compilao.
Agora para executarmos nosso novo arquivo compilado Java, basta submet-lo a
mquina virtual Java, atravs do seguinte comando:
java PrimeiraClasse
Note que, apesar de no estarmos utilizando a extenso, o arquivo submetido foi o

arquivo .class. A aplicao java (utilizada na linha de comando), compe tanto o pacote da
JDK como da JRE.
Quando executamos java PrimeiraClasse o Java comea a executar os cdigos do

nosso programa, nesse caso o mtodo public static void main(String[] args) chamado. O
mtodo main o inicio de tudo, a partir da main voc pode iniciar seu programa, se preciso
pode chamar outras classes, outros mtodos, etc.
Criado por Cristiano Camilo dos Santos de Almeida e Rafael Guimares Sakurai - 10 -
1.6 - Linhas de comentrio em Java
Durante o desenvolvimento de um software muito importante escrever comentrios

explicando os cdigos fontes, pois facilita tanto o desenvolvimento do cdigo como sua
manuteno, a linguagem Java fornece trs formas diferentes de escrever comentrios:
// -> Comentrio de uma nica linha
/* Comentrio longo com mais

de uma linha */
/**
* Javadoc
* Mais informaes sobre o Javadoc no apndice B.
*/
Exemplo:
Na linha 1 at a linha 9 estamos criando um comentrio javadoc.

Na linha 12 usamos o comentrio simples de uma linha.
Na linha 15 at a linha 16 usamos o comentrio longo que pode ser utilizado por
varias linhas.
2- A linguagem Java
2.1 - Palavras Chave
Java possui algumas palavras chaves que so da linguagem e no podem ser usados
como nome de variveis, mtodos e classes.
abstract assert boolean break byte

case catch char class const
continue default do double else
enum extends final finally float
for goto if implements import
instanceof int interface long native
new package private protected public
return short static strictfp super
switch synchronized this throw throws
transient try void volatile while
Durante as aulas veremos como utilizar estas palavras chave, note que todas palavras
chaves so escritas em minsculo.
As palavras chave const e goto foram criadas, mas no possuem nenhuma
funcionalidade.
2.2 - Variveis
Uma varivel um objeto normalmente localizado na memria utilizado para

representar valores, quando declaramos uma varivel estamos associando seu nome
(identificador) ao local da memria onde est armazenado sua informao, as variveis em
Java podem ser do tipo primitivo ou objeto:
- Variveis primitivas: podem ser do tipo byte, short, int, long, float, double, char
ou boolean.
- Variveis de referncia: usada para referenciar um objeto. Quando usamos uma

varivel de referncia definimos qual o tipo do objeto ou um subtipo do tipo do objeto
(veremos isso mais para frente).
Quando declaramos uma varivel primitiva, estamos associando est a um espao na
memria que vai guardar o seu valor. No caso da varivel de referncia, podemos t-la
apontando para algum lugar vazio (null) ou para algum espao da memria que guarda os
dados de um objeto.
As variveis primitivas e de referncia so guardadas em locais diferentes da
memria. Variveis primitivas ficam em um local chamado stack e as variveis de referncia
ficam em um local chamado heap.
2.3 - Tipos Primitivos
A linguagem Java no totalmente Orientada a Objetos, e isto se deve principalmente

aos atributos do tipo primitivo, pois so tipos de dados que no representam classes, mas
sim valores bsicos.
Os tipos primitivos, assim como em vrias outras linguagens tais como o C, existem
para representar os tipos mais simples de dados, sendo eles dados numrico, booleano e
caractere. Os tipos primitivos da linguagem Java so:
Valores Possveis
Valor
Tipos Primitivo Menor Maior Padro Tamanho Exemplo
byte -128 127 0 8 bits byte ex1 = (byte)1;
short -32768 32767 0 16 bits short ex2 = (short)1;

Inteiro
int -2.147.483.648 2.147.483.647 0 32 bits int ex3 = 1;
long -9.223.372.036.854.770.000 9.223.372.036.854.770.000 0 64 bits long ex4 = 1l;
float -1,4024E-37 3.40282347E + 38 0 32 bits float ex5 = 5.50f;

Ponto
Flutuante double ex6 = 10.20d;
1.79769313486231570E +
double -4,94E-307 0 64 bits ou
308
double ex6 = 10.20;
char ex7 = 194;
Caractere char 0 65535 \0 16 bits ou
char ex8 = 'a';
Booleano boolean false true false 1 bit boolean ex9 = true;
importante lembrar que na linguagem Java, os Arrays e Strings so Classes

(veremos isso mais adiante).
2.4 - Tipos Inteiros (byte, short, int ou long)
Tipos inteiros trabalham apenas com nmeros inteiros, positivos ou negativos. Os

valores podem ser representados nas bases octal, decimal e hexadecimal.
Inteiro em octal
Qualquer valor escrito utilizando nmeros de 0 a 7 comeando com 0 um valor na
base octal, exemplo:
short s = 010; // Equivale ao valor 8 em decimal.

int i = 025; // Equivale ao valor 21 em decimal.
Inteiro em decimal
Qualquer valor escrito utilizando nmeros de 0 a 9 um valor decimal, este o tipo de
representao mais comum uma vez que utilizada no dia a dia, exemplo:
int i = 9;
long b = 9871342132;
Inteiro em hexadecimal
Qualquer valor escrito utilizando nmeros de 0 a 9 e A a F comeando com 0x ou 0X
um valor hexadecimal, exemplo:
long a = 0xCAFE; // Equivale ao valor 51966 em decimal

int b = 0X14a3; // Equivale ao valor 5283 em decimal
Quando um precisa ser especificado como um long ele pode vir acompanhado por l ou
L depois do seu valor, exemplo:
long a = 0Xcafel;
long b = 0752L;
long c = 987654321L;
Exemplo:
Quando executamos a classe ExemploTipoPrimitivo temos a seguinte sada no

console:
2.5 - Tipos Ponto Flutuante (float ou double)
Tipos de ponto flutuante serve para representar nmeros com casas decimais, tanto
negativos quanto positivos. Todos nmeros com ponto flutuante so por padro do tipo
double, mas possvel especificar o tipo do valor durante a criao, para float utilize f ou F e
se quiser pode especificar para double usando d ou D, exemplo:
float a = 10.99f;
double b = 10.3D;
floaf c = 1.99; // Erro de compilao pois o padro do valor double.
Exemplo:
Quando executamos a classe ExemploTipoPrimitivo2 temos a seguinte sada no

console:
2.6 - Tipo Caractere (char)
O tipo caractere, como o prprio nome j diz, serve para representar um valor deste
tipo. Sua inicializao permite 2 modelos:
char a = a;
char b = 97; //Equivale a letra a
Os caracteres podem ser representados por nmeros e possuem o mesmo tamanho

que um atributo do tipo short, dessa forma podemos representar a tabela Unicode, exemplo:
char u = \u0025; //Equivale ao caracter %
OBS: O unicode no formato hexadecimal, portanto o exemplo anterior 0025

equivale a 37 na base decimal.
Exemplo:
Quando executamos a classe ExemploTipoPrimitivo3 temos a seguinte sada no

console:
2.7 - Tipo Booleano (boolean)
Tipo que representa valores lgicos true (verdadeiro) ou false (falso), exemplo:
boolean a = true;
boolean b = false;
Os palavras true, false e null representam valores bsicos e no podem ser utilizados
na declarao de atributos, mtodos ou classes.
2.8 - Casting
Na linguagem Java, possvel se atribuir o valor de um tipo de varivel a outro tipo de

varivel, porm para tal necessrio que esta operao seja apontada ao compilador. A este
apontamento damos o nome de casting.
possvel fazer converses de tipos de ponto flutuante para inteiros, e inclusive entre
o tipo caractere, porm estas converses podem ocasionar a perda de valores, quando se
molda um tipo de maior tamanho, como um double dentro de um int.
O tipo de dado boolean o nico tipo primitivo que no suporta casting.
Segue abaixo uma tabela com todos os tipos de casting possveis:
DE \ PARA byte short char int long float double
byte Implcito char Implcito Implcito Implcito Implcito

short byte char Implcito Implcito Implcito Implcito
char byte short Implcito Implcito Implcito Implcito
int byte short char Implcito Implcito Implcito
long byte short char int Implcito Implcito
float byte short char int long Implcito
double byte short char int long float
Para fazer um casting, basta sinalizar o tipo para o qual se deseja converter entre
parnteses, da seguinte forma:
float a = (float) 5.0;

Converso do doubl 5.0 para float.
int b = (int) 5.1987;

Converso de doubl para int.
float c = 100;
Converso de int para float implcito, no precisa de casting.
int d = d;
Converso de char para int implcito, no precisa de casting.
O casting ocorre implicitamente quando adiciona uma varivel de um tipo menor que o
tipo que receber esse valor.
Exemplo:
Quando executamos a classe ExemploCasting temos a seguinte sada no console:
2.9 - Scanner
Em Java temos uma classe chamada java.lang.Scanner que neste momento

utilizaremos para receber entradas do usurio via console, mas esta classe tambm pode
ser utilizada para outros fins, tais como leitura de arquivos por exemplo.
No exemplo abaixo vamos utilizar a classe Scanner para pedir que o usurio digite sua
idade, depois iremos imprimir qual foi o nmero lido:
Quando executamos a classe ExemploScanner, na linha 14 imprimimos no console a

seguinte mensagem:
Na linha 15 o programa fica esperando o usurio digitar um nmero inteiro e em

seguida apertar a tecla ENTER, para continuar a execuo:
Com o Scanner podemos ler diversos tipos de atributos, exemplo:
Quando executamos a classe ExemploScanner2 temos a seguinte sada no console:
Fazendo uma comparao com a linguagem C++ os mtodos da classe Scanner

nextInt() (L um nmero inteiro), nextDouble() (L um nmero com casa decimal do tipo
double), nextLine() (L um texto String), etc. podem ser comparados a funo cin, e o
mtodo System.out.println() pode ser comparado a funo cout.
OBS: Quando queremos ler um nmero com casa decimal via console, precisamos
digitar o numero utilizando vrgula ( , ), exemplo: 10,50. Quando criamos uma varivel dentro
do programa e definimos seu valor com casa decimal, precisamos utilizar o ponto ( . ) como
separador, exemplo: 10.50.
2.10 - Operadores
No Java existem diversos tipos de operadores alem dos que conhecemos da

matemtica, e estes operadores podem enquadrados nos seguintes tipos:
Unrio (Utiliza um operando)

Binrio (Utilizam dois operandos)
Ternrio (Utilizam trs operandos)
Os operadores so utilizados a todo o momento, por exemplo, quando queremos fazer

algum clculo, verificar alguma situao valores, atribuir um valor a uma varivel, etc.
O operando pode ser representado por um valor ou por uma varivel.
2.10.1 - Operadores aritmticos
Smbolo + chamado de adio, utilizado para somar o valor de dois operandos.
<operando1> + <operando2>
Exemplo:
Neste caso ser impresso o valor 10 que o resultado da soma de 3 + 7, ou da soma

da varivel a + varivel b.
Smbolo - chamado de subtrao, utilizado para subtrair o valor de dois operandos.
<operando1> - <operando2>
Exemplo:
Neste caso ser impresso o valor 3 que o resultado da subtrao de 5 2, ou da

subtrao da varivel a varivel b.
Smbolo * chamado de multiplicao, utilizado para multiplicar o valor de dois

operandos.
<operando1> * <operando2>
Exemplo:
Neste caso ser impresso o valor 6 que o resultado da multiplicao de 3 * 2, ou da

multiplicao da varivel a * varivel b.
Smbolo / chamado de diviso, utilizado para dividir o valor de dois operandos.
<operando1> / <operando2>
O resultado da diviso de dois operandos inteiros retorna um valor inteiro, e a diviso

tendo pelo menos um operando com casas decimais retorna um valor com casas decimais.
Exemplo:
Neste caso ser impresso o valor 1.5 que o resultado da diviso de 3.0 / 2, pois o
operando 3.0 do tipo double.
Depois ser impresso o valor 1 que o resultado da diviso da varivel a / varivel b,
note que neste caso ambos so inteiros ento o resultado da diviso um valor inteiro.
Smbolo % chamado de mdulo, utilizado para saber qual o resto da diviso de

dois operandos.
<operando1> % <operando2>
O resto da diviso de dois operandos inteiros retorna um valor inteiro, e o resto da

diviso tendo pelo menos um operando com casas decimais retorna um valor com casas
decimais.
Exemplo:
Neste caso ser impresso o valor 0.5 que o resto da diviso de 4.5 / 2, note que
neste caso um operando possui casa decimal.
Depois ser impresso o valor 2 que o resto da diviso da varivel a / varivel b,
note que neste caso ambos so inteiros ento o resultado da diviso um valor inteiro.
2.10.2 - Operadores de atribuio
Smbolo = chamado de atribuio, utilizado para atribuir o valor de um operando a

uma varivel:
<varivel> = <operando>
Exemplo:
Neste caso a varivel x possui agora o valor 25.
A operao de atribuio tambm pode receber como operando o resultado de outra

operao, exemplo:
Neste caso a varivel x possui o valor 0 que o resto da diviso de 4 por 2.
Juntando atribuio + operao
Smbolo += utilizado para atribuir a uma varivel o valor desta varivel somada ao
valor de um operando.
<varivel> += <operando>
Exemplo:
Neste caso a varivel x comea com o valor 4, depois a varivel x recebe o valor dela
somado ao valor 2, portanto a varivel x fica com o valor 6.
Smbolo -= utilizado para atribuir a uma varivel o valor desta varivel subtraindo o
<varivel> - = <operando>
Exemplo:
subtrado pelo valor 2, portanto a varivel x fica com o valor 2.
Smbolo *= utilizado para atribuir a uma varivel o valor desta varivel multiplicado
com o valor de um operando.
<varivel> *= <operando>
Exemplo:
multiplicado pelo valor 5, portanto a varivel x fica com o valor 15.
Smbolo /= utilizado para atribuir a uma varivel o valor desta varivel dividido pelo
<varivel> /= <operando>
Exemplo:
dividido pelo valor 3, portanto a varivel x fica com o valor 1.
Quando usamos o operador /= utilizando uma varivel inteira e um operando de casa

decimal, ento a diviso retorna um valor inteiro.
Caso utilize uma varivel de ponto flutuante, ento a diviso retorna um valor com
casa decimal, exemplo:
Neste caso a varivel x ter o valor 1 impresso e a varivel y ter o valor 1.3333334
impresso.
Smbolo %= utilizado para atribuir a uma varivel, o valor do resto da diviso desta
varivel por um operando.
<varivel> %= <operando>
Exemplo:
Neste caso a varivel x comea com o valor 4, depois a varivel x recebe o resto da
diviso dela pelo valor 3, portanto a varivel x fica com o valor 1.
Quando usamos o operador %= utilizando uma varivel inteira e um operando de casa

decimal, ento o resto da diviso retorna um valor inteiro.
Caso utilize uma varivel de ponto flutuante, ento o resto da diviso retorna um valor
com casa decimal, exemplo:
Neste caso a varivel x ter o valor 1 impresso e a varivel y ter o valor 0.67
impresso.
2.10.3 - Operadores unrios
Smbolo ++ utilizado para incrementar em 1 o valor de uma varivel, podendo ser

feita das seguintes formas:
++ <varivel>
Primeiro incrementa a varivel depois devolve seu valor.
<varivel> ++
Primeiro devolve o valor da varivel depois incrementa seu valor.
Exemplo:
Neste caso a varivel a e varivel b so inicializadas com 1, mas quando impresso

o valor da varivel a imprime 2 enquanto que o valor da varivel b imprime 1, e na segunda
vez que impresso ambas variveis a e b possuem o valor 2.
Smbolo -- utilizado para decrementar em 1 o valor de uma varivel, podendo ser

feita das seguintes formas:
-- <varivel>
Primeiro decrementa o valor da varivel, depois devolve seu valor.
<varivel> --
Primeiro devolve o valor da varivel, depois ela decrementada.
Exemplo:
Neste caso a varivel a e varivel b so inicializadas com 1, mas quando impresso

o valor da varivel a imprime 0 enquanto que o valor da varivel b imprime 1, e na segunda
vez que impresso ambas variveis a e b possuem o valor 0.
2.10.4 - Operadores lgicos
Os operadores lgicos aceitam apenas operando do tipo boolean.
Smbolo && chamado de E. Este operador retorna true somente se os dois

operandos forem true.
<operando1> && <operando2>
Se o valor do operando1 for false, ento o operador && no verifica o valor do

operador2, pois sabe que o resultado j false.
Tabela verdade:
Operando1 Operando2 Resultado

true true true
true false false
false true false
false false false
Exemplo:
Neste caso ser impresso false, pois a varivel a true e a varivel b false,
depois ser impresso true, pois ambas variveis a e c so true.
Smbolo || chamado de OU. Este operado retorna true caso tenha pelo menos um
operando com o valor true.
<operando1> || <operando2>
Se o valor do operando1 for true, ento o operador || no verifica o valor do

operando2, pois j sabe que o resultado true.
Tabela verdade:

true true true
true false true
false true true
false false false
Exemplo:
Neste caso ser impresso primeiro true, pois a varivel a tem o valor true, depois
ser impresso false, pois as variveis b e c so false.
Smbolo ! chamado de negao. Este operador retorna true se o operando tem o

valor false, e retorna false se o operando o valor true.
! <operando>
Tabela verdade:
Operando Resultado
false true
true false
Exemplo:
Neste caso primeiro ser impresso false, que a negao de true, depois ser
impresso true, que a negao do resultado de b || c que false.
2.10.5 - Operadores relacionais
Os resultados dos operadores relacionais so do tipo boolean.
Smbolo > chamado de maior que.
<operando1> > <operando2>
Retorna true se o valor do operando1 for maior que o valor do operando2, caso
contrario retorna false.
Exemplo:
Neste caso ser impresso true, pois o valor da varivel a maior que o valor da
varivel b.
Smbolo < chamado de menor que.
<operando1> < <operando2>
Retorna true se o valor do operando1 for menor que o valor do operando2, caso
Exemplo:
Neste caso ser impresso false, pois o valor da varivel a no menor que o valor
da varivel b.
Smbolo == chamado de igualdade.
<operando1> == <operando2>
Retorna true se o valor do operando1 for igual ao valor do operando2, caso

Exemplo:
Neste caso ser impresso true, pois o valor da varivel a igual ao valor da varivel
b.
Smbolo >= chamado de maior ou igual que.
<operando1> >= <operando2>
Retorna true se o valor do operando1 for maior ou igual que o valor do operando2,
caso contrario retorna false.
Exemplo:
Neste caso ser impresso true, pois o valor da varivel a maior que valor da
varivel b e depois ser impresso true novamente, pois o valor da varivel a igual ao valor
da varivel c.
Smbolo <= chamado de menor ou igual que.
<operando1> <= <operando2>
Retorna true se o valor do operando1 for menor ou igual que o valor do operando2,
caso contrario retorna false.
Exemplo:
Neste caso ser impresso true, pois o valor da varivel a menor ou igual ao valor
da varivel b.
Smbolo != chamado de diferente.
<operando1> != <operando2>
Retorna true se o valor do operando1 for diferente do valor do operando2, caso

Exemplo:
Neste caso ser impresso true, pois o valor da varivel a diferente do valor da
varivel b e depois ser impresso false, pois o valor da varivel b igual ao valor da
varivel c.
2.10.6 - Operador condicional
O operador condicional do tipo ternrio, pois envolve trs operandos.
Smbolo ? : utilizado para fazer uma condio if / else de forma simplificada.
<operando1> ? <operando2> : <operando3>
Se o valor do operando1 for true, ento o resultado da condicional o operando2, se

o valor do operando1 for false, ento o resultado da condicional o operando3.
Exemplo:
Neste caso a condio a != b retorna true, ento impresso o valor diferente, se o

resultado fosse false, ento seria impresso o valor igual.
2.10.7 - Operadores bit a bit
Estes operadores so chamados de bit a bit, porque os operando so comparados no

nvel dos seus bits.
Smbolo & chamado de E bit a bit.
<operando1> & <operando2>
Para este operador no importa se algum dos operando tem o valor false, ele vai
verificar todos os operandos que houver na expresso.
Exemplo:
Neste caso ser impresso o valor false, e o operador & ira comparar o valor de todas
variveis.
Se usarmos valores inteiros, por exemplo ele ira comparar cada bit, exemplo:
Neste caso ser impresso o valor 6, porque o operador & vai comparar cada bit na base
binria e depois a mesma convertida para a base decimal.
Lembrando que um inteiro tem 16bits.
Varivel a tem o valor 30.
0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0
Varivel b tem o valor 7.
0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1
Resultado tem o valor 6.
0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0
Tabela verdade:

1 1 1
1 0 0
0 1 0
0 0 0
Smbolo | chamado de OU bit a bit.
<operando1> | <operando2>
Para este operador no importa se algum dos operando tem o valor true, ele vai
verificar todos os operando que tiver na expresso.
Exemplo:
Neste caso o valor impresso ser true, e o operador | ira comparar o valor de todas
variveis.
Neste caso ser impresso o valor 31, porque o operador | vai comparar cada bit na base
0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1
0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1
Tabela verdade:

1 1 1
1 0 1
0 1 1
0 0 0
Smbolo ^ chamado de OU EXCLUSIVO bit a bit.
<operando1> ^ <operando2>
Neste caso ser impresso o valor 25, porque o operador ^ vai comparar cada bit na base
0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1
0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1
Tabela verdade:

1 1 0
1 0 1
0 1 1
0 0 0
2.11 - Exerccios
1) Qual resultado ser impresso:
a)
b)
c)
d)
e)
2) O que acontece se tentarmos compilar e executar o seguinte codigo?
1 class Teste {
2 public static void main(String args) {
3 System.out.println(args);
4 }
5 }
a) No imprime nada.
b) Erro de compilao na linha 2
c) Imprime o valor de args
d) Exceo na thread "main" java.lang.NoSuchMethodError: main
e) Erro em tempo de execuo.
1 class Soma{
2 int x, y, z;
3 public static void main (String[] args) {
4 System.out.println(x + y + z);
5 }
6 }
a) No imprime nada
b) Imprime: null
c) Imprime: 0
d) Erro de compilao
e) Erro em tempo de execuo
1 class Teste {
2 public static void main(String[] args) {
3 char a = 'a'; // 'a' = 97
4 char b = 'b'; // 'b' = 98
5
6 System.out.println(a + b + "" + b + a);
7 }
8 }
a) abba
b) 97989897
c) 195ba
d) ab195
e) 390
f) Erro de Compilao
g) Erro em tempo de execuo
3- Estruturas de controle e repetio
Estrutura de Controle
3.1 - if / else
A estrutura de controle if (se), utilizada para executar alguns comandos apenas se

sua condio for true (verdadeira). O else (seno) pode ou no acompanhar o if, mas o else
no pode ser usado sozinho, e utilizado para executar alguns comandos caso a condio
do if for false (falso).
Na linguagem Java, esta estrutura pode ser utilizada de diversas maneiras, conforme
listadas abaixo.
- Com execuo de um bloco de instrues, apenas caso a condio seja atendida:
- Com execuo de um bloco de instrues, caso a condio seja atendida, e com um

fluxo alternativo para os casos de condio no atendida:
- Com mltiplas condies:
No exemplo abaixo verificamos se o valor da varivel idade maior ou igual que 18,
caso a condio for verdadeira ento entra no bloco do if, caso contrario entra no bloco do
else.
Quando executarmos a classe ExemploIf temos a seguinte sada no console:
Dentro de um bloco { } do if / else pode ser utilizado outras variveis declaradas no

mtodo ou declarados dentro do bloco, mas estas variveis podem apenas ser utilizadas
dentro deste prprio bloco.
Exemplo:
Se tentarmos compilar a classe ExemploIf2 teremos os seguintes erros:
Neste caso criado uma varivel chamada xpto dentro do bloco do if, ento esta
varivel pode ser utilizada somente dentro do if, no pode ser usada no else e nem fora do
bloco.
OBS: Este conceito de variveis criadas dentro de blocos { } funciona para todos os
blocos.
3.2 - switch
O switch uma estrutura de seleo semelhante ao if com mltiplas selees. uma

estrutura muito fcil de utilizar e apresenta uma tima legibilidade, porem trabalha apenas
com valores constantes dos tipos primrios byte, short, int e char, tambm pode ser utilizado
com enumerations (veremos mais adiante). possvel ainda se enumerar n possveis blocos
de instruo.
Sua utilizao deve ser feita da seguinte maneira:
switch( varivel ) {
case <possvel valor da constante> :
< instrues>
break;
case <possvel valor da constante> :

< instrues>
break;
default:
< instrues>
break;
}
Cada case um caso onde os comandos dentro dele so executados se o valor dele
for o mesmo que a varivel recebida no switch.
importante lembrar que a utilizao do comando break facultativa, porem
indispensvel caso se queira que apenas aquele bloco seja executado e no todos os
demais abaixo dele.
O bloco de comandos default representa uma condio geral de execuo caso
nenhuma das anteriores tenha sido atendida, sendo a sua utilizao tambm opcional.
Segue um exemplo de utilizao do comando switch:
Neste caso ser impresso a mensagem Aluno reprovado !, pois nenhum dos
cases foi atendido, ento a estrutura default foi executada.
Estruturas de repetio
As estruturas de repetio permitem especificar um bloco de instrues que ser

executado tantas vezes, quantas especificadas pelo desenvolvedor.
3.3 - while
A estrutura while executa um bloco de instrues enquanto uma determinada condio

for verdadeira (true).
while(condio) {
< instrues >
}
Exemplo:
Neste caso sero impressos os valores de 1 a 10, e depois quando a varivel i possuir
o valor 11 a condio do while ser falso (false) e sua estrutura no mais executada.
3.4 - do / while
A estrutura do / while tem seu bloco de instrues executados pelo menos uma vez,
ento se a condio ao final das instrues for true, ento o bloco de instrues executado
novamente.
do {
< instrues >
} while(condio);
Exemplo:
Neste caso, ser pedido ao usurio digitar um nmero, e enquanto o nmero digitado
for diferente de 3, ento o bloco executado novamente.
3.5 - for
A estrutura de repetio for, trabalha da mesma forma da condio while, porm de

maneira muito mais prtica quando falamos de uma estrutura de repetio gerenciada por
contador. O for mostra-se muito mais eficiente neste ponto, pois em uma nica linha de
instruo possvel se declarar o contador, a condio de execuo e a forma de
incrementao do contador.
A estrutura for funciona da seguinte maneira:
for(<inicializao>; <condio de execuo>; <ps-instrues>) {

<< instrues >>
}
Utilizamos a rea inicializao para criar variveis ou atribuir valores para variveis j
declaradas, mas todas as variveis precisam ser do mesmo tipo, est rea executada
antes de comear a estrutura de repetio do for.
Utilizamos a rea condio de execuo para definir a lgica de parada da estrutura
de repetio for.
Utilizamos a rea ps-instrues para executar alguma ao que deve ocorrer cada
vez que as instrues dentro for forem executados.
Exemplo:
Neste caso ser impresso o valor da varivel i e informando se este valor par ou
impar.
No exemplo abaixo vamos criar duas variveis i e j na rea de inicializao e na

rea de ps-instruo vamos incrementar a varivel i e decrementar a varivel j.
Quando executarmos a classe ExemploFor2 teremos a seguinte sada no console:
3.6 - Enhanced for ou for-each
Muitas vezes o for utilizado para percorrer um array ou uma coleo de objetos,
para facilitar seu uso foi adicionado na verso 5 do Java o enhanced for.
for(<Tipo> <identificador> : <expresso>) {

<instrues>
}
Exemplo:
Neste caso o primeiro enhanced for vai percorrer um array de Strings e imprimir os
valores Altrano, Beltrano, Celtrano e Deltrano.
Depois ira percorrer uma lista de inteiros imprimindo os valores 100, 322 e 57.
OBS: As colees sero abordadas mais adiante, nesta disciplina.
3.7 - A instruo break
O comando break uma instruo de interrupo imediata de qualquer lao, seja ele
qual for e idependente de sua condio de parada ter sido atendida.
Vamos ao exemplo:
Observe que, segundo o condicional da linha 21, caso um nmero invlido seja digitado
o lao FOR iniciado na linha 20 ser abortado imediatamente devido a instruo break
existente na linha 23. Uma vez executado o cdigo acima, a seguinte sada ser projetada
caso o usurio digite o nmero 5:
3.8 - A instruo continue
O comando continue tem um comportamente semelhante ao do break porm no

interrompe completamente a execuo do lao. Este comando pode ser utilizado com
qualquer lao, porm ao invez de interroper a execuo completa do lao, ele faz com que o
lao salte para sua prxima iterao.
Vamos ao exemplo:
Note que o cdigo acima bem semelhante ao anterior, porm observe que desta vez,
ao invez de interroper o lao caso o usurio digite o nmero 5 ele ir contar de 1 at o
nmero digitado pelo usurio. Caso ele passe pelo nmero 5, conforme o condicional da
linha 21, ele ir imprimir em tela a mensagem da linha 22 e saltar o restante do cdigo e
retornar ao incio do lao na linha 20.
Exerccios
1) Escreva um programa que leia um nmero positivo inteiro e imprimir a quantidade de

dgitos que este nmero possui, exemplo:
Nmero: 13
Dgitos: 2
Nmero: 321
Dgitos: 3
2) Escreva um programa que leia um numero positivo inteiro entre 1 e 99999999999, depois
este nmero deve ser decomposto e seus dgitos devem ser somado, de forma que enquanto
o nmero tiver mais que um digito ele deve continuar sendo decomposto, exemplo:
Nmero: 59765123
Decompondo: 5 + 9 + 7 + 6 + 5 + 1 + 2 + 3
Soma dos nmeros: 38
Decompondo: 3 + 8
Soma dos nmeros: 11
Decompondo: 1 + 1
Soma dos nmeros: 2
3) Escreva um programa que leia um nmero positivo inteiro na base 10 e imprima seu valor
na base 2, exemplo:
Base10: 123
Base2: 01111011
4) Escreva um programa que leia um nmero positivo inteiro e calcule o valor do Fibonacci
desse numero.
Seqncia de Fibonacci: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89...
5) Escreva um programa que leia 10 nmeros positivos inteiros entre 1 e 20 e armazene

seus valores em um vetor. Depois informe qual o menor nmero e qual o maior nmero e a
quantidade de vezes que o menor e o maior nmero aparecem no vetor.
6) Qual a sada da compilao e execuo da classe abaixo:
Public class Teste {

public static void main(String[] args) {
int num = 2;
switch(num) {
1:
System.out.println(1);
2:
3:
4:
break;
default:
System.out.println(default);
}
}
}
a) Imprime 2
b) Imprime 234
c) Imprime 234default
d) Erro de compilao
4- Classe e Objeto
Uma classe no Java representa um modelo ou forma do mundo real que se queira
reproduzir no ambiente de desenvolvimento. Pensando desta forma muito fcil entender e
pensar sobre como se projetar um sistema com orientao a objetos.
Quando pensamos em desenvolver um sistema voltado a locao de veculos, por
exemplo, a primeira classe que vem a tona uma que possa representar a figura do carro no
seu sistema, da temos ento nossa primeira classe.
Uma classe composta basicamente de 3 itens:
Nome da Classe
o Item responsvel por identificar a classe. Este nome ser utilizado toda a vez
em que se for utilizar um objeto deste tipo. importante ressaltar a utilizao
de letra maiscula na primeira letra do nome da classe e as demais minsculas.
Caso o nome de sua classe seja composto por mais de uma palavra, coloque
sempre a primeira letra de cada palavra em letra maiscula. Isto no uma
obrigatoriedade do JAVA; apenas uma boa prtica de desenvolvimento que
visa melhorar a legibilidade do cdigo.
Ex: Carro, Pessoa, ContaCorrente, CaixaCorreio, etc.
Atributos
o So valores que possam representar as propriedades e/ou estados possveis
que os objetos desta classe podem assumir. Por conveno, costuma-se
escrever o atributo com letras minsculas, a menos que ele seja composto por
mais de uma palavra, a primeira palavra toda em minscula e as demais
comeam com a primeira letra em maisculo e o restante da palavra em
minscula.
Ex: idade, nome, listaMensagens, notaAlunoTurma, etc.
Mtodos
o So blocos de cdigo que possam representar as funcionalidades que a classe
apresentar. Assim como os atributos, costuma-se escrever o atributo com
letras minsculas, a menos que ele seja composto por mais de uma palavra.
Neste caso, a mesma regra citada nos nomes de Atributo tambm vlida.
Ex: getPessoa, consultarDadosAluno, enviarMensagemEmail, etc.
Na UML representamos uma classe da seguinte forma:
Em Java utilizamos a palavra-chave class para declararmos uma classe, no exemplo

abaixo criamos uma classe em Java chamada NovaClasse:
Note que na linha 7 utilizamos a palavra-chave class seguida do nome da classe

NovaClasse, neste momento utilize a palavra-chave public na frente da classe, mais para
frente vamos explicar o que isto significa.
Da linha 10 a 12 criamos 3 atributos, os atributos podem ser criados em qualquer lugar
do programa, mas sempre antes de serem usados.
Na linha 16 e 21 criamos dois mtodos para esta classe, mais para frente nessa aula
vamos explicar como funcionam os mtodos.
Essa mesma classe pode ser representada em UML da seguinte forma:
4.1 - Objetos
Um objeto a representao (instncia) de uma classe. Vrios objetos podem ser

criados utilizando-se a mesma classe. Basta pensarmos na Classe como uma grande forma
e no Objeto como algo que passou por essa forma, ou seja, o Objeto deve possuir as
mesmas caractersticas de sua Classe.
Na linguagem JAVA, para criarmos um novo objeto, basta utilizar a palavra-chave new
da seguinte forma:
No exemplo abaixo criamos uma classe nova chamada TesteNovaClasse, est

classe ser utilizada para criar um objeto da classe NovaClasse e chamar os mtodos
metodo1() e metodo2().
Na linha 7 utilizamos a palavra-chave class para criar a classe TesteNovaClasse.

Na linha 11 criamos um mtodo com a seguinte assinatura:
public static void main(String[] args)
OBS: a partir desse mtodo main que nosso programa Java comea a execuo.
Na linha 13 criamos uma varivel chamada novaClasse est varivel do tipo

NovaClasse, depois utilizamos a palavra-chave new seguida de NovaClasse() para
construirmos um objeto da classe NovaClasse.
Na linha 16 e 17, estamos utilizando a varivel novaClasse para chamar os mtodos
metodo1() e metodo2().
Quando executamos a classe TesteNovaClasse temos a seguinte sada no console:
4.2 - Utilizando os atributos da classe
No exemplo abaixo criamos a classe Atributo e dentro dela declaramos trs atributos
diferentes:
Na linha 10 criamos um atributo para guardar um valor inteiro do tipo int com o nome
atributo1, por enquanto utilize a palavra-chave public na declarao do atributo, nas
prximas aulas veremos o que isto significa.
Na linha 11 criamos um atributo para guardar um valor com ponto flutuante do tipo
float com o nome atributo2.
Na linha 12 criamos um atributo para guardar um valor booleano chamado atributo3.
No exemplo abaixo vamos criar um objeto da classe Atributo e atribuir valores para
as variveis, depois vamos imprimir os valores delas:
Quando executamos a classe TesteAtributo temos a seguinte sada no console:
4.3 - Mtodos com retorno de valor
Assim como j deve ter sido visto na linguagem C (em functions), os mtodos das
classes em Java tambm so capazes de retornar alguma informao decorrente de seu
processamento.
Para que seja possvel realizar o retorno do mtodo, primeiramente necessrio
declarar qual o tipo de retorno ser realizado pelo mtodo, no exemplo abaixo criamos dois
mtodos:
Note que no ponto onde at a pouco utilizvamos a palavra-chave void (que significa
vazio ou sem retorno) no retorno do mtodo, agora utilizamos a palavra-chave int. Essa
mudana na declarao significa que pretendemos que este mtodo retorne para quem o
chamou um valor do inteiro tipo int.
Porm, para que o mtodo realmente retorne algum valor, necessrio identificar qual
valor ser retornado. Para tal, faremos uso da palavra-chave return, da seguinte forma:
Com isso temos agora o metodo1() que retornar o valor do atributo1 que do tipo
int.
importante lembrar que, uma vez declarado um retorno para o mtodo, obrigatrio
que este retorno acontea. O fato de no se enviar um retorno resulta em um erro de
compilao.
No metodo2() verificamos se o atributo1 maior ou igual a 0 (zero), e retornamos a
resposta dessa verificao, ou seja, true (verdadeiro) ou false (falso).
No exemplo abaixo vamos criar um objeto da classe MetodoRetorno e vamos testar a

chamada para os mtodos metodo1() e metodo2().
Quando executamos a classe TesteMetodoRetorno temos a seguinte sada no

console:
4.4 - Mtodos com recebimento de parmetro
Na linguagem Java os mtodos tambm so capazes de receber um ou mais

parmetros que so utilizados no processamento do mtodo.
No exemplo abaixo criamos dois mtodos que recebem parmetros e utilizam esses
parmetros no processamento do mtodo:
Na linha 17 o mtodo1(int valor) recebe um parmetro inteiro do tipo int chamado

valor, e dentro do mtodo podemos utilizar este atributo valor.
Note que a declarao de um parmetro igual a declarao de um atributo na
classe, informamos seu tipo e identificador.
Se necessrio podemos declarar tantos parmetros quantos forem precisos para

execuo do mtodo. Se o parmetro recebido no mtodo for primitivo ento seu valor
recebido por copia, caso receba um objeto como parmetro seu valor recebido por
referencia.
Quando fazemos uma chamada a um mtodo com parmetros de entrada, um erro na
passagem dos tipos dos parmetros representa um erro de compilao.
Quando necessrio passar uma quantidade de parmetros muito grande ou uma
quantidade desconhecida de parmetros, isso pode ser feito atravs de um array ou
podemos usar varargs (veremos mais adiante).
A sintaxe do varargs :
tipo... identificador
Na linha 30 declaramos o mtodo metodo2(int... valores) que recebe uma

quantidade varivel de valores inteiros do tipo int.
No exemplo abaixo vamos criar um objeto da classe MetodoParametro e vamos
utilizar o metodo1(int valor) e metodo2(int... valores).
Na linha 14 criamos um atributo do tipo MetodoParametro chamado teste e depois

criamos um objeto da classe MetodoParametro.
Na linha 15 chamamos o metodo1 passando o valor 100 como parmetro.
Na linha 18, 20 e 22 chamamos o metodo2 passando valores variados para ele.
Quando executamos a classe TesteMetodoParametro temos a seguinte sada no
console:
4.5 - Mtodos construtores
Sempre quando criamos um novo objeto em Java, utilizamos sintaxe:
O que ainda no foi comentado sobre este comando a necessidade de se

referenciar o mtodo construtor daquela classe. Um mtodo construtor, como o prprio nome
j diz, responsvel pela criao do objeto daquela classe, iniciando com valores seus
atributos ou realizando outras funes que possam vir a ser necessrias. Para que um
mtodo seja considerado construtor, ele deve possuir o mesmo nome da classe,
inclusive com correspondncia entre letras maisculas e minsculas e no deve ter retorno.
Por padro, todas as classes possuem um construtor com seu nome seguindo de
parnteses (). Caso voc no declare manualmente o construtor, o compilador do
Java vai fazer isso para voc.
Vamos criar um exemplo de construtor padro que no recebe:
Neste exemplo, sempre que criarmos um objeto da classe ClasseConstrutor a frase

Criando um objeto da classe ClasseConstrutor. ser impressa na console.
No exemplo abaixo vamos criar um construtor que recebe parmetros:
Neste exemplo, para construirmos um objeto da classe ClasseConstrutor2

necessrio passar para o construtor trs parmetros: int, float e boolean. Se no passarmos
todos os parmetros ou a ordem deles estiver diferente do esperado no conseguiremos
compilar a classe.
Quando criamos um construtor que recebe parmetros, o compilador no cria

um construtor padro ClasseConstrutor2().
No exemplo abaixo vamos construir um objeto da classe ClasseConstrutor e um

objeto da classe ClasseConstrutor2.
Na linha 13 criamos um objeto da classe ClasseConstrutor chamado o construtor

sem parmetros ClasseConstrutor().
Na linha 16 criamos um objeto da classe ClasseConstrutor2 chamando o construtor

ClasseConstrutor2(int valor1, float valor2, boolean valor3) passando os trs parmetros
para ele.
Quando executamos a classe TesteConstrutor temos a seguinte sada no console:
4.6 - Exerccios
1. Crie a classe Vetor abaixo e siga as instrues nos comentrios.
/**
* Classe utilizada para representar um vetor, onde podemos
* localizar o valor do maior elemento, menor elemento e
* media dos elementos do vetor.
*
* @author <<Nome>>
*/
public class Vetor {
int[] valores;
public Vetor(int[] _valores) {

System.out.println("\nCriando um objeto da classe Vetor e inicializando o vetor de inteiros.\n");
valores = _valores;
}
public void localizarMaior() {

/* Deve imprimir o valor do maior elemento do vetor. */
}
public void localizarMenor() {

/* Deve imprimir o valor do menor elemento do vetor. */
}
public void calcularMedia() {

/* Deve imprimir a media de todos os elementos do vetor. */
}
}
Agora crie a classe TesteVetor, para testar a execuo dos mtodos:
/**
* Testa a classe Vetor.
*
* @author <<Nome>>
*/
public class TesteVetor {
public Vetor(int[] _valores) {
System.out.println("\nCriando um objeto da classe Vetor e inicializando o vetor de inteiros.\n");
valores = _valores;
}

/* 1- Crie um vetor de inteiro com 10 valores. */
/* 2- Crie um objeto da classe Vetor, passando o vetor de inteiros para o construtor. */
vetor.localizarMaior();
vetor.localizarMenor();
vetor.calcularMedia();
}
}
2. Crie uma classe que representa uma conta bancaria que possua o nmero da
conta e saldo. Est classe tambm deve executar os seguintes mtodos:
extrato (Mostra na tela o nmero e o saldo da conta)
saque (Recebe como parmetro um valor e retira este valor do saldo da conta)
deposito (recebe como parmetro um valor e adiciona este valor ao saldo da
conta)
Ao final das operaes saque e deposito, sua classe deve imprimir o nmero e o
saldo da conta.
Crie uma classe para testar os mtodos da classe conta bancaria.
3. Crie uma classe que representa uma calculadora, est calculadora deve ter os seguintes
mtodos:
soma (recebe dois nmeros e mostra o valor da soma)
subtrao (recebe dois nmeros e mostra o valor da subtrao entre eles)
diviso (recebe dois nmeros e mostra o valor da diviso entre eles)
multiplicao (recebe dois nmeros e mostra o valor da multiplicao entre eles)
resto (recebe dois nmeros e mostra o valor do resto da diviso entre esses dois
nmeros)
Crie uma classe para testar os mtodos da classe calculadora.
4. Crie uma classe Televisor. Essa classe deve possuir trs atributos:
canal (inicia em 1 e vai at 16)
volume (inicia em 0 e vai at 10)
ligado (inicia em desligado ou false)
e a seguinte lista de mtodos:

aumentarVolume() //Aumenta em 1 o volume
reduzirVolume() //Diminui em 1 o volume
subirCanal() //Aumenta em 1 o canal
descerCanal() //Diminui em 1 o canal
ligarTelevisor() //Liga a televiso
desligarTelevisor() //Desliga a televiso
mostraStatus() // dizer qual o canal, o volume e se o televisor est ligado
Nos mtodos informe se possvel realizar a operao, por exemplo, se o volume estiver
no 10 e chamar o mtodo aumentarVolume() novamente imprima uma mensagem de aviso,
etc.
Quando desligado, nosso televisor deve voltar o canal e o volume a seus valores iniciais e
no deve realizar nenhuma operao.
Crie uma classe para testar a classe Televisao.
5- A Classe java.lang.String
A classe java.lang.String utilizada para representar textos (seqncia de

caracteres), o tamanho que uma String agenta igual ao tamanho disponvel de memria.
Para criar uma String podemos utilizar qualquer uma das seguintes formas:
Para fazer concatenao de Strings podemos usar o sinal + ou usar o mtodo concat
da classe String, por exemplo:
O valor de uma String imutvel, no pode alterar seu valor, quando alteramos o valor
de uma String, estamos criando uma nova String.
Ento quando fazemos:
Estamos criando 3 Strings:

Cris
tiano
Cristiano
Alguns caracteres no podem ser simplesmente colocados dentro de uma String,

como por exemplo as aspas duplas ().Este smbolo usado para indicar o inicio e fim de
uma String.Por este motivo, caso tenhamos:
Teremos um erro de compilao, pois estamos deixando uma aspas duplas fora do
texto.
Para os caracteres que no podem ser simplesmente adicionados dentro da String,
usamos a barra invertida \ como escape de caracteres. Segue abaixo uma tabela com alguns
escapes de caracteres e o que eles representam dentro da String.
\t Tabulao horizontal
\n Nova linha
\ Aspas duplas
\ Aspas simples
\\ Barra invertida
A classe java.lang.String tem alguns mtodos para se trabalhar com os textos,

exemplo:
compareTo Compara se duas Strings so iguais. Ele retorna um nmero inteiro
sendo 0 apenas caso ambas as String sejam idnticas.
compareToIgnoreCase Compara se duas Strings so iguais sem diferenciar letras
maisculas e minsculas.
equals Verifica se uma String igual a outra. Retorna um tipo boleano.
replace Altera um caractere de uma String por outro caractere.
replaceAll Altera cada substring dentro da String com uma nova substring.
split Divide uma String em varias substrings a partir de uma dada expresso regular.
Mais mtodos da classe String podem ser encontrados em:

http://java.sun.com/javase/6/docs/api/java/lang/String.html.
Cuidado ao utilizar os mtodos da String, quando no houver uma instancia da classe

String, no caso null. Invocar um mtodo de uma referencia nula gera uma exceo
NullPointerException, um erro que ocorre em tempo de execuo, exemplo:
Este cdigo lanar uma NullPointerException, pois a String abc est vazia (null), e
est tentando invocar o mtodo equals() de um String null (excees sero abordadas).
5.1 - Converso para String (texto)
Para transformar qualquer tipo primitivo para String, basta utilizar o mtodo:
String.valueOf( <<informaes que se tornar texto>> );
Para utiliz-lo, voc deve atribuir a sada do mtodo a uma String, e preencher o
campo interno do mtodo com o valor desejado. Exemplo:
Converso de inteiro para String:
int numero = 4;
String texto = String.valueOf(numero);
Observe, que na segunda linha, a varivel do tipo inteira est sendo utilizada no
mtodo valueOf() para que a converso possa ser executada, e o resultado da converso
est sendo atribuda a String chamada texto.
O mtodo valueOf() pode converter os seguintes tipos para String:
int para String

String texto = String.valueOf(1);
long para String

String.valueOf(580l);
float para String

String.valueOf(586.5f);
double para String

String.valueOf(450.25);
boolean para String

String.valueOf(true);
char para String

String.valueOf(a);
Note que os tipos byte e short no constam nesta lista, logo, para realizar a sua
converso necessrio transformar estes tipos primeiramente em int e s ento convert-los
para String.
5.2 - Converso de String para tipos Primitivos
Assim como tratamos da manipulao de tipos de valores primitivos para String, nesta
seo falaremos sobre a converso de tipos primitivos para String.
Em Java possvel transformar qualquer String em um tipo primitivo, para tal
necessrio utilizar um dos conversores especficos de cada tipo... so eles:
String texto = 15;
String para byte

byte o = Byte.parseByte(texto);
String para short

short a = Short.parseShort(texto);
String para int

int b = Integer.parseInt(texto);
String para long

long c = Long.parseLong(texto);
String para float

float d = Float.parseFloat(texto);
String para double

double e = Double.parseDouble(texto);
String para boolean

boolean g = Boolean.parseBoolean(true);
String para char

char f = texto.charAt(1); //Pega o primeiro caractere da String.
5.3 - Recebendo Strings como parmetro diretamente no mtodo main
Quando executamos uma classe que possui o mtodo public static void
main(String[] args), podemos passar parmetros para este mtodo.
Para passar os parmetros para o mtodo main via console utilizamos a seguinte
sintaxe:
java nomeDaClasse parametro1 parametro2
No exemplo abaixo criamos um programa que recebe alguns nomes como parmetro:
Se executarmos esta classe sem passar parmetros imprime a seguinte mensagem:
Quando executamos a aplicao passando os nomes como parmetro, estes nomes

so impressos no console. Note que quando precisamos passar um parmetro que possua
espaos em brancos, devemos utilizar as aspas duplas para delimitar a rea do parmetro,
exemplo Rafael Sakurai.
5.4 - Exerccios
1) Crie um programa onde o usuario deve digitar as seguintes informaes:

- frase
- qtd parametros
- valores dos parametros separados por virgula
Exemplo:
- frase: "Ola meu nome {0} e eu tenho {1} anos"
- qtd parametros: 2
- valores dos parametros separados por virgula: Rafael,25
E a sada do programa na console deve ser:

"Ola meu nome Rafael e eu tenho 25 anos."
6- Identidade e Igualdade
Quando declaramos uma varivel a partir de um objeto, estamos criando uma varivel
que serve de meio de acesso ao nosso objeto (em memria), ou como chamamos, uma
referncia.
Exatamente por este motivo, sempre que declaramos um novo objeto, temos de
utilizar o comando new, pois o mesmo ir efetivamente criar o novo objeto em memria e
fornecer o seu endereo a varivel declarada.
O comando new recebe um parmetro que um construtor de classe.
No exemplo abaixo vamos trabalhar com a classe Pessoa:
Logo, na referncia abaixo:
O correto dizer que manuel uma referncia a um objeto do tipo Pessoa e no que
manuel o objeto propriamente dito.
Com isso, podemos afirmar que em Java uma varivel nunca um objeto, ela apenas
ser a representao de um tipo primitivo ou uma referncia a um objeto.
Com esta idia em mente, seguiremos com o seguinte exemplo:
Neste exemplo, a sada do programa seria a seguinte:
Agora por que a idade de Paulo foi exibida como 25, sendo que apenas
incrementamos a idade de Pedro?
Isso acontece, pois o comando:
Na verdade copia o valor da varivel paulo, para a varivel pedro. Por este motivo,
como falamos acima, ele copia a referncia de um objeto de uma varivel para outra. Seria
como imaginarmos a figura abaixo:
Nesta figura podemos notar que, como ambas as variveis apontam para o mesmo
objeto, qualquer operao realizada atravs da referncia pedro, tambm refletir na
referncia paulo.
Quando queremos comparar se duas variveis apontam para o mesmo objeto

podemos usar a igualdade ( == ), exemplo:
Esta comparao vai retornar true, pois ambas variveis paulo e pedro esto
apontando para o mesmo objeto da memria.
E quando queremos saber se o contedo de dois objetos so iguais devemos utilizar o

mtodo equals(), todas as classes do Java possuem este mtodo.
Neste exemplo ser impresso As duas Strings so iguais, pois o contedo das
Strings so iguais.
Agora se compararmos essas duas Strings com == teremos um resposta que no

esperada:
Neste exemplo ser impresso As duas Strings so diferentes., pois as variveis

no apontam para o mesmo objeto String.
Ento cuidado na comparao entre objetos, de preferncia ao mtodo equals(), use

comparao == somente com tipos primitivos.
Quando criamos uma nova classe, est classe tem um mtodo equals() que vem da
classe java.lang.Object. (A classe Object ser discutida mais a frente no tpico de herana).
O mtodo equals(), que existe na classe que criamos, tem a mesma funo que a
igualdade ( == ). Caso precisemos saber se duas instancias desta mesma classe so
iguais, ento temos de sobrescrever o mtodo equals().
7- Assinatura de Mtodos
Formalizando os conceitos de nome de mtodo e de mtodos com parmetros, vamos

agora ento tratar de assinatura de mtodo.
A assinatura de um mtodo composta por:
visibilidade tipo de permisso ao mtodo (veremos mais a diante).
retorno tipo de retorno do mtodo ou void caso no tenha retorno.
parmetros atributos utilizados dentro do processamento do mtodo.
excees informao de algum erro que pode ocorrer na execuo do mtodo
(veremos mais a diante).
No exemplo abaixo temos alguns exemplos de mtodos que podemos declarar:
Para o compilador os mtodos de mesmo nome, porm com parmetros diferentes

so identificados como mtodos distintos entre si.
Exemplo:
Criamos a classe Televisao, contendo os seguintes mtodos:
O compilador interpretaria estes trs mtodos de forma distinta, e em uma

determinada chamada, saberia exatamente qual deles utilizar.
Note que na chamada ao mtodo realizado na linha 11, o mtodo alterarCanal() est
sendo invocado com passagem de um parmetro inteiro, logo o mtodo da classe Televisao
a ser executado seria:
Assim como mencionado acima, o que identifica a assinatura do mtodo a unio das
informaes de nome do mtodo e parmetros, logo os seguintes mtodos listados abaixo
seriam considerados erros de compilao:
Visto que seus nomes e argumentos so idnticos, mudando apenas o tipo de retorno.
Ao conceito de se criar vrios mtodos de mesmo nome, porm com parmetros

diferentes entre si, damos o nome de Sobrecarga de Mtodo.
7.1 - Troca de Mensagens
Na linguagem Java possvel que objetos distintos se relacionem entre si por meio de
seus mtodos. A este tipo de operao damos o nome de Troca de Mensagens. Este tipo
de relacionamento pode ser representado pela troca de informaes, chamada de execuo
de mtodos, etc.
Para que seja possvel aos objetos se conversarem, necessariamente no preciso
que um objeto esteja contido dentro de outro, formando uma cadeia, mas basta
simplesmente que um referencie os mtodos do outro.
A fim de exemplificar melhor o que estamos falando, vamos imaginar uma mesa de
bilhar. Em um ambiente deste tipo, para que a bola possa se mover necessrio que o taco
a atinja diretamente. Abstraindo esta idia, para ns usurios, o que nos compete apenas o
movimento do taco, sendo que a movimentao da bola ao longo da mesa deve ser realizada
pela imposio do taco.
Agora imagine que o Usurio ser representado pela classe TacoTeste, logo:
Imaginando a situao acima, teramos a classe TacoTeste instanciando objetos de

cada um dos dois tipos. Feito isso, uma chamada ao mtodo bater(Bola bola) da classe
Taco, indicando qual a bola alvo do taco, este mtodo indica apenas que estamos movendo
o taco para acertar uma bola.
J na classe Taco, o mtodo bater(Bola bola) encarregado de executar a ao de

bater na bola. Logo, teramos algo deste gnero:
Note ento, que diferentemente das classes que desenvolvemos at ento, a

chamada do mtodo mover(int forca, float angulo) da classe Bola est sendo referenciado
de dentro da classe Taco, sem qualquer interferncia do usurio atravs da classe
TacoTeste.
A este relacionamento entre as classes sem a interveno externa, assemelhando-se

a uma conversa entre elas, damos o nome de troca de mensagens.
7.2 - Varargs
Quando temos um mtodo que no sabemos ao certo quantos parmetros sero

passados, podemos passar um vetor ou lista de atributos primitivos ou objetos, mas em Java
tambm podemos definir na assinatura do mtodo que ele recebe um parmetro do tipo
varargs.
O mtodo pode receber quantos parmetros forem necessrios, porm s pode ter
apenas um varargs na assinatura do mtodo.
O varargs tem a seguinte sintaxe:
<< Tipo ... Identificador >>
Exemplo:
Neste exemplo temos o seguinte mtodo somarValores que recebe um varargs de

inteiros, quando chamamos este mtodo podemos passar quantos atributos do tipo inteiro for
necessrio, e se quiser tambm no precisa passar nenhum atributo para ele.
O varargs um facilitador, ao invs de criar um array ou lista e colocar os valores
dentro dele para depois chamar o mtodo, o mesmo pode ser chamado diretamente
passando os n valores e os parmetros enviados so automaticamente adicionados em um
array do mesmo tipo do varargs.
Tambm podemos usar o vargars em um mtodo que recebe outros parmetros, mas
quando tem mais parmetros o varargs precisa ser o ultimo parmetro recebido pelo mtodo,
exemplo:
Neste exemplo o mtodo somarValores recebe dois parmetros, um inteiro e um

varargs do tipo inteiro, ento quando chamamos este mtodo passamos o atributo
multiplicador recebe o valor 2 e o atributo valores recebe os valores 10, 5, 15 e 20.
Lembrando que o varargs precisa ser o ultimo parmetro do mtodo e no pode
ter mais que um varargs, caso contrario ocorrer erro de compilao, exemplo:
Portanto estes dois mtodos ficam com erro de compilao.
O mtodo que tem na assinatura um parmetro do tipo varargs s chamado quando

nenhuma outra assinatura de mtodo corresponder com a invocao, exemplo:
Neste exemplo na primeira chamada do mtodo somarValores passando apenas um

atributo inteiro, chamado o mtodo somarValores(int numero).
Na segunda chamada so passado vrios parmetros do tipo inteiro, neste caso o
mtodo chamado ser o somarValores(int... numeros).
7.3 - Exerccios
1. Crie uma classe chamada Calculadora. Esta classe deve possuir os seguintes
mtodos:
public double operacao(double num1, double num2);

Retorna a soma dos dois nmeros.
public double operacao(int num1, double num2);
Retorna a subtrao dos dois nmeros.
public double operacao(double num1, int num2);
Retorna o produto dos dois nmeros.
public double operacao(int num1, int num2);
Retorna o resultado da diviso dos dois nmeros.
public double operacao(int num1, short num2);
Retorna o resto da diviso dos dois nmeros.
Elabore um roteiro de teste para a sua calculadora e observe os resultados.
2. Crie uma classe chamada Pessoa sem atributo algum. Para trabalharmos os
conceitos de sobrecarga de mtodos, crie os seguintes mtodos:
public String dizerInformacao(String nome);

Deve retornar um texto dizendo: Meu nome + nome .
public String dizerInformacao(int idade);
Deve retornar um texto dizendo: Minha idade + idade .
public String dizerInformacao(double peso, double altura);
Deve retornar um texto dizendo: Meu peso + peso + e minha altura +
altura .
Munido do retorno de cada um destes mtodos. Imprima-o em tela.

Para praticarmos o uso da classe Scanner, leia estas quatro informaes que devem ser
inseridas pelo usurio.
3. Crie as classes e implemente os mtodos para o seguinte diagrama de classe:
Crie uma classe de teste e elabore um roteiro de teste da suas classes.
4. Crie uma classe Conta com os seguintes mtodos e atributos:
No mtodo depositar por questes de segurana, no deve permitir depsitos

superiores a R$ 1.000,00 caso a conta seja do tipo Corrente.
O mtodo sacar no deve permitir saques superiores ao saldo total da conta.
O mtodo transferir, pode realizar transferncia da conta corrente para a conta
poupana, mas o contrario no permitido, tambm no deve permitir que o saldo da conta
fique negativo.
Feito isso, trace o seguinte roteiro:
Crie duas contas, uma do tipo Corrente e outra do tipo Poupana com um
saldo inicial qualquer.
Tente depositar R$ 1.500,00 reais na conta corrente.
Tente depositar R$ 1.500,00 reais na conta poupana.
Deposite R$ 98,52 na conta poupana.
Tente sacar R$ 100,00 da poupana.
Transfira R$ 1.800,00 da corrente para a conta poupana.
Transfira R$ 700,00 da poupana para a conta corrente.
Saque R$ 1.000,00 da poupana.
Saque R$ 1.000,00 da corrente.
Na classe de teste, exiba mensagens indicando o retorno e ou o resultado (xito ou

falha) de cada um dos mtodos.
8- Plain Old Java Object POJO
Plain Old Java Object ou POJO, so objetos Java que seguem um desenho
extremamente simplificado. Um POJO um JavaBean que segue definies rgidas
de estrutura, sendo elas:
Possui um construtor default, ou seja, sem argumentos que significa o
mesmo que no possuir construtor algum declarado;
Possui todos os seus atributos, sejam eles tipos primitivos ou objetos,
privados;
No possui mtodos especficos, exceto aqueles que seguem o padro
de getter e setter para seus respectivos atributos
OBS: O padro getter a forma de pegar o valor do atributo e o padro setter a

forma de alterar o valor do atributo.
Este padro baseado na idia de que quanto mais simples o projeto, melhor.
O termo foi inventado por Martin Fowler, Rebecca Parsons e Josh MacKenzie em
Setembro de 2000. "Ns queramos saber por que as pessoas eram contra o uso de
objetos regulares em seus sistemas e conclumos que era devido falta de um nome
extravagante para eles. Assim ns demos-lhes um, e funcionou muito bem.". O termo
segue o padro de atribuir um nome para tecnologias que no possuem nenhuma
caracterstica nova.
O termo ganhou aceitao por causa da necessidade de um termo comum e
facilmente inteligvel que contrasta com os complicados frameworks de objetos.
mais atrativo do que o termo bean do Java devido confuso gerada pela
semelhana dos termos JavaBeans e dos EJB (Enterprise JavaBeans).
Segue abaixo alguns exemplos do que pode ser considerado um POJO:
9- Pacotes
Na linguagem Java existe uma maneira simples e direta de se organizar arquivos,

alm de possibilitar que se utilize mais de uma classe de mesmo nome no mesmo projeto.
Essa forma de organizao recebe o nome de empacotamento, ou packaging. No Java
utilizamos a palavra package para representar o pacote da classe.
A organizao de pacotes ocorre de forma semelhante a uma biblioteca de dados.
Vrios arquivos so agrupados em pastas comuns, logo se tem por hbito agrupar arquivos
de funes semelhantes em mesmas pastas.
Neste exemplo temos os seguintes pacotes:
br
biblioteca
imagens
model
tela
util
A rvore hierrquica do pacote no possui regras restritas de limitao de quantidade

de ns, apenas recomenda-se notao semelhante a da Internet, a fim de reduzir ao mximo
a possibilidade de termos mais de um pacote de arquivos de mesmo nome.
Uma boa pratica para nomes de pacotes utilizar apenas uma palavra como nome do
pacote, por exemplo, biblioteca, pessoa, email, e o nome do pacote escrito em minsculo.
O pacote no pode ter o nome de uma palavra-chave do java e no pode comear
com nmero ou caracteres especiais (exceto $ e _).
No exemplo abaixo vamos criar a estrutura de pacotes br.metodista.telas e dentro

deste pacote vamos colocar a classe CadastroLivro:
Criada ento essa hierarquia, o prximo passo declarar no arquivo da classe o nome
do pacote ao qual ela pertence. Esta declarao deve ser feita obrigatoriamente na primeira
linha do arquivo (sem contar comentrios) da seguinte maneira:
Note na declarao acima que as pastas foram divididas por pontos. Logo a mesma
hierarquia de pastas deve ser seguida nesta declarao.
Desta forma, os arquivos ficam realmente organizados e, de certa forma, isolados de
outros pacotes. Vale lembrar que, quando criamos uma classe na raiz de nosso projeto esta
classe no possui pacote.
O pacote de desenvolvimento Java j traz consigo muitos pacotes de funes
especificas, sendo alguns eles:
PACOTE DESCRIO
java.lang Pacote usual da linguagem. Importado por padro
java.util Utilitrios da linguagem
java.io Pacote de entrada e sada
java.awt Pacote de interface grfica
java.net Pacote de rede
java.sql Pacote de banco de dados
Quando se est desenvolvendo uma classe e deseja-se utilizar uma classe de outro
pacote, somos obrigados a declarar esta utilizao. Para tal, utilizamos o comando import.
De forma semelhante ao comando package, o comando import deve considerar a
hierarquia de pastas e separ-las por pontos, da seguinte forma:
No exemplo acima, demonstramos que a classe CadastroLivro ir utilizar a classe

Livro do pacote br.biblioteca.model.
Quando queremos utilizar muitas classes de um mesmo pacote, podemos importar o
pacote inteiro utilizando o caractere asterisco ( * ) no lugar do nome das classes.
Neste exemplo criado um novo objeto a partir da classe Livro, que est dentro do
pacote br.biblioteca.model, como utilizamos o * no import, podemos utilizar qualquer
classe do pacote model.
OBS: Durante o processo de compilao do arquivo .java para .class, o compilador

primeiro importa as classes que esto com o pacote completo e depois procura pelas classes
que tiveram o pacote inteiro importado, ento normalmente utilizado o nome inteiro do
pacote e da classe, assim as classes so compiladas um pouco mais rpido.
9.1 - Exerccios
1) O que acontece se tentarmos compilar e executar o seguinte codigo:
package pessoa.interface.tela;
public classe Pessoa {

private String nome;
protected void setNome(String nome) {

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

return this.nome;
}
}
public class Funcionario extends Pessoa {

public Funcionario(String nome) {
setNome(nome);
}
public String getNome() {

return "Funcionario: "+ super.getNome();
}
}
public class TesteFuncionario {

Funcionario f = new Funcionario("Cristiano");
System.out.println(f.getNome());
}
}
a) Imprime Cristiano
b) Imprime Funcionario Cristiano
c) Erro porque a classe Funcionario no pode usar o mtodo super.getNome();
d) Erro de compilao
e) Erro em tempo de execuo
10 - Visibilidade
Em Java, utilizamos alguns modificadores que nos permitem proteger o acesso a um

atributo, mtodo ou at mesmo uma classe, de outras classes. Basicamente Java possui
quatro modificadores bsicos de acesso, sendo eles:
10.1 - Modificador de acesso: private
private um modificador de acesso que restringe totalmente o acesso aquele recurso

da classe de todas as demais classes, sejam elas do mesmo pacote, de outros pacotes ou
at subclasses. Este modificador pode ser aplicado a atributos e mtodos.
Exemplo:
Neste exemplo temos a classe Email, a partir de outras classes podemos chamar
apenas o mtodo enviarEmail(...), os outros mtodos e atributos da classe no podem ser
usados por outras classes pois tem o modificador private.
Neste exemplo conseguimos criar um objeto a partir da classe Email e enviar o email
utilizando o mtodo enviarEmail(...), mas no conseguimos acessar o atributo remetente e
o mtodo enviar(), pois so privados e o compilador gera dois erros de compilao:
10.2 - Modificador de acesso: defaut ou package
default um modificador um pouco menos restritivo que o private. Este tipo de

modificador aplicado a todas as classes, atributos ou mtodos, os quais, no tiveram o seu
modificador explicitamente declarado.
Este modificador permite que apenas classes do mesmo pacote tenham acesso as
propriedades que possuem este modificador.
Neste exemplo temos uma classe Pessoa que no declarou o modificador, portanto o
modificador o default.
Se criarmos outra classe dentro do mesmo pacote da classe Pessoa, br.visibilidade,

ento est classe tem acesso classe Pessoa tambm.
Agora se tentarmos utilizar a classe Pessoa, a partir de outro pacote, ter erro de
compilao, pois no tem acesso.
10.3 - Modificador de acesso: protected
protected um modificador um pouco menos restritivo que o default. Com este tipo
modificador, podemos declarar que um atributo ou mtodo visvel apenas para as classes
do mesmo pacote ou para as subclasses daquela classe.
Neste exemplo temos a classe Produto, e est classe tem o atributo nomeProduto e
os mtodos getNomeProduto() e setNomeProduto() que possuem o modificador
protected.
Se criarmos outra classe no pacote br.visibilidade, podemos utilizar os atributos e

mtodos protected declarados na classe Produto.
Se criarmos uma classe em um pacote diferente, no conseguiremos utilizar os

atributos e mtodos da classe Produto, pois no temos acesso ao mtodo.
Se a classe que est em outro pacote for uma subclasse da classe Produto, ento
est classe recebe atravs da herana os atributos e mtodos protected.
10.4 - Modificador de acesso: public
public o modificador menos restritivo de todos os demais. Declarando classes,

atributos ou mtodos com este modificador, automaticamente dizemos que aquela
propriedade acessvel a partir de qualquer outra classe.
OBS: Dentro de um arquivo .java, s pode existir uma classe do tipo public, e est
classe precisa obrigatoriamente ter o mesmo nome que o nome do arquivo .java.
Alm dos modificadores de acesso, temos vrios outros modificadores que sero
abordados futuramente. Abaixo temos uma relao de todos os modificadores e os seus
respectivos impactos quando aplicados a Classes, Mtodos e Atributos.
Modificador Em uma classe Em um mtodo Em um atributo

private No aplicvel Acesso pela classe Acesso pela classe
Acesso pelo pacote e Acesso pelo pacote e
protected No aplicvel subclasses subclasses
default Somente pacote Acesso pelo pacote Acesso pelo pacote
public Acesso total Acesso total Acesso total
abstract No instncia Deve ser sobrescrito No aplicvel
final Sem herana No pode ser sobrescrito CONSTANTE
static No aplicvel Acesso pela classe Acesso pela classe
native No aplicvel Indica cdigo nativo No aplicvel
transient No aplicvel No aplicvel No serializavel
synchonized No aplicvel Sem acesso simultneo No aplicvel
10.5 - Exerccios
1) Qual das alternativas abaixo esta correta:
package p1;
public class Pessoa {
private String texto = "";
protected void dizer(String texto) {
System.out.println(texto);
}
}
package p2;
public class TestePessoa {
public static void main (String[] args) {
Pessoa p = new Pessoa();
p.dizer("Ola");
}
}
a) Imprime "Ola";
b) No imprime nada
c) No compila
d) Erro em tempo de execuo
11 - Encapsulamento
Encapsular, nada mais do que proteger membros de outra classe de acesso externo,
permitindo somente sua manipulao de forma indireta. Isso possvel da seguinte maneira:
Consideremos o seguinte exemplo de uma classe Livro:
Note que os dois atributos da classe (titulo e autor) so do tipo private, que permite
apenas o acesso destas informaes a partir da prpria classe, logo para que seja possvel
ler ou alterar essas informaes criamos mtodos ditos mtodos assessores ou ento
getters e setters.
A princpio parece ser algo sem muita utilidade, mas desta forma podemos criar
atributos os quais podemos apenas ler informaes ou ainda gerar tratamentos especficos
sempre que outra classe solicita a alterao de um atributo de nossa classe.
Encapsule aquilo que pode ser alterado com freqncia na sua aplicao, exemplo:
Note que os atributos das classes Professor e Aluno so private, dessa forma eles
s podem ser acessados pelas suas classes.
Tambm criamos mtodos set (mtodos utilizados para alterar o valor de uma
propriedade) e get (mtodo utilizado para obter o valor de uma propriedade) para cada
atributo.
Dado a classe Professor e Aluno, queremos consultar os alunos e professores pelo

nome:
Agora digamos que nosso programinha que busca os alunos e professores esta
funcionando corretamente, e precisamos adicionar outra busca que procura coordenadores
pelo seu nome.
Para consultar o coordenador pelo nome, precisamos usar um mtodo bem parecido
com o que consulta o aluno e professor, mas se notarmos as classes Aluno, Professor e
Coordenador tem o atributo nome em comum e exatamente por este atributo que os
consultamos.
Se criarmos uma classe Pessoa para ser uma classe Pai dessas classes e se a
classe Pai tiver o atributo nome, ento todas as subclasses recebem este atributo por
herana:
As subclasses Professor, Aluno e Coordenador ficaram da seguinte forma:
Para consultar o Aluno, Professor e Coordenador vamos criar apenas um mtodo

que recebe um vetor de Pessoa e o nome que ser procurado e retorna um vetor com as
Pessoas encontradas:
Dessa forma usamos herana e encapsulamos a forma de encontrar um Aluno,

Pessoa e Coordenador, agora se tivermos que adicionar um Diretor, por exemplo, nosso
mtodo de consulta no precisa ser alterado, precisamos apenas criar a classe Diretor e
fazer ela filha da classe Pessoa.
11.1 - Exerccios
1- Crie uma classe chamada Comparador. Esta classe no deve possuir nenhum
atributo e nenhum mtodo construtor.
Esta classe deve possuir mtodos capazes de receber dois parmetros, compar-los e
por fim retornar true, caso sejam iguais, e false caso sejam diferentes.
public boolean comparaInt(int num1, int num2);

public boolean comparaDouble(double num1, double num2);
public boolean comparaString(String texto1, String texto2);
Lembre-se que em JAVA, as Strings so tratadas como objetos!

Elabore um roteiro que teste os trs mtodos de sua nova classe.
2- Crie uma classe chamada Pessoa com os seguintes atributos:

String nome;
int idade;
E com um mtodo construtor que inicialize estes dois atributos.
public Pessoa(String novoNome, int novaIdade);
Feito isso, crie uma classe de teste e instancie cinco pessoas com os seguintes
atributos:
1- Joo, 24 anos ( ex: Pessoa pessoa1 = new Pessoa(Joo, 24); )
2- Carlos, 24 anos
3- Joo, 32 anos
4- Joo, 32 anos
5 = 3 (ao invs de utilizar o construtor, inicialize-a com a 3 Pessoa
ex: Pessoa pessoa1 = pessoa3; )
Agora, compare-os da seguinte maneira e imprima os resultados...
if(1==2)
if(3==4)
if(1.idade == 2.idade)
if(1.nome.equals(4.nome))
if(5==3)
3- Crie uma classe que serve como utilitrio para String, est classe tem um mtodo que
recebe uma String texto e um varargs de String parmetros, voc deve ler atravs da
console, qual o texto, quantos parmetros tem no texto e quais so os parmetros,
exemplo:
texto = Oi, meu nome {0} e tenho {1} anos.

quantidade de parmetros 2
parmetros: Rafael e 24
Depois de ler esses dados seu programa deve imprimir:
Oi, meu nome Rafael e tenho 24 anos.
OBS: O texto pode ter {n} parmetros, este apenas um exemplo.
4- Crie uma classe com visibilidade default chamada ContaBancaria, pertencente ao

pacote metodista.poo.aula10.banco com os seguintes atributos:
E a classe filha public final ContaCorrente, pertencente tambm ao pacote

metodista.poo.aula10.banco, com o seguinte atributo:
Para testarmos nossa classe, crie uma classe de teste que deve pertencer ao pacote
metodista.poo.aula10, depois instancie um objeto do tipo ContaCorrente.
Teste todas as formas de acesso possveis aos membros da classe ContaBancaria e
ContaCorrente.
Note que a partir da classe de teste voc no dever conseguir instanciar um objeto
do tipo ContaBancaria e que a classe ContaCorrente no dever suportar nenhuma
subclasse.
12 - Interfaces
Interface um recurso da linguagem Java que apresenta inmeras vantagens no

sentido da modelagem e instanciao de objetos, porm deve-se entender claramente os
conceitos bsicos da orientao a objetos a fim de utiliz-la plenamente.
Uma interface similar a um contrato, atravs dele podemos especificar quais
mtodos as classes que implementam est interface so obrigados a implementar.
Exemplo de interface UML:
ou
Estes so dois modos de se representar uma interface utilizando a UML, criamos uma
interface chamada Banco, em Java est interface fica do seguinte modo:
Para criarmos uma interface em Java, utilizamos a palavra interface antes do seu
nome.
Na interface declaramos os mtodos de forma abstrata, tendo apenas sua assinatura
e terminando com ponto e vrgula ( ; ) e todos os mtodos precisam ser pblicos.
Podemos declarar atributos, porm todos os atributos de uma interface so constantes
publicas.
Uma interface pode extender (sub-interface) outras interfaces.
Dentro da interface no podemos:

- implementar mtodo
- construtor
- extender classe
- implementar outra interface
- no pode ser final
Quando uma classe implementa uma interface, est classe obrigatoriamente precisa
implementar todos os mtodos declarados na interface, apenas quando usamos classes
abstratas implementando interface que no precisamos obrigatoriamente implementar todos
os mtodos (Classes abstratas sero vistas mais para frente).
Na UML a implementao de uma interface feita da seguinte forma:
Neste exemplo temos duas classes BancoSakurai e BancoCristiano implementando

a interface Banco. Nas classes podem ser feitas implementaes diferentes dos mtodos,
mas as assinaturas dos mtodos precisam ser iguais as da interface, podemos tambm
adicionar mais mtodos que os obrigatrios.
Neste exemplo tambm estamos usando uma classe conta:
O cdigo Java dessas duas classes ficam da seguinte forma:
BancoSakurai
Nesta implementao o BancoSakurai alem de fornecer os mtodos obrigatrios da

interface Banco, tambm disponibiliza um mtodo adicional chamado transferencia(Conta
contaOrigem, Conta contaDestino, double valor).
BancoCristiano
Nesta classe BancoCristiano, podemos ver que ele possui apenas os mtodos
obrigatrios da interface Banco.
Est implementao tem um algoritmo diferente do BancoSakurai, aqui o mtodo
manutencaoConta() tem um valor que ser retirado da conta mesmo que a conta no tenha
mais saldo.
Assim podemos perceber que a interface serve como uma base, informando os
mtodos mnimos que devem ser implementados e cada classe responsvel pela lgica de
negocio utilizado nos mtodos.
Neste exemplo criamos dois bancos e duas contas e fizemos algumas operaes em
cima das contas e no final imprimimos o extrato das contas.
Note a seguinte sintaxe:
Repare que estamos criando uma varivel bancoCristiano do tipo da interface

Banco, depois estamos criando um objeto da classe BancoCristiano que uma classe que
implementa a interface Banco. Este tipo de sintaxe muito usado quando usamos
polimorfismo. (Veremos polimorfismo mais para frente)
Quando executarmos a classe BancoTeste temos a seguinte sada no console:
Quando usamos uma varivel usando o tipo interface, podemos apenas chamar os
mtodos que possuem na interface, a seguinte linha causar um erro de compilao:
Neste exemplo teremos um erro de compilao, pois a interface Banco no tem a

assinatura para o mtodo transferencia(Conta contaOrigem, Conta contaDestino, double
valor), este mtodo disponibilizado atravs da classe BancoSakurai, ento para us-lo
precisaremos de uma varivel do tipo BancoSakurai.
Uma interface em Java, aps sua compilao, tambm gera um arquivo .class, assim
como qualquer outra classe em Java.
12.1 - Exerccios de Interface
1- Vamos criar um programa Java para ordenar vrios tipos de objeto diferente,
utilizando o algoritmo de Bubble Sort.
Para isto vamos utilizar uma interface chamada Comparavel, esta interface ir
possuir a assinatura de mtodo que todas as classes que desejam ser comparadas
precisa implementar:
Vamos criar uma classe que ordena um array de objetos que so do tipo
Comparavel:
Note que iremos ordenar
Agora vamos criar uma classe que implemente a interface Comparavel:
Agora vamos criar uma classe para testar a ordenao de um array de Livro.
2- Crie uma classe Animal que possui os atributos especie e raca, faa est
classe implementar a interface Comparavel, e implemente o mtodo comparar
de forma que compare por especie e raca.
Teste a ordenao da classe Animal.
13 - Herana
Em Java, podemos criar classes que herdem atributos e mtodos de outras classes,
evitando reescrita de cdigo. Este tipo de relacionamento chamado de Herana.
Para representarmos este tipo de relacionamento na linguagem, devemos utilizar a
palavra reservada extends, de forma a apontar para qual classe a nossa nova classe deve
herdar seus atributos e mtodos.
Neste exemplo vamos demonstrar a vantagem do reaproveitamento de cdigo

utilizando a Herana. Temos as classes Funcionario e Coordenador que possuem o
atributo nome e matricula em comum.
Como esses os atributos nome e matricula so comuns para ambas as classes, e

elas possuem algo a mais em comum que seu propsito, ambas so utilizada para
representar Pessoas.
Podemos criar uma classe Pessoa que ter os atributos nome e matricula, e atravs
da herana vamos reaproveitar esses atributos nas classes Funcionario e Coordenador.
Agora vamos alterar a classe Funcionario e Coordenador:
Com a declarao acima, temos as classe Funcionario e Coordenador como classes

filha ou subclasses da classe pai Pessoa. Com isso podemos dizer que a subclasse
Funcionario e Coordenador herdam todos os atributos e mtodos da sua superclasse
Pessoa.
Por isso lembre-se, o Funcionario UMA Pessoa, pois uma subclasse, logo
apenas possui algumas caractersticas a mais do que Pessoa, porm podemos sempre
manuse-lo como uma Pessoa, logo tambm possvel se fazer o seguinte tipo de
declarao:
Porm note que na linha 21 temos um erro de compilao, pois uma Pessoa nem
sempre um Funcionario, afinal de contas, poderamos ter a seguinte situao:
Neste exemplo temos a superclasse Pessoa, e trs subclasses Funcionario, Aluno e

Professor.
Uma classe pode herdar apenas de uma classe (superclasse), quando uma classe
no define explicitamente que est herdando outra classe ento est classe filha de
java.lang.Object, ou seja, a classe Object a classe pai de todas as classes.
Por Object ser pai de todas as classes, todas as classes herdam os seguintes
mtodos dela:
Quando lidamos com classes que possuem a relao de herana, podemos fazer uso
de duas palavras-chave que servem para identificar se estamos utilizando um mtodo e ou
atributo da classe atual ou de sua super classe, estes comandos so:
this Define que o recurso pertence classe atual.

super Define que o recurso pertence super classe.
Podemos vizualizar que a classe Coordenador utiliza ambas palavras-chaves:
Na linha 12 o construtor que recebe o nome, matricula e curso do coordenador, note

que neste construtor temos a chamada super(nome, matricula), que ir chamar o construtor
da classe Pessoa que recebe um String e um inteiro como parmetro.
Dentro deste mesmo construtor temos a seguinte chamada this.cursoCoordenado =
cursoCoordenado, utilizando a palavra-chave this, estamos referenciando o atributo
cursoCoordenador da prpria classe Coordenador.
13.1 - Exercicios
1. Crie uma classe Computador com os seguintes mtodos e atributos:
Feito isso, crie mais duas outras classes chamadas Desktop e Notebook, classes filhas
de Computador, com os seguintes atributos e mtodos a mais, alguns sobrescritos:
<< Para resgatar as informaes da superclasse use o modificador super >>
Para testarmos nosso ambiente, crie uma classe de teste que instancie trs objetos,
sendo um de cada um dos tipos.
Para atestar a questo da herana, nos objetos dos tipos Notebook e Desktop, faa
chamadas aos mtodos da superclasse Computador como, por exemplo, o mtodo
dizerInformacoes().
2. Crie uma classe Veculo com os seguintes mtodos e atributos:
Feito isso, crie mais trs subclasses filhas de Veiculo, atribuindo a cada uma delas
um novo atributo e 2 novos mtodos.
Crie um roteiro de testes que comprove o funcionamento de suas classes.
3. Dado as classes abaixo informe qual(is) do(s) modificador(es) de acesso no podem ser
utilizados no mtodo getNome() da classe Funcionrio.
class Pessoa {
String nome;
String getNome() {
return this.nome;
}
}
class Funcionario extends Pessoa {

String getNome() {
return Funcionrio: + super.nome;
}
}
a) private
b) padro (default)
c) protected
d) public
14 - Classes Abstratas
Em Java temos um tipo especial de classe chamado classe abstrata. Este tipo de
classe possui uma caracterstica muito especfica em Java que o de no permitir que novos
objetos sejam instanciados a partir desta classe. Por este motivo, as classes abstratas
possuem o nico propsito de servirem como superclasses a outras classes do Java.
Em Java definimos uma classe como abstrata utilizando a palavra reservada abstract
na declarao da classe, exemplo:
Na linha 9 estamos criando uma classe abstrata atravs da palavra-chave abstract.
Uma classe abstrata desenvolvida para representar entidades e conceitos abstratos,

sendo utilizada como uma classe pai, pois no pode ser instanciada. Ela define um modelo
(template) para uma funcionalidade e fornece uma implementao incompleta - a parte
genrica dessa funcionalidade - que compartilhada por um grupo de classes derivadas.
Cada uma das classes derivadas completa a funcionalidade da classe abstrata adicionando
um comportamento especfico.
Uma classe abstrata normalmente possui mtodos abstratos. Esses mtodos so
implementados nas suas classes derivadas concretas com o objetivo de definir o
comportamento especfico. O mtodo abstrato define apenas a assinatura do mtodo e,
portanto, no contm cdigo assim como feito nas Interfaces.
Uma classe abstrata pode tambm possuir atributos e mtodos implementados,
componentes estes que estaro integralmente acessveis nas subclasses, a menos que o
mesmo seja do tipo private.
Como todo mtodo abstrato precisa ser implementado pela classe filha, ento no
pode ser private, pois no seria visvel na subclasse.
Neste exemplo vamos criar uma classe abstrata chamada Tela, nesta classe vamos
implementar alguns mtodo que devem ser utilizados por todas as telas do computador de
bordo de um veiculo, como por exemplo, setTitulo() para informar o titulo da tela e
imprimir() que imprime as informaes na tela.
Nesta classe vamos tambm definir a assinatura de um mtodo abstrato chamado
obterInformacao() que deve ser implementado pelas classes filhas.
Vamos agora criar a classe TelaKilometragem que ser uma subclasse da classe
abstrata Tela, est classe ser utilizada para mostrar a km atual percorrida pelo veiculo.
Vamos agora criar a uma classe para testar nossa aplicao. Neste teste vamos criar
um objeto da classe TelaKilometragem e chamar o mtodo imprimir() que est classe
herdou da classe Tela.
Toda classe que herdar (estender) a classe Tela deve implementar o mtodo abstrato
obterInformacao().
Temos a seguinte sada no console:
Segue abaixo um quadro comparativo entre Interface e Classe Abstrata:
Classe Abstrata Interface

Pode possui atributos de instncia Possui apenas constantes
Possui mtodos de diversas visibilidades
Todos mtodos so public e abstract
e mtodos implementados ou abstratos
estendida por classes (sub-classes) implementada por classes
Uma sub-classe s pode estender uma
Uma classe pode implementar mais de uma
nica classe abstrata (regra bsica da
interface
herana em Java)
Hierarquia de herana com outras Hierarquia de herana com outras
classes abstratas interfaces
14.1 - Exerccios
Crie uma classe abstrata chamada Animal, com a seguinte implementao:
Feito isso, desenvolva duas subclasses da classe Animal. Cada uma delas com a
seguinte especificao:
Feito isso, crie uma classe para testar suas 2 subclasses. Tente instanciar diretamente
a classe Animal. Crie o mtodo abaixo na classe principal, apenas para relembrar o conceito
de generalizao:
15 - Excees em Java
A linguagem Java possui um mecanismo especial para o tratamento de erros que

possam ocorrer em tempo de execuo do programa. Diferentemente de outras linguagens,
o surgimento de um erro ocasiona a interrupo imediata do programa, porm em Java
podemos tratar esta situao de erro de uma forma adequada e evitando assim a interrupo
do programa.
Uma exceo, basicamente uma classe de Java representada na sua forma mais
genrica pela classe java.lang.Exception, logo todas as excees que ocorram ao longo da
execuo do seu programa podem ser tratadas como objetos do tipo Exception.
Uma caracterstica importante sobre excees que, pelo fato delas poderem ocorrer
a qualquer momento, estas so literalmente lanadas de volta para a cadeia de execuo e
chamada das classes.
Exemplo:
15.1 - Bloco try / catch
Como a exceo lanada por toda a cadeia de classes do sistema, a qualquer

momento possvel se pegar essa exceo e dar a ela o tratamento adequado.
Para se fazer este tratamento, necessrio pontuar que um determinado trecho de
cdigo que ser observado e que uma possvel exceo ser tratada de uma determinada
maneira, segue um exemplo deste novo bloco:
No caso acima, o bloco try, o trecho de cdigo onde uma exceo esperada e o
bloco catch, em correspondncia ao bloco try, prepara-se para pegar a exceo ocorrida e
dar a ela o tratamento necessrio. Uma vez declarado um bloco try, a declarao do bloco
catch torna-se obrigatria.
Na linha 15 o bloco catch declara receber um objeto do tipo Exception, lembrando do
conceito da herana, todas as excees do Java so classes filhas de Exception.
Algo importante de ser comentado, que quando uma exceo ocorre, as demais
linhas de cdigo deixam de ser executadas at encontrar o bloco catch que ir tratar a
exceo.
Exemplo:
Observemos o exemplo acima. Neste cdigo, caso acontea um erro na linha 16, as
linhas de 17 a 20 no seriam executadas, retornando ento o cdigo a ser executado apenas
a partir da linha 22 (trecho correspondente ao bloco catch).
Uma vez que uma exceo foi tratada por um bloco catch, a execuo do programa
segue normalmente.
Caso no ocorra erro durante a execuo teremos a seguinte sada no console:
Se no lugar de um nmero inteiro for digitado outra informao teremos a seguinte

sada no console:
15.2 - Palavra chave throw
Tambm possvel que voc prprio envie uma exceo em alguma situao
especifica, como por exemplo, em uma situao de login onde o usurio digita
incorretamente sua senha. Para realizarmos tal tarefa necessria a utilizao da palavra
chave throw da seguinte maneira:
throw new << Exceo desejada >>();
Vamos ver um exemplo de lanamento de uma exceo do tipo Exception:
Note que, assim que a palavra throw for utilizada, a implementao do bloco try /
catch ser obrigatria, caso a exceo em questo seja do tipo checked. Observe tambm
que a palavra reservada new foi utilizada, visto que a exceo um novo objeto que deve
ser criado na memria. Isso se faz necessrio para que a exceo possa ser lanada por
toda a pilha de execuo at que seja devidamente tratada ou acarrete no trmino da
aplicao.
Quando executamos este cdigo temos a seguinte sada no console, note que no
primeiro teste entramos com uma senha invalida abc, portanto foi lanado a exceo, no
segundo teste entramos com a senha valida 123456 e executamos a aplicao por
completo.
Alguns mtodos importantes da classe Exception:
Exception.printStackTrace();
Imprime em tela a pilha de execuo. Muito comum para auxiliar no diagnstico de
erros.
Exception.getMessage();
Retorna uma String com a mensagem contida na exceo.
Exception.getClass();
Retorna uma String com o nome complete da classe da exceo.
15.3 - Bloco finnaly
A palavra chave finally representa um trecho de cdigo que ser sempre executado,
independentemente se uma exception ocorrer. Exemplo:
No exemplo acima, a mensagem Bloco Finally! sempre ser exibida, ocorrendo ou

no um Exception.
Se digitarmos zero no valor do divisor ser lanado uma exceo, note que o bloco
finally ser executado mesmo que ocorra alguma exceo:
O bloco finally muito utilizado quando queremos liberar algum recurso como, por
exemplo, uma conexo com o banco de dados, um arquivo de dados, etc. Veremos mais
adiante alguns cdigos que fazem uso do finally para este proposito.
15.4 - Palavra chave throws
Caso em algum mtodo precise lanar uma exceo, mas voc no deseja trat-la,
quer retorn-la para o objeto que fez a chamada ao mtodo que lanou a exceo, basta
utilizar a palavra chave throws no final da assinatura do mtodo.
Quando utilizamos o throws precisamos tambm informar qual ou quais excees
podem ser lanadas
Exemplo:
Note que na linha 32 declaramos na assinatura do mtodo que ele pode ou no lanar
uma exceo do tipo java.lang.Exception.
E o mtodo public static void main(String[] args) ser responsvel por tratar alguma
exceo que o mtodo dividir(double dividendo, double divisor) possa lanar.
Se digitarmos zero no valor do divisor ser lanado uma exceo pelo mtodo
dividir(), esta exceo ser tratada pelo mtodo main():
15.5 - Hierarquia das Exceptions
A princpio, Java possui diversos tipos especficos de exceo, cada um deles

diretamente relacionado a uma operao especfica, por este motivo para que uma classe
seja considerada uma exceo imprescindvel que ela de alguma forma seja filha de
java.lang.Exception.
As excees que so subclasses de java.lang.Exception so normalmente divididas
em duas parte as Checked e Unchecked, que explicaremos mais adiante.
No quadro abaixo, temos um exemplo da hierarquia de algumas subclasses de
Exception. Uma das subclasses mais comuns a java.lang.RuntimeException, sobretudo
para os usurios finais, pois como podem acontecer em qualquer parte do cdigo durante
sua execuo, normalmente, quando no tratadas ocasionam na interrupo do programa.
15.6 - Checked Exceptions
As checked exceptions, so excees j previstas pelo compilador. Usualmente so

geradas pela palavra chave throw (que discutido mais adiante). Como ela prevista j em
tempo de compilao, se faz necessria a utilizao do bloco try / catch ou da palavra chave
throws.
A princpio, todas as classes filhas de Exception so do tipo checked, exceto pelas
subclasses de java.lang.RuntimeException (exceo em tempo de execuo).
15.7 - Unchecked Exceptions
Um dos fatores que tornam a RuntimeException e suas classes filhas to especficas

em relao as demais subclasses de Exception que elas so excees no diretamente
previstas por acontecer em tempo de execuo, ou seja, so unchecked exceptions.
Exemplo:
Observe que no trecho de cdigo acima, temos uma varivel do tipo int recebendo
uma entrada do usurio tambm do tipo int. Porm, vamos supor que nosso usurio no
digite um inteiro, mas sim um caractere.
Este tipo de exceo, que acontece somente em tempo de execuo, a princpio no

era tratado e uma exceo do tipo java.util.InputMismatchException ser gerada e nosso
programa encerrado. Agora iremos prever este erro, utilizando o bloco try / catch:
Desta forma, a digitao incorreta do usurio ser tratada e uma mensagem de erro
ser exibida caso uma exceo acontea, a varivel validado no receberia o valor true.
15.8 - Errors
Errors so um tipo especial de Exception que representam erros da JVM, tais como
estouro de memria, entre outros. Para este tipo de erro normalmente no feito tratamento,
pois sempre quando um java.lang.Error ocorre a execuo do programa interrompida.
15.9 - Tratando mltiplas Excees
possvel se tratar mltiplos tipos de exceo dentro do mesmo bloco try / catch, para
tal, basta declara-los um abaixo do outro, assim como segue:
OBS: As excees tratadas pelos catchs devem seguir a ordem da mais especifica
para a menos especifica.
15.10 - Criando sua exceo
Na linguagem Java podemos tambm criar nossas prprias excees, normalmente

fazemos isso para garantir que nossos mtodos funcionem corretamentes, dessa forma
podemos lanar excees com mensagens de fcil entendimento pelo usurio, ou que possa
facilitar o entendimento do problema para quem estiver tentando chamar seu mtodo possa
tratar o erro.
No exemplo abaixo vamos criar uma exceo chamada ErroDivisao que ser lanada
quando ocorrer uma diviso incorreta, para isso precisamos criar esta classe filha de
Exception.
Agora vamos criar a classe TesteErroDivisao que iremos utilizada para testar o
lanamento da nossa exceo ErroDivisao.
Iremos criar o mtodo restoDaDivisao que ir calcular o resto da diviso de dois
nmeros e lanara a exceo ErroDivisao caso tenha o valor do divisor maior que o valor
do dividendo.
Quando executamos a classe TesteErroDivisao caso no ocorra nenhum problema

ser apresentado o resto da diviso, se ocorrer algum erro ser apresentado a mensagem
Diviso Invalida!!!.
15.11 - Exerccios
1. Crie uma classe que aceite a digitao de dois nmeros e faa a diviso entre eles
exibindo seu resultado. Sua classe deve tratar as seguintes excees:
ArithmeticException e InputMismatchException
2. Crie uma classe que crie um vetor de inteiros de 10 posies. Feito isso, permita que o
usurio digite valores inteiros afim de preencher este vetor. No implemente nenhum
tipo controle referente ao tamanho do vetor, deixe que o usurio digite valores at que
a entrada 0 seja digitada.
Uma vez digitado o valor 0, o mesmo deve ser inserido no vetor e a digitao de novos
elementos deve ser interrompida. Feita toda a coleta dos dados, exiba-os em tela.
Sua classe deve tratar as seguintes excees:
ArrayIndexOutOfBoundsException e InputMismatchException
3. Crie uma classe Login com a seguinte modelagem:
Login
private String usuario;

// Determina o nome do usurio
private String senha;
// Determina a senha do usurio.
E os mtodos:
public Login(String _usuario, String _senha) {

// Construtor padro
}
public void setSenha (String _senha) {

// Troca a senha do usurio.
}
public boolean fazerLogin(String _usuario, String _senha){

/*
Deve receber informaes de usurio e senha e compara-las com as da classe.
Caso sejam realmente iguais, deve retornar verdadeiro, ou ento deve lanar uma
nova exceo dizendo qual credencial est errada, tratar essa exeo dentro do
prprio mtodo imprimindo o erro em tela e por fim retornar false.
Ex:
try{
if(<<usurio incorreto>>)
throw new Exception(Usurio incorreto);
} catch (Exception e) {
System.out.println(Erro);
}
*/
}
Feito isso, crie uma classe para testar a inicializao de um objeto do tipo Login e que
utilize o mtodo fazerLogin, com informaes digitadas pelo usurio.
4. O que ser impresso se tentarmos compilar e executar a classe Teste Excecao?
public class MinhaExcecao extends Exception {}
public class TesteExcecao {

public void teste() throws MinhaExcecao {
throw new MinhaExcecao();
}

MinhaExcecao me = null;
try {
System.out.println("try ");
} catch (MinhaExcecao e) {
System.out.println("catch ");
me = e;
} finally {
System.out.println("finally ");
throw me;
}
System.out.println("fim");
}
}
a) Imprime "try "

b) Imprime "try catch "
c) Imprime "try catch finally "
d) Imprime "try catch finally fim"
e) Erro de compilao
4. Crie uma classe chamada ContaBancaria, pertencente ao pacote

exerccio.excecao.contas com os seguintes atributos:
private double saldo;

// Determina o saldo da conta.
private double limite;
// Determina o limite de crdito do cheque especial.
E os mtodos:
public ContaBancaria(double valorSaldo, double valorLimite){}

// Construtor padro da classe.
public double getSaldo(){}
// Retorna o saldo da conta.
protected double getLimite(){}
// Retorna o limite da conta.
public double getSaldoComLimite(){}
// Retorna o saldo da conta somado ao limite.
public void sacar(double valor) throws ContaException {}
// Deve decrementar o valor do saque da Conta. Retorna true caso a operao
tenha sido bem sucedida, ou seja, a conta possui este valor (lembre-se de
considerar o limite).
public void depositar(double valor) throws ContaException {}
// Deve incrementar o valor a Conta.
E crie tambm a seguinte classe:
ContaException extends Exception

public ContaException (String _mensagem);
Construtor padro da classe. Deve chamar o mesmo construtor da
Superclasse.
Requisitos
A sua classe conta bancria deve permitir apenas saques inferiores a R$ 500,00 ou
que no faam com que a soma entre o saldo e o limite da conta resultem em um
valor menor do que zero. Caso estas condies no se cumpram, deve ser lanada
uma ContaException com uma mensagem que identifique o tipo de erro.
A conta no deve permitir depsitos superiores a R$ 1.000,00. Caso esta condio

no se cumpra, deve ser lanada uma ContaException com uma mensagem que
identifique o tipo de erro.
Crie uma classe para testar a classe ContaBancaria
16 - Polimorfismo
Quando trabalhamos com herana e dizemos que uma subclasse PessoaFisica e

PessoaJuridica so filhas da superclasse Pessoa, podemos ento dizer que um
PessoaFisica e PessoaJuridica UMA Pessoa, justamente por ser uma extenso ou tipo
mais especificado deste. Essa a semntica da herana.
Dizer que uma Pessoa UMA PessoaFisica est errado, porque ela pode tambm
ser uma PessoaJuridica.
Quando trabalhamos com uma varivel do tipo Pessoa que uma superclasse,
podemos fazer est varivel receber um objeto do tipo PessoaFisica ou PessoaJuridica,
exemplo:
Com isso, podemos dizer que polimorfismo a capacidade de um objeto ser

referenciado de diversas formas diferentes e com isso realizar as mesmas tarefas (ou
chamadas de mtodos) de diferentes formas.
Um exemplo do uso do polimorfismo utilizando a classe Pessoa, seria todas as

subclasses sobrescreverem o mtodo getNome().
A subclasse PessoFisica sobrescreve o mtodo getNome() e retorna a seguinte

frase: Pessoa Fisica: nomePessoa CPF: cpfPessoa.
A subclasse PessoaJuridica sobrescreve o mtodo getNome() e retorna a seguinte

frase: Pessoa Juridica: nomePessoa CNPJ: cnpjPessoa.
Desta maneira, independentemente do nosso objeto PessoaFisica e PessoaJuridica

ter sido atribudo a uma referencia para Pessoa, quando chamamos o mtodo getNome() de
ambas variveis, temos a seguinte sada:
Exemplo:
Sada:
Mesmo as variveis sendo do tipo Pessoa, o mtodo getNome() foi chamado da

classe PessoaFisica e PessoaJuridica, porque durante a execuo do programa, a JVM
percebe que a varivel fisica est guardando um objeto do tipo PessoaFisica, e a varivel
juridica est guardando um objeto do tipo PessoaJuridica.
Note que neste exemplo apenas atribumos o valor do nome da Pessoa, no
informamos qual o CPF ou CNPJ da pessoa, se tentarmos utilizar a varivel do tipo Pessoa
para atribuir o CPF atravs do mtodo setCpf() teremos um erro de compilao, pois
somente a classe PessoaFisica possui este mtodo:
Durante a compilao teremos o seguinte erro informando que a classe

material.polimorfismo.Pessoa no possui o mtodo setCpf(long):
Ateno: mesmo o objeto sendo do tipo PessoaFisica, quando chamamos um

mtodo atravs da classe Pessoa, s podemos chamar os mtodos que existem na classe
Pessoa.
Durante a execuo do programa, a JVM verifica qual a classe de origem do objeto e
chama o mtodo desta classe.
Para podermos atribuir o valor para CPF ou CNPJ, preciso ter variveis do tipo
PessoaFisica e PessoaJuridica.
No exemplo abaixo as variveis so do tipo PessoaFisica e PessoaJuridica, essas
variveis sero guardadas dentro de um vetor de Pessoa:
Agora quando executarmos este programa tem a seguinte sada:
Se criarmos variveis do tipo PessoaFisica ou PessoaJuridica, atribuirmos os

valores para nome e cpf ou cnpj, depois disso podemos fazer variveis do tipo Pessoa
terem referencia para o mesmo objeto que as variveis do tipo PessoaFisica e
PessoaJuridica, exemplo:
Na linha 21 foi criado uma varivel pessoa1 do tipo Pessoa que recebe um objeto do
tipo PessoaFisica.
Na linha 22 foi criado uma varivel pessoa2 do tipo Pessoa que recebe um objeto do
tipo PessoaJuridica.
Quando executarmos este programa tem a seguinte sada:
Dessa vez o valor do cpf e cnpj so impressos, pois foram previamente preenchidos.
16.1 - Casting de objetos
Vimos anteriormente que uma Pessoa (superclasse) nem sempre UMA

PessoaFisica (subclasse), mas quando estamos trabalhando com uma superclasse e temos
a certeza de qual o tipo de subclasse ele est representando podemos fazer o casting de
objetos, para guardar o objeto em sua classe, funciona de forma similar ao casting de
atributos primitivos.
No exemplo abaixo vamos criar duas variveis do tipo Pessoa com objetos do tipo
PessoaFisica e PessoaJuridica, depois vamos tambm criar uma varivel do tipo Object
(que a superclasse de todas as classes) e guardar nela um objeto do tipo String.
Na linha 21 estamos fazendo um casting de Pessoa para PessoaFisica.

Na linha 24 estamos fazendo um casting de Pessoa para PessoaJuridica.
Na linha 27 estamos fazendo um casting de Object para String.
Temos a seguinte sada no console:
16.2 - Exerccios
1. Crie uma classe Funcionario com o seguinte atributo:
private double salario;

Determina o salrio do funcionrio.
E os mtodos:
public double getSalario();

Retorna o salrio do funcionrio.
public double setSalario(double salario);
Coloca valor no salrio do funcionrio.
public double calcularParticipacaoNosLucros();
Retorna 0;
E as seguintes classes filhas, com apenas um mtodo:
<< Gerente >>

Calcula a participao nos lucros do funcionrio. Frmula: Salrio * 0,5
<< Secretaria >>

Calcula a participao nos lucros do funcionrio. Frmula: Salrio * 0,2
Feito isso, instancie dois objetos de cada um dos tipos das subclasses, mas
armazenando-os em referencias para Funcionario, da seguinte forma:
Funcionario carlos = new Gerente();

Funcionario amanda = new Secretaria();
Teste o polimorfismo, referenciando o mtodo calcularParticipacaoNosLucros().
2. Crie uma classe Computador com os seguintes atributos:
private int velocidadeDoProcessador;

Determina a velocidade do processador.
private int qtdMemoria;
Determina a quantidade de memria.
private String fabricanteDoProcessador;
Determina a quantidade de memria.
E os seguintes mtodos:
public Computador(int vel, int memo, String proc);

Construtor base da classe.
public String dizerInformacoes();
Deve retornar o texto:
Sou um computador. Meu processador + fabricanteDoProcessador + trabalha a
uma velocidade + velocidadeDoProcessador + . Possuo + qtdMemoria + Mb
de memria..
public final String getFabricanteDoProcessador();
Retorna o fabricante do processador.
public final int getVelocidadeDoProcessador();
Retorna a velocidade do processador.
public final int getQtdMemoria();
Retorna a quantidade de memria.
Feito isso, crie mais duas outras classes chamadas Desktop e Notebook, classes filhas
de Computador, com os seguintes atributos e mtodos a mais, alguns sobrescritos:
<< Notebook >>
public int qtdAltoFalantes;

Determina a quantidade de alto-falantes.
public boolean possuiTouchPad;
true caso possua touchPad e false caso no o possua..
public Notebook(int vel, int memo, String proc);

Construtor base da classe. Deve assumir que qtdAltoFalantes = 0 e
possuiTouchPad = false.
public Notebook(int vel, int memo, String proc, int falantes, boolean touch);
Novo construtor da classe.
public int getQtdAltoFalantes ();

Retorna a quantidade de alto-falantes.
public boolean isPossuiTouchPad();
Retorna true caso possua touchPad.
public String retornaInformacoesCompletas();
Sou um notebook. Meu processador + super.getFabricanteDoProcessador() +
trabalha a uma velocidade + super.getVelocidadeDoProcessador() +
. Possuo + super.getQtdMemoria() +
Mb de memria. Tenho um total de + qtdAltoFalantes + alto-falantes;
<< para resgatar as informaes da superclasse use a palavra chave super >>

Sou um notebook. Meu processador + fabricanteDoProcessador + trabalha a
uma velocidade + velocidadeDoProcessador + . Possuo + qtdMemoria + Mb
de memria..
<< Desktop >>
public String corDoGabinente;

Determina a cor do gabinete.
public int potenciaDaFonte;
Inteiro que armazena a potncia da fonte. Ex: 300, 350, 400, etc.
public Desktop(int vel, int memo, String proc);

Construtor base da classe. Deve assumir que corDoGabinete = new
String(branco) e potenciaDaFonte = 400.
public Desktop(int vel, int memo, String proc, String cor, int pot);
Novo construtor da classe.
public String getCorDoGabinente();

Retorna a cor do gabinete.
public int getPotenciaDaFonte();
Retorna a potncia da fonte.
public String retornaInformacoesCompletas();
Sou um desktop. Meu processador + super.getFabricanteDoProcessador() +
trabalha a uma velocidade + super.getVelocidadeDoProcessador() +
. Possuo + super.getQtdMemoria() +
Mb de memria. Meu gabinete de cor + corDoGabinete + .;
<< para resgatar as informaes da superclasse use o modificador super >>
Sou um desktop. Meu processador + fabricanteDoProcessador + trabalha a uma
velocidade + velocidadeDoProcessador + . Possuo + qtdMemoria + Mb de
memria..
Para testarmos nosso ambiente, crie uma classe Principal que instancie trs objetos,
sendo um de cada um dos tipos.
Para atestar a questo da herana, nos objetos dos tipos Notebook e Desktop, faa
chamadas aos mtodos da superclasse Computador como, por exemplo, o mtodo
dizerInformacoes().
Feito isso, para testarmos o polimorfismo, instancie objetos dos tipos NoteBook e
Desktop e atribua-os a referencias de Computador. Agora teste o polimorfismo, invocando
o mtodo dizerInformacoes().
17 - Conexo com bancos de dados - J.D.B.C.
O banco de dados onde persistimos (armazenamos) os dados que pertencem ao

nosso sistema. A maioria dos bancos de dados comerciais hoje em dia do tipo relacional e
derivam de uma estrutura diferente da orientada a objetos.
Para executarmos o manuseio de informaes em um banco de dados, devemos fazer
uso de sub-linguagens de banco de dados (Database Sub Language DSL) voltadas para
as especificidades dos objetos e operaes do banco de dados. Geralmente, as sub-
linguagens de dados so compostas da combinao de recursos para a definio de dados
(Data Definition Language DDL) e recursos especficos para a manipulao de dados (Data
Manipulation Language DML). A conhecida linguagem de consulta SQL (Structured Query
Language) uma destas linguagens que fornece suporte tanto a DDL como a DML.
Para efetivarmos a conexo de um programa desenvolvido em Java com uma base de
dados qualquer, a linguagem Java implementa um conceito de ponte, que implementa todas
as funcionalidades que um banco de dados padro deve nos fornecer.
No desenho acima podemos notar o relacionamento direto da JDBC com o banco de

dados, porm este relacionamento depende tambm da extenso desta ponte que
representada pela implementao JDBC escolhida. Esta implementao depende do banco
de dados com o qual queremos nos comunicar e a ela damos o nome de Driver. Para
gerenciar estes drivers de conexo, a linguagem Java possui um gerente de drivers chamado
java.sql.DriverManager.
O driver do MySQL pode ser adicionado atravs das Propriedades do Projeto, na

aba Biblioteca utilize o boto Adicionar Biblioteca e selecione MySQL JDBC Driver.
OBS: caso voc queria colocar o driver de outro banco de dados preciso clicar no boto
Adicionar JAR/Pasta e selecionar o arquivo .jar que representa o drive desejado (OBS: no
site do fabricante possvel obter este driver).
Para criarmos uma conexo com o banco de dados primeiramente necessrio

informarmos qual driver de conexo o DriverManager deve utilizar.
Feita essa disponibilizao do arquivo de driver, na programao se faz necessrio
registrar o driver do banco de dados no sistema. Para isso, basta carreg-lo atravs do
mtodo Class.forName(). Esse mtodo abre uma classe que se registra com o
DriverManager.getConnection().
A partir da classe DriverManager, podemos utilizar um mtodo chamado
getConnection, com o qual poderemos nos conectar a uma determinada base de dados
utilizando uma String padro de conexo.
Na linha 23 estamos carregando o driver do banco de dados MySQL

com.mysql.jdbc.Driver.
Na linha 24, utilizamos o mtodo getConnection da classe DriverManager para criar
uma conexo com o banco de dados armazenado em um objeto do tipo
java.sql.Connection.
O mtodo getConnection() recebe trs parmetros: 1 url de conexo com o banco
de dados, 2 usurio e 3 senha.
Para fazer a conexo com o banco de dados precisamos tratar algumas excees que
podem ocorrer:
Na linha 26, tratamos a exceo java.sql.SQLException que lanada caso no
consiga criar uma conexo com o Banco de Dados.
Na linha 28, tratamos a exceo java.lang.ClassNotFoundException que lanada
caso no consiga carregar o driver do banco de dados.
Depois de utilizar a conexo com o banco de dados muito importante que liberemos
esta conexo, ou seja, precisamo encerrar a conexo com o banco de dados.
Na linha 35 temos o mtodo desconectar que recebe uma Connection como
parametro, dentro deste mtodo estamos verificando se a conexo com o banco ainda no
foi encerrada para depois encerra-la. Quando tentamos encerrar uma conexo com o banco
tambm pode ocorrer alguma exceo para isso na linha 41 estamos tratando caso ocorra
alguma java.sql.SQLException.
Quando executamos esta classe temos a seguinte sada no console:
17.1 - Consulta de dados
Uma vez conectado, podemos ento solicitar a execuo de comandos SQL, para que
tenhamos acesso a este tipo de chamada ao banco de dados necessrio criarmos um
java.sql.Statement.
O Statement o objeto que servir de instrumento para a execuo de comandos
SQL, porm importante ressaltar que o intuito de uma consulta a um banco de dados o
de receber uma informao, logo, fundamental que essa resposta seja armazenada em
uma estrutura. Para isso podemos utilizar a classe java.sql.ResultSet que deve receber o
retorno do mtodo executeQuery que responsvel por executar a consulta.
Exemplo:
Quando executamos essas classe temos a seguinte sada no console:
Note pelo exemplo acima que o mtodo responsvel por executar a consulta na base
de dados foi o executeQuery na linha 27. Observe tambm a forma como o ResultSet foi
percorrido na linha 29.
A classe ResultSet oferece o mtodo next() para percorrer a resposta dada pelo
banco de dados. Caso nossa consulta acima lista houvesse retornado 4 linhas, por padro o
ResultSet estaria com seu ponteiro posicionado na posio -1, logo, antes de ler a primeira
linha de resposta de sua consulta necessrio a chamada a este mtodo next() para que o
ponteiro passe para a primeira posio e possa resgatar as informaes desejadas. O
mtodo next() retorna true, caso ainda existam novas linhas na resposta e false quando no
tem mais registros para percorrer.
importante ressaltar que apenas um nico objeto ResultSet pode ser aberto por vez
por Statement ao mesmo tempo.
Para resgatar as informaes desejadas, a classe ResultSet oferece mtodos do tipo
get para todos os tipos de dados primitivos, exceto char. Todos estes mtodos devem
receber como parmetro o nome da coluna de resposta, assim como no exemplo acima, ou o
nmero correspondente a posio da coluna retornada.
17.2 - Manipulao de dados
Podemos utilizar a classe Statement para guardar (persistir) ou atualizar as

informaes na base de dados, utilizando o mtodo execute.
Na linha 26, pedimos para o Statement adicionar um novo registro na tabela PESSOA
do banco de dados.
Na linha 42, pedimos para o Statement atualizar um registro da tabela PESSOA do
banco de dados.
Note que para adicionar ou atualizar as informaes no banco de dados, podemos
utilizar o mtodo execute.
A classe Statement possui o mtodo execute para adicionar ou atualizar um registro

no banco de dados e o mtodo executeUpdate para atualizar as informaes no banco de
dados, a diferena que este mtodo retorna um inteiro com a quantidade de registros que
foram alterados.
Aps a concluso das operaes e leitura ou de manipulao de dados, importante
a chamada ao mtodo close(), tanto da classe Statement como da classe Connection, para
que a conexo com o banco de dados seja finalizada.
17.3 - Relao de algumas bases de dados
Banco Driver String de Conexo

Microsoft ODBC sun.jdbc.odbc.JdbcOdbcDriver jdbc:odbc:<<nome da base>>
MySQL com.mysql.jdbc.Driver jdbc:mysql://<<ipDoBanco>>/<<baseDeDados>>
jdbc:oracle:thin:@<<ipDoBanco>>:1521:<<nomeDaBase>> ou
jdbc:oracle:thin:@ (DESCRIPTION=
Oracle oracle.jdbc.driver.OracleDriver (ADDRESS_LIST=(ADDRESS = (PROTOCOL = TCP)(HOST =
<<ipDoBanco>>)(PORT = 1521))) (CONNECT_DATA
=(SERVICE_NAME = <<nomeDaBase>>)))
17.4 - Exemplo de aplicao C.R.U.D. (Create Read Update Delete)
Neste exemplo vamos, passo a passo, criar uma aplicao completa de acesso a uma
base de dados utilizando JDBC.
Para esta aplicao, iremos criar um sistema de cadastro de veculos. Para tal,
criamos o POJO Carro, como segue abaixo:
Agora que j temos modelado a nossa classe principal, devemos definir como nosso
programa ir interagir com a base de dados.
Para estabelecermos a conexo com a base de dados de uma maneira mais simples,
faremos uso da classe Conexao, conforme segue abaixo:
Utilizaremos um padro de projeto chamado DAO (Data Acess Object). O DAO deve
saber buscar os dados do banco e converter em objetos para ser usado pela sua aplicao.
Semelhantemente, deve saber como pegar os objetos, converter em instrues SQL e
mandar para o banco de dados. Desta forma conseguimos distinguir fortemente a
modelagem do sistema da modelagem de dados e das regras de negcio.
Geralmente, temos um DAO para cada objeto do domnio do sistema, ou seja, para
nosso exemplo criaremos uma classe CarroDAO com as quatro operaes bsicas,
definidas por seus mtodos.
Para que a classe acima no apresente nenhum erro de compilao, necessrio que
voc acrescente a biblioteca (arquivo .jar) correspondente ao seu banco de dados. Para o
nosso exemplo, devemos importar o arquivo correspondente ao banco de dados MySQL.
Observe que nosso mtodo incluir() apenas recebe o objeto Carro a ser inserido na
base de dados e internamente faz toda a operao relacionada ao banco de dados. Desta
forma, conseguimos isolar toda esta interao com a base de dados do restante do cdigo,
tornando-o mais simples de se realizar qualquer tipo de manuteno.
O mtodo consultarPorPlaca recebe apenas a placa de um carro (imagine que esta
informao uma chave da tabela e que no devemos ter mais de um carro com a mesma
placa) e que retorna um objeto do tipo Carro com todos os seus atributos devidamente
alimentados.
O mtodo alterarPorPlaca() recebe um objeto Carro e a partir de sua placa faz a
atualizao nos atributos placa e potencia.
O mtodo excluir() recebe o Carro como parametro e o apaga da base de dados,
Para testarmos nosso sistema, crie um programa semelhante ao abaixo:
Ao executarmos a classe TestarCarro temos a seguinte sada no console:
A console fica aguardando at que digitemos alguma opo, primeiro vamos criar um
novo carro para isto vamos entrar com a opo I:
Se consultarmos todos os carros cadastrados no banco de dados aparecer o carro

que acabamos de criar:
Agora vamos utilizar a opo C para consultar um carro pela placa abc-1234:
Agora vamos utilizar a opo A para alterar as informaes de modelo e potencia:
Se consultarmos todos os carros cadastrados no banco de dados aparecer o carro

que acabamos de alterar:
Agora vamos utilizar a opo E para apagar o carro do banco de dados.
Se consultarmos todos os carros, no teremos nenhum registro no banco de dados:
17.5 - Exerccios
1) Crie uma aplicao CRUD (Salvar, Remover, Atualizar e Apagar) para controlar as
informaes referentes a Produto (nome, preco, tipo e data de validade).
2) Crie uma aplicao para controlar a venda e o estoque dos produtos criados no exercicio
anterior.
O controle de estoque deve conter o Produto e sua Quantidade em estoque, cada vez
que um produto vendido deve ser reduzido do estoque a quantidade de produtos e caso a
quantidade em estoque seje menor ou igual a 10 ento deve informar que necessario
comprar mais produto, se o estoque for 0 (zero) ento no deve permitir a venda do produto.
18 - Interfaces grficas - SWING
A Linguagem Java oferece dois pacotes bsicos para o desenvolvimento de interfaces

grficas, sendo eles o AWT e o Swing. Em nosso curso, faremos uso do pacote swing, que
um pacote derivado do awt com a vantagem de ser 100% multiplataforma.
Todos os pacotes oferecem recursos para criao de janelas, barras de menu, guias,
botes, etc...
Utilizando o NetBeans como IDE de desenvolvimento para interfaces grficas
O NetBeans uma IDE de desenvolvimento que oferece suporte aos mais variados
segmentos de desenvolvimento JAVA, desde o desenvolvimento de aplicaes robustas at
aplicaes para dispositivos portteis, porm seu grande diferencial est no desenvolvimento
de interfaces grficas, por oferecer um ambiente amigvel, simples e intuitvel.
A seguir, termos um passo a passo, listando os principais pontos de como se criar
uma aplicao grfica no NetBeans.
Passo 1 Criando um projeto
Para que seja possvel se criar e organizar seus arquivos JAVA, primeiramente
necessria a criao de um novo projeto. Para tal, basta acessarmos a opo:
File (Arquivo) New Project... (Novo Projeto)
Na aba Categories (Categorias) selecione a opo e na aba Projects (Projetos)

selecione a opo Java Application (Aplicao Java). Isso nos remete a criao de um
projeto padro do Java.
Feito isso, clique em Next (Prximo) uma nova janela ser exibida, solicitando que
mais informaes sejam fornecidas:
Nesta janela, devemos preencher o campo Project Name (Nome do Projeto) com
alguma informao. Preferencialmente, coloque um nome que tenha relao com o programa
que voc ir desenvolver.
Mais abaixo existe a opo Project Location (Localizao do projeto). Neste campo,
podemos alterar o local onde os arquivos desenvolvidos sero salvos.
Ateno: caso voc queira resgatar suas classes mais tarde, este ser o caminho que
voc acessar para localizar seus arquivos .java. Dentro do projeto tem uma pasta
chamada src e dentro desta pasta fica os arquivos fontes.
A opo Set as Main Project (Definir como Projeto Principal), apenas identificar a
IDE que este seu projeto principal de trabalho, caso voc possua mais de um projeto
aberto dentro do NetBeans.
Por fim, na opo Create Main Class (Criar Classe Principal), possvel criar uma
classe inicial no projeto. Esta classe ser responsvel por iniciar a chamada a outras classes
do projeto. Coloque um nome que julgar melhor, sendo que no nosso caso colocamos o
nome Principal, devido a sua funo em nosso projeto.
Clique em Finish (Finalizar).
Passo 2 Criando uma nova classe (JFrame)
Inicialmente, nosso projeto ser dividido em 4 pastas principais, sendo que a pasta na
qual criaremos nossos novos arquivos Java ser a de nome Source Packages (Pacotes de
Cdigo-Fonte).
Clicando com o boto direito do mouse sobre nome Source Package, ou sobre o
nome do pacote metodista.aula.swing, temos acesso a um menu de opes. Dentro deste
menu, mais especialmente na primeira opo: New (Novo), podemos escolher qual o tipo de
novo componente desejamos criar. Para a criao de uma janela, selecione a opo JFrame
Form (Formulrio JFrame), conforme figura abaixo.
Com isso uma nova Janela ser exibida:
Nesta nova janela coloque apenas o Class Nome (Nome da Classe), conforme a figura
abaixo e clique em Finish (Finalizar).
Passo 3 Editando visualmente seu novo Formulrio JFrame
Com nossa classe devidamente criada, seremos automaticamente direcionados para a

tela de edio grfica.
Ao lado direito temos a Palette (Paleta), com a lista de componentes que podem ser
colocados no JFrame, e logo abaixo a janela de Properties (Propriedades).
Ao lado esquerdo, temos a janela do Project (Projeto), logo abaixo o Navigator
(Navegador) e o Inspector (Inspetor). O Inspetor nos mostra todos os componentes que j
foram adicionados ao JFrame.
A seguir, na janela do Inspector (Inspetor), vamos clicar com o boto direito do mouse
no JFrame, e indo at a opo Set Layout (Definir Layout), podemos escolher a opo Null
Layout, a qual nos dar mais liberdade para trabalhar com o JFrame. Caso seja da
preferncia, podemos manter marcada a opo Free Design (Desenho Livre), que habilitar
o novo assistente de criao de janelas chamado Matisse.
O Matisse um assistente bastante interessante que procura automaticamente alinhar
e dimensionar os componentes, de forma padronizada e seguindo as melhores prticas de
desenvolvimento.
Agora selecione o JFrame clicando sobre ele uma vez com o boto esquerdo do
mouse na janela principal, ou na janela do Inspector e na janela de Propriedades vamos
selecionar a opo Code (Cdigo). Na nova listagem que ser exibida, altere o valor de
Form Size Policy (Poltica de Tamanho de Formulrio) para Generate Resize Code (Gera
Cdigo de Redimensionamento).
Este modo de redimensionamento utilizado para os itens da tela serem ajustados

automaticamente conforme o tamanho da janela alterado.
Para trocar entre o ambiente de Design (Desenho) que mostra um ambiente mais
grfico e fcil de visualizar os componentes e o ambiente de Fonte (Source) que mostra o
cdigo fonte da classe, usamos as seguintes abas:
Passo 4 Adicionando novos componentes ao Formulrio JFrame
Agora iremos adicionar trs novos componentes ao nosso JFrame:

JButton (boto)
JLabel (texto)
JTextField (campo para entrada de texto)
Para isso, na janela Paleta, selecione o primeiro destes componentes e clique no dentro
do JFrame no local onde deve ficar o componente. Repita este Procedimento para os outros
dois componentes, resultando ento a algo semelhante a janela abaixo:
Com cada um dos componentes devidamente alocados, podemos mov-los ou

redimension-los livremente.
Clicando com o boto direito do mouse sobre cada um dos componentes, poderemos
listar algumas opes:
Iremos selecionar a opo Change Variable Name... (Mudar o nome da varivel) e

vamos colocar os seguintes nomes nas variveis:
o JTextField vamos chamar de entrada;
o JButton vamos chamar de botao;
e o JLabel vamos chamar de saida.
Feito isso, mais uma vez, clique com o boto direito do mouse sobre cada um dos trs
componentes e selecione a opo Edit Text (Editar Texto), para alterar o texto exibido em
cada um destes componentes. Por hora, vamos apagar o texto do JTextField e do JLabel e
vamos alterar o texto do JButton para Clique aqui.
O resultado ser algo prximo da janela abaixo:
Note que o JLabel mesmo no parecendo visvel, ele ainda est no JFrame e pode ser
visto e selecionado atravs do Inspector.
Aps estes passos, possvel notar que o novo nome do componente pode ser obtido
tanto na janela do Inspector como, aps selecionar o componente desejado, na janela de
Propriedades, propriedade Variable Name (Varivel Nome).
Note que todos os componentes que estamos trabalhando aqui so Objetos e o

JFrame, JButton, JTextField e JLabel. Quando adicionamos estes componentes na
tela, estamos criando uma nova instancia dos objetos deles.
Passo 5 Adicionando uma ao ao boto
Para adicionarmos uma ao ou um Evento propriamente dito ao boto, devemos

clicar sobre ele (ou sobre seu correspondente na janela do Inspector) com o boto direito do
mouse e dentro da opo Events (Eventos), devemos selecionar Action e por fim a opo
actionPerformed. Essa ao automaticamente nos direcionar para o modo de edio de
fonte (Source).
Uma vez no modo de edio Fonte, estar com o cursor dentro do seguinte texto:
Lembre-se... o // simboliza uma linha de comentrio, logo apague esta linha e no

lugar dela escreva o texto abaixo, ficando ento este trecho de cdigo da seguinte maneira:
Com essas 2 linhas, estamos realizando as seguintes aes:

Na Linha 72, lemos o contedo de texto que existe no componente entrada (o
JTextField) e armazenamos seu valor na varivel do tipo String chamada dados.
Na linha 73, colocamos no componente saida (o JLabel) o texto que havamos
guardado na varivel String.
Com isso, sabemos agora que com os cdigos getText() e setText(), podemos
pegar ou colocar um texto em um dos componentes, assim como fizemos no passo 4,
porm durante a execuo do programa.
Por fim, devemos chamar essa nossa nova janela de algum lugar, ento clicaremos 2
vezes sobre a classe Principal no menu Projeto e a editaremos da seguinte maneira:
Na linha 9 estamos criando um objeto do nosso formulrio (PrimeiroForm) e na linha

10 estamos declarando que o mesmo deve ficar visvel.
Feito isso, basta salvar ambos os arquivos e clicar com o boto direito do mouse sobre
a classe Principal.java na janela do Projeto e selecionar a opo Run File (Executar
Arquivo).
Por fim, nosso programa ser executado, e note que ao se digitar algo na JTextField e
clicar no boto, todo o texto inserido na JTextField ser transferido para a JLabel.
18.1 - Utilizando o JFrame
O JFrame uma classe que representa uma janela ou quadro da aplicao desktop,
dentro dele podemos adicionar diversos componentes como botes, textos, campos de
digitao, listas, imagens.
Alguns dos mtodos mais utilizados do JFrame so:
JFrame.setDefaultCloseOperation(int operation)
Seta a forma como a janela do JFrame deve ser fechada, seus valores podem ser:
- HIDE (Janela continua aberta, mas no mostrada na tela)
- DO_NOTHING (No faz nada)
- EXIT_ON_CLOSE (Encerra todo o programa, usando o System.exit(0))
- DISPOSE (Fecha a janela)
Exemplo:
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
JFrame.setTitle(String title)
Altera o titulo da janela, este mtodo recebe uma String como titulo.
Exemplo:
setTitle("Primeiro Formulrio");
JFrame.setResizable(Boolean resizable)
Dependendo do valor true (verdadeiro) ou false (falso), a janela JFrame permite ter
seu tamanho alterado durante sua execuo.
Exemplo:
setResizable(false);
JFrame.setName(String name)
Altera o nome da janela JFrame.
Exemplo:
setName("principal");
Para trocar a cor do JFrame, podemos fazer da seguinte forma:
this.getContentPane().setBackground(new java.awt.Color(204, 255, 204));
18.2 - Utilizando JTextField
O pacote Swing, conta com uma classe chamada JTextField. Esta classe
responsvel por receber texto quando adicionada a um container (JFrame).
Para adicion-lo a sua aplicao, localize-o no painel ao lado direito na Paleta, clique
sobre ele e clique sobre o JFrame. Aps o JTextField ter sido posicionado, possvel alterar
sua disposio e tamanho no formulrio.
Este campo capaz de receber qualquer tipo de dado, seja ele numrico ou caractere,
mas todos os caracteres digitados nele so guardados dentro de uma String.
E vimos anteriormente que podemos alterar o nome e texto do JTextField.
Alguns dos mtodos mais utilizados do JTextField so:
JTextField.getText()
Retorna o valor digitado dentro do campo solicitado.
Exemplo:
String texto = entrada.getText();
JTextField.setText(String texto)
Coloca uma String dentro do campo JTextField solicitado.
Exemplo:
entrada.getText(O texto deve estar entre aspas duplas);
JTextField.setEditable(boolean valor)
Dependendo do valor passado true (verdadeiro) ou false (falso) permite ou no a
edio do campo.
Exemplo:
entrada.setEditable(true);
JTextField.setEnabled(boolean valor)
Dependendo do valor passado true (verdadeiro) ou false (falso) desativa o campo
solicitado.
Exemplo:
entrada.setEditable(false);
JTextField.setFont(Font font)
Altera o tipo de formato da fonte do componente JTextField. Este mtodo recebe um
objeto do tipo Font que defini a fonte, estilo do texto e tamanho.
Exemplo:
entrada.setFont(new java.awt.Font("Arial", 1, 10));
JTextField.setBackground(Color c)
Alterar a cor do fundo do JTextField. Este mtodo recebe um objeto do tipo Color,
que utiliza o padro RGB para definir a cor.
Exemplo:
entrada.setBackground(new java.awt.Color(204, 255, 204));
18.3 - Utilizando JButton
Assim como o JTextField, o componente JButton tambm faz parte do pacote Swing.
Esta classe uma das mais importantes de todas as aplicaes, pois na maioria dos casos,
nela onde adicionamos as aes que desejamos que nosso programa execute. Para
adicion-lo a sua aplicao, localize-o na Paleta e clique dentro do JFrame na posio
desejada. Depois de posicionado, possvel alterar sua disposio e tamanho.
Tambm como fizemos com o JTextField, recomendvel alterar o texto e o nome da

varivel que representar este componente no programa. Para tal, utilize os mesmos
procedimentos listados no trecho que fala do JTextField. Neste momento aconselhvel
uma ateno especial ao nome do boto para que o mesmo seja intuitivo no sentido de
auxiliar o usurio na utilizao do seu programa.
Alguns dos mtodos mais utilizados do JButton so:
JButton.getText()
Retorna o texto escrito no boto. O mesmo digitado na criao do programa pela
opo Edit Text Editar Texto, do boto direito do mouse.
Exemplo:
String texto = botao.getText();
JButton.setText(String texto)
Coloca uma String dentro do boto JButton solicitado.
Exemplo:
botao.setText(O texto deve estar entre aspas duplas);
JButton.setEnabled(boolean valor)
Dependendo do valor passado true (verdadeiro) ou false (falso) desativa o campo
solicitado.
Exemplo:
botao.setEditable(false);
JButton.setFont(Font font)
Altera o tipo de formato da fonte do componente JButton. Este mtodo recebe um
Exemplo:
botao.setFont(new java.awt.Font("Arial", 1, 10));
JButton.setBackground(Color c)
Alterar a cor do fundo do JButton. Este mtodo recebe um objeto do tipo Color, que
utiliza o padro RGB para definir a cor.
Exemplo:
botao.setBackground(new java.awt.Color(204, 255, 204));
JButton.setIcon(ImageIcon imageIcon)
Adiciona um cone dentro do boto. Este mtodo recebe um objeto o tipo ImageIcon
que representa uma imagem, e esta imagem pode estar dentro do seu projeto ou pode estar
em algum diretrio do micro.
Exemplo:
botao.setIcon(new javax.swing.ImageIcon(getClass().getResource(
"/metodista/aula/imagens/ok.jpg")));
18.4 - Utilizando o JLabel
O JLabel um componente utilizado para mostrar textos ou imagens na tela. Para

adicion-lo a sua aplicao, localize-o na Paleta e clique dentro do JFrame na posio
desejada. Depois de posicionado, possvel alterar sua disposio, tamanho, texto e nome.
Alguns dos mtodos mais utilizados do JLabel so:
JLabel.getText()
Retorna o texto escrito no boto. O mesmo digitado na criao do programa pela
opo Edit Text Editar Texto, do boto direito do mouse.
Exemplo:
String texto = saida.getText();
JLabel.setText(String texto)
Coloca uma String dentro do label JLabel solicitado. Uma coisa interessante que a
propriedade text do JLabel pode receber um texto no formato HTML.
Exemplo:
saida.setText(O texto deve estar entre aspas duplas);
JLabel.setFont(Font font)
Altera o tipo de formato da fonte do componente JLabel. Este mtodo recebe um
Exemplo:
saida.setFont(new java.awt.Font("Arial", 1, 10));
JLabel.setBackground(Color c)
Alterar a cor do fundo do JLabel. Este mtodo recebe um objeto do tipo Color, que
utiliza o padro RGB para definir a cor.
Exemplo:
saida.setBackground(new java.awt.Color(204, 255, 204));
JLabel.setIcon(ImageIcon imageIcon)
Adiciona uma imagem dentro do JLabel. Este mtodo recebe um objeto o tipo
ImageIcon que representa uma imagem, e esta imagem pode estar dentro do seu projeto ou
pode estar em algum diretrio do micro.
Exemplo:
saida.setIcon(new javax.swing.ImageIcon(getClass().getResource(
"/metodista/aula/imagens/saida.jpg")));
18.5 - Utilizando o JComboBox
O JComboBox utilizado para mostrar uma lista de itens onde o usurio deve
escolher um desses itens. Para adicion-lo a sua aplicao, localize-o na Paleta e clique
dentro do JFrame na posio desejada. Depois de posicionado, possvel alterar sua
disposio, tamanho, texto e nome.
Alguns dos mtodos mais utilizados do JcomboBox so:
JComboBox.setModel(ComboBoxModel aModel)
Adiciona os itens que sero listados dentro do JComboBox.
Exemplo:
cmbNomes.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "Rafael",
"Cristiano", "Leonardo" }));
JComboBox.getSelectedItem()
Retorna o item que foi selecionado no formato de Objeto.
Exemplo:
String nomeSelecionado = (String) cmbNomes.getSelectedItem();
JComboBox.setMaximumRowCount(int count)
Informa qual a quantidade mxima de itens sero exibidos no JComboBox, se o
tamanho mximo for menor que a quantidade de itens dentro do JComboBox, ento ser
mostrado uma barra de rolagem dentro dele.
Exemplo:
cmbNomes.setMaximumRowCount(2);
JComboBox.setFont(Font font)
Altera o tipo de formato da fonte do componente JComboBox. Este mtodo recebe um
Exemplo:
cmbNomes.setFont(new java.awt.Font("Verdana", 1, 12));
18.6 - Imagens no Swing
Para se manusear imagens no Java, mais especificamente no Swing muito simples.

Para tal, basta utilizar um componente j conhecido do tipo JLabel.
Assim como segue o exemplo abaixo, crie um formulrio JFrame e adicione ao

mesmo um componente JLabel, como segue no exemplo abaixo:
Feito isso, existem duas maneiras de se adicionar uma figura a este componente. A
mais simples delas simplesmente acessando o menu de propriedades deste item, e
alterando a sua propriedade de nome Icon.
Clicando ento nessa propriedade uma janela de configuraes ser exibida e lhe
ser dada a opo de adicionar uma figura dentro do projeto ou dentro de algum diretrio do
computador ou url. Com isso, teremos ento uma janela com a figura desejada:
Assim como foi possvel alterarmos o valor desta propriedade no menu de

propriedades do NetBeans, tambm possvel incluir ou alterar uma figura em tempo de
execuo. Para isto, podemos fazer uso do seguinte mtodo:
<<JLabel>>.setIcon( )
Este mtodo, setIcon(), deve receber como parmetro um objeto do tipo Icon, para
isto, utilize a seguinte sintaxe:
<<JLabel>>.setIcon(new ImageIcon("foto.jpg"));
Onde o arquivo de foto deve estar na pasta inicial do projeto. Caso deseje utilizar
caminhos relativos, utilize a notao desde a raiz do sistema operacional.
Ex:
<<JLabel>>.setIcon(new ImageIcon("c:/minhasFotos/foto.jpg"));
Para alterar uma imagem em tempo de execuo por outra contida dentro de seu
projeto, basta utilizar o seguinte comando:
<<JLabel>>.setIcon(new ImageIcon(getClass().getResource(/pacote/arquivo)));
Onde /pacote/arquivo o endereo completo da figura dentro de seu projeto. Note que
este mtodo mais interessante, visto que a figura ir compor seu projeto e no necessitar
ser colocada em um caminho fixo no sistema operacional.
Ex:
projetoJava/imagens/Logo.gif
Agora sabendo como manusear fotos em tempo de execuo, sabemos ento como
alterar fotos de acordo com a interao do usurio com nosso programa.
A utilizao do componente ImageIcon no automaticamente entendida pelo Java,

logo, necessrio que na linha que antecede a declarao da classe (public class Imagens
extends javax.swing.JFrame { ) seja acrescentada uma importao deste componente da
seguinte forma:
import javax.swing.ImageIcon;
18.7 - Exemplo de aplicao desktop.
Neste exemplo vamos criar uma tela para cadastrar pessoas e essas pessoas sero
armazenadas dentro de um vetor de pessoas e exibido uma lista com os nomes das pessoas
cadastradas.
Vamos criar um novo Projeto Java chamado ListaPessoas, e adicionar um pacote

chamado metodista.poo.listapessoas.tela e outro pacote chamado
metodista.poo.listapessoas.pessoa, nosso projeto deve ficar assim:
Agora dentro do pacote metodista.poo.listapessoas.pessoa vamos criar uma classe

chamada Pessoa que possui os atributos nome e idade.
Vamos criar uma telinha dentro do pacote metodista.poo.listapessoas.tela, para o

usurio digitar o nome e idade da pessoa e guardar essas informaes em um vetor de
Pessoas.
O JTextField que guarda o texto do nome chama txtNome e o JTextField que guarda
o texto da idade chama txtIdade. O JButton que possui a funo de Cadastrar uma nova
pessoa chama btnCadastrar.
Foram adicionados mais alguns atributos e mtodos conforme cdigo abaixo:
Na linha 11 foi declarado um vetor de Pessoa chamado pessoas que suporta at 100
objetos dentro ele.
Na linha 12 foi declarado um inteiro que serve como contador, para marcar quantas
pessoas foram adicionadas no vetor.
Na linha 95 foi criado um mtodo que chamado quanto o boto clicado.

Na linha 96 pega os valores do txtNome e txtIdade, cria um objeto do tipo Pessoa.
Na linha 97 adiciona este novo objeto Pessoa dentro do vetor de pessoas.
Na linha 98 incrementa o contador que informa quantas pessoas tem cadastradas no
vetor.
Agora vamos adicionar na tela de cadastro de pessoas uma JLabel para mostrar para
o usurio quais so as pessoas que foram guardadas dentro do vetor.
E vamos alterar o cdigo do mtodo acionado quando o boto cadastrar clicado

para poder atualizar a lista de pessoas cadastradas:
Na linha 120, chama o mtodo atualizarListaPessoas, passando o vetor de pessoas e

o JLabel que ser atualizado.
Na linha 121 e 122 deixa o JTextField do nome e idade em branco.
Na linha 125, est declarando um mtodo que faz a atualizao do JLabel que mostra
as pessoas cadastradas.
Na linha 126, cria uma String que vai guardar o nome e idade de todas as pessoas,
est String ser escrita no formato HTML.
Na linha 127 a 129, temos um for que passa pelo vetor de pessoas e guarda na String
o texto encontrado.
Na linha 130, encerro o texto HTML dentro da String.
Na linha 132, atribui o valor da String listaPessoas no JLabel lblPessoas.
18.8 - JFileChooser
Existe um componente Swing que serve para localizar e selecionar um ou mais

arquivos no sistema operacional, seu nome JFileChooser (Selecionador de arquivo). Este
componente est localizado na barra lateral e representado pelo item:
Vamos criar um exemplo de aplicao para listar todos os arquivos de um diretrio:
Nossa tela ser esta mostrada na viso de Projeto.
Note que o componente JFileChooser foi adicionado na parte de Outros

componentes, pois este um componente um pouco grande e mante-lo dentro do JFrame
acaba atrapalhando visualmente o desenvolvimento da tela.
Nas propriedades do JFileChooser podemos definar atravs da propriedade
fileSelectionMode se ele ira aceitar FILES_ONLY (Somente Arquivos),
DIRECTORIES_ONLY (Somente Diretorios) e FILES_AND_DIRECTORIES (Arquivos e
Diretorios).
Vamos configurar nosso JFileChooser para aceitar somente diretrios
(DIRECTORIES_ONLY), pois vamos ler todos os arquivos do diretrio selecionado.
Depois de montado a tela vamos adicionar a ao do boto Pesquisar que ser

responsvel por abrir a tela do Selecionador de Arquivo (JFileChooser) e listar todos os
arquivos dentro da rea de texto (JTextArea).
Quando executarmos a aplicao teremos a seguinte tela:
Quando clicamos no boto Pesquisar abre a seguinte janela do Selecionador de

Arquivos:
Depois que selecionarmos o diretrio e clicarmos no boto Open, sero listados na

rea de texto todos os arquivos do diretrio.
18.9 - Utilizando o JMenuBar, JMenu e JMenuItem
Para criao de menus utilizamos os componentes JMenuBar para montar a barra do

menu, JMenu para criar o menu e JMenuItem para criar os itens do menu.
Vamos criar um programa para cadastrar, consultar, alterar ou excluir Livros, este
programa ser feito utilizando Swing e utiliza um menu para chamar outras telas.
A tabela do banco de dados tem as seguintes colunas, neste exemplo utilizaremos o

MySql, mas pode ser feito em qualquer outro banco de dados.:
ID Nmero - Chave Primaria - Obrigatrio

TITULO Texto - Obrigatrio
AUTOR Texto
ISBN Texto
PAGINAS Nmero
create table Livro (

id int not null auto_increment,
titulo varchar(50) not null,
autor varchar(50) not null,
isbn varchar(20) not null,
paginas int not null,
primary key(id)
);
Vamos criar agora a classe Livro:
Vamos criar uma classe chamada Conexao para fazer a conexo e desconexo do
banco de dados.
Agora vamos cria a classe LivroDAO que ser responsvel por manipular os dados
referentes a livro no banco de dados:
Feito a parte de comunicao com o banco de dados, vamos criar a tela principal do
sistema:
Crie um JFrame chamado Biblioteca e adicione dentro dele um Menu Bar

(JMenuBar) :
Quando criamos um JMenuBar, o mesmo j vem com dois JMenu (File e Edit), altere
os textos deles para Arquivo e Livro, depois altere o nome das variveis para
menuArquivo e menuLivro respectivamente:
Agora dentro do menu Arquivo, vamos adicionar um Menu Item (JMenuItem), esse
item ter o nome Sair e o nome da varivel deve ser alterado para arquivoSair. Nossa
JFrame deve ficar da seguinte forma:
O item Sair ser utilizado para encerrar a aplicao.
Dentro do menu Livro, adicione os seguintes Menu Itens (Novo e Listar) e os nomes
das variveis devem ser livroNome e livroListar respectivamente:
Agora vamos criar um novo JFrame chamado LivroNovo, que ser utilizado para
cadastrar novos livros:
Nesta tela vamos definir os seguintes construtores:
O boto Limpar deve apagar todos os campos da tela.
O boto Salvar deve salvar os dados do livro na base de dados interessante validar
o campo antes de salvar os dados.
Crie tambm um JFrame chamado LivroListar, que ser usado para mostrar todos os
livros cadastrados e tambm ser usado para excluir um livro ou chamar a tela para alterar
os dados do livro:
Vamos criar um mtodo dentro da classe LivroListar para recarregar a tabela

mostrando as informaes dos livros que consultamos:
Personalize o cdigo de criao da tabela, para quando ela for inicializada j consultar
as informaes do banco.
O boto Excluir deve excluir o registro de livro que estiver selecionado na tabela.
O boto Alterar deve chamar a tela de LivroNovo, passando o objeto livro que foi
selecionado na tabela.
Depois de criado as telas LivroNovo e LivroListar vamos adicionar as aes nos

itens do menu da tela Biblioteca:
O item do menu Arquivo Sair ter o seguinte cdigo que serve para fechar a
aplicao.
O item do menu Livro Novo ter o seguinte cdigo que serve para abrir a tela de
Novo Livro.
O item do menu Livro Listar ter o seguinte cdigo que serve para abrir a tela de
Listar Livros.
18.10 - Exerccios
1. Vamos criar uma calculadora utilizado o Swing. Nossa calculadora dever ter as seguintes
operaes: adio, subtrao, diviso e multiplicao.
2. Crie uma aplicao CRUD (Salvar, Remover, Atualizar e Apagar) para controlar as
informaes referentes Produto (nome, preco, tipo e data de validade) utilize uma interface
grafica Swing.
OBS: Utilize a estrutura criada no exercicio 1 do capitulo de JDBC.
18.11 - Exemplos de aplicaes Swing
18.11.1 - Exemplo de tratamento de exceo usando Swing
Primeiramente vamos criar uma tela com o seguinte layout:
Esta nossa tela de exemplo, ir se comunicar com uma classe chamada

Divisao, com o seguinte cdigo:
Note que no exemplo acima, uma nova exceo do tipo ErroDaConta est
sendo lanada linha 12, mas no ser tratada por um bloco try, ser remetida a
classe que a chama, no nosso caso a classe representada pela tela acima. Isto pode
ser observado pelo comando throws na linha 10.
Agora criaremos a nossa classe de exceo ErroDaConta.
Desta forma estamos criando nossa prpria exceo, declarando que nossa
classe filha de Exception, e que por este motivo ser uma checked exception. Na
linha 13 o seguinte construtor da classe Exception est sendo invocado:
Agora que j definimos as classes iniciais, vamos ao cdigo de nossa classe

JFrame, do incio do exemplo.
Perceba que, como fizemos uma chamada ao mtodo restoDaDivisao() e o

mesmo pode lanar uma exceo ErroDaConta, somos forados a utilizar o bloco try
para fazer este tratamento. Conforme a linha 117 tambm est prevendo a
possibilidade de nosso usurio solicitar uma diviso por zero, tipo de erro este que
representado no Java por uma java.lang.ArithmeticException e na linha 119
estamos prevendo a digitao de um nmero no inteiro atravs da exceo
java.lang.NumberFormatException (ambas classes filhas de RunTimeException)
que no necessitaria ser tratada, pois uma Unchecked Exception.
18.11.2 - Exemplo de aplicao C.R.U.D. com exibio em tela
Neste exemplo vamos criar uma tela que ser utilizada para visualizar os
caminhes que foram cadastrados, para adicionar novos caminhes e para apagar os
caminhes.
Vamos utilizar a classe Caminhao abaixo:
Vamos agora criar uma classe chamada CaminhaoDAO, que ser utilizada para
acessar os dados referentes ao caminho.
Na linha 10, temos o mtodo que criar as conexes com o banco de dados.
Na linha 25, temos o mtodo que fechar as conexes com o banco de dados.
Na linha 36, declaramos um mtodo que ser utilizado para consultar todos os
caminhes cadastrados.
Na linha 42, criamos uma String com a consulta de todos os caminhes da
tabela CAMINHAO.
Na linha 44, executa a consulta e guarda seu resultado dentro de um
ResultSet.
Na linha 47, temos um while que serve para percorrer todos os registros do
ResultSet para sabermos quantas linhas foram retornadas.
Na linha 50, caso o contador tenha o valor maior que 0 (zero), significa que tem
registros de caminho na tabela do banco de dados.
Na linha 51, criamos um vetor de Objetos Caminhao, de acordo com a
quantidade de registros.
Na linha 52, fazemos o ResultSet apontar para antes do primeiro registro, j
que percorremos ele inteiro na linha 47 e o mesmo est apontando para o final do
ResultSet.
Na linha 55, temos um while que ir percorrer todo o ResultSet, criando objetos
do tipo Caminhao e guardando os valores consultados da base de dados dentro
desses objetos, e depois guardando o objeto caminhao dentro do vetor de
caminhes.
Na linha 67, utilizamos o bloco finally para fechar a conexo com o banco de
dados.
Na linha 71, retornamos o vetor de caminhoes.
Na linha 74, declaramos o mtodo que ir salvar os caminhes na base de

dados, este mtodo retorna um booleano informando se conseguiu ou no salvar.
Na linha 80, criamos uma String com o texto de insero do caminho na base
de dados.
Na linha 85, executamos a insero na base de dados.
dados.
Na linha 98, declaramos o mtodo que ir apagar os caminhes da base de

dados a partir do seu cdigo, depois ir retornar um booleano informando se
conseguiu ou no apagar o caminho.
Na linha 104, criamos uma String com o texto para apagar o registro do
caminho da base de dados.
Na linha 107, apagamos o caminho da base de dados.
dados.
Vamos criar um JFrame chamado CaminhaoTela para desenharmos a tela do

programa.
Dentro do JFrame, adicione um Painel de rolagem (JScrollPane), ele
utilizado para fazer barra de rolagem.
Adicione uma Tabela (JTable) dentro do Painel de rolagem, vamos utilizar a

tabela para mostrar todos os caminhes que foram cadastrados.
Altere o nome da varivel que representa o objeto da tabela para

tabelaCaminhoes.
Adicione um Separador (JSeparator) na tela, para separarmos a parte que ir

listar e excluir os caminhes, da parte que adiciona novos caminhes.
Adicione na tela os Rtulos (JLabel), Campo de texto (JTextField) e Botes

(Button - JButton), e altere seus textos conforme a imagem abaixo:
Altere tambm o nome das variveis dos Campos de texto e Botes conforme a
imagem abaixo:
Dentro do JFrame CaminhaoTela.java, vamos adicionar o seguinte mtodo

que ser usado para carregar os valores referentes aos caminhes cadastrados no
banco de dados.
Na linha 133, chamamos a classe CaminhaDAO que faz a comunicao com o

banco de dados.
Na linha 134, consultamos todos os caminhes que esto cadastrados no
banco de dados.
Na linha 135, criamos um DefaultTableModel que um modelo onde ser
adicionado as colunas e registros da tabela JTable.
Na linha 136 a 138 adicionamos os campos da tabela.
Na linha 141, percorremos todo o vetor de caminhes adicionando suas
informaes no modelo da tabela.
Na linha 146, retornamos um modelo de tabela com suas colunas e linhas
preenchidas.
Agora vamos personalizar o cdigo de criao da JTable que mostrara os

caminhes cadastrados no banco de dados.
Clique com o boto direito em cima da tabela e clique em Personalizar cdigo.
Na tela Personalizador de cdigo, alteramos o valor do segundo combo Box

para propriedade personalizada, dessa forma podemos alterar o cdigo que cria o
modelo da tabela, e chamamos o mtodo que acabamos de criar recarregarTabela().
Se executarmos nosso programa veremos que os dados foram consultados da

base de dados.
Agora precisamos tambm dar funcionalidades para os botes Apagar e

Salvar:
Na linha 149, temos o evento actionPerformed do boto Salvar.

Na linha 150, fazemos uma validao para verificar se foram digitados todos os
dados do caminho.
Na linha 159, chamamos o mtodo que salva o caminho na base de dados.
Na linha 161, verificamos se conseguiu salvar com sucesso, caso consiga,
ento apagamos os dados da tela, recarregamos a tabela e informamos ao usurio
que foi salvo com sucesso.
Na linha 169, caso no consiga salvar vamos informar o usurio.
Na linha 179, temos o evento actionPerformed do boto Apagar.

Na linha 180, fazemos uma validao para verificar se algum registro da tabela
foi selecionado.
Na linha 183, chamamos o mtodo que apaga o caminho da base de dados.
Na linha 185, verificamos se conseguiu apagar com sucesso, caso consiga,
ento recarregamos a tabela e informamos ao usurio que o caminho foi apagado
com sucesso.
Na linha 190, caso no consiga apagar vamos informar o usurio.
Agora teste novamente seu programa.
19 - Leitura de arquivos
Na linguagem Java, existem diversos meios de se manipular arquivos.

Para iniciarmos este assunto, vamos falar da classe java.io.File. A classe File
responsvel por representar arquivos e/ou diretrios do seu sistema de arquivos. Esta classe
pode fornecer informaes teis assim como criar um novo arquivo, tamanho do arquivo,
caminho absoluto, espao livre em disco ou ainda exclu-lo.
A linguagem Java oferece uma classe especfica para a leitura do fluxo de bytes quem
compem o arquivo, esta classe chama-se java.io.FileInputStream. A FileInputStream
recebe em seu construtor uma referencia File, ou uma String que deve representar o
caminho completo do arquivo, dessa forma podemos ler as informaes que esto dentro do
arquivo.
Tanto na invocao do arquivo pela classe File, quanto diretamente pela
FileInputStream far com que o arquivo seja buscado no diretrio em que o Java foi
invocado (no caso do Eclipse vai ser dentro do diretrio do projeto). Voc pode usar um
caminho absoluto, para ler os arquivos que esto em outros diretrios do seu computador
(ex: C:\arquivos\arquivo.txt).
19.1 - Exemplo de leitura de arquivo
Exemplo de um programa que a partir de um caminho, verifica se este caminho

referente a um diretrio ou um arquivo.
Na linha 19 criamos um objeto f do tipo File a partir de um caminho recebido, este objeto
ser utilizado para representar um arquivo ou diretrio.
Na linha 22 verificamos se o objeto f um arquivo atravs do mtodo isFile() da
classe File, caso retorne true ento ir imprimir a mensagem informando que o caminho
referente a um arquivo.
Na linha 24 verificamos se o objeto f um diretorio atravs do mtodo isDirectory()
da classe File, caso retorne true ento ir imprimir a mensagem informando que o caminho
referente a um diretorio.
Ao executar a classe ExemploFile, teremos a seguinte sada no console:
Neste exemplo vamos ler um arquivo .txt e imprimir seu texto no console.
Na linha 30 criamos um objeto do tipo FileInputStream, seu construtor recebe uma

String com um caminho de arquivo, est classe le os bytes do arquivo.
Na linha 34 vamos declarar uma varivel int c que ser utilizada para guardar os
caracteres lidos do arquivo, lembre-se que todos os caracteres em Java so representador
por um nmero inteiro.
Na linha 38 vamos percorrer todo o arquivo e vamos fazer um casting de inteiro para
caracter, para imprimir o texto do arquivo, note que se o valor lido atravs do mtodo read()
for igual a -1, significa que chegamos ao final do arquivo.
Na linha 41 e 43 vamos tratar as excees que podem ser lanadas durante a leitura
de um arquivo.
Na linha 49 vamos fechar o arquivo utilizando o mtodo close().
Ao executar a classe ExemploFileInputStream, teremos a seguinte sada no console:
19.2 - Streams de caracteres
Streams de caracteres a forma como trabalhamos com os prprios caracteres lidos

do arquivo, e a partir desses caracteres podemos adicionar filtros em cima deles. Exemplos
destes leitores so as classes abstratas java.io.Reader e java.io.Writer.
19.2.1 - java.io.Reader
A classe abstrata java.io.Reader representa um fluxo de entrada de dados tratados

como caracteres. Essa classe possui vrias subclasses dedicadas a cada fonte de dados
especfica, tais como a classe java.io.FileReader.
Neste exemplo vamos ler um arquivo e imprimir seus caracteres no console:
Na linha 27 criamos um objeto do tipo FileReader, seu construtor recebe uma String
com um caminho de arquivo, est classe le os caracteres do arquivo.
Na linha 28 vamos declarar uma varivel int c que ser utilizada para guardar os
caracteres lidos do arquivo, lembre-se que todos os caracteres em Java so representador
por um nmero inteiro.
Na linha 29 vamos percorrer todo o arquivo e vamos fazer um casting de inteiro para
caracter, para imprimir o texto do arquivo, note que se o valor lido atravs do mtodo read()
for igual a -1, significa que chegamos ao final do arquivo.
Na linha 32 e 34 vamos tratar as excees que podem ser lanadas durante a leitura
de um arquivo.
Na linha 39 vamos fechar o arquivo utilizando o mtodo close().
Ao executar a classe ExemploReader, teremos a seguinte sada no console:
19.2.2 - java.io.Writer
A classe java.io.Writer uma classe abstrata que representa um fluxo de sada de

dados tratados como caracteres. Essa classe possui vrias subclasses dedicadas a cada
fonte de dados especfica, tais como a classe java.io.FileWriter.
Neste exemplo vamos ler um arquivo e copi-lo:
Na linha 33 criamos um objeto do tipo FileReader, para ler o arquivo.

Na linha 34 criamos um objeto do tipo FileWriter, para criar um novo arquivo e
escrever nele as informaes do arquivo que ser lido.
Na linha 36 vamos ler os caracteres do arquivo de entrada.
Na linha 38 vamos gravar os caracteres lidos no arquivo de sada.
Na linha 48 vamos fechar o arquivo de entrada e na linha 56 vamos fechar o arquivo
de sada.
Ao executar a classe ExemploWriter, teremos a seguinte sada no console:
19.3 - Streams de bytes
Como j mencionado no ttulo deste material, Streams nada mais so do que fluxos de
dados sejam eles de entrada ou de sada. Na linguagem Java, graas aos benefcios trazidos
ao polimorfismo, possvel se utilizar fluxos de entrada (java.io.InputStream) e de sada
(java.io.OutputStream) para toda e qualquer operao deste gnero, seja ela relativa a um
arquivo, a uma conexo remota via sockets ou at mesmo a entrada e sada padro de um
programa (normalmente o teclado e o console).
As classes abstratas InputStream e OutputStream definem respectivamente o

comportamento padro dos fluxos em Java: em um fluxo de entrada possvel ler bytes e no
fluxo de sada escrever bytes. Exemplos concretos destas classes podem ser vistos na
utilizao dos mtodos print() e println() de System.out, pois out uma
java.io.PrintStream, que filha (indiretamente) de OutputStream; e na utilizao de
System.in, utilizado na construo de um objeto da classe java.util.Scanner, que um
InputStream, por isso o utilizamos para entrada de dados.
O importante a se falar sobre as Streams, que como ambas trabalham com leitura e
escrita de bytes, importante que seja aplicado um filtro sobre esse fluxo de bytes que seja
capaz de converter caracteres para bytes e vice e versa, por este motivo utilizamos o Writer
e Reader.
Quando trabalhamos com classes do pacote java.io, diversos mtodos lanam
java.io.IOException, que uma exception do tipo checked, o que nos obriga a trat-la ou
declar-la no mtodo.
19.3.1 - java.io.InputStream
A classe InputStream uma classe abstrata que representa um fluxo de entrada de

dados. Esse fluxo de dados recebido de maneira extremamente primitiva em bytes. Por
este motivo, existem diversas implementaes em Java de subclasses de InputStream que
so capazes de tratar de maneira mais especfica diferentes tipos de fluxos de dados, tais
como as classes java.io.FileInputStream, javax.sound.sampled.AudioInputStream, entre
outros mais especializada para cada tipo de fonte.
19.3.2 - java.io.OutputStream
A classe OutputStream uma classe abstrata que representa um fluxo de sada de

dados. Assim como na InputStream, esse fluxo de dados enviado em bytes, por este
motivo, existem diversas implementaes em Java de subclasses de InputStream que so
capazes de tratar de maneira mais especfica diferentes tipos de fluxos de dados, tais como
as classes java.io.FileOutputStream, javax.imageio.stream.ImageOutputStream, entre
outros mais especializados para cada tipo de destino.
19.4 - Serializao de objetos
Na linguagem Java existe uma forma simples de persistir objetos, uma delas
gravando o objeto diretamente no sistema de arquivos.
Seguindo a mesma idia das j discutidas FileInputStream e FileOutputStream,
existem duas classes especficas para a serializao de objetos. So elas:
java.io.ObjectOutputStream e java.io.ObjectInputStream.
Para que seja possvel a escrita de um objeto em um arquivo, ou seu envio via rede
(ou seja, sua converso em um fluxo de bytes) necessrio inicialmente que este objeto
implemente uma interface chamada java.io.Serializable. Por este motivo, a classe do objeto
que desejamos serializar deve implementar esta interface, alem do que afim de evitar uma
warning (aviso) no processo de compilao ser necessria a declarao de um atributo
constante, privado e esttico chamado serialVersionUID. Este atributo apenas ser utilizado
como um controlador (um ID) no processo de serializao.
A declarao do objeto deve ocorrer assim como segue:
Este nmero da serialVersionUID pode ser adquirido atravs do programa serialver

que vem junto com o JDK, localizado na pasta %JAVA_HOME%\bin.
Feito isso, vamos nos aprofundar nas classes de leitura e escrita de objetos em
arquivos fsicos:
java.io.ObjectOutputStream
Esta classe possui um construtor que, por padro, deve receber uma OutputStream
qualquer, como por exemplo uma FileOutputStream para serializao do objeto em um
arquivo.
Exemplo:
Feita esta instanciao, podemos escrever um objeto qualquer no arquivo relacionado

no construtor utilizando o mtodo writeObject (Object obj), da seguinte forma:
Assim como no caso do mtodo readObject(), da classe ObjectInputStream, e nos

lembrando da premissa da herana, podemos utilizar qualquer objeto neste mtodo, da
seguinte forma:
Aps a escrita do arquivo, no se esquea de finalizar a comunicao com o arquivo

utilizando o mtodo close().
java.io.ObjectInputStream
Esta classe possui um construtor que, por padro, deve receber uma InputStream
qualquer, como por exemplo uma FileInputStream para converter um arquivo em Objeto.
Exemplo:
Feita esta instanciao, podemos ler um objeto a partir do arquivo relacionado no

construtor utilizando o mtodo readObject(), da seguinte forma:
Sobre este mtodo, importante ressaltar que por ele retornar um objeto (lembrando
que todos os objetos em Java so, direta ou indiretamente, filhos da classe
java.lang.Object) possvel j armazenar este retorno no objeto que j sabemos ser
compatvel atravs de uma operao de casting, da seguinte forma:
Aps a leitura do arquivo, no se esquea de finalizar a comunicao com o arquivo

utilizando o mtodo close() de InputStream.
Exemplo que armazena um objeto em um arquivo e vice-versa.
O programa gera o arquivo.txt com o objeto Pessoa no formato que ele entende para
depois converter de novo para objeto Pessoa.
19.5 - Exerccios
1. Crie um arquivo de texto com o seguinte texto:

Meu nome <<seu nome>>.
Feito isso, crie um programa capaz de ler este arquivo e imprimir seu contedo em
tela.
2. Crie um programa capaz de coletar um texto digitado pelo usurio. Pegue este texto e
grave em um arquivo de texto. Lembre-se que o mtodo de escrita em arquivo texto
comporta apenas caracteres, logo, converta a String digitada pelo usurio para caracteres
por meio do mtodo .toCharArray().
3. Crie a seguinte classe Java:
Carro
private double velocidadeMaxima;

// Determina a velocidade mxima do Carro.
private String combustivel;
// Determina o tipo de combustvel que o Carro aceita.
private Color cor;
// Determina cor do Carro.
E os mtodos:
public Carro(double _velocidadeMaxima, String _combustivel, Color _cor){}

// Construtor padro da classe.
public double getVelocidadeMaxima (){}
// Retorna a velocidade mxima do Carro.
public String getCombustivel (){}
// Retorna o tipo de combustvel que o Carro aceita.
public Color getCor(){}
// Retorna a cor do Carro.
Feito isso, crie um programa principal que serialize e armazene em um arquivo de

texto um objeto do tipo criado acima. Seu programa deve tratar uma exceo do tipo
FileNotFoundException (na instanciao do FileInputStream) criando um arquivo no sistema
de arquivos atravs do comando createNewFile() da classe File.
4. Crie uma aplicao Swing que permita cadastrar Pessoas (nome, cpf, dataNascimento), os
dados das pessoas devem ser salvos em um arquivo .txt no formato:
nome,cpf,dataNascimento
Sua aplicao tambm deve permitir ler todas as pessoas que esto no arquivo e mostrar em
uma tabela.
OBS: Utilize uma classe Pessoa para trabalhar com as informaes da pessoa que ser
cadastrada ou consultada do arquivo.
Para trabalhar com datas pesquise a classe DateFormat.
5. Crie uma agenda de contatos utilizando Swing, esta aplicao deve salvar os contatos em
um arquivo .txt.
20 - Recursos da Linguagem Java
20.1 - Arrays ou Vetores em Java
Segundo a definio mais clssica da informtica, um vetor uma estrutura de

dados homogenia, ou seja, todos os elementos de um vetor so do mesmo tipo.
A estrutura bsica de um vetor representada por seu nome e um ndice, que
deve ser utilizado toda a vez que se deseja acessar um determinado elemento dentro
de sua estrutura. importante ressaltar que todo o vetor possui um tamanho fixo, ou
seja, no possvel redimensionar um vetor ou adicinar a ele mais elementos do que
este pode suportar. Em Java a posio inicial do vetor definida pelo valor zero.
20.1.1 - Declarao do vetor
Para se declarar um vetor, devemos informar ao menos seu nome e o tipo de

dado que este ir armazenar. Em Java, este tipo de dado pode ser representado tanto
por um tipo primitivo como por uma classe qualquer, lembrando que as regras de
herana tambm so vlidas para vetores.
Exemplo:
importante ressaltar que um vetor em Java torna-se um objeto em memria,

mesmo que ele seja um vetor de tipos primitivos.
20.1.2 - Inicializao de dados do vetor
Uma vez que um vetor torna-se um objeto em memria, sua inicializao

muito semelhante de um objeto normal. Uma vez que um vetor uma estrutura de
tamanho fixo, esta informao necessria a sua inicializao.
Assim como uma varivel comum, tambm possvel inicializar um vetor que j
foi declarado anteriormente, conforme exemplo abaixo:
Assim como um objeto, um vetor deve ser inicializado antes de ser utilizado.
Uma chamada a um ndice de um vetor no inicializado gera uma exceo.
Existe outra forma de se inicializar vetores j com valores em cada uma de

suas posies, para isto basta utilizar chaves da seguinte maneira:
Note que esta forma de inicializao bastante prtica, porm no deixa clara
a quantidade de elementos que h no vetor obrigando o assim que voc conte a
quantidade de elementos para saber o tamanho do vetor.
20.1.3 - Acesso aos elementos do vetor
Consideremos o cdigo do exemplo anterior, a representao do seu vetor se

daria da seguinte forma:
ndice= 0 1 2 3 4
vetor = 2 5 4 8 5
Logo, para acessar os valores de cada uma das posies deste vetor voc
deve utilizar o seu ndice correspondente dentro de colchetes, assim como segue:
Com isso teramos a seguinte sada em tela:
Lembre-se que o primeiro ndice do vetor sempre zero, logo, seu ltimo
elemento sempre igual ao tamanho do vetor menos um.
20.1.4 - Um pouco sobre a classe Arrays
Dentro do pacote java.util encontramos uma classe chamada Arrays. Esta

classe possui uma srie de mtodos estticos que nos ajudam a trabalhar mais
facilmente com vetores. Dentre seus principais mtodos podemos evidenciar os
seguintes:
binarySearch
o Este mtodo recebe sempre 2 parmetros sendo um deles o vetor
e outro o elemento que se deseja buscar dentro dele. Para isto ele
utiliza o mtodo da busca binria que ser discutido mais a frente.
Sort
o Realizar a ordenao de um vetor utilizando um algoritmo do tipo
Quick Sort. Este tipo de algoritmo tambm ser discutido mais a
diante. Por este mtodo receber o vetor por parmetro (que
lembrando, vetores so objetos) ele o ordena e no retorna valor
algum, pois sua ordenao j foi realizada.
asList
o Coverte o vetor em uma coleo do tipo lista. Colees sero
discutidas mais a frente
copyOf
o Cria uma cpia de um vetor. Pode-se copiar o vetor completamente
ou apenas parte dele.
20.2 - Trabalhando com constantes
Assim como outras linguagens de programao, em Java tambm possvel se

trabalhar com constantes. Para tanto, basta utilizar o modificador de acesso final.
Dependendo do escopo e da utilizao desta sua varivel, possvel combina-
la com outros modificadores de acesso, por exemplo. Uma vez que a varivel foi
declarada como uma constante, obrigatrio a atribuio de um valor inicial para a
mesma.
Observe no exemplo abaixo que tanto um atributo como uma varivel interna a
um mtodo podem ser declarados como constantes.
Tendo em vista que tais variveis foram declaradas como constantes, seu valor
no pode ser alterado aps a sua declarao. Observe que a tentativa de atribuir um
valor a qualquer uma destas variveis ir gerar um erro de compilao.
20.3 - Enums
As Enums surgiram na linguagem Java a partir da verso 5 como uma alternativa

ao uso de constantes, e para atender de maneira melhor algumas das situaes
epecficas que podem ocorrer durante a programao.
20.3.1 - Justificativas do uso de Enums a constantes
Abaixo temos algumas justificativas do porque de se utilizar Enums em Java em

relao s constantes:
As constantes no oferecem segurana Como normalmente constantes

so variveis de um tipo especfico, caso sua constante sirva para ser utilizada em
algum mtodo, qualquer classe pode passar um valor de mesmo tipo da sua
constante, mas que na verdade no existe.
Por exemplo, veja a seguinte classe:
Caso outra classe invoque o mtodo calcularAprovacao na linha 18 e passe o

nmero 4 como parmetro ele simplesmente no funcionar.
No h um domnio estabelecido Para evitar duplicidades entre os nomes

de constantes nas diversas classes de um sistema, o desenvolvedor forado a
padronizar um domnio. Perceba no exemplo acima que todas as constantes iniciam
com o prefixo CONCEITO justamente com este fim.
Fragilidade de modelo - Como uma constante sempre requer um valor, caso

voc crie um novo valor intermedirio aos j existentes, todos os atuais devero ser
alterados tambm. Pior exemplo, ainda considerando o exemplo acima, imagine que
voc precise criar um novo conceito chamado REGULAR. Qual seria seu valor uma
vez que ele deveria estar entre os conceitos RUIM e BOM? Provavelmente voc teria
de alterar todo o seu cdigo para algo semelhante ao que segue abaixo:
Note que ao invs de apenas criamos este novo valor, fomo forados a alterar
os valores das variveis BOM e OTIMO. Imagine isso em um contexto com duzentas
ou trezentas variveis, por exemplo.
Seus valores impressos so pouco informativos Como constantes

tradicionais de tipos primitivos so apenas valores numricos em sua grande maioria,
seu valor impresso pode no representar algo consistente. Por exemplo, o que o
nmero 2 significa para voc em seu sistema? Um conceito? Uma temperatura? Um
modelo de carro? Etc.
20.3.2 - Como criar uma Enum
A estrutura de uma Enum bem semelhante de uma classe comum. Toda a

Enum possui um construtor que pode ou no ser sobrecarregado. Vamos ao primeiro
exemplo:
Observe que no exemplo acima quatro valores foram criados nas linhas 14 a 17,
mas, diferentemente das constantes, eles no possuem um tipo especfico sendo que
todos eles so vistos como elementos da enumerao Conceitos. Isto j torna
desnecessria a denominao de um prefixo de domnio para os nomes dos
conceitos, visto que a prpria enum j cumpre este papel.
Ainda sobre o exemplo acima, tambm vale ressaltar que uma enum pode ter
mtodos. O mtodo calcularAprovacao na linha 19 recebe como parmetro agora no
mais um nmero inteiro qualquer, mas sim uma enum do tipo ConceitosEnum. Desta
forma garante-se que ele sempre receber um valor conhecido e que no teremos os
mesmos problemas que poderiam ocorrer com uma varivel de um tipo especfico, tal
como ocorria com as constantes.
Por fim, obeserve que como os elementos da enum no possuem mais um valor
atrelado a si, a criao de um novo conceito, tal como um EXCELENTE ou PSSIMO
em nada influenciaria no cdigo j existente dentro da enum.
Uma enum, diferentemente de uma classe, j inicializada quando voc inicia
sua aplicao Java, no necessitando ser instanciada. Vamos agora a um exemplo
de uma enum com mtodo construtor e com atributos:
Perceba que agora as mensagens esto sendo utilizadas no construtor e sero

populadas no atributo mensagem para cada um dos elementos da enum. Desta
forma, outra classe poderia acessar estes dados de maneira muito mais transparente,
conforme o segue abaixo:
Observe na linha 16 como a enum est sendo invocada. No foi instnciada e

para
21 - Recursividade
Chamada de mtodo
Quando um mtodo precisa utilizar a funcionalidade de outro mtodo, precisamos

fazer com que um mtodo chame outro mtodo, no exemplo vamos criar um programa que
imprima a soma dos nmeros pares de [1 .. x] (onde x um nmero inteiro positivo).
Vamos criar um mtodo main() que por onde comea a execuo do programa,
depois vamos criar um mtodo chamado imprimir() que ir somar os nmeros pares entre 1
e x.
Na linha 10 foi criado o mtodo main() por onde vai comear a execuo do mtodo.
Na linha 11 vamos imprimir a frase Inicio do programa..
Na linha 12 criado um objeto da classe ImprimirPares para podermos chamar o
mtodo imprimir() dessa classe.
Na linha 13 chama o mtodo imprimir() passando o valor 5 como parmetro para a
varivel x. Quando a execuo do programa chega nesta linha o mtodo imprimir()
chamado e a execuo do mtodo vai para a linha 17.
Da linha 18 a 23 temos o algoritmo que soma os nmeros pares.
Na linha 25 imprime a soma dos nmeros pares entre 1 e 5, ou seja, vai imprimir
Soma dos pares: 6.
Na linha 26 acaba o mtodo imprimir(), agora a execuo do programa volta para o
mtodo main(), pois foi ele que chamou o mtodo imprimir(), repare tambm que a
execuo do mtodo volta para a linha posterior a chamada do mtodo, ou seja, vai para a
linha 13.
Na linha 14 vamos imprimir a frase Fim do programa..
Na linha 15 acaba o mtodo main() e encerra o programa.
Quando o programa encerrado temos a seguinte sada no console:
Inicio do programa.
Soma dos pares: 6
Fim do programa.
Lembre-se: toda vez que um mtodo termina sua execuo, o fluxo de execuo do
programa volta para a linha posterior a qual ele foi chamado.
Recurso
Recurso um mtodo de programao no qual uma funo chama a si mesma. A

recurso utilizada quando queremos resolver um subproblema do mesmo tipo menor.
A recurso utilizada quando queremos resolver um subproblema do mesmo tipo
menor.
Se o problema pequeno
- no resolva o problema diretamente
Seno
- Reduza o problema em um problema menor, chame novamente o mtodo para o
problema menor e volte ao problema original.
A chamada ao mtodo recursivo igual a uma chamada de mtodo normal, quando a

execuo do mtodo terminar ele deve voltar para o mesmo mtodo, s preste ateno, pois
o estado do mtodo pode ser diferente para cada vez que ele se chama.
Mas o que isso quer dizer?

Os valores das variveis passadas por parmetro podem ser diferentes para cada vez
que o mtodo se chama, no exemplo abaixo vamos reescrever o mtodo imprimir, mas agora
vamos criar seu cdigo de forma recursiva.
Antes de comear a escrever o cdigo um mtodo recursivo, precisamos pensar qual

condio ser interrompida a chamada recursiva, ou seja, quando o mtodo precisa parar de
se chamar.
Neste caso ele precisa parar a chamada do mtodo quando terminarmos de percorrer
o intervalo de 1 at x ou de x at 1.
Depois precisamos pensar no objetivo do mtodo que somar nmeros pares.
Segue abaixo o cdigo do mtodo recursivo, o mtodo ira somar os nmeros pares de
x at 1.
Na linha 13 chama o mtodo imprimirRecursivo() passando o valor 5 como

parmetro. Quando a execuo do programa chega nesta linha o mtodo
imprimirRecursivo() chamado e a execuo do mtodo vai para a linha 17.
Na linha 17 declaramos o mtodo recursivo, perceba que agora o mtodo est
retornando um nmero inteiro, dessa forma podemos calcular o valor da soma dos nmeros
pares e retornar este valor.
Na linha 18 verificamos se o valor de x igual a 0 (zero), porque no queremos somar
nenhum nmero menor que zero, e a soma do nmero 0 (zero) no ir alterar a resposta.
Ento se o valor de x for zero na linha 19 retorna o valor zero.
Na linha 21 verificamos se o valor de x par, porque queremos somar apenas os
nmeros pares, e se for par ento na linha 22 soma o valor de x com o valor do resultado da
chamada recursiva do mtodo imprimirRecursivo() passando como parmetro x 1.
A linha 24 ser executada quando o valor de x for diferente de zero e tambm quando
o nmero for impar.
Ento teremos as seguintes chamadas de mtodo:
O mtodo main() vai chamar o mtodo imprimirRecursivo(5), que por sua vez vai
chamar o mtodo imprimirRecursivo(4) at chegar no imprimirRecursivo(0), que ir parar
as chamadas recursivas e volta para quem chamou ele passando o resultado da soma
recursiva.
Exemplo de ordem decrescente:
Mtodo recursivo que recebe um nmero x por parmetro e imprime seu valor em
ordem decrescente at 1.
Quando usamos recurso, precisamos definir o momento de parada, quando a funo

no deve ser mais chamada.
No caso do exemplo anterior queremos que o mtodo no si chame novamente
quando o x for igual a 0 (zero), porque queremos apenas os nmeros entre [x ... 1]:
Agora precisamos definir o que nosso mtodo deve fazer, neste caso deve imprimir o
valor de x, e em seguida chama a si mesma diminuindo em 1 o valor de x.
A prxima vez que a funo imprimirSequencia(int x) for chamada, o valor de x

diminui 1 at chegar a 0 (zero) e parar a execuo do cdigo.
Exemplo de fatorial:
A chamada de um mtodo para ele mesmo, igual a chamada de qualquer outro

mtodo, exemplo de mtodo recursivo que calcula o fatorial n!:
O fatorial de um nmero dado pela multiplicao de seus antecessores, ou seja, se
n igual 3, ento seu fatorial ser 3 * 2 * 1. O fatorial de 0! (zero) igual a 1.
O mtodo recursivo fica da seguinte forma:
Dentro de um mtodo recursivo muito importante definirmos como ser a condio

base para que o mtodo pare a recurso, ou seja, como o mtodo vai parar de se chamar.
Neste caso queremos que o mtodo para de chamar ele mesmo, quando o valor que
ser calculado o fatorial for igual a 0 (zero), pois neste caso sabemos a resposta direta sem
ter que fazer clculos.
Chamando o mtodo fatorial(3), queremos calcular 3 * 2 * 1.
3 * fatorial(2) retorna (6)

Explicando o fluxo do programa:

3. O mtodo fatorial recebe o valor de x igual a 3, verifica se x igual a 0 (zero), como
no igual, ento calcula 3 multiplicado por fatorial(2), neste ponto estamos fazendo
uma chamada recursiva.
no igual, ento calcula 2 multiplicado por fatorial(1).
no igual, ento calcula 1 multiplicado por fatorial(0).
6. O mtodo fatorial recebe o valor de x igual a 0 (zero), verifica se x igual a 0 (zero),
ento para a execuo do mtodo e retorna o valor 1.
7. Volta para o mtodo fatorial(1) na linha 26 e faz a multiplicao de x que vale 1 pelo
resultado do fatorial(0) que 1, ou seja 1 * 1 e retorna o valor 1.
10. Volta para o mtodo que chamou o fatorial(3), neste caso o mtodo main() na linha 7,
guarda o resultado do fatorial(3) que 6, dentro da varivel resp, e imprime o
resultado da varivel resp na linha 8.
Exemplo fibonacci
Mtodo recursivo que calcula o valor de fibonacci para um determinado valor x.
Seqncia de fibonacci.
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233
Definio recursiva pela forma matemtica:
Implementao do mtodo que calcula o valor de fibonacci.
No fibonacci sabemos que o momento de parada do mtodo quando o x vale 0

(zero) ou 1, neste caso sua resposta conhecida.
Para qualquer outro valor de x diferente de 0 (zero) e 1 no sabemos sua resposta,

portanto precisamos calcular o valor do fibonacci.
Ou seja, para calcular o fibonacci de 2, eu preciso primeiro calcular seu valor para 1 e
para 0 (zero) e somar os dois resultados
Nesta figura temos a seqncia de mtodos fibonacci(int x) que sero chamados,

tambm mostra qual o valor x ser passado para o mtodo e qual o valor retornado pelo
mtodo:
Os itens em verde so as seqncias em que o mtodo fibonacci(int x) ser

executado.
Os itens em vermelho so os resultados do fibonacci para o valor x recebido.
Exemplo que soma os valores no intervalo [x ... 0]
Mtodo recursivo que deve calcular o valores entre um nmero qualquer recebido e 0
(zero), ou seja, se receber 5, deve calcular 5 + 4 + 3 + 2 + 1 + 0.
Implementao do mtodo que calcula a soma dos nmeros.
Neste exemplo queremos parar de somar os valores, quando x for igual a 0 (zero),
ento na linha 29 se o x recebido for igual a 0 (zero), ser retornado o valor 0 (zero).
Na linha 35, ser somado o valor do x atual com a soma de todos os seus
antecessores at 0.
Na linha 11, temos o mtodo main() e na linha 13 chamamos o mtodo somar(10),
queremos a soma dos nmeros 10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + 0.
A figura abaixo mostra as chamadas de mtodo recursivo e qual o valor retornado por
elas.
Na linha 13, ser armazenado na varivel resultado o valor 55, que o resultado de
somar(10), e na linha 14 ser impresso este valor.
Exemplo imprimir o nome de todos os animais de um vetor de objetos Animal.
Neste exemplo temos uma classe Animal e cada animal tem uma especie e um
nome.
A partir da classe Animal, criamos um vetor de animais e queremos imprimir a

especie e nome de todos os animais desse vetor (imprimir na ordem que foram inseridos no
vetor).
Segue abaixo a implementao do programa que imprime recursivamente as

informaes dos animais que esto no vetor.
Na linha 30 tem a assinatura do mtodo imprimirAnimais que recebe como

parmetro um vetor de animais e o tamanho desse vetor, vamos utilizar o tamanho do vetor
para definir qual animal dentro do vetor ser impresso.
Na linha 35 verificado se o tamanho do vetor 0 (zero), ou seja, se o vetor est
vazio, caso no tenha mais elementos dentro do vetor, ento para a execuo do mtodo e
volta para quem fez a chamada do mtodo.
Na linha 36 chama este mtodo recursivamente diminuindo em 1 o tamanho do vetor,

dessa forma este mtodo ser chamado recursivamente at o tamanho ficar com valor 0, e
depois vai voltar para est mesma linha, imprimindo os valores do vetor a partir do primeiro
elemento at o ultimo, ou seja, na ordem que os elementos foram inseridos.
Na linha 41 imprime a especie e nome do animal.
21.1 - Exerccios
1-) Crie um mtodo recursivo que recebe como parmetro um nmero x, e imprima os
nmeros de 1 at x.
Exemplo:
X = 10
Imprime: 1 2 3 4 5 6 7 8 9 10
2) Escreva um mtodo que recebe como parmetro um tamanho e um vetor de nmeros

inteiros, este mtodo deve recursivamente retornar o menor nmero encontrado.
Exemplo:
Vetor {3, 7, 5, 9, 1, 0}
Tamanho 6
Retorna o valor 0 (zero)
3) O exemplo do fibonacci pode ser otimizado, pois a mesma chamada do mtodo

executada varias vezes, exemplo: fibonacci(1) chamado 5 vezes e o resultado sempre o
mesmo.
Otimize o algoritmo do fibonacci para que somente chame os mtodos que no conhecemos
seu resultado.
22 - Bubble Sort
O Bubble-Sort um dos algoritmos de ordenao mais simples, que consiste em

percorrer os N elementos de um vetor, para cada vez percorrida, todos os elementos so
comparados com o seu prximo, para verificar se esto na ordem desejada.
22.1 - Execuo do algoritmo de Bubble Sort
Na primeira iterao, encontrado o maior elemento e o mesmo deslocado at a

ultima posio.
Na segunda iterao, encontrado o segundo maior elemento e o mesmo

deslocado at a penltima posio.
Continua at que todos os elementos serem ordenados.
OBS: No obrigatrio colocar sempre o maior elemento no final do vetor, dependendo

da sua lgica de programao, possvel deixar os elementos de forma decrescente.
22.2 - Implementao do Bubble Sort
Na linha 19 temos a assinatura do mtodo que ordena um vetor de inteiros.

Na linha 21 temos um for para controlar a quantidade de vezes que esse vetor ser
ordenado, no caso (v.length 1) vezes.
Na linha 23 temos um for para ordenar os elementos do vetor, este for ir ordenar
(v.length 1 i) vezes. Na quantidade de vezes que o vetor ordenado subtramos pela
quantidade de iteraes que ser realizada no caso a varivel i, porque sabemos que
quando uma iterao termina o ultimo elemento j est ordenado.
Na linha 26 verificamos se o valor da posio atual do vetor maior que o prximo
valor do vetor, se for maior trocamos os valores de lugar.
22.3 - Uma forma melhorada do Bubble Sort
Se repararmos na execuo do Bubble Sort demonstrado no exemplo anterior,

podemos perceber que se o vetor j estiver ordenado antes de chamar o mtodo que ordena,
ser realizado as (v.length 1) vezes iteraes sobre ele e ser comparado todos
elementos dele para ver se est ordenado.
Podemos melhorar isso adicionando uma varivel de controle que verifica se houve
troca de valores no vetor, porque se durante uma iterao no houver nenhuma troca de
valor, significa que o vetor j est ordenado.
Abaixo est a verso melhorada do Bubble Sort:
Na linha 23 foi criada uma varivel boolean para controlar se o vetor est ordenado.
Na linha 32 se houve alguma troca de valor, ento o vetor ainda no est totalmente
ordenado, e a varivel de controle alterada para falso.
Na linha 36 se o vetor estiver ordenado ento para a execuo do for que controla a
quantidade de vezes que o vetor ser ordenado.
22.4 - Exemplo de ordenao de vetor de objetos
nome.
A partir da classe Animal, criamos um vetor de animais e queremos ordenar os

animais pelo nome.
Segue abaixo a implementao do programa que ordena o vetor de animais utilizando

o algoritmo de Bubble Sort.
Na linha 28 temos a assinatura do mtodo que ordena um vetor de animais.

Na linha 30 temos um for para controlar a quantidade de vezes que esse vetor ser
ordenado, no caso (animais.length 1) vezes.
Na linha 32 foi criada uma varivel boolean para controlar se o vetor est ordenado.
Na linha 34 temos um for para ordenar os elementos do vetor, este for ir ordenar
(animais.length 1 i) vezes. Na quantidade de vezes que o vetor ordenado subtramos
pela quantidade de iteraes que ser realizada no caso a varivel i, porque sabemos que
quando uma iterao termina o ultimo elemento j est ordenado.
Na linha 37 verificamos se nome do animal da posio atual do vetor maior que o
nome do prximo animal do vetor, se for maior trocamos os animais de lugar.
Na linha 41 se houve alguma troca de animal, ento o vetor ainda no est totalmente
ordenado, e a varivel de controle alterada para falso.
Na linha 45 se o vetor estiver ordenado ento para a execuo do for que controla a
quantidade de vezes que o vetor ser ordenado.
Tambm podemos ordenar os animais pela especie e depois pelo nome do animal:
Na linha 65 verifica se o nome da especie do animal na posio atual do vetor maior

que a especie do prximo animal, se for ento troca os animais de lugar.
Na linha 74 verifica se o nome da especie do animal na posio atual do vetor igual
a especie do prximo animal, se as espcies forem iguais, ento verifica se o nome do
animal na posio atual do vetor maior que o nome do prximo animal, se for maior ento
troca os animais de lugar no vetor.
22.5 - Exerccios
1) Escreva um programa em Java que utilize o Bubble-Sort para ordenar de forma

decrescente um array de inteiros com 10 elementos.
Depois mostre o menor elemento, o maior elemento e todos os elementos na ordem
decrescente.
2) Escreva um programa em Java que utilize o Bubble-Sort para ordenar um array de

Strings, quando for ordenar os elementos deve ser avisado se os elementos devem ser
ordenados de forma crescente ou decrescente.
3) Melhore o exemplo do Bubble-Sort de forma que as comparaes parem de ser

feitas a partir do momento em que o vetor estiver ordenado.
Exemplo:
vetor {1, 2, 4, 3} tem apenas os elementos 3 e 4 invertidos, mas mesmo assim nosso
algoritmo vai percorrer 3 vezes esse vetor.
Melhore o exemplo de modo que o vetor percorrido apenas a quantidade de vezes

necessria para deix-lo ordenado e ter certeza que no tem mais nenhuma alterao para
ser realizada.
23 - Merge Sort
Merge-Sort um algoritmo para ordenao de dados simples e compacto,

normalmente implementado utilizando recurso.
A idia do Merge-Sort embasada seguinte a diviso de um vetor, dividi-lo em vrios
vetores menores at que no se possa dividir mais. Depois compara-se os elementos dos
vetores menores para uni-los na ordem desejada.
O Merge-Sort baseado em um padro de projeto chamado diviso e conquista
(divide-and-conquer), que pode ser dividido em 3 partes:
Diviso: Se a quantidade de elementos que sero ordenados for um ou dois

ento resolva o problema diretamente, se tiver mais elementos ento divida a
quantidade de elementos em dois ou mais conjuntos.
Recurso: Utilize a recurso para resolver cada um dos subconjuntos de
elementos.
Conquista: Depois da resoluo de cada subconjuntos, reagrupe-as em uma
nica soluo.
23.1 - Fluxo de execuo do Merge Sort
Dado um vetor de elementos inteiros { 3, 5, 4, 1, 9, 6, 7, 2 }, orden-lo utilizando Merge

Sort.
Divide o vetor at ter um par de elementos, ordena esses elementos e altera a ordem
deles no vetor original se necessrio:
Ordena outro par de elementos e altera a ordem deles no vetor original se necessrio:
Depois que tem 2 pares ordenados, ordena este 2 pares e altera a ordem deles no
vetor original se necessrio:
Continua ordenando a outra metade do vetor, faz o mesmo processo de dividir os

elementos at chegar em um par de valores e ordena esses valores e altera a ordem deles
no vetor original se necessrio:
Ordena outro par de elementos e altera a ordem deles no vetor original se necessrio.
Depois que tem 2 pares ordenados, ordena este 2 pares e altera a ordem deles no
vetor original se necessrio:
Depois que as duas metades do vetor est ordenado, ordena novamente as duas
metades e altera a ordem dos elementos no vetor original se necessrio:
O vetor foi ordenado por completo:
23.2 - Implementao do Merge Sort iterativo
Na linha 24 tem a assinatura do mtodo mergeSort no formato iterativo, que recebe o

tamanho do vetor e o vetor que ser ordenado.
Na linha 27 criado uma varivel para percorrer os elementos do vetor, est varivel
inicializada com 1 porque o vetor precisa ter pelo menos um elemento dentro dele.
Na linha 29 criado trs variveis para controlar a posio inicial, meio e fim do vetor
que ser trabalhando.
Na linha 32 criado um while para percorrer todos os elementos do vetor, neste while
o vetor ser percorrido de 1 em 1, depois de 2 em 2, depois de 4 em 4, etc, porque estamos
simulando o tamanho do vetor original, para dividi-lo em partes pequenas que podem ser
ordenadas e depois intercalada.
Na linha 38 criado outro while para percorrer os elementos do vetor, utilizando a
quantidade de elementos de 1 em 1, de 2 em 2, ou seja, vai ordenar dois elementos ou
quatro elementos ou oito elementos.
Na linha 40 define qual a posio do meio do vetor.
Na linha 42 define qual a posio final do vetor.
Na linha 51 chama o mtodo que intercala os valores do vetor, de acordo com as
posies inicio, meio e fim passadas.
Na linha 54 faz a posio inicial do vetor ser igual a posio fim, porque ser ordenado
outra parte do vetor.
Na linha 58 duplica o tamanho dos elementos que deve ser ordenados e intercalados.
Na linha 70 declara a assinatura do mtodo intercala que recebe o vetor e as posies

inicio, meio e fim que sero ordenadas dentro do vetor.
Na linha 84 tem um while que serve para ordenar os elementos do inicio ao meio do
vetor, ou do meio ao fim do vetor.
Na linha 101 tem um while que para os elementos que esto no inicio do vetor, mas
ainda no foram ordenados.
Na linha 109 tem um while que para os elementos que esto no meio do vetor, mas
ainda no foram ordenados.
Na linha 116 tem um for para passar os valores ordenados no vetor original.
23.3 - Exemplo de Merge Sort usando recurso
Na linha 25 tem a assinatura do mtodo recursivo de merge sort, que agora recebe a
posio inicial e final do vetor que ser ordenado.
Na linha 27 verifica se o inicio menor que o fim 1, para saber se o vetor no est
vazio.
Na linha 29 calcula a posio que seria o meio do vetor que ser ordenado, est
posio utilizada para dividir o vetor e depois intercalar seus valores.
Na linha 31 chama o mtodo recursivamente, s que agora a posio final do vetor vai
ser a posio do meio do vetor, que foi calculado anteriormente, assim faremos as chamadas
recursivas caminhando para a esquerda do vetor.
Na linha 35 chama o mtodo recursivamente, s que agora a posio inicial vai ser a
posio do meio do vetor, que foi calculado anteriormente, assim faremos as chamadas
recursivas caminhando para a direita do vetor.
Na linha 38 chama o mtodo que vai intercalar (ordenar) os valores do vetor.
A imagem abaixo mostra a arvore de chamadas recursivas, caso este mtodo receba
um vetor de 5 elementos.
Em vermelho est a ordem em que os mtodos sero chamados recursivamente.
23.4 - Exemplo de Merge Sort com vetor de objetos
nome.
A partir da classe animal, criamos um vetor de animais e queremos ordenar os

animais pelo nome.
Segue abaixo a implementao do programa que ordena o vetor de animais pelo

nome utilizando o algoritmo de Merge Sort:
O mtodo do merge sort muito parecido com o anterior, nica diferena que na
assinatura do mtodo ele recebe um vetor de objetos Animal.
O mtodo intercala muito parecido com o anterior, na assinatura do mtodo linha 53,
alterou o tipo do vetor que ele recebe, para receber um vetor de objetos Animal.
Na linha 55 cria um vetor de objetos Animal, para guardar temporariamente os
Animais ordenados pelo nome.
Na linha 70 foi alterado, para ordenar os nomes dos Animais em ordem crescente.
23.5 - Exerccios
1) Crie a classe Aluno abaixo:
Crie classe que tenha um mtodo que implemente o Merge-Sort, para ordenar um
vetor de Alunos de acordo com seu nome, caso exista mais de um aluno com o mesmo
nome, ento deve orden-los pela matricula.
OBS: No h matriculas duplicada
Exemplo, dado os seguintes alunos:
Depois de ordenados devem ser mostrado o nome, matricula e nmero de chamada:
Cristiano 101010 3
Rafael 100000 13
Rafael 100011 10
Sakurai 100023 20
24 - Quick Sort
24.1 - Conceitos do QuickSort
O prximo algoritmo de ordenao de dados que falaremos o Quick Sort. Assim

como o Merge Sort, o Quick Sort um algoritmo que se baseia no princpio da diviso e
conquista, porem ele trabalha de maneira contrria uma vez que a parte mais pesada do
algoritmo acontece antes da recurso e no nela.
O algoritmo Quick Sort trabalha ordenando uma seqncia qualquer de valores
dividindo-a em subseqncias menores, aplicando recurso para ordenar cada uma destas
subseqncias e por fim, concatenando-as novamente em uma seqncia idntica a original,
porem, j ordenada.
Diviso Para uma seqncia S de ao menos dois elementos, basta escolher um

elemento x de S chamado por piv. Uma vez feito isso, removemos todos os elementos de S
e os alocamos em trs novas subseqncias, sendo elas:
Uma subseqncia Me, composta de elementos menores do que x.
Uma subseqncia Ig, composta de elementos iguais a x.
Uma subseqncia Ma, composta de elementos maiores do que x.
Vale lembrar que, caso exista apenas um elemento de valor igual ao de x, a

subseqncia Lg ser composta de apenas um elemento.
0 1 2 3 4
x = 15 S 15 4 20 7 10
0 1 2 0 0
x=7 Me 7 4 10 Ig 15 Ma 20
0 0 0
Me 4 Ig 7 Ma 10
Recurso Ordene as seqncias Me e Ma recursivamente.
Conquista Recoloque os elementos das subseqncias Me, Ig e Ma novamente na

seqncia S nesta mesma ordem em que foram mencionados.
24.2 - QuickSort in-place
Uma das melhores maneiras de se aplica o Quick Sort, atravs da metodologia

Quick Sort in-place. dito in-place, pois no necessitar de novas seqncias, ou seja, no
necessita alocar mais memria.
Para que isto seja possvel, iremos no preocupar no somente com a composio de
novos vetores, mas sim iremos a partir do piv comparar todos os elementos do vetor com o
piv de maneira a trocar elementos de posio e deixar o piv centralizado, ou seja, com
elementos menores que ele a sua esquerda e maiores que ele a sua direita, com isso j
teremos os trs novos vetores.
Para que isso seja possvel, adotaremos a seguinte tcnica:
Escolher um elemento x do vetor,no caso o primeiro elemento do vetor;

Percorrer o vetor da esquerda para a direita procurando um elemento maior que x, e
da direita para a esquerda procurando um elemento menor ou igual a x. Quando este
elementos forem encontrados, devemos troca-los de posio;
Trocar x com o j-simo elemento e devolver a posio j.
Ex:
0 1 2 3 4 5 6 7 8 9 10
12 4 15 7 10 2 1 13 6 20 28
S
i j
x = S[p] = 12
0 1 2 3 4 5 6 7 8 9 10
12 4 15 7 10 2 1 13 6 20 28
S
i j
4 < 12? Sim -> incrementar ponteiro...
0 1 2 3 4 5 6 7 8 9 10
12 4 15 7 10 2 1 13 6 20 28
S
i j
15 < 12? No! -> parar ponteiro...
0 1 2 3 4 5 6 7 8 9 10
12 4 15 7 10 2 1 13 6 20 28
S
i j
28 > 12? Sim -> decrementar ponteiro...
0 1 2 3 4 5 6 7 8 9 10
12 4 15 7 10 2 1 13 6 20 28
S
i j
0 1 2 3 4 5 6 7 8 9 10
12 4 15 7 10 2 1 13 6 20 28
S
i j
6 > 12? No! -> parar ponteiro...
Os dois ponteiros pararam, logo os seus elementos devem ser trocados e

ambos os ponteiros devem ser incrementados !
0 1 2 3 4 5 6 7 8 9 10
12 4 6 7 10 2 1 13 15 20 28
S
i j
Continuando...
0 1 2 3 4 5 6 7 8 9 10
12 4 6 7 10 2 1 13 15 20 28
S
i j
0 1 2 3 4 5 6 7 8 9 10
12 4 6 7 10 2 1 13 15 20 28
S
i j
0 1 2 3 4 5 6 7 8 9 10
12 4 6 7 10 2 1 13 15 20 28
S
i j
0 1 2 3 4 5 6 7 8 9 10
12 4 6 7 10 2 1 13 15 20 28
S
i j
0 1 2 3 4 5 6 7 8 9 10
12 4 6 7 10 2 1 13 15 20 28
S
i j
13 < 12? No! -> parar ponteiro...
0 1 2 3 4 5 6 7 8 9 10
12 4 6 7 10 2 1 13 15 20 28
S
i j
0 1 2 3 4 5 6 7 8 9 10
12 4 6 7 10 2 1 13 15 20 28
S
j i
1 > 12? No! -> parar ponteiro...
Uma vez que os dois ponteiros se ultrapassaram, o elemento escolhido x

deve ser agora trocado com o elemento da posio j.
0 1 2 3 4 5 6 7 8 9 10
1 4 6 7 10 2 12 13 15 20 28
S
j i
24.3 - Implementao do QuickSort in-place em Java
Para iniciar o exemplo, vamos criar uma classe Quick Sort:
Nossa classe QuickSort j disponibiliza um mtodo especfico para a ordenao de nmeros

inteiros, conforme a linha 15 do cdigo.
Note que este mtodo invoca um mtodo interno da classe tambm chamado de quickSort, logo
vamos a seu cdigo fonte:
Observe que nesta etapa, o algoritmo visa divider o vetor de entrada utilizando o
mtodo dividir, conforme a linha 32. Nesta etapa de diviso veremos como o algoritmo se
comporta para realizar a ordenao a cada etapa desta diviso.
Este trecho de cdigo responsvel pela diviso do vetor em funo da comparao

por base de um vetor, estabelecido pelo elemento inicial do vetor, conforme a linha 63.
Utilizando dois ponteiros, um vindo da esquerda e outro da direita, este algoritmo ao
mesmo que divide o vetor em dois novos vetores, estabelece uma ordenao fundamentada
no piv, onde os elementos menores que ele ficaro a sua esquerda e os maiores a sua
direita. Quando elementos que no atendam a esta regra so localizados no vetor, estes so
trocados pelo mtodo trocar, conforme linhas 79 e 84. Vejamos seu cdigo fonte:
Agora, j finalizada a classe QuickSort, vamos elaborar uma classe de teste para
vermos o comportamento do algoritmo:
24.4 - Exerccios
1. Adapte a classe QuickSort para que a mesma passe agora a ordenar um

vetor de Strings.
2. Construa uma QuickSort, semelhante a do exemplo, mas que trabalhe com

uma Colleo Java de sua escolha.
25 - Pesquisa sequencial
O objetivo da pesquisa procurar por um elemento dentro de uma coleo de

elementos.
O algoritmo de pesquisa seqencial possui este nome porque o objetivo dele

procurar o elemento de forma seqencialmente dentro de uma coleo de elementos.
Dado um vetor:
[5, 4, 0, 8, 7, 9]
Percorre os elementos de um vetor

Se o elemento procurado estiver dentro do vetor, imprime o valor do elemento e para
de procurar pelo elemento no vetor.
Se no encontrou o elemento dentro do vetor, imprime uma mensagem informando
que o elemento no foi encontrado.
Pesquisando o valor 0 (zero)
Quando pesquisamos o nmero 0 (zero) dentro do vetor temos o seguinte fluxo:
O contador est com valor 0 (zero) e verifica se o nmero dentro do vetor na posio
do contador igual ao nmero procurado 0 (zero).
Como o nmero que est dentro do vetor no o nmero que est sendo procurado,
ento incrementa em 1 o valor do contador e verifica novamente se o valor que est dentro
do vetor na posio do contador igual ao valor procurado.
Como o nmero que est dentro do vetor ainda no o nmero que est sendo
procurado, ento incrementa em 1 o valor do contador e verifica novamente se o valor que
est dentro do vetor na posio do contador igual ao valor procurado.
Encontrou o valor procurado dentro do vetor, ento imprime uma mensagem avisando
que encontrou o valor procurado.
Pesquisando o valor 3 (trs)
Agora queremos pesquisar o valor 3 dentro do vetor, percorremos o vetor por

completo e no encontramos o valor pesquisado:
Neste ponto o valor do contador igual a o tamanho do vetor, ou seja, tamanho 6.

Ento devemos imprimir uma mensagem avisando que o valor pesquisado no est dentro
do vetor.
25.1 - Implementao do algoritmo de Pesquisa Seqencial
Na linha 20, temos a assinatura do mtodo que vai procurar um elemento dentro do
vetor, utilizando o algoritmo de Pesquisa Seqencial.
Na linha 23, utilizamos um for para percorrer todos os elementos do vetor.
Na linha 25, verifica se o numero dentro do vetor, tem o mesmo valor que o nmero
que est sendo procurado, e se encontrou o nmero ento imprime ele na tela e para de
pesquisar.
Na linha 33, verificamos se o tamanho do contador utilizado no for tem um valor maior
que o tamanho do vetor, para verificar se j percorreu todo o vetor, mas no encontrou o
valor procurado.
25.2 - Utilizando pesquisa seqencial com objetos
O mesmo conceito de pesquisa seqencial pode ser aplicado para um vetor de

Objetos, procurando algum objeto por um ou vrios atributos.
Na linha 27, temos a assinatura do mtodo que vai procurar uma Pessoa dentro do
vetor de pessoas, utilizando o algoritmo de Pesquisa Seqencial.
Na linha 30, utilizamos um for para percorrer todas as pessoas do vetor.
Na linha 32, verifica se o nome da pessoa dentro do vetor, tem o mesmo nome da
pessoa que est sendo procurada, e se encontrou ento imprime o nome da pessoa na tela e
para de pesquisar.
Na linha 40, verificamos se o tamanho do contador utilizado no for tem um valor maior
que o tamanho do vetor, para verificar se j percorreu todo o vetor, mas no encontrou
alguma pessoa com o mesmo nome.
25.3 - Outra forma de programar a pesquisa seqencial
Este mesmo algoritmo de busca seqencial pode ser programando de uma outra
forma, sem afetar a estrutura do algoritmo, exemplo:
Na linha 24, criamos um lao que enquanto no chegar ao fim do vetor ou no

encontrar o valor procurado dentro do vetor, vai incrementando a varivel cont.
Na linha 29, verifica se ainda no percorreu todos os elementos do vetor e se
encontrou o valor procurado.
A linha 32 executada se chegou ao fim do vetor e no encontrou o valor procurado.
26 - Pesquisa Binria
Este mtodo de pesquisa muito mais rpido que a pesquisa seqencial, e usa como
base que o vetor j est ordenado:
Dado um vetor:
[0, 1, 2, 4, 5, 6, 7, 8, 9]
5. Encontra a posio referente ao meio do vetor, e verifica se o valor procurado o

elemento do meio do vetor.
6. Se encontrou o valor:
- imprime uma mensagem de confirmao.
7. Se no encontrou o valor:
- Se o valor procurado menor que o valor que est no meio do vetor, a posio
final do vetor ser uma posio antes do meio do vetor.
- Se o valor procurado maior que o valor que est no meio do vetor, a posio
inicial do vetor ser uma posio depois do meio do vetor.
- Volta para o passo 1.
Procurando o valor 4 dentro do vetor
O valor da posio inicial 0 (zero).

O valor da posio final 8.
O valor da posio meio 4. (A posio do meio igual ao (inicio + fim) / 2)
Verifica se o valor do vetor que est na posio do meio igual ao valor procurado,
neste caso o valor do meio do vetor 5 e estamos procurando o valor 4.
Como o valor que estamos procurando menor que o valor que est no meio do vetor,
ento mudamos o valor da posio final para 3.
O valor da posio inicial continua sendo 0 (zero).
Agora o valor da posio meio muda 1.
Verifica novamente se o valor do vetor na posio do meio igual ao valor procurado,

Como o valor que estamos procurando maior que o valor que est no meio do vetor,
ento mudamos o valor da posio inicial para 2.
O valor da posio final continua sendo 3.

Como o valor que estamos procurando maior que o valor que est no meio do vetor,
ento mudamos o valor da posio inicial para 3.
O valor da posio final continua sendo 3.

neste caso o valor do meio do vetor 4 e encontramos o valor que estvamos procurando.
26.1 - Implementao do algoritmo de Pesquisa Binria
Na linha 20, declaramos a assinatura do mtodo que vai procurar por um nmero
dentro de um vetor de nmeros.
Na linha 27, criamos um lao que ser executado at encontrarmos o nmero
procurado ou at a posio inicial ficar maior que a posio final (no encontrar o nmero
dentro do vetor).
Na linha 28, calculamos a posio meio do vetor.
Na linha 32, verifica se o valor que tem no vetor na posio meio igual ao valor do
nmero procurado, se for igual, ento imprimimos seu valor e paramos a pesquisa.
Na linha 40, se no encontramos o valor, vamos diminuir o tamanho do vetor, para
restringir o local onde pode estar o valor procurado.
Se o valor do meio do vetor for menor que o valor procurado, significa que o valor que
estamos procurando est entre a posio do meio + 1 e o fim do vetor.
Se o valor do meio do vetor for maior que o valor procurado, significa que o valor que
estamos procurando est entre a posio inicial e o meio 1 do vetor.
A linha 52 executada apenas se no encontrou o nmero procurado dentro do vetor.
26.2 - Pesquisa Binria utilizando objetos
Dado um vetor de pessoas, queremos pesquisar as pessoas que tem a inicial do nome
entre A e F.
OBS: Neste exemplo no vamos tratar mais de um nome com a mesma inicial e
tambm no vamos tratar intervalos de letras que no tem nome, exemplo: 'G' a 'H'.
Neste exemplo criamos algumas pessoas e colocamos elas dentro de um vetor,

depois procuramos qual a posio do vetor est a pessoa com a letra 'A' e tambm
procuramos a posio do vetor est a pessoa com a letra 'F'.
Depois imprimimos todas as pessoas que esto neste intervalo.
Na linha 37, declaramos a assinatura do mtodo que recebe uma letra e um vetor de
pessoas.
Na linha 50 verificamos se a primeira letra do nome da pessoa que est no meio do
vetor igual a letra procurada. Se encontrou o nome, ento retorna a posio do vetor.
Na linha 58, se no encontramos o nome com a letra inicial igual a letra procurada,
vamos diminuir o tamanho do vetor, para restringir o local onde possa estar.
Se a letra do nome do meio do vetor for menor que a letra procurada, significa que o
nome com a letra que estamos procurando est entre a posio do meio + 1 e o fim do
vetor.
Se a letra do nome do meio do vetor for maior que a letra procurada, significa que o
nome com a letra que estamos procurando est entre a posio inicial e o meio 1 do
vetor.
A linha 57 executada apenas se no encontrou o nmero procurado dentro do vetor,
ento retorna a posio que possui um caractere mais prximo do procurado.
26.3 - Exerccios
11. Crie um programa para ordenar (Bubble Sort) um vetor de nmeros inteiros e
pesquisar (Pesquisa Seqencial) um nmero x dentro deste vetor.
OBS: Aproveite que o vetor est ordenado e otimize a pesquisa, para no ter que
percorrer elementos desnecessrios.
12. Crie um programa para pesquisar livros, a pesquisa pode ser feita por autor ou ttulo
do livro.
OBS: Crie uma classe para representar o livro com os atributos que voc achar
necessrio, utilize o algoritmo de busca seqencial ou binria.
13. Crie um programa para pesquisar um nmero dentro de um vetor de inteiros, utilize
um mtodo recursivo que usa o algoritmo de pesquisa seqencial para encontrar o
nmero.
OBS: No h necessidade de nenhuma varivel externa para utilizar o mtodo de
busca seqencial recursiva, se quiser utilize a seguinte assinatura de mtodo: public
void pesquisaRecursiva(int posicao, int valor, int[] numeros)
14. Dado o seguinte vetor de nmeros inteiros:
[1, 3, 6, 7, 8, 10, 11, 12, 15, 16, 17, 18, 19, 20, 23, 24, 25, 27, 29, 30]
Crie um programa que contenha, um mtodo que utiliza pesquisa seqencial e outro
que utiliza pesquisa binria, depois pesquise os seguintes nmeros:
3, 6, 10, 12, 18, 25, 30
e informe qual o mtodo de pesquisa encontrou o valor procurado mais rpido, ou
caso os dois algoritmos encontrem o valor em uma quantidade de passos iguais,
ento imprima que os dois mtodos foram equivalentes para encontrar o valor.
15. Crie um novo programa para melhorar o exerccio 2, agora adicione a ordenao
utilizando (Merge Sort), e permita pesquisar (Pesquisa Binria) livros por ttulo, autor
ou faixa de preo, por exemplo: pesquisar livros que tem seu preo entre R$50 e
R$100.
OBS: A ordenao pode ser feita antes de pesquisar o livro, dessa forma pode
ordenar os livros por autor, ttulo ou preo antes de comear a pesquisar.
27 - Collection
Uma coleo (collection) um objeto que serve para agrupar muitos elementos em
uma nica unidade, estes elementos preciso ser Objetos, pode ter colees homogneas e
heterogneas, normalmente utilizamos colees heterogneas de um tipo especifico.
O ncleo principal das colees formado pelas interfaces da figura a abaixo, essas
interfaces permitem manipular a coleo independente do nvel de detalhe que elas
representam.
Temos quatro grandes tipos de colees: Set (conjunto), List (lista), Queue (fila) e
Map (mapa), a partir dessas interfaces temos muitas subclasses concretas que implementam
varias formas diferentes de se trabalhar com cada coleo.
Todas as interfaces e classes so encontradas dentro do pacote (package) java.util,
embora a interface Map no ser filha direta da interface Collection ela tambm
considerada uma coleo devido a sua funo.
java.util.Collection
A interface Collection define diversos mtodos que so implementados pelas classes

que representam colees, dentro das colees so adicionados Objetos tambm chamados
de elementos.
Alguns dos mtodos que devem ser implementados por todas as subclasses de
Collection:
add(Object e) Adiciona um Objeto dentro da coleo.

addAll(Collection c) Adiciona uma coleo de Objetos dentro da coleo.
contains(Object o) Verifica se um Objeto est dentro da coleo.
clear() - Remove todos os Objetos da coleo.
isEmpty() - Retorna uma boolean informando se a coleo est vazia ou no.
remove(Object o) Remove um Objeto da coleo.
size() - Retorna o tamanho da coleo.
toArray() - Converte uma coleo em um vetor.
A imagem abaixo mostra em azul as principais filhas da classe Collection, com

exceo da interface Map, tambm mostra em verde as classes concretas mais utilizadas
que implementam as interfaces.
java.util.Set
A interface Set uma coleo do tipo conjunto de elementos. As caractersticas

principais deste tipo de coleo so: os elementos no possuem uma ordem de insero e
no possvel ter dois objetos iguais.
java.util.Queue
A interface Queue uma coleo do tipo fila. As principais caractersticas deste tipo
de coleo so: a ordem que os elementos entram na fila a mesma ordem que os
elementos saem da fila (FIFO), podemos tambm criar filas com prioridades.
java.util.Map
A interface Map uma coleo do tipo mapa. As principais caractersticas deste tipo
de coleo so: os objetos so armazenados na forma de chave / valor, no pode haver
chaves duplicadas dentro do mapa.
Para localizar um objeto dentro do mapa necessrio ter sua chave ou percorra o
mapa por completo.
java.util.List
A interface List uma coleo do tipo lista, onde a ordem dos elementos dado
atravs de sua insero dentro da lista.
Neste exemplo ir imprimir Zezinho, Luizinho e Joozinho, pois a ordem que os

elementos foram adicionados na lista.
Outra forma de percorrer os elementos de uma lista atravs da interface

java.util.Iterator.
27.1 - Um pouco sobre Generics
Usualmente, no h uso interessante uma lista com vrios tipos de objetos

misturados. Por este motivo, podemos utilizar uma nova estrutura criada a partir do Java 5.0
chamada de Generics.
A estrutura de Generics serve para restringir as listas a um determinado tipo de
objetos (e no qualquer Object), assim como segue o exemplo:
Repare no uso de um parmetro < ... > ao lado do List e ArrayList. Este parmetro
indica que nossa lista foi criada para trabalhar exclusivamente com objetos de um tipo
especfico, como em nosso caso a classe Pessoa. A utilizao deste recurso nos traz uma
segurana maior em tempo de compilao de cdigo, pois temos certeza que apenas ter
objetos do tipo Pessoa dentro da lista.
27.2 - Exerccios
1-) Crie um programa que represente e teste a seguinte estrutura:

Uma funcionrio possui matricula, nome, cargo e pode estar trabalhando em diversos
projetos, um Projeto possui cdigo, nome, durao e funcionrios que participam deste
projeto.
2-) Dado uma classe Livro, com as propriedades nome, autor, isbn, paginas e preo, crie um
programa que permita ao usurio entrar com os dados de alguns livros, esses livros devem
ser guardados dentro de uma coleo filha da interface java.util.List.
Depois crie um mtodo que utiliza o algoritmo de Bubble Sort, para ordenar est lista
de acordo com o nome do livro e no final imprima a lista de livros ordenado.
3-) Continuando o exerccio 2, crie um algoritmo de Pesquisa Binaria, que possa consultar
um livro pelo seu nome, autor ou isbn. Lembre-se de ordenar a lista de livros antes de fazer a
pesquisa.
Apndice A Boas prticas
O Java como qualquer outra linguagem tem algumas boas praticas de

desenvolvimento, para padronizar o cdigo fonte.
Nos nomes que usamos para representar pacote, classe, mtodo, varivel e etc,
devemos ter bom senso para criar nomes que facilitem a identificao do mesmo.
Nome de pacote (package)

O nome de pacote (package) normalmente representado por uma palavra em
minsculo, exemplo:
Neste exemplo temos os seguintes pacotes:

br
metodista (dentro da pasta br)
poo (dentro da pasta metodista)
aula1 (dentro da pasta poo)
aula2 (dentro da pasta poo)
Usamos os pacotes para separa os fontes da nossa aplicao, de forma que fique
mais fcil encontrar classes de um determinado assunto ou objetivo.
Nome de classe
O nome da classe deve comear com o primeiro caractere de cada palavra em

maisculo, exemplo:
OBS: Dentro de cada arquivo .java s pode existir uma classe public, as demais
classes devem ter acesso default. E o nome do arquivo .java deve ser o idntico ao nome da
classe public.
Nome de mtodo
O nome de mtodo segue o seguinte padro:
a) se o nome do mtodo tem apenas uma palavra, ento o nome todo em minsculo;
b) se o nome do mtodo tem mais de uma palavra, ento o primeiro caractere de cada
palavra a partir da segunda palavra deve se maisculo e o restante da palavra em minsculo.
Exemplo:
Nome de varivel
O nome de varivel segue o seguinte padro:
a) se o nome da varivel tem apenas uma palavra, ento o nome todo em

minsculo;
b) se o nome da varivel tem mais de uma palavra, ento o primeiro caractere de cada
palavra a partir da segunda palavra deve ser maisculo e o restante da palavra em
minsculo.
Exemplo:
Identao
Uma outra boa pratica do desenvolvimento em qualquer linguagem de programao
a identao (alinhamento) do cdigo fonte, facilitando a visualizao.
Um bom padro de identao pode ser da seguinte forma, a cada bloco de abre chave { e
fecha chave } ou a cada condio que pode executar um cdigo, deve ter seu cdigo
interno com um espaamento maior, exemplo:
Comentrios
Outra boa pratica do desenvolvimento de software o comentrio sobre o cdigo escrito,

dessa forma fica mais fcil identificar qual o objetivo de uma classe, mtodo, varivel, etc.
Comentrio pode ser feito de trs formas em Java:
// -> Comentrio de uma nica linha
/* Comentrio com mais

de uma linha */
/**
* Javadoc
* Mais informaes sobre o javadoc no tpico abaixo.

*/
Apndice B Javadoc
Javadoc um utilitrio do pacote de desenvolvimento Java utilizado para a criao de

um documento HTML com todos os mtodos e atributos das classes contidas em seu
projeto, alm dos comentrios inseridos com as tags especiais:
/**
*
*/
Os comentrios do Javadoc so usados para descrever classes, variveis, objetos,

pacotes, interfaces e mtodos. Cada comentrio deve ser colocado imediatamente acima do
recurso que ele descreve.
Tambm possvel utilizar-se de comandos especiais, que servem como marcao,
para que na gerao do documento determinadas informaes j sejam colocadas em
campos especficos, tais como o autor do mtodo descrito ou sua verso. Segue abaixo
alguns destes comandos:
Comentrios gerais
@deprecated - adiciona um comentrio de que a classe, mtodo ou varivel deveria no ser

usada. O texto deve sugeir uma substituio.
@since - descreve a verso do produto quando o elemento foi adicionado especificao da

API.
@version - descreve a verso do produto.
@see - essa marca adiciona um link seo "Veja tambm" da documentao
Comentrios de classes e interfaces
@author - autor do elemento
@version - nmero da verso atual
Comentrios de mtodos
@param - descreve os parmetros de um mtodo acompanhado por uma descrio
@return - descreve o valor retornado por um mtodo
@throws - indica as excees que um dado mtodo dispara com uma descrio associada
Comentrios de serializao
@serial - para documentar a serializao de objetos
Exemplo:
/**
* Mtodo construtor.
* Voc deve utiliza-lo para conectar a base de dados.
* @param usuario usurio do banco de dados
* @param senha senha do usurio de acesso
* @param ipDoBanco endereo IP do banco de dados
* @param nomeDaBase nome da base de dados
* @throws SQLException
* @throws Exception
* @author Cristiano Camilo
* @since 1.0
* @version 1.0
*/
public ConexaoBD(String usuario, String senha, String ipDoBanco, String nomeDaBase)
throws SQLException{
DriverManager.registerDriver(new OracleDriver());
conn = DriverManager.getConnection(
"jdbc:oracle:thin:@(description=(address=(host="+ipDoBanco+")(protocol=tcp)(port=15
21))(connect_data=(service_name="+nomeDaBase+")))",usuario,senha); stm =
conn.createStatement();
System.out.println("Conectado ao banco de dados.");
}
No Eclipse, a utilizao de tal notao j automaticamente interpretada pela IDE, e

ao se invocar este mtodo de qualquer classe do projeto, nos ser exibido uma verso
compacta do javadoc da mesma, assim como segue:
aula.ConexaoBD.ConexaoBD(String usuario, String senha, String ipDoBanco, String

nomeDaBase)
Mtodo construtor. Voc deve utiliza-lo para conectar a base de dados.
Parameters:
usuario usurio do banco de dados
senha senha do usurio de acesso
ipDoBanco endereo IP do banco de dados
nomeDaBase nome da base de dados
Throws:
SQLException
Exception
@author
Cristiano Camilo
@since
1.0
@version
1.0
Gerando a documentao em HTML - Eclipse
Depois comentar seu programa usando as tags acima, basta somente deixar o
javadoc fazer o seu trabalho, pois o mesmo vai se encarregar de gerar nosso HTML!
No diretrio que contm os arquivos-fonte execute o comando:
javadoc -d dirDoc nomeDoPacote
Onde dirDoc o nome do diretrio onde se deseja colocar os arquivos HTML.

Tambm possvel se gerar essa documentao a partir do Ecplise, para isso faa:
Clique no seu projeto com o boto

direito do mouse e selecione a opo
Export...
Na janela de opes que ser exibida, selecione a opo Javadoc e clique em Next...
A prxima janela a ser exibida pede que mais informaes sejam fornecidas.
A primeira delas corresponde ao caminho do arquivo executvel do Javadoc, mais
abaixo voc deve marcar a partir de qual pacote do seu projeto o Javadoc ser gerado.
possvel deixar a pasta do projeto marcada para que o Java gere documentao de todo o
seu projeto.
Mais abaixo existe a opo de visibilidade dos membros os quais voc deseja criar
seu Javadoc. Deixe marcada a opo public, para que a documentao seja gerada para
todos os membros de suas classes que estaro disponveis para as demais classes. O
importante aqui notar que ser gerada a documentao sempre do nvel selecionado at os
outros nveis menos restritos, ou seja, selecionando private, a documentao gerada ser de
todos os termos private, default ou package, protected e public.
Para efeito de entrega de documentao do P.A.P., a opo de gerao a partir da

visibilidade private a mais indicada.
Por fim temos a opo de Doclet, que corresponde ao padro de fonte que ser
utilizado, deixe marcada a opo Standard Doclet, e aponte o destino de gerao de sua
documentao na opo Destination.
Feito isso, basta clicar em finish e sua documentao estar disponvel na pasta
solicitada.
Apndice C Instalando e Configurando o Java
Java Development Kit (JDK)
O Java Development Kit o nome dado ao pacote de aplicativos fornecidos pela SUN
para o desenvolvimento de aplicaes Java. Este manual dedica-se a lhe fornecer os passos
bsicos para efetuar a instalao deste pacote de aplicativos e como configur-lo
adequadamente.
Fazendo o download
O site da SUN microsystems, disponibiliza 3 diferentes verses da JDK. para

download, sendo elas:
Java EE
Java SE
Java ME
Para que voc possa desenvolver aplicaes desktop e web de mdio porte, o pacote do
JavaSE j lhe suficiente. Para baix-lo acesse a seguinte URL:
http://java.sun.com/javase/downloads/index.jsp
E busque pela verso mais atualizada para download. Atualmente temos a verso 6.0
Update 7. Neste ponto, evite verses beta, pois estas ainda esto sendo testadas afim de
atingir seu ponto de maturidade e estabilidade.
A tela seguinte ir solicitar que voc escolha a sua plataforma. Faa-o e no se esquea
de marcar a caixa de seleo de aceite da licena, logo acima do boto Continue.
O download tem cerca de 80MB. E aps a sua finalizao execute-o.
A primeira tela que aparece sobre a Licensa de uso do Java, clique em Aceitar
(Accept) para continuar.
Na prxima tela podemos definir onde o Java deve ser instalado, clique em Prximo
(Next) para continuar.
Na prxima tela mostra a instalao do Java.
Clique em Concluir (Finish), para terminar a instalao.
Durante a instalao do Java SDK, tambm comea a instalao do Java SE

Runtime Environment (JRE).
Escolha onde o JRE deve ser instalado e clique em Prximo (Next) para continuar.
Na prxima tela mostra a instalao do JRE.
Depois da instalao do JDK e JRE precisamos configurar algumas variaveis de

ambiente:
Nas Propriedades do sistema, clique em Variveis de ambiente na aba Avanado.
Adicione a varivel do sistema CLASSPATH com o valor apenas de um ponto final.

Esta variavel serve para executar os comandos do java de diretorio.
Adicione a varivel do sistema JAVA_HOME com o valor igual ao caminho onde foi
instalado o Java.
Agora altere a varivel de sistema Path, no final dela adicione ;%JAVA_HOME%\bin.
Para testar se o Java esta instalado e configurado corretamente, abra um command,

pode ser feito atravs do menu Iniciar / Executar, digite cmd e clique em ENTER.
No command digite java version, deve ser impresso no console a verso do Java
que est instalado.
Depois de instalado o Java podemos tambm instalar um IDE para facilitar o

desenvolvimento.
Instalao do Netbeans
Nessa instalao demonstro como instalar o NetBeans completo, para

desenvolvimento desktop e web.
Execute o arquivo de instalao do NetBeans e aparecer a tela abaixo de

configurao.
Na tela de Bem-vindo, selecione os servidores web GlassFish e Apache Tomcat

apenas se desejar configura-los para desenvolvimento web.
Marque a opo de aceito da licena do NetBeans e clique em Prximo.
Neste tela precisamos informar onde o NetBeans ser instalado e qual verso do Java
vamos utilizar.
Nesta tela podemos definir onde ser instalado o servidor web Glassfish.
Nesta tela podemos definir onde ser instalado o servidor web Tomcat.
Depois que as configuraes foram feitas, clique no boto Instalar.
Na prxima tela mostrado o progresso da instalao do NetBeans.
Depois de instalado o NetBeans podemos fazer o registro on-line ou clicar em

Finalizar, para concluir a instalao.
Apndice D Comandos para MySQL
Segue abaixo alguns comandos utilizados no mysql:
Criar base de dados:

create database <nome da base>;
Todas as tabelas do utilizadas dentro da aplicao so criadas dentro da base

de dados.
Apagar base de dados:

drop database <nome da base>;
Antes de utilizar uma base de dados, precisamos selecion-la:

use <nome da base>;
Criar uma tabela:

create table <nome da tabela> (
);
Apagar uma tabela:

drop table <nome da tabela>;
Tipos de campos:
char
varchar(tamanho)
int
float(tamanho, casas)
date
Definir campo no nulo:

not null
Definir campo chave primaria:

primary key(nome do campo)
Definir campo do tipo auto incremental:

auto_increment
Exemplo de criao de tabela:
create table pessoa (

id int(5) not null auto_increment,
nome varchar(150) not null,
altura float(5, 2),
primary key(id)
);
Mostrar a descrio de uma tabela:

desc <nome da tabela>;
Inserir dados na tabela:

insert into <nome da tabela> ( <colunas da tabela> ) values ( <valores da
colunas> );
Exemplo de insert:
insert into pessoa (nome, altura) values (Sakurai, 1.75);
Consultando todos os dados de uma tabela:

select * from <nome da tabela>;
Consultando apenas algumas colunas de toda tabela:

select <nome das colunas> from <nome da tabela>;
Exemplos de consultas:
select * from pessoa;
select nome, altura from pessoa;
Restringindo a consulta:
select * from pessoa where id = 1;
Utilizando varias restries na consulta:

select * from pessoa where nome like %a% and altura > 1.7;
Ordenando os dados consultados pelas colunas:

select * from pessoa order by altura;
Apndice E Primeira aplicao no NetBeans
O NetBeans uma IDE de desenvolvimento que fornece suporte aos mais variados
segmentos de desenvolvimento Java, bem como algumas outras linguagens de programao
como Ruby e C/C++, tambm possui suporte a modelagem UML. Permite o desenvolvimento
de aplicaes Java simples console, aplicaes desktop client/server, aplicaes web
distribudas e aplicaes de dispositivos portteis.
O NetBeans tambm conta com um ambiente de desenvolvimento amigvel, simples e
intuitivo.
Iniciando o NetBeans 6.0
Tela principal do NetBeans 6.0
A seguir vamos mostrar um passo a passo de como criar uma aplicao console
utilizando o NetBeans:
Criando um novo Projeto Java
Na IDE do NetBeans, clique em File (Arquivo) e depois em New Project (Novo

Projeto) ou utilize o atalho Ctrl+Shift+N:
Na tela de New Project (Novo Projeto), escolha a categoria Java e em seguida

escolha o projeto Java Application (Aplicao Java):
Feito isso clicamos em Next (Prximo) para continuarmos a criao do projeto.
Aparecer a janela de New Java Application (Nova Aplicao Java).

Nesta janela, devemos preencher os campos:
- Project Name (Nome do Projeto), utilize um nome que tenha relao com o
programa que voc ir desenvolver.
- Project Location (Localizao do Projeto), este campo indica onde os arquivos do
projeto sero salvos, caso voc queria procurar pelos arquivos desenvolvidos no projeto.
Ateno, caso voc queira resgatar suas classes mais tarde, este ser o caminho que voc
acessar para localizar seus arquivos .java. Dentro do projeto tem uma pasta chamada src e
dentro desta pasta fica os arquivos fontes.
- Set as Main Project (Definir como Projeto Principal), apenas identificar a IDE que
este seu projeto principal de trabalho, caso voc possua mais de um projeto aberto dentro
do NetBeans.
- Create Main Class (Criar Classe Principal), possvel criar uma classe inicial no
projeto. Esta classe ser responsvel por iniciar a chamada a outras classes do projeto.
Coloque um nome que julgar melhor, sendo que no nosso caso colocamos o nome
HelloWorld, devido a sua funo em nosso projeto.
Feito isso clicamos em Finish (Finalizar) para terminar a criao do projeto Java.
Criado o projeto Java teremos a seguinte estrutura:
1- Estrutura do Projeto Java.

2- rea de edio das classes.
3- Navegao da classe que esta aberta na rea 2, serve para visualizar atributos e
mtodos da classe.
4- Sada da execuo das aplicaes console.
Testando a aplicao console Hello World
Escrevendo o cdigo da aplicao:
Executando a aplicao java:
Para executarmos a aplicao podemos clicar no cone Run Main Project (Executar
projeto principal) ou podemos executar apenas a classe que criamos clicando com o boto
direito em cima de HelloWorld.java e clicando no menu Run File (Executar arquivo).
Depois que executamos a aplicao Java temos a seguinte sada na aba Output.
Bibliografia
[PROJECT GREEN] A brief History of the Project Green - https://duke.dev.java.net/green/
[DEVMEDIA] Conceitos bsicos das plataformas Java e J2ME -

http://www.devmedia.com.br/articles/viewcomp.asp?comp=6484&hl=
[JAVA SE] - http://java.sun.com/javase/technologies/index.jsp
Use a Cabea Java Kathy Sierra e Bert Bates OReilly

Big Java Cay Horstmann - Bookman
Java Como Programar Deitel Prentice Hall
Java Wikipdia -
http://pt.wikipedia.org/wiki/Java_(linguagem_de_programa%C3%A7%C3%A3o)
Download Java - http://java.sun.com/javase/downloads/index.jsp
Varargs - http://java.sun.com/j2se/1.5.0/docs/guide/language/varargs.html
NetBeans - http://www.netbeans.org/
Eclipse http://www.eclipse.org
Estrutura de Dados e Algoritmos em Java Michal T. Goodrich e Roberto Tamassia
Algoritmos: Teoria e Prtica Thomas H. Cormen, Charles E. Leiserson, Ronald L.Rivest e

Clifford Stein
Estruturas de dados & algoritmos em Java Robert Lafore
Recursividade - http://pt.wikipedia.org/wiki/Recurs%C3%A3o
Fibonacci - http://pt.wikipedia.org/wiki/N%C3%BAmero_de_Fibonacci
Fatorial - http://pt.wikipedia.org/wiki/Fatorial
Recurso e algoritmos recursivos - http://www.ime.usp.br/~pf/algoritmos/aulas/recu.html
Bubble Sort - http://pt.wikipedia.org/wiki/Bubble_sort
Merge Sort -
http://www.cse.iitk.ac.in/users/dsrkg/cs210/applets/sortingII/mergeSort/mergeSort.html
Big Java Cay Horstmann
Tutorial Utilizando Collections -

http://www.devmedia.com.br/articles/viewcomp.asp?comp=3162
The Java Tutorials - http://java.sun.com/docs/books/tutorial/collections/index.html
API JDK 1.6 - http://java.sun.com/javase/6/docs/api/

Programação Orientada a Objetos e Algoritmos em Java

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Programação Orientada a Objetos e Algoritmos em Java

Enviado por

Direitos autorais:

Formatos disponíveis

Programao Orientada a

Objetos e Algoritmos em Java

Prof. Cristiano Camilo dos Santos de Almeida

4.6 - Exerccios ........................................................................................................................... 101

17.3 - Relao de algumas bases de dados.................................................................................... 231

23.1 - Fluxo de execuo do Merge Sort ...................................................................................... 359

1.1 - A Linguagem Java

Prottipo Star 7 [PROJECT GREEN]

Com o intuito de se tornar uma linguagem para dispositivos inteligentes destinados ao

Em maro de 1995 foi anunciado no evento SunWorld a tecnologia Java 1.0,

1.2 - Plataforma Java

Atualmente possumos na linguagem Java os mais diferentes seguimentos, desde o

Plataforma Java [DEVMEDIA]

Java Standard Edition (Java SE)

de dados, leitura e escrita de arquivos, comunicao atravs de rede de

Java Enterprise Edition (Java EE)

Java Micro Edition (Java ME)

1.3 - Viso geral do Java Standard Edition

APIs utilizadas dentro da plataforma Java SE [JAVA SE]

1.4 - Java Virtual Machine

A Java Virtual Machine uma maquina imaginaria que implementada atravs da

Fases da programao Java:

1.5 - Compilando um cdigo em linha de comando

Durante o desenvolvimento de aplicaes utilizando a linguagem Java, precisamos criar

Depois de criado este arquivo, acessando a linha de comando iremos executar o

Note que, apesar de no estarmos utilizando a extenso, o arquivo submetido foi o

Quando executamos java PrimeiraClasse o Java comea a executar os cdigos do

1.6 - Linhas de comentrio em Java

Durante o desenvolvimento de um software muito importante escrever comentrios

// -> Comentrio de uma nica linha

/* Comentrio longo com mais

Na linha 1 at a linha 9 estamos criando um comentrio javadoc.

2.1 - Palavras Chave

abstract assert boolean break byte

Uma varivel um objeto normalmente localizado na memria utilizado para

- Variveis de referncia: usada para referenciar um objeto. Quando usamos uma

2.3 - Tipos Primitivos

A linguagem Java no totalmente Orientada a Objetos, e isto se deve principalmente

short -32768 32767 0 16 bits short ex2 = (short)1;

float -1,4024E-37 3.40282347E + 38 0 32 bits float ex5 = 5.50f;

Booleano boolean false true false 1 bit boolean ex9 = true;

importante lembrar que na linguagem Java, os Arrays e Strings so Classes

2.4 - Tipos Inteiros (byte, short, int ou long)

Tipos inteiros trabalham apenas com nmeros inteiros, positivos ou negativos. Os

short s = 010; // Equivale ao valor 8 em decimal.

long a = 0xCAFE; // Equivale ao valor 51966 em decimal

Quando executamos a classe ExemploTipoPrimitivo temos a seguinte sada no

2.5 - Tipos Ponto Flutuante (float ou double)

floaf c = 1.99; // Erro de compilao pois o padro do valor double.

Quando executamos a classe ExemploTipoPrimitivo2 temos a seguinte sada no

2.6 - Tipo Caractere (char)

Os caracteres podem ser representados por nmeros e possuem o mesmo tamanho

char u = \u0025; //Equivale ao caracter %

OBS: O unicode no formato hexadecimal, portanto o exemplo anterior 0025

Quando executamos a classe ExemploTipoPrimitivo3 temos a seguinte sada no

2.7 - Tipo Booleano (boolean)

Na linguagem Java, possvel se atribuir o valor de um tipo de varivel a outro tipo de

Segue abaixo uma tabela com todos os tipos de casting possveis:

DE \ PARA byte short char int long float double

byte Implcito char Implcito Implcito Implcito Implcito

float a = (float) 5.0;

int b = (int) 5.1987;