universidade regional de blumenau centro de … · universidade regional de blumenau / centro de...

Universidade Regional de Blumenau / Centro de Ciências Exatas e Naturais / Departamento de Sistemas e Computação

DISCIPLINA: Programação Orientada a Objetos I

UNIVERSIDADE REGIONAL DE BLUMENAU

CENTRO DE CIÊNCIAS EXATAS E NATURAIS

DEPARTAMENTO DE SISTEMAS E COMPUTAÇÃO

PROGRAMAÇÃO ORIENTADA A OBJETOS I

(material de apoio)

PROFESSORES:

Adilson Vahldick

Marcel Hugo

Mauro Marcelo Mattos

Blumenau, Agosto de 2008


Ciências da Computação – Progr. Orientada a Objetos I Prof s. Adilson, Marcel e Mauro pág.: 1

SUMÁRIO

1 INTRODUÇÃO .................................................................................................................................................. 2

2 INTERFACE GRÁFICA.................................................................................................................................. 4

3 COLEÇÕES ....................................................................................................................................................... 30

4 RELACIONAMENTOS ENTRE CLASSES E OBJETOS ................................................................... 37

5 EXCEÇÕES ....................................................................................................................................................... 42

6 HERANÇA ......................................................................................................................................................... 46



1 INTRODUÇÃO Esta apostila é mais um material a apoiar os estudos a serem desenvolvidos na disciplina de Programação Orientada a Objetos I. Ela não tem a intenção de substituir qualquer livro indicado na bibliografia básica da disciplina muito menos de esgotar os assuntos discutidos em aula. Neste primeiro capítulo vamos relembrar uma aspecto importante da arquitetura de qualquer software, em particular de softwares orientados a objetos: o desacoplamento entre interface ao usuário e lógica do negócio.

1.1 ESTRUTURA DE UMA APLICAÇÃO OO

• A boa prática de programação recomenda que o programador deva separar a PARTE LÓGICA do programa da INTERFACE COM O USUÁRIO.

• Assim, em nossas aplicações orientados a objetos SEMPRE teremos no mínimo 2 classes:

- CLASSE PRINCIPAL: responsável pela interface com o usuário (leitura e escrita dos dados) e criação dos objetos necessários para a solução do problema. Doravante esta classe será denominada de main;

- CLASSE DO MODELO: responsável por executar as tarefas que solucionam a situação-problema proposta.

• Neste caso dizemos que há uma associação entre as classes.

• Deste modo, usaremos o seguinte modelo de arquitetura em nossas aplicações:

• A CLASSE PRINCIPAL terá sempre as seguintes tarefas fundamentais:

i. CRIAR O(S) OBJETO(S) da(s) classe(s) do modelo necessário(s) para a solução do problema;

CLASSE PRINCIPAL (classe main)

CLASSE DO MODELO (Lógica do Problema)



ii. OBTER do usuário, através do dispositivo de entrada (teclado), OS DADOS necessários para inicializar a classe do modelo;

iii. PASSAR OS DADOS obtidos para a classe do modelo;

iv. CHAMAR OS MÉTODOS da classe do modelo necessários para a solução do problema proposto;

v. OBTER da classe do modelo OS RESULTADOS do problema;

vi. INFORMAR ao usuário através do dispositivo de saída (vídeo) OS RESULTADOS obtidos;

• A CLASSE DO MODELO terá sempre as seguintes tarefas fundamentais:

vii. RECEBER os dados da classe principal;

viii. PROCESSAR os dados recebidos;

ix. DISPONIBILIZAR os resultados do processamento para a classe principal.



2 Interface Gráfica

2.1 Ambiente de Desenvolvimento Netbeans

Nas disciplinas de programação orientada a objetos ministradas nos cursos de computação da

Universidade Regional de Blumenau é comum utilizar um conjunto de ferramentas disponibilizadas

pelo ambiente de desenvolvimento Java da Sun – Java Development Kit (JDK) 1.6 (ou superior).

Contudo, este conjunto de ferramentas não fornece um ambiente de desenvolvimento para

programação (edição, compilação e depuração).

Assim sendo, para criar as aplicações Java, pode-se utilizar o Integrated Development

Environment (IDE) NetBeans. Este IDE permite a edição dos programas em Java e proporciona um

ambiente de desenvolvimento que facilita o aprendizado da linguagem e dos conceitos associados.

O material a seguir1 mostra como instalar o JDK e o NetBeans. Após o processo abaixo

descrito, você deve ter o Java e o IDE NetBeans instalados no seu sistema. Para maiores

informações, acesse o portal “IDE NetBeans” e “Documentação Java”.

2.1.1 Instalação das Ferramentas

Para fazer o download dos instaladores é necessário o aplicativo de instalação de cada uma

das ferramentas que serão utilizadas. Há duas formas de obtê-las:

a) emprestando o CD disponível na biblioteca da universidade;

b) fazendo o download diretamente da página dos fornecedores das ferramentas: IDE

NetBeans e JDK.

2.1.1.1 Fazendo o download do software JDK

Acesse o link: http://java.sun.com/javase/downloads/index.jsp. Você encontrará uma página

semelhante à mostrada na Figura 1.

1 Baseado no material produzido pela monitora Fernanda Gums.



Figura 1 - Tela para a escolha da versão do JDK

Clique no link “Get the JDK download” e você será remetido para uma página similar à

página à mostrada na Figura 2.

Figura 2 - Download Center

Clique no link “Review License Agreement” e você será remetido para a página do acordo

de Licenciamento do software (Figura 3).



Figura 3 - Acordo de Licenciamento do Software

Leia o acordo de licenciamento do software e clique no botão “Accept License Agreement” e

você será remetido para uma página que você deverá escolher a plataforma e o instalador a ser

baixado (Figura 4).

Figura 4 - Selecionar a plataforma e o instalador do JDK

Selecione uma das opções 1 ou 2 (para Windows) ou 3 ou 4 (para Linux) e clique no botão

“Download selected with Sun Download Manager” (opção 5).

No Windows será apresentada a janela para abrir um arquivo (Figura 5).



Figura 5 - Abrir o arquivo para iniciar o download

Clique no botão “Open” e será iniciado o processo de download do software Sun Download

Manager. Ao ser apresentada a janela da Figura 6 clique no botão “Run”.

Figura 6 - Execução do Gerenciador de Download

Será apresentada a janela (Figura 7) que contém os termos de licença de uso do software Sun

Download Manager. Clique no botão “Accept”.

Figura 7 - Termos de Licença do Software

Na janela de opções (Figura 8) configure as opções de funcionamento do software Sun



Download Manager selecionando a opção “Browse” (1) para indicar em que pasta você deseja

armazenar o software JDK a ser baixado. Selecione também as demais opções (2) conforme a sua

preferência e clique no botão “OK”.

Figura 8 - Opções para o download

Neste momento será apresentada uma janela (Figura 9) contendo as informações sobre o

processo de download do software selecionado. Como geralmente os arquivos a serem baixados são

relativamente grandes, o tempo para download vai depender da velocidade de conexão com a

internet que você possui. A qualquer momento você pode selecionar a opção “Pause” para

suspender temporariamente o download ou “Parar” para parar o processo.

Figura 9 - Andamento do download

Depois que o arquivo tenha sido baixado com sucesso, inicie a instalação.



2.1.1.2Fazendo o Download do Software NetBeans

Acesse o link: http://www.netbeans.info/downloads/index.php. Você encontrará uma página

semelhante a daFigura 10.

Figura 10 - Site do NetBeans > download

Se você vai executar o NetBeans em uma máquina com sistema operacional Windows,

clique no botão “Download NetBeans IDE”, baixe o arquivo e execute-o. Se você vai executar o

NetBeans em uma máquina com outro sistema operacional (Linux, MacOS, Solaris) clique no link

“Other Systems & Languages”, escolha o instalador, baixe o arquivo e siga as instruções de

instalação para o respectivo sistema. Na secção 2.1.1.4 é mostrado como instalar nos sistemas

Windows e Linux.

2.1.1.3 Instalando o ambiente JDK

Para proceder à instalação do JDK, dê um duplo clique sobre o aplicativo e siga as instruções

de instalação. Inicialmente será apresentada a tela (Figura 11) contendo o acordo de licença de uso

do software. Clique no botão “Accept”.



Figura 11 - Licença de Uso do Software

Concordando com a licença de uso, aparecerá a tela de configuração da instalação conforme

a Figura 12.

Figura 12 - Configuração da Instalação

No caso da instalação da versão 6 do ambiente de desenvolvimento (JDK), será instalado

também o ambiente de RunTime necessário para a execução de applets e aplicações em geral na sua

máquina. Esta solicitação será realizada como mostra a Figura 13. Clique no botão “Next” e

aguarde a finalização da instalação.



Figura 13 - Configuração da Instalação

Ao término do processo de instalação do ambiente JDK, será apresentada a tela (Figura 14)

indicando o sucesso dos procedimentos. O próximo passo é instalar o editor de aplicações IDE

Netbeans.

Figura 14 - Instalação Completa

2.1.1.4 Instalando o ambiente Netbeans

As informações a seguir foram obtidas a partir do link

http://www.netbeans.org/community/releases/55/install_pt_BR.html#standalone. A seguir são

apresentadas instruções para instalação nos ambientes Windows e Linux.

Em computadores com o Microsoft Windows, usar o instalador compactado auto-extraível, o

qual apresenta um método preferencial de instalar o NetBeans IDE. Para instalar siga os seguintes

passo:



c) depois de fazer o download do arquivo instalador, clique duas vezes no ícone para abrir o

instalador.;

d) no assistente de instalação, escolha uma resposta para o “Contrato de Licença” e clique

em “Próximo”;

e) especifique um diretório vazio dentro do qual será instalado o NetBeans IDE. Esta

instalação do NetBeans IDE não desorganizará as configurações de outras instalações do

NetBeans, porque o IDE cria automaticamente um novo diretório de usuário quando é

aberto (${HOME}/.netbeans/5.5);

f) escolha o JDK que o IDE usará na lista de JDKs compatíveis e clique em “Próximo”;

g) verifique se o local de instalação está correto e se há espaço disponível no sistema para a

instalação;

h) clique em “Próximo” para iniciar a instalação. Caso haja problemas durante a instalação

do software, consulte a seção “Solução de problemas” para obter as descrições completas

e as soluções alternativas sugeridas para problemas não resolvidos que podem afetar o

processo de instalação.

Em computadores com Linux, o método de preferência para instalar o NetBeans IDE é usar

o instalador binário. Para instalar siga os seguintes passo:

i) vá até o diretório que contém o instalador;

j) se necessário, altere as permissões do arquivo instalador para tornar o binário executável.

Para tanto, digite em um prompt o comando “$ chmod +x seu_binário_executável”.

Certifique-se de substituir seu binário_executável pelo nome real do arquivo do binário

que foi baixado;

k) abra o instalador executando em um prompt de comando (“$ ./seu_binário_executável”).

Verifique novamente se substituiu seu binário executável pelo nome real do

arquivo do binário que foi baixado;

l) no assistente de instalação, escolha uma resposta para o “Contrato de Licença” e clique

em “Próximo”;

m) especifique um diretório vazio dentro do qual será instalado o NetBeans IDE e clique em

“Próximo”;

n) escolha o JDK que o IDE usará na lista de JDKs compatíveis e clique em “Próximo”;

o) o instalador procura os JDKs instalados no sistema e pergunta se deseja especificar qual

será utilizado. É possível fazer isso na linha de comando (“$ ./seu_binário_executável -

is:javahome caminho_para_seu_jdk”);

p) verifique se o local de instalação está correto e se há espaço disponível no sistema para a

instalação;



q) clique em “Próximo” para iniciar a instalação. Caso haja problemas durante a instalação

do software, consulte a seção “Solução de problemas” para obter as descrições completas

e as soluções alternativas sugeridas para problemas não resolvidos que podem afetar o

processo de instalação.

2.1.2 Introdução ao NetBeans

Antes de começar, é necessário que você tenha instalado em seu sistema o J2SE

Development Kit (JDK), versão 6.0 ou compatível (SUN MICROSYSTEMS, 2007) e o NetBeans

IDE, versão 5.5 ou compatível (NETBEANS, 2007b).

2.1.2.1 Criando um Projeto Simples - tutorial

O objetivo desta seção é criar um projeto simples no IDE Netbeans objetivando o

aprendizado de como fazer as tarefas mais comuns.

O projeto criado neste tutorial mostrará na tela uma mensagem que você deseja imprimir.

Para criarmos o projeto simples na IDE os seguintes passos, adaptados de XXXXXXXX-IDE

Netbeans, deverão ser seguidos:

a) criar o projeto – passos:

- inicie o IDE NetBeans,

- no IDE escolha Arquivo > Novo Projeto (), como mostra a Figura 15;

b) na janela Novo Projeto, expanda a categoria Geral e selecione Aplicação Java (Figura

16);

c) na página Nome e Localização (Figura 17) na janela, faça:

- no campo Nome do Projeto, escreva OlaMundo,

- no campo Criar Classe Principal escreva olamundo.OlaMundo,

- deixe a opção Definir como Projeto Principal marcada;

d) Clique em Finalizar. O Projeto é criado e aberto na IDE. Devem aparecer na tela os

seguintes componentes (Figura 18):

- a aba de Projetos, que contém os componentes do projeto, incluindo códigos fontes e

bibliotecas,

- a janela de Edição do Código Fonte com um arquivo aberto contendo o nome da



Classe definida anteriormente. Neste caso o nome é OlaMundo.java,

- a janela Navegador, que pode ser usada para navegar rapidamente entre os elementos

(construtores, métodos, atributos) da classe selecionada.

Figura 15 – Criando um “Novo Projeto”

Figura 16 - Tipo do Projeto



Figura 17 - Nome e Localização do Projeto

Figura 18 - Janela do IDE NetBeans com Projeto criado



2.1.2.1.1 Adicionando Código Fonte ao Arquivo OlaMundo.java

Como você deixou a opção Criar Classe Principal selecionada na hora da criação do projeto,

a IDE criou uma classe padrão. Para adicionar a mensagem “Olá Mundo” ao código gerado, basta

substituir a linha mostrada no Quadro 1 pela linha do Quadro 2. Após, salve o arquivo selecionando

no menu Arquivo > Salvar (Ctrl+S). No arquivo OlaMundo.java deverá estar conforme mostrado no

Quadro 3.

// TODO code application logic here Quadro 1 – Comentário padrão do NetBeans

System.out.println(“Olá Mundo!”) Quadro 2 – Mostrando “Olá Mundo”

/* * OlaMundo.java * Created on 25 de Abril de 2007, 16:20 */ package olamundo; /** * A Classe OlaMundo implementa uma aplicação que simplesmente mostra * "Olá Mundo!" no dispositivo de saída. * @author Fernanda Gums */ public class OlaMundo { /** * CONSTRUTOR: * Cria um objeto de OlaMundo */ public OlaMundo() { } /** * PRINCIPAL: * Método que imprime na tela a mensagem "Olá Mundo!" * @param args the command line arguments */ public static void main(String[] args) { System.out.println("Olá Mundo!"); } }

Quadro 3 – Classe “OlaMundo”

2.1.2.1.2 Compilando o Código Fonte

Para compilar o código selecione no menu: Construir > Construir Projeto Principal (Tecla de

Atalho: F11). Na janela de Saída é mostrado o resultado (Figura 19).



Figura 19 - Janela com resultado da compilação do programa “OlaMundo”

Figura 5: Compilação do Código Fonte Executada com Sucesso

Se o resultado da compilação concluir com sucesso, será mostrada a mensagem

“EXECUTADO COM SUCESSO”. Caso contrário, a mensagem “FALHA NA EXECUÇÃO” será

mostrada, a qual indica a existência de erro no código fonte.

Na mesma janela é mostrada uma mensagem de erro com uma ligação (link) que indica o

local do código que contém o erro. Após corrigir o erro, inicie o processo de compilação

novamente. Com o projeto compilado, já é possível executar o programa.

2.1.2.1.3 Executando o Programa

A partir do menu, selecione: Executar > Executar Projeto Principal (Tecla de Atalho: F6). O

resultado da execução está representado na Figura 20.

Figura 20 - Janela de Saída da execução

2.1.2.2 Criando um Projeto com Interface Gráfica usando ferramenta do NetBeans

Este tutorial visa fornecer uma simples introdução ao uso do IDE NetBeans, sendo guiado

através de uma aplicação Java com interface de interação com o usuário.



Para criarmos um projeto na IDE os seguintes passo deverão ser seguidos:

b) inicie o NetBeans;

c) no IDE, escolha “Arquivo > Novo Projeto“, como é mostrado na Figura 21;

d) na janela Novo Projeto, expanda a categoria Geral e selecione Aplicação Java como é

mostrado na figura Figura 22;

e) na página apresentada na Figura 23, em Nome e Localização faça o seguinte:

- no Campo Nome do Projeto, escreva “Computador”,

- desmarque a opção “Criar Classe Principal”,

- clique em Finalizar;

f) expanda o item Pacotes de Código-Fonte(Figura 24). Clique com o botão direito do

mouse em <pacote padrão> e selecione Novo > Pacote Java;

g) na guia Nome e Localização(Figura 25), digite no campo Nome do Pacote o nome

desejado, por exemplo, “Interface” e clique em Finalizar. Você poderá observar que o

pacote “Interface” ficou subordinado aos Pacotes de Código-Fonte;

h) agora vamos criar a nossa primeira janela, a qual terá por finalidade simular um

computador, com teclado e monitor. Clique com o botão direto do mouse em “Interface >

Novo > Formulário JFrame” (Figura 26);

i) digite um nome para o “Formulário”, por exemplo, “InputOutput” e clique em

Finalizar(Figura 27);

j) pronto, seu formulário foi criado (Figura 28). Apenas é necessário incluir os

componentes para que o formulário fique semelhante ao que conhecemos como um

computador. Mas antes de começar a incluir os componentes, vamos abrir um parêntese e

falar sobre o Gerenciador de Layout. Um Gerenciador de Layout organiza os

componentes na janela gráfica do programa. Em Java, um objeto que implementa a

interface LayoutManager ou LayoutManager2 é responsável por esta

disposição/organização. Por padrão, o Java vem com cinco Gerenciadores de Layout:

BorderLayout, BoxLayout, FlowLayout, GridBagLayout, GridLayout e um adicional, o

CardLayout. São os gerenciadores que determinam como os componentes serão

distribuídos em seu programa O conhecimento básico sobre o funcionamento dos

mesmos é necessário para ter o domínio da aplicação gráfica na linguagem Java. O IDE

NetBeans disponibiliza mais opções de Layout. Neste tutorial utiliza-se o BorderLayout e

o GridLayout. O BorderLayout tenta organizar os objetos em um dentre cinco locais

geográficos, representados por constantes na classe BorderLayout (NORTH, SOUTH,

EAST, WEST e CENTER), possivelmente com algum afastamento entre eles

(NEIMEYER, p.473). Já o GridLayout organiza os componentes em linhas e colunas,



como se fosse uma tabela. Eles são adicionados da esquerda para direita e de cima para

baixo em uma grade;

k) continuando com a execução do tutorial, vamos adicionar no JFrame o Gerenciador de

Layout BorderLayout. Para isto, basta clicar com o botão direito do mouse em JFrame >

Definir Layout > Border Layout (Figura 29);

l) na Paleta, estão os componentes que podem ser utilizados no JFrame. Para que eles

sejam apenas adicionados, basta clicar uma vez sobre o componente desejado e no

desenho do JFrame (Figura 30);

m) para criar o nosso simulador de um computador, colocaremos três JPanel, dois

JScrollPane, um JTextArea, um JTextField e dois JLabel, seguindo os seguintes passos

(Figura 31):

- colocar no JFrame o JPanel1, o JPanel2 e o JPanel3. O JPanel1 deverá ficar alinhado

a Esquerda. Para isto, vá às propriedades do componente, procure o item Direção e

escolha “West”. Faça o mesmo procedimento com o JPanel2(East) e o

JPanel3(“North”),

- na propriedade preferredSize coloque para o JPanel 1 e 2 o valor [200,100] e para o

JPanel3 [150,30],

- desmarque a opção enabled do JPanel2,

- no JPanel3, use o Gerenciador de Layout GridLayout,

- agora adicionar no JPanel1 um JScrollPane. Dentro do JScrollPane adicionar um

JTextField,

- no JPanel2, adicione um JScrollPane, depois um JTextArea. Desmarque a opção

editable nas propriedades do JTextArea,

- no JPanel3, adicione dois JLabel. No JLabel da esquerda coloque a propriedade text

como “Teclado” e no JLabel da direita como “Monitor”, conforme a imagem

representada na Figura 32;

n) a tela de simulação de um computador já está criada. Agora basta programar um evento

que faça com que tudo o que for digitado no “Teclado” seja propagado para o “Monitor”

após pressionada a tecla <ENTER>. Para isso, clique com o botão direito do mouse em

jTextField1 > Eventos > Action > actionPerformed. Uma janela que contém o código

fonte será aberta e lá você poderá programar o evento. Foi criado um método (Quadro 4)

para fazer com que o texto digitado no “Teclado” seja mostrado no “Monitor”, após um

<ENTER>;

o) no método construtor da classe InputOutput vamos definir um tamanho para o frame

através do método setSize() e também não permitir que o tamanho do frame seja



modificado através do método setResizable(). O código fonte do método é apresentado no

Quadro 5;

p) agora para executar e ver o resultado (Figura 33), salve o projeto e clique no Menu

Executar > Executar Projeto Principal ou então utilize o atalho F6 no teclado. Agora seu

projeto Computador está pronto.

Figura 21 – Criando um projeto

Figura 22 – Janela “Novo Projeto”



Figura 23 – Janela “Nova Aplicação Java”

Figura 24 – Janela “NetBeans IDE 5.5 – Computador”



Figura 25 - Janela "Novo Pacote Java"

Figura 26 – Janela inicial do projeto “Computador”



Figura 27 - Janela "Novo Formulário JFrame"

Figura 28 - Formulário criado



Figura 29 – Gerenciador de Layout

Figura 30 - Janela "Paleta"



Figura 31 – Janela de propriedades

Figura 32 – Representação do “Teclado” e “Monitor”



Quadro 4- Método para ecoar a digitação no “Teclado” para o “Monitor”

Quadro 5 – Método construtor da classe InputOutput

Figura 33 – Resultado da execução

2.2 Interface Gráfica Swing

• Existem diversas APIs para construção de interfaces gráficas em Java. Entre elas destacam-se: AWT, SWT, Swing e JSF.



• Pela característica das aplicações desenvolvidas na disciplina será utilizada a API Swing.

• A API Swing apresenta diversos componentes gráficos para construção de interfaces com o usuário em Java.

• Estes componentes pertencem ao pacote javax.swing e estão destacados no quadro a seguir:

• Por serem classes, os componentes têm propriedades e métodos.

• Os componentes também têm eventos, que serão detalhados a seguir.

• A montagem de uma interface gráfica no Swing é feita basicamente sobre duas classes: JFrame e JPanel, os quais apresentam algumas variações.

• Para se fazer uma tela gráfica é necessário inicialmente esboçar um layout para definir como se deseja que as informações estejam dispostas na interface.

2.3 Eventos

• A interação do usuário do programa com as classes definidas pelo programador normalmente é implementada através de eventos.

• Os eventos são blocos de comandos que associam a ocorrência de alguma ação realizada sobre o sistema a uma possível reação.



• Em uma interação baseada em eventos as ações só são realizadas a partir do instante em que ocorre um evento.

• Um evento pode estar associado a:

- clique ou movimento do mouse;

- acionamento do teclado;

- operações sobre janelas (abrir, fechar, criar, redimensionar, mover);

- um temporizador (timer);

- uma falha de hardware ou software.

- etc.

• Em Java um evento é denominado de Listener. Um Listener é um objeto que é notificado quando um evento acontece.

• Alguns dos principais tipos de eventos em Java são: ActionEvent Ocorre quando um botão é pressionado, quando um item de lista recebe um duplo clique ou quando um item de menu é selecionado. ComponentEvent Ocorre quando um componente é ocultado, movido, redimensionado ou se torna visível. FocusEvent Ocorre quando um componente recebe ou perde o foco do teclado. ItemEvent Ocorre quando é selecionado um item em uma lista de itens. KeyEvent Ocorre quando se manipula o teclado. MouseEvent Ocorre quando se manipula o mouse (mover, clicar, etc.). WindowEvent Ocorre quando se manipula uma janela (mover, fechar, maximizar, etc.).



REFERÊNCIAS BIBLIOGRÁFICAS

MENGUE, Fábio. Curso de Java. Módulo II – Swing. [S.l], 2007. Disponível em: <http://ftp.unicamp.br/pub/apoio/treinamentos/linguagens/curso_java_II.pdf >. Acesso em: 15 ago. 2007.

NEIMEYER, Patrick. Aprendendo Java. Tradução Learning Java. Rio de Janeiro: Campus, 2000.

NETBEANS. GUI Building in NetBeans IDE 5.5. [S.l], 2007a. Disponível em: <http://www.netbeans.org/kb/55/quickstart-gui.html>. Acesso em: 15 ago. 2007.

_____. NetBeans IDE 5.5.1 Download. [S.l], 2007b. Disponível em: <http://www.netbeans.info/downloads/index.php>. Acesso em: 15 ago. 2007.

SUN MICROSYSTEMS. Java™ Platform, Standard Edition 6 API Specification. [S.l], 2006. Disponível em: <http://java.sun.com/javase/6/docs/api/index.html>. Acesso em: 15 ago. 2007.

_____. Java SE Downloads. [S.l], 2007. Disponível em: <http://java.sun.com/javase/downloads/index.jsp>. Acesso em: 15 ago. 2007.



3 COLEÇÕES

3.1 Vetores e Matrizes

A linguagem Java dá suporte a vetores e matrizes (arrays) de diversas formas. Os vetores constituem uma forma muito conveniente de organizar informações em fileira. Por exemplo, podemos formar um vetor com as notas de cinco alunos de uma sala de aula do seguinte modo:

float nota[] = { 7.8, 8.4, 4.2, 1.8, 6.4 }; Neste caso nota[0] é a nota do primeiro aluno, isto é, 7.8, nota[1] é a nota do segundo, ou seja, 8.4, e assim por diante. A utilização de vetores e matrizes em Java envolve três etapas:

1. Declarar o vetor ou matriz. Para isto, basta acrescentar um par de colchetes antes ou depois do nome da variável ou do tipo/classe. Por exemplo:

int ind[]; double a[][]; int[] nota;

2. Criar o vetor. Reservar espaço de memória, definindo o tamanho. É preciso

definir o tamanho do vetor, isto é, a quantidade total de elementos que terá de armazenar. Em seguida é necessário reservar espaço de memória para armazenar os elementos. Isto é feito de maneira simples pelo operador new:

ind = new int[10]; nota = new int[70]; a = new double[10][20];

3. Armazenar elementos no vetor ou matriz. Para armazenar uma informação

em um dos elementos de um vetor ou matriz, é necessário fornecer um índice que indique a posição desse elemento. Por exemplo, para armazenar um valor na quarta posição do vetor nota, fazemos o seguinte:

nota[3] = 5.2;

Como podemos observar, os índices começam em zero e vão até o número de posições reservadas, menos um. No vetor nota criado acima, os índices válidos vão de 0 até 69. Caso haja a tentativa de atribuir um valor a um elemento cujo índice



esteja fora desse intervalo, ocorrerá uma exceção que impedirá a execução do programa. Por isso, é necessário um certo cuidado ao manejar com esses índices, garantindo o perfeito funcionamento do programa. Existe um atalho para esses três passos quando desejamos criar um vetor com valores atribuídos de modo estático. Foi o que fizemos no primeiro exemplo acima, declarando o vetor nota com as notas de cinco alunos. Nesse caso o espaço suficiente para as notas de cinco alunos foi reservado e as notas foram guardadas em respectivas posições do vetor. Entretanto, nem sempre é tão fácil assim. Em geral, estaremos interessados em trabalhar com vetores muito maiores, e cujos elementos sejam provenientes de outras fontes, que variam com o tempo. Assim, seremos obrigados a seguir os passos acima. Eis mais alguns exemplos de vetores e matrizes:

// 12 primeiros termos da seqüência de Fibonacci: long Fibonacci[] = {1,1,2,3,5,8,13,34,55,89,144}; // Tabela de sen(n*pi/6), n = 0,1,2,...5 float seno[] = {0.0000,0.5000,0.8660,1.0000,0.8660,0.5000}; // Tabela de log(1+n), n = 0,2...99: double tlog[] = new double[100]; for(int n = 0; n < 100; n++) tlog[i] = Math.log(1+n); // Matriz dos coeficientes double a[][] = {{1,2,3}, {0,1,3}, {0,0,-1}};

3.2 ArrayList

Array redimensionável implementando a interface List. Implementa todas as operações opcionais de uma lista e permite qualquer elemento, incluindo null. Os métodos básicos da classe ArrayList() em Java estão listados na tabela a seguir:

Método Descrição Add (objeto) Adiciona um objeto na lista Add (pos, objeto) Adiciona um objeto na lista na posição indicada por pos clear() Elimina todos os objetos da lista boolean contains (objeto) Informa se um determinado objeto está na lista objeto get (pos) Retorna um objeto de uma determinada posição da lista boolean isEmpty() Informa se a lista está vazia remove (objeto) Retira o objeto da lista objeto remove (pos) Retira o objeto de uma determinada posição da lista int size() Retorna o tamanho da lista



3.2.1 Declarando um ArrayList Um atributo de uma classe ou uma variável local a um método pode ser definido como um ArrayList da seguinte forma: ArrayList lista; Toda lista deve ser criada, assim como qualquer objeto. A criação de um objeto lista é feita da seguinte forma. lista = new ArrayList(); Como todas as coleções, uma lista pode armazenar objetos de qualquer tipo, pois as coleções trabalham com os objetos como sendo Object – a classe mais básica do Java. Em uma mesma lista é possível ter instâncias de pessoas, carros, livros, etc. Assim, para cada objeto recuperado da lista é preciso verificar qual o seu tipo (cast). A partir da versão 5 do Java é possível especificar um tipo único de objeto a ser inserido na lista, facilitando a sua manipulação. ArrayList<Classe> lista; Desta forma, a lista terá apenas objetos que sejam do tipo da classe especificada. Exemplo: ArrayList<Pessoa> listaPessoas; No exemplo apresentado o atributo listaPessoas, que é um ArrayList, poderá armazenar apenas objetos da classe Pessoa. Para criar a lista também é necessário especificar o tipo de objeto: listaPessoas = new ArrayList<Pessoa>();

3.2.2 Percorrendo um ArrayList Há três formas de percorrer um ArrayList:

• Através de um laço for, controlado pelo tamanho (size()), buscando os objetos pela sua posição (get(int));

• Por um iterador (Iterator); • A partir da versão 5, por um laço for-each.

Na primeira forma, utiliza-se os métodos da própria classe ArrayList para controlar o laço (quantidade de elementos na lista) e para buscar cada objeto. for (int cont=0; cont < nomeLista.size();

contador++) {

objeto = (ClasseDoObjeto)nomeLista.get(cont);

[comandos da repetição]

}



Exemplo: for (int i=0; i<listaPessoas.size(); i++) {

pessoa = listaPessoas.get(i);

System.out.println (pessoa.getNome());

System.out.println (pessoa.getIdade());

}

O exemplo acima escreve o nome e a idade de todas as pessoas de uma lista de pessoas. Observe neste exemplo que não foi necessária a conversão da referência (cast) de Object para Pessoa, pois o ArrayList foi declarado e criado como sendo de objetos de Pessoa. Na segunda forma, é usada a infraestrutura do framework Collections, através de um iterador. O funcionamento é simples: pede-se ao ArrayList o objeto de iteração capaz de percorrer seqüencialmente todos os elementos da lista. Através dos métodos deste objeto é feita a busca dos elementos. Iterator nomeIterador = nomeLista.iterator();

while (nomeIterador.hasNext()) {

objeto = (ClasseDoObjeto) nomeIterador.next();


} Exemplo: Iterator it = listaPessoas.iterator();

while (it.hasNext()) {

pessoa = (Pessoa) it.next();



} Na terceira forma, o Java (a partir da versão 5) oferece uma estrutura de repetição baseado no for (for-each ou para cada), onde se deve especificar a lista que se deseja percorrer, e um objeto que representa o elemento corrente da lista. for (ClasseDoObjeto nomeObjeto : nomeLista) {


} Exemplo: for (Pessoa pessoa : listaPessoas) {



}



3.3 HashMap

Implementação de mapeamento, ou seja, uma coleção que tem mapeado chaves para valores (objetos). Através de tabela hash, é a melhor implementação da interface Map neste pacote. Provê todas as operações opcionais de Map , permitindo valores null e chave null . Os métodos básicos da classe HashMap() em Java estão listados na tabela a seguir:

Método Descrição clear() Elimina todos os objetos da coleção boolean containsKey (chave) Retorna true caso exista a chave especificada boolean containsValue (objeto) Informa se um determinado objeto está mapeado na

coleção objeto get (chave) Retorna um objeto mapeado de acordo com a chave

especificada objeto put (chave,objeto) Insere um objeto na coleção, associando a chave ao

objeto objeto remove (chave) Retira o objeto da lista, de acordo com a chave int size() Retorna a quantidade de objetos inseridos

3.3.1 Declarando um HashMap Um atributo de uma classe ou uma variável local a um método pode ser definido como um HashMap da seguinte forma: HashMap tabela; Todo mapeamento deve ser criado, assim como qualquer objeto. A criação de um objeto de mapeamento é feita da seguinte forma. tabela = new HashMap(); Como todas as coleções, um mapeamento também pode armazenar objetos de qualquer tipo. A partir da versão 5 do Java é possível especificar um tipo único de objeto a ser inserido no mapeamento, bem como o tipo de sua chave, facilitando a sua manipulação. HashMap<ClasseChave, ClasseInserido> tabela; Desta forma, o mapeamento terá apenas objetos que sejam do tipo da classe especificada, com chaves da classe especificada. Exemplo: HashMap<String,Pessoa> tabela;



No exemplo apresentado o atributo tabela, que é um HashMap, poderá armazenar apenas objetos da classe Pessoa, tendo como chave objetos de String. Para criar o mapeamento também é necessário especificar o tipo de objeto: tabela = new HashMap<String,Pessoa>();

3.3.2 Armazenando e buscando objetos Para inserir um objeto no mapeamento, deve-se usar o método put (chave, objeto). Exemplo: Pessoa p = new Pessoa(“João da Silva”, “Rua dos

Andradas”, “999.123.878-00”);

tabela.put(“999.123.878-00”, p);

O exemplo acima coloca o objeto de Pessoa (instanciado na 1ª linha) no mapeamento (HashMap) tabela, utilizando como chave um objeto de String cujo valor representa o CPF da pessoa. Desta maneira, quando quiser buscar alguma pessoa dentro do mapeamento, deverá se ter o valor de seu CPF. Utilizando o método get(chave) se obterá o objeto procurado. Caso a chave não seja localizada, null é retornado. Exemplo: Pessoa pessoa;

pessoa = tabela.get(“123.456.789.10”); if (pessoa == null)

System.out.println(“Não encontrado”);

else

pessoa.getNome();

3.3.3 Percorrendo um HashMap HashMap não foram feitos para ser percorridos seqüencialmente (como listas). Como Map não extende Collection, não é previsto em Map uma varredura dos valores contidos no mapeamento. Porém é possível através do método values() ter uma visão de coleção dos valores (objetos) mapeados e assim percorrê-los seqüencialmente através de um iterador. Iterator nomeIterador =

nomeMapeamento.values().iterator();

while (nomeIterador.hasNext()) {

objeto = (ClasseDoObjeto) nomeIterador.next();


} Exemplo: Iterator it = tabela.values().iterator();

while (it.hasNext()) {



pessoa = (Pessoa) it.next();



}

Um aspecto importante a ressaltar é que esta visão de coleção criada a partir do método values() não garante nenhuma ordem dos objetos a serem percorridos, nem a ordem das chaves nem a ordem de inserção dos objetos.

� Leia mais em HORSTMANN, Cay. Big Java. Porto Alegre: Bookman, 2004. Capítulos 13, 19 e 20.



4 RELACIONAMENTOS ENTRE CLASSES e OBJETOS

• Assim como no mundo real, os objetos na OO também se relacionam e este relacionamento ocorre de diferentes formas e graus.

• Basicamente podemos identificar os relacionamentos temporários e duradouros entre objetos.

• Um relacionamento temporário é aquele em que, para cumprir determinada responsabilidade, um objeto necessita de outro objeto (conhecê-lo e solicitar suas operações) apenas durante a execução desta responsabilidade. Este tipo de relacionamento é chamado de dependência.

• Os relacionamentos duradouros são aqueles em que durante a vida de um objeto ele está ligado a outro para cumprir várias de suas responsabilidades. Estes relacionamentos podem ser de associação ou de agregação.

4.1 Dependência

• Como dito, a relação de dependência ocorre entre dois objetos quando temporariamente um necessita do outro – assim, o objeto A necessita/depende do objeto B.

• No diagrama de classe da UML isto é representado por uma linha pontilhada, terminada em uma seta da classe dependente para a classe utilizada.

Classe A Classe B

• Em termos de código, a dependência é percebida quando um objeto é utilizado como variável local a um método (parâmetro ou declarado localmente).



• Como exemplo, imagine a situação onde um objeto de retroprojetor possua uma método limpar(). Para executar esta operação ele precisa temporariamente de um objeto de Pano, que o servirá apenas naquele instante.

Retroprojetor

limpar ()limpar (p : Pano)

Pano

esfregar( )

class Retroprojetor {

...

public void limpar(){

Pano umPano = new Pano(); // exemplo de dependência

umPano.esfregar(); // por declaração local

...

}

public void limpar(Pano p){ // exemplo de dependência

... // por parâmetro

p.esfregar();

...

}

}

class Pano {

...

}

4.2 Associação

• A relação de associação ocorre entre dois objetos quando este relacionamento é uma das características de um dos objetos, isto é, um dos atributos relevantes de um objeto é o outro objeto. Assim, o relacionamento é mais duradouro entre o objeto A e o objeto B.

• O motivo ou significado do relacionamento deve ser expresso, ou seja, deve-se nomear o relacionamento.

• No diagrama de classe da UML isto é representado por uma linha, com a nomeação da associação indicada.

Classe A Classe Bnomeação



• Na associação, além de nomeá-la, devemos também indicar sua multiplicidade. Lembre-se da teoria dos conjuntos. Para a multiplicidade vamos identificar quantos objetos de um conjunto se relacionam com quantos objetos do outro conjunto.

• Como exemplo, imagine que um Retroprojetor está alocado ou instalado em uma Sala. Identificar a multiplicidade é fazer duas perguntas:

a. Quantos Retroprojetores podem estar alocados em uma mesma Sala (0, 1 ou vários)?

b. Em quantas Salas pode estar alocado o mesmo Retroprojetor (0, 1 ou várias)?

Sala

Retroprojetor

limpar( )limpar( )

0..* 0..1

está alocado

0..10..*

Então a leitura se dá: um objeto de Retroprojetor está alocado a nenhuma ou no máximo a um objeto de Sala. Um objeto de Sala aloca nenhum ou vários objetos de Retroprojetor.

• Em termos de código, a associação é implementada colocando como atributo de uma das classes um handle para objeto(s) da outra.

• Qual classe conterá o atributo? Depende do contexto do problema e da maneira como se quer projetar a solução. Normalmente a classe que participa com multiplicidade 1 é atributo da outra. Mas para deixar isto bem claro no diagrama, ainda existe a notação da navegabilidade (uma seta no final da linha de associação), que indicará a partir de qual objeto existe a referência para o outro.

Sala

Retroprojetor

limpar( )limpar( )

0..* 0..1

está alocado

0..10..*



• Como atributo, devemos lembrar que seu conteúdo será encapsulado. Isto requer a implementação de métodos para manipular esta referência.

class Retroprojetor {

...

private Sala umaSala;

public void setSala(Sala s){

...

umaSala = s;

...

}

}

class Sala {

...

}

Execute o tutorial sobre Métodos, que contém um exemplo de auto-associação (Pessoa é casada com Pessoa), disponível em http://www.inf.furb.br/~poo/tutoriais/poo-lab4.html .

4.3 Agregação

• A relação de agregação ocorre entre dois objetos quando está envolvido o conceito de “todo-parte”, isto é, um objeto forma ou compõe o outro objeto.

• Neste momento não discutiremos a diferença entre agregação e composição, assumindo que ocorrendo “todo-parte” será modelada a agregação.

• No diagrama de classe da UML isto é representado por uma linha com um losango junto à classe que indica o todo na relação. Não há necessidade de nomear uma agregação, pois seu significado já está determinado: a parte (Classe B) está contida no todo (Classe A); o todo tem uma parte.

Classe BClasse A

• Também aqui devemos indicar sua multiplicidade, fazendo as mesmas perguntas da associação. Imagine que o campus universitário é formado por Blocos de edifícios e que estes são formados por Salas:



a. Quantos Salas podem estar existir em um mesmo Bloco (0, 1 ou várias)?

b. Em quantos Blocos pode estar alocada a mesma Sala (0, 1 ou vários)?

SalaBloco

1 1..*1..*1

• Então a leitura se dá: um objeto de Bloco é formado por no mínimo 1 ou vários objetos de Sala. Um objeto de Sala faz parte de 1 objeto de Bloco.

• Em termos de código, a agregação é implementada colocando como atributo de uma das classes (todo) um handle para uma coleção de objetos da outra (parte). E normalmente esta é a navegabilidade esperada (que fica implícita no diagrama).

• Como atributo, devemos lembrar que seu conteúdo será encapsulado. Isto requer a implementação de métodos para manipular esta coleção.

class Bloco {

...

private List salas = new ArrayList();

public void addSala(Sala s){

...

salas.add(s);

...

}

}

class Sala {

...

}

Execute o tutorial sobre Agregação, disponível em http://www.inf.furb.br/~poo/tutoriais/poo-lab5.html .

� Leia mais em MEDEIROS, Ernani. Desenvolvendo software com UML 2.0: definitivo. São Paulo: Makron Books, 2004. p. 96-105.



5 EXCEÇÕES

5.1 Tipos de Exceção

• Error = condições muito graves, sem recuperação

• Exception = superclasse das classes usadas para representar dois tipos de condições excepcionais:

a. classe RuntimeException = geradas pelo sistema de tempo de execução Java (falhas de projeto ou programação)

b. Todas as outras exceções

• Exceções ocorrem quando é tentada uma ação inválida

a. Exemplo: divisão por zero, acessar uma posição que não existe num array, abrir um arquivo que não existe, tentar conectar um site não habilitado, ....

• Manipulação de exceções:

a. pode-se tratá-las individualmente (try / catch); ou



b. pode-se definir que o método não irá tratar as exceções, e, portanto, propagá-la a quem chamou o método (throws).

Tratar ou não uma exceção é uma decisão de projeto.

O tratamento de algumas exceções pode ser ignorado: exceções não verificadas pelo compilador, ou seja, o compilador não verificará se o programador tratou/propagou a exceção.

Porém nas exceções verificadas, o compilador exige que o desenvolvedor tenha tomado alguma atitude (tratado ou propagado), senão acusará um erro de compilação.

5.2 Exemplo: tratando a exceção

class Arquivo {

public static void main(String[] args) {

try {

FileReader arqin = new FileReader(args[0]);

int lido;

while ((lido = arqin.read()) != -1) {

System.out.print((char)lido);

}

arqin.close();

} catch (ArrayIndexOutOfBoundsException e){

System.out.println("Deve ser informado o arquivo como

parâmetro");

} catch (FileNotFoundException e) {

System.out.println("Erro na abertura do arquivo " + args[0]);

} catch (IOException e) {

System.out.println("Erro de leitura");

}

5.3 Exemplo: propagando a exceção

class Arquivo {

public static void main(String[] args)

throws Exception {

try {

FileReader arqin = new FileReader(args[0]);

int lido;

while ((lido = arqin.read()) != -1) {

System.out.print((char)lido);

}

arqin.close();



} catch (ArrayIndexOutOfBoundsException e){

System.out.println("Deve ser informado o arquivo como

parâmetro");

}

}

5.4 Exceções comuns (Runtime)

• ArithmeticException: normalmente, o resultado de uma operação de divisão por zero realizada com números inteiros: int i = 12 / 0;

• NullPointerException: acessar um objeto ou método antes de ele ter sofrido uma instanciação:

Image im [] = new Image [4];

System.out.println(im[0].toString());

• NegativeArraySizeException: criar uma matriz comum tamanho de dimensão negativo.

• ArrayIndexOutOfBoundsException: acessar um elemento de matriz fora da definição original de tamanho da matriz.

5.5 Próprias exceções

• Criar a classe de exceção (subclasse de alguma classe de exceção)

• Definir o ponto de lançamento da exceção (situação excepcional)

• Tratar o lançamento da exceção

Criando sua própria classe de exceção:

class MinhaConsistênciaException extends Exception {

private String razão, solução;

public MinhaConsistênciaException(String r,String s) {

razão = r;

solução = s;

}

public String getRazão() { return razão;}



public String getSolução() { return solução;}

}

Definindo a situação excepcional:

public void setIdade(int valor) throws MinhaConsistênciaException{

if (valor < 0 || valor > 150) // teste para consistência

throw new MinhaConsistênciaException("Valor

incorreto em Idade","Valores entre 0 e 150");

idade = valor;

}

Ao fazer uso do método, tratar a exceção:

try {

pessoaAtual.setIdade(Integer.parseInt(aux2));

} catch (MinhaConsistênciaException exceção) {

System.out.println(exceção.getRazão()+

"\n"+exceção.getSolução());

}

5.6 Resumo

• Classe Throwable com subclasses Error e Exception

• A exceção é tratada (try / catch) ou é lançada/propagada para tratador em outro nível (throws)

• Pode se personalizar as exceções, criando as próprias.

� Leia mais no Capítulo “10. Exceções – controlando os erros” da apostila Caelum (disponível no AVA).



6 HERANÇA Uma das maiores vantagens da POO reside na possibilidade de haver herança entre classes. Herança consiste na capacidade de construir novas classes a partir de outras existentes. Nesse processo, os dados e métodos de uma classe existente, chamada de classe base ou superclasse, são herdados pela nova classe, chamada classe derivada ou subclasse. Este é um recurso muito útil, pois permite aproveitar um esforço de elaboração anterior – reutilização - aumentando significativamente a produtividade da programação e diminuindo o tamanho do código objeto. Suponhamos por exemplo, que tenhamos declarado previamente a seguinte classe:

class Polígono { int cx, cy; // Coordenadas do centro do polígono }

Esta classe define em linhas gerais o que é um polígono, guardando uma única característica comum a qualquer polígono, isto é, as coordenadas de seu centro. Agora, suponhamos que desejamos criar uma classe para guardar informações sobre um quadrado. Neste caso, não precisamos criar uma classe que dê as coordenadas do centro do quadrado assim como as suas dimensões. Basta fazer simplesmente:

class Quadrado extends Polígono { int lado; // Comprimento de um lado do quadrado }

A classe Quadrado declarada desse modo se diz uma classe derivada da classe Poligono, da qual herda os dados (e os métodos) nela contidos. A declaração anterior é equivalente a:

class Quadrado { int cx, cy; // Coordenadas do centro do polígono int lado; // Comprimento de um lado do quadrado }

porém esta não se beneficia das vantagens da herança. Desejando fazer uma classe para representar um retângulo, bastaria fazer então

class Retângulo extends Poligono { int base, alt; // Base e altura do retângulo }

6.1.1 Encapsulamento e Polimorfismo Outro benefício importante da POO reside no encapsulamento. Este consiste na habilidade de efetivamente isolar informações do restante do programa. Outro benefício desta prática é garantir que a informação não será corrompida acidentalmente pelo resto do programa. Criamos, assim, programas mais robustos e confiáveis. Para garantir o encapsulamento, devemos declarar os atributos sempre como privados (private) ou protegidos (protected). Uma característica importante das classes reside no fato de que as subclasses de uma dada classe são consideradas do mesmo tipo de seu pai. Isto é chamado polimorfismo. Este permite a realização de uma mesma operação sobre diferentes tipos de classes, desde que mantenham algo em comum.



Por exemplo, considere a classe Polígono e suas derivadas Retângulo e Triângulo declaradas abaixo. Apesar de retângulos e triângulos serem diferentes, eles ainda são considerados polígonos. Assim, qualquer coisa que fosse permitido fazer com um objeto da classe Polígono, seria também permitida para objetos das classes Retângulo e Triângulo. O seguinte exemplo ilustra o polimorfismo entre essas classes permitindo que se desenhe um polígono, independentemente do prévio conhecimento de que se trata de um retângulo ou de um triângulo. class Vértice { public double x, y; public Vértice(double x, double y) { this.x = x; this.y = y; } } abstract class Polígono { int numVértices; // Quantidade de vértices do polígono Vértice v[]; // Coordenadas de seus vértices abstract void desenhar(Gráfico onde); } class Gráfico { // Saída gráfica hipotética para desenhos, com os métodos de desenho necessários... } class Retângulo extends Polígono { // construtor Retângulo(Vértice param[]) { this.v = new Vértice[4]; numVértices = 4; for(int i = 0; i < 4; i++) this.v[i] = param[i]; } void desenhar(Gráfico onde) { onde.retangulo(this.v); onde.pintar(this.v[0], this.v[2]); } } class Triângulo extends Polígono { Triângulo(Vértice param[]) { this.v = new Vértice[3]; numVértices=3; for(int i = 0; i < 3; i++) this.v[i] = param[i]; } void desenhar(Gráfico onde) { onde.triangulo(this.v); onde.pintar(this.v[0]); } } public class Polimorfismo { // Coordenadas dos vértices de um retângulo - valores pré-determinados para simplificar a instanciação static Vértice v[] = { new Vértice(0.0,0.0), new Vértice(2.0,0.0), new Vértice(2.0,1.0), new Vértice(0.0,1.0) }; // Coordenadas dos vértices de um triângulo - valores pré-determinados para simplificar a instanciação static Vértice w[] = {



new Vértice(-1.0,0.0), new Vértice(1.0,0.0), new Vértice(0.0,1.0) }; // Exemplo public static void main(String args[]) { Polígono r, t; Gráfico g = new Gráfico(); r = new Retângulo(v); // Isto é válido, pois Retângulo é um Polígono t = new Triângulo(w); // Isto é válido, pois Triângulo é um Polígono // Desenha o retângulo na área gráfica g - polimorfismo r.desenhar(g); // Desenha o triângulo na área gráfica g - polimorfismo t.desenhar(g); } }

6.1.2 Sobrescrita Não é permitido declarar em uma mesma classe dois métodos com o mesmo nome e mesma lista de argumentos. De fato, isto parece não fazer nenhum sentido, pois os métodos são unicamente identificados pelo nome e pela lista de argumentos que os acompanha. Entretanto, uma das finalidades de permitir a derivação de classes é atribuir a elas novas funcionalidades. Isto é possível acrescentando-se novos métodos às subclasses. Mas também é possível sobrescrever ou sobrepor qualquer dos métodos existentes na superclasse, declarando o novo método na subclasse exatamente com o mesmo nome e lista de argumentos, como consta na superclasse. Por exemplo, considere a classe Computador abaixo:

class Computador { private boolean ligado = true; public void Desligar() { ligado = false; } }

Esta classe permite que o computador seja desligado, através da chamada do método Desligar. Porém, isto pode não ser muito seguro, pois poderíamos desligar o computador mesmo quando ele estiver executando algum programa. Nesse caso, podemos evitar uma catástrofe derivando a classe computador do seguinte modo:

class ComputadorSeguro extends Computador { private boolean executando = true; public void Desligar() { if (executando) System.out.println("Há programas rodando. Não desligue!"); else ligado = false; } }

Agora, um objeto da classe ComputadorSeguro somente será desligado quando não tiver programas rodando. A sobrescrita somente acontece quando o novo método é declarado com exatamente o mesmo nome e lista de argumentos que o método existente na superclasse. Além disso, a sobrescrita não permite que o novo método tenha mais proteções do que o método original. No exemplo acima, como o método Desligar foi declarado como public na superclasse, este não pode ser declarado private na subclasse.



6.1.3 A Especificação super A palavra super provê acesso a partes de uma superclasse a partir de uma subclasse. Isto é muito útil quando estamos sobrepondo um método. Poderíamos reescrever o método Desligar da classe ComputadorSeguro do seguinte modo:

class ComputadorSeguro extends Computador { private boolean executando = true; public void Desligar() { if ( executando ) System.out.println("Há programas rodando. Não desligue!"); else super.Desligar(); } }

Note a chamada super.Desligar(). Esta corresponde a chamada do método Desligar declarado na superclasse Computador, o qual vai efetivamente ajustar o campo ligado para o valor false. Imaginando que o método Desligar fosse muito mais complicado, não precisaríamos recodificá-lo completamente na subclasse para acrescentar a funcionalidade que permite o desligamento apenas quando o computador estiver desocupado. No caso de o método que desejamos chamar ser um construtor, a chamada usando a palavra super é bem particular. Examinemos o seguinte exemplo de uma classe chamada VérticeNumerado que estende a classe Vértice, acrescentando às coordenadas do vértice um rótulo numérico que o identifica visualmente:

class VérticeNumerado extends Vértice { int numero; VérticeNumerado(int numero, int x, int y) { this.numero = numero; super(x, y); } }

Note que a chamada super(x, y) se traduz na chamada do construtor Vértice(x,y) da superclasse. Com isto, evitamos de ter que recodificar no novo construtor as tarefas contidas no construtor da superclasse: basta chamá-lo. Vale observar que esse tipo de chamada também só é permitida de dentro de um construtor.

6.2 Aprofundamento em Herança

Herança é sempre utilizada em Java, mesmo que não explicitamente. Qualquer classe que se cria está herdando da classe raiz, chamada Object. Esta classe contém as funcionalidades básicas e comuns a todos os objetos, tais como:

• o método equals() para comparar conteúdos de objetos. Se o objeto de uma nova classe contém referências a outros objetos, este método pode ser redefinido para realizar a comparação recursivamente para os componentes;

• o método toString() para converter o estado do objeto para uma representação String, que possa ser textualmente apresentada. Todas as novas classes devem redefinir este método se a conversão automática para string for necessária -- por exemplo, em uma concatenação associada a uma invocação de println().



• o método finalize(), invocado pelo garbage collector antes de liberar a memória usada por um objeto não mais referenciado. Se o objeto fizer uso de outros recursos que não a memória alocada por Java, este método deve ser redefinido para liberar tais recursos.

6.2.1 Sintaxe de especificação de herança Considere uma aplicação de automação residencial, com alguns aparelhos eletrônicos sendo controlados por um software de controle. Uma constatação é que todos os aparelhos têm pelo menos um comportamento comum, que é a opção de ligar ou desligar o aparelho. Assim, uma possível especificação desta aplicação poderia ser:

Em Java, a palavra chave para especificar herança entre classes é extends. A situação acima poderia ser representada pela seguinte estrutura Java: class EletrApp { private boolean powerOn; public void powerSwitch() { powerOn = ! powerOn; } public boolean getPower() { return powerOn; } } public class TvSet extends EletrApp { // constantes para a classe private static final int MINCHANNEL = 2; private static final int MAXCHANNEL = 181; private static final int MAXVOLUME = 100; // atributos da classe private int channel = MINCHANNEL; private int volume; private boolean mute; // definição de métodos de TvSet public void channelPrevious() { if (getPower()) { channel--; if (channel < MINCHANNEL)



channel = MAXCHANNEL; } } public void channelNext() { if (getPower()) { channel++; if (channel > MAXCHANNEL) channel = MINCHANNEL; } } public void volumeDown() { if (getPower() && volume > 0) volume--; } public void volumeUp() { if (getPower() && volume < MAXVOLUME) volume++; } public void muteSwitch() { if (getPower()) mute = !mute; } public int getChannel() { return(channel); } public int getVolume() { return(volume); } public boolean getMute() { return(mute); } } A aplicação poderá conter invocações como: TvSet aTv = new TvSet(); ... aTv.powerSwitch();

6.2.2 Construção de objetos derivados Objetos derivados invocam implicitamente, a partir de seu construtor, o método construtor de sua superclasse antes de executar o corpo de seu construtor. Assim, no exemplo acima, ao se construir um objeto da classe TvSet (usando o construtor default, já que nenhum outro foi definido), o método construtor da classe EletrApp será inicialmente invocado. Este, por sua vez, invocará o construtor de sua superclasse, Object. Como Object não tem uma superclasse, seu construtor é executado; então executa-se o restante do construtor de EletrApp e finalmente o restante do construtor de TvSet. Construtores da superclasse podem ser diretamente invocados usando o método super(). Implicitamente, é isto que o compilador faz para cada construtor. Entretanto, a invocação direta pode ser interessante quando se deseja invocar algum construtor que não o default. O prefixo super. pode também ser utilizado para referenciar métodos da superclasse que tenham sido redefinidos pela classe derivada.



6.2.3 final A palavra chave final pode ser utilizada como uma indicação de algo que não deve ser modificado ao longo do restante da hierarquia de descendentes de uma classe. Pode ser associada a atributos, a métodos e a classes. Um atributo final pode indicar um valor constante, que não deve ser alterado pela aplicação. Apenas valores de tipos primitivos podem ser utilizados para definir constantes. O valor do atributo deve ser definido no momento da declaração, pois não é permitida nenhuma atribuição em outro momento. A utilização de final para uma referência a objetos é permitida. Como no caso de constantes, a definição do valor (ou seja, a criação do objeto) também deve ser especificada no momento da declaração. No entanto, é preciso ressaltar que o conteúdo do objeto pode ser modificado -- apenas a referência é fixa. Um método que é definido como final em uma classe não pode ser redefinido (sobrescrito ou sobreposto) em classes derivadas. Por exemplo, todos os métodos da classe java.util.Vector são definidos como final. Assim, a tentativa de redefinir algum método em uma classe derivada de Vector, como em public class MyVector extends java.util.Vector { //... void addElement(Object obj) { // minha implementacao de addElement... } } causaria um erro: C:\> javac MyVector.java MyVector.java:3: The method void addElement(java.lang.Object) declared in class MyVector cannot override the method of the same signature declared in class java.util.Vector. The access modifier is made more restrictive. void addElement(Object obj) { ^ 1 error Uma classe definida como final não pode ser estendida. Assim, a compilação do arquivo Reeleicao.java final class Mandato { } public class Reeleicao extends Mandato { } ocasionaria um erro de compilação: C:\> javac Reeleicao.java Reeleicao.java:4: Can't subclass final classes: class Mandato public class Reeleicao extends Mandato { ^ 1 error



6.2.4 Várias formas de relacionamentos de herança

1. Extensão: subclasse estende a superclasse, acrescentando novos membros (atributos e/ou métodos). A superclasse permanece inalterada, motivo pelo qual este tipo de relacionamento é normalmente referenciado como herança estrita.

2. Especificação: a superclasse especifica o que uma subclasse deve oferecer, mas não implementa nenhuma funcionalidade. Diz-se que apenas a interface (conjunto de especificação dos métodos públicos) da superclasse é herdada pela subclasse.

3. Combinação de extensão e especificação: a subclasse herda a interface e uma implementação padrão de (pelo menos alguns de) métodos da superclasse. A subclasse pode então redefinir métodos para especializar o comportamento em relação ao que é oferecido pela superclasse, ou ter que oferecer alguma implementação para métodos que a superclasse tenha declarado mas não implementado. Normalmente, este tipo de relacionamento é denominado herança polimórfica.

A última forma é, sem dúvida, a que mais ocorre na programação orientada a objetos.

6.2.5 Usando heranças Como decidir qual o tipo de relacionamento -- composição, herança estrita, herança polimórfica -- que existe entre as classes de sua aplicação? Em geral, o procedimento requer iterações entre especializações (top-down) e generalizações (bottom-up). Especialização: quando uma classe é-um-tipo-de (is-a-kind-of) uma outra classe. Se a nova classe puder ser utilizada em qualquer contexto onde a classe original podia ser utilizada, então diz-se que a nova classe é um subtipo da superclasse. Se esta substituição é possível, a subclasse obedece ao Princípio de Substituição de Liskov (por Barbara Liskov). Uma das restrições em subtipos é que o significado dos métodos não deve ser alterado. Na subtipagem estrita, métodos não podem ser redefinidos, apenas acrescentados. Generalização: nesse processo, classes com características comuns são reorganizadas como subclasses de uma classe que agrega apenas a parte comum entre as classes originais. É o "outro lado da moeda" da especialização. Especificação: usada quando, no projeto, você sabe o que uma classe deve fazer, embora não saiba exatamente como fazê-lo. Neste caso, é possível especificar métodos sem implementação, os quais deverão ser efetivamente implementados pelas subclasses. Na especificação pura, nenhum método é implementado; apenas a especificação da interface é definida. Contração: seria uma outra forma de herança onde a subclasse elimina métodos da superclasse com o objetivo de criar uma "classe mais simples". A eliminação pode ocorrer pela redefinição de métodos com corpo vazio. O problema com este mecanismo é que ele viola o princípio da substituição, pois a subclasse já não pode mais ser utilizada em todos os pontos onde a superclasse poderia ser utilizada. Se a contração parece ser uma solução adequada em uma hierarquia de classes, provavelmente a hierarquia deve ser reanalisada para detecção de inconsistências (problema pássaros-pinguins). De modo geral, o mecanismo de contração deve ser evitado. Como saber qual o mecanismo correto para o meu caso? Prática, prática, prática, ...



6.2.6 Mecanismos de herança em Java

• Extensão simples: palavra-chave extends; para herança estrita, marcar todos os métodos da superclasse como final.

• Especificação: em Java, uma especificação é implementada como uma interface; subclasses da especificação usam a palavra-chave implements para indicar este tipo de herança.

• Herança polimórfica: como a extensão simples, usa a palavra-chave extends. Usando na superclasse as palavras-chave final e abstract, é possível indicar que partes da superclasse não podem ser modificadas ou devem ser modificadas.

6.3 Polimorfismo

Mecanismo para expressar comportamentos diferenciados para objetos derivados de uma mesma superclasse em tempo de execução. Termos correspondentes: dynamic binding , late binding Princípio:

1. superclasse expressa métodos que subclasses devem suportar 2. subclasses podem (ou tem que) definir métodos que podem ser diferenciados. No entanto,

recomenda-se que métodos de mesmo nome tenham comportamentos consistentes; 3. na invocação do método, pode-se utilizar no programa referências à superclasse; o sistema

verifica a qual objeto a invocação refere-se e aplica o método mais adequado.

6.3.1 Exemplo No exemplo a seguir, a superclasse (Raiz) e as duas classes derivadas (Filho1 e Filho2) tem um método show(). A aplicação (método main da classe Exemplo1) invoca o método relativo ao objeto da classe Raiz, sem saber durante a compilação se o objeto será da classe Raiz, Filho1 ou Filho2. class Raiz { public void show() { System.out.println("Raiz"); } } class Filho1 extends Raiz { public void show() { System.out.println("Filho1"); } } class Filho2 extends Raiz { public void show() { System.out.println("Filho2"); } } public class Exemplo1 { // Metodo recebe um argumento "1" ou "2" // para indicar que tipo de filho deve ser // associado ao objeto raiz. Sem argumentos,



// um objeto raiz (nao filho) e' criado. static public void main(String[] args) { Raiz r; // Algum objeto e' criado if (args.length > 0) if (args[0].charAt(0) == '1') r = new Filho1(); else { if (args[0].charAt(0) == '2') r = new Filho2(); else r = new Raiz(); } else r = new Raiz(); // Invocacao do metodo r.show(); } } Se a referência a objeto r vai estar referenciando um objeto da classe Raiz, Filho1 ou Filho2 só será definido no momento de execução. Mesmo assim, o sistema consegue verificar a que classe a referência está associada e invocar o método que aplica: C:\> javac Exemplo1.java C:\> java Exemplo1 Raiz C:\> java Exemplo1 1 Filho1 C:\> java Exemplo1 2 Filho2 C:\> java Exemplo1 3 Raiz Observe neste código que referências a objetos das classes derivadas podem ser atribuídas diretamente a referências à superclasse, sem necessidade de cast. Este mecanismo é algumas vezes referenciado como upcasting. Referências a uma superclasse podem ser atribuídas a referências a objetos de classes derivadas desde que o objeto seja de fato da classe indicada. Por exemplo, supondo que o programa acima fosse modificado para incluir a seguinte atribuição ao final: ... r.show(); Filho1 f = (Filho1) r; O cast é aqui necessário pois não se caracteriza um upcast (na verdade, ocorre um “downcast"). Se a aplicação for executada com o argumento 1, tudo está bem: C:\> java Exemplo1a 1 Filho1 No entanto, com o argumento 2, o interpretador indica uma condição de exceção: C:\> java Exemplo1a 2 Filho2 Exception in thread "main" java.lang.ClassCastException: Filho2



at Exemplo1a.main(Compiled Code)

6.3.2 Classes e métodos abstratos No exemplo acima, a superclasse tinha um comportamento válido associado ao método show(). No entanto, nem sempre este é o caso. Em grande parte das situações, uma superclasse especifica apenas uma interface comum que todas suas classes derivadas deverão implementar, mas não como a implementação deve ocorrer. Um exemplo clássico do uso de polimorfismo envolve classes de objetos geométricos. Uma superclasse Shape indica a funcionalidade que deve ser suportada por formas geométricas em geral; por exemplo, desenhar (draw) ou remover (erase) a forma da tela. No entanto, a implementação destes métodos só faz sentido quando se conhece a forma que se deseja desenhar ou remover, como um retângulo ou círculo. Seguindo a estrutura do Exemplo1 acima, seria possível criar a superclasse Shape com métodos com corpo vazio (ou com mensagens de erro) e especificar o corpo do método apenas nas classes derivadas: class Shape { public void draw() { System.out.println("???"); } public void erase() { System.out.println("???"); } } class Square extends Shape { public void draw() { System.out.println("Desenhando quadrado"); } public void erase() { System.out.println("Apagando quadrado"); } } class Circle extends Shape { public void draw() { System.out.println("Desenhando circulo"); } public void erase() { System.out.println("Apagando circulo"); } } public class Exemplo2 { // Metodo recebe um argumento "Q" ou "C" // para indicar que tipo de filho deve ser // associado ao objeto raiz. Sem argumentos, // um objeto Shape e' criado. static public void main(String[] args) { Shape r; // Criacao do objeto if (args.length > 0) if (args[0].toUpperCase().charAt(0) == 'Q') r = new Square(); else {



if (args[0].toUpperCase().charAt(0) == 'C') r = new Circle(); else r = new Shape(); } else r = new Shape(); // Desenho e remocao da forma r.draw(); r.erase(); } } A execução desta classe apresentaria como resultados: C:\> javac Exemplo2.java C:\> java Exemplo2 ??? ??? C:\> java Exemplo2 q Desenhando quadrado Apagando quadrado C:\> java Exemplo2 c Desenhando circulo Apagando circulo C:\> java Exemplo2 x ??? ??? Um dos problemas associados a este exemplo é que não se sabe como lidar com "formas genéricas" -- na verdade, isto nem faz sentido para a aplicação. Neste tipo de situação, seria mais adequado sinalizar que os métodos da classe Shape não têm implementação -- mais ainda, que nem faz sentido criar objetos desta classe. O mecanismo que Java e outras linguagens orientadas a objetos oferecem para suportar este conceito é a definição de métodos abstratos. Um método abstrato define apenas uma interface, uma assinatura, sem especificação do corpo. A sintaxe de definição de um método abstrato é: public abstract void draw(); public abstract void erase(); Uma classe que contenha métodos abstratos deve ser uma classe abstrata. Assim, a tentativa de definir uma classe não abstrata contendo métodos abstratos, como em // Exemplo3.java class Shape { public abstract void draw(); public abstract void erase(); } // ... acarretaria em um erro de compilação: C:\> javac Exemplo3.java Exemplo3.java:1: class Shape must be declared abstract. It does not define void draw() from class Shape.



class Shape { ^ Exemplo3.java:1: class Shape must be declared abstract. It does not define void erase() from class Shape. class Shape { ^ Ainda mais, a tentativa de se instanciar objetos de uma classe abstrata também gera erros de compilação: Exemplo3.java:40: class Shape is an abstract class. It can't be instantiated. r = new Shape(); ^ Exemplo3.java:43: class Shape is an abstract class. It can't be instantiated. r = new Shape(); ^ Assim, a definição de Shape como classe abstrata requer o uso da palavra chave abstract, e objetos desta classe não podem ser criados: abstract class Shape { public abstract void draw(); public abstract void erase(); } class Square extends Shape { public void draw() { System.out.println("Desenhando quadrado"); } public void erase() { System.out.println("Apagando quadrado"); } } class Circle extends Shape { public void draw() { System.out.println("Desenhando circulo"); } public void erase() { System.out.println("Apagando circulo"); } } public class Exemplo3 { // Metodo recebe um argumento "Q" ou "C" // para indicar que tipo de filho deve ser // associado ao objeto raiz. Sem argumentos, // uma mensagem indica forma de uso. static public void main(String[] args) { Shape r = null; // Criacao do objeto if (args.length > 0) if (args[0].toUpperCase().charAt(0) == 'Q') r = new Square(); else { if (args[0].toUpperCase().charAt(0) == 'C') r = new Circle(); else



System.out.println("Uso: Exemplo3 Q ou Exemplo3 C"); } else System.out.println("Uso: Exemplo3 Q ou Exemplo3 C"); // Desenho e remocao da forma if (r != null) { r.draw(); r.erase(); } } } Resultado: C:\> javac Exemplo3.java C:\> java Exemplo3 Uso: Exemplo3 Q ou Exemplo3 C C:\> java Exemplo3 q Desenhando quadrado Apagando quadrado C:\> java Exemplo3 c Desenhando circulo Apagando circulo C:\> java Exemplo3 x Uso: Exemplo3 Q ou Exemplo3 C C:\> Toda a classe que seja derivada de uma classe abstrata deve implementar (redefinir) todos os métodos abstratos ou ser também declarada como abstrata. Por exemplo, se a classe Square implementasse apenas o método draw() mas não o método erase(), class Square extends Shape { public void draw() { System.out.println("Desenhando quadrado"); } } a seguinte mensagem seria apresentada durante a compilação: C:\>Polimorf[39] javac Exemplo4.java Exemplo4.java:6: class Square must be declared abstract. It does not define void erase() from class Shape. class Square extends Shape { ^ Classes podem ser declaradas como abstratas mesmo sem ter nenhum método abstrato. Neste caso, indica-se que nenhum objeto pode ser criado para a classe.

6.4 Interface

Uma interface em Java é uma classe abstrata para a qual todos os métodos são implicitamente abstract e public, e todos os atributos são static e final. Em outros termos, uma interface Java implementa uma "classe abstrata pura".



A definição de uma interface Java equivale à definição de uma classe, apenas usando a palavra chave interface ao invés da palavra chave class: interface Eleccion { void vota(String candidato); int contagem(); String vencedor(); } Apesar de não estar explicíto, os dois métodos desta interface são public e abstract. Se desejado, as duas palavras chaves poderiam ser utilizadas na declaração dos métodos sem alteração na definição da interface. A diferença entre uma classe abstrata e uma interface Java é que a interface obrigatoriamente não tem um "corpo" associado, apenas forma. Enquanto uma classe abstrata é "estendida" (palavra chave extends) por classes derivadas, uma interface Java é "implementada" (palavra chave implements) por outras classes: class ConeSurDemocracia implements Eleccion { int votos = 0; public void vota(String qualquerUm) { ++votos; } public int contagem() { return votos > 2 ? votos-1 : 1; } public String vencedor() { return "El Senor Presidente"; } } A utilização de uma interface em um programa ocorre da mesma forma que para classes abstratas. Por exemplo, na aplicação a seguir, cria-se uma referência à interface, br, à qual é atribuída uma referência a um objeto que implementa a interface (upcasting): public class Exemplo5 { public static void main(String[] args) { Eleccion br = new ConeSurDemocracia(); int i = 0; // votacao while (i < args.length) br.vota(args[i++]); // and the winner is... System.out.println(br.vencedor() + " foi eleito com " + br.contagem() + " votos!"); } } Outra diferença essencial entre classes e interfaces Java é que uma classe pode implementar múltiplas interfaces, mas pode estender apenas uma superclasse. Neste caso, as interfaces implementadas são separadas por vírgulas: class Derivada extends SuperClasse implements Interface1, Interface2 { ...



} Neste exemplo, a classe Derivada deve implementar todos os métodos da Interface1 e todos os métodos da Interface2. Adicionalmente, se SuperClasse também tiver métodos abstratos, esses também deverão ser implementados por Derivada. Assim como ocorre com classes, interfaces Java também podem ser derivadas de outras interfaces. A diferença é que diversas interfaces podem ser estendidas: interface S1 { ... } interface S2 { ... } interface D extends S1, S2 { ... } Outro uso de interfaces Java é para a definição de constantes que devem ser compartilhadas por diversas classes. Neste caso, a recomendação é implementar interfaces sem métodos, pois as classes que implementarem tais interfaces não precisam redefinir nenhum método: interface Moedas { int PENNY = 1, NICKEL = 5, DIME = 10, QUARTER = 25, DOLAR = 100; } class CokeMachine implements Moedas { int price = 2*QUARTER; // ... }

� Leia mais nos Capítulos 7 a 9 da apostila Caelum (disponível no AVA).

universidade regional de blumenau centro de … · universidade regional de blumenau / centro de...

Documents