Linguagens tecnicas prog ll by EAD UNIFACS

4º Semestre

LINGUAGENS E TÉCNICAS DE PROGRAMAÇÃO II Autor: Ana Patrícia F. Magalhães Mascarenhas

Universidade Salvador – UNIFACS Diretor Presidente

Marcelo Henrik Chanceler

Manoel Joaquim Fernandes de Barros Sobrinho Reitora

Marcia Pereira Fernandes de Barros Diretor de Educação Corporativa & Novos Projetos

Adriano Lima de Barbosa Miranda Pró-reitora de Pós-Graduação, Pesquisa e Extensão Comunitária

Carolina de Andrade Spinola Coordenadora do Eixo de Formação Humanística

Sílvia Rita Magalhães de Olinda EAD UNIFACS Coordenador Geral de EAD, GEX e Extensão

Luciano Pena Almeida de Souza Coordenador do Curso

José Carlos Couto Souza Junior Coordenadora de Design Educacional

Agnes Oliveira Bezerra

Coordenadora de Sistemas e Processos

Karina Fabiana Vieira da Silva Supervisor de Produção de Mídias

Jorge Antonio Santos Alves Designers

Adusterlina Cerqueira Lordello Carlos Eduardo Cova Santos Paulo Ricardo de Souza Dourado Thiago Gomes Monteiro Penha Revisão / estrutura

Noemia Carla Santana Reis Séfora Joca Maciel Sonildes de Jesus Sousa Tatiana Souza Motta EAD UNIFACS - http://ead.unifacs.br/ UNIFACS Atende (Salvador): 3021-2800 - Demais Localidades: 0800-284-0212

APRESENTAÇÃO Olá pessoal!

Vamos iniciar uma nova disciplina, Linguagem Técnica de Programação II. Nela, aprenderemos um novo paradigma de programação, a Programação Orientada a Objetos (POO) e a linguagem Java. Espero que vocês estejam ansiosos em aprender POO e Java, pois este paradigma é o mais utilizado pelas empresas atualmente no desenvolvimento de sistemas. Vamos iniciar o curso entendendo os conceitos básicos de POO tais como modelos, classes e objetos. Em seguida, faremos uma introdução à linguagem Java e seus recursos. Dando continuidade, aprenderemos conceitos avançados de POO tais como herança, polimorfismo e classes abstratas. Também avançaremos na linguagem Java trabalhando com vetores e matrizes. Veremos também o tratamento de exceções, importante na construção de sistemas mais confiáveis. Finalmente trabalharemos com interface gráfica para construirmos aplicações mais amigáveis e interativas.

Sendo assim, desejo a todos um ótimo curso!

Ana Patrícia F. M. Mascarenhas

Autora: Ana Patrícia F. Magalhães Mascarenhas

Os sistemas de informação estão presentes na nossa vida em quase tudo que fazemos hoje. Utilizamos sistemas para estudar, nos divertir, marcar uma consulta médica e para fazer nossas compras.

de programação II

ORIENTADA A OBJETOS

483 lingüagens e técnicas

AULA 01 - INTRODUÇÃO À PROGRAMAÇÃO

Existem diversas técnicas que podemos utilizar para desenvolver sistemas. Dentre estas técnicas, a programação orientada a objetos é a que mais tem se destacado atualmente. Nesta aula, começaremos a entender os conceitos básicos da programação orientada a objetos.

Introdução Os sistemas que utilizamos nas nossas atividades cotidianas são construídos de acordo com uma abordagem de desenvolvimento. Ao longo dos anos, diversas abordagens foram propostas. Inicialmente, tivemos a abordagem orientada a funções, onde o foco do desenvolvimento estava em mapear as funcionalidades que o sistema

deveria processar. Com a evolução tecnológica e o surgimento dos sistemas geren- ________________________ ciadores de banco de dados (SGBDs), passamos a dar mais importância para os dados ________________________ processados em nossas aplicações. Surgiu, então, a abordagem de desenvolvimento ________________________ orientada a dados. A evolução destas técnicas mostrou que tanto os dados quanto as ________________________ funções são importantes para a construção de software. Atualmente, então utilizamos ________________________ o paradigma de desenvolvimento orientado a objetos para construir nossos sistemas. ________________________ A base para a construção dos programas orientados a objetos está nos conceitos de ________________________ classes e objetos, conforme descrito a seguir.

Programação Orientada a Objetos (POO) é um paradigma de programação de computadores onde se usam classes e objetos, criados a partir dos modelos para representar e processar dados usando programas de computadores (SANTOS, 2003, p.1).

Na definição de Santos descrita anteriormente destacamos três conceitos fundamentais para o entendimento de POO. De acordo com esta definição, as classes e objetos são criados a partir de modelos. Então, iniciaremos nosso aprendizado de POO entendendo o conceito de modelos para, em seguida, analisarmos os conceitos de classes e objetos.

lingüagens e técnicas

de programação II

484

Modelos Os modelos existem na nossa vida há muitos anos e independem de computadores para serem utilizados. Por exemplo, considere uma pequena mercearia da década de 20 do século passado. O dono da mercearia, mesmo sem computadores, provavelmente tinha uma maneira organizada de gerenciar o seu negócio. Ele podia usar um caderno para anotar as compras realizadas por cada cliente, indicando a data da compra, o nome do cliente, os produtos e quantidades adquiridas. Com este caderno de anotações ele podia obter várias informações importantes para o seu negócio, tais como, quanto foi vendido de determinado produto em um mês, quantos clientes compraram em um determinado dia, etc. É claro que o volume de cliente e de vendas que existia naquela época permitia que o negócio fosse controlado desta forma. Esta representação utilizada para controlar as vendas é um exemplo de modelo utilizado com sucesso. Modelos são representações simplificadas de objetos, pessoas, itens, processos, conceitos, idéias, etc. usados comumente por pessoas no seu dia-a-dia, independente do uso de computadores. (SANTOS, 2003, p.2)

Ainda hoje podemos observar no nosso cotidiano exemplos de modelos não informatizados que são utilizados com sucesso para controlar empresas.

Vamos considerar, por exemplo, uma empresa de venda de alimentos, um restaurante a quilo, conhecido e frequentado por muitas pessoas. Quando chegamos a um restaurante a quilo, geralmente encontramos um funcionário na porta do restaurante distribuindo uma comanda a cada cliente que entra no restaurante. Esta comanda representa um modelo de controle do consumo de um cliente do restaurante (figura 1). Figura 1: Modelo de conta do restaurante a quilo

Fonte: Autoria própria

tes para controle do consumo dos clientes: um número de identificação sequencial, para evitar fraudes ou extravios de comandas pelos funcionários; a data do consumo; os diversos itens que serão controlados; a forma de pagamento e o total da conta. Todas as vezes que um cliente consome algum item do restaurante, este é registrado na sua comanda. Ao final da refeição, o cliente se dirige ao caixa com a sua

485 de programação II

Observe que o proprietário do restaurante definiu os seguintes dados como relevan-

lingüagens e técnicas

A figura 1 ilustra um exemplo simples de comanda para conta do restaurante.

comanda e paga a conta. Facilmente, o funcionário do restaurante consegue calcular o valor total da conta baseado nos dados de consumo preenchidos na comanda. Mais tarde, esta mesma comanda pode ser utilizada para calcular o consumo de refrigerantes de um determinado dia, a quantidade de clientes que frequentaram o restaurante, qual a média de consumo de um cliente, qual o dia da semana que se vende mais sobremesas, entre outras informações relevantes para que o proprietário do restaurante possa controlar o seu negócio. Desta forma, podemos perceber que para a elaboração da comanda, dois aspectos foram considerados: quais os dados que precisam ser guardados sobre o consumo de um cliente (ex. quantidade de refrigerantes consumidos) e quais as operações que precisam ser realizadas sobre estes dados para controlar o restaurante (ex. calcular total da conta). Assim, modelos são especificados a partir da definição dos seus dados e operações. É possível termos modelos que contenham apenas dados e modelos que contenham apenas operações, embora estes casos sejam mais raros. Indo um pouco mais além na definição de modelos, podemos dizer que modelos podem ser compostos por outros modelos. Vamos evoluir o nosso restaurante para um restaurante convencional, com mesas, garçons, etc. Aquele modelo de comanda ilustrado na figura 1 agora será utilizado para controlar o consumo de uma mesa. Desta forma, supondo que temos quatro mesas no restaurante, podemos usar um quadro para representar cada uma delas e suas respectivas contas, conforme ilustrado na figura 2. O modelo das mesas do restaurante é composto pelo modelo das contas de cada mesa e pode ter seus próprios dados e operações associados. Por exemplo, podemos definir uma operação para calcular o faturamento do restaurante considerando todas as mesas. Modelos devem ser criados de acordo com a necessidade de controle do negócio em que estão inseridos. Muitas vezes criamos modelos que representam simplificações do mundo real, pois não precisamos carregar o modelo com detalhes que não sejam relevantes para o nosso negócio. Por exemplo, no modelo da comanda do restaurante a quilo, não colocamos o tipo de cartão de crédito utilizado pelo cliente para pagamento da conta, pois este dado não era relevante para o restaurante, embora seja um dado real. Modelos também podem ser reutilizados em outros contextos. Por exemplo, o modelo da comanda poderia ser reaproveitado para o nosso restaurante convencional.

486 lingüagens e técnicas

de programação II

Figura 2: Modelo das mesas e contas de um restaurante convencional

Fonte: Autoria própria

Representação de modelos

Modelos podem ser representados através de pseudocódigo. Vamos considerar um exemplo de modelo para controlar contas bancárias. Considere que uma conta bancária precisa ter os seguintes dados: cpf do correntista, número da conta e saldo. Considere, também, que é possível fazermos as seguintes operações em uma conta bancária: abrir uma conta, depositar dinheiro, sacar dinheiro e consultar o saldo da conta.

487 lingüagens e técnicas

de programação II

Figura 3: Pseudocódigo para o modelo de uma conta bancária

Fonte: Adaptado de Santos (2003, p. 9)

A figura 3 ilustra o pseudocódigo criado para representar a nossa conta bancária. Todo modelo começa com a indicação modelo <nome do modelo>. Em seguida, temos que delimitar o código do modelo usando a indicação de início e o fim do modelo. A codificação do modelo está dividida em partes. Primeiramente, devemos definir todos os dados que compõem o modelo. Em seguida, definimos cada uma das operações. Estas operações podem ser definidas em qualquer ordem, mas não podemos ter uma operação dentro de outra operação. Na figura 3, observamos a definição dos dados logo após o início do modelo. Em seguida foram definidas cinco operações:

abreConta(cpf, deposito, numero), usada quando o cliente deseja abrir uma conta e

de programação II

tado;

lingüagens e técnicas

488

já depositar um valor nesta conta, neste caso o saldo é inicializado com o valor deposi-

abreConta(cpf, numero), usada quando o cliente deseja abrir uma conta sem depositar nenhum valor nela, neste caso o saldo é inicializado com 0; deposita(valor), usada quando o cliente deseja depositar um valor qualquer na conta. Neste caso o saldo é atualizado incrementado o valor informado; retira(valor), usado quando o cliente deseja retirar um valor qualquer da conta. Só é possível efetuar a retirada se houver saldo. Neste caso o saldo é atualizado decrementando-se o valor retirado; consultaSaldo(), usado para imprimir o saldo atual do cliente.

Observe que cada uma das operações também é delimitada com um início e fim. Estas operações podem ou não receber argumentos, dados entre parênteses especificados ao lado do nome da operação. Argumentos são especificados quando precisamos informar algum dado para ser utilizado no processamento da operação. Por exemplo, para retirar um valor da nossa conta, precisamos informar qual o valor que queremos retirar.

Encapsulamento

Às vezes, precisamos proteger o acesso aos dados do nosso modelo para que eles não possam ser manipulados diretamente, mas apenas através de operações escritas especialmente para este fim. Por exemplo, a atualização do saldo da nossa conta bancária não pode ser feita diretamente no campo saldo por qualquer pessoa. Precisamos de uma operação que cheque se existe saldo antes de atualizá-lo e que não permita a existência de valores negativos para este tipo de dado. Muitas vezes, também, precisamos esconder do resto das aplicações os detalhes de funcionamento de determinadas operações de um modelo. Quem utiliza o modelo, precisa ter conhecimento apenas dos serviços que ele oferece, não precisa saber como este serviço é processado internamente. A capacidade de ocultar dados dentro dos modelos, permitindo que somente operações especializadas ou dedicadas manipulem os dados ocultos chama-se encapsulamento; Encapsulamento é um dos benefícios mais palpáveis da POO. (SANTOS, 2003, p.5)

Por exemplo, quando estamos com dor de cabeça e tomamos um comprimido de analgésico, não precisamos saber como aquele comprimido vai agir no nosso organismo. Precisamos saber que ele tem o serviço de analgésico de que necessitamos. Vamos analisar, agora, o conceito de encapsulamento no nosso exemplo de conta bancária. Imagine que você precisa construir um sistema para pagamento da mensalidade da faculdade. O seu sistema receberá o número da conta, a agência, o

pode ter conta em um banco diferente, teremos que nos comunicar com os diversos bancos existentes no país para fazermos as operações de retirada e depósito. Agora imagine se estes bancos disponibilizassem os dados de Saldo da conta do aluno para ser acessado e atualizado diretamente por você. É visível a quantidade de problemas que podemos ter com esta prática:

489 de programação II

depositar este valor na conta da faculdade. Considerando que cada aluno da faculdade

lingüagens e técnicas

banco e a senha do aluno e deverá retirar o valor da mensalidade da conta do aluno e

Podemos atualizar erroneamente o valor do saldo na conta do aluno ou da faculdade; Programadores de outras empresas podem querer fazer a mesma operação que você, e o banco perderá o controle da segurança de seus dados se permitir acesso por todos estes programadores; Você precisará conhecer a rotina de trabalho de cada banco para retirada de valores de uma conta. Por exemplo, é preciso verificar se tem saldo ou não? Existem contas especiais? Posso fazer a retirada de contas de aplicação caso a conta corrente não tenha saldo? Quando o banco modificar a sua rotina de trabalho, terá que notificar todos os programadores que acessam os dados para que estes façam manutenção nos seus sistemas; Etc.

________________________

Podemos observar, pelos itens listados acima, que não seria uma tarefa fácil ________________________ construir o nosso sistema de pagamento de mensalidade. O encapsulamento resol- ________________________ ve este problema. Neste caso, cada banco é responsável por criar seus modelos de ________________________ conta encapsulados e disponibilizar os serviços necessários para que programadores ________________________ externos possam acessá-los e utilizá-los sem precisar ter conhecimento das rotinas do ________________________ banco. Assim, você poderá solicitar ao modelo de conta do banco que faça uma retira- ________________________ da da conta do aluno, informando os dados necessários e o valor. O modelo do banco ________________________ deverá processar esta solicitação e mandar uma resposta indicando se a transação foi ________________________ efetuada ou não. Para você não importa saber como ele fez este processamento, mas ________________________ sim se este foi executado com sucesso ou não. ________________________

Classes e objetos Voltando a nossa definição inicial de POO, vimos que classes e objetos são criados a partir de modelos. Mas, então, o que são classes e objetos? Para Santos (2003, p.14) “classes são estruturas das linguagens POO para conter, para determinado modelo, os dados e as operações que devem ser efetuadas nos dados.” As classes são definidas em uma linguagenm de programação. Neste curso, utilizaremos a linguagem Java para definir as nossas classes. Cada classe deve conter um nome, deve definir os dados e as operações que deverão processar estes dados.

lingüagens e técnicas

de programação II

490

Na POO, chamados de atributos os dados da classe e de métodos as operações definidas para a classe. No nosso exemplo de modelo de conta bancária, poderíamos criar uma classe também chamada ContaBancaria com os atributos cpfDoCorrentista, saldo e numeroDaConta e os métodos abreConta(cpf, deposito, numero); abreConta(cpf,numero),depos ita(valor), retina(valor) e consultaSaldo(). Classes podem ser representadas, visualmente, através de uma linguagem unificada de modelagem (UML), conforme ilustrado na figura 4 a seguir.

Figura 4: representação da classe contaBancaria em UML

________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ Fonte: Autoria própria ________________________ ________________________ A representação da classe em UML é feita em um retângulo com três partes. Na ________________________ ________________________ primeira delas, colocamos o nome da classe, na segunda, os atributos e na terceira, os ________________________ métodos. ________________________ Existe uma convenção para nomear classes, atributos e métodos que segue a ________________________ regra: ________________________ ________________________ ________________________ Nomes de classes devem iniciar sempre com letras maiúsculas seguidos de letras mi________________________ núsculas. Cada nova palavra inicia-se sempre com letras maiúsculas. Ex.: ContaBancaria; ________________________ Nomes de atributos devem iniciar sempre com letras minúsculas. Cada nova palavra ________________________ inicia-se sempre com letras maiúsculas. Ex.: cpfDoCorrentista; ________________________ Nomes de métodos seguem a mesma regra dos nomes de atributos. ________________________ ________________________ Um programa orientado a objetos então é formado por um conjunto das clas-

“Um objeto ou instância é a materialização da classe”. No nosso exemplo de conta bancária, cada vez que um novo correntista abre uma conta no banco, um novo objeto é instanciado na memória a partir da classe ContaBancaria.

de programação II

Agora precisamos entender o que é um objeto. Segundo Santos (2003, p.15),

491 lingüagens e técnicas

ses necessárias para modelar o negócio do sistema.

Objetos são instanciados sempre a partir de uma classe. O conjunto de todos os objetos instanciados da mesma classe terá a mesma definição de atributos e métodos, ou seja, a classe serve de forma, de padrão para a criação de objetos. Objetos possuem identidade própria. Isso significa dizer que eles são únicos dentro de um sistema. Por exemplo, no nosso restaurante a quilo podemos dizer que o modelo da conta do cliente será a nossa classe e que cada vez que um cliente entra no restaurante, um novo objeto conta é instanciado a partir desta classe. Mesmo que um cliente vá duas vezes ao restaurante no mesmo dia e tenha exatamente o mesmo consumo, serão duas contas diferentes e, portanto, dois objetos diferentes. Para instanciarmos um objeto precisamos utilizar uma referência. Referências são variáveis que definimos no nosso programa, utilizando a classe como tipo de dado. Podemos resumir, então, da seguinte maneira para o nosso exemplo de restaurante a quilo:

Classe: Conta; Objeto: dados do consumo de um cliente de acordo com as definições da classe Conta; Referencia: variável conta1, do tipo Conta, criada no programa para acessar os dados do objeto.

Em um sistema orientado a objetos, então, temos diversas classes nas quais são instanciados objetos. Esses objetos podem se comunicar através de mensagens. Quando um objeto envia uma mensagem para ele mesmo ou para outro objeto ele está solicitando que este objeto execute determinado método.

Outros exemplos de classes Nesta seção, vamos ilustrar um exemplo de sistema modelado com diversas classes. Considere a definição de sistema a seguir: Uma faculdade precisa construir um sistema para controlar a reserva de laboratórios de informática. A faculdade possui um nome, um CNJP e vários laboratórios. Cada laboratório é identificado por um número, possui uma capacidade, uma lista com o nome de cada software disponível no laboratório e uma lista de reservas já efetuadas para o laboratório. Cada reserva é feita em

lingüagens e técnicas

de programação II

492

uma data, para um turno específico (matutino, vespertino ou noturno) e deve conter o nome do professor que solicitou a reserva. Os professores devem ser mantidos pelo sistema informando a sua matrícula, nome, email e telefone. O primeiro passo para construirmos um sistema que atenda a este cenário é identificarmos quais as classes que precisam ser criadas para atender às necessidades da faculdade. Para tanto, devemos analisar o cenário descrito e extrair dele os conceitos relevantes para o nosso sistema, ou seja, quais os conceitos que demandam a identificação de dados e operações. Estes conceitos são grandes candidatos a se tornarem classes. Para cada uma destas classes mapeamos então os atributos (dados) e os métodos (operações) necessários. A figura 5 ilustra, usando a representação de classes da UML, as classes necessárias para o nosso sistema.

Figura 5: Classes do sistema de Faculdade na linguagem UML

Fonte: Autoria própria

Quatro classes foram identificadas para o sistema da faculdade. A classe Faculdade contém os atributos necessários para identificar a faculdade, por exemplo, o nome da faculdade, o cnpj e a lista dos laboratórios existentes na faculdade, e os métodos necessários para criar uma nova faculdade e adicionar um novo laboratório à faculdade. Observe que uma faculdade pode conter diversos laboratórios, ou seja, temos um modelo composto por outro modelo.

identificado por um número e tem uma capacidade. Da mesma maneira, podemos identificar alguns métodos, por exemplo, sempre que um software é instalado neste laboratório, usamos o método adicionarSoftware para incluí-lo no laboratório. Analogamente, reservas podem ser agendadas para o laboratório através do método adicionarReserva.

493 de programação II

atributos e métodos associados a ele. Por exemplo, todo laboratório da faculdade é

lingüagens e técnicas

Laboratório também é um conceito importante para o sistema, pois contém

A classe Reserva também foi criada para o sistema, pois precisamos guardar os dados de cada uma das reservas, tais como, a data da reserva, o turno reservado e o professor que solicitou a reserva. Alguns métodos também podem ser modelados para esta classe, por exemplo, verificar se uma reserva foi feita em nome de um professor através do método verificarReservas e podemos verificar qual o turno que um professor fez a sua reserva através do método verificarTurno. Finalmente, modelamos a classe Professor para manter o cadastro de professores da faculdade. Uma vez definidas estas classes em uma linguagem de programação (ex. Java), podemos instanciar nossos objetos. Para o sistema de faculdade, podemos criar uma variável fac1, para fazer referência a um objeto da classe Faculdade que terá os seguintes dados: nome Unifacs; cnpj 111222. Para esta faculdade, podemos adicionar um laboratório, instanciado na variável lab1 com os seguintes dados: número 1; capacidade 30; software InternetExplorer, Firefox e netBeans. Ao longo do tempo, podemos ________________________ adicionar reservas a este laboratório, por exemplo, a reserva referenciada pela variável ________________________ res1, da classe Reserva, com os dados: dataReserva 10/06/2012; turnoReserva matuti- ________________________ no; para o professor criado a partir da classe Professor com matricula 12, nome Jose, ________________________ email jose@unifacs.br e telefone 2345-3344. Agora que já estamos entendendo os conceitos elementares de POO, classes e objetos, estamos prontos para construir o nosso primeiro programa em Java. Sendo assim, na próxima aula veremos uma introdução à linguagem Java e seus recursos básicos.

SÍNTESE Nesta aula, tivemos o primeiro contato com a abordagem de desenvolvimento orientada a objetos. Como podemos observar, a ideia central da orientação a objetos é aproveitar os conceitos que já usamos no nosso dia a dia para criar os nossos programas. Começamos, então, utilizando o conceito de modelos e vimos que este conceito já era usado há muito tempo pelas pessoas. Durante muitos anos, controlamos nossos negócios criando modelos que agregavam dados e operações em uma única estrutura. A partir dos modelos, derivamos, então, os conceitos de classe e objetos. Vimos que uma classe nada mais é do que um modelo codificado em uma linguagem de programação na abordagem de orientação a objetos, ou seja, uma estrutura que agrega atributos (dados) e métodos (operações) e que serve de molde para instanciarmos

lingüagens e técnicas

de programação II

494

objetos. Desta forma, um sistema orientado a objetos é codificado em classes. Quando o sistema é executado, objetos são instanciados de acordo com as suas respectivas classes, para que possamos guardar os dados e executar os métodos necessários para controlar nosso negócio.

QUESTÃO PARA REFLEXÃO Ao longo dos anos, tivemos várias abordagens de desenvolvimento: orientado a funções, orientado a dados, e finalmente orientado a objetos. Pesquise e analise os benefícios que a orientação a objetos pode trazer em relação às outras abordagens de desenvolvimento.

LEITURAS INDICADAS Capitulo 3 do livro de DEITEL, 2005. Capítulo 1 do livro de Rafael Santos, 2003.

________________________ ________________________ ________________________ SITES INDICADOS ________________________ ________________________ http://www.jack.eti.br/www/arquivos/apostilas/java/poo.pdf ________________________ http://www.inf.pucrs.br/flash/lapro2/lapro2_1.pdf ________________________ ________________________ ________________________ ________________________ REFERÊNCIAS ________________________ ________________________ DEITEL, H. M., DEITEL, P. J. Java: como programar. 8. ed. São Paulo: Pearson Prentice Hall, 2010.(BV) ________________________ ________________________ SANTOS, Rafael. Introdução à Programação Orientada a Objetos usando Java. São Paulo: Campus, ________________________ 2003. ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________

Na aula passada, vimos os conceitos básicos relacionados à programação orientada a objetos, os conceitos de classe e objetos. Existem muitas linguagens para construirmos programas orientados a objetos. Neste curso, utilizaremos a linguagem Java, uma das mais utilizadas atualmente nesta abordagem.

de programação II

Autora: Ana Patrícia F. Magalhães Mascarenhas

495 lingüagens e técnicas

AULA 02 - INTRODUÇÃO À LINGUAGEM JAVA

Na aula de hoje aprenderemos os elementos básicos da linguagem Java e aprenderemos a construir nossas primeiras classes e a instanciar os nossos primeiros objetos em Java.

A linguagem Java A linguagem Java surgiu de um projeto patrocinado pela Sun Microsystems em 1991, cujo objetivo era criar uma linguagem baseada na linguagem C. Inicialmente, a linguagem foi batizada como Oak (homenagem a uma árvore). No entanto já existia uma linguagem com este nome, então a equipe do projeto sugeriu o nome Java (cidade de origem de um café) que deu nome à linguagem. O Java foi formalmente publicado pela Sun em uma conferência em 1995 e se tornou interessante pela sua aplicabilidade em sistemas para Web. Atualmente, é utilizado para desenvolver grandes softwares corporativos (DEITEL, 2010). Para criarmos um programa em Java, podemos usar um editor de texto qualquer, digitar o nosso programa e salvá-lo com a extensão .java. O Java é uma linguagem de alto nível, ou seja, utiliza comandos mais próximos da nossa linguagem natural. No entanto, os computadores não entendem esta linguagem, eles entendem a linguagem de máquina. Sendo assim, após digitarmos o nosso programa em Java precisamos passar por um processo de tradução desta linguagem para uma linguagem de máquina, para que somente então ele possa ser executado. O primeiro passo neste processo de tradução é a compilação do nosso programa fonte (.java) em bytecode (com extensão .class). Quando fazemos isso, o Java analisa o programa que nós escrevemos e verifica se há algum erro em relação às construções definidas para a linguagem. Verifica se as palavras reservadas estão sintaticamente corretas e verifica se a semântica das nossas construções está de acordo com o definido pela linguagem. O Java trabalha com um conceito de máquina virtual, a virtual machine (VM). A VM é responsável por fazer uma ponte entre o nosso bytecode e a máquina onde o sistema está sendo executado. Desta forma, no momento em que executamos o nosso programa, ele é traduzido para a linguagem de máquina de acordo com a plataforma que estivermos usando. Essa característica fornece aos programas Java uma grande vantagem que é a portabilidade, ou seja, se a VM for implementada em várias plataformas, os programas Java podem ser construídos e executados também em várias plataformas. A figura 1 ilustra os passos para construirmos, compilarmos e executarmos um programa em java.

496 lingüagens e técnicas

de programação II

Figura 1: Processo de construção de um programa em Java

Fonte: Adaptado de Deitel (2010)

Inicialmente editamos o programa em um editor de texto qualquer e salvamos o código fonte, na figura Aula2.java. Em seguida compilamos o programa gerando o

bytecode Aula2.class. Para executar o programa, usamos a máquina virtual.

Classes em Java Na aula passada vimos que um programa Java nada mais é do que um conjunto de classes, definidas na linguagem Java, a partir das quais instanciamos objetos. Cada objeto contém os seus dados e pode executar métodos dele mesmo ou de outros objetos através do envio de mensagens. A definição de uma classe segue a mesma estrutura que utilizamos para definir os modelos em pseudo-código na aula passada. Podemos recordar que para cada modelo dávamos um nome e definíamos seus dados e operações. Analogamente, para cada classe, damos um nome, definimos seus atributos e em seguida os seus métodos. Para criarmos uma classe em Java utilizamos a palavra-chave class seguida do nome da classe. O nome da classe é definido por nós de acordo com as seguintes regras:

O nome não pode conter espaços Deve começar com uma letra Deve ser diferente das palavras reservadas Caracteres maiúsculos e minúsculos são diferenciados

Atenção: a linguagem Java é sensível ao contexto, ou seja, faz distinção entre palavras maiúsculas e minúsculas. Desta forma, devemos sempre escrever as palavras da mesma maneira ao longo do nosso programa. Por exemplo, se definirmos uma classe chamada Aluno, não podemos, em outro momento, instanciar um objeto da classe aluno, pois esta última não existe.

497 de programação II

código que define a classe.

lingüagens e técnicas

O Conteúdo da classe é limitado por chaves { } que indicam o início e o final do

Voltando à definição de classes, vimos que uma classe é uma estrutura que agrega atributos (dados) e métodos (operações) e serve como modelo para criação dos objetos do nosso sistema.

Definição de Atributos em Java

Os atributos de uma classe são definidos em Java dentro do corpo da classe. Cada atributo deve ser representado por um determinado tipo de dado. Em linguagens POO, é possível declarar atributos como referências (variáveis) a instâncias de outras classes já existentes. Isso significa dizer que quando criamos uma classe ela fica disponível para ser utilizada como se fosse um tipo de dado. Assim, podemos declarar atributos ou variáveis cujo tipo seja outra classe.

Tipos de dados em Java A linguagem Java provê os seguintes tipos de dados primitivos, divididos em quatro grandes categorias:

Inteiros, representa os números inteiros positivos e negativos. Na sintaxe Java temos as seguintes variações para este tipo: byte (8 bits), short (16 bits), int (32 bits) e long (64 bits); Floating Point, números reais positivos e negativos. Na sintaxe Java temos os seguintes variações para este tipo: float (32 bits) e double (64 bits); Character, representa um único caracter alfa numérco. Na linguagem Java é representado pelo tipo char (16 bits) Boolean, para valores booleanos. Na linguagem Java é representado pelo tipo boolean

Atenção: O String, tipo muito comum em outras linguagens de programação para representar uma sequência de caracteres alfa numéricos, não é um tipo nativo da linguagem Java. O String na linguagem Java é uma classe usada para representar cadeias de caracteres. Sendo assim, quando definimos um atributo ou variável do tipo String, estamos usando uma instância de um objeto da classe String.

Criação de métodos em Java

de programação II

As classes são formadas por métodos e atributos (vimos anteriormente como

lingüagens e técnicas

498

declará-los). Os métodos devem ser criados dentro da classe a que eles pertencem, em geral após a declaração dos atributos. Não podemos criar um método dentro de outro método. A figura 2, a seguir, ilustra o exemplo de uma classe em Java chamada Pessoa. Esta classe guarda os dados de uma pessoa: nome e ano de nascimento. Para isso, foram criados dois atributos, um do tipo String para chamado nome e um do tipo int chamado anoNascimento respectivamente. A classe possui também três métodos: um para inicializar os atributos da classe, o método inicializaDados; um para calcular a idade de uma pessoa, o método calculaIdade; e um para imprimir os dados de uma pessoa, o método imprimir.

Figura 2: Classe em Java para representar uma pessoa

Fonte: Autoria própria

Métodos podem ser executados e retornar um valor como resposta ou podem ser executados e não retornar nenhum valor como resposta para quem o chamou.

após a execução, usamos a palavra void antes do nome do método. Na figura 2, temos exemplos destas duas situações. O método calculaIdade retorna como resposta da execução o total de anos referente à idade da pessoa. Assim, na sua declaração é indicado o retorno do tipo int. No corpo do método, o retorno é feito através da palavra reservada return. Os métodos inicializaDados e imprimir não possuem retorno, então usam a palavra void.

499 de programação II

ração qual o tipo de dado que será retornado. Quando o método não retorna nada

lingüagens e técnicas

Quando o método fornece um retorno da execução, precisamos indicar na sua decla-

Métodos também podem receber ou não argumentos para sua execução. Argumentos são definidos com uma lista de variáveis separadas por vírgula e entre parênteses logo após o nome do método. Por exemplo, o método inicializaDados recebe 2 argumentos (String n, int a), o primeiro receberá o nome da pessoa e o segundo o ano de nascimento. Uma classe pode ter diversos métodos, mas não pode ter um método dentro de outro método. Desta forma, a declaração de cada método é composta por: uma assinatura, que corresponde ao cabeçalho do método e compreende o tipo de retorno, o nome do método e os argumentos, se existir; e o corpo do método, também delimitado pelos caracteres { }. Somente quando um método é finalizado, podemos começar a escrever o método seguinte. Esses métodos podem ser escritos em qualquer ordem dentro da classe. No exemplo ilustrado na figura 2, colocamos primeiro o método inicializaDados, depois o método calculaIdade e por último o método imprimir. Porém, estes métodos poderiam ter sido organizados em outra ordem qualquer se assim desejássemos. Um método pode conter uma chamada a outro método. Observe que no exemplo da figura 2, o método imprimir faz uma chamada ao método calculaIdade. Esse tipo de construção indica que, no momento da execução do método imprimir, o programa manda uma mensagem para o método calculaIdade, que calcula a idade da pessoa e retorna o valor como resposta. O valor retornado é impresso na tela.

Saída de dados no Java

A saída de dados no Java é realizada a partir da seguinte sentença: System.out.println (valor a ser impresso); O argumento informado para ser impresso pode ser uma variável, um texto (entre aspas duplas) ou a combinação destes, como pode ser visto no método imprimir ilustrado na figura 2.

Escopo de atributos e variáveis em Java

O escopo dos atributos e variáveis definidos em uma classe pode variar a de-

lingüagens e técnicas

de programação II

500

pender de onde é feita a sua definição. Os atributos definidos para uma classe estão visíveis em qualquer método desta classe. No exemplo da figura 2, o atributo nome foi acessado pelo método inicializaDados e pelo método imprimir. As variáveis e os argumentos definidos em um método só são visíveis (só podem ser acessados) ao próprio método. Na figura 2, os argumentos definidos para o método inicializaDados (String n e int a) só podem ser utilizados dentro do método onde foram definidos. O mesmo acontece com a variável int idade definida dentro do método calculaIdade, só pode ser utilizada dentro deste método.

Modificadores de acesso

Uma vantagem do paradigma OO é a possibilidade de encapsular os campos e métodos de uma classe. É desejável que os campos das classes sejam ocultos. Até agora demonstramos o encapsulamento, mas sem colocar os dados ocultos. Por exemplo, na classe Pessoa não podemos garantir que o ano de nascimento informado seja um ano válido. O usu-

ário poderia digitar, por exemplo, um ano negativo, pois o atributo foi definido como int, que aceita números negativos. Java permite a restrição ao acesso de atributos em métodos por intermédio de modificadores de acesso que são declarados dentro das classes. Existem três modificadores de acesso:

Public, garante que o atributo ou método da classe declarado com este modificador poderá ser acessado ou executado a partir de qualquer outra classe; Private, só pode ser acessado, modificado ou executado por métodos da mesma classe, sendo oculto para o programador usuário que for usar instâncias desta classe ou criar classes herdeiras ou derivado (veremos estes tipos de classes nas próximas aulas); protected: funciona como o modificador private, exceto que classes herdeiras ou derivadas também terão acesso ao campo ou método.

Atributos e métodos podem ser declarados sem modificadores. Nesse caso, eles serão considerados como pertencentes à categoria package, significando que seus campos e métodos serão visíveis para todas as classes de um mesmo pacote ou package (veremos a definição de package nas próximas aulas). Ao criarmos nossas classes, devemos nos preocupar com a ocultação dos atributos e métodos. Para tanto, algumas orientações devem ser seguidas:

Todo atributo deve ser declarado como private ou protected.

Métodos para controle dos atributos devem ser escritos, e estes métodos devem ter o modificador public. Se for desejável, métodos podem ser declarados como private.

501 de programação II

Caso classes não venham a ser agrupadas em pacotes, a omissão não gera problemas.

lingüagens e técnicas

Métodos que devem ser acessíveis devem ser declarados com o modificador public.

Por exemplo, na classe Pessoa, devemos criar todos os atributos com o modificador private. Assim, temos um canal único de acesso para consulta e atualização dos dados que serão mantidos por cada um destes atributos. Convencionou-se criar estes métodos da seguinte maneira:

Para

consultar

dado

guardado

atributo,

utiliza-se

prefixo

get+nomeDoAtributo; Para atualizar o dado no atributo, utiliza-se prefixo set+nomeDoAtributo.

Desta forma, teremos, então, na classe Pessoa, mais quatro método: getNome e getDataNascimento, para consultar os dados; e setNome e setDataNascimento para atualizar os dados. Assim, no método setDataNascimento poderemos testar se o ano

________________________ ________________________ ________________________ ________________________ ________________________ Operações com a linguagem java ________________________ As operações básicas que podem ser feitas com os tipos numéricos da lingua- ________________________ ________________________ gem Java são: ________________________ ________________________ ________________________ + Soma ________________________ - Subtração ________________________ / Divisão ________________________ ________________________ * Multiplicação ________________________ % Módulo (resto da divisão) ________________________ ________________________ ________________________ Valores numéricos podem ser comparados com operadores que retornam um ________________________ valor do tipo boolean. Os operadores são: ________________________ ________________________ ________________________ < (menor) ________________________ ________________________ > (maior) informado é maior que 0 e evitar que o usuário digite um número negativo.

<= (menor ou igual)

de programação II

>= (maior ou igual)

lingüagens e técnicas

502

== (igual) != (diferente)

Strings não podem ser comparados com os operadores >, <, ==, pois não são um tipo nativo da linguagem Java. Para comparar se duas variáveis do tipo String são iguais, utilizamos o método equals da classe String. O exemplo a seguir compara se a variável nome do tipo String contém o valor “Maria”. Caso seja verdadeira, a comparação retornará o valor true, caso contrário, retornará o valor false.

Ex.: if (nome.equals(“Maria”))

Valores booleanos podem ser combinados com três operadores lógicos. Que são:

&& (E lógico) ________________________ ________________________ || (OU lógico) ________________________ ! (NÃO lógico) ________________________ ________________________ ________________________ O E lógico será verdadeiro se todas as expressões envolvidas forem verdadeiras. ________________________ ________________________ Por exemplo, na seguinte condição: ________________________ ________________________ If ((nota>=4) && (nota<=6) ________________________ ________________________ ________________________ A condição anterior será verdadeira se a nota estiver no intervalo entre 4 e 6. ________________________ ________________________ O OU lógico será verdadeiro se pelo menos uma expressão for verdadeira. Por ________________________ exemplo, na seguinte condição: ________________________ ________________________ ________________________ If ((nota1>=6) || (nota2>=6)) ________________________ ________________________ ________________________ A condição anterior será verdadeira se pelo menos um das duas notas avaliadas ________________________ for maior ou igual a 6. ________________________ ________________________

Desta forma, para compararmos se duas variáveis do tipo String são diferentes, usamos o operador de negação conforme ilustrado no exemplo abaixo:

if ! (nome.equals(“Maria”))

503 de programação II

resultado for true, o NÃO transforma em false e vice-versa.

lingüagens e técnicas

O NÃO lógico inverte o resultado avaliado pela expressão testada, ou seja, se o

Para efetuarmos uma operação de concatenação entre duas variáveis do tipo String, usamos o sinal +. Na nossa classe Pessoa, o método imprimir ilustra um exemplo de concatenação:

System.out.println(“ola ”+ nome + “ sua idade é: “ + calcularIdade(anoAtual));

Criando nossa primeira classe em java Agora que já temos um conhecimento básico em linguagem Java e em POO vamos criar e executar a nossa primeira classe. Para isso, utilizaremos neste início do ________________________ curso um software chamado BlueJ. Este software foi projetado e construído para ser ________________________ utilizado no aprendizado de POO com Java. Trata-se de um software que permite edi- ________________________ tar, compilar e executar facilmente seus primeiros programas Java. Você poderá baixá- ________________________ lo gratuitamente através do site www.blueJ.org. Para executá-lo, também será neces- ________________________ sário baixar o Java developmet kit (JDK) na versão mais atual, que é gratuita e pode ser ________________________ facilmente encontrada na web. Se desejar, você pode optar também por usar outra ________________________ IDE Java qualquer, como, por exemplo, o Netbeans ou o Eclipse. Não importa qual o ________________________ software de desenvolvimento que você vai utilizar para construir o seu programa, o ________________________ código fonte que vamos construir será o mesmo.

Para ilustrar a nossa primeira classe. Vamos supor que precisamos construir um sistema para controle de contas de um banco. Neste sistema vamos cadastrar todas as contas com numero da agencia, numero da conta, o dígito verificador da conta e o saldo da conta. Será possível efetuar saque e deposito de uma conta.

Como dito anteriormente para facilitar a edição e execução dos nossos programas nesta fase inicial utilizaremos a ferramenta BlueJ. O próximo passo então na criação do nosso sistema bancário será acessar o blueJ e criar um novo projeto (menu Project -> New Project). A figura 3 ilustra a tela principal do BlueJ com o projeto SistemaBancario criado.

Figura 3: Tela principal do BlueJ

lingüagens e técnicas

de programação II

504

Fonte: Autoria própria

Para o nosso sistema bancário, será criada a classe Conta. Assim, após criar o projeto, utilize a barra de ferramentas do lado esquerdo para selecionar o botão new class. Coloque o nome da nossa primeira classe, Conta, e selecione ok. Será criado na área central do BlueJ (figura 3A) um retângulo com o nome da classe Conta. A área representada na figura 3B será mais tarde utilizada para execução do nosso programa. Para digitarmos o código referente à nossa classe, basta clicar duas vezes no retângulo que representa a nossa classe Conta. O BlueJ abre uma tela de edição da classe (figura 4) com um código-fonte de exemplo. Você pode apagar este código de

exemplo, pois vamos criar nosso próprio código. O BlueJ disponibiliza uma área central para edição do código-fonte; um menu de opções; e uma barra de ferramentas. Na barra de ferramentas, temos a opção Compile, para compilar o nosso código-fonte gerando o bytecode. Caso seja detectado algum erro durante a compilação, o erro será apresentado em uma mensagem na base da tela. Caso contrário, a mensagem “Class compiled - no systax errors” aparecerá indicando que não há erros na compilação. Observe que ao longo da edição do texto palavras reservadas são coloridas de vermelho, modificadores de acesso de rosa e comentários de cinza. Figura 4: Tela de edição da classe

Fonte: Autoria própria

As primeiras duas linhas apresentam um comentário sobre o programa. Comentários em Java podem ser escritos usando o delimitador /* comentário com mais de uma linha */, para comentários com mais de uma linha; ou usando as barras // para comentários com apenas uma linha (como é apresentado na linha 5 da figura 5).

505 de programação II

código fonte linha a linha.

lingüagens e técnicas

A figura 5 ilustra o código fonte completo da classe Conta. Vamos analisar este

Em seguida, temos a declaração da classe class Conta. Lembre que por convenção os nomes de classes devem iniciar com letras maiúsculas. Toda classe é delimitada pelos caracteres { } que indicam início e fim respectivamente (linhas 4 e 52 ).

A primeira coisa que declaramos no corpo da classe são os atributos. Verifique que devemos declarar estes atributos com o modificador private, para preservar o encapsulamento, e escrever métodos de acesso (get e set) para cada um destes atributos. Nas linhas 7 e 8, temos a declaração dos atributos da classe Conta. Nas linhas 27 a 51, podemos observar os métodos get e set construídos para cada um dos atributos.

________________________

Métodos set são responsáveis por atualizar os dados do atributo. Portanto, re- ________________________ cebem um argumento, que indica o novo valor do atributo, e, em geral, não retornam ________________________ nada (são declarados como void). No corpo destes métodos, devemos nos preocupar ________________________ em fazer as validações necessárias para manter o valor do nosso atributo integro. Por ________________________ exemplo, na nossa classe Conta, o atributo numeroConta deve ser um número inteiro ________________________ entre 0 e 1000. Esta checagem pode ser vista no método setNumeroConta (linhas 27 ________________________ a 30).

Métodos get são responsáveis pela consulta ao valor do atributo. Portanto, não recebem nenhum argumento, mas retornam o valor consultado. Nestes métodos, podemos colocar qualquer tipo de tratamento que deverá ser dado ao atributo antes de ser disponibilizado para outros. Por exemplo, observe que no método getNumeroConta, em vez de retornar apenas o número da conta, foi retornado uma String contendo o número da conta concatenado com um ponto, concatenado com o dígito verificador da conta. Quem solicita da classe Conta o número de uma conta qualquer não sabe que internamente este número está separado em dois atributos: número e digito. Essa característica está encapsulada na classe.

Figura 5: Código-fonte da classe Conta

lingüagens e técnicas

de programação II

506

Fonte: Autoria própria

Para a classe Conta também foram definidos mais dois métodos: depositar e saque. O método depositar recebe como argumento um valor e o deposita na conta (linha 15), ou seja, “seta” o saldo adicionando a este o valor informado. Nenhuma informação é retornada após a execução deste método, ou seja, o método é declarado

como void. O método saque faz uma retirada da conta (linha 19). Para isso, recebe um valor como argumento e verifica se existe saldo para retirar este valor (linha 20). Em caso afirmativo, atualiza o saldo e retorna true, indicando que o saque foi efetuado. Caso não haja saldo (linha 25), retorna false, indicando que o saque não foi efetuado.

Agora que já criamos a nossa classe, vamos fazer o primeiro teste. Feche a janela de edição da classe (botão close) e volte à janela principal do blueJ, certificando-se de que sua classe foi compilada com sucesso. É muito simples testarmos uma classe usando o blueJ. Como vimos no início do curso, classes são utilizadas para instanciar objetos. Assim, para executarmos o nosso programa, vamos ter que criar objetos desta classe, colocando os valores que desejarmos para as contas, para somente depois executarmos os métodos que vão processar esses valores.

Na tela principal do BlueJ, clique com o botão direito do mouse sobre a classe Conta e selecione a opção new Conta() para criarmos uma nova conta. Neste momento, estamos instanciando um objeto da nossa classe conta. Inicialmente, todos os dados da conta estão zerados. Como vimos na aula 1, para instanciarmos um objeto, precisamos criar uma variável que fará referência a este objeto. O blueJ então solicita que nos informemos o nome da nossa variável que vai fazer referencia à conta que estamos criando. A figura 6 ilustra esses passos.

507 lingüagens e técnicas

de programação II

Figura 6: Execução da classe Conta

Fonte: Autoria própria

Uma vez instanciado o objeto, o mesmo é apresentado na base da tela do BlueJ como um retângulo vermelho. Podemos agora executar qualquer método desta classe clicando com o botão direito do mouse sobre o objeto vermelho e escolhendo o método a ser executado. A figura 7 mostra o nosso objeto conta1 criado e a lista de métodos disponíveis para serem executados (métodos definidos com o modificador public).

Figura 7: Lista de métodos disponíveis na para o objeto instanciado da classe conta

Fonte: Autoria própria

Supondo que desejamos executar o método criarConta responsável por inicializar os dados da conta. Como este método recebe argumentos, é apresentada uma tela para que os valores de cada argumento sejam informados (figura 8A). Atenção: Para valores do tipo String, devemos informar o dado entre aspas duplas “”. Para valores do tipo char, devemos informar o dado entre aspas simples ‘ ‘. Para valores do tipo float, devemos utilizar o ponto como separador decimal e colocar um caractere f no final do número, ex. 10.45f. Uma vez digitados os dados, eles ficam armazenados no nosso objeto. O BlueJ permite visualizar os dados de um objeto em uma tela (figura 8B) através de um duplo clique no objeto instanciado.

508 lingüagens e técnicas

de programação II

Figura 8: Classe em Java para representar uma pessoa

Fonte: Autoria própria

Os conceitos vistos nesta aula foram apenas o início do que precisaremos saber para podemos construir aplicações orientadas a objetos em Java. Na próxima aula, vamos evoluir um pouco mais nos conceitos de OO e verificar como eles podem ser implementados em Java.

SÍNTESE Nesta aula, aprendemos a sintaxe básica da linguagem Java e como utilizá-la

para criar nossas primeiras classes. Vimos que o Java é uma das linguagens mais utilizadas atualmente. Seus programas são traduzidos em linguagem de máquina a partir de uma máquina virtual. Esta característica nos fornece uma grande vantagem que é a construção de programas portáveis. Programas orientados a objetos são formados por um conjunto de objetos que se comunicam trocando mensagens. Esses objetos são criados a partir de classes. As classes são definidas na linguagem Java com um nome, atributos e métodos. Atributos possuem um tipo de dado e um nome. Métodos representam o comportamento da nossa classe, ou seja, é onde colocamos a lógica da classe que estamos construindo. A visibilidade dos atributos e métodos é definida pelos modificadores de acesso, por exemplo, podemos definir métodos públicos e métodos privados. Para criar nossas classes em Java, podemos utilizar desde um editor de texto até IDEs mais complexas. Nesta aula, utilizamos o software BlueJ para desenvolver, compilar e executar nossos programas em Java.

QUESTÃO PARA REFLEXÃO Nesta aula aprendemos a criar nossa primeira classe Java. Instale o BlueJ, crie a classe Conta utilizada no nosso exemplo e execute os diversos métodos existentes nela analisando os resultados apresentados.

LEITURAS INDICADAS Capitulos 1 e 3 do livro de Deitel Capitulo 2 do livro de Rafael Santos

http://www.ceunes.ufes.br/downloads/2/mariateixeira-EC. Programa%C3%A7%C3%A3o%20III.Conte%C3%BAdos%201-2.2012.1.pdf http://www.hardware.com.br/artigos/programacao-orientada-objetos/

de programação II

http://www.riopomba.ifsudestemg.edu.br/dcc/dcc/materiais/1662272077_POO.pdf

509 lingüagens e técnicas

SITES INDICADOS

REFERÊNCIAS DEITEL, H. M., DEITEL, P. J. Java: como programar. 8. ed. São Paulo: Pearson Prentice Hall, 2010.(BV)

SANTOS, Rafael. Introdução à programação orientada a objetos usando Java. São Paulo: Campus, 2003.

lingüagens e técnicas

de programação II

510

Na aula passada, aprendemos a construir nossas primeiras classes e a instanciar objetos em Java. No entanto, para criarmos aplicações compostas por diversas classes precisamos avançar um pouco mais na sintaxe da linguagem Java e nos conceitos básicos de OO.

de programação II

Autora: Ana Patrícia F. Magalhães Mascarenhas

511 lingüagens e técnicas

AULA 03 - CRIAÇÃO DE APLICAÇÕES EM JAVA

Construtores Construtor é um tipo especial de método de classe chamado automaticamente quando objetos são instanciados através da palavra chave new. Os Construtores são úteis para:

inicializar os atributos de uma classe realizar rotinas complexas de inicialização realizar inicializações segundo parâmetros passados no momento da criação do objeto

Para entendermos melhor o conceito de construtores, vamos relembrar como fizemos para criar os nossos objetos na aula passada. Através da opção new do BlueJ (sobre a classe desejada), instanciamos objetos e em seguida utilizamos métodos de inicialização para informar os valores iniciais dos atributos destes objetos. Por exemplo, na classe Conta, figura 1 a seguir, que criamos na aula passada, tínhamos um método chamado criarConta, responsável pela inicialização dos dados do objeto conta1 criado. Esta maneira de programar funciona se o usuário lembrar de executar o método criarConta para inicializar os dados da conta1 antes de fazer qualquer outro processamento. Mas, se ele esquecer de fazer essa inicialização? Não podemos correr este risco em um sistema. Para isso, temos os métodos contrutores que são automaticamente executados pelo Java quando um objeto é instanciado. Na linguagem Java, a declaração de um método construtor contém algumas regras:

Construtores devem ter exatamente o mesmo nome da classe Construtores não possuem tipo de retorno Construtores são, normalmente, públicos

O construtor public Conta(int nc, int dc, int na) é público; não tem tipo de retorno (no construtor não colocamos a palavra reservada void para indicar que não

lingüagens e técnicas

de programação II

512

temos retorno); e possui exatamente o mesmo nome da classe (observe que o Java faz distinção entre letras maiúsculas e minúsculas). No Java, toda classe que é criada no nosso programa possui um construtor. Caso o programador não forneça uma versão explícita do construtor, o Java utiliza uma versão de construtor escondida sem nenhum parâmetro declarado. Por exemplo, para a classe Conta, como não foi criado pelo programador o método construtor, o Java criaria implicitamente o método public Conta(), ou seja, um método público, sem nenhum tipo de retorno, com nome igual ao da classe e sem nenhum parâmetro. Se o programador fornecer qualquer versão de um construtor, a linguagem não mais incluirá o construtor padrão implícito.

Figura 1: Exemplo de construtor para a classe Conta

Fonte: Autoria própria

Sobrecarga Antes de conhecermos o conceito de sobrecarga, precisamos distinguir entre nome de um método e assinatura de um método. O nome de um método é o nome que o desenvolvedor define quando cria um método. Por exemplo, a classe Conta possui métodos com os seguintes nomes: depositar; saque; getSaldo; setSaldo, entre outros. A assinatura do método contém toda a declaração do método, ou seja, o nome e os tipos de dados envolvidos. Por exemplo, a classe Conta possui as seguintes assinaturas de métodos: public void depositar(float valor); public boolean saque(float valor); entre outras. A linguagem Java permite que, na mesma classe, possamos criar métodos que tenham o mesmo nome, porém com assinaturas diferentes. Esse conceito é o mesmo que temos no nosso mundo real, onde existem pessoas com o mesmo nome, porém cada uma delas tem uma assinatura diferente e pode ser reconhecida por esta assinatura. No caso dos métodos, o princípio é o mesmo. Por exemplo, na classe Conta podemos ter dois métodos para depósito: um para depositar um valor na conta do

se realizar a mesma tarefa na mesma classe. Neste caso, dizemos que o método está sobrecarregado. Uma sobrecarga é válida se a assinatura do método difere no número ou no tipo dos parâmetros. Diferenças no nome dos parâmetros não são relevantes e diferenças no tipo de retorno são permitidas, mas não são relevantes. O exemplo da figura 2 mos-

513 de programação II

exemplo. Este conceito é usual quando existem duas ou mais formas diferentes de

lingüagens e técnicas

correntista; e um para depositar um valor acrescido de juros. A figura 2 ilustra este

tra uma diferença na quantidade de parâmetros entre os dois métodos depositar. O primeiro tem 1 parâmetro e atualiza o saldo do correntista com o valor do depósito; e o segundo tem dois parâmetros e atualiza o saldo do correntista com o valor do depósito acrescido dos juros.

Figura 2: Exemplo de sobrecarga de método

Fonte: Autoria própria

A sobrecarga de métodos é válida para qualquer tipo de método de uma classe e também para construtores. No caso de construtores, podemos invocar uma sobrecarga de método através da palavra reservada this. Por exemplo, na classe Conta, podemos ter dois métodos construtores, um para criar um objeto, informando um saldo inicial e um para criar um objeto com saldo inicial 0. A figura 3 ilustra este exemplo. Figura 3: Exemplo de sobrecarga de construtor

Fonte: Autoria própria

lingüagens e técnicas

de programação II

514

Podemos ter vários métodos sobrecarregados na mesma classe. Por exemplo, na classe Conta, ilustrada anteriormente, além dos dois construtores criados, poderíamos ter também 3 formas diferentes de imprimir o saldo, cada uma requerendo parâmetros específicos. Neste caso, criamos 3 métodos com o nome Saldo, diferindo a assinatura deles:

public float saldo() /* para imprimir o saldo da conta corrente*/ public float saldo(int contaPoup) /* para imprimir o saldo da conta poupança, caso esta poupança seja na própria agencia da conta corrente*/ public float saldo(int contaPoup, int agencia) /* para imprimir o saldo da conta poupança, caso esta poupança esteja em outra agencia */

A referência this A palavra reservada this pode ser utilizada sob vários aspectos dentro de um programa Java, não apenas para invocar outro construtor. A palavra this indica uma referência ao objeto atual. Quando chamamos um

método usando o this, é passada, implicitamente, como parâmetro, a referência do objeto atual para onde a mensagem foi enviada. Desta forma, a palavra this permite obter a referência do objeto atual de dentro da classe. Existem várias situações em que a palavra reservada this pode ser usada:

Para fazer referência ao próprio objeto Para acessar variáveis do objeto Para passagem do objeto como parâmetro

Por exemplo, suponha que criamos uma classe Aluno com os atributos matricula, nome, email e telefone. Em seguida, criamos o construtor da classe Aluno, recebendo estes dados como parâmetro para inicializar os atributos da classe, conforme ilustrado na figura 4. Observe que os parâmetros criados no método construtor possuem os mesmos nomes dos atributos da classe. Para que no corpo do método possamos fazer a atribuição (ex. this.matricula = matricula;), foi necessário utilizar a palavra this para indicar que this.matricula se refere ao atributo matricula e apenas matricula se refere ao parâmetro do método construtor. Caso não tivéssemos utilizado a palavra this, nada aconteceria, pois o Java iria interpretar o comando como uma atribuição do parâmetro matricula a ele mesmo. Outro exemplo de uso da palavra reservada this, também ilustrado no método construtor da figura 4, é a chamada explícita ao método calculaMensalidade(). Neste

Figura 4: Exemplo de uso da palavra this

515 de programação II

está localizado na própria classe Aluno que está sendo processada.

lingüagens e técnicas

caso, estamos indicando que queremos executar o método calculaMensalidade() que

Fonte: Autoria própria

________________________ Aplicações OO em Java ________________________ ________________________ Até o momento, criamos classes que representam um modelo do nosso mundo ________________________ real, mas não criamos efetivamente um sistema. ________________________ ________________________ Um sistema (aplicação) OO nada mais é do que um conjunto de objetos instan________________________ ciados a partir de classes, que se comunicam através de mensagens. A figura 5 ilustra ________________________ um exemplo fictício de sistema OO. ________________________ ________________________ Figura 5: funcionamento de um sistema OO ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ Fonte: Autoria própria

lingüagens e técnicas

de programação II

516

Temos diversas classes (ex. Aluno, Professor e Turma). A partir destas classes instanciamos objetos (ex. instanciamos os objetos Maria e Jose usando a classe Aluno). Estes objetos se comunicam através de mensagens (ex. a mensagem x é enviada do objeto Turma1 para o objeto Maria) fazendo o nosso sistema funcionar. Para criarmos um sistema OO, também precisamos indicar por onde o processamento se inicia. Por exemplo, quem é responsável por criar os primeiros objetos e enviar as primeiras mensagens? Em Java, o ponto de entrada de um sistema é criado a partir de uma classe que contém um método especial chamado main. A presença deste método faz com que a classe se torne executável. Só é possível existir em um sistema uma única classe que contenha um método main. O método main possui uma assinatura fixa composta por:

modificadores pubic static retorno void lista de argumentos formada por um array

Desta forma, a assinatura do método é a seguinte: ________________________ ________________________ ________________________ public static void main(String[] args) ________________________ ________________________ ________________________ ________________________ onde, ________________________ ________________________ public: indica que o método é visível para qualquer outra classe ________________________ ________________________ static: dispensa a criação de objetos ________________________ void: indica que nenhum retorno esperado ________________________ ________________________ main: é a convenção utilizada para indicar a máquina virtual qual o ponto de entrada ________________________ da aplicação ________________________ String[] args: é um vetor de elementos String chamado args que contém a parâmetros ________________________ passados pela aplicação via linha de comando. ________________________ ________________________ ________________________ A inicialização de uma aplicação pode demandar que muitos parâmetros se________________________ jam informados. Por este motivo, Java padroniza os parâmetros do método main em ________________________ um vetor de Strings, pois a depender de cada aplicação que for construída, diferentes ________________________ quantidades de parâmetros podem ser necessárias. ________________________ A figura 6 ilustra um exemplo do método main. Como pode ser observada, a ________________________ classe Aplicação possui um método main, com a assinatura padrão. O main é responsá-

No exemplo foi instanciado um objeto da classe Aluno e executado o método calculaMensalidade(). O processo de criação de um objeto demanda a definição de uma variável (criamos a variável aluno1 do tipo Aluno) e a utilização do operador New, que será apresentado na seção a seguir. Uma vez criado o objeto aluno1, é possível enviar mensagens para ele a partir da invocação de um de seus métodos. No exemplo foi chamado o método calculaMensalidade().

517 de programação II

Neste método, são feitas todas as inicializações de objetos necessárias para o sistema.

lingüagens e técnicas

vel por criar um objeto do tipo aplicação (app) e executar o método inicializaObjetos().

Figura 6: exemplo de método main

Fonte: Autoria própria

O Operador New A criação de uma aplicação demanda, muitas vezes, também, a criação de objetos via código pelo nosso sistema. Até o momento, criamos nossos objetos a partir da interface do BlueJ clicando com o botão direito do mouse sobre a classe desejada e selecionado a opção New. Neste momento, o método construtor da nossa classe é automaticamente chamado e o BlueJ apresenta uma janela com campos para informarmos os parâmetros definidos no construtor. Para criarmos objetos diretamente via código Java, utilizamos o operador New que compreende então as seguintes tarefas:

instancia um novo objeto aloca o espaço necessário para armazenar o estado do objeto e uma tabela para indicar o corpo do código necessário para efetuar suas operações executa as tarefas de inicialização do objeto conforme o seu Construtor

lingüagens e técnicas

de programação II

518

Sempre que criamos um objeto, precisamos definir uma referência para uma variável que nos permitirá manipular esse objeto. O operador new, quando executado, retorna o identificador do objeto criado para a variável definida que servirá para futuras referências ao objeto. O compilador e a máquina virtual Java verificam o tipo da variável e o tipo da referência retornada. Variáveis do tipo referência armazenam uma referência nula até serem inicializadas. A palavra reservada null indica uma referência nula do objeto. Assim, se desejarmos desfazer uma referência a um objeto, podemos atribuir a palavra null às variáveis que apontam para ele. Por exemplo, na figura 6 podemos colocar a1=null; para limpar a referencia de a1 para o objeto da classe Aluno anteriormente criado.

Entrada e saída de console em java A construção de aplicações em Java pode demandar a impressão e a aquisição de valores via console. Desta forma, analisaremos alguns exemplos de entrada e saída de dados via console.

Saída de dados

A saída de dados via console em Java é realizada a partir de um atributo da classe System, conforme instrução a seguir:

System.out.println(“string a ser impressa”);

Neste caso, objetos são automaticamente convertidos para String e tipos primitivos podem ser concatenados a Strings através do operador +. Por exemplo,

System.out.println(“Meu primeiro programa em Java”); System.out.println(“a idade do aluno é:”+aluno1.getIdade());

No primeiro exemplo, a frase entre aspas é impressa. No segundo exemplo, é concatenada a frase “a idade do aluno é:” com o resultado obtido após o processamento do método getIdade() do objeto aluno1.

Entrada de dados Toda classe que for realizar entrada de dados via teclado em Java deve utilizar o

utilizá-lo, coloca-se o seguinte comando no início do programa (antes da declaração

lingüagens e técnicas

da classe):

519 de programação II

package Java.io.*. Esse pacote contém as classes que tratam de entrada de dados. Para

import java.io.*

Para obter valores do teclado em uma classe Java, precisamos criar um objeto da classe BufferedReader, ou seja, criar um buffer de leitura que vai armazenar o que foi digitado no teclado. A criação do buffer de leitura deve ser realizada da seguinte maneira:

BufferedReader

obj

new

BufferedReader(new

inputStreamReader(System.in));

Finalmente, toda entrada de dados está sujeita a erros, uma vez que depende do que for digitado pelo usuário final. A forma mais simples de se tratar esses erros (chamamos de exceção em Java) é solicitar que a exceção não seja tratada localmente através da linha de comando.

________________________ ________________________ ________________________ throws java.io.IOException ________________________ ________________________ ________________________ O tratamento de exceções será detalhado nas próximas aulas. ________________________ ________________________ ________________________ Conversão de tipos primitivos de dados ________________________ ________________________ ________________________ Os dados recebidos através do teclado pelo Java são sempre do tipo String. As- ________________________ sim, muitas vezes precisamos converter esses dados para outros tipos, por exemplo, ________________________ int ou float para realizarmos cálculos. ________________________ ________________________ Existem alguns tipos de conversões de dados String possíveis no Java ________________________ Conversão de String para inteiro ________________________ ________________________ int i = Integer.valueOf(line).intValue(); ________________________ Conversão de String para long ________________________ ________________________ long l = Long.valueOf(line).longValue(); ________________________ Conversão de String para float ________________________ ________________________ float f = Float.valueOf(line).floatValue();

Conversão de String para double

de programação II

double d = Double.valueOf(line).doubleValue();

lingüagens e técnicas

520

Figura 7: exemplo de entrada, saída e conversão tipos de dados

Fonte: Autoria própria

A figura 7 ilustra um exemplo com entrada/saída de dados e conversão de tipos de dados String para int. O código apresentado é uma classe chamada Soma com apenas um método, o main. A implementação deste método recebe dois valores a e b via teclado, realiza uma operação de soma e apresenta o resultado no final. Antes de realizar a operação de soma, converte os valores digitados do tipo String para int. Na próxima aula, avançaremos um pouco mais na sintaxe da linguagem Java aprendendo as estruturas condicionais e de repetição existentes.

SÍNTESE Nesta aula, aprendemos a inicializar nossas classes Java a partir de métodos construtores. Vimos que em Java todas as classes possuem um método construtor. Caso o programador se esqueça de criá-lo, o Java automaticamente criará um construtor vazio para a classe. Os métodos construtores têm exatamente o mesmo nome da classe e são importantes para inicializarmos nossos objetos, por exemplo, colocando valores nos seus atributos. Métodos em uma classe podem ser sobrecarregados, sejam eles construtores ou não. Isso significa dizer que podemos ter mais de um método com o mesmo nome,

seja, podemos ter métodos com o mesmo nome, desde que não tenham a mesma quantidade de parâmetros ou a mesma sequência de tipos nos parâmetros. Nesta aula, aprendemos, também, a criar aplicações executáveis em Java. Para isso, utilizamos o método main, cuja assinatura é padrão. Não podemos construir um sistema em Java que tenha classes com mais de um método main.

521 de programação II

assinatura de um método consiste nos tipos de dados passados como parâmetro, ou

lingüagens e técnicas

na mesma classe, desde que eles tenham assinaturas diferentes. A parte relevante da

Finalmente, aprendemos a fazer entrada e saída de dados via console nos nossos programas. Considerando que os dados digitados em console são sempre do tipo String, vimos também como transformar um dado do tipo String para outro tipo qualquer.

QUESTÃO PARA REFLEXÃO Aprendemos até o momento os conceitos básicos de programação orientada a objetos. Analise esses conceitos (classe, objeto, encapsulamento, construtor e sobrecarga) e reflita sobre os ganhos de produtividade que podemos ter com a POO.

LEITURAS INDICADAS Capítulos 1 e 3 do livro de Deitel Capítulo 2 do livro de Rafael Santos

SITES INDICADOS http://www.riopomba.ifsudestemg.edu.br/dcc/dcc/materiais/1662272077_POO.pdf http://www.ceunes.ufes.br/downloads/2/mariateixeira-EC. Programa%C3%A7%C3%A3o%20III.Conte%C3%BAdos%201-2.2012.1.pdf http://www.hardware.com.br/artigos/programacao-orientada-objetos/

REFERÊNCIAS DEITEL, H. M., DEITEL, P. J. Java: como programar. 8. ed. São Paulo: Pearson Prentice Hall, 2010.(BV)

SANTOS, Rafael. Introdução à programação orientada a objetos usando Java. São Paulo: Campus, 2003.

lingüagens e técnicas

de programação II

522

Autora: Ana Patrícia F. Magalhães Mascarenhas

Na aula passada, aprendemos a criar aplicações em Java. Para que estas aplicações tenham um pouco mais de complexidade precisamos de estruturas de programação mais elaboradas. Nesta aula aprenderemos a trabalhar com estruturas condicionais e de repetição em Java.

de programação II

REPETIÇÃO

523 lingüagens e técnicas

AULA 04 - ESTRUTURAS CONDICIONAIS E DE

Estruturas condicionais Muitas vezes, quando construímos um programa, precisamos expressar desvios condicionais a depender de uma situação específica do programa. Por exemplo, suponha que estamos construindo um método para calcular a média de um aluno de acordo com as seguintes regras:

A média para aprovação deve ser superior ou igual a 7; Alunos com média inferior a 7 podem fazer prova final caso tenham uma nota superior ou igual a 4.

________________________ ________________________ Alunos com nota inferior a 4 estão reprovados. ________________________ ________________________ Para este exemplo, o retorno do nosso processamento depende de algumas ________________________ condições, ou seja, o método não deve se resumir a calcular a média, ele deve fornecer ________________________ ________________________ um conceito: aprovado, prova final ou reprovado. ________________________ Para este tipo de situação, temos as estruturas condicionais de programação. ________________________ No Java, duas estruturas condicionais podem ser utilizadas: if-else; e switch. ________________________ ________________________ ________________________ Estruturas do tipo if-else ________________________ ________________________ ________________________ As estruturas do tipo if-else contêm a seguinte sintaxe: ________________________ ________________________ Figura 1: Sintaxe da estrutura if-else ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ Fonte: autoria própria

De acordo com a sintaxe ilustrada na figura 1, podemos observar o seguinte:

de programação II

O comando else não é obrigatório.

lingüagens e técnicas

524

Quando usamos if’s aninhados, o else faz referência ao if mais próximo. Chaves são utilizadas para delimitar os blocos. A expressão Bloco de comandos pode conter um só comando (terminado por ponto-evírgula) ou vários comandos (delimitados por {}). É obrigatório o uso de parênteses ( ) na expressão_booleana.

É importante lembrar que o operador de comparação igual a é representado por == e não por = como é de costume em outras linguagens. Expressões booleanas podem ser construídas com os operadores relacionais (<; >; <=; >=; !=, ==) e com os operadores aritméticos (&&, ||, !) conforme visto na aula 2. A figura 2 ilustra o método calcularMedia que recebe dois valores do tipo float, calcula a média, verifica o conceito (conforme definição no início desta seção) e retorna um dado to tipo String com o conceito encontrado.

Figura 2: Exemplo de método com estrutura if-else

Fonte: autoria própria

Como pode ser observado no exemplo anterior, estruturas if-else podem também ser aninhadas. O else sempre se refere ao if mais próximo. Observe também que as expressões booleanas sempre estão entre parênteses. Se tivermos mais de uma expressão booleana temos que colocar um parêntese sempre englobando toda a sentença, conforme ilustrado a seguir.

525

Estruturas do tipo switch

Muitas vezes temos um dado no nosso programa que precisa ser avaliado sob

lingüagens e técnicas

de programação II

if ((x>10) && (y>5) && (X==y))

várias condições diferentes. Nestes casos se torna interessante o uso da estrutura switch onde é possível fazer vários testes para uma mesma variável. A sintaxe da estrutura switch é ilustrada na figura 3.

Figura 3: Sintaxe da estrutura switch

Fonte: Autoria própria

Como pode ser observado na figura 3, o switch é usual quando queremos selecionar alguma ação de um número de alternativas. No entanto, o swich contém algumas restrições:

A variável de controle só pode ser dos tipos int ou char O switch define o ponto de entrada da execução. Se você quiser que só um bloco de declarações seja executado deve usar o comando break para forçar a saída do switch. A opção default é opcional.

Analisando as condições impostas pelo switch, podemos verificar que a estrutura if-else poderá sempre ser utilizada quando desejarmos expressar condições. Somente em alguns casos, essa estrutura poderá ser representada também usando o switch.

A figura 4 ilustra um exemplo de método implementado utilizando o switch.

526 lingüagens e técnicas

de programação II

Figura 4: Exemplo de método com a estrutura switch

Fonte: Autoria própria

Para o exemplo da figura 4, suponha que queremos construir um método chamado faixaEtaria para, dado um valor do tipo char qualquer, indicar por extenso o seu significado de acordo com a regra: ‘1’ para criança; ‘2’ para jovem; ‘3’ para adulto; ‘4’ para idoso. Perceba que não foi usada a cláusula else, ou seja, se for informado um valor di-

ferente de 1, 2, 3 ou 4 nada será impresso. Além disso, em todas as opções foi colocado o comando break, para forçar a saída do switch quando uma opção for encontrada. Desta forma, uma vez encontrado um valor, não precisamos mais analisar todas as outras opções do switch.

Estruturas de repetição Muitas vezes quando fazemos um programa precisamos repetir diversas vezes um mesmo trecho de código. Por exemplo, suponha que precisamos imprimir todos os números pares existentes entre 1 e 100. Neste caso, precisamos imprimir os números 2, 4, 6, 8, ...., 98. Este programa pode ficar extremamente grande se não utilizarmos uma estrutura de repetição para desenvolvê-lo. As estruturas de repetição em linguagens de programação permitem que um conjunto de instruções sejam repetidas diversas vezes durante a execução do programa. Na linguagem Java podemos fazer repetições utilizando 3 estruturas diferentes: while; do - while; e o comando for. No entanto, antes de analisarmos cada uma destas estruturas, é importante vermos também como o Java trabalha com contadores, estruturas necessárias quando utilizamos repetições.

Contadores

contador = contador + 1;

Na linguagem Java, podemos expressar os contadores de várias maneiras, não apenas conforme ilustrado no exemplo anterior, são elas:

527 de programação II

incrementadas a cada interação de uma repetição da seguinte maneira:

lingüagens e técnicas

Contadores podem ser vistos como variáveis que recebem um valor inicial e são

Usando o sinal ++para incrementar o valor em 1 Usando o sinal -- para decrementar o valor em 1 Usando o sinal += para incrementar o valor em várias unidades Usando o sinal -= para decrementar o valor em várias unidades Usando o sinal *= para multiplicar o valor em várias unidades Usando o sinal /= para dividir o valor em várias unidades.

A figura 5 ilustra alguns exemplos de contadores em Java. Por exemplo, suponha uma variável A do tipo int com valor inicial igual a 5. Se executarmos o comando

________________________ ________________________ ________________________ ________________________ ________________________ Figura 5: Exemplo de contador em Java ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ Fonte: Autoria própria ________________________ ________________________ Estruturas do tipo while ________________________ ________________________ ________________________ A estrutura while é utilizada quando desejamos repetir um determinado trecho ________________________ de código enquanto uma dada expressão booleana for verdadeira. A figura 6 ilustra a ________________________ sintaxe da estrutura while na linguagem Java. ________________________ A++; o valor de A após a execução será 6, pois A será incrementada em 1.

528 lingüagens e técnicas

de programação II

Figura 6: sintaxe da estrutura while

Fonte: Autoria própria

Para a estrutura while, é indispensável o uso de parênteses ( ) na expressão booleana. Durante o processamento dessa estrutura, o laço permanece em execução, enquanto a expressão booleana for verdadeira. Por este motivo, temos que ter o cuidado de tornar a nossa expressão booleana falsa em algum momento para que o laço seja finito. Como também pode ser observado na figura 6, é necessário usar chaves para delimitar o Bloco de comandos. Caso deseje interromper um laço sem que a expressão booleana seja avaliada como falsa, pode-se utilizar o comando break.

Estruturas do tipo do - while

A estrutura do tipo do-while se assemelha muito à while, vista anteriormente. No entanto, quando usamos do-while, a expressão booleana só é avaliada após a execução dos comandos que fazem parte da estrutura de repetição. Desta forma, estes comandos sempre serão executados ao menos uma vez mesmo que a expressão booleana seja avaliada como falsa. A figura 7 ilustra um exemplo da estrutura do-while. Observe que as mesmas considerações realizadas para a estrutura while são válidas neste caso, ou seja, usar chaves para delimitar o bloco de código a ser repetido; usar parênteses englobando a expressão booleana; e garantir que a expressão booleana em algum momento será avaliada com falsa para que o laço seja finito.

Figura 7: sintaxe da estrutura do-while

Fonte: Autoria própria

Estruturas do tipo for

Figura 8: sintaxe da estrutura for

529 de programação II

figura 8.

lingüagens e técnicas

A estrutura do tipo for é um tipo de repetição que segue a sintaxe ilustrada na

Fonte: Autoria própria

Como pode ser observado na figura 8, o for contém 3 definições em sua declaração:

Inicialização, que indica o valor inicial da variável de controle do laço Terminação, que indica a condição de parada do laço Iteração, que indica o contador utilizado

Um erro comum, quando se utiliza a estrutura for, é colocar o ponto e vírgula após a declaração do for, ficando o bloco de comandos fora do laço. O resultado é um loop que nada realiza. A figura 9 ilustra o mesmo exemplo desenvolvido nas três estruturas de repetição diferentes. Trata-se de um exemplo simples, imprimir os números inteiros de 1 a 10. Como pode ser observado na figura 9, o exemplo da esquerda utiliza a estrutura while. Desta forma, antes do processamento, a repetição avalia a variável de controle a e somente entra no laço se o resultado da avaliação for verdadeiro.

No exemplo ilustrado no centro da figura, temos o mesmo programa implementado com a estrutura do-while. Neste caso, o primeiro número será sempre impresso, independente de que número seja, pois o teste da expressão booleana só é realizado após cada iteração do laço.

No terceiro exemplo, mais à direita, temos o mesmo programa implementado na estrutura for. Observe que a variável de controle a foi declarada dentro da estrutura for e já inicializada. A segunda parte da estrutura define a condição de parada e a terceira parte, o contador. Neste caso, o contador faz um incremento de uma unidade a cada iteração. Note também que não foi necessário utilizar as chaves para delimitar os comandos a serem repetidos, pois temos apenas um comando dentro do laço.

530 lingüagens e técnicas

de programação II

Figura 9: exemplo das estruturas de repetição

Fonte: autoria própria

Exemplo Para ilustrar os conceitos abordados até o momento, vamos desenvolver um pequeno programa de exemplo. Considere o cenário a seguir:

Uma empresa de telefonia deseja construir um sistema para controle das contas de telefone dos seus clientes. Sabe-se que quando fazemos uma ligação, estamos ligando de um local e de um número de origem para um local e um número de destino. Esta ligação tem uma duração em minutos calculada com base no momento de início e no momento de término da ligação. Por exemplo, fazemos uma ligação de Salvador

do número 2222-2222 para São Paulo número 3333-3333 que se inicia às 10:20h e termina às 10:55h. Neste caso, a ligação durou 35 minutos. Desta forma, podemos dizer que uma ligação telefônica possui os seguintes atributos: número e local de origem, número e local de destino, momento de início, momento de termino e duração. Vamos considerar que este momento de início e término consiste em hora e minuto de início em que a ligação foi iniciada e hora e minuto em que a ligação foi encerrada. Considere, para efeitos de simplificação, que todas as ligações ocorrem no mesmo dia.

Para resolver este problema, vamos iniciar identificando as classes necessárias. Precisamos de uma classe para representar nossas ligações telefônicas. Precisamos, também, de uma classe para representar um momento (com hora e minuto) necessária na nossa ligação. A figura 10 ilustra graficamente essas classes.

Observe que criamos a classe Tempo e utilizamos a sua definição para declarar dois atributos da classe Ligação: inicio e termino. Observe também que alguns métodos foram criados. Na classe Tempo, criamos um método que determinará quantos minutos existem em um tempo qualquer. Esse método será mais tarde utilizado para calcular a duração de uma ligação, que é dado em minutos. Temos também o método valorLigacao() que calcula o valor de uma ligação qualquer. Na classe

Ligação, também temos um método para verificar, dado um número de telefone qualquer, se a ligação foi feita para o número informado.

531 lingüagens e técnicas

de programação II

Figura 10: Classes definidas para o exemplo

Fonte: Autoria própria

O próximo passo, então, é construirmos o código destas duas classes. A figura 11 mostra o código fonte da classe Tempo. Figura 11: código fonte da classe Tempo

Fonte: Autoria própria

Como podemos observar no código fonte da classe Tempo, temos um construtor (método que tem o mesmo nome da classe e serve para fazer inicializações) que recebe os parâmetros e inicializa os atributos da classe. Temos métodos get e set para cada um dos atributos. Observe também que nos métodos sets estamos fazendo validações para garantir que os valores inseridos são íntegros. Estas validações utilizam

lingüagens e técnicas

de programação II

532

a estrutura condicional if para fazer o teste. Finalmente temos também a implementação do método totalMinutos() que nos retorna um Tempo qualquer em minutos, ou seja, transforma a hora para minutos e totaliza quantos minutos existem em um tempo qualquer. O segundo passo é construir a classe Ligação. A figura 12 ilustra o código fonte da classe Ligação. Figura 12: Código fonte da classe Ligação

Fonte: Autoria própria

Observe que temos, neste exemplo, uma sobrecarga de método construtor, ou seja, temos dois métodos construtores com o mesmo nome, porém, com assinaturas diferentes. O primeiro recebe todos os dados como parâmetro; o segundo não recebe o término da ligação e será usado quando a ligação ainda estiver em andamento. Em seguida, precisamos implementar métodos gets e sets para todos os atributos. Por questão de espaço, a figura 12 não mostra esses métodos, mas assume que eles foram criados. Temos também um método chamado duracao(), que é utilizado quando desejamos calcular qual a duração em minutos desta ligação. Observe que para isso precisamos executar o método totalMinutos() que está na classe Tempo, ou seja, estamos mandando uma mensagem à classe tempo solicitando que ela execute este método e nos mande a resposta. Para enviar esta mensagem, utilizamos o objeto inicio e termino

O método valorLigacao() foi criado para calcularmos o valor de uma ligação, considerando que cada minuto falado custa R$ 0.40. Observe que colocamos a seguinte sentença no código: return duracao() * 0.4f; neste caso, estamos executando o método duração (o objeto manda uma mensagem para ele mesmo) e multiplicando o resultado por 0.4. Em Java, utilizamos o ponto em vez da vírgula para expressar casas

533 de programação II

objeto da classe Tempo representado pela variável inicio.

lingüagens e técnicas

existente na nossa ligação. inicio.totalMinutos() vai nos fornecer o total de minutos do

decimais. Também colocamos a letra f minúscula ao lado do número, pois o nosso valor é do tipo float. Finalmente, temos o método pesquisaNumero(String numero), que recebe um número de telefone como parâmetro e verifica se a ligação foi feita para o número informado. Observe que a comparação de igualdade do tipo String não é a convencional utilizada em Java. Para isso, utilizamos o método equals. Para testarmos esta aplicação, podemos utilizar o ambiente do BlueJ, criar inicialmente um objeto tempo para representar o início de uma ligação e outro objeto tempo para representar o término de uma ligação. Em seguida, criamos um objeto ligação e solicitamos que os métodos sejam executados.

Figura 13: código fonte da classe AppTeste

________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ Fonte: Autoria própria ________________________ ________________________ ________________________ Outra opção de teste é criarmos uma classe com um método main onde pode________________________ remos criar manualmente nossos objetos, executar métodos e imprimir os resultados. ________________________ A figura 13 ilustra uma classe AppTeste com a implementação do método main. ________________________ Observe na figura 13 que temos um método main que será sempre executado ________________________ quando a aplicação for chamada. Este método tem a assinatura pré-definida. ________________________ ________________________ O corpo do método main cria alguns objetos e executa métodos. Para instan-

lingüagens e técnicas

de programação II

534

ciar um objeto, precisamos inicialmente criar uma variável que seja do tipo de dado do objeto que pretendemos criar. Em seguida utilizamos a palavra reservada new para criar o objeto. Uma vez criado o objeto, podemos executar qualquer método colocando o nome do objeto, mais um sinal de ponto, mais o nome do método. Este exemplo será melhor explorado na próxima aula com a utilização de vetores. Na próxima aula aprenderemos a trabalhar com estruturas mais complexas comumente chamadas de vetores e matrizes.

SÍNTESE Nesta aula, aprendemos a trabalhar com estruturas condicionais e de repetição em Java. As estruturas condicionais são utilizadas quando precisamos expressar uma condição para execução de um certo trecho de código. Assim, o trecho subordinado à condição somente será executado se a expressão booleana associada a ele for avaliada como verdadeira. Em Java, temos duas estruturas condicionais, o if; e o switch.

As estruturas de repetição são utilizadas quando precisamos repetir determinado trecho de código n vezes no nosso programa. Em geral, estas estruturas expressam um laço que é executado enquanto uma expressão booleana for avaliada como verdadeira. Esses laços utilizam muitas vezes uma variável de controle. Em Java, vimos as estruturas de repetição while; do-while; e for.

QUESTÃO PARA REFLEXÃO Neste momento, já temos conhecimento para criarmos nossas primeiras aplicações usando Java e OO. Analise o exemplo apresentado no final desta aula, implemente-o e execute-o no Java avaliando os seus resultados.

LEITURAS INDICADAS Capitulos 1 e 3 do livro de Deitel Capitulo 2 do livro de Rafael Santos

SITES INDICADOS http://www.riopomba.ifsudestemg.edu.br/dcc/dcc/materiais/1662272077_POO.pdf

http://www.hardware.com.br/artigos/programacao-orientada-objetos/

REFERÊNCIAS

535 de programação II

Programa%C3%A7%C3%A3o%20III.Conte%C3%BAdos%201-2.2012.1.pdf

lingüagens e técnicas

http://www.ceunes.ufes.br/downloads/2/mariateixeira-EC.

DEITEL, H. M., DEITEL, P. J. Java: como programar. 8. ed. São Paulo: Pearson Prentice Hall, 2010.(BV)

SANTOS, Rafael. Introdução à programação orientada a objetos usando Java. São Paulo: Campus, 2003.

lingüagens e técnicas

de programação II

536

AULA 05 - ARRAYS

Na aula passada, vimos as estruturas de programação Java, que nos permitem criar programas expressando condições e repetições.

lingüagens e técnicas

Autora: Ana Patrícia F. Magalhães Mascarenhas

de programação II

537

Nesta aula, aprenderemos como o Java trabalha com estruturas de dados representadas por arrays unidimensionais (também chamados de vetores) e arrays multidimensionais (também chamados de matrizes).

Vetores Muitas vezes, quando construímos nossos programas, precisamos criar estruturas de dados na memória que representem conjunto de dados de um determinado tipo. Por exemplo, suponha que, em um sistema acadêmico, temos uma classe Aluno com alguns atributos, tais como: matricula, nome e email. Sabe-se que todo objeto da classe Aluno possui um conjunto de médias relativas às disciplinas que já foram cursadas por ele. A representação dessas médias em nossa classe Aluno não pode ser feita utilizando atributos simples, uma vez que não sabemos quantas disciplinas o aluno já cursou e ainda vai cursar ao longo do curso. Para resolver este problema, precisamos de uma estrutura de dados que nos permita armazenar um conjunto de médias para ________________________ cada aluno. Nestes casos, utilizamos vetores. ________________________ Um vetor (ou array) é uma sequência de objetos ou valores de tipos primitivos, ________________________

todos do mesmo tipo e combinados sob um único identificador. Vetores são estáticos, ________________________ ou seja, o seu tamanho é definido no momento da sua criação. Em Java, vetores são objetos. Na prática, eles herdam de uma classe genérica chamada Object. Todo vetor possui um atributo público que informa o seu tamanho, o atributo length.

Figura 1 - Exemplo de estrutura de um vetor

Fonte: Autoria própria

A Figura 1 ilustra, graficamente, um vetor. Como pode ser observado, uma única variável (identificador chamado, na figura, de vet) aloca um espaço de memória, que é dividido em partes. Cada uma dessas partes pode ser utilizada para guardar um valor diferente, porém do mesmo tipo de dado. O acesso a uma posição qualquer de um vetor é realizado a partir de um índice. Em Java, os índices de um vetor se iniciam na posição 0. Desta forma, se temos

lingüagens e técnicas

de programação II

538

um vetor com 8 elementos, como ilustrado na Figura 1, temos os índices de 0 a 7. A propriedade vet.length, quando executada, retornará o valor 8, que é o tamanho do nosso vetor. A declaração de um vetor em Java é realizada da seguinte maneira:

tipoDeDado[] nomeDaVariavel;

Onde o tipo tipoDeDado pode ser um tipo primitivo do Java ou uma classe definida no nosso programa. Por exemplo:

float[] notas; vetor chamado notas que aceita apenas valores do tipo float. String[] nomes; vetor chamado nomes que aceita apenas valores do tipo String Aluno[] listaDeAlunos; vetor chamado listaDeAlunos que aceita apenas objetos da classe Aluno

Vetores precisam ser instanciados antes de serem utilizados. Quando instan-

ciamos um vetor, dizemos a quantidade máxima de elementos que ele terá e, efetivamente, alocamos espaço na memória para utilizá-los. A criação do vetor é realizada com a palavra reservada new, conforme ilustrado a seguir.

notas = new float[10]; criação do vetor notas com 10 elementos, cujos índices de acesso vão de 0 a 9. nomes = new String[20]; criação do vetor nomes com 20 elementos, cujos índices de acesso vão de 0 a 19. listaDeAlunos = new Aluno[15]; criação do vetor listaDeAlunos com 15 elementos, cujos índices de acesso vão de 0 a 14.

É possível também declarar e criar um vetor ao mesmo tempo da seguinte maneira:

String[] listaNomes = new String[20];

Neste caso, estamos criando um vetor com 20 elementos, todos do tipo String, chamado listaNomes. Quando um vetor é criado, todos os seus elementos ficam vazios. No entanto, podemos definir um vetor, criar e inicializar seus valores em uma única sentença, por exemplo:

o valor 3 e a quarta posição o valor 4. String[] mes = {“JAN”, “FEV”, “MAR”, “ABR”, “MAI”, “JUN”,”JUL”, “AGO”,”SET”, “OUT”, “NOV”, “DEZ”}; cria um vetor chamado mes, com 12 elementos do tipo String, inicializado com os nomes dos meses do ano.

539 de programação II

meira posição contém o valor 1, a segunda posição contém o valor 2, a terceira posição

lingüagens e técnicas

int[] vet = {1,2,3,4}; cria um vetor chamado vet, com 4 elementos do tipo int, cuja pri-

A Figura 2, a seguir, ilustra um exemplo de utilização de vetor em Java. Considere que temos uma classe chamada Aluno, onde todo aluno possui matrícula, nome, email e telefone. Além disso, o aluno possui uma lista das disciplinas cursadas. Considere também que temos uma classe Disciplina que contém o código, o nome e a carga horária da disciplina.

Figura 2 - Classe Disciplina (esquerda) e Aluno (direita) usando vetor

Fonte: Autoria própria

A classe Disciplina é uma classe simples, como tantas que já fizemos. Possui os atributos codigo, nome e cargaHoraria; construtor e métodos get e set. A classe Aluno contém, então, 6 atributos: matrícula, do tipo int; nome, email e telefone, do tipo String; listaDisciplinas, vetor do tipo Disciplina. Observe que utilizamos a classe Disciplina na definição do vetor listaDisciplinas. Isso indica que teremos um vetor cujos elementos serão objetos instanciados da classe Disciplina. No exemplo, criamos o vetor com 50 elementos. Essa inicialização foi feita no construtor da classe Aluno (destacado em vermelho na Figura 2). Assim, sempre que um objeto aluno é criado, também já é criado o vetor que, futuramente, guardará as disciplinas por ele cursadas. Inicialmente, este vetor fica vazio. Vetores que guardam objetos, como é o caso de listaDisciplinas, utilizam como vazio a referência nula expressa pela palavra reservada null. Em geral, quando trabalhamos com vetor, temos a necessidade de percorrer

lingüagens e técnicas

de programação II

540

os elementos desse vetor, seja para atualizar um elemento, consultar este elemento ou fazer outra operação qualquer. Para isso, é comum utilizarmos uma estrutura de repetição para percorrer o vetor posição a posição. Por exemplo, para incluirmos uma disciplina na lista de disciplinas do aluno, temos o método incluirDisciplina. A Figura 3 ilustra o código referente ao método incluirDisciplina da classe Aluno. Figura 3 - Método para incluir uma disciplina do aluno

Fonte: Autoria própria

Este método recebe como parâmetro um objeto da classe Disciplina chamado nova e o inclui no vetor. Para fazer essa inclusão, é preciso percorrer este vetor e identificar se existe alguma posição disponível para fazer a inclusão (verificar para cada posição do vetor se ela está vazia, ou seja, se é igual a null). No exemplo, a sentença for (int x=0;x<listaDisciplinas.length;x++) percorre todo

o vetor listaDisciplinas, começando da posição 0 (que é a primeira posição no Java) e indo até a última. Observe que utilizamos a expressão booleana x<listaDisciplinas. length, em vez de usar o sinal <=, pois, se o vetor tiver tamanho de 50, a última posição será a 49.

Matrizes É comum construirmos programas que precisem de uma estrutura de dados ainda mais sofisticada que os vetores. Por exemplo, para construirmos um jogo de damas, precisamos de uma estrutura de dados específica para representar o tabuleiro. Uma solução apropriada nesses casos é a utilização de matrizes, ou arrays multidimensionais. A Figura 4 ilustra, graficamente, uma matriz. Como pode ser observado, temos agora uma estrutura que se assemelha a uma tabela, contendo linhas e colunas.

Figura 4 - Estrutura de uma matriz

Fonte: Autoria própria

Por exemplo, na matriz mat ilustrada na Figura 4, para acessarmos o valor 80, precisamos informar sua linha e coluna, 1 e 2 respectivamente. A declaração de uma matriz em Java é realizada de maneira análoga ao do vetor, porém com o uso de dois colchetes:

541 de programação II

nada na tabela, ou seja, informar o valor da linha e da coluna que desejamos acessar.

lingüagens e técnicas

Para acessarmos um elemento de uma matriz, precisamos informar sua coorde-

tipoDeDado[][] nomeDaVariavel;

Onde o tipo tipoDeDado pode ser um tipo primitivo do Java ou uma classe definida no nosso programa. Por exemplo:

int[][] tabuleiro; matriz chamada tabuleiro que aceita apenas valores do tipo int. Pessoas[][] funcionarios; matriz chamada funcionarios que aceita apenas objetos da classe Pessoas

Assim como os vetores, as matrizes precisam ser instanciadas antes de serem utilizadas. Quando instanciamos uma matriz, dizemos a quantidade de linhas e colunas de que ela será formada e, efetivamente, alocamos espaço na memória para utilizá-la. A criação da matriz é realizada com a palavra reservada new, conforme ilustrado a seguir.

tabuleiro = new int[10][10]; criação da matriz tabuleiro com 10 linhas e 10 colunas, cujos índices de acesso vão de 0 a 9 para as linhas e de 0 a 9 para as colunas. funcionarios = new Pessoas[20][5]; criação da matriz funcionarios com 20 linhas e 5 colunas, cujos índices de acesso vão de 0 a 19 para as linhas e de 0 a 4 para as colunas.

É possível também declarar e criar uma matriz ao mesmo tempo da seguinte maneira:

int[][] tabuleiro = new int[10][10];

Neste caso, estamos criando uma matriz com 10 linhas e 10 colunas, todas do tipo int, chamado tabuleiro. Quando uma matriz é criada, todos os seus elementos ficam vazios. No entanto, podemos definir uma matriz, criar e inicializar seus valores em uma única sentença, por exemplo:

lingüagens e técnicas

de programação II

542

int[][] tabuleiro = {{1,2},{3,4}}; cria uma matriz chamada tabuleiro, com 2 linhas e 2 colunas do tipo int, com os valores 1 e 2 na primeira linha e 3 e 4 na segunda linha.

A Figura 5 ilustra um exemplo de utilização de matriz através de um jogo de damas. O tabuleiro é representado no programa como uma matriz inicializada no construtor com 10 linhas e 10 colunas. Em seguida, temos o método jogar, que recebe posições (linha e coluna) de origem e de destino e efetua o deslocamento da peça no tabuleiro. Figura 5 - Exemplo de matriz no jogo de damas

Fonte: Autoria própria

Coleções Coleções podem ser vistas como estruturas de dados onde podemos armazenar vários objetos. As coleções existem no nosso cotidiano. Por exemplo, quando vamos a uma clínica médica, cujo atendimento é realizado por ordem de chegada, temos uma “fila” de pacientes para serem atendidos, onde o primeiro paciente a chegar à clínica será, também, o primeiro a ser atendido; o segundo paciente a chegar será o segundo a ser atendido, e assim sucessivamente. Podemos ter, então, uma representação de fila como uma coleção de pacientes que obedecem a uma determinada ordem para serem atendidos. As coleções nos oferecem operações predefinidas que nos ajudam a manipular os objetos. Cada tipo de coleção possui suas operações, no entanto, em geral, incluem as seguintes operações básicas:

Acesso aos elementos da coleção Pesquisa aos elementos da coleção Consulta a atributos

de programação II

Exclusão de elementos da coleção

543 lingüagens e técnicas

Inclusão de elementos na coleção

Existem vários tipos de coleções no Java. Estas coleções estão em um pacote chamado java.util e são acessadas a partir da interface collection. A seguir, vamos analisar algumas das estruturas de coleção mais utilizadas disponíveis no Java.

Conjunto (Set)

Modela um conjunto conforme definição matemática de conjuntos, portanto não há elementos repetidos e podem ou não estar ordenados. Em Java, podemos representar conjuntos de 3 formas:

HashSet, implementação de Set, modela conjuntos com elementos não ordenados usando tabela hash; TreeSet, implementado como uma estrutura de árvore LinkedHashSet, implementado com tabela hash e lista encadeada

A Figura 6 ilustra um exemplo de uso de conjuntos com HashSet.

Figura 6 - Exemplo de conjunto com HashSet

Fonte: Autoria própria

lingüagens e técnicas

de programação II

544

Como pode ser observado na figura, primeiro o conjunto chamado nomes é criado como um HashSet. Em seguida, é utilizado o método add para adicionarmos diversos nomes neste conjunto. É possível sabermos o tamanho do conjunto usando o método size(). Também é possível pesquisarmos se determinado nome (ex. Ana) é um elemento do conjunto usando o método contains. Podemos usar também um objeto iterator ao longo do nosso programa, para acessar cada elemento do nosso conjunto. A Figura 7 ilustra um exemplo de Iterator, sendo utilizado com um conjunto do tipo TreeSet. Observe que criamos um identificador iterator e, em seguida, o utilizamos dentro de um loop (while), para percorrer todos os elementos do conjunto.

Figura 7 - Exemplo de conjunto com TreeSet e iterator

________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ Fonte: Autoria própria ________________________ ________________________ Outra maneira de acessar todos os elementos do conjunto é através de um loop ________________________ ________________________ usando a estrutura for, conforme ilustrado na Figura 8. ________________________ Figura 8: Exemplo de conjunto com HashSet e for ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ Fonte: Autoria própria

duas maneiras de implementar listas:

ArrayList - é uma lista implementada com arrays; LinkedList - é uma lista onde os elementos estão ligados. Neste caso, temos uma inser-

lingüagens e técnicas

Uma lista é uma coleção onde seus elementos estão ordenados. Em Java, temos

de programação II

545

Listas

ção e uma deleção de elementos muito mais rápidos que ArrayList.

A Figura 9 ilustra um exemplo de lista utilizando o ArrayList. Observe que criamos a lista nomes, adicionamos elementos na lista e acessamos estes elementos informando no método get o índice do elemento desejado. No exemplo, será impresso o nome Rosa.

Figura 9 - Exemplo de lista com ArrayList

________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ Fonte: Autoria própria ________________________ ________________________ Em uma lista, cada um dos elementos possui o seu sucessor (menos o último) ________________________ e o seu antecessor (menos o primeiro). A seguir, estão listadas as principais operações ________________________ que podemos realizar quando trabalhamos com listas: ________________________ ________________________ ________________________ Adicionar um objeto em qualquer lugar da lista; ________________________ ________________________ Remover um objeto de qualquer lugar da lista; ________________________ Obter um elemento localizado em qualquer lugar da lista; ________________________ Percorrer os elementos da lista; ________________________ ________________________ Verificar se um elemento faz parte da lista; ________________________ Descobrir o índice que faz referência a um elemento específico na lista;

Obter a quantidade de elementos da coleção.

de programação II

Mapas

lingüagens e técnicas

546

Um mapa é uma estrutura que utiliza uma chave e contém um mapeamento entre esta chave e o valor armazenado. A chave e o valor podem ser de qualquer tipo de dado, ordenado ou não. As chaves são utilizadas para otimizar o processo de busca de um elemento, pois, desta forma, é possível usar algoritmos especiais de busca. Uma chave é sempre única, ou seja, um mapa não pode conter duas chaves com o mesmo valor. Existem 3 tipos de mapas: HashMap; Hashtable e SortedMap. Os principais métodos associados ao mapa são:

put (chave, valor), para incluir um par formado pela chave/elemento no mapa; get (chave), para retorna o valor correspondente à chave passada como parâmetro.

A Figura 10 ilustra um exemplo de HashMap, usando os métodos put e get. Observe que criamos o mapa cuja chave e cujo valor são do tipo String. Em seguida, usamos o método put para incluir diversos pares de chave e valor no mapa. Quando precisamos recuperar um valor, informamos a sua chave e, através do método get, recuperamos o valor correspondente.

Figura 10 - Exemplo de mapa com HachMap

Fonte: Autoria própria

SÍNTESE Nesta aula, aprendemos a trabalhar com estruturas de programação em Java

547 de programação II

da a objetos e estudaremos herança e polimorfismo.

lingüagens e técnicas

Na próxima aula, iniciaremos os conceitos avançados de programação orienta-

que podem guardar coleção de elementos. Inicialmente, vimos as estruturas básicas de arrays unidimensionais (vetores) e multidimensionais (matrizes). Em seguida, vimos as estruturas de coleções que nos oferecem mais recursos para inclusão, exclusão, pesquisa de elementos etc. Dentre elas, aprendemos a trabalhar com conjuntos, listas e mapas.

QUESTÃO PARA REFLEXÃO Existem vários tipos de coleções na linguagem Java disponíveis para serem utilizadas pelos programadores. Analise as diferenças de aplicabilidade desses vários tipos de coleções disponíveis.

LEITURA INDICADA BARNES, J. David; KÖLLING, Michael. Programação orientada a objetos com Java: uma introdução prática usando o Blue J. 4. ed. São Paulo: Pearson, 2004.

SITES INDICADOS http://java.sun.com/docs/books/tutorial/collections/intro/index.html http://pt.wikinourau.org/bin/view/GrupoJava/SlidesIntroducaoAsColecoes http://dietinf.ifrn.edu.br/lib/exe/fetch.php?media=corpodocente:marilia:disciplinas:2 008.2:poo:14_colecoes.pdf

REFERÊNCIAS BARNES, J. David; KÖLLING, Michael. Programação orientada a objetos com Java: uma introdução prática usando o Blue J. 4. ed. São Paulo: Pearson, 2004.

DEITEL, H. M.; DEITEL, P. J. Java: como programar. 6. ed. São Paulo: Pearson Prentice Hall, 2005.

lingüagens e técnicas

de programação II

548

549

Autora: Ana Patrícia F. Magalhães Mascarenhas

lingüagens e técnicas

Na aula passada aprendemos a trabalhar com coleções de dados. Desta forma podemos manipular vários elementos de dados utilizando o mesmo identificador.

de programação II

AULA 06 - HERANÇA E POLIMORFISMO

Na aula de hoje começaremos a ver conceitos avançados de programação orientada a objetos, dentre eles herança, polimorfismo e classes abstratas.

herança O paradigma da orientação a objetos (OO) utiliza muitos conceitos do nosso cotidiano para representar as suas estruturas de programação. Um deles é o conceito de herança. Na nossa vida, quando dizemos que uma pessoa se parece com o seu pai, tem os olhos da sua mãe ou a habilidade de desenhar do avô, estamos querendo dizer que essa pessoa herdou estas características dos seus ancestrais. A figura 1 ilustra um exemplo de herança no nosso mundo real. Todo animal tem algumas características comuns entre si, por exemplo, o nome e a idade. Estas características podem ser herdadas de uma estrutura genérica que represente animais. ________________________ Da mesma forma, os animais podem ser classificados em alguns tipos específicos com ________________________ características distintas. Por exemplo, os mamíferos têm uma maneira diferente de se ________________________

________________________ ________________________ ________________________ Figura 1: exemplo de herança no mundo real ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ Fonte: autoria própria ________________________ ________________________ De forma semelhante temos o conceito de herança na programação orientada ________________________ a objetos. Herança é a capacidade de uma classe definir o seu comportamento e sua ________________________ ________________________ estrutura aproveitando definições de outra classe. reproduzir em relação aos répteis e às aves.

lingüagens e técnicas

de programação II

550

A figura 2 ilustra um exemplo de herança para um sistema que trabalha com seres vivos. Podemos notar uma estrutura hierárquica com vários níveis. A primeira classe, Animais, contém as definições genéricas a todos os tipos de animais. Por exemplo, todo animal tem um nome. No segundo nível temos uma especialização dos animais em Mamiferos, Repteis e Aves. Considere que para os mamíferos precisamos saber, além do nome, o tipo de alimento que consomem. Para os répteis, precisamos do local onde se reproduzem e para as aves a sua espécie. Os mamíferos podem ainda ser especializados em Racionais e Irracionais. Os racionais devem conter o nível de escolaridade. Figura 2: Exemplo de herança em um diagrama de classes

Fonte: autoria própria

Nesta estrutura hierárquica que representa a nossa herança damos o nome de classe pai, superclasse, generalização ou classe base para a classe que contém as definições que serão herdadas, ou seja, a classe mais acima na hierarquia. As classes herdeiras são chamadas de classes filhas, subclasse, especialização ou classe derivada. Quando dizemos que uma classe herda características de outra classe, estamos nos referindo às definições de atributos e métodos. Desta forma, no exemplo ilustrado na figura 2, dizemos que a classe Racionais contém os atributos nome, alimento e nívelEscolaridade e os métodos que tenham sido definidos para a estrutura. A herança de características entre classes acontece sempre de cima para baixo na estrutura hierárquica, ou seja, no exemplo da figura 2, a classe Mamífero herda características de Animal e a classe Racional herda as características de Mamífero. A semelhança existente entre Mamíferos e Aves vem apenas do fato de ambas herdarem características de um mesmo Pai, ou seja, não existe herança no sentido horizontal da estrutura hierárquica (Ave não herda de Mamífero ou vice-versa).

Herança em Java

Para criarmos uma estrutura de herança em Java utilizamos a palavra reservada extends, indicando que uma classe filha estende as definições de uma classe pai. A

Figura 3: Exemplo de herança em Java

551 de programação II

exemplo da figura 2.

lingüagens e técnicas

figura 3 a seguir ilustra a criação das classes Animal, Mamifero e Racional descritas no

Fonte: autoria própria

Na figura 3 (A) temos a classe Animal. Por se tratar da classe inicial da estrutura de herança, ela é definida como uma classe simples, iguais as outras já definidas em aulas anteriores. A figura 3 (B) apresenta a definição da classe Mamífero. Observe logo na primeira linha a indicação de que Mamífero extends Animal para informar que temos o primeiro nível de herança criado. É importante notar que não precisamos redefinir os ________________________ atributos que já foram definidos na classe Animal, no entanto, precisamos recebê-los ________________________ no construtor da classe Mamífero. Na prática, o sistema que irá utilizar a classe Mamífe- ________________________ ro não precisa ter conhecimento da estrutura de herança a qual a classe está amarrada. ________________________ É preciso saber quais são todos os atributos que a classe contém para, caso necessário, ________________________ informá-los no construtor. Observe que a assinatura do construtor de Mamífero con- ________________________ tém todos os atributos de Animal e todos os atributos de Mamífero. Podemos também ________________________ utilizar as definições da nossa classe pai explicitamente através da palavra reservada ________________________ super. Observe na figura 3 (B) que no construtor utilizamos super(nome,idade); para ________________________ acessar o construtor da classe Animal. A palavra reservada super pode ser utilizada nos ________________________

________________________ ________________________ ________________________ Para fazer uma referência à classe base (pai) do objeto; ________________________ Para fazer acesso a variáveis escondidas que têm o mesmo nome de uma variável de- ________________________ ________________________ finida em uma classe filha; ________________________ Para fazer acesso a métodos que foram redefinidos, ou seja, métodos que possuem a ________________________ mesma assinatura na classe Pai e na classe filha; ________________________ Para a classe filha acessar o construtor da classe pai. ________________________ ________________________ ________________________ ________________________ Polimorfismo ________________________ ________________________ seguintes casos:

Quando utilizamos o mecanismo de herança estamos criando uma relação de

lingüagens e técnicas

de programação II

552

generalização/especialização entre classes que pode ser lida como uma relação é um tipo de. Isso significa dizer que partimos de uma estrutura mais genérica para uma estrutura mais especializada (ex. Animal para Mamifero) onde estabelecemos que as classes filhas são tipos de classe pai (ex. Mamífero é um tipo de Animal e Racional é um tipo de mamífero que é um tipo de animal). A relação é um tipo de nos possibilita a utilização de outro conceito bastante importante da OO que é o conceito de Polimorfismo. Polimorfismo (“muitas formas”) permite a manipulação de instâncias de classes que herdem de uma mesma classe ancestral de forma unificada. Em outras palavras, podemos definir uma variável como sendo do tipo da nossa classe pai (ex. Animal) e colocar nela uma referência para objetos criados a partir de classes filhas (ex. Mamífero ou Aves). Assim, podemos criar classes que respondam a um mesmo método de forma diferente. Por exemplo, podemos criar um método locomover que vai se comportar de maneira diferente para um Animal do tipo Mamífero, para um Animal do tipo Ave ou para um Animal do tipo Réptil. Para ilustrar o conceito de polimorfismo, vamos usar um exemplo de sistema para uma livraria. Considere que uma livraria comercializa títulos que podem ser Livros ou Revistas. Todo título comercializado pela livraria possui um nome, um autor e um ano de publicação. Os livros possuem também um resumo. As revistas possuem a edição e a semana. Precisamos construir uma estrutura de classes que represente os

títulos da livraria e precisamos criar uma rotina para imprimir os dados de um título qualquer. A figura 4 ilustra a estrutura de classes montada para atender ao sistema. Temos uma classe pai chamada Titulo e duas classes filhas: Livro e Revista. Isso significa dizer que Livro é um tipo de Titulo e Revista também é um tipo de Titulo. Assim, Livro possui como atributos o nome, o autor e o ano, herdados da classe Titulo e o resumo, específico para um Livro.

Figura 4: Exemplo de polimorfismo

Fonte: autoria própria

A figura 5 ilustra o código fonte referente à criação das classes da estrutura mo-

consequência, seus respectivos construtores apresentam as chamadas para o construtor da classe Titulo, aproveitando as suas definições. Observe, também, que cada uma das classes contém o método retornarDados(), todos com a mesma assinatura, porém com implementações diferentes, ou seja, métodos polimórficos.

553 de programação II

Titulo (extends Titulo) e a classe Revista também herda de Titulo (extends Titulo). Como

lingüagens e técnicas

delada na figura 4. Como podemos observar, a classe Livro herda as características de

Para usarmos o polimorfismo, precisamos estar dentro de uma estrutura de herança. Além disso, precisamos ter um método criado na classe pai e redefinido nas classes filhas com a mesma assinatura. Figura 5: Código fonte das classes do sistema de livraria

Fonte: autoria própria

Agora vamos ilustrar a utilização destes métodos por um programa qualquer. A figura 6 ilustra a classe Livraria com um método main para testar as classes Titulo, Livro e Revista. Inicialmente definimos uma variável titulo1 do tipo Titulo. Em seguida, instanciamos um objeto da classe Livro e o referenciamos a partir da variável titulo1. Isso é possível porque Livro é um tipo de Titulo, portanto a linguagem aceita esta construção. Quando mandamos executar o método retornaDados() é executado o método correspondente à classe Livro, pois embora o objeto seja referenciado por uma variável do tipo Titulo, o objeto criado é do tipo Livro. O mesmo acontece quando criamos uma variável titulo2 e instanciamos nela um objeto da classe Revista. Se chamarmos o método retornaDados(), será executado o método correspondente à classe Revista e não o da classe Titulo. O exemplo ilustrado na figura 6 acontece devido ao tipo de ligação existente entre o objeto e a variável que o referencia. O processo de ligação de uma invocação

lingüagens e técnicas

de programação II

554

de um método ao corpo equivalente correto é conhecido por biding ou ligação. Existem dois tipos de ligação possíveis: early biding (ligação cedo) e late biding (ligação tardia).

Figura 6: Código fonte da classe Livraria para testar as demais classes.

Fonte: autoria própria

Early Binding

O Early binding é a ligação realizada pela linguagem em tempo de compilação. Esta ligação utiliza como base o tipo de dado em que as variáveis foram definidas. Como a ligação é feita durante a compilação, a execução do programa é realizada de forma mais rápida. O early binding é utilizado pelas linguagens procedurais. Em java, usamos para binding de método Final.

Late Binding

O Late biding é uma ligação definida em tempo de execução onde é analisado o tipo do objeto que está sendo referenciado pela variável no momento do processamento. Por este motivo, quando criamos a variável titulo1 e colocamos nela um objeto da classe Livro, a execução do método retornaDados() foi feita na classe Livro. Este tipo de ligação garante maior flexibilidade na execução e viabiliza o polimorfismo, pois somente em tempo de execução é decidido que método vai ser chamado dentro de uma estrutura de herança. É uma ligação utilizada pelas linguagens orientadas a objetos.

upCast

UpCast consiste na possibilidade de um objeto da classe filha fazer referência

Em algumas situações pode ser necessário saber qual o tipo específico (dentre as classes filhas disponíveis) de um objeto referenciado por uma variável do tipo genérico (classe pai). Nestes casos, podemos usar o operador instanceof para verificar se o seu primeiro operando, que é uma variável qualquer, aponta para um objeto de uma determinada classe definida no seu segundo operando.

555 de programação II

jeto da classe filha é um tipo de objeto da classe pai.

lingüagens e técnicas

por um ponteiro à classe pai. Isso acontece porque, como dito anteriormente, um ob-

Figura 7: Exemplo de UpCast

Fonte: autoria própria

A figura 7 ilustra um exemplo de UpCast. No exemplo, uma classe chamada Teste possui um método equals que recebe como parâmetro um objeto da classe Titulo qualquer (pode ser um objeto da classe Livro ou um objeto da classe Revista). Dentro do corpo do método, é verificado qual o tipo do objeto, se for Livro, retorna-se true, caso contrário, retorna-se false.

Classes abstratas A adoção de padrões na construção de software é uma tendência seja para projetos, códigos, entre outros artefatos que podem ser padronizados. A classe abstrata é um mecanismo da OO para criar definições genéricas de uma determinada categoria de elementos de um sistema, originando assim um padrão de desenvolvimento. Por exemplo, supomos que na nossa Livraria, títulos serão sempre especializados em alguma categoria, por enquanto temos Livros e Revistas, e que não desejamos criar um título que não esteja especializado. A maneira mais apropriada que temos para criar este programa é definirmos a classe Titulo como uma classe abstrata. Desta forma, não será possível instanciar objetos diretamente da classe, apenas a partir das suas especializações: Livro e Revista. Podemos definir então classes abstratas como classes cujas definições servem como padrão para criação de outras classes. Uma classe abstrata pode ter dois tipos de métodos: métodos genéricos, com implementação padrão que será utilizada pelas classes filhas; ou métodos abstratos, métodos que contêm apenas a assinatura e ne-

lingüagens e técnicas

de programação II

556

nhuma implementação. Desta forma, quando uma classe filha herdar as definições de uma classe abstrata poderá utilizar seus métodos genéricos e terá obrigatoriamente que implementar seus métodos abstratos. Como as classes abstratas não são totalmente implementadas (por exemplo, nos métodos abstratos), não produzem instâncias, ou seja, não podemos criar objetos dessas classes. Elas agrupam atributos e métodos que serão herdados por outras classes e determinam padrões de comportamento para serem implementados nas classes filhas. Para definir classes abstratas, usa-se a palavra chave abstract na declaração da classe: Ex.: abstract class Titulo{...}

Para definir um método abstrato, usamos a palavra abstract na declaração da assinatura do método Ex.: public abstract float calculaPrecoTitulo(); A figura 8 ilustra o exemplo da livraria utilizando o conceito de classe abstrata. Como podemos observar, a classe Titulo (topo da figura 8) agora é abstrata. Ela contém, além das definições que já havíamos feito anteriormente, um método abstrato chamado calculaPrecoTitulo(). Este método não tem nenhuma implementação. A classe Livro (do lado esquerdo da figura 8) herda de Titulo. Por este motivo,

________________________ obrigatoriamente, é preciso implementar o método abstrato calculaPrecoTitulo(), ago________________________ ra sem colocar a palavra abstract. O mesmo acontece para a classe Revista. ________________________ ________________________ Figura 8: Exemplo de classe abstrata e método abstrato ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ Fonte: autoria própria ________________________

classe abstrata tiver somente métodos abstratos, podemos criá-la como uma Interface. Assim como classes abstratas, as interfaces também não podem ser instanciadas e não é preciso colocar a definir o modificador de acesso, pois todos os métodos são implicitamente abstract e public. Caso tenha algum atributo, ele será implicitamente static e final e deverá ser inicializado na declaração.

lingüagens e técnicas

Classes abstratas podem conter métodos abstratos e não abstratos. Se uma

de programação II

557

Interface

Para criarmos uma interface em Java, usamos a palavra reservada interface e não criamos construtores. A figura 9 ilustra um exemplo de inteface. Como podemos observar, temos inicialmente a definição da interface Figura com dois métodos calculaArea() e calculaPerimetro(). Em seguida, temos uma classe chamada Retangulo que implementa a interface Figura. Nesta classe, os métodos foram implementados. Figura 9: Exemplo de interface

Fonte: autoria própria

Vantagens do uso de herança e polimorfismo Para melhor ilustrar o conceito de Herança e Polimorfismo, e evidenciar suas vantagens, vamos considerar que precisamos construir um sistema para os Correios para controlar a cobrança do pagamento para envio de correspondências de acordo com a seguinte especificação. O correio possui várias agências espalhadas pela cidade onde cada agência possui um código e um nome. Essas agências recebem as correspondências que serão enviadas para um destinatário. Para enviar uma correspondência, o cliente deve pagar uma taxa e informar seu nome (emitente) e os dados do destinatário (nome do destinatário, rua, CEP, número, bairro, cidade, estado e complemento do endereço). As correspondências podem ser cartas ou encomendas. As encomendas possuem um peso (em kilos). Caso o cliente deseje que a encomenda seja entregue com

lingüagens e técnicas

de programação II

558

urgência, pode escolher enviar uma encomenda do tipo sedex, neste caso é necessário informar o CPF do emitente. O valor da taxa cobrada para o envio de uma correspondência varia a depender do tipo de correspondência que está sendo enviada. Para cartas é cobrado um valor fixo de R$ 1.00 Para correspondências do tipo encomendas, é cobrado R$ 10.00 por kilo. Caso a encomenda seja por sedex, é cobrado um adicional de 30% do valor calculado para a encomenda. O primeiro passo na construção do nosso sistema é a definição das classes que precisarão ser criadas. A figura 10 ilustra as classes definidas para o sistema dos Correios. Como podemos observar, o Correio é formado por objetos da classe Agencia onde cada Agencia possui um conjunto de objetos do tipo Correspondencia com as correspondências a serem enviadas. A classe Correspondencia foi mapeada como abstract e especializada em Carta ou Encomenda. A classe Encomenda por sua vez foi especializada em Sedex.

Figura 10: Estrutura de classes para o sistema de Correio

Fonte: autoria própria

A figura 11 mostra em Java o código correspondente a algumas das classes mapeadas para o sistema de Correio. Em (A) temos a classe Correspondencia, abstrata, com o método calculaTaxa também abstrato. Observe que não há implementação para o método calculaTaxa nesta classe, apenas a definição da assinatura. Em (B) temos a classe Carta especializando Correspondência. O construtor de Carta contém todos os parâmetros de Correspondência e chama em sua implementação o construtor da classe pai “super(ne,nd,ed);”. O método calculaTaxa é agora implementado e conserva a mesma assinatura da definição realizada na classe Correspondencia excluindo apenas a palavra abstract. O mesmo acontece na classe Encomenda (C). Em (D) temos a classe Sedex que especializa a classe Encomenda e tem em seu construtor todos os

e depois acrescentado 1.3f que corresponde a 30% do valor da encomenda, conforme especificado para o sistema.

Figura 11: Código fonte das classes para o sistema de Correio

Fonte: autoria própria

Vamos considerar agora que precisamos evoluir este sistema para trabalhar com um novo tipo de correspondência que são as correspondências eletrônicas, por email. O emitente manda um email usando o site do Correio que possui certificação digital de segurança. Para isso, é cobrado uma taxa de R$ 2.00 por mensagem. Para efetuar esta modificação, precisamos apenas criar uma nova subclasse associada à classe Correspondencia e implementar o método calculaTaxa obrigatório para todas as classes filhas de Correspondencia. Todo o restante da estrutura é aproveitada pela nova implementação. Esta característica é um dos diferenciais do paradigma de orientação a objetos, pois facilita a manutenção e a evolução dos sistemas. Os conceitos aprendidos nesta aula são de grande importância para construirmos softwares orientados a objetos. Na próxima aula continuaremos a ver conceitos avançados de OO.

559 de programação II

o método calculaTaxa. Observe que neste caso, é chamado o método da sua classe pai

lingüagens e técnicas

dados necessários para criar uma encomenda Sedex. Esta classe também implementa

lingüagens e técnicas

de programação II

560

SÍNTESE Nesta aula, aprendemos os conceitos avançados de orientação a objetos. Vimos que classes podem ser agrupadas em estruturas hierárquicas que partem de definições genéricas e são especializam em classes mais específicas. A esta organização damos o nome de herança. Assim, nos sistemas orientados a objetos uma classe pode herdar características (atributos e métodos) de outra classe. Dentro da estrutura de herança, podemos criar métodos que tenham a mesma assinatura e implementações diferentes, ou seja, para um mesmo método classes podem responder de forma diferente. A este conceito demos o nome de polimorfismo. Podemos também criar definições padrões de classes para serem herdadas por outras classes dentro do nosso sistema. A estas classes damos o nome de classes abstratas. Classes abstratas não podem instanciar objetos, servem apenas como padrão, e podem conter métodos comuns (genéricos) ou métodos abstratos (que não possuem implementação). Os métodos abstratos devem obrigatoriamente ser implementados nas classes filhas. Estes conceitos avançados de OO permitem viabiliza a construção de sistemas modulares, fáceis de evoluir e de manter.

QUESTÃO PARA REFLEXÃO Classes abstratas é um mecanismo bastante utilizado pelos programadores para garantir a boa evolução dos sistemas. Analise quais os benefícios que este conceito pode trazer para o sistema de Livraria visto nesta aula.

LEITURAS INDICADAS BARNES, J. David, KÖLLING, Michael. Programação Orientada a Objetos com Java: uma introdução prática usando o Blue J. 4.ed. São Paulo: Pearson, 2004.

ca usando o Blue J. 4.ed. São Paulo: Pearson, 2004.

DEITEL, H. M., DEITEL, P. J. Java: Como Programar. 6. ed. São Paulo: Pearson Prentice Hall, 2005.

de programação II

BARNES, J. David, KÖLLING, Michael. Programação Orientada a Objetos com Java: uma introdução práti-

561 lingüagens e técnicas

REFERÊNCIAS

lingüagens e técnicas

de programação II

562

Muitas vezes quando executamos um programa podem acontecer problemas que não foram previstos pelo programador durante o desenvolvimento do sistema. Assim, precisamos preparar nossos programas para tratar estes erros e garantir a continuidade da aplicação. Na aula de hoje aprenderemos como fazer o controle e tratamento de erros nos nossos programas.

de programação II

Autora: Ana Patrícia F. Magalhães Mascarenhas

563 lingüagens e técnicas

AULA 07 - TRATAMENTO DE EXCEÇÕES

Exceção Quando construímos um programa, temos que nos preocupar com os possíveis problemas que podem acontecer durante a execução do mesmo. Por exemplo, considere que estamos construindo um programa para receber o nome, o ano de nascimento de uma pessoa e o ano atual e calcular a sua idade (Figura 1).

Figura 1: Programa para calcular a idade de uma pessoa

Fonte: A autora

Vamos analisar duas execuções para este programa. No primeiro caso informamos o nome Maria, o ano de nascimento 1980 e o ano atual 2012. O programa, então, calcula a idade subtraindo o ano atual (variável anoAtual) do ano de nascimento (variável ano) e apresenta como resultado a idade de Maria. A figura 2 ilustra esta execução.

Figura 2: Execução normal do programa ilustrado na figura 1

lingüagens e técnicas

de programação II

564

Fonte: A autora

No segundo caso, vamos supor que o usuário, quando solicitado para informar o seu ano de nascimento, escreva o ano por extenso. Nesta situação o programa apresenta um problema, pois a variável ano, que recebe o valor digitado, foi declarada como sendo do tipo int e, portanto, só aceita números inteiros. A figura 3 ilustra esta execução com problema. Observe que quando foi digitado o ano de nascimento, o programa apresentou um problema Exception in thread “main” java.util.InputMismatchException e encerrou a execução sem pedir para informar o ano atual.

Figura 3: Execução com problema do programa ilustrado na figura 1

Fonte: A autora

No caso ilustrado na figura 3, dizemos que o programa levantou uma exceção, ou seja, caiu em um caso que não é o seu normal. Para Deitel (2010), a exceção é uma indicação de um problema que ocorre durante a execução de um programa. Muitos problemas podem acontecer durante a execução de um programa, por exemplo, podemos ter problemas de entrada de dados (como o apresentado no exemplo anterior), problemas com operações aritméticas (a exemplo de divisões pode zero), problemas de acesso a um banco de dados que não existe, entre outros.

danosas ao usuário, tais como perda de dados ou interrupção de um serviço.

Tratamento de Exceção

565 de programação II

para que o programa não seja encerrado de maneira abrupta e tenha consequências

lingüagens e técnicas

Os programadores devem se preocupar com o tratamento destes problemas

Para evitarmos o encerramento inadequado de um programa, devemos nos preocupar com o tratamento de exceções. Para ilustrar este procedimento, vamos utilizar o mesmo exemplo da figura 1. Neste caso, precisamos prever que o usuário poderá digitar um dado que não seja o ideal para o programa e tomarmos alguma providência quando isso acontecer. A figura 4 ilustra o tratamento de exceção para o exemplo do programa de calculo de idade. Figura 4: Tratamento de exceção para o programa da figura 1

lingüagens e técnicas

de programação II

566

acesso ao tratamento de exceção para o erro específico de entrada de dados com tipo diferente do especificado na variável. Em seguida, incluímos no nosso código principal uma instrução para monitorar possíveis problemas, a instrução try. Finalmente, colocamos um trecho de código que será executado quando o problema de entrada de dados ocorrer e será responsável por dar uma mensagem ao usuário informando como deve ser digitado o dado solicitado. A figura 5 ilustra o resultado na execução deste programa. Inicialmente foi digitado o ano de nascimento por extenso. O programa então exibiu a mensagem informando que deveria ser digitado um número inteiro e retornou ao início. Finalmente o usuário informou corretamente todos os dados e o programa apresentou o resultado executando seu fluxo normal.

Figura 5: Execução do programa ilustrado na figura 4

Fonte: A autora

Estrutura básica do tratamento de exceções

O tratamento de exceção obedece a uma estrutura pré-definida conforme ilustrado na figura 6. O bloco compreendido pela instrução try{} será o bloco monitorado, ou seja, qualquer exceção que ocorrer dentro do try{} será lançada (throw), ou seja, a execução será desviada para o bloco catch correspondente. Podem existir diversos blocos catch para um mesmo try, pois podemos fazer tratamento para vários tipos de exceções diferentes. Dizemos que o bloco catch é responsável por capturar e tratar uma exceção. O bloco catch recebe um parâmetro, um objeto com o erro ocorrido, e contém um bloco de comandos para tratamento deste erro delimitado pelo {}. É necessário ter, ao menos, um bloco catch ou um bloco finally (explicado a seguir) depois de um bloco try. Algumas vezes, precisamos garantir a execução de um bloco de código sempre,

o arquivo texto. Caso aconteça algum problema na leitura de uma das linhas, devemos garantir que o arquivo texto aberto será fechado, para que não tenhamos problema na próxima execução do programa. Nestes casos, podemos utilizar a cláusula finally do tratamento de exceções. Esta cláusula aparece ao final dos blocos catch e delimita um bloco de código que será sempre executado, mesmo que o processamento normal não ocorra devido a algum problema.

567 de programação II

ma vai abrir um arquivo texto, ler cada uma das linhas e processar, e, ao final, vai fechar

lingüagens e técnicas

mesmo que o nosso programa contenha erros. Por exemplo, imagine que seu progra-

Figura 6: Estrutura básica de tratamento de exceções em Java

Fonte: A autora

Exceções podem não ser capturadas, mesmo que tenhamos um bloco try. Isso acontece quando não tivermos nenhum bloco catch que esteja tratando o tipo de exceção levantada pelo programa principal. É importante frisar que quando acontece um problema no código principal de uma aplicação monitorado por um bloco try, a execução é interrompida e o controle passa para o bloco catch que captura a exceção levantada. Após a execução do bloco catch, a execução vai para a primeira linha após os blocos trys, ela não retorna para o ponto do programa principal que levantou o problema.

A classe Throwable Java possui uma estrutura hierárquica (herança) que organiza os tipos de exceções que podem ser tratados pelos programadores. Por definição, segundo Deitel (2020, s.p.), “todas as classes de exceção do Java herdam direta ou indiretamente da classe Exception.”

lingüagens e técnicas

de programação II

568

A figura 7 ilustra a estrutura de classes Exception (que herda da classe Throwable) com algumas de suas subclasses. Existem centenas de classes possíveis para o tratamento de erros no Java que podem ser acessadas em java.sun.com/javase/6/ docs/api/java/lang/Throwable. Os programas que desenvolvemos geralmente tratam exceções. A classe Error, em geral, representa erros da máquina virtual, que acontecem raramente e não são tratados pelos programadores. Figura 7: Parte da hierarquia de herança da classe Exception

Fonte: Adaptado de Deitel (2010, p. 343)

Os problemas capturados por exceções que herdam da classe RuntimeException são considerados problemas no código fonte do programa e são chamadas de exceções não verificadas. Por exemplo, se acessamos em um vetor um índice que não existe temos a exceção IndexOutOfBoundExecption. As demais exceções são chamadas de exceções verificadas e dizem respeito a problemas fora do controle do nosso programa, como, por exemplo, entrada de dados. Desta forma, o compilador faz uma verificação no código do programa para identificar as possíveis exceções verificadas e checa se foram definidos blocos catch para capturar essas exceções. No caso de exceções não verificadas, o compilador Java não faz nenhuma verificação. Assim, o programador precisa estar atento para fazer o devido tratamento quando identificar que algum problema poderá ocorrer. É importante lembrar que, considerando a estrutura hierárquica de herança descrita na figura 7, se tivermos mais de um bloco catch possível de capturar o mesmo problema, apenas o primeiro será executado. Por exemplo, podemos ter um bloco catch para capturar uma exceção IOException seguido de um bloco catch para capturar uma exceção Exeption. Neste caso, apenas o primeiro será executado. A instrução throw Até este momento, trabalhamos com o tratamento de exceções capturadas do próprio programa.

569 lingüagens e técnicas

de programação II

Figura 8: Exemplo de lançamento de exceção

Fonte: Adaptado de Deitel (2010, p.346)

O programador pode lançar a sua própria exceção utilizando a instrução throw, especificando o objeto a ser lançado, utilizando qualquer subclasse da classe Throwable. É possível, também, relançar uma exceção, caso o bloco catch que a capturou não consiga tratá-la completamente. Isso significa que o erro será capturado por um bloco try...catch externo. Para fazer o relançamento, também utilizamos a instrução throw seguida do objeto capturado de exceção pelo catch. Não é possível relançar exceções de dentro de um bloco finally. A figura 8 ilustra um exemplo de lançamento e relançamento de exceção. No exemplo temos 3 métodos: o método main, principal, executado inicialmente; o meto-

lingüagens e técnicas

de programação II

570

do1, chamado no corpo do método main; o metodo2, chamado também pelo método main. O método main é monitorado por uma instrução try e chama inicialmente o método1. Observe que na assinatura do método1 public static void metodo1() throws execption, temos a declaração de que uma exceção poderá ser lançada pelo programador. Na execução deste método, temos uma instrução try monitorando o código principal que imprime uma mensagem System.out.println(“estamos no metodo1”); e lança uma exceção throw new Exception(); No momento em que a exceção é lançada, o bloco catch a recupera catch (Exception e2){ emite uma mensagem e relança a exceção throw e2; Esse relançamento faz com que a instrução try externa que chamou o método1, ou seja, a instrução try do método main seja ativado e capture o erro relançado. No entanto, antes desta captura, o bloco finally do metodo1 é completamente executado. Quando o bloco catch do método main captura a exceção relançada, processa e continua sua execução chamando o metodo2. O método2 como não lança nenhuma exceção, é completamente executado (inclusive a sua cláusula finally) não tendo a necessidade de processar o seu bloco catch. A figura 9 ilustra o resultado da execução do exemplo ilustrado na figura 8. Observe que foram impressas algumas mensagens para acompanharmos o fluxo da execução do programa. Inicialmente, quando o método main é executado, chama o método1 e temos a mensagem estamos no metodo1. Em seguida, a exceção é lança-

da no método1 e capturada no catch, então temos a mensagem exceção tratada no metodo1. Embora este catch relance a exceção, antes de ela ser capturada pelo bloco try externo (main) o finally do metodo1 é executado, temos a mensagem execucao do finally no metodo1. Em seguida, temos a mensagem impressa pelo catch do método main exceção tratada no main que capturou a exceção relançada; temos a chamada ao método2 com a mensagem estamos no metodo2; temos a execução do método2, com a mensagem execucao do finally no metodo2 e finalmente a aplicação termina com a mensagem fim do metodo2, pois nenhuma exceção foi lançada no metodo2 A execução de lançamento e relançamento de exceções é feita utilizando o conceito de pilha. Exceções são empilhadas quando são lançadas e desempilhadas quando capturadas pelo try externo.

Criação de novos tipos de exceção

É possível que um programador crie sua própria classe de exceção atendendo a problemas específicos de sua aplicação. Para tanto, se deve criar classes que estendam a definição de alguma classe de exceção já existente, ou seja, que sejam subclasses de alguma classe existente na estrutura hierárquica da classe Exception.

571 lingüagens e técnicas

de programação II

Figura 9: Execução do exemplo ilustrado na figura 8

Fonte: A autora

Impressão de dados sobre uma exceção

Para obtermos informações sobre as exceções, utilizamos alguns métodos fornecidos pela classe Throwable. Alguns deles são:

printStackTrace e printStackTrace, que contêm informações sobre o rastreamento do erro na pilha; getMessage, que retorna uma String com a descrição da mensagem de erro.

Essas informações são importantes, pois ajudam na depuração dos programas e na correção dos problemas.

A figura 10 ilustra um exemplo de uso dos métodos da classe Throwable para obter informações sobre os erros capturados.

No exemplo, temos uma classe com 4 métodos: main, que chama o metodo1; metodo1, que chama o metodo2; metodo2 que chama o metodo3; e metodo3 que lança a exceção.

No método main, temos um bloco try com um catch que será responsável por imprimir as informações que desejamos sobre os erros capturados. Observe que para isso foi utilizado o método getStackTrace() que captura as informações dos erros lançados e armazena em um vetor. Depois, este vetor é percorrido (através da instrução for) e cada um dos erros lançados é impresso.

Observe que a assinatura dos demais métodos indica que exceções devem ser relançadas para o try externo, instrução throws Exception

lingüagens e técnicas

de programação II

572

Quando o metodo3 lança a exceção, ela é passada para o método2 que relança para o método1 que relança para o método main, que por fim realiza a impressão dos dados.

Figura 10: Impressão de informações sobre erros

Fonte: Adaptado de Deitel (2010, p.350)

a impressão realizada pela nossa instrução for.

Figura 11: Resultado da execução do programa ilustrado na figura 10

Fonte: A autora

Os conceitos aprendidos nesta aula são de grande importância para construirmos softwares robustos, pois um programa deve estar apto a tratar possíveis anormalidades que venham a acontecer durante a execução.

SÍNTESE Nesta aula, aprendemos a trabalhar com exceções na linguagem Java. Vimos que durante a execução de um programa podem acontecer erros que precisam ser monitorados e tratados para que não causem problemas ao bom funcionamento da aplicação. Para o tratamento de exceções em Java, utilizamos a classe Exception e suas respectivas subclasses. Assim, quando precisamos monitorar um código fonte qualquer, utilizamos a instrução try{}. A instrução try é associada a um ou mais blocos catch responsáveis por capturar uma exceção quando ela acontecer e pode conter um bloco finally com códigos que serão sempre executados. O programador pode capturar uma exceção e tratá-la ou pode relançar a exceção para ser tratada em um try externo. Também é possível criar novas classes de

573 de programação II

dos dados de um erro. Inicialmente, temos a impressão do erro original e em seguida

lingüagens e técnicas

A figura 11 mostra a impressão do resultado da execução do teste de impressão

lingüagens e técnicas

de programação II

574

exceção customizadas de acordo com as necessidades de uma aplicação específica. A classe Exception oferece também uma série de métodos que permite ao programador capturar informações sobre os erros capturados e assim facilitar o processo de correção destes erros.

QUESTÃO PARA REFLEXÃO Analise a importância do tratamento de exceção na qualidade dos softwares no que se refere à comunicação do sistema com o usuário final.

LEITURAS INDICADAS Capítulo 11 do livro de Paul Deitel

SITES INDICADOS ________________________ http://www.tiexpert.net/programacao/java/try-catch-finally.php ________________________ ________________________ ________________________ ________________________ REFERÊNCIAS ________________________ ________________________ DEITEL, Paul. Java. Como Programar. 8. ed. São Paulo: Pearson Prentice Hall, 2010 ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________

Geralmente quando executamos um programa, precisamos interagir com ele fornecendo dados que serão processados e que nos darão uma saída. Nesta aula, aprenderemos como é feita a comunicação entre o mundo externo e um sistema no que se refere à entrada e saída de dados.

de programação II

Autora: Ana Patrícia F. Magalhães Mascarenhas

575 lingüagens e técnicas

AULA 08 - ENTRADA E SAÍDA DE DADOS

Entrada e saída de dados A comunicação entre o mundo externo e o nosso sistema é comumente realizada através da troca de dados entre o usuário e o sistema. Esta comunicação na linguagem Java pode ser feita diretamente em linha de comando ou através de uma interface gráfica. A comunicação via linha de comando já foi parcialmente abordada nas aulas anteriores. Nesta aula veremos detalhadamente como pode ser realizada esta comunicação. Os exemplos utilizados nesta aula serão desenvolvidos utilizando a ferramenta ________________________ netbeans. Para iniciar um projeto nesta ferramenta, selecione a opção novo projeto no ________________________ menu arquivo, escolha o item projeto Java e dê um nome ao seu projeto. Será criada ________________________ uma nova pasta para o seu projeto contendo um arquivo chamado main.java onde ________________________ começaremos a desenvolver o código do nosso programa.

Saída de dados

Podemos efetuar uma saída de dados na linguagem Java de várias maneiras: usando o método System.out.print ou System.out.println; utilizando o método System. out.printf. O método System.out.println e o método System.out.print têm o mesmo objetivo: escrever na janela de saída o texto informado como parâmetro. A figura 1 ilustra um exemplo de utilização deste método. Quando utilizamos somente o método print, o texto é impresso, mas o programa não salta para a próxima linha. Quando utilizamos o método println, o texto é impresso e o programa passa para a próxima linha antes de executar outra instrução. Na figura 1, logo abaixo do código, temos o resultado da execução do programa. Observe que a frase “o println salta a linha após a impressão” aparece em uma nova linha, pois após imprimir a frase “este é o nosso exemplo de saída de dados”, o programa foi para uma nova linha. Os métodos print e println podem conter dentro do texto a ser impresso o caractere de barra invertida “\” (chamado de caractere de escape) para indicar a saída de um caractere especial. A barra invertida é combinada a outros caracteres para fornecer

alguma informação adicional à impressão. A figura 2 ilustra a lista de opções para saída de informações usando a “\”.

lingüagens e técnicas

de programação II

576

Figura 1: Programa para calcular a idade de uma pessoa

Fonte: A autora

Os caracteres “\n”, por exemplo, servem para posicionar o cursor em uma nova

________________________ linha. ________________________ ________________________ ________________________ Seqüência de ________________________ escape ________________________ \n ________________________ ________________________ ________________________ \t ________________________ ________________________ \r ________________________ ________________________ ________________________ ________________________ \\ ________________________ ________________________ ________________________ \” ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________

Figura 2: Algumas sequências de escape comuns

Descrição

Nova linha. Posiciona o cursor de tela no início da nova linha.

Tabulação horizontal. Move o cursor de tela para a próxima parada de tabulação. Retorno de carro. Posiciona o cursor da tela no início da linha atual – não avança para a próxima linha. Qualquer saída de caracteres depois do retorno sobrescreve a saída de caracteres anteriormente gerada na linha atual. Barras invertidas. Utilizadas para imprimir um caractere de barra invertida Aspas duplas. Utilizadas para imprimir um caractere de aspas duplas. Por exemplo System.out.println(“\”in quotes\””); Exibe: “in quotes” Fonte: Deite, (2010, p.35)

uma string de formatação. Os demais parâmetros indicam as strings que serão impressas. Para especificar a string de formatação, usa-se o caractere % chamado especificador de formato seguido do caractere que indica o tipo de dado. O exemplo da figura 3 mostra a utilização do método printf onde é impressa uma frase “ola pessoal sejam bem vindos” dividida em duas linhas.

577 de programação II

método recebe parâmetros separados por vírgula. O primeiro parâmetro informado é

lingüagens e técnicas

Para exibir dados que precisam ser formatados, usamos o comando printf. Este

Figura 3: Exemplo do método printf

Fonte: A autora

Entrada de dados

A entrada de dados via linha de comando na linguagem Java é feita utilizandose a classe Scanner. A figura 4 ilustra um exemplo de entrada de dados. Neste programa, o usuário informa o seu nome, ano de nascimento e ano atual e o programa calcula e imprime a idade do usuário. Observe que foi necessário importar uma biblioteca da linguagem Java (import java.util.Scanner;) para utilizarmos este comando. A linguagem Java é uma linguagem bastante abrangente e costuma dividir suas classes em pacotes que podem ser importados quando necessários em uma aplicação específica. No caso da entrada de dados, utilizaremos métodos da classe Scanner que precisou ser importada. Em seguida, definimos um objeto do tipo Scanner (objeto entradaDados) para que pudéssemos executar os métodos desta classe. A partir deste ponto, sempre que precisamos ler algum dado digitado via linha de comando, utilizamos o método next(). Existem algumas variações ao método next a depender do tipo de dado que está sendo lido do teclado. No exemplo, utilizamos o método next() para ler uma String e o método nextInt() para ler um valor do tipo int. No exemplo, temos 3 variáveis, nome, anoNascimento e anoAtual que serão utilizadas para guardar os dados digitados via linha de comando. Primeiro utilizamos o método println para escrever a mensagem “informe o seu nome” e o comando next() para recuperar o nome digitado pelo usuário e guardá-lo na variável nome. O mesmo procedimento é utilizado para receber o anoNascimento e o anoAtual. De posse destes dados, o programa imprime a idade da pessoa. Observe que utilizamos o método prin-

tln e concatenamos alguns strings para montar a mensagem que será impressa.

lingüagens e técnicas

de programação II

578

Figura 4: Execução normal do programa ilustrado na Figura 1

Fonte: A autora

Entrada / saída de dados utilizando caixas de diálogo Até o momento estávamos fazendo entrada e saída de dados nos nossos programas a partir de linha de comando. No entanto, atualmente, é muito comum encontrarmos sistemas que oferecem uma interface mais amigável para o usuário. Estas interfaces conhecidas como interfaces gráficas com o usuário (Graphical User Interface - GUI) permitem que o usuário interaja com a aplicação através de elementos tais como caixas de texto, menus, botões, entre outros. Existem diversos ambientes de desenvolvimento (IDEs) que disponibilizam opções visuais de criação da interface gráfica de uma aplicação. Podemos criar estas interfaces de duas maneiras: utilizando a facilidade das IDEs ou diretamente através do código da nossa aplicação. Nesta aula, utilizaremos como base a criação da GUI através de comandos da nossa aplicação, mas mostraremos alguns exemplos de utilização da interface da IDE Netbeans. As GUIs fornecem diversas opções de controles que poderão ser utilizadas para programar a interação do seu programa com o usuário. A primeira delas é através de caixas de diálogo

entrada e saída de dados. Este controle faz parte do pacote javax.swing que deve ser importado quando precisar ser utilizado. A figura 5 ilustra o mesmo programa desenvolvido na figura 4, agora utilizando

lingüagens e técnicas

O JOptionPane é um controle que possibilita a criação de caixas de diálogo para

de programação II

579

JOptionPane

caixas de diálogo para entra e saída dos dados. Observe que foi importada a biblioteca javax.swing.JOptionPane logo na primeira linha do programa. Caixas de diálogo são do tipo Modal, ou seja, não permitem que o usuário processe outra operação no sistema antes que a caixa de diálogo seja fechada.

Figura 5: Exemplo de JOptionPane

Fonte: A autora

A figura 6 a seguir ilustra as janelas apresentadas na execução do programa. Quatro caixas de diálogo foram criadas: três para entrada de dados, utilizando o comando showInputDialog; uma para saída de dados, utilizando o comando showMessageDialog. Observe que a resposta do usuário (caixa de entrada de dados) é sempre capturada em uma variável do tipo String que pode ser depois transformada para o tipo de dado desejado. Por exemplo, quando o usuário digitou o ano de nascimento, capturamos o dado em uma variável anoNasc do tipo String que depois foi transformada em um dado do tipo int e armazenado na variável anoN. A caixa de saída de dados permite que sejam informados alguns parâmetros para customização da caixa, tais como:

Localização do diálogo em relação à janela pai; Texto a ser exibido como mensagem Texto a ser exibido como título da mensagem

Ícone de diálogo a ser exibido (ex.: exclamação, informação, interrogação);

lingüagens e técnicas

de programação II

580

Como mencionado, uma caixa de diálogo pode apresentar um ícone se assim nós a formatarmos utilizando as seguintes constantes: ERROR_MESSAGE, para indicar que desejamos um ícone de exclamação vermelho (erro) INFORMATION_MESSAGE, para indicar que desejamos um ícone de informação WARNING_MESSAGE, para indicar que desejamos um ícone de exclamação amarelo (alerta) QUESTION_MESSAGE, para indicar que desejamos um ícone de interrogação PLAIN_MESSAGE, para indicar que não queremos que nenhum ícone seja apresentado.

Figura 6: Execução do exemplo ilustrado na Figura 5

Fonte: A autora

Nas aulas anteriores, criamos nossas aplicações orientadas a objetos e utilizamos a interface do aplicativo BlueJ para testá-las. Desta forma, não precisamos nos preocupar com a programação da interface, pois o próprio BlueJ nos fornece um ambiente para viabilizar nossos testes. Nesta aula, começamos a trabalhar na construção nossas próprias interfaces, pois em uma aplicação comercial não poderemos ficar limitados ao BlueJ, precisaremos criar nossas próprias formas de comunicação com o usuário final. Os conceitos aprendidos nesta aula possibilitam a construção de sistemas com interativas através de linha de comando e caixas de diálogo. No entanto, as aplicações atuais demandam interfaces mais sofisticadas, com recursos gráficos que possam torná-las mais amigáveis e atrativas. Desta forma, na próxima aula, começaremos a aprender os recursos mais avançados de interface gráfica para construção das nossas aplicações.

SÍNTESE Nesta aula, aprendemos a utilizar recursos de entrada e saída de dados permitindo interação dos usuários com nossas aplicações.

Esta opção faz a interação do sistema com o usuário através de linha de comando. Além disso, vimos que podemos também fazer esta interação através de caixas de diálogo customizadas. Podemos utilizar caixas de saída de dados, através do método showMessageDialog e caixas de entrada de dados, através do método showInputDialog. Esta forma de interação começa a utilizar recursos gráficos tais como janelas e

581 de programação II

do System.out.println e receber dados digitados via teclado utilizando a classe Scanner.

lingüagens e técnicas

Inicialmente, vimos que é possível fazer uma saída de dados utilizando o méto-

ícones para tornar nossas interfaces mais amigáveis.

QUESTÃO PARA REFLEXÃO Analise a importância da interface gráfica nas aplicações comerciais atuais. A caixa de diálogo é suficiente para fazer a interação entre o sistema e os usuários?

LEITURAS INDICADAS Capítulo 14 do livro de Paul Deitel

SITES INDICADOS http://www.youtube.com/watch?v=ZUqTjD1E1Dw http://www.youtube.com/watch?v=LCzdEHyGQPw&feature=related

REFERÊNCIAS DEITEL, Paul. Java. Como programar. 8. ed. São Paulo: Pearson Prentice Hall, 2010.

lingüagens e técnicas

de programação II

582

583

Autora: Ana Patrícia F. Magalhães Mascarenhas

lingüagens e técnicas

Na aula passada, aprendemos a trabalhar com entrada e saída de dados via linha de comando ou utilizando caixas de diálogos. No entanto, as aplicações atuais demandam interfaces mais sofisticadas, com janelas, caixas de texto, botões, entre outros elementos que fazem parte do que chamamos de interface gráfica. Nesta aula, começaremos a aprender a construir interfaces gráficas para as nossas aplicações.

de programação II

AULA 09 - INTERFACE GRÁFICA - PARTE 1

Interface gráfica O uso de caixas de diálogo visto na aula passada é interessante, mas, na maioria das aplicações, precisamos desenhar uma interface mais elaborada para possibilitar uma interação mais amigável com o usuário. Esta interface é construída utilizando componentes GUI Swing existentes no pacote javax.swing. A Figura 1 lista alguns dos componentes disponíveis.

________________________ ________________________ Componentes Descrição ________________________ ________________________ Jlabel Exibe texto não editável ou ícones ________________________ JTextField Permite ao usuário inserir dados do teclado. Também pode ser ________________________ utilizada para exibir texto editável ou não editável ________________________ ________________________ Jbutton Desencadeia um evento quando o usuário clicar nele com o mouse ________________________ ________________________ JCheckBox Especifica uma opção que pode ser ou não selecionada ________________________ ________________________ JComboBox Fornece uma lista Drop-Down de itens a partir da qual o usuário pode ________________________ fazer uma seleção clicando em um item ou possivelmente digitando na caixa ________________________ ________________________ Jlist Fornece uma lista de itens a partir da qual o usuário pode fazer uma ________________________ seleção clicando em qualquer item da lista. Múltiplos elementos ________________________ podem ser selecionados ________________________ Jpanel Fornece uma área em que os componentes podem ser colocados e ________________________ organizados. Também pode ser utilizado como uma área de desenho ________________________ para imagens gráficas. ________________________ Fonte: Deitel (2010, p.423) ________________________ ________________________ Os componentes disponíveis na GUI da linguagem Java (chamados de compo- ________________________ nentes leves) estão organizados hierarquicamente em uma estrutura de herança de ________________________ Figura 1: Alguns componentes GUI básicos

classes, conforme ilustrado na Figura 2. Temos a classe Object que é uma superclasse

lingüagens e técnicas

de programação II

584

de Component, que é uma superclasse de Container (janelas) que, por sua vez, é superclasse de JComponent. Cada uma dessas classes declara atributos e métodos comuns aos objetos de uma GUI. No site java.sun.com/javase/6/docs/api/java/awt/Component. html, você pode consultar a lista dessas classes com seus atributos e métodos. A classe Container é importante porque funciona como um repositório onde os objetos de uma interface serão organizados (arrumados).

Figura 2 - Superclasses do Java Swing

Fonte: Deitel (2010)

A interface gráfica de um programa pode ser construída diretamente via có-

digo ou através de uma interface visual da IDE que você estiver usando. Nesta aula, vamos fazer das duas formas. Inicialmente, vamos aprender a criar nossa interface através IDE Netbeans. Para isso, utilizaremos um exemplo. Entraremos no NetBeans e criaremos um projeto Java com nome InterfaceGrafica. Será criada pela IDE uma pasta para o projeto com várias subpastas. Na pasta pacotes de codigo fonte, serão armazenados todos os arquivos com os códigos fontes da nossa aplicação. Para criarmos um novo formulário (tela nova no nosso sistema), clique com o botão direito do mouse sobre a pasta pacotes de codigo fonte, selecione a opção novo -> formulário JFrame e dê um nome ao seu formulário. Por exemplo, vamos criar o formulário cadastroAluno. Observe que, na sua pasta pacotes de codigo fonte, agora foi criado o arquivo cadastroAluno.java, que vai conter o código fonte da sua aplicação. A Figura 3 ilustra uma parte da IDE NetBeans com o novo formulário criado, aguardando para ser desenhado de acordo com as necessidades da nossa aplicação. Na parte A da figura, faremos o desenho do nosso formulário. Na parte B da figura, temos as opções de componentes GUI que poderemos utilizar para desenhar nosso formulário. Para montar a parte gráfica do nosso formulário, basta clicar no componente desejado (Figura 3B) e arrastar para a o formulário (Figura 3A). A Figura 4 ilustra um exemplo de formulário criado para um cadastro de alunos de uma universidade.

585 lingüagens e técnicas

de programação II

Figura 3 - Área de edição do formulário no netBeans

Fonte: Autoria própria

Neste exemplo, foram usados os seguintes tipos de componentes:

JLabel, para colocar um texto no formulário - Ex.: o título Cadastro de Alunos e os rótulos (Matrícula, Nome, Telefone, etc.); JTextFiled, para criar campos de entrada de texto - Ex.: o campo de texto para digitar a matrícula do aluno; JComboBox, para colocar uma lista de opções de seleção - Ex.: o campo que contém a lista de cursos disponíveis;

________________________ ________________________ nino e Masculino; ________________________ JPasswordField, para incluir campos de senha - Ex.: campo para digitação da senha do ________________________ aluno; ________________________ JCheckBox, para incluir controles de opções com múltipla escolha. Ex.: campo de che- ________________________ cagem Deseja receber email com noticias; ________________________ ________________________ JButton, para incluir botões - Ex.: Confirmar, Cancelar e Pesq. ________________________ ________________________ Figura 4 - Exemplo de formulário para cadastrar alunos ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ Fonte: Autoria própria ________________________ JRadioButton, para incluir controles de opções exclusivas - Ex.: opções de sexo Femi-

lingüagens e técnicas

de programação II

586

Cada um desses componentes colocados no formulário pode ser configurado de acordo com suas propriedades. Por exemplo, podemos dar um nome para o componente (nome da variável que vai fazer referência ao componente), formatar a fonte etc. A janela Propriedades (Figura 4, à direita) nos permite fazer essas configurações. Uma vez montada a nossa tela, a IDE NetBeans gera automaticamente o código associado aos componentes que selecionamos. Podemos visualizar o design da tela ou o código gerado selecionando a opção Código Fonte e Projeto presentes no topo da tela, onde editamos o formulário (veja círculos no topo esquerdo da Figura 4). A Figura 5 ilustra um trecho do código gerado pelo NetBeans para o formulário de cadastro de Alunos que criamos. Observe que foram criadas as variáveis que vão representar cada um dos componentes que colocamos no nosso formulário. Figura 5 - Trecho do código gerado pelo Netbeans para o formulário cadastro de alunos

Fonte: Autoria própria

A partir de agora, com o formulário desenhado, precisamos colocar a programação necessária para que o nosso formulário funcione, ou seja, definir o que será

chamamos de eventos (veremos essa parte mais à frente, nesta aula). Outra maneira de construirmos as telas dos nossos programas é a partir da criação manual dos formulários e componentes que desejamos, utilizando código Java diretamente, em vez de usar uma interface provida por uma IDE. As seções a seguir descrevem, com detalhe, cada um dos componentes dispo-

587 de programação II

nados os botões Confirmar e Cancelar, etc. Essa programação é feita a partir do que

lingüagens e técnicas

executado quando o formulário for apresentado ao usuário, quando forem selecio-

níveis para usarmos na construção das nossas interfaces. Lembrando que, para começarmos a montar a nossa interface, é necessário utilizarmos uma janela onde colocaremos os objetos que vão compor a nossa interface. Em geral, as janelas são instâncias ou subclasses da classe JFrame.

Rótulos Rótulos são utilizados para colocar um texto na nossa interface. Em geral, uma interface possui vários rótulos. Por exemplo, na Figura 4 colocamos o rótulo Cadastro de Alunos. Para inserirmos um rótulo na nossa interface, usamos a classe JLabel (subclasse de JComponent). O texto exibido em rótulos é apenas de leitura. Pode-se também exibir uma imagem. A Figura 6 ilustra um exemplo de criação via código de um rótulo usando o JLabel. Observe que, inicialmente, é preciso importar algumas bibliotecas do swing. Depois disso, precisamos criar uma janela com o JFrame (JFrame janela = new JFrame();), onde será colocado o rótulo. Feito isso, podemos colocar os componentes que quisermos na janela, sempre criando uma variável do tipo do componente que desejamos e instanciando o objeto nesta variável. Para o rótulo, criamos a variável label1 e instanciamos o objeto, informando qual o texto que deveria ser colocado no rótulo (JLabel label1 = new JLabel (“texto do rótulo”); ). Finalmente, colocamos o rótulo dentro da janela (janela.add(label1);). Podemos também trabalhar com a configuração das propriedades do nosso componente. Por exemplo, utilizamos o comando label1. setToolTipText(“este é o rotulo 1”); para especificar um texto que será apresentado ao usuário sempre que ele passar o mouse sobre o nosso rótulo. Neste exemplo, construir a interface de uma aplicação manualmente (sem o auxílio de um editor gráfico) pode ser muito trabalhoso, mas vamos fazer dessa maneira para analisarmos cada código criado. Sendo assim, para organizarmos manualmente os componentes dentro da nossa janela, vamos utilizar um gerenciador de layout chamado FlowLayout, que organiza os componentes sempre da esquerda para a direita na ordem em que são criados.

588 lingüagens e técnicas

de programação II

Figura 6 - Exemplo de código para rótulo

Fonte: Autoria própria

Campos de texto Campos de texto são utilizados para entrada de texto em uma aplicação. Apre-

sentam uma área de uma única linha onde o usuário digita o texto desejado. Temos dois tipos de campos de texto: o JTextField, que é uma campo simples para entrada de texto; e o JPasswordField, que é um campo para digitação de senha, ou seja, altera o caractere digitado por outro (ex. *). Ambos os componentes fazem parte do pacote javax.swing. A Figura 7 ilustra um exemplo de caixas de texto. Neste caso, dois campos de texto são criados: campo1, para o usuário informar o seu login; e campo2, para o usuário informar a senha. Quando fazemos entrada de dados em um sistema, geralmente precisamos dar algum tratamento aos dados digitados. Esse tratamento é feito com a utilização de eventos. No exemplo da Figura 7, começamos a introduzir o conceito de tratamento de eventos. Neste caso, quando o usuário digitar algum conteúdo nas caixas de texto e teclar <enter>, será disparado um evento que fará aparecer uma tela de diálogo com uma mensagem (no caso, a mensagem “tratamento do campo1”). Para fazer o tratamento de eventos, é preciso importar as bibliotecas java.awt. event.ActionListener e java.awt.event.ActionEvent e seguir os passos descritos abaixo:

Criar uma classe que tenha uma ligação (handle) com o evento desejado; Implementar a interface que vai monitorar o evento, ou seja, que vai ser chamada quando o evento for disparado Definir que objeto vai estar associado ao evento.

589 lingüagens e técnicas

de programação II

Figura 7 - Exemplo de campo texto

Fonte: Autoria própria

No nosso exemplo (Figura 7), criamos uma classe interna (classe declarada dentro de outra classe), chamada TrataEvento, que implementa a interface ActionListener, responsável por monitorar a ocorrência de um evento. Associamos o campo1 e o campo2 a esta classe através dos comandos campo1.addActionListener(handler); e campo2. addActionListener(handler);. Quando o evento for disparado, automaticamente o método ActionPerformed será executado. Lá, então, colocamos o tratamento que desejamos fazer sobre os dados digitados.

lingüagens e técnicas

de programação II

590

Quando trabalhamos com interface gráfica, podemos disparar vários tipos de eventos a depender da interação do usuário com o sistema. O pacote java.awt.event possui várias classes de eventos. Para cada tipo de evento que desejamos tratar, existe uma interface listener que monitora o evento para que ele possa ser tratado, presentes nos pacotes java.awt.event e javax.awt.event.

Botões Nas GUI dos nossos sistemas, é comum utilizarmos botões para acionar ações específicas. Botões de comando para confirmar um cadastro; caixas de seleção entre várias opções de escolha; botões de alternação e botões de opção são tipos de botões que podemos utilizar. A Figura 8 ilustra a hierarquia de classes que implementam opções de botões (subclasses de abstractButton).

Figura 8 - Hierarquia de botões no Swing

591 lingüagens e técnicas

de programação II

Figura 9 - Exemplo de código implementando um botão

Fonte: Autoria própria

Observe que importamos o pacote javax.swing.button para ter acesso ao uso de botões. Para o exemplo, foi criado um rótulo (nome) e uma caixa de texto (para entrada do nome). Em seguida, dois botões foram definidos, um para confirmar e outro para cancelar. Todos esses elementos estão localizados dentro de uma janela.

Para tratar o evento de clique no botão, utilizamos o mesmo procedimento visto anteriormente, ou seja, criamos um handle para a classe interna chamada TrataEvento. Esse handle foi associado aos botões. Na classe TrataEvento, fizemos o tratamento que desejávamos para o botão, implementando o método actionPermormed, que vai responder ao evento quando um dos botões for selecionado pelo usuário.

lingüagens e técnicas

de programação II

592

Temos também o botão de checagem disponível na classe JCheckBox. Neste caso, temos a opção de marcar ou não o botão e vários podem ser marcados ao mesmo tempo. A Figura 10 ilustra um exemplo de uso deste tipo de botão. Observe que importamos a biblioteca javax.swing.jCheckBox e que, agora, o tratamento de eventos é realizado pelas classes da biblioteca java.awt.event.ItemListener e java.awt.event.ItemEvent.

No exemplo, criamos o rótulo Disciplinas e colocamos três opções de botões de checagem: Banco1, LTP1 e LTP2, sendo que é possível selecionar mais de uma disciplina ao mesmo tempo.

O tratamento de eventos é semelhante ao de botão de controle. Inicialmente, criamos o handler e associamos aos objetos checkbox criados. Em seguida, definimos a classe interna TrataEvento, que agora implementa a interface ItemListener e o método ItemStateChanged, que é chamado quando o estado de um checkbox é alterado.

A última opção de botão são os botões de rádio, que criamos a partir da classe JRadioButton. Nestes, temos opções exclusivas de seleção. No exemplo da Figura 11,

temos este tipo de botão. Trata-se de um botão exclusivo, ou seja, que só permite uma seleção por vez.

A Figura 11 ilustra um exemplo de botão de rádio onde foram definidas três opções de turnos a serem selecionados. Apenas uma das opções pode ser selecionada. Quando o usuário escolhe sua opção, é disparado um evento que mostra uma mensagem com a opção escolhida.

Observe que, para botões de rádio, foi acrescentada uma classe ButtonGroup, responsável por agrupar todas as opções exclusivas em um grupo. Somente assim podemos ter vários grupos de botões de rádio diferentes na mesma janela.

O tratamento de eventos para botões de radio é semelhante ao do checkbox, em que usamos as classes das bibliotecas java.awt.event.ItemListener e java.awt.event. ItemEvent. O resto do procedimento é igual ao das outras classes que já vimos.

593 lingüagens e técnicas

de programação II

Figura 10 - Exemplo de botão CheckBox

Fonte: Autoria própria

Figura 11 - Exemplo de botão de rádio

lingüagens e técnicas

de programação II

594

________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ Fonte: Autoria própria ________________________ ________________________ ________________________ Os conceitos aprendidos nesta aula são importantes para construirmos inter________________________ faces mais amigáveis e interativas para nossas aplicações. A GUI da linguagem Java é ________________________ bastante extensa. Por isso, na próxima aula, continuaremos a estudar outros tipos de ________________________ componentes gráficos. ________________________ ________________________ ________________________ ________________________ SÍNTESE ________________________ ________________________ Nesta aula, aprendemos a construir interfaces gráficas para nossas aplicações. Vimos que é possível criarmos as nossas interfaces diretamente via uma IDE que ofere-

Os componentes que fazem parte da GUI da linguagem Java estão em geral no pacote javax.swing e devem ser importados para nossos programas quando necessários. Vimos que os componentes da nossa interface são organizados em uma janela (usamos o JFrame) e que existe uma grande quantidade de componentes disponíveis

595 de programação II

programa.

lingüagens e técnicas

ça recursos de desenho da interface, ou diretamente através do código fonte do nosso

para serem utilizados, a exemplo de rótulos, caixas de texto e vários tipos de botões. Os componentes de interface respondem a eventos, interações que o usuário faz com o sistema, tais como: a seleção da tecla enter e o clique de um botão. Podemos associar nossos componentes a esses eventos. Desta forma, o sistema monitora a interação do usuário e, quando um evento é capturado pelo sistema, ele é tratado de acordo com o que programamos para ele. Por exemplo, podemos criar uma programação para ser executada sempre que um botão de controle for selecionado pelo usuário.

QUESTÃO PARA REFLEXÃO Execute os exemplos listados nesta aula e analise o comportamento dos eventos disparados pelos diversos programas.

LEITURA INDICADA Capítulo 14 do seguinte livro: DEITEL, Paul. Java: como programar. 8. ed. São Paulo: Pearson Prentice Hall, 2010.

SITES INDICADOS http://www.oracle.com/technetwork/java/index.html http://www.youtube.com/watch?v=ZMlySbYed8Q

REFERÊNCIA DEITEL, Paul. Java: como programar. 8. ed. São Paulo: Pearson Prentice Hall, 2010.

lingüagens e técnicas

de programação II

596

Na aula passada, começamos a trabalhar construindo interfaces gráficas para as nossas aplicações. Na aula de hoje aprenderemos mais algumas opções de componentes gráficos para utilizarmos nos nossos programas

de programação II

Autora: Ana Patrícia F. Magalhães Mascarenhas

597 lingüagens e técnicas

AULA 10 - INTERFACE GRÁFICA - PARTE 2

Interface gráfica Como vimos na aula passada, o uso de interface gráfica (GUI) é uma realidade nas aplicações construídas atualmente. Existem diversos componentes disponíveis para montarmos a nossa interface de maneira amigável e eficiente para interagir com o usuário. A seguir serão apresentados novos componentes disponíveis na interface gráfica do Java.

JComboBox

Muitas vezes, quando construímos um software, temos a necessidade de colocar um campo de texto que ofereça uma lista com opções pré- definidas para seleção. Por exemplo, no cadastro de alunos de uma universidade é necessário selecionar o curso que o aluno está matriculado. O componente JComboBox é uma subclasse da classe JComponent que disponibiliza uma lista de opções onde o usuário pode selecionar uma das opções. O JComboBox é composto de itens e responde a ItemEvents, eventos associados ao componente que podem ser programados de acordo com a necessidade de cada sistema. A Figura 1 ilustra um exemplo simples de uso do JComboBox onde temos uma lista de cursos para o usuário selecionar o curso desejado. Uma vez selecionado o curso, é disparado um evento que mostra uma mensagem com o nome do curso selecionado. Observe que inicialmente precisamos importar a biblioteca javax.swing.JComboBox. Na classe principal (Figura 1 A), temos também que declarar um vetor de elementos String (opcoes) para colocar a lista de valores que serão apresentados no combobox. Assim, quando efetivamente criamos o combobox de cursos comboCursos = new JComboBox(opcoes); usamos o vetor opcoes como parâmetro do construtor de JComboBox. Em seguida temos o tratamento do evento. Primeiro, associamos o combobox ao handle criado comboCursos.addItemListener(handler); Quando um item do combobox é selecionado pelo usuário, a execução do programa é desviada para a classe TrataEvento. Esta classe verifica se foi um evento de seleção de um item if (evento. getStateChange()==ItemEvent.SELECTED). Em caso afirmativo emite a mensagem com o item selecionado. O código referente à Figura 1 B é o código implementado para testar o exem-

lingüagens e técnicas

de programação II

598

plo. Uma vez executado, ele apresenta a janela com as opções do combobox (Figura 1 C). Quando o usuário seleciona um dos itens é apresentada outra janela com a mensagem (Figura 1 D). Observe

que

definimos

que

lista

teria

linhas

comboCursos.

setMaximumRowCount(3);, como temos mais de 3 itens, automaticamente aparece a barra de rolagem (Figura 1 C). Figura 1 - Exemplo de utilização de TComboBox.

Fonte: autoria própria

JList

Outra opção de componente gráfico é o JList, que exibe uma lista com vários itens onde o usuário pode selecionar um (lista de única seleção) ou mais de um item (lista de seleção múltipla). O JList é uma subclasse de JComponent. No exemplo ilustrado na Figura 2 é apresentada uma janela com uma lista de cores. Quando o usuário clica em uma das cores a janela muda para a cor selecionada. No código da Figura 2 A, temos inicialmente as importações de bibliotecas. Além das importações já conhecidas, precisamos importar javax.swing.JList; para trabalhar com o JList, o import java.awt.Color; para trabalharmos com cores e as bibliotecas de tratamento de eventos javax.swing.event.ListSelectionListener; e javax.swing. event.ListSelectionEvent;

Quando criamos o nosso JList indicamos como parâmetro do construtor a lista com o nome das cores que serão apresentadas listaCores = new JList(nomeCores); Em seguida fazemos o tratamento do evento de seleção para mudança da cor de fundo da janela listaCores.addListSelectionListener(...)

599 de programação II

das cores e colors para os códigos que representam cada uma das cores no Java.

lingüagens e técnicas

As cores apresentadas foram definidas nas constantes listaCores para o nome

Figura 2: exemplo de JList

Fonte: adaptado de Deitel (2010, p.445)

Lista de seleção múltipla

Listas de seleção múltipla possibilitam a escolha de vários itens dentro de um JList. Existem algumas maneiras de fazer a seleção: SINGLE_INTERVAL_SELECITION - possibilita selecionar um intervalo de itens clicando no primeiro item, pressionando shift e clicando no último item; MULTIPLE_INTERVAL_SELECTION (padrão) - permite selecionar vários itens em um intervalo ou itens diversos (pressionando a tecla control - ctrl).

A Figura 3 ilustra um exemplo de lista com seleção múltipla usando a opção MULTIPLE_INTERVAL_SELECTION. No exemplo temos uma lista de disciplinas cadastradas (à esquerda) onde o usuário pode selecionar várias delas e colocar na lista de disciplinas selecionadas (à direita)

600 lingüagens e técnicas

de programação II

Figura 3 - Exemplo de lista com múltipla seleção

Fonte: Adaptado de Deitel (2010, p.247)

A Figura 3 (A) mostra o código fonte do exemplo. Observe que fizemos a importação do componente JList e dos componentes de tratamento de eventos java.awt. event.ActionListener e java.awt.event.ActionEvent. No corpo do programa, criamos 3 objetos: duas listas e um botão. A primeira lista foi inicializada com o nome das disciplinas listaDiscCadast = new JList(nomeDisc); O botão foi associado ao evento botao.addActionListener. Desta forma, quando clicarmos no botão, será executado o código que faz a cópia das disciplinas selecionadas para a outra lista, listaDiscSelect.setListData(listaDiscCadast.getSelectedValues());. A Figura 3(B) mostra o programa principal utilizado para testar nosso código. A Figura 3 (C) ilustra a tela gerada quando o programa foi executado.

JTextArea

O componente JTextArea é utilizado para entrada de texto assim como o JTextField visto na aula passada. Sua diferença é que permite entrada de texto em múltiplas linhas. Por exemplo, para entrar com um campo de endereço em um cadastro de alunos podemos utilizar o componente JTextArea. Este componente também é uma subclasse da classe JComponet.

texto será copiado para outro JTextArea.

Figura 4 - Exemplo de JTextArea

Fonte: adaptado de Deitel (2010, p.467)

Observe que importamos a biblioteca javax.swing.JTextArea. No corpo do programa (Figura 4 A) criamos os dois TtextArea e o botão e associamos ao botão o evento ActionListener que faz a cópia do texto para o segungo JTextArea.

Eventos do mouse

Eventos de mouse são os eventos disparados quando utilizamos o mouse. Eles podem ser associados a qualquer componente GUI derivado da classe java.awt. As interfaces providas para eventos de mouse são as MouseListener e MouseMotionListener. Elas possuem vários métodos que podem ser implementados a depender da necessidade do nosso programa, por exemplo, mousePressed, disparado quando um botão do mouse é selecionado e mouseMoved, disparado quando o cursor é movido sobre um componente. O pacote java.swing.event possui uma interface chamada MouseInputListener que estende as MouseListener e MouseMorionListener para ser utilizada com os objetos herdados da classe Component. Todos os métodos utilizados para tratar eventos de mouse recebem como parâmetro um objeto MouseEvent com informações sobre o evento, tais como, as coorde-

601 de programação II

tArea. Quando o usuário selecionar uma parte do texto e clicar no botão copiar, este

lingüagens e técnicas

A Figura 4 ilustra um exemplo onde será digitado um texto em um objeto JTex-

lingüagens e técnicas

de programação II

602

nadas onde estava o mouse no momento do evento.

Exemplo integrando interface e programação OO

Agora que já sabemos como funciona a interface gráfica do Java vamos construir um exemplo completo envolvendo classes e interface. Para iniciar este trabalho criamos um projeto novo no Java chamado InterfaceGraficaSimples. Neste exemplo, utilizaremos a IDE Netbeans para criar a interface GUI.

Suponha que precisamos construir um cadastro de alunos para um sistema. Neste caso, vamos construir inicialmente a classe Aluno, como fizemos ao longo deste curso. Todo aluno possui matricula, nome, telefone, email e sexo. Desejamos guardar também uma informação indicando se o aluno deseja receber emails informativos sobre o curso. Além disso precisamos criar um método específico para calcular a mensalidade de um aluno. De acordo com este cenário então, criamos uma nova classe em Java chamada Aluno e colocamos o código ilustrado na figura 5.

Observe que foram declarados vários atributos, um para cada dado que precisamos guardar sobre um aluno; um método construtor que recebe como parâmetro os dados necessários para instanciar um objeto aluno; um método calcMensalidade() para calcular a mensalidade do aluno (neste caso abstraímos o cálculo e colocamos que todos os alunos pagam R$ 500,00 de mensalidade); e os métodos get e set para cada um dos atributos.

Agora que temos a nossa classe Aluno pronta, podemos utilizá-la para construir qualquer aplicação que precise tratar de Alunos. Vamos então construir o nosso cadastro. Para isso, construímos a interface gráfica funcionando da seguinte maneira. Temos um formulário (no nosso projeto selecionamos novo->formulario JFrame para criar o novo formulário e demos o nome de cadAluno) com os campos necessários para cadastrar o aluno (Figura 6A). O usuário deverá digitar os dados e selecionar o botão Confirmar. Neste momento, é instanciado um objeto da classe Aluno que criamos anteriormente com os dados preenchidos no formulário. Também é chamado o método calMensalidade() para calcular a mensalidade do aluno que é apresentada na tela no campo mensalidade, antes vazio (Figura 6B). É possível também limpar a tela selecionando o botão Limpar (Figura 6C).

603 lingüagens e técnicas

de programação II

Figura 5 - Classe Aluno

lingüagens e técnicas

de programação II

604

Caso o usuário queira consultar o último cadastro feito, seleciona o botão Pesq e os dados são recuperados do objeto aluno instanciado e colocado nos campos da tela (Figura 6D) Figura 6 - Interface para o cadastro de aluno

Fonte: autoria própria

A Figura 7 ilustra o trecho que código implementado quando selecionamos o botão Confirmar. Observe que temos a criação de uma variável do tipo Aluno como atributo do formulário. Em seguida, no evento ActionPerformed associado ao botão Confirmar (JButton1) temos o código de criação do objeto aluno. Logo após a criação do objeto, chamamos o método calcMensalidade() para recuperar o valor da mensalidade e mostrar no formulário.

605 lingüagens e técnicas

de programação II

Figura 7 - Código referente à seleção do botão Confirmar

________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ Fonte: autoria própria ________________________ ________________________ A Figura 8 ilustra o código executado quando é selecionado o botão Limpar, ________________________ limpando todos os campos ________________________ ________________________ ________________________ Figura 8 - Código referente à seleção do botão Limpar ________________________ ________________________ Fonte: autoria própria ________________________ ________________________ A Figura 9 ilustra o código executado quando é selecionado o botão Pesq para ________________________ recuperar os dados do último objeto criado. ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________

606 lingüagens e técnicas

de programação II

Figura 9 - código referente à seleção do botão Pesq

Fonte: autoria própria

Nesta aula, finalizamos os trabalhos com interface gráfica e vimos como integrar esta interface com as classes que já havíamos construído ao longo do curso. Agora, estamos prontos para construir nossos próprios programas. Bom trabalho!

SÍNTESE ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________ ________________________

Nesta aula, aprendemos a construir interfaces gráficas para nossas aplicações. Trabalhamos com campos de texto com múltiplas linhas, caixas de seleção, listas e eventos. Vimos também como integrar a parte gráfica à programação OO que trabalhamos ao longo de todo o semestre.

QUESTÃO PARA REFLEXÃO Execute o exemplo de integração de interface e programação OO listados nesta aula e faça alguns experimentos com o tratamento de eventos e a chamada de métodos das classes.

LEITURAS INDICADAS Capítulo 14 do livro de Paul Deitel

SITES INDICADOS http://www.tiexpert.net/programacao/java/try-catch-finally.php

REFERÊNCIAS DEITEL, Paul. Java: como programar. 8. ed. São Paulo: Pearson Prentice Hall, 2010