Baixe o app para aproveitar ainda mais
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 <%= e %>. 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
Compartilhar