PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS

Prévia do material em texto

PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 1 
Apresentação ................................................................................................................................ 6 
Aula 1: Programação Orientada a Objetos.................................................................................... 8 
Introdução ............................................................................................................................. 8 
Conteúdo ................................................................................................................................ 9 
Conceitos básicos de programação orientada a objetos .......................................... 9 
Pilares da programação orientada a objetos ................................................................ 9 
Classe ................................................................................................................................. 10 
Objeto ................................................................................................................................ 12 
Encapsulamento .............................................................................................................. 13 
Construtores ..................................................................................................................... 13 
Sobrecarga de métodos ................................................................................................. 15 
Final .................................................................................................................................... 17 
Static ................................................................................................................................... 17 
Herança ............................................................................................................................. 19 
Classe abstrata .................................................................................................................. 22 
Interface ............................................................................................................................. 24 
Polimorfismo .................................................................................................................... 25 
Referências........................................................................................................................... 27 
Exercícios de fixação ......................................................................................................... 27 
Chaves de resposta ..................................................................................................................... 33 
Aula 1 ..................................................................................................................................... 33 
Exercícios de fixação ....................................................................................................... 33 
Aula 2: Servlet e JSP .................................................................................................................... 38 
Introdução ........................................................................................................................... 38 
Conteúdo .............................................................................................................................. 39 
Servlet ................................................................................................................................ 39 
Principais vantagens da tecnologia Servlet ................................................................ 39 
Principais classes e interfaces da API Servlet ............................................................. 40 
Ciclo de vida Servlet ........................................................................................................ 42 
HTTP Servlet ..................................................................................................................... 43 
Principais classes e interfaces da API HttpServlet ..................................................... 45 
Principais métodos da HttpServletRequest e da HttpServletResponse ................. 46 
Mapeamento Servlet ....................................................................................................... 47 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 2 
Estrutura de uma aplicação web .................................................................................. 47 
JavaServer Pages (JSP) ................................................................................................... 48 
Arquitetura JSP ................................................................................................................. 48 
Sintaxe JSP ........................................................................................................................ 49 
Expression Language (EL) .............................................................................................. 51 
Referências........................................................................................................................... 53 
Exercícios de fixação ......................................................................................................... 53 
Chaves de resposta ..................................................................................................................... 59 
Aula 2 ..................................................................................................................................... 59 
Exercícios de fixação ....................................................................................................... 59 
Aula 3: Gerenciamento de Sessão do Usuário ............................................................................ 65 
Introdução ........................................................................................................................... 65 
Conteúdo .............................................................................................................................. 66 
Gerenciamento de sessão .............................................................................................. 66 
Técnicas utilizadas na sessão ........................................................................................ 66 
JDBC ................................................................................................................................... 71 
Principais classes, interfaces envolvidas e persistência de dados na prática ....... 73 
Referências........................................................................................................................... 79 
Exercícios de fixação ......................................................................................................... 79 
Chaves de resposta ..................................................................................................................... 85 
Aula 3 ..................................................................................................................................... 85 
Exercícios de fixação ....................................................................................................... 85 
Aula 4: Generics e Collections ..................................................................................................... 89 
Introdução ........................................................................................................................... 89 
Conteúdo .............................................................................................................................. 90 
Generics ............................................................................................................................. 90 
Nomenclatura de tipos de parâmetros .......................................................................90 
Classes e interfaces genéricas ....................................................................................... 91 
Métodos e construtores genéricos ............................................................................... 92 
Genéricos e herança ....................................................................................................... 93 
Coleções e mapas............................................................................................................ 96 
Vetores ............................................................................................................................... 96 
Uso de vetores .................................................................................................................. 97 
Principais interfaces ........................................................................................................ 98 
Interface List ..................................................................................................................... 99 
Interface Set .................................................................................................................... 103 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 3 
Interface Map .................................................................................................................. 105 
Referências......................................................................................................................... 109 
Exercícios de fixação ....................................................................................................... 109 
Chaves de resposta ................................................................................................................... 115 
Aula 4 ................................................................................................................................... 115 
Exercícios de fixação ..................................................................................................... 115 
Aula 5: Filtros e Tags Personalizadas ......................................................................................... 119 
Introdução ......................................................................................................................... 119 
Conteúdo ............................................................................................................................ 120 
Filtros ................................................................................................................................ 120 
Diferentes funções dos filtros ...................................................................................... 120 
Principais interfaces ...................................................................................................... 121 
Principais métodos ........................................................................................................ 121 
Aplicação de filtros para um Servlet .......................................................................... 122 
Tags personalizadas ...................................................................................................... 125 
Referências......................................................................................................................... 136 
Exercícios de fixação ....................................................................................................... 136 
Chaves de resposta ................................................................................................................... 144 
Aula 5 ................................................................................................................................... 144 
Exercícios de fixação ..................................................................................................... 144 
Aula 6: Introdução a Padrões Arquiteturais e GOF ................................................................... 148 
Introdução ......................................................................................................................... 148 
Conteúdo ............................................................................................................................ 149 
Padrões GoF de criação e de estrutura ..................................................................... 149 
Abstract Factory ............................................................................................................. 149 
SamsungE1270.java: ...................................................................................................... 152 
Builder .............................................................................................................................. 154 
Factory Method .............................................................................................................. 161 
Prototype ......................................................................................................................... 164 
Singleton .......................................................................................................................... 167 
Padrões estruturais ........................................................................................................ 169 
Adapter ............................................................................................................................ 169 
Bridge ............................................................................................................................... 172 
Composite ....................................................................................................................... 176 
Decorate .......................................................................................................................... 179 
Facade .............................................................................................................................. 182 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 4 
Flyweight ......................................................................................................................... 185 
Proxy................................................................................................................................. 189 
Padrões GoF de comportamento e Front Controller .............................................. 191 
Chain of Responsability ................................................................................................ 192 
Command ....................................................................................................................... 196 
Interpreter ....................................................................................................................... 200 
Interator ........................................................................................................................... 205 
Mediator........................................................................................................................... 207 
Memento ......................................................................................................................... 210 
Observer .......................................................................................................................... 213 
State .................................................................................................................................. 217 
Strategy ............................................................................................................................ 220 
Visitor ............................................................................................................................... 225 
Front Controller (outros padrões) ............................................................................... 230 
Referências.........................................................................................................................233 
Exercícios de fixação ....................................................................................................... 233 
Chaves de resposta ................................................................................................................... 240 
Aula 6 ................................................................................................................................... 240 
Exercícios de fixação ..................................................................................................... 240 
Aula 7: Annotation e JPA ........................................................................................................... 243 
Introdução ......................................................................................................................... 243 
Conteúdo ............................................................................................................................ 244 
Annotation Java ............................................................................................................. 244 
Categorias de annotations ........................................................................................... 245 
Tipos de annotations .................................................................................................... 245 
Criando annotations personalizadas ......................................................................... 248 
Java Persistence API (JPA) ........................................................................................... 250 
Arquitetura do Java Persistence API (JPA) ............................................................... 251 
Referências......................................................................................................................... 261 
Exercícios de fixação ....................................................................................................... 262 
Chaves de resposta ................................................................................................................... 266 
Aula 7 ................................................................................................................................... 266 
Exercícios de fixação ..................................................................................................... 266 
Aula 8: Introdução a JEE ............................................................................................................ 270 
Introdução ......................................................................................................................... 270 
Conteúdo ............................................................................................................................ 271 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 5 
Conceito de EJB ............................................................................................................. 271 
Arquitetura multicamadas e EJB ................................................................................ 272 
Tipos EJB ......................................................................................................................... 273 
Session beans ................................................................................................................. 274 
Entity beans .................................................................................................................... 275 
Message-driven beans .................................................................................................. 276 
Java message service (JMS) ......................................................................................... 276 
Referências......................................................................................................................... 279 
Exercícios de fixação ....................................................................................................... 280 
Chaves de resposta ................................................................................................................... 285 
Aula 8 ................................................................................................................................... 285 
Exercícios de fixação ..................................................................................................... 285 
Conteudista ............................................................................................................................... 290 
 
 
 
 
 
 
 
 
 
 
 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 6 
Os atuais sistemas de informação, particularmente aqueles voltados para áreas 
cadastrais, são implementados em plataformas voltadas para a Internet, 
obtendo independência de ambiente e centralização de manutenção. 
 
Para tal implementação dois tipos de tecnologias abrangem a grande maioria 
do mercado: CGI e Server Pages. 
 
Em ambos os casos, tratam respostas a requisições HTTP, com respostas em 
XML ou HTML. 
 
Com o aumento de complexidade, sistemas de maior porte passam a utilizar 
arquiteturas de objetos distribuídos e pools de conexões com bancos de dados. 
A linguagem Java demonstra-se uma boa ferramenta para estas 
implementações, oferecendo tecnologias já consolidadas, tais como JSP, 
Servlet, JEE e JPA. 
 
Sendo assim, essa disciplina tem como objetivos: 
1. Programação Orientada a objetos em Java. 
2. Servlet e JSP. 
3. Gerenciamento de sessão. 
4. JDBC. 
5. Generics. 
6. Collections. 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 7 
7. Padrões de Projeto GOF. 
8. Padrões FrontController, Command, MVCII. 
9. TagLibs, TagFiles e Filtros. 
10. Annotation. 
11. JPA. 
12. JEE. 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 8 
Introdução 
A programação orientada a objetos (POO) tem sido empregada em larga escala 
no desenvolvimento de aplicações, no cenário mundial. Podemos observar o 
crescente número de aplicações que empregam esse paradigma de 
programação. 
 
Esta aula visa apresentar ao aluno ao paradigma de programação orientada a 
objetos, empregando a linguagem Java, tornando-o apto a se aprofundar em 
qualquer linguagem que utilize esse tipo de programação. 
 
Objetivo: 
1. Compreender os conceitos básicos de programação orientada a objetos; 
2. Explorar peculiaridades do paradigma de orientação a objetos. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 9 
Conteúdo 
Conceitos básicos de programação orientada a objetos 
Ao contrário do que se pensa a programação orientada a objetos não é tão 
recente. O conceito de classe se dá com a criação da linguagem de 
programação Simula 67, que foi a primeira linguagem orientada a objetos. 
Esta foi projetada para apoiar a Simulação de Eventos Discretos. Hoje, 
existe uma infinidades de linguagens que possuem suporte nativo a esse 
paradigma de desenvolvimento, entre elas Linguagem C++, C#, Java. 
 
Diferente da programação imperativa, onde toda a implementação se flexiona à 
lógica de programação, a Programação Orientada a Objetos (POO) tem por 
objetivo simular a realidade. O mundo real em si funciona orientado a objetos. 
Uma das maiores dificuldades que iniciantes encontram no estudo de 
algoritmos é justamente implementar a lógica como espinha dorsal no 
desenvolvimento, em contrapartida à realidade orientada a objetos de nosso 
cotidiano. 
 
Vivemos a era do conhecimento. Com isso, o mundo contemporâneo sofre 
mudanças intensas e volumosas, em especial, na organização das empresas. A 
programação orientada a objetos oferece uma forma de organizar os 
programas, permitindo que soluções mais eficientes sejam implementadas. 
 
Assim como no mundo real, uma aplicação orientada a objetos é composta por 
objetos que são agentes e que interagem entre si através do envio de 
mensagens. 
 
Pilares da programaçãoorientada a objetos 
Para o desenvolvimento no paradigma orientado a objetos, alguns conceitos 
são de extrema relevância, entre eles temos: 
 
 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 10 
Abstração 
Segundo o dicionário Aurélio, abstração é o ato de considerar componentes de 
um todo de maneira isolada. 
 
Nossos objetos, em geral, são abstrações do mundo real. Nele elencamos as 
propriedades (características) e habilidades (funcionalidades) que nosso objeto 
deve possuir. 
 
Encapsulamento 
Embora bastante simples esse conceito permite ocultar partes de nossos 
objetos a outros. A grande vantagem é permitir modificação sem que os 
usuários do objeto sejam afetados. 
 
Herança 
Considerado um dos principais conceitos da orientação a objetos, a herança é 
implementada através de uma hierarquia de classes. As subclasses herdam as 
características e funcionalidades de sua superclasse, permitindo a reusabilidade 
de códigos, bem como a redefinição destes. 
 
Polimorfismo 
Vem do grego, significando "muitas formas" (poli = muitas, morphos = 
formas). Esse conceito permite que através da referência a um objeto do tipo 
superclasse possamos invocar métodos com comportamentos distintos, mas 
com a mesma assinatura de suas subclasses. 
 
Classe 
Java é uma linguagem totalmente orientada a objetos. Para tanto, oferece 
suporte nativo à implementação desse paradigma. 
 
O primeiro conceito que precisamos saber é o de classe, que consiste em um 
modelo que define como serão os objetos que pertencem a essa classe. 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 11 
Podemos compará-lo a um projeto que todos os objetos devem tomar por 
referência para serem considerados pertencentes à classe. 
 
É formada por atributos e/ou métodos. Os atributos são responsáveis por 
manter o estado dos objetos; já os métodos correspondem às funcionalidades 
desse objeto. Equivalem respectivamente a variáveis e funções internas das 
classes. 
 
Veja o exemplo: 
 
Esta classe chamada Aluno define o que os futuros objetos têm em comum em 
sua estrutura, os atributos (variáveis): matrícula, nome, teste, prova, e que 
serão capazes de obter e configurar valores desses atributos, bem como 
calcular a média através de métodos (funções). 
 
public class Aluno { 
 private String matricula, nome; 
 private double teste, prova; 
 public double getMedia(){ return (teste + prova)/2; } 
 public String getMatricula() { return matricula; } 
 public void setMatricula(String matricula) 
 {this.matricula = matricula;} 
 public String getNome() { return nome; } 
 public void setNome(String nome) { this.nome = nome; } 
 public double getTeste() { return teste; } 
 public void setTeste(double teste) { this.teste = teste; } 
 public double getProva() { return prova; } 
 public void setProva(double prova) { this.prova = prova; } 
} 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 12 
Objeto 
Um segundo conceito essencial é o de objeto. Assim como podemos entender 
que classe nada mais é que uma representação de uma entidade do mundo 
real, objeto seria a ocorrência do mesmo. Consiste em uma instância de uma 
classe. 
 
Veja o exemplo: 
 
public class Principal { 
 public static void main(String[] args) { 
 Aluno aluno = new Aluno(); 
 aluno.setMatricula(“1234”); 
 aluno.setNome(“Oswaldo”); 
 aluno.setTeste(9.3); 
 aluno.setProva(9.9); 
 System.out.println("Matricula: " + aluno.getMatricula()); 
 System.out.println("Nome: " + aluno.getNome()); 
 System.out.println("Teste: " + aluno.getTeste()); 
 System.out.println("Prova: " + aluno.getProva()); 
 System.out.println("Média: " + aluno.getMedia()); 
 } 
} 
 
A linha Aluno aluno = new Aluno(), está instanciando um objeto chamado 
aluno. Como pode constatar, isso é feito através do operador new. 
 
Observe que conseguimos enviar o argumento “1234” através da linha 
aluno.setMatricula (“1234”). 
 
Assim como os demais métodos setXXX, estes são conhecidos como métodos 
de configuração e são responsáveis por atribuir valores aos nossos atributos. 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 13 
Da mesma forma que a linha aluno.getMatricula(), podemos obter os valores 
armazenados (estado) de nossos atributos. 
 
Os métodos getXXX são conhecidos como métodos de acesso. 
 
Encapsulamento 
Por que precisamos dos métodos de acesso e de configuração, visto que 
poderíamos tranquilamente acessar, de uma forma bastante simples, os 
atributos? 
 
A resposta está em mais um conceito básico denominado encapsulamento. 
Este consiste permitir que o mundo externo ao objeto somente tenha acesso às 
funcionalidades que desejamos oferecer (interface do objeto). 
 
As demais funcionalidades e atributos ficam restritas ao objeto. Com isso, 
diminuímos o acoplamento e aumentamos a coesão de nossos objetos, 
facilitando assim a sua reusabilidade. 
 
Observe em nosso exemplo de classe as linhas a seguir: 
 
private double teste, prova; 
public double getMedia(). 
 
A interface de nossa classe é constituída pelos métodos e atributos com a 
visibilidade pública (public). Com isso, podem ser acessados tanto pela própria 
classe como por classes externas. Ao contrário dos atributos e métodos 
privados (private), esses são de uso exclusivo da classe. 
 
Construtores 
Outro conceito básico implementado em larga escala são os construtores. Ele 
tem por finalidade instanciar uma classe, ou seja, criar o objeto em memória. 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 14 
Na verdade, é um método que é chamado automaticamente quando 
instanciamos nossas classes. Costumo dizer que é um método autorun. 
Normalmente são definidos para inicialização de valores do objeto. 
 
Veja o exemplo: 
 
public class Circulo { 
 private double PI; 
 private double raio; 
 public Circulo(){ //Construtor 
 PI = 3.14; 
 } 
 public double getPI(){ 
 return PI; 
 } 
 public double getRaio(){ 
 return raio; 
 } 
 public void setRaio(double raio){ 
 this.raio = raio; 
 public double getArea(){ 
 return PI * raio * raio; 
 } 
 public double getPerimetro(){ 
 return 2 * PI * raio; 
 } 
} 
 
Embora existam os métodos setPI, que permitiriam definir um valor a pi, o 
construtor public Circulo() permite atribuir um valor inicial ao mesmo. 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 15 
Para implementarmos um construtor, que é um método como outro qualquer, 
basta retirarmos o retorno e atribuirmos ao seu nome o mesmo da classe. Com 
isso, ele se torna um método “autorun”. Ele é disparado quando instanciamos 
uma classe, não podendo ser chamado explicitamente. 
 
Mesmo que não cheguemos a desenvolver um construtor em nossa classe, o 
Java declara, implicitamente, um construtor default, ou seja, um construtor 
vazio. 
 
Sobrecarga de métodos 
Embora seja aplicável a qualquer método, a sobrecarga é comumente 
implementada com os métodos construtores. Esta consiste na inclusão de um 
método com o mesmo nome, porém com a lista de parâmetros diferente na 
quantidade e/ou tipo. 
 
Veja o exemplo: 
 
public class Pagamento { 
 private double valorCompra; 
 private int nrPrest; 
 public Pagamento(){ valorCompra=0; nrPrest = 1; } 
 public Pagamento(double valorCompra){ 
 this.valorCompra = valorCompra; nrPrest = 1; 
 } 
 public Pagamento(int nrPrest){ 
 valorCompra=0; this.nrPrest = nrPrest; 
 } 
 public Pagamento(double valorCompra, int nrPrest){ 
 this.valorCompra = valorCompra; this.nrPrest = nrPrest; 
 } 
 public Pagamento(int nrPrest, double valorCompra){ 
 this.valorCompra = valorCompra; this.nrPrest = nrPrest; 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 16 
 } 
 public void setValores(double valorCompra, int nrPrest){ 
 this.valorCompra = valorCompra; this.nrPrest = nrPrest; 
 } 
 public void setValores(int nrPrest, double valorCompra){ 
 this.valorCompra = valorCompra; this.nrPrest= nrPrest; 
 } 
 public double getValorCompra() { return valorCompra; } 
 public void setValorCompra(double valorCompra) { 
 this.valorCompra = valorCompra; 
 } 
 public int getNrPrest() { return nrPrest; } 
 public void setNrPrest(int nrPrest) { this.nrPrest = nrPrest;} 
 
 public double getValorPrest(){ return valorCompra / nrPrest; } 
} 
 
Quando instanciamos o objeto pagamento (new Pagamento(1000.00)), 
automaticamente será selecionado o construtor em que a assinatura do método 
melhor se enquadrar. Em nosso caso, o construtor disparado será public 
Pagamento(double valorCompra), visto que o argumento passado 
(1000.00) é do tipo double. 
 
public class Principal { 
 public static void main(String[] args) { 
 Pagamento pagamento = new Pagamento(1000.00); 
 System.out.println("Valor da compra: " + 
 pagamento.getValorCompra()); 
 System.out.println("Número de pretações: " + 
 pagamento.getNrPrest()); 
 System.out.println("Valor da Prestação: " + 
 pagamento.getValorPrest()); 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 17 
 } 
} 
 
Final 
Muitas vezes desejamos definir valores constantes para nossas aplicações. Em 
nossa classe Círculo, o valor de PI poderia ser facilmente alterado através do 
método de configuração setPi. A palavra final pode ser empregada para 
definição de constantes. 
 
Veja o nosso programa alterado: 
 
public class Circulo { 
 private final double PI; 
 private double raio; 
 public double getPI(){ return PI; } 
 public double getRaio(){ return raio; } 
 public double getArea(){ return PI * raio * raio; } 
 public double getPerimetro(){ return 2 * PI * raio; } 
} 
 
A palavra reservada final possui outras aplicações, como veremos mais à frente. 
 
Static 
Em Java, nem sempre precisamos instanciar uma classe para fazer uso de sua 
interface. A palavra reservada static confere a possiblidade de manipularmos 
métodos e/ou atributos sem a existência de um objeto. 
 
Na literatura são comumente chamados de atributos e/ou métodos da classe e 
não do objeto. Como consequência, são compartilhados por todos os objetos 
daquele classe, ou seja, são visíveis por todos os objetos instanciados dessa 
classe. 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 18 
Veja o exemplo: 
 
public class Produto { 
 public static int codigo = 0; 
 private String descricao; 
 public Produto(String descricao) { 
 codigo++; 
 this.descricao = descricao; 
 } 
 public String getDescricao() {return descricao; } 
 public void setDescricao(String descricao) 
 {this.descricao = descricao; } 
} 
 
public class Principal { 
 public static void main(String[] args) { 
 Produto prod1 = new Produto("Caneta"); 
 System.out.println("Codigo Prod1: " + Produto.codigo 
 + " Descrição: " + prod1.getDescricao()); 
 Produto prod2 = new Produto("Borracha"); 
 System.out.println("Codigo Prod2: " + Produto.codigo 
 + " Descrição: " + prod2.getDescricao()); 
 Produto prod3 = new Produto("Lápis"); 
 System.out.println("Codigo Prod3: " + Produto.codigo 
 + " Descrição: " + prod3.getDescricao()); 
 } 
} 
 
Observe que o atributo código agora é compartilhado entre todos os objetos 
que forem instância da classe “produto”. Por ser tratar de um atributo da 
classe, para acessarmos basta referenciá-lo através do nome “classe”, como 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 19 
podemos observar no exemplo acima. O mesmo ocorre com os métodos 
estáticos. 
 
Devemos usar os atributos estáticos com moderação, para não termos o 
mesmo problema do uso de variáveis globais quando não são mais necessárias. 
 
Herança 
Conforme avançamos em Java, percebemos que é uma linguagem 
extremamente poderosa e rica em recursos. Herança certamente pode se 
destacar entre os principais conceitos que estudaremos. 
 
O conceito de herança nos permite estabelecer uma hierarquia entre as classes. 
Esse mecanismo permite a uma classe herdar as operações e os atributos de 
outra classe. Umas das principais vantagens de seu uso certamente é o reuso 
de código. 
 
Por Java nos fornecer suporte nativo à orientação a objetos, para 
implementarmos basta apenas estender a classe que desejamos herdar. 
 
Veja o exemplo: 
 
public class Pessoa { 
 private String nome, tel; 
 public String getNome() { return nome; } 
 public void setNome(String nome) { this.nome = nome; } 
 public String getTel() { return tel; } 
 public void setTel(String tel) { this.tel = tel; } 
} 
public class Funcionario extends Pessoa{ 
 
 private String codigo; 
 private double salarioBruto; 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 20 
 public String getCodigo() { return codigo; } 
 public void setCodigo(String codigo) { this.codigo = codigo; } 
 public double getSalarioBruto() { return salarioBruto; } 
 
 public void setSalarioBruto(double salarioBruto) { 
 this.salarioBruto = salarioBruto; 
 } 
} 
 
A classe Vendedor herda não só os atributos da classe Funcionario, como seus 
métodos. O mesmo se dá com a classe Funcionario em relação à classe Pessoa. 
O mesmo se dá com a classe Funcionario em relação à classe Pessoa. Isso 
pode ser verificado facilmente: 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 21 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
public class Principal { 
 
 public static void main(String[] args) { 
 
 Vendedor vendedor = new Vendedor(); 
 
 vendedor.setCodigo(“1234); 
 
 vendedor.setNome(“Oswaldo”); 
 
 vendedor.setTel(“9876-5432”); 
 
 vendedor.setSalarioBruto(100.00); 
 
 vendedor.setComissao(550.00); 
 
 System.out.println("Código: " + 
vendedor.getCodigo()); 
 
 System.out.println("Nome: " + 
vendedor.getNome()); 
 
 System.out.println("Telefone: " + vendedor.getTel()); 
 
 System.out.println("Salário Bruto: " 
 + 
vendedor.getSalarioBruto()); 
 
 System.out.println("Comissão " + vendedor.getComissao()); 
 
System.out.println("Salário Líquido: " 
 + vendedor.getSalarioLiquido()); 
 
 } 
} 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 22 
No exemplo acima, instanciamos o objeto Vendedor. Mesmo assim acessamos 
métodos declarados nas classes Pessoa e Funcionario, como por exemplo, 
getNome(), e getCodigo(). 
 
É oportuno comentar que existem 2 tipos de herança: Simples e Múltipla. A 
simples se caracteriza por cada classe poder herdar somente uma outra. Já na 
múltipla poderia herdar mais de uma. 
 
Em Java não podemos fazer uso da herança múltipla de classes. Um dos 
grandes problemas desse tipo de herança consiste que uma classes poderia 
herdar mais de uma classe com métodos de mesma assinatura, porém com 
implementações diferentes. Quando referenciássemos esse método pela 
subclasse, qual seria a implementação a ser executada? 
 
public class Vendedor extends Funcionario{ 
 private double comissao; 
 public double getSalarioLiquido(){ 
 return (getSalarioBruto() + comissao)*0.89; 
 } 
 public double getComissao() { return comissao; } 
 public void setComissao(double comissao){ 
 this.comissao = comissao; 
 } 
} 
 
Classe abstrata 
A palavra de ordem na programação orientada a objetos é reuso de código. 
Muitas vezes, quando fazemos uso da herança, percebemos que certas classes 
não têm como objetivo ser instância de um objeto, mas servir de modelo para 
suas subclasses. Como por exemplo, a classe Funcionario, desenvolvida 
anteriormente, pode servir de base para se implementar a herança para 
Gerente, Almoxarife e outros. 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 23 
 
Fica claro que em nossa empresa jamais instanciaremos a classe Funcionario. O 
mesmo ocorre com a classe Pessoa. Dentre outras funcionalidades, a palavra 
reservada abstract define que a classe não poderá ser instanciadae que deverá 
ser estendida. 
 
Veja o exemplo: 
 
Nossa classe Principal não sofrerá nenhuma alteração. Se incluíssemos a linha 
Funcionario funcionário = new Funcionario(), aí sim ocorreria um erro, pois, 
como supracitado, uma classe abstrata nunca pode ser instanciada. 
 
public abstract class Pessoa { 
 private String nome, tel; 
 public String getNome() { return nome; } 
 public void setNome(String nome) { this.nome = nome; } 
 public String getTel() { return tel; } 
 public void setTel(String tel) { this.tel = tel; } 
} 
public abstract class Funcionario extends Pessoa{ 
 
 private String codigo; 
 private double salarioBruto; 
 
 public String getCodigo() { return codigo; } 
 
 public void setCodigo(String codigo) {this.codigo = codigo;} 
 
 public double getSalarioBruto() { return salarioBruto; } 
 
 public void setSalarioBruto(double salarioBruto) { 
 this.salarioBruto = salarioBruto; 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 24 
 } 
} 
 
Interface 
Um outro conceito que, dentre outras coisas, permite contornar a herança 
múltipla, é o conceito de interface. 
 
Similar a uma classe, a interface define somente a assinatura dos métodos que 
devem ser implementados, mas essa implementação não é realizada. Cabe às 
classes que implementarem essa interface definir o código a ser executado. Por 
definição, todos os métodos da classe são públicos e abstratos. Além disso, 
seus atributos são final e estáticos. Para implementar-se uma interface usamos 
a palavra reservada implements. 
 
Veja o exemplo: 
 
interface InterfaceAnimal { 
 void alimentar(); 
 void locomover(); 
} 
public class Animal implements InterfaceAnimal{ 
 public void alimentar(){ 
System.out.println("Comendo....."); 
 } 
 public void locomover(){ 
 System.out.println("Locomovendo...."); 
 } 
} 
public class Principal { 
 public static void main(String[] args) { 
 Animal animal = new Animal(); 
 animal.alimentar(); 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 25 
 animal.locomover(); 
 } 
} 
 
Polimorfismo 
Um dos conceitos mais explorados na programação Java avançada é o 
polimorfismo. Existem quatro tipos de polimorfismo: 
 
Coerção (cast) 
 
Polimorfismo de inclusão 
 
Polimorfismo paramétrico (Generics Java) 
 
Sobrecarga (sobrecarga de métodos) 
 
Estudamos anteriormente a sobrecarga de métodos, que configura o 
polimorfismo de sobrecarga. Estudaremos em nossas próximas aulas os 
conceitos de coerção e paramétrico. 
 
Considerado por alguns como tipo mais básico de polimorfismo, a inclusão 
permite referenciar uma instância de qualquer classe filha a partir da classe pai. 
Como consequência, temos o benefício de tratar objetos diferentes através do 
envio de uma mesma mensagem. 
 
Veja o exemplo: 
 
public abstract class Veiculo { 
 private String placa; 
 private double ipva; 
 public String getPlaca() { return placa; } 
 public void setPlaca(String placa) { this.placa = placa; } 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 26 
 public double getIpva() { return ipva; } 
 public void setIpva(double ipva) { this.ipva = ipva; } 
 public abstract double getPedagio(); 
} 
public class Carro extends Veiculo{ 
 public double getPedagio() { 
 return getIpva() * 0.01; 
 } 
} 
public class Caminhao extends Veiculo { 
 public double getPedagio() { 
 return getIpva() * 0.03; 
 } 
} 
public class Principal { 
 public static void main(String[] args) { 
 Scanner input = new Scanner(System.in); 
 int op; 
 Veiculo veiculo = null; 
 do { 
 System.out.println("1 - Carro"); 
 System.out.println("2 - Caminhão"); 
 System.out.println("0 - Sair"); 
 System.out.println("Selecione uma das opções acima: "); 
 op = input.nextInt(); 
 if (op == 0) { break; } 
 switch (op) { 
 case 1: veiculo = new Carro(); break; 
 case 2: veiculo = new Caminhao(); break; 
 default: System.out.println("Opção Invalida"); continue; 
 } 
 System.out.print("Digite a placa do Carro:"); 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 27 
 veiculo.setPlaca(input.next()); 
 System.out.print("Digite o IPVA do Carro: "); 
 veiculo.setIpva(input.nextDouble()); 
 System.out.println("Placa: " + veiculo.getPlaca()); 
 System.out.println("Pedágio: " + veiculo.getPedagio()); 
 } while (true); 
 } 
} 
 
Observe que, em nossa classe principal, efetuamos a leitura e exibição dos 
dados de um Carro ou Caminhão de forma transparente, ou seja, sem nos 
preocuparmos com o tipo de objeto. Isso porque, através de veículo (Tipo 
Veículo) conseguimos fazer referência a Carro (veículo = new Carro();) ou 
Caminhão (veículo = new Caminhão();). Essa seleção foi efetuada 
dinamicamente (quando rodamos). 
 
Referências 
Java - Como Programar - 8ª Ed. 2010 - Paul J. Deitel e Dr. Harvey M. 
Deitel. 
BIG JAVA - HORSTMANN, CAY. 
 
Exercícios de fixação 
Questão 1 
Encapsulamento é a técnica que faz com que detalhes internos do 
funcionamento dos métodos de uma classe permaneçam ocultos para os 
objetos. 
Selecione a opção abaixo que apresenta a abrangência do modificador 
protected. 
a) Acessado na classe, no pacote e na subclasse. 
b) Acessado apenas na classe e na subclasse. 
c) Acessado no pacote e na subclasse. 
d) Acessado de qualquer lugar. 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 28 
e) Acessado na classe e no pacote. 
 
Questão 2 
Em orientação a objetos, uma Função (ou função membro) é uma sub-rotina 
(ou procedimento ou função) associada a um objeto, e que possui acesso aos 
seus dados, as variáveis membro. Ele é executado por um objeto ao receber 
uma mensagem. Os métodos determinam o comportamento dos objetos de 
uma classe e são análogos às funções ou procedimentos da programação 
estruturada. O envio de mensagens (chamada de métodos) pode alterar o 
estado de um objeto. 
 Portanto marque a alternativa CORRETA referente aos métodos de uma classe: 
a) No momento em que um método é chamado , seus argumentos são 
atribuídos a seus parâmetros. Então o corpo do método utiliza as 
variáveis de parâmetro para acessar os valores de argumento; 
b) Em geral você pode chamar um método de uma classe, mesmo sem ter 
criado um objeto desta classe; 
c) Um método pode especificar múltiplos parâmetros, separando cada 
parâmetro do seguinte por um ponto e vírgula; 
d) O número de argumentos na chamada de um método não precisa 
necessariamente corresponder ao número de parâmetros definidos no 
método; 
e) Nem todo parâmetro precisa especificar necessariamente o tipo ou o 
identificador. 
 
Questão 3 
(ENADE/2011) Considerando os conceitos da programação orientada a objetos, 
analise as afirmações abaixo. 
I. O objeto tem determinadas propriedades que o caracterizam e que são 
armazenadas no próprio objeto. As propriedades de um objeto são chamadas 
de instâncias. 
II. As mensagens são informações enviadas ao objeto para que ele se comporte 
de uma determinada maneira. Um programa orientado a objetos em execução 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 29 
consiste em envios, interpretações e respostas às mensagens. São os métodos, 
os procedimentos residentes nos objetos, que determinam como eles irão atuar 
ao receber as mensagens. 
III. A herança é um mecanismo para o compartilhamento de métodos e 
atributos entre classes e subclasses, permitindo a criação de novas classes 
através da programação das diferenças entre a nova classe e a classe-pai. 
IV. O encapsulamento é um mecanismo que permite o acesso aos dados de um 
objeto somente através dos métodos desse. Nenhuma outra parte do programa 
pode operar sobre os dados do objeto. A comunicação entre os objetos é feita 
apenas através de troca de mensagens. 
É correto apenas o que afirma em: 
a) I e II 
b) I e III 
c) III e IV 
d) I, II e IV 
e) II, III e IV 
 
Questão 4 
(EAOT/2011) Para que seja estabelecida a sobrecarga de métodos na 
linguagem Java, uma das características obrigatóriasé a utilização de métodos: 
a) Com a mesma assinatura. 
b) Com o mesmo número de parâmetros. 
c) O mesmo nome, declarados na mesma classe. 
d) Herdados da superclasse direta. 
e) Com métodos polimórficos. 
 
Questão 5 
5. (ENADE/2011) Eclipse, Netbeans, Jdeveloper são exemplos de ambientes 
integrados de desenvolvimento, chamados de IDE, que têm por objetivo 
facilitar o desenvolvimento de softwares, provendo maior produtividade e 
gerenciamento de projetos. A especificação JavaBeans foi criada para ser um 
padrão de desenvolvimento de componentes que possam ser facilmente usados 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 30 
por outros desenvolvedores em diferentes IDE. Com relação ao tema, analise as 
asserções a seguir: 
Seja para o Netbeans ou para o Eclipse, é possível adquirir 
componentes de terceiros que facilitem a implementação do seu 
projeto 
PORQUE 
como o código desses componentes está em linguagem intermediária, 
ou seja, independente da arquitetura de um computador real, só é 
necessário que a máquina virtual esteja instalada no computador 
onde o aplicativo será executado e a máquina virtual será a 
responsável pela interpretação do código para a linguagem de 
máquina do computador em execução. 
Acerca dessas asserções, assinale a alternativa correta: 
a) As duas asserções são proposições verdadeiras, e a segunda é uma 
justificativa correta da primeira. 
b) As duas asserções são proposições verdadeiras, mas a segunda não é 
uma justificativa correta da primeira. 
c) A primeira asserção é uma proposição verdadeira, e a segunda, uma 
proposição falsa. 
d) A primeira asserção é uma proposição falsa, e a segunda, uma 
proposição verdadeira. 
e) Tanto a primeira quanto a segunda asserções são proposições falsas. 
 
Questão 6 
Classes abstratas são feitas para serem modelos para suas classes derivadas. 
Com relação a uma classe abstrata é correto afirmar que: 
a) Esta não pode ser instanciada; 
b) Esta só pode ser instanciada se o objeto também for abstrato; 
c) Esta não possui métodos; 
d) Esta só possui métodos e atributos abstratos; 
e) Esta não possui métodos nem atributos abstratos. 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 31 
Questão 7 
(ENADE/2011) O paradigma de programação orientado a objetos tem sido 
largamente utilizado no desenvolvimento de sistemas. 
Considerando o conceito de herança, avalie as afirmações abaixo. 
I. Herança é uma propriedade que facilita a implementação de reuso. 
II. Quando uma subclasse é criada, essa herda todas as características da 
superclasse, não podendo possuir propriedades e métodos próprios. 
III. Herança múltipla é uma propriedade na qual uma superclasse possui 
diversas subclasses. 
IV. Extensão é uma das formas de se implementar herança. 
É correto apenas o que se afirma em: 
a) I 
b) III 
c) I e IV 
d) II e III 
e) II e IV 
 
Questão 8 
A orientação a objetos é um modelo de análise, projeto e programação de 
sistemas de software baseado na composição e interação entre diversas 
unidades de software chamadas de objetos. Com relação a conceitos de 
orientação a objetos, julgue os seguintes itens: 
I - As variáveis ou métodos declarados com modificador de acesso private só 
são acessíveis a métodos da classe em que são declarados. 
II - Uma classe deve possuir uma única declaração de método construtor 
III - Uma instância de uma classe abstrata herda atributos e métodos de sua 
superclasse direta. 
IV - O polimorfismo permite substituir a lógica condicional múltipla (lógica 
switch ou faça caso). 
a) I e II 
b) I e III 
c) I e IV 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 32 
d) II e III 
e) II e IV 
 
Questão 9 
Analise as seguintes afirmativas (Fonte: Poscomp 2011). 
I. Ocultar dados dentro das classes e torná-los disponíveis apenas por meio de 
métodos é uma técnica muito usada em programas orientados a objetos e é 
chamada de sobrescrita de atributos. 
II. Uma subclasse pode implementar novamente métodos que foram herdados 
de uma superclasse. Chamamos isso de sobrecarga de métodos. 
III. Em Java não existe Herança múltipla como em C++. A única maneira se se 
obter algo parecido é via interfaces. 
a) Apenas a afirmativa I está incorreta. 
b) Apenas a afirmativa II está incorreta. 
c) Apenas a afirmativa III está incorreta. 
d) Apenas as afirmativas I e III estão incorretas. 
e) Apenas as afirmativas I e II estão incorretas. 
 
Questão 10 
Considerando o esquema de herança existente na metodologia de Orientação a 
Objeto, em uma hierarquia de classes em Java, temos: 
I. Os construtores da superclasse não são herdados pelas instâncias de uma 
subclasse. 
II. Todo método construtor de uma superclasse precisa também chamar um 
construtor da subclasse. 
III. O comando super( ), chamada ao construtor da superclasse, deve ser 
declarado obrigatoriamente na primeira linha do construtor da subclasse. 
Marque a alternativa CORRETA: 
a) Apenas as a sentença I e III são verdadeiras. 
b) Apenas as sentenças I e II são verdadeiras. 
c) Apenas as sentenças II e III são verdadeiras. 
d) Todas as sentenças são verdadeiras. 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 33 
e) Nenhuma sentença é verdadeira. 
 
Aula 1 
Exercícios de fixação 
Questão 1 - A 
Justificativa: Existem quatro tipos de modificadores: 
public: Este pode ser acessado de qualquer lugar. 
private: Este só pode ser acessado por membros da classe. 
protected: Pode ser acessado por classes do mesmo pacote ou através da 
herança. 
default: pode ser acessado por membros de mesmo pacote. 
 
Questão 2 - A 
Justificativa: Analisando as opções: 
1 - A alternativa “em geral você pode chamar um método de uma classe, 
mesmo sem ter criado um objeto desta classe” é falsa, pois em geral 
precisamos criar objetos para acessar seus métodos. Um caso, particular, são 
os métodos estáticos. 
2 - A alternativa “um método pode especificar múltiplos parâmetros, separando 
cada parâmetro do seguinte por um ponto e vírgula” é falsa, pois a separação é 
efetuada por uma vírgula. 
3 - A alternativa “o número de argumentos na chamada de um método não 
precisa necessariamente corresponder ao número de parâmetros definidos no 
método é falsa porque precisa corresponder. 
4 - A alternativa “Nem todo parâmetro precisa especificar necessariamente o 
tipo ou o identificador é falsa pois é preciso especificar ambos. 
5 - No momento em que um método é chamado, seus argumentos são 
atribuídos a seus parâmetros. Então o corpo do método utiliza as variáveis de 
parâmetro para acessar os valores de argumento está correta. 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 34 
Questão 3 - E 
Justificativa: Analisando as opções, observa-se que a única opção incorreta é: 
I. O objeto tem determinadas propriedades que o caracterizam e que são 
armazenadas no próprio objeto. As propriedades de um objeto são chamadas 
de instâncias. 
Opção errada, pois as instâncias de uma classe são chamadas de objetos. 
 
Questão 4 - C 
Justificativa: É muito comum a confusão referente aos conceitos de sobrecarga 
e sobrescrita: 
Sobrescrita: Quando temos um método em uma Classe que herda outra, e 
possui um método com a mesma assinatura que a da classe Ancestral. 
Sobrecarga: Quando temos dois ou mais métodos com mesmo nome, porém 
recebendo parâmetros diferentes, ou seja, com uma assinatura diferente. 
Analisemos as opções dadas: 
• com a mesma assinatura - Falso, pois é referente a sobrescrita. 
• com o mesmo número de parâmetros - Falso, pois não é obrigatório ter o 
mesmo número de parâmetros. 
• com métodos polimórficos - Falso, pois não é obrigado necessariamente. 
• herdados da superclasse direta - Falso, pois não é obrigatório ser referente a 
métodos herdados. 
 
Questão 5 - B 
Justificativa: As duas opções estão corretas, mas nem todos os componentes 
necessariamente são desenvolvidos em Java. Por isto a segunda afirmação nãoé justificativa da primeira. 
 
Questão 6 - A 
Justificativa: Analisando as opções: 
• Esta só pode ser instanciada se o objeto também for abstrato -> Errada, pois 
em hipótese nenhuma uma classe abstrata pode ser instanciada. 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 35 
• Esta não possui métodos -> Errada, pois pode possuir métodos abstratos ou 
não. 
• Esta só possui métodos e atributos abstratos -> Errada, pois pode possuir 
métodos concretos. 
• Esta não possui métodos nem atributos abstratos - Errada, pois pode possuir 
métodos abstratos e concretos. 
• Esta não pode ser instanciada – Verdadeira. Uma classe abstrata nunca pode 
ser instanciada. 
 
Questão 7 - C 
Justificativa: Analisando as opções: 
• Herança é uma propriedade que facilita a implementação de reuso -> Correta, 
pois podemos implementar métodos em uma superclasse e herdarmos em 
todas suas subclasses, evitando assim a reescrita dos mesmos. 
• Quando uma subclasse é criada, essa herda todas as características da 
superclasse, não podendo possuir propriedades e métodos próprios -> Errada, 
pois as subclasses , não só podem, como normalmente, implementam seus 
atributos e métodos próprios. 
• Herança múltipla é uma propriedade na qual uma superclasse possui diversas 
subclasses- > Errada, pois consiste em uma subclasses possuir diversas 
superclasse. 
• Extensão é uma das formas de se implementar herança -> Correto. Inclusive 
usamos a palavras reservada extends. 
 
Questão 8 - C 
Justificativa: Analisando as opções: 
• As variáveis ou métodos declarados com modificador de acesso private só são 
acessíveis a métodos da classe em que são declarados –> Correto. Por isto 
existem os demais modificadores como, por exemplo, public, protected e 
default. 
• Uma classe deve possuir uma única declaração de método construtor -> 
Errado, pois podemos declarar vários construtores ou até mesmo nenhum. 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 36 
• Uma instância de uma classe abstrata herda atributos e métodos de sua 
superclasse direta.-> Errado, pois classe abstrata não pode ser instanciada. 
• O polimorfismo permite substituir a lógica condicional múltipla (lógica switch 
ou faça caso). Correto. Polimorfismos possui esta característica. 
 
Questão 9 - E 
Justificativa: Analisando as opções: 
• Ocultar dados dentro das classes e torná-los disponíveis apenas por meio de 
métodos é uma técnica muito usada em programas orientados a objetos e é 
chamada de sobrescrita de atributos -> Errada, pois é conhecida como 
Encapsulamento. 
• Uma subclasse pode implementar novamente métodos que foram herdados 
de uma superclasse. Chamamos isso de sobrecarga de métodos -> Errada, pois 
é conhecida por sobrescrita de métodos. 
• Em Java não existe Herança múltipla como em C++. A única maneira se se 
obter algo parecido é via interfaces. -> Correto. A linguagem Java não permite 
herança múltipla com herança de código.Para tanto, implementa o conceito de 
interface. É possível herdar múltiplas interfaces. Uma classe pode estender uma 
outra classe e implementar zero ou mais interfaces. Inclusive, para implementar 
uma interface em uma classe, usamos a palavra implements. 
 
Questão 10 - A 
Justificativa: Analisando as opções: 
• Os construtores da superclasse não são herdados pelas instâncias de uma 
subclasse. -> Correto. Inclusive, em herança, todos os construtores de classe 
base são chamados antes de construtores de classe derivada na ordem em que 
as classes aparecem na hierarquia de classes. 
• Todo método construtor de uma superclasse precisa também chamar um 
construtor da subclasse. -> Errada. O construtor da super classe não chama 
explicitamente o construtor da subclasse. 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 37 
• O comando super( ), chamada ao construtor da superclasse, deve ser 
declarado obrigatoriamente na primeira linha do construtor da subclasse. -> 
Correto. Caso contrário, será gerado um erro. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 38 
Introdução 
A Internet está crescendo de forma avassaladora a cada dia que passa. Seu 
potencial permite que sejam constituídos verdadeiros sistemas de informação, 
que viabilizam a execução de serviços interativos. Já foi o tempo que 
funcionava apenas como repositórios estáticos de informação. Hoje, promove a 
troca e o compartilhamento de informações em ambientes cooperativos. 
 
Os atuais sistemas de informação, particularmente aqueles voltados para áreas 
cadastrais, são implementados em plataformas voltadas para a Internet, 
obtendo independência de ambiente e centralização de manutenção. 
 
Com o aumento de complexidade, sistemas de maior porte passam a utilizar 
arquiteturas robustas, padrões de desenvolvimento e pools de conexões com 
bancos de dados. 
 
A linguagem Java demonstra-se uma boa ferramenta para essas 
implementações, oferecendo tecnologias já consolidadas, tais como JSP e 
Servlet. 
 
Objetivo: 
1. Compreender procedimentos e técnicas de desenvolvimento de aplicações 
para a Internet, com a utilização da tecnologia Sevlet; 
2. Explorar potencialidades da tecnologia JavaServer Pages na criação de 
servidores web. 
 
 
 
 
 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 39 
Conteúdo 
Servlet 
Considerada umas das tecnologias mais bem-sucedidas e conhecidas no 
mercado, o Servlet se consolidou como base de desenvolvimento de sistema 
Web em Java. Criado em 1997, seu conceito é bastante simples. Esse consiste 
de classes que são executados no servidor, capazes de gerar páginas 
dinâmicas. Sua funcionalidade consiste em receber uma requisição (request) e, 
após processamento, gerar ou não uma resposta (response), ou seja, possibilita 
o tratamento dinâmico de Request e Response. 
 
 
 
Arquitetura Servlet 
 
Em geral, nosso Web-Server é especialista em conteúdo estático. Quando o 
cliente (ex.: Brownser) envia uma requisição que demande a geração de 
conteúdo dinâmico, este repassa para nossa aplicação amiga (Container Web), 
que instancia o Servlet para gerar esse conteúdo. 
 
Para implementar um Servlet, basta implementar a interface Servlet. É bastante 
importante ressaltar que essa tecnologia pode atender a qualquer tipo de 
aplicação baseada no modelo request-response, mas seu uso normalmente se 
aplica a web. 
 
Principais vantagens da tecnologia Servlet 
As principais vantagens da tecnologia Servlet são: 
 
Performance 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 40 
 
Por trabalhar com Threads, não são criados novos processos a cada requisição, 
permitindo ser executado de forma mais eficaz e eficiente. 
 
Portabilidade 
 
Por se tratar de Java, roda sobre a Java Virtual Machine (JVM). Com isso, pode 
ser executado em qualquer Sistema Operacional (SO) que possua JVM 
instalada. 
 
Fácil programação 
 
Oferece suporte nativo à gestão de memória, ao nível de segurança e 
permissão de acesso, o que facilita muito a programação. Além disso, possui 
API rica em classes e interfaces. 
 
Para ser executado, um Servlet precisa de um Container web, visto que estende 
a funcionalidade do mesmo. Entre os principais, podemos destacar: 
 
Tomcat (Não suporta EJB) 
GlassFish 
JBoss 
Websphere 
 
Principais classes e interfaces da API Servlet 
A API oferece um vasto conjunto de interfaces e classes abstratas ou não para 
implementarmos um Servlet: 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 41 
 
 
Interfaces 
 
• Servlet 
• ServletConfig 
• ServletContext 
• ServletRequest 
• ServletResponse 
• SingleThreadModel 
• RequestDispatcher 
 
Classes abstratas 
 
• GenericServlet 
 
Classes concretas 
 
• ServletException 
• UnavailableException 
• ServletInputStream 
• ServletOutputStream 
 
Fonte: http://webjellee.weebly.com/servlets.html 
 
 
 PROJETO E IMPLEMENTAÇÃOORIENTADO A OBJETOS 42 
Ciclo de vida Servlet 
Por ser controlado pelo Container, quando este recebe a requisição é delegada 
a um Servlet que: 
 
1 - Carregar a classe na memória; 
 
2 - Criar uma instância da classe Servlet; 
 
3 - Iniciar a instância chamando o método init(); 
a) Chamado exatamente uma vez. Pode ser sobrecarregado para conter código 
de inicialização, como por exemplo, carregar driver de banco de dados, 
inicialização de valores, etc. 
 
4 - Para cada request executar o método service; 
a) O Container passa um objeto request (possui dados da solicitação do 
usuário) e um objeto response (possui dados da resposta do usuário). 
b) Quando a resposta é enviada, os objetos são destruídos. 
 
5 - Chamar o método destroy() quando o Servlet for removido da memória. 
 
Ao estender a classe abstrata GenericServlet deve-se implementar o seu 
método service () para tratar suas requisições. Este aceita dois parâmetros: um 
objeto de pedido (request) e um objeto de resposta (response). 
 
Veja o exemplo abaixo: 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 43 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
HTTP Servlet 
A classe HttpServlet facilita bastante a programação de servlets para web. 
Quando a estendemos, ela redireciona as chamadas ao método service() para 
os métodos doGet() e/ou doPost(), que refletem os métodos GET e/ou POS do 
HTTP. Precisamos, pelo menos, implementar um dos dois. 
 
Veja o exemplo abaixo: 
import java.io.*; 
import javax.servlet.*; 
 
public class MeuPrimeiroServlet implements Servlet { 
 public void init(ServletConfig config) thorws ServletException{ 
 System.out.println(“método init()”); 
 } 
 public void service(ServletRequest request, ServletResponse 
response) 
 throws ServletException, IOException{ 
 System.out.println(“método Service”); 
 } 
 public void destroy(){ 
 System.out.println(“método destroy()”); 
 } 
 public String getServletInfo(){ 
 return null; 
 } 
 public ServletConfig getServletConfig(){ 
 return null; 
 } 
} 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 44 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
import java.io.IOException; 
import java.io.PrintWriter; 
import javax.servlet.ServletException; 
import javax.servlet.http.HttpServlet; 
import javax.servlet.http.HttpServletRequest; 
import javax.servlet.http.HttpServletResponse; 
 
 
public class MeuServlet extends HttpServlet { 
 
 @Override 
 
 protected void doGet(HttpServletRequest request, HttpServletResponse 
response) 
 throws ServletException, IOException { 
 
 response.setContentType("text/html;charset=UTF-8"); 
 PrintWriter out = response.getWriter()) 
 
 out.println("<!DOCTYPE html>"); 
 out.println("<html>"); 
 out.println("<head>"); 
 out.println("<title>MeuServlet</title>"); 
 out.println("</head>"); 
 out.println("<body>"); 
 out.println("<h1>Oswaldo</h1>"); 
 out.println("</body>"); 
 out.println("</html>"); 
 } 
} 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 45 
Em nosso exemplo, implementamos somente o método doGet. Como pode ver, 
precisamos programar toda a página de saída, em HTML, através do método 
println de nosso objeto out, obtido do objeto HttpServletResponse. Isso torna 
inviável o trabalho de webdesigners que têm seu foco de trabalho, como por 
exemplo, em arquitetura da informação, ergonomia, usabilidade, e não em 
programação Java. 
 
Principais classes e interfaces da API HttpServlet 
A HttpServlet também oferece uma API bastante robusta: 
 
 
 
Interfaces: 
• HttpServletRequest 
• HttpServletResponse 
• HttpSession 
 
Classes abstratas: 
• HttpServlet 
 
Classes concretas: 
• Cookie 
https://pt.wikipedia.org/wiki/Arquitetura_da_informa%C3%A7%C3%A3o
https://pt.wikipedia.org/wiki/Ergonomia
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 46 
 
Fonte: http://webjellee.weebly.com/servlets.html 
 
Principais métodos da HttpServletRequest e da 
HttpServletResponse 
Vejamos agora os principais métodos da HttpServletRequest e da 
HttpServletResponse: 
 
• Enumeration getHeaderNames() 
• String getHeader(“name”); 
• Enumeration getHeader(“name”); 
• String getParameter(“name”); 
• String getParameterValues(“name”); 
• Enumeration getParameterNames(); 
• Cookies[] getCookies(); 
• HttpSession getSession(); 
• setAttribute(“name”,obj); 
• Object getAttribute(“name”); 
• String getRemoteUser(). 
 
HttpServletResponse 
 
• addHeader(String name, String valor); 
• setContentType(tipo MIME); 
• sendRedirect(String location); 
• Writer getWriter(); 
• OutputStream getOutputStream(); 
• addCookie(Cookie c); 
• encodeURL(String url); 
• reset(); 
• resetBuffer(). 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 47 
Mapeamento Servlet 
É muito perigoso permitir o acesso direto ao arquivo de nossa classe Servlet. 
Para tanto, podemos mapear nossas classes oferecendo nomes fictícios. Isso é 
possível através de Annotations Java, que estudaremos em nossas próximas 
aulas, ou XML. O arquivo web.xml (Deployment Descriptor) tem por função 
definir o mapeamento entre o nome lógico e o nome verdadeiro de uma 
solicitação. 
 
Veja o exemplo abaixo: 
 
As principais tags para configuração do servlet são: 
 <servlet>...</servlet>: 
o Registra no Container quais arquivos de classes pertencem a uma 
aplicação em particular. 
 <servlet-mapping>...<servlet-mapping>: 
o Define qual servlet deve ser executada quando uma URL for 
solicitada. 
 <servet-name>...</servlet-name>: 
o Responsável por relacionar um elemento <servlet> a um elemento 
específico <servlet-mapping>. 
 <servlet-class>...< servlet-class>: 
o É o nome real do servlet(completamente qualificado) 
 <url-pattern>...</url-pattern>: é o nome fictício disponível ao cliente. 
 
Estrutura de uma aplicação web 
A figura abaixo mostra a estrutura da árvore de diretórios de uma aplicação 
Java padrão: 
 
• Contexto(Assembly Root): área acessível ao cliente. Diretório onde, 
normalmente, são armazenados seus componentes estáticos; 
• Web-inf: área inacessível ao cliente; 
• lib: destinado a arquivos jars de terceiros; 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 48 
• classes: onde são armazenados suas classes compiladas (.class). 
 
JavaServer Pages (JSP) 
É uma tecnologia para o desenvolvimento de páginas da web que suportam 
conteúdo dinâmico, ajudando aos desenvolvedores a inserir o código Java em 
páginas HTML. Um componente JavaServer Pages quando compilado é 
convertido em um Servlet. 
 
JSP é projetado para tornar mais amigável o desenvolvimento de interfaces de 
usuário para um aplicativo web Java. Isso facilita muito a vida dos 
desenvolvedores Web a escrever JSPs como arquivos de texto que combinam 
código HTML, XHTML, CSS, entre outros. 
 
Arquitetura JSP 
A arquitetura e ciclo de vida dos JSPs são praticamente iguais aos do Servlet. A 
principal diferença consiste que quando o JSP é chamado, o Container o traduz 
para o código-fonte de uma classe Servlet e o compila. 
Vantagens 
 
Por ser um Servlet quando compilado, herda todas vantagens e também: 
 
• O desenvolvimento da parte estática pode ocorrer separadamente da parte 
dinâmica; 
• Viabiliza a separação de profissionais, como desenvolvedores e webdesigners. 
 
Objetos implícitos 
 
• request: representa o HttpServletRequest; 
• response: representa o HttpServletResponse; 
• out: representa o PrintWriter associado ao response; 
• session: representa o HttpSession associado ao request; 
• application: representa o ServletContext; 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 49 
• config: representa o ServletConfig;• pageContext: representa o PageContext; 
• page: apenas um sinônimo para this; 
• exception: representa o Throwable. 
 
Sintaxe JSP 
Ao trabalharmos com JSP, precisamos entender bem os três tipos elementos de 
sua sintaxe: 
Elemento Script: é através dele que inserimos código Java em nossas páginas 
JSP 
 
Scriptles - São blocos de código Java que são inseridos delimitando-se com as 
tags <% %>. 
 
São blocos de código Java que são inseridos delimitando-se com as tags <% 
%>. Veja o exemplo abaixo: 
 
 
 
<html> 
 <head> 
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 
 <title>Sucesso</title> 
 </head> 
 <body> 
 <h1>Dados do Aluno:</h1> 
 
 <% Aluno aluno = (Aluno) request.getAttribute("parametroAluno"); 
 out.println("Matricula: "+aluno.getMatricula()+"<br/>"); 
 out.println("Nome: "+aluno.getNome()+"<br/>"); 
 out.println("Média: "+aluno.calcMedia()+"<br/>"); 
 %> 
 
 </body> 
</html> 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 50 
No exemplo acima, em negrito, podemos verificar o uso de um Scriptlet. Nesse 
caso, estamos recebendo um atributo chamado parametroAluno de um Servlet. 
Logo após, estamos usando o objeto implícito out para exibir os dados do 
aluno. 
 
Declarações - Através desse elemento podemos declarar variáveis ou até 
mesmo métodos. Para tanto, deve encontrar-se entre as tags <%! E %> 
 
Expressões - Quando uma página JSP é chamada, as expressões são 
normalmente usadas em substituição ao out.println(). Para implementar uma 
expressão deve-se fazer uso das tags &#60;%= e %&#62;. Veja o exemplo: 
 
Ação Padrão - São um grupo de tags JSP predefinidas que oferecem 
funcionalidades especiais, minimizando a necessidade de uso de scriptlet. As 
principais são. 
 
Veja o exemplo abaixo: 
<html> 
 <head> 
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 
 <title>Sucesso</title> 
 </head> 
 <body> 
 <h1>Dados do Aluno:</h1> 
 
 <jsp:useBean id="parametroAluno" class="modelo.Aluno" scope="request"> 
 <jsp:setProperty name="parametroAluno" property="matricula" value="Sem 
Matricula"/> <br/> 
 <jsp:setProperty name="parametroAluno" property="nome" value="Sem 
Nome"/> <br/> 
 </jsp:useBean> 
 
 Matricula: <jsp:getProperty name="parametroAluno" property="matricula"/> 
<br/> 
 Nome: <jsp:getProperty name="parametroAluno" property="nome"/> <br/> 
 Média: <jsp:getProperty name="parametroAluno" property="media"/> <br/> 
 
 </body> 
</html> 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 51 
Em nosso exemplo, a tag jsp:useBean buscar um parâmetro cujo o id é 
parametroAluno do tipo modelo.Aluno. Caso não o encontre, o criará e 
configurará suas propriedades matrícula e nome com os respectivos valores 
Sem matrícula e Sem nome. 
 
jsp:useBean 
• encontra ou constrói um JavaBeans; 
 jsp:setProperty 
• configura o valor de uma propriedade; 
 jsp:getProperty 
• retorna o valor de uma propriedade; 
jsp:include 
• incorpora recursos estáticos ou dinâmicos a página vigente; 
jsp:forward 
• a página atual é finalizada e o controle encaminhado para outro recurso. 
 
Diretivas - As diretivas (Page, Include e Taglib) têm por finalidade informar ao 
Container dados importantes referentes estrutura geral do Servlet resultante. 
Podem ser classificadas em três tipos: 
 
Diretivas de página; 
 Ex: <%@ page import=”modelo.Aluno” %> 
Diretivas de inclusão; 
 Ex: <%@ include = “rodape/footer.html” %> 
Diretivas de tag de biblioteca: 
 Ex: <%@ taglib uri=”tagLibURI” prefix=”tlu %> 
 
Expression Language (EL) 
A Expression Languange é uma forma fácil e compacta de acessar dados de 
aplicativos armazenados em JavaBeans. Aceita números inteiros, ponto 
flutuante, Strings e até mesmo booleanos, entre outros tipos. 
 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 52 
Veja o exemplo abaixo: 
 
 
 
 
 
 
 
 
 
 
Uma EL sempre vem entre chaves e procedida pelo símbolo de $. Mais um 
exemplo: 
 
 
 
 
 
<html> 
 <head> 
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 
 <title>Sucesso</title> 
 </head> 
 <body> 
 <h1>Dados do Aluno:</h1> 
 Matricula: ${parametroAluno.matricula} <br/> 
 Nome: ${parametroAluno.nome} <br/> 
 Média: ${parametroAluno.media} <br/> 
 
 </body> 
</html> 
<%@page import="java.util.*" %> 
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 
 
 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
 "http://www.w3.org/TR/html4/loose.dtd"> 
 
<html> 
 <head> 
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 
 <title>Diretivas e Taglib</title> 
 </head> 
 <body> 
 
 <c:forEach var="nome" items="${listaNomes}"> 
 ${nome}<br/> 
 </c:forEach> 
 </body> 
</html> 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 53 
Em nosso exemplo estamos usando diretivas, tagLibs e Expression Language. A 
tag forEach recebe uma lista de nomes e exibe nome a nome a cada interaçã 
 
Referências 
Java para Web com Servlets, JSP e EJB – Budi Kurniawan. 
Murach’s Java Servlets ans JSP – Andrea Steelman. 
Use a cabeça Servlets & JSP – Bryan Basham, Kathy Sierra e Bert Bates. 
Core Servlets and JavaServer Pages – Vol I – Marty Hall. 
 
Exercícios de fixação 
Questão 1 
Servlet é uma classe Java usada para estender as funcionalidades de um 
servidor. Apesar dos servlets poderem responder a quaisquer tipos de 
requisições, eles normalmente são usados para estender as aplicações 
hospedadas por servidores web, desta forma eles podem ser imaginados como 
Applets Java que rodam em servidores em vez de rodarem nos navegadores 
web. 
Tendo como base o funcionamento dos Servlets, pode-se afirmar que: 
a) Servlet não aciona outro Servlet. Este é capaz de receber uma 
requisição, apenas processá-la. 
b) Um Servlet pode apenas processar requisições do tipo "get", isto é, 
aquelas originadas de um formulário web. 
c) Os Servlets são executados sempre no computador do usuário, nunca no 
servidor Web. 
d) Apesar dos Servlets serem baseados na tecnologia Java, não há a 
necessidade de uma Máquina Virtual Java para executá-lo. 
e) Para que um Servlet possa ser executado é necessário que um Container 
Java esteja em funcionamento. 
 
Questão 2 
(TRE-CE/2012) No contexto do ciclo de vida de um servlet, considere: 
 
 PROJETO E IMPLEMENTAÇÃO ORIENTADO A OBJETOS 54 
I. Quando o servidor recebe uma requisição, ela é repassada para o container 
que, por sua vez, carrega a classe na memória e cria uma instância da classe 
do servlet. 
II. Quando um servlet é carregado pela primeira vez para a máquina virtual 
Java do servidor, o método init() é invocado, para preparar recursos para a 
execução do serviço ou para estabelecer conexão com outros serviços. 
III. Estando o servlet pronto para atender as requisições dos clientes, o 
container cria um objeto de requisição (ServletRequest) e de resposta 
(ServletResponse) e depois chama o método service(), passando os objetos 
como parâmetros. 
IV. O método destroy() permite liberar os recursos que foram utilizados, sendo 
invocado quando o servidor estiver concluindo sua atividade. 
Está correto o que se afirma em: 
a) I, II e III, apenas. 
b) I, II e IV, apenas. 
c) I, III e IV, apenas. 
d) II, III e IV, apenas. 
e) I, II, III e IV. 
 
Questão 3 
3. (JUCESC/2013) Assinale a alternativa que defne corretamente um Servlet: 
a) É um método da JPA utilizado na persistência assíncrona de dados. 
b) É um componente que roda do lado do cliente para tratar problemas de 
comunicação. 
c) É uma classe Java utilizada para estender as capacidades de um 
servidor. 
d) É uma biblioteca JBOSS que emula servidores no lado do cliente. 
e) É uma JSP que possibilita a execução