INTRODUO AO JAVA WEB

Realizao: Lecom

Informaes de contato
Andr Farina Lecom
Rua Manoel Bento da Cruz, 11-29, Bauru - SP
Fixo: 14 4009.8900
Internet: www.lecom.com.br
Email: andre.farina@lecom.com.br

Rafael Fantini da Costa Lecom / MNIX

Rua Manoel Bento da Cruz, 11-29, Bauru - SP
Fixo: 14 4009.8910 / Cel: 14 8104.9339
Internet: www.mnix.com.br
Email: rafael.costa@mnix.com.br

Licena de uso
Este material est licenciado sob a Licena Creative Commons
Atribuio-NoComercial-SemDerivaes 4.0 Internacional.
Para ver uma cpia desta licena, visite
http://creativecommons.org/licenses/by-nc-nd/4.0/
CONTEDO
1. INTRODUO .......................................................................................................................... 1
1.1 O que Java? ........................................................................................................................ 1
1.2 Caractersticas da Linguagem ................................................................................................ 1
1.3 Plataforma Java ..................................................................................................................... 1
1.4 Java Development Kit (JDK) ................................................................................................. 2
1.5 A Mquina Virtual Java ......................................................................................................... 2
1.6 Garbage Collection ................................................................................................................ 3
1.7 Convenes de Cdigo .......................................................................................................... 3
2. A LINGUAGEM JAVA ............................................................................................................... 4
2.1 Princpios .............................................................................................................................. 4
2.2 Membros de uma Classe ........................................................................................................ 4
2.3 O Mtodo main .................................................................................................................. 5
2.4 Exerccios.............................................................................................................................. 5
2.5 Variveis e Operadores .......................................................................................................... 5
2.6 Palavras Reservadas .............................................................................................................. 6
2.7 Tipos de Dados ...................................................................................................................... 6
2.7.1 Inteiro ............................................................................................................................. 6
2.7.2 Ponto Flutuante............................................................................................................... 7
2.7.3 Caractere ........................................................................................................................ 7
2.7.4 Lgico ............................................................................................................................ 7
2.7.5 Tipo de Referncia .......................................................................................................... 7
2.8 Escopo de Variveis ............................................................................................................... 8
2.9 Operadores ............................................................................................................................ 8
2.9.1 Precedncia de Operadores ............................................................................................. 9
2.10 Constantes ....................................................................................................................... 9
2.11 Controle de Fluxo ................................................................................................................ 9
2.11.1 if else ......................................................................................................................... 9
2.11.2 switch ......................................................................................................................... 10
2.11.3 while ........................................................................................................................... 10
2.11.4 for ............................................................................................................................... 10
2.11.5 continue break .......................................................................................................... 11
2.12 Exerccios .......................................................................................................................... 11
3. MTODOS ............................................................................................................................... 12
3.1 Modificadores de Acesso ..................................................................................................... 12
3.2 Parmetros .......................................................................................................................... 12
3.3 Retorno ............................................................................................................................... 12
4. PROGRAMAO ORIENTADA A OBJETOS ........................................................................ 13
 4.1 O Antecessor ....................................................................................................................... 13
4.2 Conceitos ............................................................................................................................ 13
4.2.1 Abstrao ...................................................................................................................... 13
4.2.2 Encapsulamento ............................................................................................................ 14
4.2.3 Classe e Objeto ............................................................................................................. 14
4.2.4 Herana ........................................................................................................................ 16
4.2.5 Polimorfismo ................................................................................................................ 17
4.2.6 Modularidade ............................................................................................................... 18
4.3 Benefcios ........................................................................................................................... 18
4.4 Construtores ........................................................................................................................ 19
4.5 this & super ......................................................................................................................... 19
4.6 Exerccios............................................................................................................................ 20
4.7 Membros Estticos .............................................................................................................. 20
4.7.1 Ocorrncias de membros estticos ................................................................................ 20
4.8 Exerccios............................................................................................................................ 20
5. CLASSES ABSTRATAS E INTERFACES ............................................................................... 22
5.1 Classes Abstratas ................................................................................................................. 22
5.2 Interfaces ............................................................................................................................. 23
5.3 Exerccio ............................................................................................................................. 23
6. EXCEES .............................................................................................................................. 24
6.1 Definio de Exception ....................................................................................................... 24
6.2 Classes de Excees ............................................................................................................ 24
6.3 Tratamento de Excees ...................................................................................................... 24
6.3.1 Capturando Excees.................................................................................................... 25
6.3.2 Deixando uma Exceo Passar ...................................................................................... 26
6.3.3 Lanando uma Exceo ................................................................................................ 26
6.4 Exerccios............................................................................................................................ 27
7. SERVLETS ............................................................................................................................... 27
7.1 O Protocolo HTTP............................................................................................................... 27
7.2 Common Gateway Interface ................................................................................................ 29
7.3 O que so Servlets? ............................................................................................................. 29
7.4 Funcionamento da Servlet ................................................................................................... 30
7.5 Respostas ............................................................................................................................ 31
7.5.1 Exerccios ......................................................................................................................... 32
7.5.2 Status HTTP ................................................................................................................. 32
7.5.3 Exerccios ..................................................................................................................... 33
7.6 Requisies ......................................................................................................................... 33
7.6.1 Parmetros da requisio .............................................................................................. 33
7.6.2 Exerccios ..................................................................................................................... 33
 7.6.3 Cabealhos de Requisio ............................................................................................. 33
8. COOKIES ................................................................................................................................. 35
8.1 Definio ............................................................................................................................. 35
8.2 Estrutura.............................................................................................................................. 35
8.3 Adicionando Cookies........................................................................................................... 35
8.4 Recuperando Cookies .......................................................................................................... 36
8.5 Exerccios............................................................................................................................ 36
9. SESSES.................................................................................................................................. 37
9.1 Funcionamento .................................................................................................................... 37
9.2 Exerccios............................................................................................................................ 38
9.3 Validade da Sesso .............................................................................................................. 38
9.4 Exerccios............................................................................................................................ 38
10. CICLO DE VIDA DA SERVLET ............................................................................................ 39
10.1 Inicializao ...................................................................................................................... 39
10.2 Atendendo as Requisies ................................................................................................. 39
10.3 Finalizao ........................................................................................................................ 40
10.4 Servlet Context .................................................................................................................. 40
10.5 Exerccios .......................................................................................................................... 41
11. VISO GERAL SOBRE JSP .................................................................................................. 42
11.1 O que uma pgina JSP? ................................................................................................... 42
11.2 Diretivas ............................................................................................................................ 42
11.2.1 Diretiva page .............................................................................................................. 43
11.2.2 Diretiva include .......................................................................................................... 43
11.3 Expresses ......................................................................................................................... 43
11.4 Exerccios .......................................................................................................................... 43
11.5 Scriptlets ........................................................................................................................... 44
11.6 Objetos Implcitos ............................................................................................................. 44
11.7 Declaraes ....................................................................................................................... 44
1. INTRODUO

1.1 O que Java?

Java uma linguagem de programao orientada a objetos mantida pela Oracle e originalmente
desenvolvida pela Sun Microsystems. Baseada no C++, o Java foi projetado para ser uma
linguagem portvel para todas as plataformas.
A portabilidade alcanada atravs do uso de um interpretador que traduz os bytecodes (cdigo
resultante da compilao de um programa Java) em instrues de mquina. Isso dispensa a tarefa de
portar o cdigo para diversas plataformas, uma vez que basta instalar a mquina virtual na
plataforma alvo e o programa Java funcionar como na plataforma original.

1.2 Caractersticas da Linguagem

Orientada a objetos: Paradigma de programao mais utilizado na atualidade. Entre os
principais benefcios esto o reuso de cdigo e maior facilidade na manuteno dos sistemas
desenvolvidos;
Simples e robusta: Inspirada no C++, o Java apresenta vrias melhorias em relao a
linguagem da qual foi originada. Possui vrias caractersticas que previnem o programador
de cometer erros comuns no C++, alm de estruturas que facilitam a programao, tornando-
a mais produtiva;
Gerenciamento automtico de memria: O Java abstrai o conceito de referncias, livrando
o programador da (rdua) tarefa de lidar com ponteiros. Alm disso, tanto alocao quanto a
liberao de memria so geridas pela mquina virtual Java, liberando o programador da
preocupao de gerenciar a memria em baixo nvel. A este mecanismo de liberao de
memria damos o nome de Garbage Collection;
Independncia de plataforma: Uma das caractersticas mais marcantes do Java a sua
capacidade de executar programas em plataformas diferentes daquela para a qual o
programa foi inicialmente desenvolvido, como evidenciado pelo mote write once, run
everywhere. Isso possvel graas utilizao da mquina virtual que interpreta bytecodes;
Multi-threading: A execuo de tarefas paralelas facilitada pelo uso da biblioteca de
threading e pelos recursos de sincronizao.

1.3 Plataforma Java

A tecnologia est separada em trs edies com propsitos distintos:
Java Standard Edition (Java SE): ferramentas e frameworks bsicos para qualquer
aplicao Java (inclusive para as outras duas plataformas). Suficientemente completo para
desenvolvimento de aplicaes com interface grfica, por exemplo;
Java Enterprise Edition (Java EE): ferramentas e frameworks para desenvolvimento de
aplicaes distribudas e sites voltados para o uso corporativo. Engloba tecnologias como
EJB, JMS, RMI, CORBA, etc;
Java Micro Edition (Java ME): ferramentas e frameworks para desenvolvimento de
aplicaes executadas em dispositivos mveis e integrados: celulares, set-top boxes,
impressoras, eletrodomsticos, etc.

1
1.4 Java Development Kit (JDK)
O JDK o kit de desenvolvimento disponibilizado pela Oracle que permite ao desenvolvedor criar
aplicativos para a plataforma Java. A ltima verso, 1.7, do JDK, pode ser encontrada em
http://www.oracle.com/technetwork/pt/java/javase/downloads
O JDK compreende:
Java Runtime Environment (JRE) utilizado para executar as aplicaes
Ferramenta de desenvolvimento: compilador, empacotador JAR, debugger, utilitrios (como
o Java2WSDL), etc
Biblioteca de cdigo (framework) com vrios recursos prontos para uso: criao de
aplicativos com recursos visuais, manipulao de estruturas de dados, etc

1.5 A Mquina Virtual Java

O JRE prov os requisitos mnimos para a execuo Java: a Java Virtual Machine (JVM),
implementao das bibliotecas e arquivos de suporte. Alm de ser o corao da JVM, o JRE a

pedra angular da filosofia write once, run everywhere.

Explicando a imagem anterior:

Na compilao, ao invs do cdigo-fonte ser convertido em cdigo-objeto, as instrues so
geradas em bytecode. O bytecode genrico e independe de arquitetura ou sistema
operacional;

2
 Quando um programa Java executado, o arquivo bytecode interpretado pela JVM. Cada
sistema operacional / arquitetura possui sua implementao prpria de JVM e a mesma
dever ser instalada na mquina onde o programa ser executado. Os browser, por exemplo,
possui uma implementao prpria da JVM, utilizada para execuo de Applets (como a
applet de segurana do banco).

1.6 Garbage Collection

Comparativamente, tanto no C quanto no C++, o programa desenvolvido responsvel pela
alocao e liberao de memria, sendo responsvel por um grande nmero de erros: memory leak,
crashes, etc. No Java, ao criar um objeto, a plataforma se encarrega de alocar a quantia certa de
memria e manter o registro de utilizao do mesmo. Assim, quando no estiver mais sendo usado
(referenciado), o objeto coletado e a memria ocupada por ele devolvida ao sistema.
Por ser uma operao custosa, o Garbage Collection acionado automaticamente apenas quando a
aplicao sendo executada excede um limiar de memria em uso. Essa liberao ocorre numa
thread em background para evitar o travamento do programa.
Embora seja possvel invocar o Garbage Collector manualmente utilizando a chamada System.gc(),
destruir objetos diretamente no permitido. Para forar a liberao, preciso eliminar todas as
referncias a esse objeto e, em seguida, invocar o System.gc().

1.7 Convenes de Cdigo

Convenes de cdigo so importantes para desenvolvedores por um nmero de razes:
80% da vida til de um software gasto em manuteno;
Dificilmente um software mantido por toda a sua vida pelo autor original;
Convenes de cdigo aumentam a legibilidade do cdigo, permitindo que os
desenvolvedores entendam o cdigo mais rapidamente e corretamente.
Por ser extenso e fora do escopo deste curso, deixo aqui o link para a pgina que contm uma
definio extensa e completa das convenes de cdigo utilizadas pelos desenvolvedores Java ao
redor do mundo: http://www.oracle.com/technetwork/java/javase/documentation/codeconvtoc-
136057.html

3
2. A LINGUAGEM JAVA
Como o Java uma linguagem orientada a objetos, o desenvolvimento de programas feito por
meio de classes. Uma classe java segue a seguinte sintaxe:
<modificador de acesso> class <nome da classe>
{
<Declarao das Variveis de Instncia (Atributos)>
<Declarao de Mtodos>
public static void main( String args[] )
{
// corpo principal do programa
}
}
Por exemplo:
public class Exemplo1
{
String mensagem = "Minha mensagem";

public void imprimeTexto(String texto) {

// Mostra 'texto' no console
System.out.println(texto);
}

public static void main( String args[] )

{
imprimeTexto(mensagem);
}
}

2.1 Princpios
Assim como toda linguagem, o Java possui suas particularidades:
Identificadores (nomes de varivel, classe, mtodo) devem comear sempre por letras ou
underscore ( _ )
Comandos so finalizados com um ponto e vrgula ( ; )
Java case-sensitive, ou seja, diferencia maisculas de minsculas (diferente de Delphi)
Blocos de cdigo so delimitados por um par de chaves { }
Comentrios so precedidos por // ou contidos entre /* */
o // Isto um comentrio
o /* Isto tambm */

2.2 Membros de uma Classe

As variveis de um objeto (instncia) so chamadas de campos e, juntamente com os mtodos,
compe os elementos bsicos para a construo de uma classe. Como tal, so denominados de
membros da classe.

Os campos so blocos de memria reservados para o armazenamento de informaes durante a vida

4
til de um objeto e, portanto, constituem o estado interno do mesmo. Campos so inicializados na
construo do objeto e ficam disponveis para utilizao por todos os seus mtodos. Os mtodos,
por sua vez, definem as operaes (aes) que podem ser realizadas pela classe.

2.3 O Mtodo main

Para executar, toda aplicao Java precisa de um ponto de entrada e este ponto o mtodo main().
A declarao deve conter a seguinte assinatura para que a aplicao consiga ser iniciada com
sucesso: public static void main( String[] args ) { }
Quando um programa executado, o interpretador chamar primeiramente o mtodo main da classe.
ele quem controla o fluxo de execuo do programa e executa qualquer outro mtodo necessrio
para a funcionalidade da aplicao.
Nem toda classe ter um mtodo main (normalmente apenas uma classe tem um main). Uma
classe que no possui um mtodo main() no pode ser executada pois no representa um
programa em Java. Ela ser sim, utilizada como classe utilitria para a construo de outras classes
ou mesmo de um programa.

2.4 Exerccios
Utilizando a IDE Eclipse:
1. Crie um Java Project que imprima Hello World
2. Crie um programa com uma classe que contenha as quatro operaes algbricas bsicas
(soma, subtrao,...) e outra classe que faa uso das mesmas

2.5 Variveis e Operadores

Variveis so denominaes dadas a pores de memria que armazenam algum dado. Toda
varivel vlida tem as seguintes caractersticas:
declarada antes de ser inicializada;
Possui um tipo, um identificador e um escopo;
Podem ser locais, quando declaradas em mtodos ou so campos, quando declaradas no
corpo da classe;
Podem ser inicializadas na declarao.
Como Java uma linguagem fortemente tipada, todas as variveis devem ser declaradas antes de
serem usadas. O tipo de uma varivel determina o tipo de informao que pode ser armazenada nela.
Variveis em Java podem ser declaradas como campos, no corpo da classe, ou podem ser declaradas
localmente em qualquer parte da implementao de um mtodo. Variveis tambm possuem um
escopo, o qual determina onde no programa ela estar visvel e poder ser acessada.
Declarao de variveis feita como segue:
tipo identificador [= valor] [, identificador [= valor]];

Exemplos:
String texto = Exemplos de declarao de variveis;
int umNumero, UmNumero;
char letra = i;

5
2.6 Palavras Reservadas
Alguns identificadores reservados para uso da prpria linguagem e recebem o nome de palavras
reservadas. So elas:
abstract continue for new switch
assert default goto package synchronized
boolean do if private this
break double implements protected throw
byte else import public throws
case enum instanceof return transient
catch extends int short try
char final interface static void
class finally long strictfp volatile
const float native super while

2.7 Tipos de Dados

No Java, uma varivel pode pertencer a quatro tipos distintos: classes, interfaces, arrays (vetores) e
tipos primitivos. Variveis com classes, interfaces e arrays contm apenas a referncia de memria
(ponteiros) par ao objeto real, enquanto tipos primitivos so armazenados em sua totalidade e
possuem tamanho fixo.
O tamanho e as caractersticas de cada tipo primitivo so consistentes entre as plataformas, no
havendo variaes entre plataformas diferentes, como ocorre no C e C++. Os tipos primitivos so:
Categoria Tipo Tamanho Valor padro
Inteiro byte 8 bits 0
Inteiro short 16 bits 0
Inteiro* int 32 bits 0
Inteiro long 64 bits 0L
Ponto flutuante float 32 bits 0.0f
Ponto flutuante* double 64 bits 0.0
Caractere char 16 bits '\u0000'
Lgico boolean 8 bits False

Os tipos marcados com um asterisco ( * ) so o padro para literais definidos no cdigo.

2.7.1 Inteiro
Tipos inteiros armazenam valores numricos sem casas decimais. Por padro, literais inteiros so
do tipo int e podem ser especificados como hexadecimais utilizando o prefixo 0x . Para literais do
tipo long, deve-se utilizar o sufixo L . Ex:
int hexa = 0xfe; // OK
long outro = 1L; // OK
long combo = 0xfeL; // OK, equivale a 254
int errado = 1L; // No compila

6
 Tipo Variao
byte -128 .. +127
short -32768 .. +32767
int -2147483648 .. +2147483647
long -9 quintilhes .. +9 quintilhes

2.7.2 Ponto Flutuante

Variveis de ponto flutuante armazenam nmeros com casas decimais (conjunto dos nmeros reais).
Deve ser utilizado o ponto ( . ) como separador de casas decimais e, quando necessrio, os nmeros
podem ser escritos em notao exponencial utilizando a caractere E . Para literais do tipo float,
deve-se utilizar o sufixo f . Ex:
double expo = 1.1e4; // OK, equivale a 1.1 * 10^4 = 11000.0
float outro = 1.2f; // OK
float errado = 1.2; // No compila

2.7.3 Caractere
Uma varivel char armazena apenas 1 caractere em seu interior o armazenamento de palavras
reservado a classe String, que no um tipo primitivo. Internamente, o Java utiliza o padro
UNICODE para codificao das variveis do tipo char.
O literal char identificado pelo uso de aspas simples ( ' ) ao redor da letra. Alguns exemplos:
char letra = 'a'; char dupla = '\"'; // Aspas dupla
char linha = '\n'; // Nova linha char unicode = '\u007F'; // Valor UNICODE
char simples = '\''; // Aspas simples char tabula = '\t'; // Tabulao

2.7.4 Lgico
Uma varivel boolean pode armazenar apenas os valores true e false . No possvel utilizar
valores numricos para testes lgicos, como ocorre no C / C++.

2.7.5 Tipo de Referncia

Tipos se separam em primitivos ou referncia. Como vimos, os primitivos armazenam valores
numricos, caracteres e booleanos. Tipos de referncia so classes, interfaces e arrays, e
diferentemente dos tipos primitivos, podem ser definidos pelo desenvolvedor.
Uma grande diferena entre os tipos primitivos e de referncia a alocao: tipos primitivos so
alocados na Stack por possuir tamanho fixo e tipos de referncia so alocados na Heap, por no
possurem tamanho definido. Em funo disso, tipos primitivos so sempre passados por valor,
enquanto tipos de referncia so passados por referncia.
Um exemplo prtico da diferena: ao alterar um parmetro inteiro recebido por uma funo, voc
estar alterando uma cpia da varivel que foi passada como parmetro. Caso fosse um array, a
mudana seria refletida na varivel original.

7
2.8 Escopo de Variveis
O escopo de uma varivel delimitado pelo bloco { } no qual ela est inserida e isso, por sua vez,
determina o ciclo de vida da varivel e quem ter acesso sobre ela.
De forma geral, quando uma varivel declarada no corpo de uma classe, chamamos de campo e
quando declarada no corpo de um mtodo, chamados de local. Uma varivel local s pode ser
acessada pelo mtodo que a definiu, enquanto um campo tem o nvel de acesso definido pelo seu
modificador de acesso (public, private, protected).

2.9 Operadores
Operadores so funes especiais e intrnsecos da linguagem. No Java, temos:
Operador Funo Exemplo Resultado
= Atribuio int var = 2, var1 = -1;
var = var1 + 12;
var1 = var2 = 50;
+ Adio 2+2 4
- Subtrao 1-2 -1
* Multiplicao 1.1 * salario
/ Diviso 100 / 40 2
100 / 40.0 2.5
% Resto da diviso 100 % 40 20
== Igual x == 10
!= Diferente 1 != 1 false
< Menor 1<2 true
> Maior 1>2 false
>= Maior ou igual 2 <= 2 true
<= Menor ou igual 2 >= 3 false
instanceof Pertence classe // Mamifero m; true
m instanceof Animal
&& AND (0 < 1) && (12 > 6) true
|| OR (0 > 1) || (12 < 6) false
! NOT !(2 == 3) true
+= Soma e atribui x += 20 // x = 10 x 30
-= Subtrai e atribui x -= 20 // x = 10 x -10
*= Multiplica e atribui x *= 2 // x = 10 x 20
%= Resto e atribui x %= 3 // x = 10 x1
/= Divide e atribui x /= 3 // x = 10 x3
++ Incremento x++ // x = 10 x 11
-- Decremento x-- // x = 10 x9

8
2.9.1 Precedncia de Operadores
Entende-se por precedncia a ordem na qual os operadores so executados em uma expresso.
Operadores com mesma precedncia so executados da esquerda para a direita, de acordo com a
associatividade. Por exemplo:
int n = 21 / 3 * 5; // n = 35
int n = 21 / (3 * 5); // n = 1

A tabela abaixo mostra as precedncias entre diferentes operadores.

Precedncia Operadores
1 ++ -- !
2 */%
3 +-
4 < > <= >= instanceof
5 == !=
6 && ||
7 = += -= /= %=

2.10 Constantes
Uma constante pode tanto ser definida como um atributo de classe como uma varivel local. Uma
constante uma vez que foi declarada e atribudo um valor para a mesma, no permitido que outra
atribuio seja efetuada, ocasionando um erro de compilao caso isso ocorra. A atribuio do valor
inicial pode ser feita no momento da declarao, ou posteriormente em outra parte do programa.
Para declarar uma varivel do tipo constante, devemos utilizar o modificador final dessa forma:
final <tipo> <identificador> [= valor];

2.11 Controle de Fluxo

2.11.1 if else
Sintaxe Exemplo
if (expr_boolean) { if (idade < 18) {
// Corpo 1 System.out.println("Entrada bloqueada");
} }
else { else {
// Corpo 2 System.out.println("Entrada permitida");
} }

Se a expresso booleana for verdadeira, o Bloco 1 executado, caso contrrio, o Bloco 2

executado.

9
2.11.2 switch
O switch normalmente utilizado para determinar o fluxo a partir de uma expresso com vrios
resultados possveis. A limitao que a expresso avaliada pode ser apenas dos tipos char, byte,
short, int, String e enumeradores.
Sintaxe Exemplo
switch (expr) { switch (nome) {
case const1: case "Fanta":
// Corpo 1 System.out.println("Pessoa");
break; break;
case const2: case "Lecom":
// Corpo 2 System.out.println("Empresa");
break; break;
... default:
[default: System.out.println("Desconhecido");
// Corpo n] }
}

importante notar que:

O case deve ser seguido por um literal ou uma constante.
Todo bloco deve ser finalizado por um break , exceto o bloco default.

2.11.3 while
Executa um bloco de comandos sucessivas vezes at que a condio seja falsa. A
expresso de comparao avaliada antes que o lao seja executado.
Sintaxe Exemplo
while (expr_boolean) { while (i < n) {
// Corpo pot *= x;
} i++;
}

2.11.4 for
Em sua forma mais utilizada, o loop possui um trecho inicial com inicializao das variveis,
seguida por uma expresso de comparao e depois a parte final com o incremento ou decremento
das variveis do lao.
Sintaxe Exemplo
for (init; expr_boolean; pos) { for (int i = 0; i < array.length; i++) {
// Corpo double elemento = array[i];
} }

Logo ao iniciar, o for executa o trecho <init> e, em seguida, testa a condio <expr_boolean>. Caso
seja verdadeira, executa os comandos no bloco e, ao final, executa o comando em <pos> seguido
pelo teste de condio em <expr_boolean>, <bloco>, <pos>, <expr_boolean>, at que
<expr_boolean> seja falsa. O funcionamento se aproxima ao trecho abaixo:
init;
while (expr_boolean) {
// Corpo
pos;
}

10
2.11.5 continue break
O break, quando executado, faz com que o lao mais interno seja interrompido e fora a sada do
mesmo, como se a condio de repetio estivesse falsa. Os usos mais comuns so no switch
usado para sinalizar o fim de um case e para abortar um lao diante de algum gatilho interno (ex:
encontrou o elemento desejado num array).
O continue funciona de maneira anloga, porm oposta. Ele fora que o lao seja interrompido,
mas fora uma nova repetio do lao e, consequentemente, uma nova avaliao da expresso
lgica.

2.12 Exerccios
Faa:
Um programa que calcula o fatorial de um nmero real
Um programa que ordena os valores de um vetor de entrada
Um programa que calcula o permetro do crculo de raio igual ao parmetro de entrada
realizada
Um programa que imprime os nmeros primos contidos entre os valores passados por
parmetro

11
3. MTODOS
Num programa orientado a objetos, o estado interno de um programa determinado pelos campos e
o comportamento definido pelos mtodos. Em Java, um mtodo equivale a uma funo / subrotina
/ procedimento encontrado em outras linguagens de programao. importante notar que no
existem mtodos globais todo mtodo deve, obrigatoriamente, estar contido em uma classe.
Sintaxe:
[modificadores] tipo_retorno identificador([argumentos]) {
// Corpo
}
Exemplo:
public static final int soma(int a, int b) {
return a + b;
}

3.1 Modificadores de Acesso

O acesso a campos e mtodos controlado por meio do uso dos modificadores de acesso. A tabela
abaixo relaciona os modificadores de acesso com a acessibilidade do membro em diferentes pontos
do cdigo.
public protected <nenhum> private
Mundo Sim No No No
Subclasse Sim Sim No No
Mesmo pacote Sim Sim Sim No
Prpria classe Sim Sim Sim Sim
Nota: Os modificadores de acesso no podem ser aplicados a variveis locais.

3.2 Parmetros
Mtodos podem ter zero ou mais parmetros sendo que, mesmo na ausncia de parmetros,
obrigatrio informar os parnteses vazios tanto na definio quanto na chamada do mtodo. Ao
nome do mtodo acrescido dos parmetros d-se o nome de assinatura do mtodo.
Na definio de um mtodo, a declarao de parmetros assemelha-se declarao de variveis
locais, utilizando uma vrgula separadora entre os parmetros, como no mtodo soma acima.

3.3 Retorno
Mtodos podem (ou no) retornar valores. Para sinalizar que existe um retorno, precisamos definir
de antemo o tipo do valor retornado e, no corpo da funo, utilizar a palava reservada return
seguida pela expresso a ser retornada (veja o exemplo do mtodo soma acima). Caso no haja um
retorno, necessrio definir o tipo de retorno como sendo void na assinatura do mtodo.
Quando chamado, o return faz com que o mtodo encerre sua execuo e volte para a posio
anterior na pilha de instrues. Mesmo funes declaradas com retorno void podem lanar mo do
return; como uma ferramenta de controle de fluxo. No exemplo abaixo, curto-circuitamos a
execuo do mtodo quando o saldo for insuficiente.
if (saldo < 0) { return; }

12
4. PROGRAMAO ORIENTADA A OBJETOS

4.1 O Antecessor
Anteriormente programao orientada a objetos, o paradigma dominante era a programao
estruturada. Neste paradigma, a abordagem decompor um programa em subprogramas, realizando
o particionamento at que a unidade de subprograma alcanada tenha coeso e inteligibilidade.
Neste paradigma, o programador forado a fixar ateno nos procedimentos (verbos do problema)
ao invs dos dados (substantivos do problema).
Essa disparidade tem como resultado um aumento na complexidade do software, uma vez a
modelagem de um problema pensando em suas aes no uma tarefa trivial um paradigma que
busca representar um problema baseando-se nos substantivos seria mais recomendado. A partir
dessa ideia foi desenvolvido o paradigma de Programao orientada a objetos.

4.2 Conceitos
Os conceitos bsicos que permeiam a programao orientada a objetos so:
Abstrao;
Encapsulamento;
Classe e Objeto;
Herana;
Polimorfismo;
Modularidade;
Mensagens e mtodos.

4.2.1 Abstrao
Abstrao consiste em ignorar aspectos no-relevantes de um domnio, concentrando-se apenas nos
assuntos principais do problema. Assim, abstrair consiste basicamente no processo de retirar do
domnio do problema os detalhes relevantes e represent-los no mais na linguagem de domnio, e
sim na linguagem de soluo, como Java, C++, etc.

13
4.2.2 Encapsulamento
A propriedade de implementar dados e
procedimentos correlacionados em uma
mesma entidade recebe o nome de
Encapsulamento. A ideia por trs do
encapsulamento a de que um sistema
orientado a objetos no deve depender
da implementao interna, e sim da
interface de seus componentes.
Vejamos o exemplo de um circuito
integrado (CI). Pode-se notar o
encapsulamento de vrios componentes
como transistores, resistores,
capacitores e outros interligados por um
circuito. O usurio que utiliza um CI
no precisa se preocupar com os
mecanismos internos de um CI apenas com o comportamento da interface (os pinos).

4.2.3 Classe e Objeto

Um Objeto um elemento que formaliza o modo pelo qual compreendemos algo no domnio do
problema, refletindo a capacidade do sistema de guardar informaes sobre tal elemento, interagir
com ele, ou ambas as coisas.
Uma Classe descreve (define) um conjunto de objetos semelhantes que compartilham a mesma
semntica. Um relacionamento anlogo ao de Classe-Objeto seria a relao entre uma Receita de
Bolo e um Bolo criado com a receita: a receita pode ser encarada como uma frmula para criao
bolos, mas ela, em si, no um bolo.
Considere um programa para um banco, uma entidade extremamente importante para o nosso
sistema a conta uma boa prtica generalizarmos as informaes da conta relevantes ao
domnio do problema, juntamente com as funcionalidades (aes) que toda conta deve possuir.

14
Entre os dados de uma conta que so importantes, podemos listar: nmero da conta, nome do cliente,
saldo, limite, etc. Entre as aes que gostaramos de atribuir a uma conta, temos: sacar uma
quantidade x, depositar uma quantidade y, imprimir o nome do dono da conta, retornar o saldo
atual, transferir uma quantidade x para uma outra conta y, etc.
Comeando pelos contedos de uma conta, podemos traduzir as informaes acima para uma classe
que ficaria como no trecho abaixo:
class Conta {
int numero;
String nome;
double saldo;
double limite;
}

Agora temos a definio da estrutura de uma conta. No possvel, no entanto, obter o saldo da
conta, pois o que temos apenas a definio de uma conta no uma conta propriamente dita.
Para essa tarefa, precisamos construir uma conta, sua definio, assim conseguiremos manipular a
conta como gostaramos. A esta definio damos o nome de classe e aos produtos da construo de
uma classe damos o nome de objeto.
Para podermos efetivamente usar um objeto criado a partir da classe Conta, alm de construir o
objeto, precisamos tambm de um ponto de incio no programa a partir do qual o sistema
operacional passa o controle a nossa aplicao. Vamos criar um arquivo Programa.java para isso:
class Programa {
public static void main(String[] args) {
Conta minhaConta;
minhaConta = new Conta();
}
}

Para criar (construir, instanciar) uma Conta, basta usar a palavra reservada new seguida pelo nome
da classe (neste caso, Conta) e parnteses.
Atravs da varivel minhaConta agora podemos acessar o objeto recm-criado para obter/alterar
seu nome, saldo, etc
class Programa {
public static void main(String[] args) {
Conta minhaConta;
minhaConta = new Conta();

minhaConta.nome = "Fanta";
minhaConta.saldo = 1.99;
}
}

importante fixar que o ponto em minhaConta.saldo foi utilizado para acessar o campo saldo no
objeto minhaConta. Agora, minhaConta pertence ao Fanta, e tem saldo de R$ 1,99.
Dentro da classe, tambm iremos declarar o que cada conta faz, e como feito os
comportamentos que cada classe tem, isto , o que ela faz. Por exemplo, de que maneira que uma
Conta saca dinheiro?
Especificaremos isso dentro da prpria classe Conta, e no em um local desatrelado das
informaes da prpria Conta. Essas funes declaradas no interior de uma classe so chamadas
de mtodo e recebem este nome, pois, determina a maneira de fazer uma operao com um objeto.

15
Como queremos a possibilidade de sacar dinheiro da conta, iremos criar um mtodo que saca uma
quantidade determinada e no retorna informaes.
void saca(double quantidade) {
double novoSaldo = this.saldo - quantidade;
this.saldo = novoSaldo;
}

A palavra reservada void indica que o mtodo no retorna nenhum dado quele que o invocou.
Mtodos exigem a colocao de parnteses tanto nas declaraes quanto nas chamadas para
delimitar os parmetros fornecidos aos mesmos.
Neste exemplo, podemos ver que o mtodo saca possui um parmetro (ou argumento)
quantidade que indica a quantia a ser sacada. Essa varivel uma varivel comum, chamada
tambm de temporria ou local, pois ao final da execuo desse mtodo, ela deixa de existir (escopo
local). Dentro do mtodo, tambm estamos declarando uma nova varivel que assim como o
argumento, vai morrer no fim do mtodo, pois este seu escopo. Para fins de escopo, o parmetro
tratado como uma varivel declarada no corpo do mtodo.
O prximo passo mandar uma mensagem ao objeto minhaConta e pedir que ele execute o
mtodo saca(). Para denominar essa execuo, utilizamos o termo invocao de mtodo.
public static void main(String[] args) {
Conta minhaConta;
minhaConta = new Conta();

minhaConta.nome = "Fanta";
minhaConta.saldo = 1.99;

minhaConta.saca(1.00);
}

Objetos interagem e se comunicam atravs de mensagens. As mensagens identificam os mtodos a

serem executados e, quando enviadas a um objeto, sinalizam ao objeto que uma invocao de
mtodo deve ser realizada. Para enviar uma mensagem, precisamos de:
Identificar o objeto que receber a mensagem
Identificar o mtodo que o objeto dever executar
Passar os argumentos requeridos pelo mtodo

4.2.4 Herana
A herana possibilita a hierarquizao de classes, onde uma classe mais especializada (classe filha
ou subclasse) pode herdar as propriedades (mtodos e atributos) e semntica de uma classe mais
geral (classe pai ou superclasse).
No exemplo a seguir dizemos que a classe Gerente herda todos os atributos e mtodos da classe
me Funcionario. Sendo mais preciso, ela tambm herda os atributos e mtodos privados, porm
no consegue acess-los diretamente.
class Funcionario {
String nome;
String cpf;
double salario;
}

16
class Gerente extends Funcionario {
int senha;
public boolean autentica(int senha) {
if (this.senha == senha) {
System.out.println("Acesso Permitido!");
return true;
} else {
System.out.println("Acesso Negado!");
return false;
}
}
}

4.2.5 Polimorfismo
O termos polimorfismo originrio do grego e quer dizer possuidor de vrias formas. Na
programao, est atrelado capacidade de um mtodo assumir vrias implementaes diferentes
sob um mesmo nome e capacidade do programa em discernir, dentre mtodos homnimos, aquele
que deve ser executado. Uma das maiores vantagens do uso de polimorfismo est na criao de
programas mais claros e flexveis, pois, elimina a necessidade de replicao de mtodos ao mesmo
tempo em que permite a extenso dos j existentes, como podemos observar no exemplo:
class EmpregadoDaFaculdade {
private String nome;
private double salario;

double getGastos() {
return this.salario;
}
}

class ProfessorDaFaculdade extends EmpregadoDaFaculdade {

private int horasDeAula;

double getGastos() {
return super.getGastos() + this.horasDeAula * 10;
}
}

Polimorfismo tambm est relacionado capacidade de uma varivel em receber objetos de classes
distintas. Veja:
public class Aluno extends Pessoa {
....
}

Pessoa p;
p = new Pessoa(); // OK
p = new Aluno(); // OK
p = new Object(); // ERRO

17
4.2.6 Modularidade
Em programas grandes, ocasionalmente surge o problema: quero escrever uma classe com
determinado nome, mas o mesmo j est em uso. Por exemplo: Voc est integrando o cdigo de
um outro sistema ao seu e uma coliso de nomes ocorre em classes com funcionamentos diferentes.
Para resolver este problema, recorremos a estrutura de diretrios para organizar as classes. Por sua
vez, no Java, estes diretrios so mapeados para pacotes, estruturas que agrupam classes com
objetivos comuns. Veja o pacote java.util ele contm classes utilitrias.
A utilizao de pacotes no s permite uma organizao maior do cdigo como tambm facilita o
compartilhamento do mesmo, j que existem modificadores de acesso para o nvel de pacote,
permitindo que determinado mtodo / campo / classe seja visvel apenas para classes pertencentes
ao mesmo pacote.

4.3 Benefcios
Observe a classe abaixo de uma simples aplicao de Zoolgico:
public class Zoo {
private Animal[] lista = new Animal[8];
public Animal[] getLista(){
return this.lista;
}

public void adicionarAnimal( Animal p){

for(int i=0; i<lista.length; i++){
if (lista[i] == null){
lista[i] = p;
break;
}
}
}

Utilizamos a classe Animal para lanar mo do polimorfismo (Rpteis, Mamferos, etc). No fosse
por ela, teramos um grande prejuzo ao criar estruturas distintas para receber cada um dos tipos de
Animal: uma para Reptil, uma para Mamifero, etc. Como a estrutura dessas classes tem muito em
comum, podemos generalizar a definio em uma superclasse a fim de evitar a replicao de
cdigo e facilitar a manuteno.

18
4.4 Construtores
Construtores so mtodos especiais, utilizados para personalizar a construo de objetos e possuem
as seguintes caractersticas:
o primeiro mtodo executado pelo objeto
Deve possuir o mesmo nome da classe
No tem um tipo de retorno (nem mesmo void)
invocado atravs do uso do operador new (instanciao)
Tem modificador de acesso, normalmente public
Toda classe deve possuir ao menos um construtor. Se omitido, o compilador gerar um construtor
pblico, com corpo vazio e sem parmetros, como no exemplo abaixo:
public Reptil() {
}

Por serem os primeiros mtodos a serem executados, construtores so utilizados para iniciar o
estado interno de um objeto, configurando-o de acordo com os parmetros fornecidos:
public Reptil(String especie) {
this.especie = especie;
}

public Reptil() {
this("Desconhecido");
}
Nota: Caso alguma exception lanada no corpo do construtor no seja tratada, a criao do objeto
falhar.
O exemplo acima demonstra que, assim como ocorre com os mtodos, podemos ter sobrecargas de
um construtor. Inclusive, podemos faz-los chamarem uns aos outros utilizando o this(). Aplicamos
este recurso na definio de sobrecargas de um construtor que vo de um nvel mais complexo
(vrios parmetros) para um nvel mais simples.

4.5 this & super

Todos os mtodos de uma instncia recebem os argumentos implcitos this e base que nada mais
so do que referncias para o prprio objeto e para o objeto pai, respectivamente. Embora possa
parecer pouco til a primeira vista, essas referncias so indispensveis em muitas das situaes
encontradas pelo desenvolvedor Java:
Desambiguao: O construtor da classe Reptil recebe um parmetro que possui o mesmo
nome de um campo. Neste caso, utilizamos o this.especie para dizer ao compilador que
queremos a varivel membro e no a local. O mesmo vale para uma classe que define um
campo com nome idntico a um campo presente na superclasse e que deseja utilizar a
varivel da superclasse ao invs da prpria;
Construtor: Caso seja necessrio que uma sobrecarga do construtor chame outra, utilizamos
o this() para sinalizar a inteno. Usando a base(), conseguimos chamar um construtor da
superclasse til para situaes onde a assinatura do construtor de sua classe difere da
superclasse;
19
 Polimorfismo: Muitas vezes, ao sobrescrever um mtodo da superclasse, queremos apenas
ampliar o comportamento original em vez de substitu-lo completamente. Em casos como esse,
comum invocar a verso da superclasse utilizando base.metodo().

4.6 Exerccios
Crie uma classe Poligono com os mtodos calculaPerimetro() e calculaArea() e crie as
classes Triangulo e Quadrado sobrescrevendo ambos os mtodos.

4.7 Membros Estticos

Membros estticos so aqueles que no pertencem a uma instncia especfica, mas sim prpria
classe. Como tal, membros estticos so compartilhados entre todas as instncias da classe e no
precisam de instanciao para serem usados. Vejamos o exemplo:
class Usuario { Usuario.tentativas = 0;
public static int tentativas; Usuario c1 = new Usuario();
... Usuario c2 = new Usuario();
public void login() {
tentativas++; c1.login(); // tentativas = 1
// Restante c2.login(); // tentativas = 2
} c1.tentativas = 0;
} c2.login(); // tentativas = 1

Para tornar um membro esttico, basta acrescentar o modificador static declarao do mesmo.
Note que possvel utilizar o membro esttico atravs da prpria classe (Usuario.tentativas) ou
atravs das instncias (c1.tentativas). Independentemente da abordagem, a varivel acessada a
mesma em ambos os casos.
Embora teis, membros estticos exigem alguns cuidados especiais no manuseio. Primeiramente,
no possvel utilizar as referncias this e base, uma vez que o membro esttico no existe em uma
instncia. Pela mesma razo, membros estticos s podem referenciar outros membros estticos.

4.7.1 Ocorrncias de membros estticos

Nas bibliotecas do Java encontramos inmeros casos de atributos e mtodos estticos. Nosso
conhecido mtodo main(), por exemplo, um mtodo esttico, que chamado pela JVM quando
uma aplicao executada. A classe Math prove mtodos de classe que executam vrias funes
matemticas, como funes trigonomtricas e logaritmos. Um exemplo o mtodo Math.sqrt() que
calcula a raiz quadrada de um nmero no negativo. A classe System prove variveis de classe para
representar o estado do sistema inteiro. System.out uma varivel de classe que faz referncia ao
objeto PrintStream, que representa o fluxo padro de sada. O mtodo println() um mtodo de
instncia da classe PrintStream.

4.8 Exerccios
Refaa os exerccios dos itens 2.12 e 4.6 utilizando seus novos conhecimentos
Crie um programa de perguntas e respostas com reprocessamento onde o usurio dever
responder uma srie de perguntas mltipla escolha.
Ao trmino da jogada, ser apresentado o nmero de acertos realizados na jogada

20
 Aps mostrar o nmero de acertos, imprimir tambm as 3 questes que mais tiveram
respondidas erradas de todos os tempos (no apenas da jogada atual)

21
5. CLASSES ABSTRATAS E INTERFACES
Em grandes sistemas, comum que a hierarquia de classes torne-se complexa, onde as classes mais
acima (raiz e proximidades) costumar ser bastante gerais, favorecendo o reuso. Passa a ser
interessante a possibilidade de definir prottipos de classes que sero usadas para guiar a criao de
outras classes. Elas implementam ou apenas definem comportamentos que so genricos o
suficiente para serem comuns a vrias outras classes.

5.1 Classes Abstratas

Voltando ao exemplo da classe Animal, podemos notar que a definio de animal muito ampla e
mesmo que animais possuam caractersticas compartilhadas, o modo como de operar de cada tipo
de animal muito diferente: alguns se locomovem pelo ar, outros por terra, etc. Sendo assim, temos
que a classe Animal pode ser considerada um modelo que no deve ser criado diretamente.
Uma das maneiras de criar tais modelos se d atravs do uso de classes abstratas. Uma classe
abstrata uma classe incompleta que no pode ser construda, necessitando de subclasses que
forneam os detalhes necessrios para que a classe esteja completa. Vejamos um exemplo da
modelagem de animais:
abstract class Animal {
String especie;
int idade;

public abstract void locomover();

public abstract void alimentar();
public void nascer() { ... }
public morrer() { ... }
}
Foi utilizada a palavra reservada abstract para definir uma classe abstrata e tambm mtodos
abstratos. Se tentarmos instanciar uma classe abstrata receberemos um erro de compilao.
Analogamente, mtodos abstratos no possuem corpo, e devem ser obrigatoriamente
implementados nas classes filhas. Uma classe abstrata pode conter:
Mtodos e atributos como em classes convencionais. As classes derivadas de uma classe
abstrata herdam da mesma forma os mtodos e atributos. Estes mtodos podem ser
sobrescritos nas subclasses mas isto no obrigatrio;
Mtodos abstratos, que obrigatoriamente devem ser sobrescritos pelas subclasses.
A existncia de mtodos abstratos ocorre apenas em classes abstratas. Como uma classe abstrata
est num nvel muito alto de abstrao, muito frequentemente no possui detalhes suficientes para
implementar determinados comportamentos que sero comuns a todas as suas subclasses. Ao invs
disso, elas apenas definem quais sero estes comportamentos obrigatrios atravs da criao de
mtodos abstratos.
Como pode ser visto no exemplo, para definir um mtodo abstrato devemos prover apenas a
assinatura do mtodo, isto , seu nome, argumentos e tipo de retorno. A implementao (corpo)
deste mtodo ficar a cargo de cada subclasse concreta, que poder dar a sua verso para ele.
O uso de classes e mtodos abstratos uma forma bastante comum e flexvel para criarmos e
utilizarmos bibliotecas orientadas a objetos: por meio de herana associamos nossas classes e
implementamos os mtodos abstratos. Por meio do polimorfismo, temos a garantia de que as nossas
implementaes sero compatveis com os locais que fazem uso da classe abstrata.

22
5.2 Interfaces
Suponhamos que exista a necessidade de fazer com que um animal bote ovos. Uma ideia seria
acrescentar o mtodo abstrato botarOvo() na classe Animal, mas nada garante que um Animal
tenha a capacidade de botar ovos.
Uma outra soluo seria criar outra classe com este mtodo, mas precisamos que nossa classe seja
descendente de Animal, uma vez que o Java no suporta herana mltipla, como no C++. Devemos
recorrer a interfaces para solucionar este problema:
interface Oviparo {
public static final int MAX_OVOS = 10;
public void botarOvo();
}

class Mamifero extends Animal implements Oviparo, Comparable {

...
public void botarOvo() {
...
}
}

Existe muita semelhana entre interfaces e classes abstratas, mas interfaces possuem limitaes em
sua constituio: elas podem conter apenas constantes e mtodos, sendo que nenhum destes
mtodos pode conter implementao (abstratos). Para uma classe implementar uma interface,
devemos usar a palavra reservada implements (diferente de extends), como no exemplo anterior.
obrigatrio que toda classe ao implementar uma interface implemente todos os mtodos
especificados pela mesma. Assim, interfaces fornecem a ideia de um contrato que qualquer
subclasse deve obedecer. Outra caracterstica importante que uma classe pode derivar de apenas
uma nica outra classe (herana simples), mas pode implementar um nmero indeterminado de
interfaces.
Uma concepo errnea de quem est se iniciando no Java que escrever interfaces perda de
tempo, uma vez que o cdigo escrito no serve pra nada, uma vez que a classe implementadora
obrigada a fornecer uma implementao. Essa uma maneira errada de pensar O objetivo do uso
de uma interface deixar seu cdigo mais flexvel, e possibilitar a mudana de implementao sem
maiores traumas (manutenibilidade).
No apenas um cdigo de prototipao, tampouco um cabealho Trata-se de uma definio de
um novo tipo e j podemos observar suas vantagens.

5.3 Exerccio
Crie um programa de agenda com:
o Uma classe abstrata Pessoa (codigo, nome)
o Uma interface DoadorSangue com o mtodo String getTipoSangue()
o Uma classe Funcionrio que estenda Pessoa e implemente DoadorSangue
Inclua o atributo int cracha com set e get
Adicione um atributo String tipoSangue cujo valor dever se atribudo pelo
construtor
o Uma classe Fornecedor, subclasse de Pessoa, com o campo String ramo

23
6. EXCEES
Olhando os Javadocs (e recomendo que olhem com frequncia), podemos encontrar alguns mtodos
que possuem a palavra reservada throws em sua assinatura, como o mtodo File.createNewFile():
http://docs.oracle.com/javase/7/docs/api/java/io/File.html#createNewFile()
A palavra reservada throws indica que este mtodo realiza operaes que podem retornar um ou
mais tipos de Exceptions. Mas, afinal, o que so exceptions no Java?

6.1 Definio de Exception

O termo exception uma abreviao para evento excepcional um evento ocorrido durante a
execuo do programa que rompe o fluxo normal de instrues.
Quando um erro ocorre dentro de um mtodo (como tentar acessar uma posio no existente em
um array), o mtodo cria um objeto e entrega-o ao Runtime a este objeto damos o nome de
exception. Esta exception carrega dentro de si informaes relacionadas ao erro, incluindo o tipo
do erro e algumas variveis indicadoras do estado do programa no momento em que o erro ocorreu.
O ato de criar um objeto da classe Exception pass-lo ao Runtime chamado lanar uma
exception.

6.2 Classes de Excees

Tanto as excees quanto os erros derivam da classe Throwlable:
Erros: So classes filhas da classe Error e indicam que ocorreu um erro irrecupervel,
geralmente fatal para a execuo do programa;
Excees unchecked: Estas excees so derivadas da classe RuntimeException e
geralmente esto associadas com erros inerentes da execuo do programa: acessar posies
inexistentes de um array, chamar um mtodo de um objeto inexistente (null), etc. possvel
optar por no tratar essas excees;
Excees checked: Excees que derivam da classe Exception. O desenvolvedor deve,
obrigatoriamente, capturar excees deste tipo ou um erro de compilao ocorrer.

6.3 Tratamento de Excees

Quando um mtodo lana uma exception, o Runtime encerra a execuo do mtodo no ponto onde a
exceo foi lanada e inicia a busca por algum que consiga trat-la. A lista de candidatos
composta pelos mtodos que foram chamados at o ponto onde o erro ocorreu. A esta lista de
mtodos damos o nome de call stack.
A exception continua rompendo o fluxo dos mtodos na call stack at que encontre um bloco de
tratamento de exceptions. A ordem em que a busca ocorre do mtodo mais prximo da
ocorrncia do erro at o mtodo main. Caso o Runtime no encontre nenhum bloco de tratamento
adequado, o programa terminado.
As excees existem em duas modalidades: checked e unchecked. A primeira obrigatoriamente
precisa ser envolta em um bloco try-catch, do contrrio, um erro de compilao ocorrer. Como
desenvolvedor Java, ao encontrar um mtodo que lana exceptions, voc tem alternativas:
Capturar a exceo e trat-la
Deix-la seguir para o mtodo superior na call stack

24
 Capturar a exceo e disparar uma exceo diferente

6.3.1 Capturando Excees

Se um bloco de cdigo possui um ou mais mtodos que podem disparar excees, basta cerc-lo
com um bloco try-catch para permitir que seu cdigo esteja escutando possveis excees.
possvel (e comum) que exista mais de um bloco de catch para um dado trecho de cdigo,
permitindo que cada catch trate uma exceo de um tipo especfico. Opcionalmente, pode-se
incluir um bloco finally aps todos os blocos catch, o que sempre executado ao final, mesmo que
nenhuma exceo ocorra. Um exemplo de exceo aritmtica:
try {
int erro = 1 / 0; // Diviso por zero
} catch (ArithmeticException e) {
// Tratamento do erro
}
Nota: Se houvesse algum cdigo aps a diviso, ele nunca seria executado.
Alterando o exemplo anterior, teremos os seguintes valores impressos no console:
Cdigo Console
try { passo 1
int erro = 1 / 0; // Diviso por zero passo 2
} catch (ArithmeticException e) {
System.out.println("passo 1");
} finally {
System.out.println("passo 2");
}
Podemos ir alm e remover o bloco de catch, deixando apenas o finally. Com isso, o programa
imprimir passo 2 no console antes da exception ser lanada para o Runtime e forar o
encerramento do programa:
passo 2
Exception in thread "main" java.lang.ArithmeticException: / by zero
at lecom.curso.Programa.main(Programa.java:7)

Voltando ao mtodo File.createNewFile(), podemos observar que ele existem trs possibilidades de
exceo: IOException (checked), IllegalArgumentException (unchecked) e SecurityException
(unchecked). Por ser uma exceo checked, devemos tratar a IOException, ficando a critrio do
desenvolvedor tratar as outras duas. Uma possvel implementao ficaria como segue:
File f = null;
try {
f = File.createTempFile("tmp", ".txt");
// Bloco de operaes com 'f'
}
catch (IOException e1) {
// Tratamento de e1
}
catch (SecurityException e2) {
// Tratamento de e2
}
finally {
if (f != null) {
f.deleteOnExit(); // Limpeza
}

25
}

importante notar que o polimorfismo do Java nos permite construir estruturas elaboradas de
tratamento de exceptions. Complementando o exemplo do File.createTempFile():
try {
f = File.createTempFile("tmp", ".txt");
// Bloco de operaes com 'f'
}
catch (IOException e1) {
// Tratamento de e1
}
catch (SecurityException e2) {
// Tratamento de e2
}
catch (Exception e3) {
// Tratamento de excees inesperadas
}
finally {
if (f != null) {
f.deleteOnExit(); // Limpeza
}
}
Veja que acrescentamos um novo bloco de catch com uma Exception e3. O efeito prtico dessa
estrutura que todas as excees no tratadas pelos blocos de catch anteriores sero direcionadas
para a varivel e3. Isso ocorre porque todas as excees so subclasses de Exception.

6.3.2 Deixando uma Exceo Passar

Existem casos onde no queremos tratar uma exceo do tipo checked. Felizmente, podemos livrar
o mtodo da obrigao de tratar a exceo acrescentando um throws NomeDaException
assinatura do mesmo. Desse modo, estamos delegando a responsabilidade de tratar a Exception para
os mtodos acima.
public void meuMetodo() throws IOException {
File f = File.createTempFile("tmp", ".txt");
// Restante do mtodo
}

6.3.3 Lanando uma Exceo

Como desenvolvedor, seria interessante podermos criar nossas prprias excees e lan-las como
resposta a um comportamento inesperado. Felizmente, isso possvel no Java.
Para criar sua prpria exceo do tipo checked, basta criar uma classe que seja filha de Exception.
Caso deseje uma exceo unchecked, a classe deve ser filha de RuntimeException.
Lanar uma exceo igualmente simples: basta utilizarmos o comando throw (no confundir com
o throws que acompanha a assinatura de um mtodo) seguido pelo objeto da exceo:
throw new MinhaException("Erro mortal");
Dica: Podemos encarar o throw como se fosse um return de excees.

26
6.4 Exerccios
Refaa o exerccio do item 5.3 fazendo com que os dados venham de um arquivo e tratando
as Exceptions e criando uma Exception prpria que deve ser lanada ao tentar inserir um
contato com nome idntico a um j existente na agenda.

7. SERVLETS
Hoje comum vincularmos a ideia de Web com dinamicidade, mudana, mas essa nem sempre foi a
realidade: j houve um tempo onde sites eram apenas stios de hipertexto esttico ligados por meio
de hiperlinks. Tecnologias da atualidade nos permitiram alterar esse panorama e transformar a Web
no que vemos hoje: CGI, PHP, .NET, e, principalmente, Java.
Java ganhou destaque como linguagem para a Web por ter vrias caractersticas que favoreciam o
desenvolvimento de pginas dinmicas:
Portabilidade (JVM);
Produtividade (POO, Garbage Collection)
Comunidade ativa e numerosa (Apache Foundation e vrias outras instituies open-source)
Escalabilidade (permite arquitetura distribuda)
Eficincia (Servlets persistentes entre requisies)
Recompilao automtica (pginas JSP)

7.1 O Protocolo HTTP

Antes de tratarmos de Servlets, importante entendermos deste protocolo sobre o qual os Servlets
esto fundamentados.
O protocolo HTTP um protocolo da camada de aplicao utilizado para distribuio de contedo
hipermdia de maneira distribuda e colaborativa e utilizado na navegao de pginas na internet.
Os browsers utilizam o HTTP para obter contedo de servidores remotos e mostr-los localmente.
Os clientes obtm contedo por meio de requisies enviadas ao servidor que, por sua vez, processa
a requisio e devolve uma resposta ao cliente (possivelmente com algum contedo hipermdia).
Por ser um protocolo stateless de comunicao cliente-servidor, nenhuma informao mantida
sobre os clientes ou requisies previamente recebidas.
Requisies HTTP so compostas pelos seguintes elementos:
Um comando, tambm conhecido como mtodo ou verbo
O endereo de um recurso no servidor, tambm chamado de caminho ou path
A verso do protocolo HTTP sendo utilizado
Juntando todos esses dados, teremos uma requisio que se assemelha ao exemplo abaixo:
GET / HTTP/1.1
Host: www.google.com.br
Existem diversos mtodos HTTP disponveis para uso nas requisies, mas os mais comuns so:
GET utilizado para obter algum contedo do servidor, como uma pgina ou imagem
POST utilizado para enviar dados de formulrio ao servidor

27
 HEAD similar ao GET, mas envia apenas os cabealhos de resposta

Com a introduo da verso 1.1 do HTTP, novos mtodos foram acrescentados:

PUT armazena a entidade enviada no corpo da requisio
DELETE remove o recurso especificados
OPTIONS lista os mtodos suportados pelo servidor no endereo fornecidos
Uma requisio tambm pode conter parmetros adicionais, chamados cabealhos ou
headers. Os headers mais comuns so:
User-Agent contm informaes sobre o cliente que iniciou a requisio (browser, verso,
etc).
o Chrome: Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML,
like Gecko) Chrome/33.0.1750.146 Safari/537.36
Accept indica quais os tipos de recursos aceitos pelo cliente
o Exemplos: */* (tudo), text/html, image/jpeg, etc.

Exemplo atualizado com os cabealhos:

Estrutura Exemplo
<Verbo> <Caminho> <Verso HTTP> GET /ExemploServlet/ImprimeIp HTTP/1.1
Host: <Endereo base> Host: localhost:8080
<Nome do cabealho 1>: <Valor 1> User-Agent: curl/7.30.0
... Accept: */*
<Nome do cabealho n>: <Valor n>

IMPORTANTE: A ordem precisa ser respeitada para que o servidor entenda a requisio
corretamente.
A padronizao tambm est presente na resposta do servidor. Uma resposta bem formada contm:
Verso do protocolo, como na requisio
Cdigo de status indicando sucesso (ou no) ao processar a requisio, acompanhado por
mensagem auxiliar
Cabealhos, com informaes adicionais com o tipo do contedo sendo retornado,
Corpo da resposta, contendo o contedo solicitado

Eis um exemplo de reposta completa:

Estrutura
<Verso HTTP> <Cdigo> <Mensagem>
<Nome do cabealho 1>: <Valor 1>
<Nome do cabealho n>: <Valor n>
Exemplo
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Cache-Control: no-cache
Pragma: no-cache
Expires: Thu, 01 Jan 1970 00:00:00 GMT
Transfer-Encoding: chunked

28
 Date: Sun, 09 Mar 2013 03:43:12 GMT

<Contedo> <html> <body>

<h1>Hello World</h1>
</body> </html>

No exemplo anterior, o cdigo de status 200 indica que a requisio do cliente foi bem-sucedida. Os
cabealhos trazem informaes adicionais sobre o contedo retornado, como instrues para que o
browser no faa cache da resposta. O contedo retornado textual e corresponde a uma pgina
HTML, porm dados binrios tambm podem fazer parte de uma resposta.

A tabela abaixo contempla os cdigos mais comuns e seus significados:

Cdigo da resposta Mensagem Significado
200 OK Requisio processada com sucesso
302 Moved Temporarily Contedo solicitado est em outar URL
404 Page Not Found Contedo solicitado no foi encontrado
500 Internal Server Error Erro inesperado no processamento da requisio
503 Service Unavailable Servio indisponvel no momento

7.2 Common Gateway Interface

O advento do Common Gateway Inteface, mais conhecido por CGI possibilitou o surgimento de
contedo dinmico na Web. Neste modelo, uma aplicao (processo) era executada a cada
requisio HTTP, passando os parmetros para a aplicao via Variveis de Ambiente. A aplicao,
por sua vez, retornava o cdigo HTML que deveria ser mostrado para o browser que iniciou a
requisio.
A utilizao de Servlets trouxe vrias melhorias ao fluxo acima:
Maior desempenho resultante da persistncia do Servlet na memria, que no precisa ser
iniciado a cada nova solicitao. Alm disso, conexes ociosas ao banco de dados so
mantidas abertas para evitar o overhead de iniciar novas conexes (pool de recursos);
Implantao facilitada pelo uso de uma mquina virtual que abstrai os detalhes do hardware
subjacente aumentando o nvel de padronizao e portabilidade;
Distribuio facilitada em ambientes heterogneos em funo do uso de uma mquina
virtual.

7.3 O que so Servlets?

Servlets so classes Java usadas para estender as capacidades dos servidores que hospedam
aplicaes acessadas por meio de um modelo de requisio-resposta (como o HTTP). Embora
Servlets possam ser usadas para responder qualquer tipo de requisio, o uso mais comum para
estender a capacidade de aplicaes hospedadas por servidores Web. Para aplicaes deste tipo, a
tecnologia de Servlets Java oferece classes especficas para uso com HTTP.
Para que um servidor possa executar um Servlet, preciso que ele implemente um Servlet
Container, tambm conhecido como Servidor de Aplicaes Java. Um Servlet Container um

29
servidor que suporta as tecnologias JSP, Servlet, JSTL e JSF mas no o Java EE completo. Um dos
mais conhecido o Apache Tomcat.
No contexto Web, o Servlet reponsvel por receber requisies HTTP feitas ao servidor e, a partir
dos parmetros recebidos, realizar o processamento relevante para finalmente retornar uma resposta
ao cliente solicitante seja uma pgina HTML, uma imagem JPEG, um arquivo JSON, etc.
Os pacotes javax.servlet e javax.servlet.http fornecem as interfaces e classes necessrias para que
possamos iniciar o desenvolvimento de Servlets para Web. Todos os Servlets precisam implementar
a interface Servlet, a qual define os mtodos para gesto do ciclo de vida. A classe HttpServlet
oferece mtodos como doGet() e doPost() para lidar com requisies HTTP.

7.4 Funcionamento da Servlet

Para ilustrar o modo de operao do Servlet, comearemos com um exemplo simples. O servlet
abaixo faz com que todas as requisies HTTP GET direcionadas para a URL <endereo do
host>/<nome do servlet>/ImprimeIp recebam uma pgina HTML exibindo o IP do solicitante.
package org.exemplo;
import java.io.*;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;

@WebServlet("/ImprimeIp")
public class ImprimeIp extends HttpServlet {
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
PrintWriter out = response.getWriter();
out.println("<html> <body>");
out.printf("<h1>Seu IP: %s</h1>", request.getRemoteAddr());
out.println("</body> </html>");
out.flush();
}
}

Quando o HttpServlet recebe a requisio, ele verifica o verbo HTTP utilizado (GET, POST,
PUT, ...) e busca o mtodo doXXX() correspondente. Caso exista, o mtodo chamado com dois
parmetros:
Um objeto da classe HttpServletRequest, que encapsula a requisio recebida; e
Um objeto da classe HttpServletResponse, que encapsula a resposta do servlet.
Para devolver uma resposta ao cliente que iniciou a requisio, precisamos obter a instncia do
PrintWriter associado a resposta. O programa utiliza este PrintWriter para escrever no Stream de
resposta vinculado ao cliente que iniciou a requisio.
A instncia do PrintWriter obtida utilizando o mtodo getWriter() presente no objeto response. A
classe PrintWriter possui mtodos que facilitam a escrita de texto num Stream, alm de realizar a
bufferizao automtica do output. No exemplo, utilizamos os mtodos println() e printf() para
adicionar Strings o Stream do servlet e, ao final, utilizamos o mtodo flush() para forar a escrita
dos dados no Stream de sada.
No exemplo, no estamos tratando a IOException lanada pelo getWriter(). No entanto,
considerada uma boa prtica capturar excees lanadas para a gerao de logs no servidor.
try {
PrintWriter out = response.getWriter();
out.println("<html> <body>");

30
 out.printf("<h1>Seu IP: %s</h1>", request.getRemoteAddr());
out.println("</body> </html>");
out.flush();
} catch (IOException e) {
ServletContext context = getServletContext();
context.log("Erro ao obter writer", e);
}

7.5 Respostas
Servlets realizam trabalho por trs das cortinas durante o processamento de uma requisio. Embora
no esteja visvel no exemplo anterior, o texto que escrevemos no Stream de sada passou por
alguns processamentos at finalmente chegar ao formato final. Antes de chegar ao cliente, a
resposta precisa ser envelopada numa mensagem HTTP vlida. O Servlet se encarrega de
acrescentar os cabealhos HTTP nossa resposta. Eis a resposta retornada pelo Servlet escrito no
exemplo anterior:
HTTP/1.1 200 OK Cabealhos: Populados automaticamente
Server: Apache-Coyote/1.1
Transfer-Encoding: chunked
Date: Sun, 09 Mar 2013 03:01:16 GMT

<html> <body> Corpo: Populado pelo doGet()

<h1>Seu IP: 0:0:0:0:0:0:0:1</h1></body> </html>

Quando aplicaes Web precisam de controle sobre os cabealhos retornados, possvel utilizar o
mtodo setHeader() do objeto de response para definir ou modificar cabealhos HTTP. Um caso
de uso comum acrescentar cabealhos que instruam o browser do cliente a no fazer cache das
respostas. Existem tambm as variaes setDateHeader() e setIntHeader(), usadas para headers com
valores de data e inteiros, respectivamente.
Voltemos ao exemplo Java, agora com setHeader():
response.setHeader("Cache-Control","no-cache"); // HTTP 1.1
response.setHeader("Pragma","no-cache"); // HTTP 1.0
response.setDateHeader ("Expires", 0); // Proxy
response.setDateHeader("Last-Modified", System.currentTimeMillis());
PrintWriter out = response.getWriter();
out.println("<html>");
...
E os cabealhos da nova resposta:
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Cache-Control: no-cache
Pragma: no-cache
Expires: Thu, 01 Jan 1970 00:00:00 GMT
Last-Modified: Sun, 09 Mar 2013 03:43:12 GMT
Transfer-Encoding: chunked
Date: Sun, 09 Mar 2013 03:43:12 GMT
IMPORTANTE: A alterao dos cabealhos deve ser feita ANTES de que qualquer contedo de
sada seja escrito. A ordem dos elementos na resposta crtica para obter o resultado desejado.
Primeiro o status (HTTP/1.1 200 OK), depois os cabealhos e por fim o corpo da mensagem. Violar
31
esta regra far com que seja lanada uma IllegalStateException, consequentemente interrompendo
a gerao de uma resposta ao cliente.

O header Content-Type usado para sinalizar ao cliente o tipo de contedo sendo retornado e til
para auxiliar os browsers a mostrar o contedo de maneira inteligente. Entre os possveis valores
para esse header, temos: text/html para pginas HTML, image/jpeg para imagens no formato JPEG,
application/octet-stream para dados binrios, etc. Devido grande utilizao, foi criado o mtodo
setContentType(), prprio para definir valores ao header Content-Type.
Exemplo:
FileInputStream in = null;
try {
response.setContentType("image/jpeg");
in = new FileInputStream("imagem.jpg");
// Obtem stream de sada binria do Servlet
ServletOutputStream out = response.getOutputStream();
byte[] buffer = new byte[1024];
int bytes = 0;
// Copia contedo binrio para sada
while ((bytes = in.read(buffer)) >= 0) {
// write() pode lanar IOException
out.write(buffer);
}
out.flush();
in.close();
}
catch (IOException io) {
// Tratamento de erro
}
Nota: O trecho acima pode demorar alguns segundos para finalizar a execuo, pois, os dados so
enviados gradualmente para o cliente solicitante medida que o Servlet escreve na
ServletOutputStream. Caso a conexo seja encerrada (ex: browser foi fechado durante a
execuo), o mtodo write() lanar uma IOException.

7.5.1 Exerccios
Crie uma Servlet que retorne uma pgina HTML com uma mensagem de boas-vindas caso o
IP do cliente seja igual ao IP contido em um arquivo.
o No Eclipse, crie um novo Dynamic Web Project

7.5.2 Status HTTP

Como j vimos, toda resposta a uma requisio HTTP comea com o status da resposta. O status
segue o formato <verso do http> <cdigo da resposta> <mensagem auxiliar> e responsvel
por indicar se a requisio foi bem-sucedida (ou no).
Podemos controlar o status das respostas geradas por nossa aplicao assim como fazemos com os
cabealhos basta utilizarmos o mtodo setStatus() do HttpServletResponse. A fim de melhorar a
legibilidade do cdigo, a classe HttpServletResponse define constantes para cada um dos cdigos de
status. Caso o setStatus() no seja utilizado, considera-se que houve sucesso no processamento e o
cdigo 200 retornado.
Cdigo Constante
200 SC_OK
302 SC_MOVED_TEMPORARILY

32
 404 SC_NOT_FOUND
500 SC_INTERNAL_SERVER_ERROR
503 SC_SERVICE_UNAVAILABLE

7.5.3 Exerccios
Utilizando o exerccio do item 7.5.1 como base, altere o status da resposta para 404 quando
o arquivo no for encontrado

7.6 Requisies
7.6.1 Parmetros da requisio
Para um Web efetivamente dinmica, o cliente precisa de meios de enviar dados para que o servidor
consiga produzir contedos variados. Formulrios HTML so uma das opes, uma vez que
possvel utiliz-los para enviar dados ao servidor por meio do mtodo HTTP Post. Os dados a
serem enviados so incorporados como parmetros ao corpo da requisio, podendo ser recuperados
posteriormente no servidor.
Outra forma de enviar parmetros ao servidor atravs da concatenao dos mesmos URL de uma
requisio GET. Para isso, precisamos acrescentar o caractere interrogao ( ? ) ao final da URL
e, em seguida, acrescentar os parmetros no formato <nome parmetro>=<valor parmetro>
separados entre si por um caractere & . Exemplo:
<URL base>/ExemploServlet/?nome=fanta&idade=26
A API de Servlets disponibiliza diversos mtodos para capturar os parmetros de uma requisio:
String HttpServletRequest.getParameter(String paramName) Retorna o parmetro
especificado em paramName, ou null caso o parmetro no exista
Enumeration HttpServletRequest.getParameterNames() Retorna um enumerador com
os nomes de todos os parmetros
String HttpServletRequest.getQueryString() Retorna a parte da URL de requisio que
vem aps o caractere interrogao ( ? ). Ex: nome=fanta&idade=26

7.6.2 Exerccios
Crie uma Servlet que receba os parmetros altura e peso de uma requisio GET. Responda
com uma pgina contendo o clculo do ndice de Massa Corporal (IMC). Caso algum dos
parmetros no esteja presente, responda com o cdigo de status 500 (ver item 7.5.2)
o Clculo do IMC: peso / (altura * altura)
Crie uma pgina HTML com um formulrio de login e senha que envie uma requisio
POST para uma Servlet. A Servlet retornar uma pgina de boas vindas em caso de sucesso.
Caso contrrio, responda com o cdigo de status 401 (Forbidden).

7.6.3 Cabealhos de Requisio

Vimos que uma mensagem de resposta HTTP composta pelo status, cabealhos e corpo.
Requisies possuem uma estrutura similar, como podemos ver no exemplo abaixo:
Estrutura Exemplo
<Verbo> <URL> <Verso HTTP> GET /ExemploServlet/ImprimeIp HTTP/1.1

33
<Nome do cabealho 1>: <Valor 1> User-Agent: curl/7.30.0
<Nome do cabealho 2>: <Valor 2> Host: localhost:8080
<Nome do cabealho n>: <Valor n> Accept: */*
A classe HttpServletRequest fornece mtodos para obter mais informaes sobre a requisio:
String HttpServletRequest.getHeader(String name) Retorna o valor cabealho
especificado em name, ou null caso o cabealho no exista
long HttpServletRequest.getDateHeader(String name) Retorna o valor do cabealho
como um long que representa uma data. O valor retornado equivale ao nmero de
milissegundos desde 1o de Janeiro de 1970 ou -1, caso no o cabealho no exista. Se o
valor do cabealho no for uma data, uma IllegalArgumentException lanada
int HttpServletRequest.getIntHeader(String name) Retorna o valor do cabealho como
um int. Caso o cabealho no exista, retorna 01. Se o valor do cabealho no puder ser
convertido para um int, uma NumberFormatException lanada
Enumeration HttpServletRequest.getHeaderNames() Retorna um enumerador com os
nomes de todos os cabealhos presentes na requisio
Um cabealho bastante utilizado o User-Agent, pois nele esto contidas informaes sobre o
cliente que iniciou a requisio (software e verso). Estas informaes so teis para que o Servlet
possa gerar uma verso de contedo especialmente adaptada para o cliente, como um site que
oferece uma verso para smartphones e outra para desktops.

34
8. COOKIES
Por ser um protocolo stateless, o HTTP no mantm informaes sobre requisies passadas e,
portanto, incapaz de agrupar requisies de um mesmo cliente. Isso representa um problema para
aplicaes que dependam de aes executadas anteriormente para poder operar, como o caso de
sistemas que possuem algum tipo de autenticao (e-commerce, webmail, etc).
Uma das possibilidades o uso de Cookies para realizar a persistncia de informaes (estado)
associadas a um cliente.

8.1 Definio
Cookies so pacotes de dados gerados pelo servidor e enviados ao cliente juntamente com a
resposta da requisio. Esses dados so armazenados pelo browser do usurio, que se encarrega de
envi-los a cada requisio efetuada aps o recebimento do cookie. Com isso, o servidor capaz de
fazer a distino entre clientes e recuperar outras informaes necessrias para a gerao de uma
resposta.

8.2 Estrutura
Alm do nome, valor e caminho, cookies possuem os seguintes campos:
Comment: Comentrio descrevendo o propsito do cookie
MaxAge: Intervalo de tempo (em segundos) no qual o cookie considerado vlido
Domain: Define todos os servidores abaixo de um mesmo domnio
Path: Define os recursos abaixo do diretrio virtual do recurso

8.3 Adicionando Cookies

Para a manipulao de cookies, a API de Servlets disponibiliza a classe javax.servlet.http.Cookie
que encapsula dados e operaes de um cookie. Os campos de um cookie podem ser recuperados /
alterados utilizando os vrios getters e setters disponveis na classe.
O primeiro passo para utilizar um cookie cri-lo passando ao construtor o nome e o valor do
mesmo. O prximo passo definir os campos (Comment, MaxAge, ...) relevantes ao objeto criado.
Por fim, o cookie precisa ser adicionado ao objeto HttpServletResponse para que seja enviado ao
browser do cliente, como mostra o exemplo:
Cookie cookie = new Cookie("Nome", "Valor");
cookie.setMaxAge(120);
cookie.setComment("Comentario sem acento");
response.addCookie(cookie);
Importante: NO utilize caracteres acentuados tanto em cookies quanto em cabealhos.
O trecho acima cria um cookie com nome Nome e valor Valor. Ele ser vlido por 120
segundos a partir do instante em que for recebido e ser excludo pelo browser aps expirar. A
resposta acrescida do cabealho abaixo:
Set-Cookie: Nome=Valor; Version=1; Comment="Comentario sem acento"; Max-Age=120;
Expires=Sun, 09-Mar-2013 18:30:04 GMT

Caso o valor fornecido para MaxAge seja negativo, o cookie ser mantido at que o browser seja
encerrado. Se o valor for 0, o browser remover o cookie imediatamente.

35
Assim como ocorre com todo cabealho, a adio de cookies na resposta do Servlet deve ocorrer
antes que o contedo da resposta comece a ser escrito no Stream de sada.

8.4 Recuperando Cookies

Cookies podem ser extrados das requisies utilizando o mtodo getCookies() da classe
HttpServletRequest. O mtodo retorna um array de objetos da classe Cookie, ou null caso no
haja nenhum. No existe um mtodo que recupere um cookie especfico a partir do nome, ficando
para o desenvolvedor interar pelo array retornado em busca do cookie desejado.

8.5 Exerccios
Utilizando como base o Servlet de login do item 7.6.2, utilize um cookie para persistir as
informaes de login, evitando que o usurio precise digitar suas credenciais novamente

36
9. SESSES
Alm de cookies, podemos utilizar Sesses, ou Sessions, para persistir informaes de estado entre
requisies de um mesmo cliente. A API de Servlets possui um mdulo de Gerenciamento de
sesses de usurio onde podemos encontrar a classe HttpSession que possui mtodos para
manipulao de sesses.

9.1 Funcionamento
criado, no primeiro acesso, um identificador de sesso, ao qual associado um objeto da classe
javax.servlet.http.HttpSession na memria do container. O container, por sua vez, encarrega-se de
carregar este identificador para todas as requisies oriundas daquele usurio. Para isso, utiliza-se 1)
Cookies ou 2) URLs reescritas (informaes adicionadas ao caminho) caso a opo (1) esteja
disponvel (usurio desabilitou os cookies, por exemplo). Com o identificador em mos, a API
disponibiliza o objeto HttpSession automaticamente para o Servlet.
O Servlet usa o objeto HttpSession em memria para armazenar informaes associadas a um
usurio especfico que acessa a aplicao. Essas informaes estaro disponveis em todas as
requisies posteriores a todos os Servlets que compartilham o mesmo contexto. Para obter uma
referncia ao objeto da classe HttpSession, um Servlet deve utilizar o mtodo getSession() da classe
HttpServletRequest. Olhando a documentao, possvel verificar que existem duas sobrecargas:
HttpSession getSession(boolean create) Retorna a HttpSession associada a requisio ou,
se no houver uma sesso e create for true, retorna uma nova sesso, caso contrrio, retorna
null
HttpSession getSession() Equivale a getSession(true)
O trecho a seguir obtm o objeto de sesso, se houver, ou cria um novo, caso ainda no exista:
HttpSession session = request.getSession();
if (session.isNew()) { // Acabou de ser criada
getServletContext().log("ID: " + session.getId());
// Inicializa session
}
else {
// Recupera dados da session
}

O mtodo isNew() utilizado para determinar se o identificador de sesso j foi enviado para o
browser cliente. Caso seja uma sesso recm-criada, ns efetuamos a inicializao da mesma com
dados que gostaramos de recuperar em requisies futuras (usurio, senha, etc). Alm deste mtodo,
a classe HttpSession oferece vrios outros mtodos. Entre eles esto:
void setAttribute(String attributeName, Object attributeValue)
Object getAttribute(String attributeName)
void removeAttribute(String attributeName)
Enumeration getAttributeNames()

Estes mtodos permitem que o desenvolvedor controle os objetos vinculados sesso do usurio de
maneira similar ao funcionamento de um HashMap:
sessao.setAttribute("Contador", new Integer(contador));
...
Integer contador = (Integer) sessao.getAttribute("Contador");

37
9.2 Exerccios
Substitua o uso de cookies por sesses no exerccio do item 8.5

9.3 Validade da Sesso

possvel definir um tempo mximo de inatividade que, se ultrapassado, faz com que a sesso
expire um recurso bastante utilizado pelos sites de Internet Banking para aumentar a segurana do
usurio. Para que a sesso expire, basta que o cliente no execute nenhuma requisio durante o
tempo limite. Quando isso ocorre, o usurio precisa de uma nova sesso vlida, geralmente obtida
por meio de um novo login.
O desenvolvedor tambm pode revogar a validade de uma sesso manualmente. este o caso em
lugares onde o usurio efetua logout. Para controlar a validade da sesso, utilizamos os seguintes
mtodos da classe HttpSession:
int getMaxInactiveInterval() obtm o intervalo mximo de inatividade em segundos
void setMaxInactiveInterval(int interval) atribui o intervalo mximo de inatividade
invalidate() invalida sesso manualmente

9.4 Exerccios
Personalize a pgina de boas-vindas do exerccio no item 9.2 mostrando o nome do usurio
autenticado e acrescente um boto de logout

38
10. CICLO DE VIDA DA SERVLET
O ciclo de vida de um Servlet composto de 3 fases: inicializao, atendimento de requisies e
finalizao.

10.1 Inicializao
Processo onde o Servlet carregado pelo Servlet Container. O instante em que a inicializao
ocorre depende do campo loadOnStartup na annotation @WebServlet: caso o valor seja um
inteiro positivo, o Servlet inicializado automaticamente pelo Container quando a aplicao
iniciada, comeando pelos menores valores. Caso contrrio, a inicializao ocorre quando
recebida a primeira requisio a ser mapeada para o Servlet. Exemplo de annotation:
@WebServlet(urlPatterns = "/MeuServlet", loadOnStartup = 1)

Na inicializao, o Servlet Container executa o mtodo init() do Servlet, dando chance ao Servlet
de executar quaisquer passos necessrios para sua inicializao, tais como:
Leitura de parmetros de configurao
Inicializao de variveis de classe (variveis estticas)
Inicializao de conexes ao banco de dados, etc
Ao sobrescrever o init() em seu Servlet, utilize o mtodo getServletConfig() para obter uma
instncia da classe ServletConfig, a qual guarda os parmetros de inicializao do Servlet. Em
seguida, invoque o mtodo getInitParameter() do ServletConfig para obter o parmetro desejado.
public void init() throws ServletException {
super.init();
ServletConfig config = getServletConfig();
String smtp = config.getInitParameter("Email.SMTP");
if (smtp != null) {
// Logica de inicializao
}
}

Tambm possvel obter um enumerador contendo o nome de todos os parmetros do Servlet

Config por meio de uma chamada ao mtodo getInitParameterNames().
O Servlet somente poder receber requisies aps a concluso de seu processo de inicializao.
Para indicar que houve um problema durante a inicializao, o desenvolvedor deve lanar uma
exception da classe ServletException ou UnavailableExcetion. Nestes casos, o Servlet Container
deixar o Servlet em estado inativo, incapaz de receber requisies.
Observando o construtor da UnavailableException, pode-se notar que uma das sobrecargas possui
um parmetro do tipo int. Este parmetro recebe a estimativa, em segundos, de quanto tempo o
Servlet dever ficar inativo.

10.2 Atendendo as Requisies

Aps o trmino bem-sucedido do mtodo init(), o Servlet marcado como ativo pelo Servlet
Container e est pronto para receber requisies. Na classe GenericServlet, utilizada para Servlets
genricos e superclasse da HttpServet, o mtodo service() centraliza o processamento de
requisies.

A cada nova requisio recebida, o Servlet Container faz uma chamada ao mtodo service()

39
passando como parmetros um objeto que encapsula a requisio feita pelo cliente e outro objeto
que encapsula a resposta que dever ser encaminhada ao cliente. Felizmente, como vimos no item
7.4, a classe HttpServlet j cuida de encaminhar a requisio para o mtodo relevante: doGet(),
doPost(), etc.

10.3 Finalizao
O Servlet finalizado quando o servidor finalizado ou quando a aplicao se torna inativa pelo
Servlet Container. A imagem abaixo traz uma ilustrao do ciclo de vida nos vrios estgios de uma
aplicao.

A finalizao de um Servlet deve ser tratada atravs da implementao do mtodo destroy(). No

instante em que o Servlet inicia a sua finalizao, o mtodo destroy() chamado, permitindo a
execuo de rotinas de finalizao como: Encerramento de conexes com bancos de dados,
Finalizao de threads que tenham sido lanados, etc. Exemplo:
public void destroy() {
super.destroy();
// Logica de finalizao
}

10.4 Servlet Context

O objeto ServletContext contm os atributos e informaes sobre o contexto em que o Servlet est
sendo executado e contm mtodos teis para Servlets que desejam se comunicar com o Servlet
Container para, por exemplo, escrever num arquivo de log.
Existe um ServletContext por aplicao web por JVM e, portanto, todos os Servlets de uma mesma
aplicao compartilham o mesmo ServletContext. O contexto retornado a partir da chamada do
mtodo getServletContext() presente nas Servlets.

40
A classe define mtodos para recuperar os parmetros iniciais do contexto definidos no Deployment
Descriptor: getInitParameterNames() e getInitParameter(). importante notar que existem
diferenas entre os parmetros iniciais do contexto e os parmetros iniciais do Servlet.
O objeto ServletContext tambm possui mtodos que podem ser usados para atribuir e recuperar
atributos compartilhados por todos os Servlets do contexto:
Object getAttribute(String name)
Enumeration getAttributeNames()
void removeAttribute(String name)
void setAttribute(String name, Object value)
O funcionamento destes mtodos anlogo aos mtodos estudados no item 9.1.
Um recurso bastante utilizado do ServletContext e presente em vrios exemplos nesta apostila o
mtodo log(). Ele permite que voc adicione mensagens em um arquivo de log do Servidor de
Aplicaes. Voc poder utilizar esse mtodo para depurar seus Servlets, gerar alertas de problemas
na sua execuo etc.
No Tomcat, as mensagens geradas por meio do mtodo log() so adicionadas a um arquivo de log
chamado localhost.<aaaa-mm-ddd>.log , onde o bloco < > substitudo pela data da gerao do
log.

10.5 Exerccios
Implemente os mtodos init() e destroy() da Servlet do exerccio no item 9.4:
o O init() dever ler o arquivo que contm os dados do usurio e senha e inseri-los
num array de usurios para evitar operaes de leitura de arquivo em toda requisio.
Alm disso, tambm dever abrir um arquivo para escrita e armazenar a instncia
num campo do Servlet.
o O destroy() dever fechar o arquivo que foi aberto para escrita durante o init()

41
11. VISO GERAL SOBRE JSP
A tecnologia Java Server Pages, tambm conhecida com JSP, facilita a criao de contedo web
que contenha partes estticas e dinmicas. O JSP disponibiliza todas as capacidades dinmicas da
tecnologia de Servlets, mas possui uma abordagem mais natural para a criao de contedo esttico.
A principal motivao para o uso da tecnologia JSP evitar a formatao de sadas de texto em
Servlets, concentrando no Servlet a lgica de controle e mantendo a responsabilidade sobre
formatao de contedo em outro arquivo. Alm de facilitar a manuteno, conseguimos paralelizar
o desenvolvimento em duas frentes.

11.1 O que uma pgina JSP?

Uma pgina JSP um documento texto que mescla dois tipos de texto: dados estticos, que podem
ser expressos em qualquer formato baseado em texto (como HTML, SVG, XML, etc) e elementos
JSP, utilizados para a gerao de contedo dinmico. As pginas JSP podem ser reconhecidas pela
sua extenso .jsp e podem ser encontradas na pasta WebContent do projeto Java Web.
Os elementos dinmicos que disponibilizados pelo JSP so:
Elementos Sintaxe
Comentrios <%--.. --%>
Declaraes <%! ..%>
Diretivas <%@ include .. %>
<%@ page .. %>
<%@ taglib .. %>
Expresses <%= ..%>
Scriptlets <% ..%>

11.2 Diretivas
Diretivas so elementos que encaminham mensagens para o Container JSP e afetam a compilao
da pgina JSP. As diretivas no aparecem no XML de sada.
Formato Exemplo
<%@ diretiva <%@ page
nomeAtributo1 = valorAtributo1 language = "java"
nomeAtributo2 = valorAtributo2 contentType = "text/html"
... %> pageEncoding = "ISO-8859-1" %>
Nota: Cada diretiva possui seu prprio conjunto de atributos especficos.

Existem trs diretivas: page, include e taglib (no contemplada nesta apostila)
page Define propriedades relacionadas ao formato e linguagem da pgina atual. Este
elemento precisa ser filho direto do n raiz. Alguns dos atributos so: language,
contentType, pageEncoding, import, errorPage e isErrorPage
include Utilizando para inserir o contedo de outro arquivo (seja texto esttico ou outra
pgina JSP) no documento atual. Este elemento pode ser colocado em qualquer lugar do
documento e seu possui apenas o atributo file, que deve conter o caminho para o arquivo a
ser includo. O funcionamento similar ao da diretiva <include> do C / C++

42
11.2.1 Diretiva page
O atributo info usado para armazenar texto informativo sobre a pgina e podemos obter o
contedo utilizando o mtodo getServletInfo() do Servlet. Exemplo:
<%@ page info="Autor: Fanta" %>

O atributo contentType informa o tipo de contedo gerado pelo documento JSP. O propsito
permitir que o browser consiga interpretar a pgina corretamente. Exemplo:
<%@ page contentType="text/html" %>

O atributo pageEncoding informa a codificao do texto utilizado na pgina. Sem esse atributo, o
contedo pode ser exibido incorretamente no browser.
<%@ page pageEncoding="ISO-8859-1" %>

O atributo import funciona de maneira anloga ao import do Java. Todos os pacotes utilizados no
documento JSP devem ser declarados utilizando este atributo. Exemplo:
<%@ page import="java.util.*" %>

O atributo errorPage usado para indicar a pgina JSP que dever ser exibida caso ocorra algum
erro durante o processamento da pgina que contm este elemento. Para habilitar esse
comportamento, a pgina que far o tratamento de erros dever declarar a diretiva page com o
atributo isErrorPage = true.

11.2.2 Diretiva include

A diretiva include nos permite compartilhar o contedo comum a vrias pginas JSP, seja ele
dinmico ou esttico, facilitando a manuteno das mesmas. Pode-se, por exemplo, construir novas
pginas JSP que incluem os arquivos cabecalho.jsp e rodape.html. Caso seja necessrio mudar o
cabealho ou rodap, no precisaremos alterar todas as pginas, apenas estas duas. Exemplo:
<%@ include file=cabecalho.jsp %>
<!-- Contedo -->
<%@ include file=rodape.html %>

11.3 Expresses
Expresses utilizam a sintaxe <%= ..%> para imprimir o resultado de um comando Java durante a
gerao do contedo. Um trecho de cdigo que imprime o IP do cliente que iniciou a requisio
seria:
<p>O seu endereo IP "<%= request.getRemoteAddr()%>"<p>
Importante: O resultado da expresso deve ser do tipo String. Algumas alternativas so utilizar o
mtodo toString() do objeto ou o mtodo esttico String.format()

11.4 Exerccios
Utilize elementos dinmicos para melhorar o exerccio no item 10.5:

43
 o Crie uma pgina JSP de cabealho que imprima o nome do usurio autenticado
o Crie uma pgina JSP de rodap que imprima a data atual (dd/mm/aaaa)
o Transfira a gerao de HTML para uma pgina JSP
Dica: Na Servlet de autenticao, utilize o mtodo sendRedirect() para
enviar o usurio para a pgina .JSP de boas-vindas

11.5 Scriptlets
Scriptlets permitem a insero de um bloco de cdigo Java diretamente no corpo da pgina JSP e
possuem o seguinte formato:
Formato Exemplo
<!-- HTML --> <p><%
<% /* Bloco Java */ %> String arg = request.getParameter("r");
<!-- HTML --> if (arg != null && arg.equals("42")) {
out.println("Found!");
}
else {
out.println("Nothing here");
}
out.flush();
%></p>

11.6 Objetos Implcitos

Para facilitar o trabalho do desenvolvedor, alguns objetos so disponibilizados pelo JSP Container
sem que seja necessria a sua declarao (como o objeto request do exemplo anterior). Os mais
comuns so:
Objeto Classe Funo
request HttpServletRequest Encapsula a request enviada pgina
response HttpServletResponse Encapsula a response que ser devolvida ao cliente
out JspWriter Utilizada para escrever na Stream de sada
session HttpSession Encapsula a sesso associada request
config ServletConfig ServletConfig associado pgina
application ServletContext Contexto da Servlet

11.7 Declaraes
O elemento de declarao usado para definir variveis e mtodos que devero ser acrescentados
definio do Servlet JSP. Membros declarados num elemento de declarao ficam disponveis para
uso nas Scriptlets e Expresses, assim como os objetos implcitos.
Formato Exemplo
<%! /* Declarao */ %> <%!
public void erro(String msg) {
getServletContext().log("ERRO: " + msg);
}
%>
...
<%

44
 if (request.getParameter("url") == null) {
erro("Parmetro 'url' no encontrado");
}
%>

As declaraes tambm podem ser usadas para a declarao dos mtodos public void jspInit() e
public void jspDestroy(), usados para inicializar a pgina JSP (ler dados de configurao, por
exemplo) e liberar recursos, respectivamente.

45