Você está na página 1de 198

PROGRAMAÇÃO ORIENTADA

A OBJETOS
CURSOS DE GRADUAÇÃO – EAD
Programação Orientada a Objetos – Prof. Ms. Marcelo Camacho de Souza

Meu nome é Marcelo Camacho de Souza. Sou mestre em Ciências da Computação pela
Universidade de São Paulo (USP) – (IME/São Paulo) e graduado em Ciências da Computação pela
Universidade Estadual Paulista (Unesp) campus Rio Claro/SP. Atualmente faço doutorado em
Ciências da Computação pela Universidade de São Paulo (USP) – (IME/São Paulo) e sou professor
do Instituto Federal de Educação, Ciência e Tecnologia de São Paulo (IFSP).

E-mail: camacho.marcelo@gmail.com
Marcelo Camacho de Souza

PROGRAMAÇÃO ORIENTADA
A OBJETOS

Batatais
Claretiano
2011
© Ação Educacional Claretiana, 2010 – Batatais (SP)
Versão: fev./2011

005.1 S716p

Souza, Marcelo Camacho de


Programação orientada a objetos / Marcelo Camacho de Souza – Batatais, SP :
Claretiano, 2011.
198 p.

ISBN: 978-85-8377-518-8

1. Classes. 2. Objetos. 3. Abstração. 4. Atributos. 5. Métodos. 6. Encapsulamento.


7. Herança. 8. Diagrama de Classes. I. Programação orientada a objetos.

CDD 005.1

Corpo Técnico Editorial do Material Didático Mediacional


Coordenador de Material Didático Mediacional: J. Alves

Preparação Revisão
Aletéia Patrícia de Figueiredo Felipe Aleixo
Aline de Fátima Guedes
Isadora de Castro Penholato
Camila Maria Nardi Matos CDD 658.151
Cátia Aparecida Ribeiro Maiara Andréa Alves
Dandara Louise Vieira Matavelli Rodrigo Ferreira Daverni
Elaine Aparecida de Lima Moraes Vanessa Vergani Machado
Elaine Cristina de Sousa Goulart
Josiane Marchiori Martins
Lidiane Maria Magalini Projeto gráfico, diagramação e capa
Luciana A. Mani Adami Eduardo de Oliveira Azevedo
Luciana dos Santos Sançana de Melo Joice Cristina Micai
Luis Henrique de Souza Lúcia Maria de Sousa Ferrão
Luiz Fernando Trentin
Luis Antônio Guimarães Toloi
Patrícia Alves Veronez Montera
Rosemeire Cristina Astolphi Buzzelli Raphael Fantacini de Oliveira
Simone Rodrigues de Oliveira Renato de Oliveira Violin
Bibliotecária Tamires Botta Murakami
Ana Carolina Guimarães – CRB7: 64/11 Wagner Segato dos Santos

Todos os direitos reservados. É proibida a reprodução, a transmissão total


ou parcial por qualquer forma e/ou qualquer meio (eletrônico ou mecânico,
incluindo fotocópia, gravação e distribuição na web), ou o arquivamento em
qualquer sistema de banco de dados sem a permissão por escrito do autor e
da Ação Educacional Claretiana.

Centro Universitário Claretiano


Rua Dom Bosco, 466 - Bairro: Castelo – Batatais SP – CEP 14.300-000
cead@claretiano.edu.br
Fone: (16) 3660-1777 – Fax: (16) 3660-1780 – 0800 941 0006
www.claretiano.edu.br
SUMÁRIO

CADERNO DE REFERÊNCIA DE CONTEÚDO


1 INTRODUÇÃO ............................................................................................................................................... 7
2 ORIENTAÇÕES PARA ESTUDO......................................................................................................................8

UNIDADE 1 - ORIENTAÇÃO A OBJETOS


1 OBJETIVOS.................................................................................................................................................... 25
2 CONTEÚDOS................................................................................................................................................. 25
3 ORIENTAÇÕES PARA O ESTUDO DA UNIDADE ..........................................................................................25
4 INTRODUÇÃO À UNIDADE...........................................................................................................................26
5 CONCEITOS BÁSICOS DA ORIENTAÇÃO A OBJETOS..................................................................................26
6 EXEMPLO PRÁTICO....................................................................................................................................... 35
7 QUESTÕES AUTOAVALIATIVAS....................................................................................................................40
8 CONSIDERAÇÕES.......................................................................................................................................... 42
9 E-REFERÊNCIAS............................................................................................................................................ 42
10 REFERÊNCIAS BIBLIOGRÁFICAS ................................................................................................................42

UNIDADE 2 - AMBIENTE DE PROGRAMAÇÃO JAVA


1 OBJETIVOS.................................................................................................................................................... 43
2 CONTEÚDOS................................................................................................................................................. 43
3 ORIENTAÇÃO PARA O ESTUDO DA UNIDADE ............................................................................................43
4 INTRODUÇÃO À UNIDADE...........................................................................................................................44
5 CONCEITOS................................................................................................................................................... 44
6 AMBIENTE DE DESENVOLVIMENTO JAVA..................................................................................................45
7 EXECUTANDO PELA PRIMEIRA VEZ A FERRAMENTA BLUEJ......................................................................47
8 CRIANDO O PRIMEIRO PROGRAMA EM JAVA NO BLUEJ..........................................................................50
9 EXEMPLO PRÁTICO....................................................................................................................................... 61
10 Q UESTÕES AUTOAVALIATIVAS....................................................................................................................70
11 C ONSIDERAÇÕES.......................................................................................................................................... 73
12 E-REFERÊNCIAS............................................................................................................................................ 73
13 REFERÊNCIAS BIBLIOGRÁFICAS ................................................................................................................74

UNIDADE 3 - LINGUAGEM JAVA


1 OBJETIVOS.................................................................................................................................................... 75
2 CONTEÚDOS................................................................................................................................................. 75
3 ORIENTAÇÃO PARA O ESTUDO DA UNIDADE ............................................................................................75
4 INTRODUÇÃO À UNIDADE ..........................................................................................................................76
5 CONHECENDO MELHOR A LINGUAGEM JAVA...........................................................................................76
6 SINTAXE DA LINGUAGEM JAVA...................................................................................................................79
7 CRIAÇÃO DE CLASSES E OBJETOS...............................................................................................................88
8 EXEMPLO PRÁTICO....................................................................................................................................... 94
9 QUESTÕES AUTOAVALIATIVAS....................................................................................................................97
10 C ONSIDERAÇÕES.......................................................................................................................................... 102
11 E-REFERÊNCIAS............................................................................................................................................ 103
12 R EFERÊNCIAS BIBLIOGRÁFICAS .................................................................................................................103
UNIDADE 4 - RELACIONAMENTO ENTRE OBJETOS
1 OBJETIVOS.................................................................................................................................................... 105
2 CONTEÚDOS................................................................................................................................................. 105
3 ORIENTAÇÕES PARA O ESTUDO DA UNIDADE ..........................................................................................105
4 INTRODUÇÃO À UNIDADE...........................................................................................................................106
5 CONCEITOS RELACIONADOS À LINGUAGEM JAVA....................................................................................106
6 ORGANIZAÇÃO DAS CLASSES DE UM SISTEMA.........................................................................................108
7 INICIANDO A CODIFICAÇÃO DA CLASSE PESSOA NO PACOTE BIBLIOTECA............................................110
8 IMPLEMENTAÇÃO DA RELAÇÃO DE ASSOCIAÇÃO ....................................................................................131
9 EXEMPLO PRÁTICO....................................................................................................................................... 149
10 Q UESTÕES AUTOAVALIATIVAS....................................................................................................................181
11 C ONSIDERAÇÕES.......................................................................................................................................... 185
12 E-REFERÊNCIAS............................................................................................................................................ 185
13 R EFERÊNCIAS BIBLIOGRÁFICAS .................................................................................................................185

APÊNDICE 1........................................................................................................................................ 186


APÊNDICE 2........................................................................................................................................ 194
Caderno de
Referência de
Conteúdo
CRC

Conteúdo–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
Classes. Objetos. Abstração. Instanciação de objetos. Construtores. Atributos e métodos de classe e de instância.
Pacotes. Encapsulamento e modificadores de acesso. Herança. Polimorfismo. Classes abstratas. Exceções. Docu-
mentação. Linguagem de programação orientada a objetos: sintaxe, variáveis, tipos de dados, operadores e estrutu-
ras de controle. Diagrama de representação de classes.
–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––

1. INTRODUÇÃO
Seja bem-vindo! Programação Orientada a Objetos é uma das obras que compõem os
cursos de Graduação do Centro Universitário Claretiano.
Nesta parte, você encontrará o conteúdo das quatro unidades em que se divide a presen-
te obra.
Na obra Programação Orientada a Objetos, você terá a oportunidade de estudar e com-
preender os conceitos básicos da orientação a objetos e da linguagem Java, bem como utilizar a
ferramenta BlueJ. Além disso, conhecerá a sintaxe da linguagem Java, criando classes e objetos
por meio dessa linguagem.
Na Unidade 1 serão apresentados os conceitos básicos de Orientação a Objetos. Na Unida-
de 2 você será capaz de criar as primeiras classes usando a linguagem Java e a ferramenta BlueJ.
Na Unidade 3 aprofundará ainda mais seus conhecimentos na linguagem Java e na orientação a
objetos. Na última unidade, que é a Unidade 4, você já terá condições de implementar as dife-
rentes formas de relação existentes entre classes.
É fundamental, também, que você saiba que os objetivos finais desse estudo são: desen-
volver a capacidade de programar usando o paradigma de Orientação a Objetos, e implementar
sistemas usando a linguagem de programação Java.
8 © Programação Orientada a Objetos

Para tanto, é necessário que assuma a responsabilidade do seu aprendizado, na adapta-


ção, no aprimoramento e na capacitação profissional e pessoal.
Este material didático não deverá ser a sua única fonte de informação a ser consultada.
Além de outros materiais do curso, sugerimos que você consulte revistas, livros e outras fontes
especializadas para entender melhor os conceitos estudados. É necessário que você adquira o
hábito da pesquisa.
Como você pode perceber, o desafio é grande. Você está convidado a fazer parte conosco
deste novo caminho de construção do saber. Mas não se preocupe, pois nossos tutores estarão
sempre ao seu lado, de forma que você poderá fazer perguntas e resolver suas dúvidas na Sala
de Aula Virtual (SAV) ou pelo 0800.
Esteja consciente de que seu bom desempenho dependerá de você mesmo. Na educação
a distância, é fundamental que você participe ativamente dos debates no Fórum e na Lista, dis-
cutindo os conteúdos com seus colegas e tutores.
É nesse processo de colaboração que o conhecimento é construído.
Que você tenha um bom e proveitoso estudo!

2. ORIENTAÇÕES PARA ESTUDO

Abordagem Geral
Neste tópico, apresenta-se uma visão geral do que será estudado nesta obra. Aqui, você en-
trará em contato com os assuntos principais deste conteúdo de forma breve e geral e terá a opor-
tunidade de aprofundar essas questões no estudo de cada unidade. No entanto, essa Abordagem
Geral visa fornecer-lhe o conhecimento básico necessário a partir do qual você possa construir
um referencial teórico com base sólida – científica e cultural – para que, no futuro exercício de sua
profissão, você a exerça com competência cognitiva, ética e responsabilidade social.

A importância da Orientação a Objetos (OO)


Talvez esta não seja a primeira vez que você se depare com a expressão "Orientação a
Objetos”. Ela está presente em várias áreas da computação, desde a modelagem de sistemas
(exemplo: UML – Unified Modeling Language –, em português, Linguagem de Modelagem Uni-
ficada), linguagens de programação (exemplos: SmallTalk, C++, Java, Object Pascal e Javascript),
passando inclusive por bancos de dados.
A Orientação a Objetos constitui um importante paradigma e possui grande aplicação em
várias áreas computacionais. Sua importância está relacionada, principalmente, à forma pela
qual as informações sobre determinados assuntos são representadas no modelo computacio-
nal. Isto é, quando analisamos um problema real que será solucionado por meio da informática,
buscamos identificar (abstrair) informações desse mundo real que serão relevantes à solução
do problema.
Com relação à Orientação a Objetos, a análise das informações e a forma pela qual elas
são representadas no mundo computacional se baseiam no conceito de Objeto. Um objeto
pode ser algo concreto ou palpável como, por exemplo, uma pessoa, automóvel, livro etc., ou
algo abstrato que não se pode tocar como, por exemplo, uma ação ou relação (comprar, vender,
emprestar, alugar etc.).

Centro Universitário Claretiano


© Caderno de Referência de Conteúdo 9

Um objeto é representado por:


• características;
• comportamentos.
As características relacionam-se ao conjunto de informações que descrevem e qualificam
como realmente é o objeto. Os comportamentos relacionam-se às ações que o objeto pode
executar.
Para facilitar a compreensão desses conceitos, vamos dar um exemplo prático. Digamos
que você deseja desenvolver um sistema para uma escola e utilizará a Orientação a Objetos para
analisar as informações de alunos e disciplinas.
A respeito do objeto aluno, identificamos as seguintes características:
• Nome.
• Ra – registro do aluno.
• Data de Nascimento.
• Telefone.
• E-mail.
Com relação aos comportamentos do Objeto Aluno, identificamos:
• Faz Matrícula.
• Cancela Matrícula.
No que diz respeito ao Objeto Disciplina, identificamos estas características:
a) Nome.
b) Sigla.
c) Descrição.
d) Carga Horária.
Com relação aos comportamentos do Objeto Disciplina, identificamos:
• Aceita Matrícula.
• Cancela Disciplina.
Note que outras características e comportamentos poderiam ser citados para cada um
dos objetos; porém, devemos, nessa análise, identificar apenas aqueles que são relevantes ao
nosso sistema.
Isso nos permite constatar que nem todos os sistemas sobre um determinado assunto
possuem efetivamente as mesmas informações armazenadas. Isso acontece porque o analista
ou programador abstrai apenas as informações que julga serem mais importantes para a imple-
mentação de seu sistema.
Voltando ao sistema da escola, vamos agora analisar o objeto aluno. Uma escola possui
vários alunos. Como exemplo, podemos citar os seguintes alunos da escola:

Aluno 1 Aluno 2
• Nome = José • Nome = Maria
• Ra = 11111 • Ra = 22222
• Data de Nascimento = 01/10/1980 • Data de Nascimento = 15/02/1981
• Telefone = 1111111 • Telefone = 222222
• E-mail = jose@email.com • E-mail = maria@email.com
10 © Programação Orientada a Objetos

Na Orientação a Objetos, os objetos semelhantes são reunidos em uma única representa-


ção chamada Classe. A Classe corresponde à estrutura que representa um modelo comum para
todo um conjunto de objetos semelhantes. Na classe, estão identificadas as características e os
comportamentos dos objetos em que ela está representada.
A relação classe versus objeto é um dos conceitos-base da Orientação a Objetos. Costuma-
se dizer que a classe é o molde, enquanto os objetos são exemplos que seguem as definições
e as estruturas do molde. Um objeto também é denominado de instância de uma classe. Uma
instância é uma ocorrência da classe em forma de objeto.
No exemplo do sistema da escola, nós identificamos a classe Aluno como um modelo para
todos os objetos Aluno da escola, incluindo os objetos Aluno José e Maria. Assim, a classe Aluno
é um modelo que reúne as características (Nome, Ra, Data de Nascimento, Telefone e E-mail) e
os comportamentos (Faz Matrícula e Cancela Matrícula) comuns a todos os objetos Aluno.

O diagrama de classes da UML


Uma classe pode ser representada graficamente usando a Linguagem de Modelagem Uni-
ficada (UML). A UML possui um conjunto rico de diagramas que permitem a representação
da modelagem de um sistema usando os conceitos da Orientação a Objetos. Dentre os vários
diagramas existentes, destaca-se o diagrama de classes que pertence à categoria dos diagramas
estruturais e oferece suporte à representação do conceito classe.
A Figura 1 a seguir exibe a representação genérica de uma classe usando o diagrama de
classes da UML. Nela são identificados o nome da classe, suas características e seus comporta-
mentos.

Nome da Classe

Características

Comportamentos

Figura 1 Classe – Diagrama de classes


da UML.

Na análise do sistema da escola, podemos representar a Classe Aluno usando a mesma


representação visual, porém adicionando o nome da classe, suas características e seus compor-
tamentos. Veja, na Figura 2 a seguir, a representação da classe Aluno usando a UML.

Centro Universitário Claretiano


© Caderno de Referência de Conteúdo 11

Aluno

Nome
ra
data_de_nascimento
telefone
email

fazMatricula
cancelaMatricula
Figura 2 Classe Aluno (UML).

Note que a nomenclatura usada nas características e comportamentos da classe Aluno


foi ligeiramente modificada. Como as informações descritas no diagrama de classes serão pos-
teriormente reproduzidas usando uma linguagem de programação orientada a objetos, é con-
venção retirarmos das palavras as acentuações, os espaços em branco e os símbolos especiais
(exemplos: % , . + - / | } [ * @ # ! ? ), uma vez que as linguagens de programação normalmente
não os aceitam.
Outra convenção também adotada é utilizar letra maiúscula no início do nome da classe e
letra minúscula no início do nome das características.
Como vimos, não se pode utilizar espaços em branco entre as palavras, assim você deve
substituí-los pelo símbolo _ (underline) ou emendar as palavras destacando com letra maiúscula
o início delas (exemplo: fazMatricula).
Uma vez que já aprendemos como se cria uma classe usando a representação visual do
diagrama de classes da UML, vamos agora representar a classe Disciplina.

Disciplina

nome
sigla
descrição
cargaHoraria

aceitaMatricula
cancelaDisciplina
Figura 3 Classe Disciplina (UML).

Até o momento nos preocupamos apenas com os conceitos da Orientação a Objetos e não
abordamos nada a respeito de sua programação. Afinal, como é feita a programação orientada
a objetos?
12 © Programação Orientada a Objetos

A linguagem em Java
A programação orientada a objetos é realizada utilizando-se uma linguagem de programa-
ção orientada a objetos. Conforme citamos anteriormente, existem várias linguagens orientadas
a objeto no mercado. São muitos os fatores que influenciam na escolha, tais como: eficiência,
confiabilidade, portabilidade, mão de obra profissional existente no mercado, custo (proprietá-
ria ou livre), suporte técnico, ferramentas etc.
É importante ressaltar que cada linguagem possui uma sintaxe diferente, o que conse-
quentemente ocasionará diferentes formas de se codificar uma mesma situação.
Utilizaremos neste material a linguagem de programação Java. Sua escolha baseia-se no
fato de a linguagem possuir muitas qualidades técnicas, o que a tornou bastante aceita e difun-
dida no mercado de trabalho. Além disso, a sintaxe da linguagem Java é similar à linguagem C, o
que facilita bastante o aprendizado, principalmente para quem já programou com C.
Diferentemente de outras linguagens mais antigas (exemplos: Basic, Pascal e C), que foram
posteriormente adaptadas à Orientação a Objetos, Java foi definida desde a sua origem como
orientada a objetos.
Uma das características que talvez mais tenha contribuído para a difusão da linguagem Java
é a sua portabilidade. Java não depende do sistema operacional e muito menos do hardware
do computador para sua execução. Java requer apenas que o computador possua instalado um
software chamado Ambiente de Execução Java ou JRE (Java Runtime Environment). Assim, um
programa criado em Java é portável para vários computadores diferentes, não necessitando que
o seu código seja modificado e recompilado para se manter executável e compatível.
Esse ambiente de execução Java também recebe a denominação de Máquina Virtual Java
ou JVM (Java Virtual Machine). O termo virtual refere-se ao software Java que se comporta
como se fosse um computador, simulando certas características para executar os programas
escritos em Java. Veja, na Figura 4, uma representação gráfica que ilustra um mesmo programa
escrito em Java e sua portabilidade para outro computador com hardware e sistema operacio-
nal diferentes.

Programa Java Programa Java

JVM JVM

Sistema Operacional (Windows) Sistema Operacional (Linux)

Hardware (PC) Hardware (PC)


Figura 4 Portabilidade dos programas Java.

Os programas escritos em linguagem Java, quando compilados são convertidos em um


formato particular chamado bytecode. Os bytecodes são interpretados pela JVM e traduzidos
para o formato compatível com o sistema operacional e hardware do ambiente de execução.
Apesar do processo de compilação realizado para gerar os bytecodes, Java é uma linguagem
interpretada.
Outra característica de Java é o fato de ela ser case-sensitive, isto é, realiza diferenciação
entre letras minúsculas e maiúsculas em seus comandos. Por isso, recomendamos muita aten-
ção quando for codificar suas classes usando a linguagem Java. Uma simples letra minúscula
pode ocasionar um erro de compilação.

Centro Universitário Claretiano


© Caderno de Referência de Conteúdo 13

Nosso intuito no momento não é abordar todos os detalhes a respeito da linguagem Java.
Você terá mais informações a respeito da linguagem quando estiver estudando a Unidade 2.

A programação orientada a objetos em Java


Pelo fato de Java ser puramente orientada a objetos, toda e qualquer codificação é realiza-
da definindo-se uma classe. As características e os comportamentos presentes na representação
da classe na UML são convertidos, respectivamente, em atributos e métodos no momento da
programação. Os atributos correspondem a variáveis na linguagem de programação, enquanto
os métodos correspondem a funções (Figura 5).

Nome da Classe class Nome_da_Classe {

Atributos
Características
Métodos

Comportamentos }
Figura 5 Classes em Java.

Em Java, os tipos mais comuns de variáveis são:


a) int = números inteiros;
b) float = números reais;
c) String = sequência de caracteres ou texto;
d) boolean = valores lógicos (verdadeiro ou falso).
Vamos agora praticar um pouco realizando a codificação da classe Aluno, usando a lingua-
gem Java (Figura 6). Note que as características definidas na classe Aluno foram mapeadas como
atributos (variáveis) na codificação em Java.

class Aluno {

Aluno String nome;


int ra;
String data_de_nascimento;
String telefone;
Nome String email;
ra
void fazMatricula ( ) {
data_de_nascimento //códgio
telefone }
email
boolean cancelaMatricula ( ) {
//código
fazMatricula }
cancelaMatricula
}
Figura 6 Classe Aluno em Java (versão inicial).
14 © Programação Orientada a Objetos

Na Figura 6, quase todos os atributos foram identificados como caractere e, portanto,


mapeados como variáveis do tipo String. A única exceção foi o atributo ra identificado como
int. Os atributos data_de_nascimento e telefone foram representados como String, e não como
int, porque caracteres podem ser armazenados como parte da informação (barra ou hífen para
separação entre dia, mês e ano, e parênteses ou hífen entre o DDD e o número do telefone).
Os comportamentos, mapeados em forma de métodos, encontram-se parcialmente codi-
ficados. Os métodos correspondem às funções das linguagens Pascal e C e indicam um tipo de
dado que será retornado após sua execução. Nos métodos citados na classe Aluno, são exibidos
os tipos void e boolean. O tipo void corresponde à ausência de valor, ou seja, nenhum valor será
retornado pelo método (nesse caso, o método assemelha-se a procedure da linguagem Pascal).
O tipo boolean indica que o valor verdadeiro (true) ou falso (false) será retornado após a execu-
ção do método cancelaMatricula.
Note que os códigos internos dos métodos foram omitidos, pois envolvem a classe Disci-
plina que não foi codificada. O intuito neste momento é mostrar que os comportamentos são
representados em forma de métodos. Para ilustrarmos como se codificam métodos em Java,
vamos criar mais adiante alguns exemplos que envolvem apenas a classe Aluno, e deixaremos
de lado a codificação dos métodos fazMatricula e cancelaMatricula, porque a implementação
deles envolve conceitos mais aprofundados da Orientação a Objetos que serão tratados nesta
obra.
A Orientação a Objetos define uma série de conceitos importantes envolvendo as classes.
Dentre eles, destaca-se o Encapsulamento, que consiste na propriedade da classe esconder os
detalhes de sua implementação (atributos e métodos) de outras classes. Encapsulamento é uma
propriedade muito importante na programação orientada a objetos, pois diminui a interdepen-
dência entre classes, ou seja, evita que o código de uma classe faça referência a todo e qualquer
atributo ou método de outra classe.
A desvantagem de se implementar um projeto sem se preocupar com o encapsulamento
das classes é que, quando uma classe sofre modificações em atributos e métodos, as mudanças
realizadas podem ocasionar erros em outras classes que acessavam as antigas versões. Nesse
caso, erros ocorrerão em classes que nem sequer sofreram modificações, mas simplesmente
acessavam os atributos e métodos que foram modificados.
Java oferece suporte ao encapsulamento por meio do uso dos Modificadores de Acesso.
Estes correspondem a referências usadas, geralmente, no início da declaração de atributos e
métodos e controlam, de forma diferenciada, os acessos a eles. Java possui os seguintes modi-
ficadores de acesso:
• public;
• private;
• protected.
O modificador public (público) oferece acesso compartilhado ou público do atributo, mé-
todo ou classe a todas as demais classes. O modificador private (privado) permite acesso restrito
apenas à própria classe sobre atributos e métodos. Enquanto o modificador protected (protegi-
do) permite o acesso apenas às subclasses. As subclasses são classes filhas que herdam as defi-
nições da superclasse ou classe pai. Estudaremos o conceito de herança nas Unidades 1 e 4.
Para facilitar a compreensão do uso de modificadores de acesso, vamos alterar a Classe
Aluno e simular o uso dos vários tipos de modificadores. Veja, na Figura 7, um exemplo de apli-
cação:

Centro Universitário Claretiano


© Caderno de Referência de Conteúdo 15

Acesso compartilhado public class Aluno {


com todas as classes
private String nome;
private int ra;
Acesso restrito private String data_de_nascimento;
à classe Aluno private String telefone;
private String email;

public void fazMatricula ( ) {


Acesso compartilhado //códgio
com todas as classes }

protected boolean cancelaMatricula ( ) {


Acesso compartilhado apenas //código
para subclasses }

}
Figura 7 Classe Aluno em Java (versão com modificadores de acesso).

Note, na Figura 7, que todos os atributos da classe Aluno foram definidos com o modificador
de acesso private. Essa codificação garante aos atributos acesso restrito à própria classe e nenhu-
ma referência externa será permitida. Os métodos foram codificados usando modificadores public
e protected. Estes estarão acessíveis externamente a outras classes. Essa forma de codificação pos-
sibilita um bom nível de Encapsulamento, pois isola os detalhes mais internos da classe (atributos)
e mantém certo nível de acesso de compartilhamento com outras classes (métodos).
Em Java, a ausência ou falta de uso do modificador de acesso em um atributo, método ou
classe corresponde ao modificador chamado de padrão ou default. Este gera um quarto tipo de
comportamento no que se refere ao acesso a atributos, métodos e classes. Neste, o Java com-
partilha o acesso apenas com as classes que estão no mesmo pacote (package) da classe, isto é,
na mesma pasta do projeto.
Basicamente, um pacote corresponde ao agrupamento de classes em pastas e normalmen-
te são definidas para se reunir em um mesmo grupo as classes que participam de um mesmo
sistema ou módulo. No nosso sistema da escola, a classe Aluno poderia, por exemplo, participar
do pacote Secretaria, uma vez que o cadastro de alunos e disciplinas corresponde a informações
gerenciadas por esse setor.
Podemos ter vários pacotes dentro de um mesmo sistema, assim como pacotes dentro de
pacotes. No sistema da escola, poderíamos ter, por exemplo, um pacote chamado escola para
agrupar todas as classes do projeto. Dentro desse pacote escola, podemos ter, por exemplo, dois
outros pacotes (subpacotes) chamados secretaria e biblioteca. As classes correspondentes ao
controle de alunos e disciplinas ficariam registradas no pacote secretaria, enquanto as classes
livro e empréstimo estariam registradas no pacote biblioteca.
Assim, os modificadores de acesso são importantes para se definir o que será acessado em
uma classe e quem poderá acessar a classe e seus atributos e métodos. O conjunto de atributos
e métodos acessíveis corresponde à interface da classe, pois são visualizados e compartilhados
com outras classes. Modificações realizadas sobre eles devem ser feitas com muito cuidado,
porque uma alteração poderá gerar inconsistências nas classes que os acessam. Nessa situação,
um conjunto de alterações também deve ser realizado nessas classes, para manter a compatibi-
lidade das referências com os atributos e métodos.
16 © Programação Orientada a Objetos

Retornando à codificação em Java, vamos agora abordar a implementação dos métodos


da classe Aluno. Você deve ter notado no código da Figura 7 que todos os atributos foram defini-
dos com o modificador de acesso private. Para torná-los acessíveis, podemos criar métodos que
permitam o compartilhamento para leitura e modificação. Esse conjunto de métodos recebe o
nome de Métodos Acessores ou Getters e Setters.
A maior motivação para o uso dos métodos acessores é manter o encapsulamento das
classes, pois elas podem restringir o acesso direto aos atributos (modificador private) e compar-
tilhar o acesso por meio de métodos (modificador public, protected ou default).
Para melhor compreender a utilização dos métodos acessores, vamos exemplificar usando
a classe Aluno e seu atributo nome. O atributo nome está definido na classe Aluno (Figura 7)
como acesso privado (private). Para acessá-lo, vamos definir dois métodos, sendo um deles cha-
mado getNome, que será encarregado de ler o valor armazenado no atributo nome e devolvê-
lo como informação de retorno, e outro método chamado setNome, que será responsável por
receber um valor e registrá-lo como nova informação do atributo nome.
Os prefixos get e set presentes no início do nome dos métodos remetem-nos à denomi-
nação anteriormente citada dos getters e setters. Acompanhe, na Figura 8, a codificação desses
métodos referentes ao atributo nome.

public String getNome ( ) {


Retorna o valor do
return nome;
atributo nome }

public void setNome ( String nome ) {


Modifica o valor do this.nome = nome;
atributo nome }
Figura 8 Métodos acessores do atributo nome da classe Aluno.

Observe que nos dois métodos foi utilizado o modificador de acesso public, como forma
de tornar os métodos acessíveis. Além disso, os tipos de retorno usados foram String e void, isto
é, o método getNome retornará, após sua execução, uma informação do tipo String, enquanto
o método setNome não realizará nenhum retorno.
No método getNome, o comando return se encarregará de finalizar a execução do método
e devolverá o valor armazenado no atributo nome. No método setNome, um parâmetro do tipo
String e de identificação nome é repassado. Esse parâmetro nome confunde-se com o atributo
nome definido na classe Aluno. Para diferenciar um do outro, o Java dispõe do termo this que
reforça a origem da referência nome, presente no comando this.nome, como um atributo da
classe, e não como o parâmetro local.
Os prefixos get e set são comuns de se utilizar e encontrar nos nomes dos métodos Java,
que possuem como propósito compartilhar o acesso a atributos privado à classe. Note que o uso
desses prefixos é apenas uma convenção (padronização), sendo possível ao programador esco-
lher qualquer outra denominação para os métodos. Por exemplo, em vez de getNome poderia
se utilizar pegaNome ou obtemNome, como uma referência direta à tradução do termo inglês
get para o português.
Acompanhe, na Figura 9, a codificação dos métodos acessores (Getters e Setters) para
todos os atributos de acesso restrito, definidos na classe Aluno.

Centro Universitário Claretiano


© Caderno de Referência de Conteúdo 17

public class Aluno {

private String nome;


private int ra;
Atributos de acesso restrito private String data_de_nascimento
à classe private String telefone;
private String email;

public String getNome ( ) {


return nome;
}
Métodos acessores para o
atributo nome
public void setNome ( String nome ) {
this.nome = nome;
}

public int getRa ( ) {


return ra;
}
Métodos acessores para o
atributo ra
public void setRa ( int ra ) {
this.ra = ra;
}

public String getDataDeNascimento ( ) {


return data_de_nascimento;
}
Métodos acessores para o
atributo data_de_nascimento public void setDataDeNascimento ( String data ) {
data_de_nascimento = data;
}

public String getTelefone ( ) {


return telefone;
}
Métodos acessores para o
atributo telefone public void setTelefone ( String fone ) {
telefone = fone;
}

public String getEmail ( ) {


return email;
}
Métodos acessores para o
atributo email
public void setEmail ( String email ) {
this.email = email;
}
}
Figura 9 Classe Aluno com todos os métodos acessores.

Perceba que o uso do termo this foi obrigatório nos métodos setNome, setRa e setEmail,
enquanto não foi utilizado nos métodos setDataDeNascimento e setTelefone. A razão para isso
é que nos métodos setNome, setRa e setEmail existem parâmetros com nomes que coincidem
com o nome dos atributos da classe, e o termo this é necessário para reforçar a diferenciação
entre os dois. Nos métodos setDataDeNascimento e setTelefone, o nome dos parâmetros difere
do nome dos atributos, não sendo necessário o uso do this para indicar que se trata de um atri-
buto da classe, porém o seu uso poderia ser feito sem causar qualquer tipo de erro à classe.
18 © Programação Orientada a Objetos

Note que os métodos fazMatricula e cancelaMatricula, presentes inicialmente no código


da classe Aluno, foram omitidos nessa última versão. Conforme comentamos anteriormente, a
codificação deles envolve conceitos mais aprofundados da Orientação a Objetos, como é o caso
da relação de associação que ocorre entre as classes Aluno e Disciplina. Você aprenderá a codi-
ficar esse tipo de relação na Unidade 4.
A retirada desses métodos no momento é interessante porque contribui para a correta
codificação da classe, uma vez que os métodos enquanto incompletos causam erros de compi-
lação, conforme regras da linguagem Java.
Além dos métodos acessores, já definidos anteriormente, a programação orientada a ob-
jetos define também mais um importante tipo de método que quase sempre está presente nos
códigos de uma classe. Esse método chama-se Método Construtor.
Os métodos construtores desempenham um papel importantíssimo no que se refere à
programação orientada a objetos. Conforme vimos, uma classe com seus atributos e métodos
serve de modelo para os objetos que ela representa e para os que serão criados a partir de suas
definições. O método construtor é justamente o método que torna possível a instanciação ou
criação de um novo objeto em memória.
Quando o método construtor é chamado, o ambiente de execução Java (JVM) interpreta
a execução como um comando para alocar um espaço na memória do computador, suficiente
para armazenar todos os atributos definidos na classe. Além de realizar a alocação dos atributos
(variáveis) em memória, o método construtor também desempenha como segunda função a
iniciação dos atributos com valores normalmente recebidos por meio de parâmetros que são
repassados ao método.
Cada chamada ao método construtor realiza a instanciação de um novo objeto em memó-
ria, e cada objeto terá seus atributos (variáveis) inicialmente definidos conforme os parâmetros
repassados ao método construtor.
Em Java, o método construtor possui uma particularidade. Seu nome corresponde exata-
mente ao nome da classe, isto é, na classe Aluno, o método construtor será identificado pelo
nome Aluno. Esteja atento ao fato de que em Java as letras minúsculas e maiúsculas possuem
diferenciação.
Outra particularidade da linguagem Java em relação ao método construtor é que não se
define um tipo de variável de retorno para o método. Nos outros métodos, definimos retornos
do tipo String, boolean e void, porém, no método construtor, não se identifica o tipo de retorno.
Uma justificativa para tal é que o método, quando executado, retorna não um tipo de dado, mas
sim um objeto que se encontra alocado em memória.
Acompanhe, na Figura 10, a codificação de um método construtor para a classe Aluno que
deverá ser incluído junto com os métodos acessores dentro da classe Aluno.

public Aluno ( String nome, int ra, String data, String fone, String email ) {
this.nome = nome;
this.ra = ra;
Iniciação dos
data_de_nascimento = data;
atributos
telefone = fone;
this.email = email;
}
Figura 10 Método construtor da classe Aluno.

Centro Universitário Claretiano


© Caderno de Referência de Conteúdo 19

Note, no código da Figura 10, que não existe depois do modificador public e antes do
nome do método a definição de tipo de dado de retorno. Repare que o nome do método cor-
responde exatamente ao nome da classe. Note também que existem parâmetros declarados
no método que são usados para realizar a iniciação dos valores dos atributos. Um parâmetro
foi passado para cada um dos atributos declarados na classe. Essa codificação faz a iniciação de
todos os atributos juntos.
Uma classe pode declarar mais de um método construtor. Isso é possível, pois quantida-
des e tipos diferentes de parâmetros podem ser repassados, resultando assim em diferentes
métodos construtores.
Para ilustrar a criação de objetos, vamos simular a execução do método construtor da
classe Aluno. A chamada, a seguir, exemplifica a passagem de parâmetros ao método construtor
Aluno.

Aluno( “Jose”, 11111, “01/10/1980”, “1111111”, “jose@email.com” )

Como resultado dessa execução, o método construtor irá alocar em memória um objeto
contendo os atributos declarados na classe (Figura 11). Esses atributos terão iniciação com base
nos valores dos parâmetros repassados ao método construtor.

• Nome = José
• Ra = 11111
• Data de Nascimento = 01/10/1980
• Telefone = 11111111
• E-mail = jose@email.com
Figura 11 Objeto Aluno alocado em memória depois da
chamada ao método construtor.

São muitos os conceitos a serem estudados. Neste roteiro de videoaula, apenas realiza-
mos a apresentação dos conceitos iniciais envolvendo Orientação a Objetos e Java. Esta obra
abordará por completo a codificação de um sistema, usando a programação orientada a objetos
com a linguagem Java. Esperamos que você tenha aprendido os principais conceitos e esteja
motivado a prosseguir com os estudos.

Glossário de Conceitos
O Glossário de Conceitos permite a você uma consulta rápida e precisa das definições con-
ceituais, possibilitando-lhe um bom domínio dos termos técnico-científicos utilizados na área de
conhecimento dos temas tratados na obra Programação Orientada a Objetos. Veja, a seguir, a
definição dos principais conceitos:

1) Abstração: mecanismo utilizado na análise de um domínio de aplicação em que se


observa a realidade e dela se identificam informações consideradas essenciais para
uma aplicação, excluindo todos os aspectos julgados irrelevantes.
2) Agregação: tipo de relação existente entre classes que permite a reutilização de clas-
ses já existentes para compor classes de estruturas mais complexas. A relação estabe-
lecida é do tipo "parte-todo", em que se criam classes (agregadoras) que se utilizam
de outras classes (agregadas) como parte de sua definição.
20 © Programação Orientada a Objetos

3) Associação: outro tipo de relação existente entre classes, em que as classes envolvi-
das não apresentam estruturas comuns como acontece na herança e na agregação. O
que se observa normalmente é que, na associação, as classes relacionadas apresen-
tam estruturas distintas, e o tipo de relação está vinculado a alguma regra de negócio
do sistema.
4) Classe: abstração de um conjunto de objetos similares do mundo real, descrevendo a
estrutura de dados e o comportamento de objetos similares.
5) Classificação: ação de criar classes por meio da abstração de conceitos existentes em
objetos que possuem características e comportamentos iguais.
6) Domínio de Aplicação: corresponde às informações do ambiente em que a aplicação
está inserida. Por exemplo, para projetar um sistema de biblioteca, é necessário que o
desenvolvedor compreenda todas as regras de negócio relacionadas ao funcionamen-
to da biblioteca (controle de livros, empréstimo, devolução etc.). A compreensão do
domínio da aplicação é pré-requisito para um bom projeto de software.
7) Encapsulamento: é uma técnica para minimizar interdependências entre objetos, por
meio da definição de métodos que possibilitam o acesso aos dados do objeto. Assim,
mudanças na definição e na implementação de uma classe, desde que preservem os
métodos de acesso, não afetam outras classes presentes no restante do sistema.
8) Herança: tipo de relação existente entre classes que permite definir uma nova classe
(subclasse) a partir de uma já existente (superclasse). Ao se estabelecer uma subclas-
se, ela herda todas as características da superclasse, ou seja, a especificação dos atri-
butos e dos métodos da superclasse passa a fazer parte da especificação dos atributos
e dos métodos da subclasse. Assim, a subclasse pode adicionar novos métodos, como
também reescrever os métodos herdados da superclasse. A relação estabelecida é
chamada de "é do tipo", em que uma subclasse "é do tipo" da superclasse.
9) Instanciação: corresponde à ação de criar objetos com base em uma classe. Todo ob-
jeto criado é uma instância de uma classe.
10) Objeto: abstração de uma entidade do mundo real representada por meio das carac-
terísticas e dos comportamentos.

Esquema dos Conceitos-chave


Para que você tenha uma visão geral dos conceitos mais importantes deste estudo, apre-
sentamos, a seguir (Figura 12), um Esquema dos Conceitos-chave. O mais aconselhável é que
você mesmo faça o seu esquema de conceitos-chave ou até mesmo o seu mapa mental. Esse
exercício é uma forma de você construir o seu conhecimento, ressignificando as informações a
partir de suas próprias percepções.
É importante ressaltar que o propósito desse Esquema dos Conceitos-chave é representar,
de maneira gráfica, as relações entre os conceitos por meio de palavras-chave, partindo dos
mais complexos para os mais simples. Esse recurso pode auxiliar você na ordenação e na se-
quenciação hierarquizada dos conteúdos de ensino.
Com base na teoria de aprendizagem significativa, entende-se que, por meio da organiza-
ção das ideias e dos princípios em esquemas e mapas mentais, o indivíduo pode construir o seu
conhecimento de maneira mais produtiva e obter, assim, ganhos pedagógicos significativos no
seu processo de ensino e aprendizagem.
Aplicado a diversas áreas do ensino e da aprendizagem escolar (tais como planejamentos de
currículo, sistemas e pesquisas em Educação), o Esquema dos Conceitos-chave baseia-se, ainda,
na ideia fundamental da Psicologia Cognitiva de Ausubel, que estabelece que a aprendizagem
ocorre pela assimilação de novos conceitos e de proposições na estrutura cognitiva do aluno. As-
sim, novas ideias e informações são aprendidas, uma vez que existem pontos de ancoragem.
Centro Universitário Claretiano
© Caderno de Referência de Conteúdo 21

Tem-se de destacar que "aprendizagem" não significa, apenas, realizar acréscimos na es-
trutura cognitiva do aluno; é preciso, sobretudo, estabelecer modificações para que ela se con-
figure como uma aprendizagem significativa. Para isso, é importante considerar as entradas de
conhecimento e organizar bem os materiais de aprendizagem. Além disso, as novas ideias e os
novos conceitos devem ser potencialmente significativos para o aluno, uma vez que, ao fixar es-
ses conceitos nas suas já existentes estruturas cognitivas, outros serão também relembrados.
Nessa perspectiva, partindo-se do pressuposto de que é você o principal agente da cons-
trução do próprio conhecimento, por meio de sua predisposição afetiva e de suas motivações
internas e externas, o Esquema dos Conceitos-chave tem por objetivo tornar significativa a sua
aprendizagem, transformando o seu conhecimento sistematizado em conteúdo curricular, ou
seja, estabelecendo uma relação entre aquilo que você acabou de conhecer com o que já fazia
parte do seu conhecimento de mundo (adaptado do site disponível em: <http://penta2.ufrgs.
br/edutools/mapasconceituais/utilizamapasconceituais.html>. Acesso em: 11 mar. 2010).

Orientação a
Objetos

Linguagem Java UML


Abstração
Características Comportamento
Código-Fonte s
Objeto

JDK Classificação Instanciação

Classe Diagrama de Classes


Encapsulamento
Bytecode

Polimorfismo Relações
JVM

Portabilidade
Herança Agregação Associação

Figura 12 Esquema dos Conceitos-chave de Programação Orientada a Objetos.

Como você pode observar, esse Esquema dá a você, como dissemos anteriormente, uma
visão geral dos conceitos mais importantes deste estudo. Ao segui-lo, você poderá transitar
entre um e outro conceito desta obra e descobrir o caminho para construir o seu processo de
ensino-aprendizagem. Por exemplo, o conceito classe implica conhecer o conceito objeto, que,
por consequência, implica conhecer o conceito de abstração. Sem o domínio conceitual desse
processo explicitado pelo Esquema, pode-se ter uma visão confusa do tratamento da temática
do ensino de Programação Orientada a Objeto, proposto nesta obra.
O Esquema dos Conceitos-chave é mais um dos recursos de aprendizagem que vem se
somar àqueles disponíveis no ambiente virtual, por meio de suas ferramentas interativas, bem
como àqueles relacionados às atividades didático-pedagógicas realizadas presencialmente no
polo. Lembre-se de que você, aluno EaD, deve valer-se da sua autonomia na construção de seu
próprio conhecimento.
22 © Programação Orientada a Objetos

Questões Autoavaliativas
No final de cada unidade, você encontrará algumas questões autoavaliativas sobre os con-
teúdos ali tratados, as quais podem ser de múltipla escolha, abertas objetivas ou abertas disser-
tativas.
Responder, discutir e comentar estas questões, bem como relacioná-las com a prática do
ensino de Programação Orientada a Objetos, pode ser uma forma de você avaliar o seu conhe-
cimento. Assim, mediante a resolução de questões pertinentes ao assunto tratado, você estará
se preparando para a avaliação final, que será dissertativa. Além disso, essa é uma maneira pri-
vilegiada de você testar seus conhecimentos e adquirir uma formação sólida para a sua prática
profissional.
Você encontrará, ainda, no final de cada unidade, um gabarito, que lhe permitirá conferir
as suas respostas sobre as questões autoavaliativas de múltipla escolha.

As questões de múltipla escolha são as que têm como resposta apenas uma alternativa correta. Por
sua vez, entendem-se por questões abertas objetivas as que se referem aos conteúdos matemáticos
ou àqueles que exigem uma resposta determinada, inalterada. Já as questões abertas dissertativas
obtêm por resposta uma interpretação pessoal sobre o tema tratado; por isso, normalmente, não há
nada relacionado a elas no item Gabarito. Você pode comentar suas respostas com o seu tutor ou com
seus colegas de turma.

Bibliografia Básica
É fundamental que você use a Bibliografia Básica em seus estudos, mas não se prenda só
a ela. Consulte, também, as bibliografias complementares.

Figuras (ilustrações, quadros...)


Neste material instrucional, as ilustrações fazem parte integrante dos conteúdos, ou seja,
elas não são meramente ilustrativas, pois esquematizam e resumem conteúdos explicitados no
texto. Não deixe de observar a relação dessas figuras com os conteúdos, pois relacionar aquilo que
está no campo visual com o conceitual faz parte de uma boa formação intelectual.

Dicas (motivacionais)
O estudo desta obra convida você a olhar, de forma mais apurada, a Educação como pro-
cesso de emancipação do ser humano. É importante que você se atente às explicações teóricas,
práticas e científicas que estão presentes nos meios de comunicação, bem como partilhe suas
descobertas com seus colegas, pois, ao compartilhar com outras pessoas aquilo que você obser-
va, permite-se descobrir algo que ainda não se conhece, aprendendo a ver e a notar o que não
havia sido percebido antes. Observar é, portanto, uma capacidade que nos impele à maturidade.
Você, como aluno do curso de Graduação na modalidade EaD, necessita de uma formação
conceitual sólida e consistente. Para isso, você contará com a ajuda do tutor a distância, do tutor
presencial e, sobretudo, da interação com seus colegas. Sugerimos, pois, que organize bem o
seu tempo e realize as atividades nas datas estipuladas.
É importante, ainda, que você anote as suas reflexões em seu caderno ou no Bloco de
Anotações, pois, no futuro, elas poderão ser utilizadas na elaboração de sua monografia ou de
produções científicas.

Centro Universitário Claretiano


© Caderno de Referência de Conteúdo 23

Leia os livros da bibliografia indicada, para que você amplie seus horizontes teóricos. Co-
teje-os com o material didático, discuta a unidade com seus colegas e com o tutor e assista às
videoaulas.
No final de cada unidade, você encontrará algumas questões autoavaliativas, que são im-
portantes para a sua análise sobre os conteúdos desenvolvidos e para saber se estes foram
significativos para sua formação. Indague, reflita, conteste e construa resenhas, pois esses pro-
cedimentos serão importantes para o seu amadurecimento intelectual.
Lembre-se de que o segredo do sucesso em um curso na modalidade a distância é parti-
cipar, ou seja, interagir, procurando sempre cooperar e colaborar com seus colegas e tutores.
Caso precise de auxílio sobre algum assunto relacionado a esta obra, entre em contato
com seu tutor. Ele estará pronto para ajudar você.
24 © Programação Orientada a Objetos

Centro Universitário Claretiano


EAD
Orientação a Objetos

1. OBJETIVOS
• Compreender os conceitos básicos da Orientação a Objetos.
• Abstrair informações e classificar conceitos.
• Conhecer diferentes formas de relacionamento entre objetos.

2. CONTEÚDOS
• Definição de Abstração, Objeto e Classe.
• Conceitos: Generalização, Especificação, Encapsulamento e Polimorfismo.
• Relacionamentos: Herança, Agregação e Associação.

3. ORIENTAÇÕES PARA O ESTUDO DA UNIDADE


Antes de iniciar o estudo desta unidade, é importante que você leia as orientações a se-
guir:
1) Leia os livros da bibliografia indicada, para que você amplie e aprofunde seus horizon-
tes teóricos. Esteja sempre com o material didático em mãos e discuta a unidade com
seus colegas e com seu tutor.
2) Tenha sempre a mão o significado dos conceitos explicitados no Glossário e suas li-
gações pelo Esquema de Conceitos-chave para o estudo de todas as unidades desta
obra. Isso poderá facilitar sua aprendizagem e seu desempenho.
26 © Programação Orientada a Objetos

4. INTRODUÇÃO À UNIDADE
Nesta primeira unidade, apresentaremos os principais conceitos da Orientação a Objetos
(OO), bem como teremos a oportunidade de aprender a interpretar diagramas que representam
tais conceitos. Conheceremos, também, as motivações que levaram a seu surgimento.
Bom estudo!

5. CONCEITOS BÁSICOS DA ORIENTAÇÃO A OBJETOS


A queda nos preços dos equipamentos de informática na década de 1970 motivou diver-
sas empresas de pequeno e médio porte a informatizarem seus processos operacionais. Nessa
época, os conhecimentos técnicos relacionados ao desenvolvimento de software não eram sufi-
cientes para resolver alguns problemas de desenvolvimento de sistemas.
Essa necessidade tornou-se evidente com a crescente demanda do público consumidor
de software. Os novos usuários de sistemas não eram especialistas em computação, e sim pro-
fissionais de outras áreas. Foi esse cenário que motivou o surgimento da Orientação a Objetos
(OO).
Portanto, a Orientação a Objetos surgiu da necessidade de simular a realidade, criando
abstrações na tentativa de representar as características relevantes dos objetos envolvidos no
sistema que se deseja desenvolver. A compreensão do software tornou-se mais fácil, pois a re-
presentação em objetos é um processo natural.
Com o uso da Orientação a Objetos, a engenharia de software conseguiu avançar na ha-
bilidade de modelar e projetar softwares, que representam os problemas do mundo real no
mundo computacional. O desenvolvedor aproveita os aspectos mais importantes do mundo real
para realizar as representações no mundo computacional.
A modelagem conceitual descreve as informações que o sistema irá gerenciar. Uma das
formas de modelagem mais utilizadas atualmente e que emprega os conceitos da orientação a
objetos é a UML (Unified Modeling Language), que em português significa Linguagem de Mode-
lagem Unificada (BOOCH; RUMBAUGH; JACOBSON, 2005), que possui vários tipos de diagramas
necessários para representar diferentes tipos de informações de um sistema.
Dessa forma, constata-se que a tarefa mais importante de um processo de desenvolvi-
mento de software é realizar a análise do domínio da aplicação e a modelagem dos objetos. A
análise do domínio da aplicação corresponde às informações do ambiente em que a aplicação
está inserida. Por exemplo, para projetar um sistema de biblioteca, é necessário que o desen-
volvedor compreenda todas as regras de negócio relacionadas ao funcionamento da biblioteca
(controle de livros, empréstimo, devolução etc.).
A compreensão do domínio da aplicação é pré-requisito para um bom projeto de software.
Já a modelagem são fenômenos que ocorrem sobre estes, independentemente da forma como
serão implementados posteriormente. Nesse sentido, o processo de modelagem dos objetos
envolve dois mecanismos:
• Abstração.
• Representação.
Veja, na Figura 1, o processo de modelagem de objetos.

Centro Universitário Claretiano


© Orientação a Objetos 27

Figura 1 Modelagem Conceitual.

Abstração
A abstração é o mecanismo utilizado na análise de um domínio da aplicação, em que se
observa a realidade e dela se abstraem entidades e ações que são consideradas essenciais para
uma aplicação, excluindo todos os aspectos julgados irrelevantes.
A representação é o processo de traduzir essas informações essenciais no mundo compu-
tacional. Na modelagem orientada a objetos, destacamos as representações em formato gráfico
(UML) e em formato de código (linguagem de programação Orientada a Objetos).
A ideia básica da Orientação a Objetos é perceber o mundo como uma coleção de objetos
que interagem entre si. Na modelagem de sistemas orientada a objetos, um objeto é uma enti-
dade que possui:
a) características;
b) comportamento;
c) estado;
d) identidade única.

cor
aparência peso
tamanho
Correr
Brincar Criar
Comer

Figura 2 Abstração.
28 © Programação Orientada a Objetos

Na Figura 2, observe que uma pessoa poderia olhar um coelho como um animal de es-
timação e descrevê-lo com as características “cor” e “aparência”, e com os comportamentos
“correr” e “brincar”. Um médico veterinário, ao olhar o mesmo coelho, iria se preocupar com as
características “peso” e “tamanho”, bem como com os comportamentos “criar” e “comer”. Note
que um mesmo objeto pode possuir diferentes características, pois depende da abstração ou
visão da pessoa que o analisa.
Assim, na análise realizada pelo veterinário, o animal coelho foi representado no objeto Coe-
lho, e tem como características “peso” e “tamanho”, e como comportamentos “criar” e “comer”.

Coelho

peso
Características
tamanho

criar Comportamentos
comer
Figura 3 Objeto Coelho.

É importante considerar, ainda, o Estado de um objeto, que corresponde ao conjunto de


valores associados às características do objeto. Dessa forma, considere o objeto Coelho e os dois
estados representados na Figura 4:

Coelho Coelho

peso = 650 gm peso = 500 gm


tamanho = 39 cm tamanho = 35 cm

criar criar
comer comer
hoje 3 meses antes
Figura 4 Estados.

A Figura 4 ilustra o Estado do Objeto coelho no dia de “hoje” e em “3 meses antes”. Perce-
ba que o estado pode mudar com o passar do tempo.
Assim, cada objeto tem uma identidade única, que o diferencia dos demais. Em um sis-
tema orientado a objetos, por exemplo, cada objeto Coelho terá uma identificação única que o
diferenciará de quaisquer outros coelhos que venham a existir no sistema.

Classe e objeto
Segundo Deitel e Deitel (2007), quando estamos modelando um sistema usando a Orien-
tação a Objetos, notamos que existem vários objetos com características e comportamentos
similares. A análise desses objetos semelhantes pode gerar, conforme a visão da abstração, uma

Centro Universitário Claretiano


© Orientação a Objetos 29

representação única chamada Classe, a qual, na Orientação a Objetos, incorpora essa operação
por meio da abstração dos atributos (características) e dos métodos (comportamentos) que ca-
racterizam objetos semelhantes.
CLASSE

<nome do objeto>

<atributos>

<métodos>

Figura 5 Estrutura de Classe (UML).

Enquanto um Objeto é uma abstração de uma entidade do mundo real, por meio das ca-
racterísticas e comportamentos, a classe é a abstração de um conjunto de objetos similares do
mundo real, que descreve a estrutura de dados e o comportamento de objetos similares.
Uma classe representa, portanto, um conjunto de objetos que possui características seme-
lhantes (atributos), os mesmos comportamentos (métodos), os mesmos relacionamentos com
outros objetos e a mesma semântica.

CASA

Sala
Quarto
Cozinha
Banheiro

Reformar
Mobiliar
Limpar
Figura 6 Classe Casa.

Na Figura 6, definimos a Classe Casa como a representação de vários objetos que possuem
características (sala, quarto, cozinha e banheiro) e comportamentos (reformar, mobiliar e lim-
par) semelhantes. A ação de criar classes por meio da abstração de objetos similares é denomi-
nada Classificação.
A ação de criar objetos com base em uma classe é denominada Instanciação. É importante
ressaltar, ainda, que todo objeto é uma instância de uma classe. Em um sistema Orientado a
Objetos, não há limites relacionados à quantidade de objetos que podem ser instanciados ou
criados a partir de uma classe.
30 © Programação Orientada a Objetos

Encapsulamento
Na Orientação a Objetos, todo objeto está relacionado a uma classe que o representa e
que serve como um modelo ou molde para ele. O objeto terá os atributos e os métodos que
estão definidos na estrutura da classe que o representa, e os detalhes relacionados à implemen-
tação desses atributos e métodos estão reunidos dentro da implementação da classe. Essa ca-
racterística de “esconder” os detalhes da implementação recebe o nome de Encapsulamento.
Nas linguagens de programação estruturada (como, por exemplo, Pascal e C), as estrutu-
ras de dados abstratas eram acessadas por meio de funções sem a possibilidade do tratamento
de segurança para controle de acesso a esses dados e sem os devidos tratamentos para uma
reusabilidade de código. A Orientação a Objetos, por meio do Encapsulamento, proporciona
meios para o controle de acesso a características e métodos das classes, resultando em melhor
qualidade na reusabilidade dos códigos.
Dessa forma, o Encapsulamento é uma técnica para minimizar interdependências entre
objetos por meio da definição de métodos que possibilitam o acesso aos dados do objeto. As-
sim, mudanças na definição e na implementação de uma classe, desde que preservem os méto-
dos de acesso, não afetam o restante do sistema. O Encapsulamento produz, então, um controle
diferenciado de acesso aos atributos e métodos de um objeto. Logo, as partes de um objeto
podem ser divididas em:
• Parte privada (visão interna sem permissão de acesso externo):
a) corresponde à parte interna do objeto, isto é, àquela que é inacessível a outros
objetos;
b) pode representar tanto atributos como métodos do objeto.

• Parte compartilhada ou interface (visão externa com acesso disponível):


a) corresponde à parte externa do objeto, isto é, àquela que é vista por outros obje-
tos com a finalidade de invocar os métodos que o objeto realiza;
b) agrupa um conjunto de mensagens a que o objeto pode responder;
c) representa as mensagens que especificam quais operações sobre o objeto podem
ser realizadas, mas não como a operação será executada.
Além disso, o Encapsulamento oferece os seguintes benefícios:
• Segurança: protege os atributos dos objetos de terem seus valores corrompidos por
outros objetos.
• Independência: ao “esconder” seus atributos, um objeto protege outros objetos de
complicações de dependência de sua estrutura interna.
A comunicação entre os objetos ocorre por meio do envio de mensagens, em que um
objeto (emissor) envia uma mensagem a outro objeto (receptor), que executará o método invo-
cado por esta. As mensagens só interagem com a interface do objeto (parte compartilhada), e
não com a sua parte interna correspondente (parte privada).
Cada objeto possui seu próprio conjunto de métodos, conforme a definição realizada no
processo de classificação (criação da classe). Os métodos são intrínsecos aos objetos e descre-
vem uma sequência de ações a serem executadas por um objeto.
Para efetuar uma operação, ao receber uma mensagem, um objeto determinará como a
operação será efetuada, uma vez que este tem comportamento próprio.

Centro Universitário Claretiano


© Orientação a Objetos 31

Nesse sentido, como a responsabilidade é do receptor e não do emissor, pode acontecer


que uma mesma mensagem ative métodos diferentes, dependendo da classe de objeto para
onde é enviada a mensagem. Essa característica é denominada Polimorfismo, que veremos com
mais detalhes a seguir.

Polimorfismo
O Polimorfismo permite a criação de várias classes com interfaces idênticas, porém com
objetos e implementações diferentes. Ele possibilita que uma mensagem seja executada de
acordo com as características do objeto que está recebendo o pedido de execução do serviço.
Vimos que uma classe representa um conjunto de objetos que possuem características se-
melhantes (atributos e comportamentos). Além disso, uma classe pode se relacionar com outras
classes, possibilitando, assim, uma melhor modelagem dos conceitos do mundo real no mundo
computacional. Destacamos três principais formas de relacionamento entre classes: Herança,
Agregação e Associação.
Em muitas ocasiões, o processo de classificação identifica objetos com características
semelhantes que não podem ser agrupados em uma única representação (classe), pois apre-
sentam regras de uso e comportamentos diferentes dentro de um sistema. Com o intuito de
reaproveitar ao máximo os conceitos abstraídos em uma classe, a Orientação a Objetos permite
a criação de “classes filhas” que se baseiam nas definições de uma classe já existente. Esse rela-
cionamento entre classes com o intuito de reaproveitamento recebe o nome de Herança.

Herança
Herança é o mecanismo que permite definir uma nova classe (subclasse) a partir de uma
já existente (superclasse). Ao se estabelecer uma subclasse, ela herda todas as características da
superclasse, ou seja, a especificação dos atributos e dos métodos da superclasse passa a fazer
parte da especificação dos atributos e dos métodos da subclasse. Assim, a subclasse pode adi-
cionar novos métodos, como também reescrever os métodos herdados da superclasse.

CASA
Sala
Quarto
Cozinha
Banheiro
Reformar
Mobiliar
Limpar
Classe Casa
(superclasse)
RESIDENCIAL COMERCIAL
HERANÇA Piscina Vaga
Sauna Luminoso
Classe Residencial Classe Comercial Quadra
(subclasse) (subclasse) Limpar Piscina Ligar Luminoso
Figura 7 Herança.
32 © Programação Orientada a Objetos

Na Figura 7, a Classe Residencial (subclasse) e a Classe Comercial (subclasse) herdam as


definições da Classe Casa (superclasse), ou seja, um objeto instanciado a partir da Classe Resi-
dencial terá como atributos: sala, quarto, cozinha, banheiro, piscina, sauna e quadra; e como
métodos: reformar, mobiliar, limpar e limpar piscina. Já um objeto instanciado a partir da Classe
Comercial terá como atributos: sala, quarto, cozinha, banheiro, vaga e luminoso; e como méto-
dos: reformar, mobiliar, limpar e ligar luminoso.
Note que um objeto do tipo da Classe Residencial não terá a característica vaga nem po-
derá executar o método ligar luminoso. O inverso também é verdade para atributos e métodos
que são exclusivos da Classe Residencial em relação a um objeto da Classe Comercial.
Com base no conceito de Herança, podemos afirmar que um objeto do tipo residencial é,
também, um objeto do tipo casa, porém não podemos afirmar que todo objeto do tipo casa é
um objeto do tipo residencial, pois ele poderá ser um objeto do tipo residencial ou comercial.
No processo de modelagem orientado a objetos, realizamos uma Generalização quando
criamos uma classe (superclasse) com características e comportamentos comuns a outras clas-
ses (subclasses). Nesse processo, deseja-se generalizar na superclasse os atributos e métodos
que são comuns a todas as subclasses.
Entretanto, quando desejamos criar subclasses, identificamos as características específi-
cas e únicas de cada subclasse. Esse processo de criação de subclasses é denominado Especia-
lização.

Agregação e Composição
Além da Herança, a Orientação a Objetos oferece outras formas de reutilização e relação
entre classes. O processo de modelagem orientado a objetos possibilita, também, a criação de
classes que utilizam outras classes como parte de sua definição. Esse processo recebe o nome
de Agregação ou Composição e tem como objetivo principal reutilizar classes já existentes para
compor outras classes mais complexas.
Apesar das semelhanças, a Agregação e a Composição são diferentes em relação à forma
como tratam os objetos que são contidos dentro do objeto que os contém. Na Agregação, os
objetos contidos (agregados) podem existir sem serem parte do objeto que os contém (agrega-
dor). Já na Composição, os objetos contidos não podem existir fora do contexto do objeto que os
contém. Observe, a seguir, quais são as vantagens de se utilizar a Agregação e a Composição:
• Simplificar os detalhes de programação de uma classe por meio da criação de imple-
mentações mais simples, utilizando classes agregadas.
• Reutilizar as classes já existentes; o que possibilita a vantagem desse processo é que
as classes que estão prontas poderão ser utilizadas como parte da definição de outras
classes.
A Figura 8 demonstra duas classes relacionadas por meio de Agregação. Nela, a classe
Casa (agregadora) utiliza a classe Sala (agregada) como parte de sua definição.

Centro Universitário Claretiano


© Orientação a Objetos 33

CASA SALA
TEM
Sala
Quarto Largura
COMPOSIÇÃO Comprimento
Cozinha
Banheiro
Área
Reformar
Mobiliar
Limpar
Figura 8 Composição.

Os detalhes da implementação da Classe Sala estão descritos dentro da Classe Sala e,


portanto, podemos dizer que suas definições são visíveis e pertinentes apenas à própria classe
(Encapsulamento). Contudo, a Classe Casa poderá utilizá-la como parte de sua definição. Nesse
caso, entendemos que a Classe Casa possui Sala como uma característica de sua definição e,
assim, poderá criar (instanciar) vários objetos do tipo Sala para definir suas características.
Nesse contexto, um objeto criado a partir da Classe Sala conterá os atributos Largura e
Comprimento, bem como o método Área.
Veja, na Figura 9, dois objetos (sala 1 e sala 2) criados com base na Classe Sala.

SALA = N° 1 SALA = N° 2

Largura = 3,00 Largura = 3,50


Comprimento = 3,00 Comprimento = 4,00

Área Área

Figura 9 Objetos do tipo Sala.

Observe que os dois objetos Sala podem ser utilizados como parte integrante de um ob-
jeto do tipo Casa Comercial, que foi criado com base na Classe Casa. Assim, enquanto o objeto
agregador (por exemplo, Casa Comercial) existir, também existirão os objetos Sala 1 e Sala 2.
Se o sistema desejar informar os dados sobre a área útil do imóvel, o objeto Casa poderá
enviar uma mensagem aos objetos agregados para calcular a sua área. Os detalhes relacionados
ao cálculo de área estão “encapsulados” na Classe Sala, porém a execução do método Área re-
tornará, como informação, o valor da área da sala.
Na Composição, os objetos do tipo Sala estão vinculados ao objeto Casa, porém, se este
deixar de existir quando for destruído, também deixarão de existir os objetos Sala que estão a
ele relacionados.
34 © Programação Orientada a Objetos

CASA MORADOR
TEM
Sala
Quarto Nome
AGREGAÇÃO Idade
Cozinha
Banheiro
Trabalhar
Reformar
Mobiliar
Limpar
Figura 10 Agregação.

A Figura 10 exibe duas classes relacionadas por meio de Agregação. Nela, a Classe Casa
(agregadora) utiliza a Classe Morador (agregada) como parte de sua definição.
Os detalhes da implementação da Classe Morador, conforme Figura 10, estão descritos den-
tro da Classe Morador e, portanto, podemos dizer que suas definições são visíveis e pertinentes
apenas à própria classe (Encapsulamento). Contudo, a Classe Casa poderá utilizá-la como parte
de sua definição. Nesse caso, entendemos que a Classe Casa possui Morador como parte de sua
definição e, assim, poderá criar (instanciar) vários objetos do tipo Morador para sua definição.
Diferentemente da situação ocorrida na Composição, na Agregação os objetos vinculados
(agregados) podem existir independentemente da classe que os contém (agregadora). Quando
a classe agregadora deixar de existir, os objetos agregados permanecem vivos e podem ser agre-
gados a outros objetos do tipo Casa.
Tanto na agregação como na Composição, um objeto poderá ter vínculo com vários ob-
jetos de outras classes, visto que a quantidade de objetos vinculados é definida no momento
da modelagem do sistema. As classes também poderão relacionar-se com mais de uma classe.
Ressaltamos que a modelagem do sistema indica quais serão as classes que farão parte das de-
finições de outras classes, bem como qual será a quantidade de objetos vinculados.

Associação
Além da Herança e da Agregação, a Orientação a Objetos oferece mais um tipo de relacio-
namento entre classes: a Associação. Em uma associação, as classes envolvidas não apresentam
estruturas comuns como acontece na Herança e na Agregação. O que se observa normalmente
é que, na Associação, as classes relacionadas apresentam estruturas distintas e o tipo de relação
está vinculado a alguma regra de negócio do sistema.

CASA PESSOA
aluga
Sala Nome
Quarto ASSOCIAÇÃO DataNascimento
Cozinha Profissão
Banheiro
Trabalhar
Reformar
Mobiliar
Limpar
Figura 11 Associação.

Centro Universitário Claretiano


© Orientação a Objetos 35

No exemplo da Figura 11, uma pessoa poderá alugar uma casa. Nesse sentido, Casa e
Pessoa são classes diferentes e não representam objetos de características ou comportamentos
comuns ou semelhantes. A relação entre ambos acontece apenas porque o vínculo entre eles
existe como uma regra de negócio do sistema a ser modelado.
Portanto, para que o vínculo de associação aconteça, é necessário que os objetos associa-
dos sejam criados antes da criação do relacionamento. Da mesma forma, se uma associação dei-
xar de existir, os objetos que estavam associados permanecem no sistema, podendo até mesmo
estabelecer novas associações com outros objetos.

Integrando os conceitos
A Figura 12, denominada Diagrama de Classes, ilustra os conceitos de Herança, Agregação
e Associação. Esse diagrama é parte da etapa de modelagem da Orientação a Objetos, desen-
volvida com base na UML.

CASA PESSOA
aluga
Sala Nome
Quarto ASSOCIAÇÃO DataNascimento
Cozinha Profissão
Banheiro
Trabalhar
Reformar
Mobiliar
Limpar
CO

te
m
M
PO
SI

1 .. N
ÇÃ

RESIDENCIAL COMERCIAL
O

SALA
Piscina Vaga
Sauna Largura
Luminoso
Quadra Comprimento
Limpar Piscina Ligar Luminoso
Área
Figura 12 Diagrama de Classes (UML).

6. EXEMPLO PRÁTICO
Para aprimorarmos os conceitos tratados nesta unidade, vamos exemplificar com uma
nova situação. Consideremos que uma faculdade deseje desenvolver um sistema para controlar
as orientações e defesas dos Trabalhos de Conclusão de Curso (TCC). Para isso, utilizará a Orien-
tação a Objetos para identificar os principais conceitos que, posteriormente, serão implementa-
dos usando uma linguagem orientada a objetos.
Destacamos as seguintes funcionalidades referentes ao sistema de controle de orienta-
ções de TCC:
a) armazenamento de dados de alunos, professores e cursos da instituição;
b) identificação dos professores que trabalham como coordenadores de curso;
c) registro das matrículas dos alunos nos cursos;
36 © Programação Orientada a Objetos

d) armazenamento dos dados sobre as orientações de TCC;


e) cadastramento das informações sobre as bancas de defesa de TCC realizadas na insti-
tuição.
Com base nas funcionalidades descritas, iniciamos o processo de abstração para identificar os
objetos envolvidos no novo sistema. Após uma breve análise, identificamos os seguintes objetos:
a) aluno;
b) professor;
c) curso;
d) coordenador;
e) TCC;
f) banca.
Muitas dúvidas devem surgir no momento da abstração dos objetos, pois essa é uma difi-
culdade comum para aqueles que estão iniciando o aprendizado dos conceitos da Orientação a
Objetos. Note que os objetos sempre possuirão informações que os descrevem (por exemplo, o
objeto Aluno possui as seguintes características: nome, ra, telefone, endereço etc.).
Assim, no momento da abstração e da identificação dos objetos, você pode se orientar
procurando informações que deverão de algum modo aparecer em seu sistema. Ao analisar
quem é o “dono” da informação, você descobre o objeto que possui aquela característica.
Sabendo que objetos podem ser representados por uma classe que reúne em sua estru-
tura as características e os comportamentos comuns a eles, detalhamos, a seguir, as classes ini-
cialmente identificadas, por meio de um diagrama de classes da representação UML (Figura 13).
Note que nesse momento representamos apenas as características como atributos nas classes,
enquanto os comportamentos serão identificados posteriormente, quando estivermos anali-
sando as relações existentes entre as classes.

Aluno Professor Curso

nome nome nome


ra titulacao sigla
email area

Coordenador Tcc Banca


titulo
ramal ano data
cargaHoraria situacao parecer
notas

Figura 13 Classes (UML).

Note que apenas algumas características foram identificadas em cada uma das classes. O
intuito nesse exemplo é praticar os conceitos da Orientação a Objetos; por isso, simplificamos
um pouco a definição das classes. Lembre-se de que os nomes das classes, seus atributos e
métodos devem ser identificados sem o uso de acentuação e símbolos especiais, pois posterior-
mente serão codificados usando uma linguagem de programação. Nas linguagens de programa-
ção, incluindo Java, o uso de acentuação e de símbolos especiais não é permitido.

Centro Universitário Claretiano


© Orientação a Objetos 37

Uma vez que foram identificadas as classes, vamos agora analisar as relações entre elas.
Destacamos as seguintes:
• Herança.
• Agregação/Composição.
• Associação.
Observamos que a Herança é a relação que permite definir uma nova classe usando como
base as definições já existentes em outra classe. A pergunta-chave que podemos fazer para auxi-
liar na identificação da herança entre classes é se um objeto da classe A “é um” objeto da classe
B. Assim, ao analisarmos as classes identificadas na Figura 13, notamos que existe uma relação
de herança entre as classes Professor e Coordenador. Isto é, um Coordenador “é um” Professor.
Expandindo um pouco mais essa análise, constatamos que todo Coordenador “é um” Professor,
mas nem todo Professor “é um” Coordenador.
Por meio da herança entre as classes Professor e Coordenador, temos que a superclasse
Professor estende suas definições para a subclasse Coordenador. A classe Coordenador herda
todas as características existentes na classe Professor, o que possibilita o reaproveitamento de
código e a facilidade de manutenção de código.

Professor Coordenador
nome ramal
titulacao cargaHoraria
email

Figura 14 Herança entre as Classes Professor e Coordenador (UML).

Analisemos agora a relação de Agregação/Composição. Esta relação possibilita utilizar


como parte da definição de uma classe outra(s) classe(s) já existente(s). A maior motivação de
seu uso é permitir a reutilização de classes. Em nosso sistema, podemos identificar a relação de
agregação entre a classe Banca e a classe Professor (Figura 15), pois os Objetos Banca e Profes-
sor podem existir independentemente uns dos outros. A Composição não é definida, nesse caso,
porque os objetos podem existir separados uns dos outros.

Banca Professor

data nome
parecer titulacao
email
atribuirProfessor
Figura 15 Agregação entre as Classes Banca e Professor (UML).

A Agregação entre Banca e Professor pode ser expressa pela indicação de que uma Banca
possui como parte de sua definição a participação de dois Professores. A relação parte-todo
caracteriza a agregação entre classes. Professor é parte da definição de uma Banca. Note que
existe a indicação, na seta de agregação, de que dois Professores participam da agregação com
a classe Banca (Figura 15).
38 © Programação Orientada a Objetos

Como reflexo da agregação entre classes, novos comportamentos podem ser adicionados
às classes existentes. Assim, adicionamos o método “atribuirProfessor” à classe Banca, que será
responsável por criar o vínculo entre as classes Banca e Professor (Figura 15). A quantidade
de comportamentos adicionados às classes depende única e exclusivamente da análise que se
realiza. É importante ressaltar que uma vez adicionado um comportamento a uma classe, este
deverá ser codificado posteriormente no momento da programação orientada a objetos.
Outra agregação que podemos destacar é a que ocorre entre Curso e Coordenador e que
um Coordenador está relacionado a um Curso. Assim, a classe agregadora Curso possui como
parte de sua definição o Coordenador que o coordena. Note que, quando apenas um objeto
participa da relação, não precisamos identificar a quantidade junto à seta de agregação do dia-
grama de classes da UML.
Como reflexo da agregação entre Curso e Coordenador, adicionamos um novo comporta-
mento à classe Curso chamado: “trocarCoordenador”. Este será representado no diagrama de
classes (Figura 16) em forma de um método, quando a classe Curso for codificada usando uma
linguagem orientada a objetos.

Curso Coordenador
nome
sigla ramal
area cargaHoraria

trocarCoordenador
Figura 16 Agregação entre as Classes Curso e Coordenador (UML).

Outra agregação existente no sistema relaciona a classe Tcc com a classe Aluno, indicando
que um Tcc utiliza como parte de sua definição o aluno responsável pelo trabalho. Como forma
de permitir que um Aluno seja vinculado ao Tcc, adicionamos o comportamento “vincularAluno”
na classe Tcc (Figura 17).

Tcc Aluno
titulo
ano nome
situacao ra
notas
vincularAluno
Figura 17 Agregação entre as Classes Tcc e Aluno (UML).

A composição é outra relação existente no sistema que relaciona a classe Tcc com a classe
Banca, indicando que um Tcc utiliza como parte de sua definição a banca que examinará o tra-
balho. Na Composição, um objeto do tipo Banca é relacionado ao objeto do tipo Tcc, e o objeto
Banca só existirá se estiver vinculado ao objeto Tcc. Quando o objeto Tcc deixar de existir, o ob-
jeto Banca também será destruído. Como forma de permitir que uma Banca seja vinculada ao
Tcc, adicionamos o comportamento “vincularBanca” na classe Tcc (Figura 18).

Centro Universitário Claretiano


© Orientação a Objetos 39

Tcc Banca
titulo
ano data
situacao parecer
notas
vincularAluno
vincularBanca atribuirProfessor
Figura 18 Agregação entre as Classes Tcc e Banca (UML).

Por fim, analisaremos a relação de Associação. A associação permite representar as rela-


ções entre objetos que apresentam estruturas e comportamentos diferenciados, e não se carac-
terizam por vínculos do tipo “parte-todo” (agregação ou Composição) e “é um” (herança). Como
exemplo, destaca-se a relação entre as classes Aluno e Curso, em que um aluno se matricula em
um determinado Curso.

Aluno Curso
nome
nome sigla
ra area
fazMatricula trocarCoordenador
Figura 19 Associação entre as Classes Aluno e Curso (UML).

A associação matrícula pode resultar na criação de comportamentos nas duas classes re-
lacionadas. Note que podemos criar um novo comportamento na classe Aluno chamado “faz-
Matricula”, que se encarregará de estabelecer a verdadeira relação entre os objetos das classes
relacionadas (Figura 19).
Por fim, apresentamos na Figura 20 o diagrama de classes completo, resultante da análise
orientada a objetos do sistema de controle de orientações e defesas de TCC:

Aluno Curso Coordenador


matricula nome
nome ramal
sigla cargaHoraria
ra area
fazMatricula trocarCoordenador

Tcc Banca Professor


titulo nome
ano data
parecer titulacao
situacao email
notas
vincularAluno atribuirProfessor
Figura 20 Diagrama de Classes do sistema de orientações e defesas de TCC (UML).
40 © Programação Orientada a Objetos

7. QUESTÕES AUTOAVALIATIVAS
Sugerimos que você procure responder, discutir e comentar as questões a seguir que tra-
tam da temática desenvolvida nesta unidade.
A autoavaliação pode ser uma ferramenta importante para você testar o seu desempenho.
Se você encontrar dificuldades em responder a essas questões, procure revisar os conteúdos
estudados para sanar as suas dúvidas. Esse é o momento ideal para que você faça uma revisão
desta unidade. Lembre-se de que, na Educação a Distância, a construção do conhecimento ocor-
re de forma cooperativa e colaborativa; compartilhe, portanto, as suas descobertas com os seus
colegas.
Confira, a seguir, as questões propostas para verificar o seu desempenho no estudo desta
unidade:
1) Na Orientação a Objetos, como você define a relação existente entre os conceitos de classe e objeto?

2) Considerando o sistema de uma faculdade, defina pelo menos cinco características e três comportamentos para
cada um dos seguintes objetos: Funcionário, Departamento e Projeto.

3) Considerando as classes Carro, Casa, Pessoa, Moto, Veículo, Pneu, Proprietário e Locatário, crie um diagrama
de classes que permita agrupar todas as classes representadas por tais objetos em apenas um único diagrama
de classes da UML.

4) Sabemos que a Orientação a Objetos possui uma série de conceitos importantes. Cite e defina pelo menos qua-
tro conceitos relacionados exclusivamente à Orientação a Objetos.

5) Qual é a importância do conceito de Encapsulamento da Orientação a Objetos para a programação de um sis-


tema? Destaque pelo menos uma vantagem e uma desvantagem no uso do Encapsulamento para a codificação,
usando uma linguagem orientada a objetos.

Gabarito
Depois de responder às questões autoavaliativas, é importante que você confira o seu
desempenho, a fim de que possa saber se é preciso retomar o estudo desta unidade.
1) Para responder a esta pergunta você terá que primeiro definir separadamente cada um dos conceitos de classe
e objeto. Assim, em relação à Orientação a Objetos, o que são objetos? Objetos são abstrações de informações
do mundo real para o mundo computacional que possuem características e comportamentos. Um objeto pode
ser algo que possui existência física ou apenas um conceito não tangível. Um objeto possui similaridade com
uma infinidade de outros objetos semelhantes a ele. Quando analisamos todos os objetos similares e identifi-
camos neles suas características e comportamentos comuns, encontramos a Classe que representa esse grupo
de objetos.
Classes são representações que possuem características e comportamentos comuns a um conjunto de objetos.
Uma classe é definida como um modelo para os objetos que ela representa ou define.
Uma vez que definimos os conceitos de classe e objeto, vamos agora responder à questão inicial. A relação existen-
te entre classe e objeto é que uma classe é identificada como um molde para objetos que ela representa, e todos
os objetos criados com base na classe possuirão características e comportamentos idênticos.

2) Nesta questão, você deverá abstrair informações relacionadas ao sistema de uma faculdade. Não existem res-
postas corretas ou incorretas, pois não definimos o escopo do projeto. Use sua criatividade para identificar as
informações mais relevantes ao sistema fictício proposto. Acompanhe, a seguir, algumas características e com-
portamentos possíveis para essa abstração.
Funcionário: Características: Nome, Código Funcionário, Telefone, Endereço, Data de Contratação. Comportamen-
tos: chefiaDepartamento, trabalhaProjeto e coordenaProjeto.
Departamento: Nome, Sigla, Descrição, Data de Criação e Localização. Comportamentos: adicionaFuncionário,
vinculaProjeto e trocaDiretor.
Projeto: Código, Descrição, Data de Início, Data de Término e Situação. Comportamentos: vinculaFuncionario, as-
sociaDepartamento e finalizaProjeto.

Centro Universitário Claretiano


© Orientação a Objetos 41

3) Comece analisando cuidadosamente os objetos citados na questão. Busque identificar diferentes tipos de re-
lações existentes entre eles. A figura, a seguir, exibe um diagrama de classes da UML que permite representar
todos os conceitos envolvidos na questão. Note como as relações de herança, agregação e associação foram
indicadas no diagrama.

Veículo

aluga

possui Inquilino

Carro Moto Proprietário

4 2

Pneu Pessoa

4) Nessa questão você deverá indicar quatro conceitos importantes relacionados à orientação a objetos. A seguir,
citamos sete conceitos. Quanto mais conceitos você citar, mais estará ciente da conceituação existente.
– Encapsulamento: técnica para minimizar interdependências entre objetos, por meio da definição de métodos
que possibilitam o acesso aos dados do objeto. Assim, mudanças na definição e na implementação de uma classe,
desde que preservem os métodos de acesso, não afetam outras classes presentes no restante do sistema.
– Abstração: mecanismo utilizado na análise de um domínio de aplicação em que se observa a realidade e dela se
identificam informações consideradas essenciais para uma aplicação, excluindo todos os aspectos julgados irrele-
vantes.
– Classificação: ação de criar classes por meio da abstração de conceitos existentes em objetos que possuem ca-
racterísticas e comportamentos iguais.
– Instanciação: corresponde à ação de criar objetos com base em uma classe. Todo objeto criado é uma instância
de uma classe.
– Herança: mecanismo que permite definir uma nova classe (subclasse) a partir de uma já existente (superclas-
se). Ao se estabelecer uma subclasse, ela herda todas as características da superclasse, ou seja, a especificação
dos atributos e dos métodos da superclasse passa a fazer parte da especificação dos atributos e dos métodos da
subclasse. Assim, a subclasse pode adicionar novos métodos, como também reescrever os métodos herdados da
superclasse. A relação estabelecida é chamada de “é do tipo”, em que uma subclasse “é do tipo” da superclasse.
– Agregação: tipo de relação existente entre classes que permite a reutilização de classes já existentes para com-
por classes de estruturas mais complexas. A relação estabelecida é do tipo “parte-todo”, em que se criam classes
(agregadoras) que se utilizam de outras classes (agregadas) como parte de sua definição.
– Associação: outro tipo de relação existente entre classes. As classes envolvidas não apresentam estruturas co-
muns como acontece na Herança e na Agregação. O que se observa normalmente é que, na Associação, as classes
relacionadas apresentam estruturas distintas, e o tipo de relação está vinculado a alguma regra de negócio do
sistema.
42 © Programação Orientada a Objetos

5) A
o analisar a importância do Encapsulamento para um sistema, você deve considerar que o Encapsulamento é
uma técnica importante para minimizar interdependências entre objetos, por meio do uso de modificadores de
acesso que restringem o acesso direto a detalhes internos do objeto (atributos e métodos) e que compartilham
acesso a eles por meio, principalmente, de métodos de acesso. A importância desse conceito para a programa-
ção de um sistema é que as mudanças na definição e na implementação de uma classe, desde que preservados
os métodos de acesso, não afetam outras classes presentes no restante do sistema.
Vantagem: mais robustez no sistema, pois a menor interdependência entre classes resulta em uma menor incidên-
cia de erros quando os códigos das classes sofrem modificações.
Desvantagem: códigos mais complexos e de maior tamanho em virtude da utilização de modificadores de acesso
de uso restrito sobre atributos e criação de métodos de acesso.

8. CONSIDERAÇÕES
Os conceitos e definições abordados nesta unidade serão complementados no decorrer
do estudo desta obra, cujo foco estará voltado à programação e à modelagem orientadas a ob-
jetos. Objetos, Classes, Generalização, Especialização, Encapsulamento, Polimorfismo, Herança,
Agregação, Composição e Associação são conceitos que fazem parte do vocabulário da Orienta-
ção a Objetos.
Na próxima unidade, será apresentada a linguagem de programação Java, que será utiliza-
da, posteriormente, na programação dos conceitos estudados nesta unidade. Participe! Interaja
com seus colegas de curso e com seu tutor. Lembre-se de que é fundamental que você entregue
as atividades nas datas previstas.

9. E-REFERÊNCIAS
BLUEJ. The Interactive Java Environment. Disponível em:<http://www.bluej.org>. Acesso em: 09 dez. 2010.
SUN DEVELOPERS NETWORK (SDN). Sun Microsystems. Disponível em:<http://java.sun.com>. Acesso em: 09 dez. 2010.

10. REFERÊNCIAS BIBLIOGRÁFICAS


CADENHEAD, R.; LEMAY, L. Aprenda em 21 dias Java 2. Tradução de Daniel Vieira e Ana Beatriz Tavares. 4. ed. Rio de Janeiro:
Elsevier, 2005.
DEITEL, H. M.; DEITEL, P. J. Java: como programar. Tradução de Edson Furmankiewicz. 6. ed. São Paulo: Pearson Prentice Hall,
2007.
BOOCH, G.; RUMBAUGH, J.; JACOBSON, I. UML: guia do usuário. Tradução de Fábio Freitas da Silva et al. 2 ed. rev. atual. Rio de
Janeiro: Elsevier, 2005.

Centro Universitário Claretiano


EAD
Ambiente de Programação
Java

1. OBJETIVOS
• Compreender alguns conceitos introdutórios sobre a linguagem Java.
• Configurar o ambiente de desenvolvimento Java.
• Criar classes e objetos utilizando Java.

2. CONTEÚDOS
• Introdução da linguagem Java.
• Ambiente de desenvolvimento Java.
• Ferramenta visual de programação Java.
• Classificação e instanciação em Java.

3. ORIENTAÇÃO PARA O ESTUDO DA UNIDADE


Antes de iniciar o estudo desta unidade, é importante que você leia a orientação a se-
guir:
1) Recomendamos a leitura por várias vezes dos textos deste material para fixar seus
conteúdos. Para isso, recomendamos realizar pequenos apontamos com a finalidade
de comparar e aprofundar pontos de destaque, utilizando-se das fontes aqui elenca-
das e que já indicamos como indispensáveis para o estudo deste tema.
44 © Programação Orientada a Objetos

4. INTRODUÇÃO À UNIDADE
Na unidade anterior, você teve a oportunidade de compreender alguns conceitos básicos
da Orientação a Objetos (OO) e de conhecer as diferentes formas de relacionamento entre ob-
jetos.
Nesta unidade será apresentada a linguagem de programação Java e você poderá conhe-
cer um pouco sobre sua origem e suas características. Aprenderá a configurar o ambiente para
desenvolvimento Java e a utilizar uma ferramenta visual de programação Java. E como forma de
praticar e compreender os conceitos estudados na Unidade 1, você irá criar o primeiro progra-
ma em Java.
Não se preocupe com a linguagem Java, pois nossa principal preocupação é que você co-
nheça o ambiente de programação Java. Os detalhes específicos sobre a linguagem Java serão
apresentados na Unidade 3.
Bom estudo!

5. CONCEITOS
Java é uma linguagem de programação orientada a objetos desenvolvida pela Sun Mi-
crosystems. Modelada depois de C++, a linguagem Java foi projetada para ser pequena, simples
e portável a todas as plataformas e sistemas operacionais, tanto o código-fonte como os biná-
rios. Essa portabilidade é obtida pelo fato de a linguagem ser interpretada, ou seja, o compilador
gera um código independente de máquina chamado bytecode.
Um programa feito na linguagem Java é compilado, gerando então um arquivo em bytecode
(código binário). Esse bytecode possui neutralidade de arquitetura ("independente de platafor-
ma") e não está completo até ser interpretado pelo ambiente de execução Java. Como cada am-
biente de execução Java é designado para uma plataforma específica, o produto final funcionará
apenas nessa plataforma específica.
A parte final da compilação é realizada por um dispositivo específico da plataforma, que
é mantido pelo usuário final, liberando assim a responsabilidade de manter várias fontes para
diversas plataformas. A interpretação, também, permite que os dados sejam incorporados em
tempo de execução, que é fundamento do comportamento dinâmico da linguagem Java.
No momento da execução, o arquivo gerado bytecode é interpretado por uma máquina
virtual instalada na máquina. Para portar Java para uma arquitetura de hardware e sistema ope-
racional específica, basta instalar a máquina virtual (interpretador). Um programa Java não tem
contato com o computador real, ele conhece apenas a máquina virtual. Logo, os programas Java
são independentes de plataforma.

Programas Java Compilados


JVM (Máquina Virtual Java)
Hardware e Sistema Operacional
Figura 1 Estrutura de funcionamento de aplicações Java.

Para compreender melhor, acompanhe, a seguir, a explicação da Máquina Virtual Java


(JVM).

Centro Universitário Claretiano


© Ambiente de Programação Java 45

Máquina Virtual Java (JVM)


A máquina virtual Java (JVM – Java Virtual Machine) é um software que simula um compu-
tador. Ela é "virtual" porque é geralmente implementada em softwares no topo da plataforma
de hardware "real" e no sistema operacional. Todo programa Java é compilado pela JVM. Entre-
tanto, a JVM precisa ser implementada em uma plataforma particular antes de ser compilada
pelo Java para rodar nesta plataforma.
A máquina virtual determina o que os programas Java podem ou não fazer. No entanto,
os programas escritos em linguagens compiladas, como C ou C++, são executados diretamente
pelo sistema operacional. Dessa forma, eles têm acesso direto a todos os recursos do sistema,
incluindo memória e sistema de arquivos. A máquina virtual age como um firewall (barreira)
entre o computador e o programa Java. Um programa nunca acessa os dispositivos de entrada e
saída, o sistema de arquivos ou mesmo a memória do seu computador, ele pede que a máquina
virtual faça isso. Tal característica confere mais segurança na execução de programas Java.
Qualquer desenvolvedor que esteja no mercado de softwares deseja desenvolver versões
de seus aplicativos que possam rodar em PCs, Macs e workstations UNIX. Está cada vez mais di-
fícil produzir softwares para todas as plataformas existentes. Se o aplicativo for escrito em Java,
porém, ele pode rodar em todas as plataformas atuais e em outras que venham a surgir.
A portabilidade da linguagem Java está relacionada ao fato de a linguagem ser interpre-
tada e definir um formato de bytecode padronizado e neutro em relação às arquiteturas. En-
tretanto, Java vai ainda mais longe, assegurando que não existem aspectos "dependentes de
implementação" na especificação da linguagem.
Assim, Java especifica explicitamente o tamanho de cada um dos tipos de dados primiti-
vos, bem como seu comportamento aritmético. Por essas características o lema é: “Escreva uma
vez, rode em qualquer lugar” (“Write once, run anywhere”), o qual se tornou uma das marcas
registradas de Java.

6. AMBIENTE DE DESENVOLVIMENTO JAVA


Para iniciar o desenvolvimento em Java, precisamos do Kit de Desenvolvimento Java ou
JDK (Java Development Kit), que é composto basicamente pelo compilador da linguagem, pelas
interfaces de programação (Java API) e pela JVM para a execução das aplicações.
Assim que um programa Java é compilado, ele está pronto para ser executado em qualquer
hardware que tenha uma JVM e uma API Java de versão igual ou superior àquela utilizada na com-
pilação do programa fonte. A esse conjunto dá-se o nome de JRE (Java Runtime Environment ou
Ambiente de Execução Java).
Com o intuito de facilitar a compreensão dos conceitos de OO, adotaremos uma ferra-
menta visual chamada BlueJ para auxiliar no desenvolvimento dos códigos da linguagem Java.
Ressaltamos que a linguagem Java não exige o uso de ferramentas, pois o código Java pode ser
escrito em um editor de textos simples (por exemplo: Bloco de notas do Windows), e posterior-
mente compilado e executado por meio de instruções em uma janela de comandos (prompt
do MS-DOS). A adoção de uma ferramenta é sugerida como forma de simplificar o processo de
codificação Java.
Existem várias ferramentas no mercado com suporte à linguagem Java, tais como Eclipse e
NetBeans, porém escolhemos usar a ferramenta BlueJ em razão de suas características para fins
46 © Programação Orientada a Objetos

didáticos. O BlueJ é um projeto da universidade de Kent, na Austrália, que desenvolveu a ferra-


menta com o intuito de auxiliar na prática do estudo da Orientação a Objetos. Ela utiliza como
linguagem de programação a linguagem Java, além de utilizar como formato de representação
visual uma versão simplificada do Diagrama de Classes da UML (Unified Modeling Language).
Para sua melhor compreensão, acompanhe, a seguir, a configuração do ambiente de de-
senvolvimento Java. Antes de realizar a instalação da ferramenta BlueJ, você deverá primeiro
providenciar a instalação do JDK em sua máquina de desenvolvimento. Esse processo é impor-
tante, pois o BlueJ, ao ser executado, irá selecionar o JDK existente no computador. Acompanhe
a instalação na Configuração do ambiente de desenvolvimento Java. O processo pode ser orga-
nizado nos seguintes passos:
1) Download do kit de desenvolvimento Java (JDK).
2) Instalação do kit de desenvolvimento Java (JDK).
3) Download da ferramenta BlueJ.
4) Instalação da ferramenta BlueJ.

Configuração do ambiente de desenvolvimento Java


Veja, a seguir, os quatro passos de configuração do ambiente de desenvolvimento Java.
Passo 1 – Download do kit de desenvolvimento Java (JDK)
Inicialmente será necessário obter o JDK compatível com o sistema operacional da sua
máquina de desenvolvimento. Para facilitar esse processo, apresentamos, no Apêndice 1, a se-
quência completa das telas referentes a todo o processo de instalação. Siga os passos atenta-
mente nele descritos e, caso tenha dúvida, entre em contato com seus colegas de curso ou seu
tutor.
Passo 2 – Instalação do kit de desenvolvimento Java (JDK)
Após finalizar o download do JDK no Passo 1, localize o diretório em que o arquivo foi salvo
e execute o programa para iniciar o processo de instalação. Após uma tela inicial de confirmação
de licenças, surgirá a tela de "Custom SetUp”. Neste momento, você poderá indicar o diretório
de instalação de sua preferência. Caso deseje modificar o diretório de instalação, clique no bo-
tão "Change” e digite o novo diretório (por exemplo: C:\Java6). Recomendamos que mantenha
as configurações sugeridas pelo próprio instalador. Continue acompanhando o processo de ins-
talação no Apêndice 1, pois lá você encontrará a sequência completa das telas referentes a todo
o processo de instalação.
Passo 3 – Download da ferramenta BlueJ
Após finalizar a instalação do JDK, realize o download da ferramenta visual BlueJ. Para
facilitar a instalação da ferramenta, apresentamos, no Apêndice 2, a sequência completa das
telas referentes ao processo de download.. Para executar o Passo 4 da instalação da ferramenta
visual BlueJ, consulte o Apêndice 2, pois nele você encontrará a sequência completa do processo
de instalação.
Passo 4 – Instalação da ferramenta BlueJ
Após finalizar o download do BlueJ conforme indicado no Passo 3, localize o diretório em
que o arquivo foi salvo e execute o programa para iniciar o processo de instalação. Recomendamos
que adote as opções sugeridas pelo próprio software de instalação, porém, se for de sua vontade,
você pode realizar alterações como, por exemplo, a escolha do diretório de instalação.

Centro Universitário Claretiano


© Ambiente de Programação Java 47

Parabéns! Após o término dos Passos 1 a 4, você poderá iniciar o uso do ambiente Java em
sua máquina de desenvolvimento.

7. EXECUTANDO PELA PRIMEIRA VEZ A FERRAMENTA BLUEJ


Após finalizar a configuração do ambiente de desenvolvimento Java, vamos iniciar o uso
da ferramenta BlueJ. Para isso, você deve localizar o ícone da ferramenta BlueJ na área de traba-
lho de seu computador e executar o programa com um duplo clique. Outra opção para executar
a aplicação é localizar o programa BlueJ na barra de programas do menu Iniciar.
Ao executar pela primeira vez a ferramenta BlueJ, o aplicativo exibirá a tela de apresenta-
ção (Figura 2) e, em seguida, exibirá a tela de configuração do JDK usado pelo BlueJ (Figura 3).
Você deve selecionar a versão do JDK instalado em seu computador e clicar no botão "Launch”
para iniciar o uso da ferramenta. Essa etapa é importante, pois configura a versão do JDK que
será utilizado para a compilação e execução dos programas Java no BlueJ.

Figura 2 Tela de apresentação do BlueJ.

Figura 3 Configuração do JDK usado pelo BlueJ.


48 © Programação Orientada a Objetos

Ao completar a configuração do JDK no BlueJ, indicada na Figura 3, será exibida a tela


principal da ferramenta (Figura 4). De início, a maioria das opções aparece bloqueada, pois é
necessário criar um projeto para controlar todos os códigos e programas que serão criados. Para
criar um projeto no BlueJ, você deve acessar o menu "Project” e escolher a opção "New Project”
(Novo Projeto).
Ao realizar essa operação, será exibida uma nova janela (Figura 5), em que poderemos
escolher a localização do novo projeto. Você pode optar por criar o projeto em qualquer pasta
de seu computador. Como exemplo, vamos criar um novo projeto chamado “poo” (abreviação
de Programação Orientada Objetos) na pasta raiz do disco local (C:).

Figura 4 Tela principal do BlueJ.

Para isso, selecione o drive C e digite o nome do projeto "poo" na opção "File Name"
(Nome do Arquivo), conforme exemplo exibido na Figura 5. Para confirmar a criação do projeto,
clique no botão "Create” (Criar).

Centro Universitário Claretiano


© Ambiente de Programação Java 49

Figura 5 Criação de um projeto no BlueJ.

Como resultado da criação do projeto "poo", a ferramenta BlueJ criará uma pasta com
nome “poo” localizada no drive C de seu computador. Dentro dessa pasta, serão gravados todos
os códigos e programas desenvolvidos na ferramenta. Sugerimos que você crie diferentes proje-
tos para controlar diferentes aplicações.
Após criar o projeto, a ferramenta BlueJ irá desbloquear toda a área de trabalho, e você
poderá iniciar o desenvolvimento dos programas em Java, conforme demonstra a Figura 6.
Os projetos criados no BlueJ servem para gerenciar os programas que serão criados na
ferramenta. É aconselhável que você crie diferentes projetos para controlar diferentes aplica-
ções. Por exemplo, os códigos de uma aplicação Java, para controle de uma biblioteca escolar,
poderiam ser salvos em um projeto com o nome “biblioteca”, e os códigos de uma aplicação
Java, para controle de matrículas de aluno em disciplinas, poderiam ser salvos em um projeto
de nome “secretaria”. Lembre-se de que você deverá criar diferentes projetos para diferentes
aplicações.
50 © Programação Orientada a Objetos

Figura 6 Tela principal do BlueJ com projeto aberto.

Permaneça com a ferramenta BlueJ em execução, pois iremos, a seguir, criar o primeiro
programa Java.

8. CRIANDO O PRIMEIRO PROGRAMA EM JAVA NO BLUEJ


Agora, vamos iniciar a criação de programas Java usando a ferramenta BlueJ. Na Unidade
1, você aprendeu os principais conceitos relacionados à orientação a objetos. Todos os conceitos
estudados serão abordados usando a linguagem Java. Isso é possível porque a linguagem Java é
uma linguagem do tipo orientada a objetos. Dentre os principais conceitos, destacamos inicial-
mente a Classe e o Objeto.

Classes em Java
Com relação à linguagem Java, podemos afirmar que a representação dos códigos nessa
linguagem é realizada por meio do conceito Classe. Em Java, a Classe é a estrutura responsável
pelo armazenamento dos códigos. Não é possível criar códigos em Java sem utilizar o conceito
de classe. Para exemplificar, vamos utilizar a definição da Classe Casa criada na Unidade 1, con-
forme demonstra a Figura 7.

Centro Universitário Claretiano


© Ambiente de Programação Java 51

CASA

Sala
Quarto
Cozinha
Banheiro

Reformar
Mobiliar
Limpar
Figura 7 Classe Casa. Figura 8 BlueJ: definição da Classe Casa.

Retornando à ferramenta BlueJ, que já está em execução e que utiliza o projeto “poo”
(Figura 7), vamos iniciar com a criação da Classe Casa. Para criar uma classe no BlueJ, você deve
clicar no botão "New Class ...” (Nova Classe), localizado na coluna lateral esquerda da ferra-
menta. Ao clicar sobre o botão, a ferramenta exibirá uma nova janela (Figura 8), que solicitará a
identificação do nome da classe (Class Name) e a escolha do tipo da classe (Class Type). Siga as
orientações conforme indicadas na Figura 8 e clique no botão “Ok” para criar a classe no BlueJ.
Como resultado desse processo de criação, o BlueJ exibirá a classe Casa usando a repre-
sentação visual da classe, conforme o modelo definido pelo diagrama de classes da UML (Figura
9). Cada classe criada no BlueJ terá uma representação visual dentro da ferramenta.

Compilando o código Java


O formato da classe com linhas diagonais indica que ela ainda não foi compilada pelo Java
(Figura 10). Para realizar a compilação da uma classe específica, você deve clicar com o botão
direito do mouse sobre a classe Casa e selecionar a opção “Compile” (Compilar). Outra opção de
compilação é clicar sobre o botão "Compile” (Compilar), localizado na coluna lateral esquerda.
A diferença entre as duas opções de compilação é que a segunda opção irá compilar todas as
classes existentes em seu projeto (nesse caso, no projeto "poo").
Ao término da compilação, se a classe for compilada com sucesso, uma mensagem será
exibida na barra de status, localizada na parte inferior cinza da ferramenta BlueJ, informando:
“Compiling... Done” (Compilação... Realizada). O formato visual da classe compilada com suces-
so também é modificado, e as linhas diagonais não são mais exibidas, conforme demonstra a
Figura 11.
52 © Programação Orientada a Objetos

Figura 9 BlueJ: visualização da classe.

Figura 10 BlueJ: classe não Figura 11 BlueJ: classe


compilada. compilada.

Uma vez que a classe Casa está compilada no BlueJ, podemos começar a criar objetos por
meio de sua declaração. Conforme você estudou na Unidade 1, uma classe é um modelo que
representa os objetos que possuem características e comportamentos similares.
Com relação à orientação a objetos, podemos afirmar que uma classe será um molde
para os objetos que serão criados (ou instanciados) conforme a declaração da classe. Os objetos
criados com base na classe Casa são identificados como objetos do tipo Casa. Assim, antes de
realizarmos alterações no código para representar as características e os comportamentos da
Casa, é necessário criar alguns objetos usando a ferramenta BlueJ.

Centro Universitário Claretiano


© Ambiente de Programação Java 53

Criando um objeto
Para criar objetos com base em uma classe compilada, você deve clicar com o botão
direito do mouse sobre a representação visual da classe Casa (Figura 12) e escolher a opção
“New Casa ()” (Nova Casa). Essa operação abrirá uma nova janela (Figura 13) que solicitará
a informação de "Name of Instance" (Nome da Instância) que corresponde à identificação
(nome) do novo objeto Casa que será criado. Casa, objeto instanciado com base em uma clas-
se, deve receber um nome ou identificação única. Esse nome corresponde, nas linguagens de
programação estruturadas (por exemplo: Pascal), ao nome de uma variável.
Como sugestão, modifique o nome da instância (ou nome do objeto) para "popular", como
uma referência à criação de um objeto Casa correspondente a uma casa simples. Clique sobre
o botão "Ok" para confirmar a criação do objeto. Para cada objeto criado (ou instanciado) no
BlueJ, será exibida, na parte inferior da ferramenta, uma representação visual dos objetos ins-
tanciados em memória (Figura 14).

Figura 12 BlueJ: menu de classe Figura 13 BlueJ: identificação do objeto (ou nome da Figura 14 BlueJ: objeto
compilada. instância). instanciado.

A programação orientada a objetos utiliza a classe como uma forma de representar a abs-
tração das informações a respeito de um determinado conceito. Os objetos criados a partir
de uma classe são armazenados na memória do computador, realizando a alocação de espaço
como se fossem declarações de variáveis.
Muitos alunos que iniciam os estudos da programação orientada a objetos imaginam que
os objetos criados podem ser tocados ou que aparecem no computador como imagens ou algo
visual. Na verdade, os objetos são apenas formas de se trabalhar com conceitos que necessitam
de representação em um sistema computacional. Os objetos serão armazenados na memória
RAM do computador, e seu formato real assemelha-se a uma variável de uma linguagem de
programação.
A ferramenta BlueJ foi desenvolvida com o intuito de facilitar a compreensão dos concei-
tos da programação orientada a objetos. A representação visual, exibida na Figura 14, permite
a percepção de que um objeto foi criado e que está instanciado no sistema. Essa característica
é algo próprio desta ferramenta, pois, caso contrário, nenhuma informação seria visível em re-
lação a um objeto.
Conforme exibido na Figura 14, note que, após o nome do objeto (popular), aparece a re-
ferência ao nome da classe (Casa), a qual serviu de molde para o objeto. Esse tipo de informação
é importante, pois facilita a identificação dos objetos na ferramenta BlueJ.
54 © Programação Orientada a Objetos

Criando outro objeto


Para praticar um pouco mais, vamos criar um novo objeto do tipo Casa. Para isso, clique
novamente com o botão direito do mouse sobre a classe Casa e selecione a opção "New Casa()”
(Figura 12). Como sugestão, utilize o nome “luxo” como o nome da nova instância. Note que
podem ser criados ou instanciados vários objetos com base em uma classe (Figura 15).

Figura 15 BlueJ: Classe Casa e seus objetos instanciados.

A classe serve de molde para os objetos. O que diferencia os obje-


tos casa “popular” e “luxo” são as características declaradas na classe Casa: Sala,
Quarto, Cozinha, Banheiro. A casa "popular" terá uma quantidade menor de cômodos que a
casa "luxo". As características (Sala, Quarto, Cozinha e Banheiro), bem como os comportamen-
tos declarados na classe Casa (Figura 7), ainda não foram implementados na classe Casa no
BlueJ. Para incluí-los na declaração da classe Casa, precisaremos usar a linguagem Java e realizar
as devidas codificações.

Centro Universitário Claretiano


© Ambiente de Programação Java 55

Figura 16 BlueJ: editor de código.

Visualizando o código Java da classe


No BlueJ, para visualizar o código-fonte correspondente a uma classe, você pode clicar
com o botão direito do mouse sobre a classe e executar a opção "Open Editor” (Abrir Editor),
conforme mostra a Figura 12. Outra opção disponível é realizar um clique duplo com o botão
esquerdo do mouse sobre a classe. Como resultado dessa ação, uma nova janela será exibida
(Figura 16) e você poderá visualizar o código-fonte da classe Casa. Verifique, a seguir, a tradução
do código da classe Casa.
56 © Programação Orientada a Objetos

código 1
/**
* Escreva a descrição da classe Casa aqui.
*
Comentários da Classe
* @author (seu nome)
* @version (um número de versão ou uma data)
*/
public class Casa Declaração da Classe
{
// variáveis da instância – substitua o exemplo abaixo com seu próprio código Atributos da
private int x; Classe

/**
* Construtor para objetos da classe Casa Comentários do método
*/
public Casa()
{
// inicie as variáveis de instância método construtor
x = 0;
}

/**
* Um exemplo de um método – substitua esse comentário com o seu próprio
* Comentários do
* @param y um exemplo de um parâmetro para o método método
* @return a soma de x e y
*/
public int sampleMethod(int y)
{ Método
// coloque o seu código aqui (comportamentos)
return x + y;
}
} Fim da Classe

fim código 1

Para todas as classes criadas no BlueJ é gerado esse código inicial padrão que deve ser
modificado para se ajustar às reais necessidades da declaração da classe (Figura 7). Como essa
ferramenta está disponível apenas no idioma inglês, o código-padrão foi traduzido e alguns co-
mentários foram adicionados ao lado direito dele (veja no código anterior a tradução).
Note que, diferentemente dos atributos, os métodos possuem um par de parênteses ao
término de seu nome de identificação. Essa forma de definição se assemelha às declarações de
funções e procedimentos existentes nas linguagens estruturadas (por exemplo: Pascal e C). De
modo similar às funções e aos procedimentos das linguagens estruturadas, os parâmetros po-
dem ser repassados como parte da chamada aos métodos.

Alterando os códigos Java


Para realizarmos a programação referente à classe Casa (Figura 7), são necessárias as se-
guintes modificações indicadas em negrito no código a seguir. Realize tais modificações no có-
digo da classe Casa e refaça a compilação da classe clicando no botão “Compile" existente na
parte superior da janela de edição de código. Neste momento, não se preocupe com os detalhes
relacionados à linguagem Java. Apenas reproduza as mudanças indicadas no código a seguir. Os
detalhes a respeito da linguagem Java serão abordados minuciosamente na Unidade 3. O foco
agora é aprender a utilizar a ferramenta BlueJ.

Centro Universitário Claretiano


© Ambiente de Programação Java 57

código 2
/**
* Classe Casa
*
* @author (seu nome)
* @version (um número de versão ou uma data)
*/
public class Casa
{
1
// variáveis da instância que representam as características da Casa Atributos da classe
private int sala, quarto, cozinha, banheiro; (características)

/**
* Método Construtor responsável por criar objetos do tipo Casa
*/
public Casa(int sala, int quarto, int cozinha, int banheiro)
{
Método Construtor
// atribui valores para as variáveis da instância (objeto)
(cria objetos do tipo casa)
this.sala = sala;
this.quarto = quarto;
this.cozinha = cozinha; 2
this.banheiro = banheiro;
}

/**
* Método que exibe informações sobre a Casa
*/
public void exibeInformacoes( ) 3 Método exibeInformacoes ( )
{
(permite visualizar as características
System.out.println(“Essa casa possui:”);
dos objetos)
System.out.println(“Quarto(s): ”+quarto);
System.out.println(“Sala(s): ”+sala);
(Comportamentos)
System.out.println(“Cozinha(s) : ” + cozinha);
System.out.println(“Banheiro(s) : ”+banheiro);
}
}

fim código 2

Dentre as modificações realizadas no código, destacamos:

As características indicadas na declaração da classe Casa (Figura 7) tornaram-se os atri-


1 butos na codificação da classe na linguagem Java. Utilizamos o tipo int para representar uma
informação numérica, de modo que represente a quantidade de cômodos da casa.

O método construtor da classe foi modificado com o intuito de receber informações


2 referentes aos novos objetos que serão criados por meio de sua execução. O método cons-
trutor tem como função principal realizar a alocação de memória suficiente para armazenar
o objeto. Outra função do método construtor é atribuir os valores iniciais aos atributos dos
objetos. Essa atribuição é realizada utilizando as informações recebidas por meio de parâme-
tros do método construtor. Na linguagem Java, o nome do método construtor é o mesmo do
nome da Classe.

O método “exibeInformacoes” foi adicionado com o intuito de possibilitar a visualiza-


3 ção das informações contidas nos atributos dos objetos Casa. Esse método corresponde a um
comportamento presente aos objetos Casa e pode fazer parte da declaração da classe Casa.
Cada comportamento indicado na classe Casa será traduzido como um método no momento
de sua codificação.
58 © Programação Orientada a Objetos

Com o resultado das modificações realizadas e após a compilação da classe Casa,


poderemos então criar objetos usando a nova declaração do método construtor. Clique
com o botão direito do mouse sobre a classe Casa (Figura 17) e note como a assinatura
do método de criação de novos objetos está diferente da forma anterior. Essa mudança
ocorreu porque o código do método construtor foi modificado e o formato anterior não
existe mais.

Novo método construtor


Após clicar com o botão direito do mouse sobre a classe Casa, execute a opção
"New Casa (int sala, int quarto, int cozinha, int banheiro)” (Figura 17). Ao executar o
método, uma nova janela será exibida (Figura 18), e as informações correspondentes
aos novos parâmetros do método construtor necessitarão ser repassadas. Orientamos
que realize agora a criação de dois objetos seguindo as indicações repassadas conforme
as Figuras 19 e 20.

Figura 17 BlueJ: novo menu da classe compilada.

Figura 18 BlueJ: identificação do objeto (ou nome da instância).

Centro Universitário Claretiano


© Ambiente de Programação Java 59

Figura 19 BlueJ: novo objeto – popular.

Figura 20 BlueJ: novo objeto – luxo.

“Inspecionando” os objetos
Como resultado do processo de criação dos objetos “popular” e “luxo”, você obteve a ins-
tanciação de dois objetos dentro da ferramenta BlueJ.
No BlueJ, para visualizarmos por completo as características de um objeto, você deve cli-
car com o botão direito do mouse sobre um objeto e executar a opção "Inspect” (Inspecionar),
conforme mostra a Figura 21.
60 © Programação Orientada a Objetos

Como resultado dessa ação, todas as informações referentes aos atributos (característi-
cas) do objeto serão exibidas. Faça esse procedimento sobre os objetos “popular” e “luxo” e
veja como os objetos possuem características diferentes e se mantêm separados uns dos outros
(Figura 22). Cada objeto possui um armazenamento em memória distinto dos demais objetos, o
que possibilita a representação de vários objetos diferentes ao mesmo tempo.

Figura 21 BlueJ: menu sobre objeto do tipo Casa.

Figura 22 BlueJ: inspect sobre os Objetos Popular e Luxo.

Um aspecto importante é que todos os objetos possuem exatamente as mesmas carac-


terísticas (atributos) e comportamentos (métodos), conforme a codificação realizada na classe.
Tal situação é garantida pelo fato de a classe representar um grupo de objetos que possuem
características e comportamentos comuns.

Executando métodos sobre os objetos


Agora que os objetos já estão criados, vamos invocar métodos sobre eles. Para isso, reco-
mendamos que clique com o botão direito do mouse sobre o objeto "popular" e execute o mé-
todo "exibeInformacoes()” (Figura 21). Como resultado dessa ação, o Java executará o método
sobre o objeto que recebeu a invocação.
Nesse exemplo, o objeto casa "popular" será a referência para a execução do método
“exibeInformacoes()” e, portanto, os atributos referenciados no método serão os correspondentes
ao objeto casa "popular". O método “exibeInformacoes()” utiliza o comando “System.out.println"
para enviar informações de texto e dos valores dos atributos para o terminal do BlueJ, responsável
por exibir as mensagens em formato texto (Figura 23).

Centro Universitário Claretiano


© Ambiente de Programação Java 61

Figura 23 BlueJ: terminal de mensagens.

Você poderá executar métodos que estejam codificados na classe em que os objetos foram
instanciados. Cada método, usando a codificação em Java, pode realizar ações e tarefas diferen-
tes envolvendo, principalmente, os atributos do objeto que recebeu a invocação do método.
Cada objeto possui um tempo de vida e assim como foi criado, também pode ser destru-
ído. Para realizar essa ação, clique com o botão direito do mouse sobre o objeto e execute a
opção "Remove” (Remover) para destruir o objeto (Figura 21). A ação de destruir um objeto tem
como significado o término do uso do objeto e a consequente liberação de espaço de memória
da máquina para futuras alocações com outros objetos.
Para melhorar seu aprendizado, recomendamos que você refaça as etapas aprendidas no
BlueJ usando outra classe. Observe como a representação visual adotada pelo diagrama de classes
da UML reflete na forma pela qual a classe é implementada no BlueJ usando a linguagem Java.

9. EXEMPLO PRÁTICO
Nesta unidade, vamos iniciar a codificação das classes definidas no exemplo prático da
Unidade 1. Usaremos como base o diagrama de classes do sistema de controle de orientações e
defesas dos Trabalhos de Conclusão de Curso (TCC) (Figura 24).

Aluno Curso Coordenador


nome ramal
nome sigla
ra cargaHoraria
area

Tcc Banca Professor


titulo nome
ano data
parecer titulacao
situacao email
notas

Figura 24 Diagrama de Classes do sistema de orientações e defesas de TCC (UML).


62 © Programação Orientada a Objetos

Nesta Unidade 2, você aprendeu a criar classes em linguagem Java usando a ferramenta
BlueJ. É importante ressaltar que ainda não estudamos a forma pela qual a linguagem Java
representa as relações de herança, agregação e associação. Assim, neste momento, nossa im-
plementação será apenas focada na criação das classes que foram identificadas no processo da
modelagem orientada a objetos da Unidade 1. Deixaremos para a Unidade 4 a codificação dos
métodos que permitem relacionar as classes.
Vamos agora executar a ferramenta BlueJ. De início, serão exibidas as classes que foram
criadas dentro do projeto "poo". Como regra-padrão, o BlueJ sempre abre o último projeto que
foi utilizado. Para não confundirmos a nova implementação com as classes já existentes, vamos
definir um novo projeto chamado "tcc". Você pode fechar o projeto atual acessando o menu
"Project” (Projeto) e escolhendo a opção "Close” (Fechar). Essa ação resultará no fechamento
do projeto atual e exibirá a tela inicial do BlueJ (tela cinza).
Para criar um novo projeto, acesse o menu “Project” (Projeto) e escolha a opção "New Project"
(Novo Projeto). Ao realizar essa operação, será exibida uma nova janela (Figura 25), em que podere-
mos escolher a localização do novo projeto. Você pode optar por criar o projeto em qualquer pasta
de seu computador. Como exemplo, vamos criar um novo projeto chamado “tcc” na pasta raiz do
disco local (C:). Para isso, selecione o drive C e digite o nome do projeto "tcc" na opção "File Name"
(Nome do Arquivo), conforme exemplo exibido na Figura 25. Para confirmar a criação do projeto,
clique no botão "Create” (Criar).

Figura 25 Criação do projeto tcc no BlueJ.

Como resultado da criação do projeto "tcc", a ferramenta BlueJ criará uma pasta com o
nome "tcc", localizada no drive C de seu computador. Nessa pasta, serão gravados todos os có-
digos desenvolvidos na ferramenta. Nesse momento, a ferramenta BlueJ já desbloqueou a área
de trabalho (Figura 6), e então podemos iniciar a criação das classes do novo projeto.

Centro Universitário Claretiano


© Ambiente de Programação Java 63

Vamos iniciar o desenvolvimento criando a classe Aluno (Figura 24). Para criar uma classe
no BlueJ, você deve clicar no botão "New Class ...” (Nova Classe), localizado na lateral esquerda
da ferramenta. Ao clicar sobre o botão, a ferramenta exibirá uma nova janela que solicitará a
identificação do nome da classe (Class Name) e a escolha do tipo da classe (Class Type). Digite
"Aluno" na identificação do nome da classe e clique no botão "Ok” para criar a classe no BlueJ.
Como resultado dessa ação, o BlueJ exibirá a classe Aluno em seu ambiente visual (Figura 27).

Figura 26 Classe Aluno.

Figura 27 BlueJ: visualização da classe Aluno.


64 © Programação Orientada a Objetos

Como vimos anteriormente, o BlueJ cria classes usando um código-padrão que precisará
ser modificado para que as características presentes nas definições das classes do novo projeto
sejam implementadas.
Para simplificar o processo de codificação do novo sistema, vamos repetir os passos re-
alizados no processo de criação da classe Aluno no BlueJ com todas as outras classes (Curso,
Coordenador, Tcc, Banca e Professor), definidas no diagrama de classes do sistema de controle
de orientações e defesas de TCC. O intuito dessa ação é criarmos todas as classes com o código-
padrão e depois modificarmos uma por vez, conforme a necessidade de projeto. Após a criação
de todas as classes, visualizamos a ferramenta BlueJ ( Figura 28).

Figura 28 BlueJ: visualização das classes do novo projeto.

Uma vez que as classes estejam criadas, iniciaremos o processo de alteração dos códigos
para adequar cada classe à sua especificação, conforme as orientações do diagrama de classes
(Figura 24).

Alterações da Classe Aluno


Assim, vamos começar as alterações pela classe Aluno. Para visualizar o código-fonte de
uma classe, realize um duplo clique com o botão esquerdo do mouse sobre a classe e o BlueJ o
exibirá em uma nova janela. Note que o código exibido corresponde ao código-padrão criado
automaticamente pela ferramenta.
Segundo as orientações do diagrama de classes (Figura 24), a classe Aluno possui duas ca-
racterísticas que serão codificadas em Java em forma de dois atributos: nome e ra. Um atributo
corresponde à declaração de uma variável, assim, definiremos os dois atributos como do tipo
caractere usando o tipo String da linguagem Java. A classe Aluno possui também um comporta-
mento chamado "fazMatricula", e, conforme mencionamos, a codificação do método será reali-
zada posteriormente na Unidade 4, quando estudaremos as relações existentes entre classes.
Centro Universitário Claretiano
© Ambiente de Programação Java 65

Outra modificação importante a ser realizada no código da classe Aluno corresponde ao


método construtor chamado Aluno. Na linguagem Java, todo método construtor deve possuir o
mesmo nome da classe. Esse método será o responsável pela criação de objetos e terá o impor-
tante papel de realizar a iniciação dos valores dos atributos dos objetos.
Além das alterações descritas, também introduzimos no código da classe Aluno o método
"exibeInformacoes()” que será responsável por mostrar na tela (terminal do BlueJ) as informa-
ções armazenadas pelos objetos. Foi utilizado nesse método a chamada "System.out.println”,
que corresponde aos comandos “writeln” da linguagem Pascal e “printf” da linguagem C.
O código, a seguir, exibe, em negrito, as partes que devem ser alteradas no código-padrão
da classe Aluno. Recomendamos que você faça as mudanças indicadas, lembrando que a lin-
guagem Java faz diferenciação entre letras minúsculas e maiúsculas (case-sensitive). Depois de
realizar as alterações, você deverá compilar a classe clicando no botão "Compile”, localizado na
parte superior da janela de edição do código.
código 3
/**
* Classe Aluno.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Aluno
{
// variáveis da instância que representam as características do Aluno Atributos da
private String nome; classe
private String ra; (características)
/**
* Método Construtor responsável por criar objetos do tipo Aluno
*/
public Aluno(String nome, String ra)
Método Construtor
{
// atribui valores para as variáveis da instância (objeto) (cria objetos do tipo
this.nome = nome; Aluno)
this.ra = ra;
}

/**
* Método que exibe informações sobre o Aluno
*/ Método exibeInformacoes ( )
public void exibeInformacoes( ) (permite visualizar as características
{ dos objetos)
System.out.println(“Informações sobre Aluno:”);
System.out.println(“Nome: “+nome);
System.out.println(“Ra: “+ra); (Comportamentos)
}
}
fim código 3

Note que removemos do código original da classe Aluno o método "sampleMethod" e


toda a sua declaração. Essa remoção foi necessária, pois tal método fazia referência a variáveis
que foram retiradas da declaração da classe Aluno. Como já foi dito, realizaremos na Unidade 4
a codificação de outros métodos que tratarão dos comportamentos das classes.
Uma vez que a classe esteja compilada, vamos testá-la criando objetos por meio da
interface da ferramenta BlueJ. Para isso, clique com o botão direito do mouse sobre a repre-
sentação visual da classe Aluno (Figura 28) e escolha a opção "New Aluno (String nome, String ra)"
(Novo Aluno). Essa operação abrirá uma nova janela (Figura 29), que solicitará a informação de
"Name of Instance" (Nome da Instância), que corresponde à identificação (nome) do novo
objeto Aluno que será criado. Cada objeto instanciado com base em uma classe deve rece-
ber um nome para identificação única.
66 © Programação Orientada a Objetos

Conforme exemplificado na Figura 29, mantivemos o nome da instância (ou nome do ob-
jeto) sugerido pelo BlueJ e adicionamos as informações do nome ("Jose") e ra ("1111111") do
novo aluno (novo objeto). Você pode digitar qualquer outra informação, só não se esqueça de
que como nome e ra foram definidos na linguagem Java como do tipo String, então as informa-
ções digitadas devem ser iniciadas e finalizadas com aspas duplas. Clique sobre o botão "Ok"
para confirmar a criação do novo objeto. Para cada objeto criado (ou instanciado) no BlueJ será
exibida, na parte inferior da ferramenta, uma representação visual dos objetos instanciados em
memória (Figura 30).
Como forma de aprimorar seu aprendizado, recomendamos que você crie outros objetos
do tipo Aluno. Note que, quando um novo objeto é instanciado, uma nova representação similar
à exibida na Figura 30 será acrescentada na barra inferior da ferramenta BlueJ.

Figura 30 BlueJ: identificação do objeto (ou nome da Figura 31 BlueJ: objeto


Figura 29 BlueJ: menu de classe compilada. instância). instanciado.

Uma vez que um objeto esteja instanciado em memória, podemos realizar a invocação de
métodos que estão disponíveis para ele. Todos os métodos são codificados dentro da classe que
define o objeto, no nosso caso, dentro da classe Aluno.
Assim, para visualizar os métodos disponíveis para um objeto no BlueJ, você deverá clicar
com o botão direito do mouse sobre o objeto (Figura 31). Note que, para o objeto “aluno1”,
apenas o método "exibeInformacoes()" é exibido. Isso acontece porque apenas este método foi
codificado e encontra-se disponível dentro da classe Aluno (ver código da classe).
Mas onde está o método Construtor da classe Aluno? Ele não deveria aparecer também
para o objeto “aluno1” junto com o método "exibeInformacoes()"? A resposta para esse ques-
tionamento é: NÃO, pois o método construtor só poderá ser executado sobre a classe, e nunca
sobre os objetos instanciados.
Antes de invocarmos métodos sobre os objetos, executaremos a opção "Inspect” (Ins-
pecionar) para visualizar o estado atual do Objeto “aluno1” (Figura 31). Como resultado dessa
ação, todas as informações referentes aos atributos (características) do objeto serão exibidas
(Figura 32). Faça esse procedimento em todos os outros objetos que você tenha instanciado e
note como os objetos possuem características diferentes. Relembramos que cada objeto possui
um armazenamento distinto em memória para cada objeto instanciado.
Vamos agora invocar o método "exibeInformacoes()” sobre o objeto “aluno1” (Figura 31).
Como resultado dessa ação, o Java executará o método sobre o objeto que recebeu a invocação.
Nesse exemplo, o objeto "aluno1" será a referência para a execução do método "exibeInforma-
coes()" e, portanto, os atributos referenciados no método serão os correspondentes ao objeto
"aluno1". O método "exibeInformacoes()" utiliza o comando "System.out.println" para enviar as
informações de texto e os valores dos atributos para o terminal do BlueJ responsável por exibir
as mensagens em formato texto (Figura 33).

Centro Universitário Claretiano


© Ambiente de Programação Java 67

Figura 32 BlueJ: menu sobre objeto do tipo Aluno.

Figura 33 BlueJ: inspect sobre um objeto do tipo Aluno. Figura 34 BlueJ: terminal de mensagens.

Os passos descritos permitem a você um maior contato com a ferramenta BlueJ, com a
linguagem Java e com os conceitos da Orientação a Objetos. Aconselhamos que você realize
esses passos sobre os outros objetos que venha a instanciar. Quanto mais praticar, maior será
seu aprendizado.
É aconselhável que, após o término da utilização de um objeto, você faça a "destruição"
dele, o que resultará na consequente liberação da memória que o objeto alocava. Para isso, você
tem à disposição, dentro da ferramenta BlueJ (Figura 31), a opção "Remove" (Remover) que
indicará à linguagem Java a destruição do objeto.
Vamos agora realizar as alterações sobre as demais classes existentes no projeto do sis-
tema de controle de orientações e defesas de TCC. Para as próximas classes não detalharemos
todas as etapas que foram realizadas sobre a classe Aluno, porém, recomendamos fortemente
a você que faça uso da ferramenta BlueJ para:
a) editar os códigos-fontes realizando as modificações necessárias, para atender às espe-
cificações do diagrama de classes;
b) compilar as classes modificadas e realizar prováveis correções, quando necessárias,
devido aos possíveis erros que venham a ocorrer na codificação das classes;
c) instanciar objetos por meio da execução dos métodos construtores presentes em cada
classe;
d) inspecionar os objetos criados, para visualizar as informações armazenadas nos atri-
butos;
e) invocar métodos sobre os objetos instanciados, para testar os métodos implementa-
dos.
A seguir, encontram-se, em negrito, as alterações a serem realizadas em cada uma das de-
mais classes existentes no projeto do novo sistema. Realize as modificações necessárias sobre os
códigos-fonte padrões da ferramenta BlueJ e siga a sequência de passos indicada anteriormente
para cada uma das classes. Ao refazer essa sequência, você estará aprimorando seus conhe-
cimentos na programação orientada a objetos com Java, o que resultará em maior segurança
quando estivermos aprofundando nossos estudos nas próximas unidades.
68 © Programação Orientada a Objetos

Alterações da Classe Curso


código 4
/**
* Classe Curso.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Curso
{
// variáveis da instância que representam as características do Curso
private String nome;
private String sigla;
private String area;
/**
* Método Construtor responsável por criar objetos do tipo Curso
*/
public Curso(String nome, String sigla, String area){
// atribui valores para as variáveis da instância (objeto)
this.nome = nome;
this.sigla = sigla;
this.area = area;
}
/**
* Método que exibe informações sobre o Curso
*/
public void exibeInformacoes( ){
System.out.println(“Informações sobre Curso:”);
System.out.println(“Nome: “+nome);
System.out.println(“Sigla: “+sigla);
System.out.println(“Área: “+area);
}
}
fim código 4

Alterações da Classe Coordenador.


código 5
/**
* Classe Coordenador.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Coordenador
{
// variáveis da instância que representam as características do Coordenador
private String ramal;
private String cargaHoraria;
/**
* Método Construtor responsável por criar objetos do tipo Coordenador
*/
public Coordenador(String ramal, String cargaHoraria)
{
// atribui valores para as variáveis da instância (objeto)
this.ramal = ramal;
this.cargaHoraria = cargaHoraria;
}
/**
* Método que exibe informações sobre o Coordenador
*/
public void exibeInformacoes( )
{
System.out.println(“Informações sobre Coordenador:”);
System.out.println(“Ramal: “+ramal);
System.out.println(“Carga Horária: “+cargaHoraria);
}
}
fim código 5

Centro Universitário Claretiano


© Ambiente de Programação Java 69

Alterações da Classe Tcc.


código 6
/**
* Classe Tcc.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Tcc{
// variáveis da instância que representam as características do Tcc
private String titulo;
private int ano;
private String situacao;
private float nota;
/**
* Método Construtor responsável por criar objetos do tipo Tcc
*/
public Tcc(String titulo, int ano, String situacao, float nota){
// atribui valores para as variáveis da instância (objeto)
this.titulo = titulo;
this.ano = ano;
this.situacao = situacao;
this.nota = nota;
}
/**
* Método que exibe informações sobre o Tcc
*/
public void exibeInformacoes( ){
System.out.println(“Informações sobre Tcc:”);
System.out.println(“Título: “+titulo);
System.out.println(“Ano: “+ano);
System.out.println(“Situação: “+situacao);
System.out.println(“Nota: “+nota);
}
}
fim código 6

Alterações da Classe Banca


código 7
/**
* Classe Banca.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Banca{
// variáveis da instância que representam as características da Banca
private String data;
private String parecer;
/**
* Método Construtor responsável por criar objetos do tipo Banca
*/
public Banca(String data, String parecer){
// atribui valores para as variáveis da instância (objeto)
this.data = data;
this.parecer = parecer;
}
/**
* Método que exibe informações sobre a Banca
*/
public void exibeInformacoes( ){
System.out.println(“Informações sobre a Banca:”);
System.out.println(“Data: “+data);
System.out.println(“Parecer: “+parecer);
}
}
fim código 7
70 © Programação Orientada a Objetos

Alterações da Classe Professor.


código 8
/**
* Classe Professor.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Professor
{
// variáveis da instância que representam as características do Professor
private String nome;
private String titulacao;
private String email;
/**
* Método Construtor responsável por criar objetos do tipo Professor
*/
public Professor(String nome, String titulacao, String email)
{
// atribui valores para as variáveis da instância (objeto)
this.nome = nome;
this.titulacao = titulacao;
this.email = email;
}
/**
* Método que exibe informações sobre o Professor
*/
public void exibeInformacoes( )
{
System.out.println(“Informações sobre o Professor:”);
System.out.println(“Nome: “+nome);
System.out.println(“Titulação: “+titulacao);
System.out.println(“Email: “+email);
}
}
fim código 8

Uma vez que todas as modificações tenham sido realizadas, faça a compilação das classes
e realize as validações e testes que foram feitos sobre a classe Aluno.
Parabéns! Completamos mais uma importante fase do projeto. Nossa implementação do
sistema de controle de orientações e defesas de TCC está parcialmente feita. Resta, ainda, rea-
lizarmos as codificações dos métodos que possibilitarão a implementação das relações de he-
rança, agregação e associação. Essas codificações serão estudadas na Unidade 4, e os códigos
referentes a sua implementação estarão lá disponibilizados.

10. QUESTÕES AUTOAVALIATIVAS


Confira, a seguir, as questões propostas para verificar o seu desempenho no estudo desta
unidade:
1) Relacionado à linguagem Java, podemos afirmar que ela é portável? Justifique.

2) O que são métodos construtores? Qual sua importância na programação orientada a objetos?

3) Considerando que você é o responsável por definir um novo sistema para uma escola infantil, que deseja in-
formatizar sua secretaria para controlar as informações de alunos, pais e responsáveis, professores, turmas
e atividades extras realizadas pelas crianças, como você definiria e criaria o diagrama de classes de tal projeto?

4) Com base na Questão 2, do Tópico Questões Autoavaliativas da Unidade 1 que solicitava a relação existente
entre os conceitos de classe e objeto, bem como considerando o sistema de uma Faculdade e as classes Funcio-
nário, Departamento e Projeto, que foram definidas anteriormente com cinco características, escreva o código-
fonte Java de cada uma dessas classes, não se esquecendo de identificar os atributos, os métodos construtores
e os métodos para exibição das informações dos objetos criados.

Centro Universitário Claretiano


© Ambiente de Programação Java 71

Gabarito
Confira, a seguir, as respostas corretas para as questões autoavaliativas propostas:
1) Para responder a esta questão, você deverá recordar como funciona a arquitetura da linguagem Java. Para ini-
ciar o desenvolvimento de programas usando Java, você precisou inicialmente instalar o kit de desenvolvimento
Java (JDK), que contém o ambiente de execução Java (JRE). Esse ambiente, também chamado de JVM (Máquina
Virtual Java), corresponde à camada de software necessária para a execução de programas desenvolvidos em
Java. Os códigos Java (arquivos .java) depois de escritos são compilados para gerar uma versão intermediária
chamada bytecode (arquivos .class). Esse bytecode é então interpretado pela JVM, não precisando ser recompi-
lado para se ajustar a qualquer mudança na versão do sistema operacional ou do hardware do computador de
execução. Isso é possível porque o responsável pela execução do programa é a JVM, que foi instalada previa-
mente no computador. Desse modo, podemos afirmar que a linguagem Java é portável.

2) Os métodos construtores são métodos especiais na programação orientada a objetos, pois permitem a instan-
ciação de novos objetos em memória com base nas declarações realizadas na classe. Além disso, os métodos
construtores possibilitam a iniciação dos atributos dos objetos instanciados por meio de parâmetros repassados
aos métodos. Sua importância para a programação orientada a objetos está em que esses métodos são os úni-
cos métodos responsáveis pela criação de objetos, enquanto os outros são responsáveis por tornar atributos
acessíveis (métodos de acesso) ou executar tarefas específicas.

3) Vamos iniciar o projeto da escola infantil abstraindo informações relacionadas aos principais assuntos tratados
no projeto. Nesta questão, você poderá encontrar uma solução diferente da apresentada, porém o intuito maior
é praticar e autoavaliar os conhecimentos adquiridos até aqui.
Como etapa inicial, identifique os objetos e suas respectivas características. Veja, a seguir, alguns objetos identifi-
cados e suas características:
a) Aluno: nome, data de nascimento, pai e mãe.
b) Responsável: nome, CPF, parentesco, data de nascimento, telefone residencial, telefone celular e endereço.
c) Professor: nome, formação, código funcionário, data de nascimento, telefone residencial, telefone celular
e endereço.
d) Turma: código, nome, ano e sala.
e) Atividade: nome, descrição e valor.

É possível que você tenha identificado objetos diferentes com características distintas destas que foram identifica-
das. Relembramos que a abstração é uma etapa que depende da visão do analista que esteja criando o sistema.
Após identificar os objetos e suas características, defina as classes e as represente usando o diagrama de classes da
UML. Não se esqueça de representar as relações de herança, agregação e associação existentes entre as classes.
Acompanhe, a seguir, uma possível definição das classes usando o diagrama de classes da UML. Note que foi defi-
nida a classe Pessoa e suas definições foram herdadas das classes Professor e Responsável.
72 © Programação Orientada a Objetos

Turma Professor

codigo codigo_funcionario
nome formacao
ano
sala

matricula

Aluno Atividade
nome nome
codigo descricação
data_de_nascimento valor
pai
mae

Responsavel Pessoa
cpf nome
parentesco data_nascimento
telefone_residencial
telefone_celular
endereco

4) Nesta questão, você deverá escrever um código-fonte na linguagem Java para cada uma das classes que você
definiu na questão autoavaliativa 2 da Unidade 1. Apresentaremos, a seguir, a codificação das classes conforme
a resposta que exibimos anteriormente. Esteja atento para não se esquecer de todos os detalhes solicitados
no enunciado da questão. Note que omitimos da codificação os três métodos identificados para cada uma das
classes, pois não possuímos orientações suficientes sobre como eles deveriam ser implementados.

código 1
public class Departamento
{
private String nome, sigla, descricao, dataDeCriacao, localizacao;

/* Método Constructor da classe Departamento */


public Departamento(String nome, String sigla, String descricao, String dataDeCriacao,
String localizacao)
{
// iniciação das variaveis da instância
this.nome = nome;
this.sigla = sigla;
this.descricao = descricao;
this.dataDeCriacao = dataDeCriacao;
this.localizacao = localizacao;
}

/* Método que exibe informações sobre Departamento */


public void exibeInformacoes( )
{
System.out.println(“Informações sobre Departamento:”);
System.out.println(“Nome: “ + nome);
System.out.println(“Sigla: “ + sigla);
System.out.println(“Descrição: “ + descricao);
System.out.println(“Data de Criação: “ + dataDeCriacao);
System.out.println(“Localização: “ + localizacao);
}
}

fim código 1

Centro Universitário Claretiano


© Ambiente de Programação Java 73

código 2
public class Projeto
{
private String codigo, descricao, dataDeInicio, dataDeTermino, situacao;

/* Método Constructor da classe Projeto */


public Projeto(String codigo, String descricao, String dataDeInicio, String
dataDeTermino, String situacao)
{
// iniciação das variaveis da instância
this.codigo = codigo;
this.descricao = descricao;
this.dataDeInicio = dataDeInicio;
this.dataDeTermino = dataDeTermino;
this.situacao = situacao;
}

/* Método que exibe informações sobre Projeto */


public void exibeInformacoes( )
{
System.out.println(“Informações sobre Projeto:”);
System.out.println(“Código: “ + codigo);
System.out.println(“Descrição: “ + descricao);
System.out.println(“Data de Início: “ + dataDeInicio);
System.out.println(“Data de Término: “ + dataDeTermino);
System.out.println(“Situação: “ + situacao);
}
}

fim código 2

11. CONSIDERAÇÕES
Nesta unidade, você teve a oportunidade de aprender alguns conceitos introdutórios so-
bre a linguagem Java, configurar o ambiente de desenvolvimento, utilizar uma ferramenta visual
de programação e criar sua primeira classe usando a linguagem.
Com relação à ferramenta BlueJ, você pôde aprender como:
a) criar um projeto;
b) criar uma classe;
c) visualizar e modificar o código de uma classe;
d) compilar uma classe;
e) instanciar objetos por meio de classe (execução do método construtor);
f) visualizar as informações de objetos;
g) invocar métodos sobre objetos;
h) destruir objetos.
O intuito, nesta unidade, foi apresentar a linguagem Java e a ferramenta de programação
BlueJ.
Recomendamos, para uma maior compreensão dos conceitos da linguagem Java, a repro-
dução dos exemplos estudados em seu computador.

12. E-REFERÊNCIAS

Sites pesquisados
BLUEJ The Interactive Java Environment. Disponível em: <http://www.bluej.org>. Acesso em: 9 dez. 2010.
SUN DEVELOPERS NETWORK (SDN). Sun Microsystems. Disponível em: <http://java.sun.com>. Acesso em: 9 dez. 2010.
74 © Programação Orientada a Objetos

13. REFERÊNCIAS BIBLIOGRÁFICAS


CADENHEAD, R.; LEMAY, L. Aprenda em 21 dias Java 2. Tradução de Daniel Vieira. 4. ed. Rio de Janeiro: Elsevier, 2005.
DEITEL, H. M.; DEITEL, P. J. Java: como programar. Tradução de Edson Furmankiewicz. 6. ed. São Paulo: Pearson Prentice Hall, 2007.
BOOCH, G.; RUMBAUGH, J.; JACOBSON, I. UML: guia do usuário. Tradução de Fábio Freitas da Silva et al. 2 ed. rev. atual. Rio de
Janeiro: Elsevier, 2005.

Centro Universitário Claretiano


EAD
Linguagem Java

1. OBJETIVOS
• Conhecer a sintaxe da linguagem Java.
• Criar classes e objetos utilizando Java.

2. CONTEÚDOS
• Sintaxe dos principais comandos Java.
• Classificação e instanciação em Java.

3. ORIENTAÇÃO PARA O ESTUDO DA UNIDADE


Antes de iniciar o estudo desta unidade, é importante que você leia a orientação a se-
guir:
1) Esta unidade trata de conceitos mais aprofundados da linguagem Java. Serão aborda-
dos os principais comandos da linguagem, bem como diferentes aspectos envolvendo
a criação de classes. A seguir, elaboramos uma lista com referências mais aprofun-
dadas sobre alguns tópicos tratados de maneira introdutória nesta unidade. Reco-
mendamos que você pesquise nas referências indicadas, de modo a suprir eventuais
dúvidas que surjam sobre esses tópicos:
a) Para obter mais informações sobre os tipos de acesso, visite o site: <http://www.
javafree.org/artigo/6941/Cap-2-Modificadores.html>.
b) Para obter mais informações sobre o tratamento de exceções em Java, visite o site:
<http://imasters.uol.com.br/artigo/11445/java/tratamento_de_excecoes/>.
76 © Programação Orientada a Objetos

c) Para obter mais informações sobre a linguagem Java, visite os seguintes sites:
<http://www.mundojava.com.br>; <http://www.guj.com.br>.

4. INTRODUÇÃO À UNIDADE
Na unidade anterior, você configurou o ambiente de desenvolvimento Java e, usando o
projeto “poo”, criou o primeiro programa utilizando a linguagem Java e a ferramenta BlueJ.
Nesta unidade, você terá a oportunidade de estudar com mais detalhes a linguagem de
programação Java. Aprenderá os tipos de dados existentes e a sintaxe dos principais comandos.
Além de conhecer a estrutura completa de uma classe em Java, você criará programas utilizan-
do essa linguagem como forma de praticar e compreender a sintaxe dos comandos usados. No
estudo desta unidade, você implementará uma classe que instancia objetos por meio dela.

5. CONHECENDO MELHOR A LINGUAGEM JAVA


Na Unidade 2, dentro do projeto “poo”, você criou a primeira classe usando a ferramenta
BlueJ no ambiente da linguagem Java. Dessa forma, foi possível notar que o BlueJ oferece total
suporte à linguagem Java. A seguir, trabalharemos com os conceitos da Orientação a Objetos
com o foco direcionado à linguagem Java. Você deverá utilizar o BlueJ como ferramenta de de-
senvolvimento para codificar os exemplos citados.
Uma característica que a linguagem Java possui é que todos os programas são escritos
em formato de classe. Para isso, basta notar a declaração existente no início da classe Casa:
“public class Casa". A referência public indica que o acesso ao programa é compartilhado a
todos. A referência class é uma palavra reservada da linguagem Java que faz menção à decla-
ração da classe. A palavra Casa corresponde ao nome da classe.

Arquivos .java e .class


As classes criadas em Java são gravadas no computador em arquivos com formatos padro-
nizados. Os códigos-fonte das classes Java são armazenados em arquivos com a extensão .java,
e as classes compiladas, em formato bytecode, são armazenadas em arquivos com a extensão
.class. Na unidade anterior, criamos a classe Casa dentro do projeto “poo”.
Assim, recomendamos que você visualize, pelo gerenciador de arquivos de seu computa-
dor, o conteúdo da pasta C:\poo (Figura 1), que corresponde ao local em que o projeto do BlueJ
foi criado. Note que existem, dentro dessa pasta, os arquivos Casa.java e Casa.class, que são re-
ferentes à implementação da classe Casa, em que o primeiro corresponde à fonte do programa
e o segundo, ao "executável".
A linguagem Java é case-sensitive, isto é, as letras maiúsculas e minúsculas representam
letras diferentes. Essa diferenciação poderá refletir em erros de codificação, pois os nomes atri-
buídos às classes, aos objetos, aos atributos e aos métodos devem ser feitos da forma exata
como foram declarados na codificação.
Para gerenciar os projetos, a ferramenta BlueJ cria outros arquivos dentro da pasta de pro-
jeto. Esses arquivos não devem ser alterados ou removidos, sob risco de ocasionar problemas na
visualização das classes pela ferramenta.

Centro Universitário Claretiano


© Linguagem Java 77

Figura 1 BlueJ: arquivos gravados na pasta do projeto.

No Java, a execução de métodos pode ser realizada de duas maneiras: sobre objetos ins-
tanciados ou sobre as classes. Na unidade anterior, foram invocados métodos apenas sobre
objetos instanciados (objeto: casa "popular", método: “exibeInformacoes”). Vamos, a seguir,
criar uma nova classe Java que permitirá a execução de métodos diretamente sobre ela, sem a
necessidade da criação de objetos.
Como padrão, a ferramenta BlueJ adota, como projeto atual, o último projeto utilizado.
Assim, caso você tenha realizado a implementação do projeto prático da Unidade 2, então serão
exibidas as classes do projeto "tcc" na próxima execução do BlueJ. Para que possamos praticar
com os novos exemplos da Unidade 3, envolvendo a linguagem Java e não modificar a imple-
mentação das classes do projeto "tcc", recomendamos a você que feche o projeto “tcc”, aces-
sando o menu “Project” (Projeto), e escolhendo a opção "Close” (Fechar).
Para abrir o antigo projeto “poo”, acesse o menu “Project" e escolha a opção "Open Project”
(Abrir Projeto), o que resultará na abertura de uma nova janela, parecida com um gerenciador de
arquivo, que possibilitará a escolha do projeto "poo". Caso você tenha seguido nossas orientações,
o projeto "poo" estará acessível em “C:\poo”. Recomendamos que você abra a ferramenta BlueJ
utilizando o projeto “poo” e crie no BlueJ uma nova classe chamada “Executa”.

Classe executável
Após criar a classe usando a janela de configuração da classe, abra o editor de código da
classe “Executa” e apague todo o código-padrão gerado pela ferramenta. Substitua o código an-
tigo pelo código citado a seguir e compile a classe. Caso existam erros nos comandos, eles serão
exibidos na parte inferior da janela de edição de código. Realize eventuais correções no código,
estando atento ao fato de que existem diferenciações entre letras minúsculas e maiúsculas, e
por fim recompile a classe até obter sucesso.
78 © Programação Orientada a Objetos

código 1
public class Executa { // Definição da classe chamada Executa
   public static void main(String arg) {// Método que inicia o programa
      System.out.println(“Você passou o parâmetro :”+arg); // comando de escrita
}//fecha o método main
}//fecha a definição da classe

fim código 1

A seguir, você encontrará comentários sobre cada uma das linhas e os comandos da classe
“Executa”:

Quadro 1 Explicação da linha 1 de declaração de classe.


CÓDIGO DESCRIÇÃO
Palavra reservada da linguagem Java que denota um tipo de acesso. A referência public compartilha
public:
o acesso à classe Executa a todos.
O termo class é uma palavra reservada da linguagem Java que denota a identificação da classe
class:
(Executa).
Nome da classe. Letras minúsculas e maiúsculas são caracteres diferentes. Como sugestão,
recomendamos que você nomeie as classes com a primeira letra maiúscula e as demais minúsculas.
Executa:
Se o nome da classe apresentar duas ou mais palavras combinadas, use letras maiúsculas no início das
palavras (por exemplo: classe CasaModelo).

Quadro 2 Explicação da linha 2 do método de execução principal.


Palavra reservada da linguagem Java que denota um tipo de acesso (nesta classe, o acesso ao método
main é compartilhado com todos).
Java também disponibiliza outros modificadores de acesso para controlar o acesso aos métodos e às
variáveis de uma classe. São eles:
public:
public: qualquer classe tem acesso aos membros públicos da classe.
protected: permite que as classes herdadas e as que estão no mesmo pacote acessem os métodos e
atributos definidos como protected na classe.
private: é o modificador mais restrito. Um método ou atributo privado só pode ser acessado apenas
pela própria classe.
Indica que o método main será invocado diretamente apenas pela classe, e não sobre os ob-
static: jetos instanciados. O operador static também pode ser utilizado em atributos e resulta na
criação de um atributo da classe (global) que é acessível a todos os objetos instanciados a
partir da classe.
Indica que o método main não retornará valores ao término de sua execução. Tradução de void =
void:
vazio.
main: Método principal que executa a classe. Similar ao método main da linguagem C.
String arg: Parâmetro do tipo "String” que pode ser repassado no momento da execução do método main.

Quadro 3 Explicação da linha 3 do comando de impressão.


A classe System pertence às bibliotecas da linguagem Java e é responsável por imprimir uma mensagem
quando executado seu método println.
System.out.println:
A execução desse comando exibirá o texto resultante da combinação de: "Você passou o parâmetro :
" com o valor do parâmetro arg.

Na linguagem Java, assim como em C, os comentários podem ser incluídos de duas ma-
neiras:

Formato 1: Formato 2:

/*aqui dentro fica o comentário e ele


// comentário segue até o final da linha
pode continuar quantas linhas quiser
// aqui é outro comentário de linha
desde que seja fechado no final com */

Centro Universitário Claretiano


© Linguagem Java 79

Execução do método main


Clique com o botão direito do mouse sobre a classe “Executa” e execute o método main
(Figura 2) passando parâmetros por meio da janela de execução de métodos. Como o parâme-
tro aguardado pelo método main é do tipo String, recomendamos que você digite o texto entre
aspas duplas (Figura 3). Clique no botão "Ok" para executar o método e visualize a mensagem
com o parâmetro ("Java é legal !”) no terminal de mensagens (Figura 4). Execute novamente o
programa trocando o valor do parâmetro na opção de execução do método main.

Figura 2 BlueJ: menu da Classe Executa.

Figura 3 BlueJ: parâmetros do método main. Figura 4 BlueJ: mensagens.

Agora que você já aprendeu a executar métodos sobre classes e sobre objetos, vamos
conhecer um pouco da linguagem Java.

6. SINTAXE DA LINGUAGEM JAVA


A seguir, você conhecerá a sintaxe da linguagem Java. Fique atento a todos os detalhes.

Tipos de dados
A linguagem Java possui oito tipos de dados considerados primitivos, isto é, tipos de da-
dos básicos definidos pela própria linguagem.

Quadro 4 Tipos de dados Java.


TIPOS DE DADOS

Tipo Tamanho (bits) Descrição

boolean 1 Valor lógico (true/false).


byte 8 Número inteiro de 8 bits, podendo assumir valores de -128 a 127.
char 16 Tipo caractere que pode armazenar dados alfanuméricos.
80 © Programação Orientada a Objetos

TIPOS DE DADOS

Tipo Tamanho (bits) Descrição

short 16 Número inteiro de 16 bits, podendo assumir valores de -32.768 a 32.767.

int 32 Número inteiro de 32 bits, podendo assumir valores de -2.147.483.648 a 2.147.483.647.

float 32 Números em notação ponto flutuante normalizada com precisão de 32 bits.

long 64 Número inteiro de 64 bits, podendo assumir valores de -263 a (263-1).

double 64 Números em notação ponto flutuante normalizada com precisão dupla de 64 bits.

O “tipo” de dado String é, na verdade, uma classe e representa o tipo de dado literal ou
caractere. Mais detalhes sobre dados do “tipo” String serão apresentados a seguir.

Operadores aritméticos
Conheça os operadores aritméticos em Java, descritos no Quadro 5.

Quadro 5 Operadores aritméticos.


Operador Exemplo
Soma op1 + op2
Subtração op1 – op2
Multiplicação op1 * op2
Divisão op1 / op2
Resto da divisão op1 % op2
Incremento op1++ ou ++op1
Decremento op1-- ou --op1

Para exemplificar a utilização de operadores aritméticos, criaremos um programa chama-


do “Soma”. O programa usará a classe Integer e seu método parseInt para realizar a conversão
de dados do tipo texto (String) para numérico (int). Crie uma nova classe chamada “Soma” e
substitua o código-fonte do BlueJ pela declaração a seguir.
código 2
public class Soma
{
public static void main(String[] args) // método que inicia o programa
{
// converte os parâmetros em inteiros e os armazena em a e b
int a = Integer.parseInt(args[0]);
int b = Integer.parseInt(args[1]);
int c = a + b; // realiza a soma
System.out.println(“O Resultado da soma é: ” + c); // exibe a soma
}
}

fim código 2

Array (lista de valores ou objetos)


Como opção de parâmetros de um método, você pode usar uma lista de valores ou obje-
tos. A declaração: String[] args corresponde à declaração de um Array de objetos String. A estru-
tura de Array pode ser utilizada com vários tipos de dados diferentes (tipos primitivos de dados
ou objetos). Na classe “Soma”, iremos repassar dois parâmetros. O conteúdo do Array será:

Centro Universitário Claretiano


© Linguagem Java 81

args[0] – “parâmetro 1”
args[1] – “parâmetro 2”

Em Java, assim como na linguagem C, a primeira posição do Array é referenciada com [0].
Compile e execute o método main da classe “Soma”, conforme apresentado na Figura 5.
Em seguida, realize a passagem de parâmetros, indicada na Figura 6. Note que os valores foram
repassados entre aspas duplas, pois correspondem ao tipo de dado String. Clique no botão "Ok”
e visualize a mensagem com o resultado da operação da soma entre os dois valores passados
por parâmetro (Figura 7). Execute novamente o programa trocando o valor dos parâmetros na
janela de execução do método main.

Figura 5 BlueJ: menu da classe Soma.

Figura 6 BlueJ: parâmetros do método main. Figura 7 BlueJ: mensagens.

No que se refere à passagem de parâmetros, existem outras formas possíveis de se imple-


mentar a classe “Soma”. Por exemplo:

public static void main(int[] args) // Array com números inteiros


public static void main(float[] args) // Array com números reais
public static void main(int arg1, int arg2) // dois parâmetros inteiros separados

Os exemplos anteriores oferecem como vantagem sobre a programação inicial da classe


"Soma" a não necessidade de conversão de valores do tipo String para um tipo de dado numé-
rico.

Operadores relacionais e lógicos


Observe, nos quadros a seguir, os operadores relacionais e lógicos.
82 © Programação Orientada a Objetos

OPERADORES RELACIONAIS OPERADORES LÓGICOS


Operador Exemplo Operador Exemplo
Diferente op1 != op2 E exp1 && exp2
Igual op1 == op2 OU exp1 || exp2
Menor ou igual que op1 <= op2 NÃO !epx
Maior ou igual que op1 >= op2
Menor que op1 < op2
Maior que op1 > op2

Estrutura de decisão: comando if – else


A declaração if-else permite que a execução proceda por meio de um conjunto de estados bo-
oleanos, fazendo com que diferentes partes do código sejam executadas. A cláusula else é opcional.

if (expressão booleana) declaração1;


[else declaração2;]

Neste caso, apenas uma declaração pode aparecer depois de if e else. Para incluir mais
declarações, é preciso utilizar chaves.
Para exemplificar o uso das estruturas de repetição if, criaremos agora uma classe chama-
da “EstacaoDoAno”. Crie no BlueJ a nova classe, descarte o código-padrão e utilize como código
da classe a seguinte codificação:
código 3
class EstacaoDoAno
{
public static void main(int mes)
{
String estacao; // armazenara o nome do mes
if (mes ==12 || mes == 1 || mes == 2)
{ // IF dos meses de Verao
estacao = “Verão”;
}
else if (mes ==3 || mes == 4 || mes ==5)
{ // IF dos meses de Outono
estacao = “Outono”;
}
else if (mes ==6 || mes == 7|| mes ==8)
{ // IF dos meses de Inverno
estacao = “Inverno”;
}
else if (mes ==9|| mes == 10|| mes ==11)
{ // IF dos meses de Primavera
estacao = “Primavera”;
}
else // ELSE para mes invalido
estacao = “Desconhecida”;
System.out.println(“Mês: “+ mes + “ - Estação: “ + estacao + “.”); // exibe
estacao
}
}

fim código 3

Note que o comando System.out.println, existente na parte final do programa, realiza a


concatenação (junção) de textos ("Mês: ”, " – Estação: ” e ".") com valores armazenados nas va-
riáveis (mes e estacao) por meio do símbolo +. Perceba que as aspas duplas contemplam apenas
os textos que serão impressos, e não as variáveis do programa.

Centro Universitário Claretiano


© Linguagem Java 83

Compile e execute o método main da classe “EstacaoDoAno”, conforme apresentado na


Figura 8. Em seguida, realize a passagem de parâmetros, indicada na Figura 9. Note que o valor
foi passado sem aspas duplas, pois corresponde ao tipo de dado int. Clique no botão "Ok” e
visualize a mensagem com o mês correspondente ao valor passado por parâmetro (Figura 10).
Execute novamente o programa trocando o valor do parâmetro na janela de execução do mé-
todo main.

Figura 8 BlueJ: menu classe EstacaoDoAno.

Figura 9 BlueJ: parâmetros do método main. Figura 10 BlueJ: mensagens.

Estrutura de decisão: comando switch


Fornece a opção de execução de diferentes partes do código, com base no valor de uma
única variável ou expressão. A forma geral de declaração é:

switch (expressao)
{
case valor1:
break;
case valor2:
break;
case valorN:
break;
default:
}

O break sem um rótulo faz com que a execução desvie para o próximo comando depois do
final de switch.
Para exemplificar o uso das estruturas de repetição switch, criaremos no BlueJ uma nova
classe chamada “EstacaoDoAno2”. Para tanto, utilize, como código da classe, a codificação a
seguir:
84 © Programação Orientada a Objetos

código 4
class EstacaoDoAno2
{
public static void main(int mes)
{
String estacao; // armazenara o nome do mes
switch (mes)
{
case 12:

case 1:

case 2:
estacao = “Verão”;
break;

case 3:

case 4:

case 5:
estacao = “Outono”;
break;

case 6:

case 7:

case 8:
estacao = “Inverno”;
break;

case 9:

case 10:

case 11:
estacao = “Primavera”;
break;

default:
estacao = “Desconhecida”;
}
// exibe a estação conforme o mes
System.out.println(“Mês: “+ mes + “ - Estação: “ + estacao + “.”);
}
}

fim código 4

Compile e execute o método main da classe “EstacaoDoAno2”, conforme apresentado na


Figura 11. Em seguida, realize a passagem de parâmetros, indicada na Figura 12, usando valores
do tipo numérico inteiro (sem aspas duplas). Clique no botão "Ok” e visualize a mensagem com
o mês correspondente ao valor passado por parâmetro (Figura 13). Execute novamente o pro-
grama trocando o valor do parâmetro na janela de execução do método main.

Figura 11 BlueJ: menu classe EstacaoDoAno2.

Centro Universitário Claretiano


© Linguagem Java 85

Figura 12 BlueJ: parâmetros do método main. Figura 13 BlueJ: mensagens.

Estrutura de repetição: comando for


A forma geral do comando for é:
for (inicialização; encerramento; iteração ) {
comandos;
}

Para exemplificar a utilização da estrutura de repetição for, criaremos uma nova classe no
BlueJ chamada “RepeticaoFor”. Para tanto, utilize, como código da classe, a codificação a seguir:
código 5
class RepeticaoFor
{
public static void main(String arg)
{
for (int i = 1; i <= 10; i++) // repete 10 vezes
System.out.println(“i = “ + i + “ / Parâmetro: ”+ arg); // imprime o valor da
variável i
}
}

fim código 5

Compile e execute o método main da classe “RepeticaoFor”, conforme apresentado na


Figura 14. Em seguida, realize a passagem de parâmetros, indicada na Figura 15, usando valores
do tipo String (com aspas duplas). Clique no botão "Ok” e visualize os valores gerados pelo laço
de repetição for (Figura 16). Execute novamente o programa trocando o valor do parâmetro na
janela de execução do método main.

Figura 14 BlueJ: menu classe RepeticaoFor.


86 © Programação Orientada a Objetos

Figura 15 BlueJ: parâmetros do método main. Figura 16 BlueJ: mensagens.

Estrutura de repetição: comando while


Observe a seguir a forma geral do comando while:

[inicialização]
while ( encerramento ) {
comandos;
[iteração;]
}

Para exemplificar a utilização da estrutura de repetição while, criaremos uma nova classe no
BlueJ chamada “RepeticaoWhile”. Para tanto, utilize, como código da classe, a codificação a seguir:
código 6
class RepeticaoWhile
{
public static void main(String arg)
{
int i = 1;// inicialização de i
while (i <= 10)
{ // encerramento em 10
System.out.println(“i = “ + i + “ / Parâmetro: ”+ arg); // imprime o valor da
variavel i
i++; // iteracao para adicionar 1 em i
}
}
}

fim código 6

Compile e execute o método main da classe “RepeticaoWhile”, conforme apresentado na


Figura 17. Em seguida, realize a passagem de parâmetros, indicada na Figura 18, usando valores
do tipo String (com aspas duplas). Clique no botão "Ok” e visualize os valores gerados pelo laço
de repetição while (Figura 19). Execute novamente o programa trocando o valor do parâmetro
na janela de execução do método main.

Figura 17 BlueJ: menu classe RepeticaoWhile.

Centro Universitário Claretiano


© Linguagem Java 87

Figura 18 BlueJ: parâmetros do método main. Figura 19 BlueJ: mensagens.

Estrutura de repetição: comando do-while


A construção do-while executa pelo menos uma vez o corpo do laço, mesmo que a expres-
são boolean seja false da primeira vez.
Veja, a seguir, a forma geral do comando do-while.
[inicialização;]
do {
comandos; [iteração;]
} while (encerramento);

Para exemplificar a utilização da estrutura de repetição do-while, criaremos uma nova


classe no BlueJ chamada “RepeticaoDoWhile”. Para tanto, utilize, como código da classe, a co-
dificação a seguir:
código 7
class RepeticaoDoWhile
{
public static void main(String arg)
{
int i = 1;// inicializacao de i
do
{
System.out.println(“i = “ + i + “ / Parâmetro: ”+ arg); // imprime o valor da
variavel i
i++; // iteracao para adicionar 1 em i
} while (i <= 10); // encerramento em 10
}
}

fim código 7

Compile e execute o método main da classe “RepeticaoDoWhile”, conforme apresentado


na Figura 20. Em seguida, realize a passagem de parâmetros, indicada na Figura 21, usando
valores do tipo String (com aspas duplas). Clique no botão "Ok” e visualize os valores gerados
pelo laço de repetição do-while (Figura 22). Execute novamente o programa trocando o valor do
parâmetro na janela de execução do método main.

Figura 20 BlueJ: menu classe RepeticaoDoWhile.


88 © Programação Orientada a Objetos

Figura 21 BlueJ: parâmetros do método main. Figura 22 BlueJ: mensagens.


Todos os exemplos mencionados anteriormente fizeram a execução do método main por
meio das classes. Esse conjunto de exemplos possibilitou um maior contato com a sintaxe dos co-
mandos da linguagem Java. Neles, o método main foi definido com o modificador static que força
a execução direta pela classe, sem a necessidade da criação de objetos. Os métodos definidos com
o modificador static somente poderão ser executados pela classe e nunca pelos objetos.
A modelagem OO cria a classe como forma de representar objetos que apresentam carac-
terísticas similares; na criação dessa classe, são definidos os atributos e os métodos. Para possi-
bilitar uma melhor compreensão na programação orientada a objetos, vamos agora estudar as
características da linguagem Java referentes à definição de classes.

7. CRIAÇÃO DE CLASSES E OBJETOS


Antes de retornarmos à criação de objetos a partir das classes, é importante que você
conheça o formato completo de declaração de uma classe em Java. Lembre-se de que a classe
pode ter um número variado de atributos (variáveis) e métodos (funções). Observe, a seguir, o
formato geral da codificação de uma classe em Java.
package nome-pacote; // classes são organizadas em pacotes
import nome-pacote-importado; // permite a importação de classes
tipo-de-acesso class nome-classe // declaração da classe
{ // todo programa Java é definido como uma classe
/* Variáveis em Java:
tipo-acesso = public, private e protected
tipo = int, float, boolean, String, ...
var-instancia = nome da variável
*/
tipo-de-acesso tipo var-instancia1;
tipo-de-acesso tipo var-instancia2;
tipo-de-acesso tipo var-instanciaN;
/* Métodos em Java:
tipo-acesso = public, private e protected
tipo = valor a ser retornado(void, int, float, boolean, String, ...)
nome = nome do método
lista-de-parametros = ( ) ou ( tipo param1, tipo param2, ...)
*/
tipo-de-acesso tipo nome-método1(lista-de-parametros)
{
corpo do método; // contém comandos, variáveis, ...
}
tipo-de-acesso tipo nome-método2(lista-de-parametros)
{
corpo do método;
}
tipo-de-acesso tipo nome-métodoN(lista-de-parametros)
{
corpo do método;
}
}

Centro Universitário Claretiano


© Linguagem Java 89

Em Java, os atributos (variáveis) são declarados utilizando os tipos primitivos de dados


(boolean, byte, char, short, int, float, long, double), ou como objeto do tipo de uma classe (clas-
se do Java, por exemplo: String e Date, ou uma classe definida pelo programador, por exemplo:
Pessoa e Aluno).
Note que os atributos e os métodos de uma classe possuem controles para definir o seu
“tipo-de-acesso”. Tal controle é definido por meio de "modificadores de acesso", que permitem
compartilhar ou restringir a visibilidade dos atributos e métodos da classe às demais classes
existentes no sistema.
Assim, podemos dizer que os modificadores de acesso são importantes, pois controlam
o nível de Encapsulamento da classe, isto é, permitem definir a visibilidade que os atributos e
métodos da classe terão com relação às demais classes. Como regra, devemos sempre expor o
mínimo possível de funcionalidades, para criar um baixo acoplamento entre as nossas classes.
O Encapsulamento é fundamental para que seu sistema seja suscetível a mudanças. As-
sim, não precisaremos mudar uma regra de negócio em vários lugares, mas em apenas um único
lugar, já que essa regra está encapsulada.
A seguir, veremos os modificadores de tipo de acesso disponíveis na linguagem Java.

Modificadores de acesso (ou modificadores de visibilidade)


Os modificadores de tipo de acesso public, private e protected servem para controlar o
nível de acesso aos atributos e métodos da classe (Encapsulamento). São assim definidos:
• public: acesso público em que o atributo e/ou método pode ser utilizado por métodos
declarados dentro de outras classes.
• private: acesso privado em que o atributo e/ou método pode apenas ser acessado por
métodos declarados dentro da mesma classe.
• protected: acesso protegido em que o atributo e/ou método é acessado por meio de:
a) métodos dentro da mesma classe;
b) métodos de classes pertencentes ao pacote (package), no qual a classe é definida.
Um pacote (package) é uma estruturação que permite organizar as classes em pas-
tas ou diretórios, de modo que reúnam classes com relação sistêmica. Explicações
mais detalhadas podem ser obtidas na Unidade 4;
c) métodos de classes que herdam da classe (subclasses).
Você sabe o que acontece quando a declaração de um atributo e/ou método não possui
modificador de acesso? Nesse caso, identificamos esse tipo de declaração como default (pa-
drão). No acesso padrão, o atributo e/ou método são acessados por intermédio de métodos
dentro da mesma classe e por métodos de classes pertencentes ao pacote (package), no qual a
classe é definida.
Veja, a seguir, uma tabela-resumo sobre a visibilidade de atributos e/ou métodos, usando
os modificadores de acesso:

Tabela 1 Visibilidade de atributos e/ou métodos.


Atributos e/ou métodos private default protected public
Mesma classe SIM SIM SIM SIM
Mesmo pacote NÃO SIM SIM SIM
Pacote diferente (sendo subclasse) NÃO NÃO SIM SIM
Pacote diferente (não sendo subclasse) NÃO NÃO NÃO SIM
90 © Programação Orientada a Objetos

Método construtor
Um método que tem o mesmo nome da classe e que não apresenta tipos de retorno é
chamado Método Construtor. Um construtor é um método que inicializa um objeto imediata-
mente após sua criação (instanciação), atribuindo valores aos atributos do objeto. Após ser de-
finido, o método construtor é automaticamente chamado depois que o objeto é criado e antes
que o operador new termine sua execução.

Operador new
O operador new tem a função de criar um objeto (instância) com base em uma classe. Este
operador referencia o método construtor da classe para atribuir informações aos atributos do
objeto.
Para compreendermos melhor os conceitos anteriormente mencionados, considere uma
Classe Aluno, com os atributos: nome e ra e com os métodos Aluno e respondeChamada.

Aluno
nome
ra

Aluno
respondeChamada

Os atributos nome e ra serão codificados como do tipo "String". O método Aluno (método
construtor) receberá como parâmetros os dois valores do tipo “String", que serão utilizados para
atribuir valores aos atributos (variáveis) do objeto a ser criado. O método respondeChamada
exibirá uma mensagem na tela.
Crie uma nova classe no BlueJ chamada “Aluno”. Utilize como código da classe a codifica-
ção a seguir:
código 8
class Aluno
{
String nome, ra; // atributos
Aluno(String nome, String codigo) // método construtor com dois parâmetros
{
this.nome = nome; // Atribui o valor do parâmetro nome à variável nome.
ra = codigo; // atribui o valor do parâmetro ra à variável ra
}
void respondeChamada( ) // método sem parâmetros e sem retorno (void)
{
System.out.println( nome + “ está presente !”); // mostra mensagem
}
}

fim código 8

Operador this
O operador this utilizado na classe Aluno é necessário para referenciar o objeto corrente.
Assim, this.nome referencia o atributo nome do objeto, e não o parâmetro nome. Você deverá
utilizar o operador this sempre que os nomes dos atributos da classe forem iguais aos nomes
dos parâmetros de um método.

Centro Universitário Claretiano


© Linguagem Java 91

A classe Aluno não tem em sua codificação o método main, pois será utilizada apenas
como definição de classe. Para instanciarmos objetos com base na classe Aluno, precisaremos
criar outra classe chamada “ExecutaAluno”. Observe, a seguir, a implementação da classe Exe-
cutaAluno.java.
código 9
class ExecutaAluno
{ // classe de teste da classe Aluno
public static void main(String args[])
{
// variável fulano é do tipo “Aluno”
Aluno fulano;
// cria objeto via método construtor e associa o objeto criado à
// variável fulano
fulano = new Aluno(“Fulano de Tal”,”123456”);
// mostra os valores que estão armazenados no objeto fulano
// fulano.nome acessa a variável nome do objeto fulano
// fulano.ra acessa a variável ra do objeto fulano
System.out.println(“Nome = “ + fulano.nome + “ - RA = “ + fulano.ra);
// invoca um método do objeto fulano
fulano.respondeChamada();
}
}

fim código 9

A classe “ExecutaAluno” instancia um novo objeto aluno (variável fulano), com base nas
definições da classe “Aluno”. O método construtor recebe como parâmetros o nome e o ra do
aluno e os repassa em sua execução aos atributos do novo objeto instanciado.
A referência fulano.nome e fulano.ra permite acessar os atributos do objeto. Esse acesso
só é possível porque os atributos nome e ra estão acessíveis a todos os objetos. Já a referência
fulano.respondeChamada permite invocar o método respondeChamada sobre o objeto fulano.
Crie no BlueJ as classes “Aluno” e “ExecutaAluno”. Substitua o código-padrão gerado pelo
BlueJ pelos códigos anteriores correspondentes a cada uma das classes. Compile e execute o
método main da classe “ExecutaAluno”, conforme apresentado na Figura 23. Nessa execução,
não é necessária a passagem de parâmetros (Figura 24). Em seguida, clique no botão "Ok” e
visualize as mensagens retornadas pelo objeto criado na declaração do método main da classe
“ExecutaAluno”, conforme demonstra a Figura 25.
Note que, ao criarmos as duas classes, o BlueJ incluirá uma “seta” interligando as classes
“Aluno” e “ExecutaAluno”. Essa seta indica que a classe "ExecutaAluno" realiza referências em
seu código para a classe “Aluno”.

Figura 23 BlueJ: menu classe ExecutaAluno.


92 © Programação Orientada a Objetos

Figura 24 BlueJ: parâmetros do método main. Figura 25 BlueJ: mensagens.

É importante ressaltar que o papel desempenhado neste exemplo pela classe "ExecutaA-
luno" é instanciar objetos de modo similar ao processo realizado, manualmente, por meio das
interfaces visuais do BlueJ. A diferença fundamental entre as duas formas de execução é que o
processo de criação de objetos no BlueJ resulta em representações visuais na ferramenta. E o
processo de execução do método main da classe "ExecutaAluno" instancia objetos por meio de
alocação de memória, fato este que não é perceptível, visualmente, no momento da execução.
Neste material, apresentaremos os conceitos usando, preferencialmente, a interface visu-
al da ferramenta BlueJ. Uma vez que o conceito esteja compreendido, ele será aprofundado ao
modo de programação, utilizando métodos main, que correspondem, na prática, à forma pela
qual os objetos são trabalhados pelas linguagens de programação orientadas a objetos.

Método finalize
De forma análoga ao método construtor, o Java disponibiliza o método finalize que é exe-
cutado pela JVM sempre antes da destruição de um objeto.
Quando um objeto não é mais referenciado por nenhuma variável, a memória utiliza-
da por ele é retornada automaticamente como memória disponível para futuras alocações ao
computador. Este processo realizado pela JVM é conhecido como “coleta de lixo” (garbage col-
lection). Em Java, para destruir um objeto, basta tornar a referência ao objeto nula, usando a
indicação null. Quando a JVM, por meio do seu processo de “coleta de lixo”, localiza um objeto
que possui referência nula (null), ela realiza a destruição do objeto, porém, antes executa o mé-
todo finalize.
Assim, no momento da destruição do objeto, o método finalize é executado. É importante
salientar que não é necessário que você faça a codificação desse método dentro da classe, pois
este é nativo da linguagem Java para todo objeto instanciado na JVM. Se desejar, poderá rea-
lizar uma implementação particular para o método finalize em sua codificação de classe. Uma
motivação para realizar essa codificação diferenciada é adicionar algum controle específico, ou
executar de algum comando particular antes da destruição do objeto.

Exceções (Exception)
Uma característica importante do Java, que auxilia a tornar os programas mais robustos, é
o manuseio de exceções (Exception). Uma exceção é disparada ou gerada quando algum tipo de
erro ou falha ocorreu durante a execução do código. Com a ajuda dos comandos try { } / catch {
} / finally { }, é possível agrupar todo o código de manipulação de erros em um único local, o que
simplifica a tarefa de manipulação e recuperação de erros.

Centro Universitário Claretiano


© Linguagem Java 93

Uma exceção (Exception) também pode ser “disparada” pelo programador, com o intuito
de gerar formas de controle para certos tratamentos de erro. Nesse caso, o comando “throw
new Exception();”, presente dentro de um comando try { },será utilizado para gerar uma exceção.
Ao ser gerada uma exceção, o comando catch { }, mais próximo do comando try { }, que trata a
exceção compatível com o tipo da exceção disparada, será o responsável por seu tratamento.
É importante diferenciar os termos finalize e finally. O termo finalize corresponde ao mé-
todo executado pela JVM antes da destruição de objetos e liberação de memória. O termo fi-
nally corresponde ao comando que será sempre precedido do comando try { } e ao bloco de
instruções, que serão executadas após o término da execução dos comandos definidos dentro
do try { } e/ou dentro do catch { } que recebeu alguma exceção gerada pelo try { }.
Veja, a seguir, em negrito, as modificações necessárias para incluir, no código da classe
“ExecutaAluno”, o tratamento de exceções. Recomendamos a você que realize tais modificações
em seu código, compile (Figura 23) e execute novamente o método main da classe “ExecutaAlu-
no” (Figura 24). Note que as mensagens exibidas (Figura 25) são as mesmas da execução ante-
rior à inclusão do tratamento de exceções. Isso ocorre porque nenhuma exceção foi disparada,
resultando na execução padrão prevista na classe.
código 10
class ExecutaAluno
{ // classe de teste da classe Aluno
public static void main(String args[])
{ // método que inicia o teste
// variável fulano é do tipo “Aluno”
Aluno fulano;
try {

// cria objeto via método construtor e associa o objeto criado a


// variável fulano
fulano = new Aluno(“Fulano de Tal”,”123456”);
// mostra os valores que estão armazenados no objeto fulano
// fulano.nome acessa a variável nome do objeto fulano
// fulano.ra acessa a variável ra do objeto fulano
System.out.println(“Nome = “ + fulano.nome + “ - RA = “ + fulano.ra);
// invoca um método do objeto fulano
fulano.respondeChamada();

} catch(Exception e) {
// inserir aqui o tratamento das exceções
System.out.println(e.getMessage()); // exibe a mensagem correspondente à exceção
ocorrida
}finally {
// inserir aqui os últimos comandos da execução de método
fulano = null; // Finaliza o objeto fulano e libera seu espaço de memória para outras
alocações
}
}
}

fim código 10

Como resultado final dos exemplos implementados nesta unidade, você terá, na ferra-
menta BlueJ, as seguintes classes criadas:
94 © Programação Orientada a Objetos

Figura 26 Classes criadas na ferramenta BlueJ.

8. EXEMPLO PRÁTICO
Nesta unidade, você teve a oportunidade de ter um maior contato com a linguagem Java.
Aprendeu a criar classes que conseguem instanciar objetos e interagir com eles por meio da
chamada de métodos. Aproveitando esse conhecimento adquirido, vamos agora aprimorar um
pouco mais a implementação do nosso projeto sobre o sistema de controle de orientações e
defesas de TCC.
Antes de realizarmos qualquer comentário sobre as novas implementações, vamos exe-
cutar a ferramenta BlueJ e preparar nosso ambiente de desenvolvimento. Possivelmente sua
ferramenta BlueJ está atualmente exibindo as classes do projeto "poo". Precisamos retornar ao
projeto "tcc" para continuar o desenvolvimento do novo sistema. Assim, recomendamos a você
que feche o atual projeto ("poo") e abra o projeto "tcc", localizado em seu computador.
Uma vez que a ferramenta BlueJ exiba as classes do projeto “tcc”, então poderemos con-
tinuar o desenvolvimento do novo projeto. Você aprendeu que a linguagem Java permite, por
meio do operador new, instanciar novos objetos com base no método construtor definido den-
tro da classe. Além disso, a linguagem Java permite associar os objetos instanciados a variáveis.
Essas variáveis tornam-se referências para acesso e uso dos objetos.
Em vez de realizarmos a criação de objetos do tipo Aluno, Curso, Coordenador, Tcc, Banca e
Professor, usando a ferramenta BlueJ, utilizaremos agora o operador new dentro de uma nova clas-
se, denominada “Executa”, que deverá ser criada, exclusivamente, para instanciarmos os objetos
do novo sistema. A instanciação de objetos usando o BlueJ se dá de modo mais visual, enquanto a
criação de objetos pelo Java é realizada apenas em memória, e o acesso aos dados armazenados
nos objetos somente poderá ser feito usando a invocação de métodos sobre os objetos.
Vamos agora utilizar a interface do BlueJ para criarmos uma nova classe chamada “Exe-
cuta”, que possuirá o código-fonte padrão gerado pela ferramenta. Esse código-padrão deverá
ser substituído pelo código exibido a seguir. Note que muitos comentários foram adicionados
ao código, porém você não precisa reproduzi-los na codificação de sua classe. Tais comentários
servem, principalmente, para que você tenha uma melhor orientação sobre cada uma das linhas
de código utilizadas.

Centro Universitário Claretiano


© Linguagem Java 95

código 11
class Executa
{ // classe de teste do projeto tcc
public static void main(String args[]) // método que inicia o teste
{
Aluno jose; // variável jose é do tipo Aluno
Curso computacao; // variável computacao é do tipo Curso
Coordenador carlos; // variável carlos é do tipo Coordenador
Tcc trabalho; // variável trabalho é do tipo Tcc
Banca banca; // variável banca é do tipo Banca
Professor paulo; // variável paulo é do tipo Professor

try {
// cria objeto usando o método construtor e
// associa o objeto criado a variável do tipo correspondente
jose = new Aluno(“Jose”,”111111”);
jose.exibeInformacoes(); // invoca um método sobre o objeto

computacao = new Curso(“Computação”,”COMP”,”exatas”);


computacao.exibeInformacoes(); // invoca um método sobre o objeto

carlos = new Coordenador(“123”,”40”);


carlos.exibeInformacoes(); // invoca um método sobre o objeto

trabalho = new Tcc(“Orientação a Objetos”, 2010, “Aprovado”, 9);


trabalho.exibeInformacoes(); // invoca um método sobre o objeto

banca = new Banca(“01/06/2010”,”Favorável”);


banca.exibeInformacoes(); // invoca um método sobre o objeto

paulo = new Professor(“Paulo”,”Mestrado”,”paulo@email.com”);


paulo.exibeInformacoes(); // invoca um método sobre o objeto

} catch(Exception e) {
// inserir aqui o tratamento das exceções
// exibe a mensagem correspondente à exceção ocorrida
System.out.println( e.getMessage() );
} finally {
// inserir aqui as últimas instruções a serem executadas após o bloco try / catch
// finaliza os objetos para liberar espaço de memória para outras alocações
jose = null; // finaliza objeto do tipo Aluno
computacao = null; // finaliza objeto do tipo Curso
carlos = null; // finaliza objeto do tipo Coordenador
trabalho = null; // finaliza objeto do tipo Tcc
banca = null; // finaliza objeto do tipo Banca
paulo = null; // finaliza objeto do tipo Professor
}
}
}

fim código 11

A classe Executa realiza a instanciação de vários objetos, conforme as Classes Aluno, Cur-
so, Coordenador, Tcc, Banca e Professor, que foram definidas no projeto do novo sistema. Des-
tacamos, a seguir, os principais passos que devem ser utilizados para a instanciação de objetos,
usando a linguagem Java:
1) Declaração de uma variável do tipo da classe (exemplo: Curso computacao;)
2) Utilização do operador new para chamar o método construtor da classe e associar o
novo objeto criado com a variável compatível com o tipo do objeto (exemplo: compu-
tacao = new Curso(“Computação”,”COMP”,”exatas”);)
3) Invocação de métodos sobre o objeto instanciado (exemplo: computacao.exibeInfor-
macoes();)
4) Retirada da alocação de memória dos objetos não mais utilizados (exemplo: compu-
tacao = null;)
96 © Programação Orientada a Objetos

Após realizar a substituição do código-padrão pelo código modificado, você deverá compi-
lar a classe. Note que o BlueJ adicionará, no ambiente de desenvolvimento, várias setas interli-
gando a classe Executa às demais classes do projeto. A Figura 27 exibe a ferramenta BlueJ com
as classes em um posicionamento diferente. Você pode mudar a posição das classes mantendo
pressionado o botão esquerdo do mouse sobre a classe e arrastando-a para uma nova posição.

Figura 27 BlueJ: Classe Executa e suas interligações.

Figura 28 BlueJ: parâmetros do método main. Figura 29 BlueJ: menu Classe Executa.

Em relação ao código, a classe Executa possui um formato diferente das demais classes
do projeto. Ela não possui o método construtor, pois não temos a intenção de criar objetos do
tipo Executa. Em vez disso, a classe Executa possui um método main, que servirá apenas para
execução de comandos. Para executar o método main, você deve clicar com o botão direito do
mouse sobre a classe Executa e escolher a opção "void main(String[])” (Figura 29).

Centro Universitário Claretiano


© Linguagem Java 97

Como resultado dessa ação, o BlueJ exibirá uma nova janela (Figura 28) para a passagem
de parâmetros. Não precisamos de parâmetros para executar o método main, assim, apenas cli-
que no botão "Ok”, e uma nova janela (terminal) será aberta para exibir as mensagens impressas
pela execução do método main.
Informações sobre Aluno:
Nome: Jose
Ra: 111111
Informações sobre Curso:
Nome: Computação
Sigla: COMP
Area: exatas
Informações sobre Coordenador:
Ramal: 123
Carga Horária: 40
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
Situação: Aprovado
Nota: 9.0
Informações sobre a Banca:
Data: 01/06/2010
Parecer: Favorável
Informações sobre o Professor:
Nome: Paulo
Titulação: Mestrado
Email: paulo@email.com

Note que as informações impressas no terminal de mensagens da ferramenta BlueJ cor-


respondem exatamente aos dados que estão armazenados nos objetos. Esses dados foram re-
passados pelos métodos construtores que são responsáveis pela alocação de memória para
cada objeto, bem como são responsáveis pela iniciação dos atributos de cada um deles.
A codificação da classe Executa exemplifica como a linguagem Java permite que objetos
sejam instanciados usando como base as classes já definidas. Na Unidade 2, realizamos a imple-
mentação de classes que possuíam: atributos, métodos construtores e métodos de acesso. Note
que, na codificação da classe Executa, as classes criadas na Unidade 2 serviram como tipo de
dado para definirmos as variáveis que serviram de referência aos novos objetos instanciados.
Parabéns! Concluímos mais uma etapa do projeto do novo sistema de controle de orien-
tações e defesas de TCC. Na próxima unidade, iremos realizar muitas modificações no código,
pois precisaremos tratar as relações de herança, agregação e associação que existem entre as
classes do sistema.

9. QUESTÕES AUTOAVALIATIVAS
É chegado o momento de verificar o seu desempenho do seu estudo referente ao conteú-
do desta unidade. Portanto, realize as questões autoavaliativas a seguir.
1) Com base na questão autoavaliativa 4 da Unidade 2 e considerando o sistema de uma faculdade e as classes
Funcionário, Departamento e Projeto, definidas anteriormente com cinco características, adicione nos códigos-
fonte Java de cada uma das classes os métodos de acesso para cada um dos atributos definidos nas classes.

2) Com base na linguagem Java, explique a utilização do operador new.

3) Com base na questão autoavaliativa 1, crie uma nova classe chamada “ExecutaFaculdade”, que deverá conter o
método executável main e instanciar nele um objeto do tipo Funcionario, Departamento e Projeto.

4) Explique como funciona o tratamento de exceções em Java.

5) Com base na linguagem Java, explique a utilização do operador static.


98 © Programação Orientada a Objetos

Gabarito
Confira, a seguir, as respostas corretas para as questões autoavaliativas propostas:
1) Nesta questão, você deverá reescrever o código-fonte na linguagem Java de cada uma das classes que você
definiu na questão autoavaliativa 4 da Unidade 2. A codificação dos três métodos, inicialmente identificados
para cada uma das classes, continua sendo omitida, pois não possuímos orientações suficientes sobre como
eles deveriam ser implementados. Acompanhe, nas linhas em negrito a seguir, as modificações necessárias
referentes aos métodos de acesso.

código 1
public class Funcionario
{
private String nome, codigoFuncionario, telefone, endereco, dataDeContratacao;

/**
* Método Constructor da classe Funcionario
*/
public Funcionario(String nome, String codigoFuncionario, String telefone, String
endereco, String dataDeContratacao)
{
// iniciação das variaveis da instância
this.nome = nome;
this.codigoFuncionario = codigoFuncionario;
this.telefone = telefone;
this.endereco = endereco;
this.dataDeContratacao = dataDeContratacao;
}

/**
* Método que exibe informações sobre Funcionario
*/
public void exibeInformacoes( )
{
System.out.println(“Informações sobre Funcionário:”);
System.out.println(“Nome: “ + nome);
System.out.println(“Código: “ + codigoFuncionario);
System.out.println(“Telefone: “ + telefone);
System.out.println(“Endereço: “ + endereco);
System.out.println(“Data de Contratação: “ + dataDeContratacao);
}

/**
* Métodos De acesso
*/
public String getNome()
{
return nome;
}

public String getCodigoFuncionario()


{
return codigoFuncionario;
}

public String getTelefone()


{
return telefone;
}

public String getEndereco()


{
return endereco;
}

public String getDataDeContratacao()


{
return dataDeContratacao;
}

public void setNome(String nome)


{

Centro Universitário Claretiano


© Linguagem Java 99
this.nome = nome;
}

public void setCodigoFuncionario(String codigoFuncionario)


{
this.codigoFuncionario = codigoFuncionario;
}

public void setTelefone(String telefone)


{
this.telefone = telefone;
}

public void setEndereco(String endereco)


{
this.endereco = endereco;
}

public void setDataDeContratacao(String dataDeContratacao)


{
this.dataDeContratacao = dataDeContratacao;
}
}

fim código 1

código 2
public class Departamento
{
private String nome, sigla, descricao, dataDeCriacao, localizacao;

/**
* Método Constructor da classe Departamento
*/
public Departamento(String nome, String sigla, String descricao, String dataDeCriacao,
String localizacao)
{
// iniciação das variaveis da instância
this.nome = nome;
this.sigla = sigla;
this.descricao = descricao;
this.dataDeCriacao = dataDeCriacao;
this.localizacao = localizacao;
}
/**
* Método que exibe informações sobre Departamento
*/
public void exibeInformacoes( )
{
System.out.println(“Informações sobre Departamento:”);
System.out.println(“Nome: “ + nome);
System.out.println(“Sigla: “ + sigla);
System.out.println(“Descrição: “ + descricao);
System.out.println(“Data de Criação: “ + dataDeCriacao);
System.out.println(“Localização: “ + localizacao);
}

/**
* Métodos De acesso
*
*/
public String getNome()
{
return nome;
}

public String getSigla()


{
return sigla;
}

public String getDescricao()


{
return descricao;
100 © Programação Orientada a Objetos

public String getDataDeCriacao()


{
return dataDeCriacao;
}

public String getLocalizacao()


{
return localizacao;
}

public void setNome(String nome)


{
this.nome = nome;
}

public void setSigla(String sigla)


{
this.sigla = sigla;
}

public void setDescricao(String descricao)


{
this.descricao = descricao;
}

public void setDataDeCriacao(String dataDeCriacao)


{
this.dataDeCriacao = dataDeCriacao;
}

public void setLocalizacao(String localizacao)


{
this.localizacao = localizacao;
}
}

fim código 2

código 3
public class Projeto
{
private String codigo, descricao, dataDeInicio, dataDeTermino, situacao;
/**
* Método Constructor da classe Projeto
*/
public Projeto(String codigo, String descricao, String dataDeInicio, String
dataDeTermino, String situacao)
{
// iniciação das variaveis da instância
this.codigo = codigo;
this.descricao = descricao;
this.dataDeInicio = dataDeInicio;
this.dataDeTermino = dataDeTermino;
this.situacao = situacao;
}

/**
* Método que exibe informações sobre Projeto
*/
public void exibeInformacoes( )
{
System.out.println(“Informações sobre Projeto:”);
System.out.println(“Código: “ + codigo);
System.out.println(“Descrição: “ + descricao);
System.out.println(“Data de Início: “ + dataDeInicio);
System.out.println(“Data de Término: “ + dataDeTermino);
System.out.println(“Situação: “ + situacao);
}

/**
* Métodos De acesso
*

Centro Universitário Claretiano


© Linguagem Java 101
*/
public String getCodigo()
{
return codigo;
}

public String getDescricao()


{
return descricao;
}

public String getDataDeInicio()


{
return dataDeInicio;
}

public String getDataDeTermino()


{
return dataDeTermino;
}

public String getSituacao()


{
return situacao;
}

public void setCodigo(String codigo)


{
this.codigo = codigo;
}

public void setDescricao(String descricao)


{
this.descricao = descricao;
}

public void setDataDeInicio(String dataDeInicio)


{
this.dataDeInicio = dataDeInicio;
}

public void setDataDeTermino(String dataDeTermino)


{
this.dataDeTermino = dataDeTermino;
}

public void setSituacao(String situacao)


{
this.situacao = situacao;
}

fim código 3

2) O operador new da linguagem Java está relacionado à instanciação de objetos. Seu uso é realizado junto com
a invocação do método construtor de uma classe. Como resultado dessa combinação, é instanciado um objeto
em memória que imediatamente tem atribuída sua referência a uma variável declarada como do mesmo tipo
da classe do objeto. Essa variável é que tornará acessível o objeto dentro da programação Java. Acompanhe, a
seguir, um exemplo da utilização do operador new para instanciar um objeto do tipo Funcionário.

Funcionario jose = new Funcionario (“José”, “112233”, “1234-5678”, “Rua da Matriz, 500,
centro, São Paulo, SP”, “10/03/2009”);

3) Nesta questão, você deverá recordar como se declara um método executável em Java. O método main é o mé-
todo que permite realizar sua execução e não exige que um objeto da classe seja instanciado. Vamos declarar o
método main dentro da classe ExecutaFaculdade. Essa classe servirá apenas para criarmos uma classe que irá
utilizar as classes previamente declaradas.
Conforme o enunciado da questão, você deverá instanciar objetos dentro do método main da classe ExecutaFacul-
dade. A instanciação de objetos em Java se dá pelo uso do operador new, invocado sobre um método construtor.
A questão 1 apresentou um exemplo de aplicação dele. Acompanhe, no código a seguir, uma possível codificação
para a classe ExecutaFaculdade.
102 © Programação Orientada a Objetos

código 4
public class ExecutaFaculdade
{ // classe de teste
public static void main(String args[]) // método executável
{
Funcionario jose; // variável jose é do tipo Funcionario
Departamento info; // variável depart é do tipo Departamento
Projeto web; // variável proj é do tipo Projeto

try {
// cria objeto usando o método construtor e
// associa o objeto criado a variável do tipo correspondente

jose = new Funcionario (“José”, “112233”, “1234-5678”, “Rua da Matriz, 500,


centro, São Paulo, SP”, “10/03/2009”);
jose.exibeInformacoes(); // invoca um método sobre o objeto

info = new Departamento (“Informatica”, “INFO”, “Departamento de Informática”,


“01/03/2008”, “Bloco A”);
info.exibeInformacoes(); // invoca um método sobre o objeto

web = new Projeto (“WEB”, “Projeto de Web”, “03/05/2009”, “12/01/2010”,


“Finalizado”);
web.exibeInformacoes(); // invoca um método sobre o objeto

} catch(Exception e) {
// exibe a mensagem correspondente à exceção ocorrida
System.out.println( e.getMessage() );
} finally {
// finaliza os objetos para liberar espaço de memória para outras alocações
jose = null; // finaliza objeto do tipo Funcionario
info = null; // finaliza objeto do tipo Departamento
web = null; // finaliza objeto do tipo Projeto
}
}
}
fim código 4

4) As exceções constituem uma importante característica da linguagem Java e auxiliam a tornar os programas mais
robustos e confiáveis. Uma exceção é disparada ou gerada quando algum tipo de erro ou falha ocorreu durante
a execução do código. Com a ajuda dos comandos try { } e catch { }, é possível agrupar todo o código de manipu-
lação de erros em um único local, o que simplifica a tarefa de manipulação e recuperação de erros.

Uma exceção (Exception) também pode ser “disparada” pelo programador com o intuito de gerar formas de con-
trole para certos tratamentos de erro. Nesse caso, o comando “throw new Exception();”, presente dentro de um
comando try { }, será utilizado para gerar uma exceção. Ao ser gerada uma exceção, o comando catch { }, mais
próximo do comando try { }, que trata a exceção compatível com o tipo da exceção disparada, será o responsável
por seu tratamento.
O comando finally { } corresponde ao comando que será sempre precedido do comando try { } e ao bloco de ins-
truções que serão executadas após o término da execução dos comandos definidos dentro do try { } e/ou dentro
do catch { } que recebeu alguma exceção gerada pelo try { }.

5) O operador static é utilizado para criar uma referência direta à classe. Seu uso pode ser feito junto a métodos ou
atributos. O operador static, quando utilizado com um método, indica que o método será invocado diretamen-
te sobre a classe, e não sobre os objetos instanciados por ela. O operador static também pode ser utilizado em
atributos e resulta na criação de um atributo da classe (global), que é acessível a todos os objetos instanciados
a partir da classe.

10. CONSIDERAÇÕES
Nesta unidade, você teve a oportunidade de aprender os tipos de dados e a sintaxe dos
principais comandos da linguagem Java. Aprendeu a estrutura geral e como uma classe é defi-
nida em Java, além de criar um programa que permite instanciar objetos por meio de progra-
mação.

Centro Universitário Claretiano


© Linguagem Java 103

Não pretendemos esgotar todo o assunto sobre a linguagem Java, mas oferecer uma visão
sobre os principais conceitos. Assim, para aprofundar seus conhecimentos relacionados a essa
linguagem, recomendamos o estudo adicional por meio de livros e interação em fóruns sobre a
linguagem.
Ao final do estudo deste conteúdo, você criou, pela primeira vez, um objeto com base nas
definições realizadas em uma classe.
Recomendamos, para uma maior compreensão dos conceitos da linguagem Java, a repro-
dução dos exemplos estudados em seu computador.

11. E-REFERÊNCIAS
BLUEJ. The interactive Java environment. Disponível em:<http://www.bluej.org>. Acesso em: 09 dez. 2010.
SUN DEVELOPERS NETWORK (SDN). Sun microsystems. Disponível em:<http://java.sun.com>. Acesso em: 09 dez. 2010.

12. REFERÊNCIAS BIBLIOGRÁFICAS


CADENHEAD, R.; LEMAY, L. Aprenda em 21 dias Java 2. Tradução de Daniel Vieira. 4. ed. Rio de Janeiro: Elsevier, 2005.
DEITEL, H. M.; DEITEL, P. J. Java: como programar. Tradução de Edson Furmankiewicz. 6. ed. São Paulo: Pearson Prentice Hall,
2007.
BOOCH, G.; RUMBAUGH, J.; JACOBSON, I. UML: guia do usuário. Tradução de Fábio Freitas da Silva et al. 2 ed. rev. atual. Rio de
Janeiro: Elsevier, 2005.
EAD
Relacionamento entre Objetos

1. OBJETIVOS
• Implementar em linguagem Java os conceitos de Herança, agregação e associação.
• Compreender diagramas de classes da UML.

2. CONTEÚDOS
• Herança.
• Agregação.
• Associação.
• Diagrama de classes da UML.
• Classes abstratas.

3. ORIENTAÇÕES PARA O ESTUDO DA UNIDADE


Antes de iniciar o estudo desta unidade, é importante que você leia as orientações a se-
guir:
1) Fique atento a todo o conteúdo desta unidade, na qual você encontrará conceitos
importantes para sua aprendizagem.
2) Volte às unidades anteriores para entender e recordar os conceitos propostos. Consul-
te sempre o Glossário quando surgirem ideias que ainda não foram completamente
assimiladas.
106 © Programação Orientada a Objetos

4. INTRODUÇÃO À UNIDADE
Nas unidades anteriores, você teve a oportunidade de compreender os conceitos básicos
sobre a linguagem Java, configurou o ambiente de desenvolvimento Java e conheceu a sintaxe
dos principais comandos desta linguagem.
Nesta unidade, você poderá ampliar seus estudos sobre a programação orientada a obje-
tos, analisando mais profundamente os conceitos da Orientação a Objetos aplicados à lingua-
gem de programação Java. Para isso, nosso foco estará na criação de objetos e na construção de
relacionamentos entre classes, aprofundando, assim, a programação com a linguagem Java e a
interpretação de diagramas de classes da UML.
Iniciaremos esta unidade apresentando alguns conceitos importantes sobre a linguagem Java.
Bom estudo!

5. CONCEITOS RELACIONADOS À LINGUAGEM JAVA


Para iniciar o estudo desta unidade, é fundamental que você relembre os conteúdos es-
tudados até o momento. Dessa forma, vamos recordar, na Unidade 1, estudamos os principais
conceitos relacionados à orientação a objetos. Na Unidade 2, aprendemos como funciona um
programa escrito em linguagem Java, bem como criamos objetos, com base nas definições de
uma classe. Na Unidade 3, vimos mais detalhes a respeito da linguagem Java e instanciamos
objetos por meio de métodos. Na Unidade 4, prosseguiremos nossos estudos com a programa-
ção Java, enfatizando os conceitos da orientação a objetos relacionados aos diferentes tipos de
relacionamentos existentes entre classes.
Ao final da Unidade 1, também estudamos os conceitos de Herança, agregação e associa-
ção e agrupamos tais conceitos em um único diagrama denominado diagrama de classes. Esse
diagrama faz parte da linguagem de modelagem orientada a objetos, denominada UML, que
se baseia na criação de diversos diagramas para a representação dos conceitos que norteiam a
modelagem de um sistema. Esta etapa de modelagem é realizada por um analista de sistemas e
antecede à implementação do próprio sistema.
A modelagem UML é neutra em relação à linguagem que será utilizada para implementar
o sistema. A preocupação no momento da modelagem não é como será implementado, mas,
sim, o que será implementado.
Ao receber um diagrama de classes, os programadores analisam a especificação e identi-
ficam os conceitos que deverão ser implementados, utilizando uma linguagem de programação,
de preferência orientada a objetos. O diagrama de classes servirá como especificação, direcio-
nando o trabalho dos programadores. Desse modo, vamos analisar, a seguir, um diagrama de
classes.

Diagrama de classes da UML


O diagrama, a seguir, corresponde a um sistema simplificado de uma biblioteca e será de-
senvolvido passo a passo ao longo desta unidade.

Centro Universitário Claretiano


© Relacionamento entre Objetos 107

retira
Pessoa Livro
ASSOCIAÇÃO
nome nome
dataDeNascimento editora
isbn

Pessoa Livro
retiraLivro emprestaLivro
getNome getNome
setNome setNome
getData getEditora
setData AGRAGAÇÃO setEditora
getIsbn
HERANÇA setIsbn
tem

Professor 1 Telefone
Aluno

ra titulacao ddd
curso dataContratacao numero

Aluno Professor Telefone


getRa getTitulacao getDdd
setRa setTitulacao SetDdd
getCurso getDataContratacao getNumero
setCurso setDataContratacao setNumero

Figura 1 Diagrama de classes.

No diagrama da Figura 1, temos cinco classes representadas, são elas: Pessoa, Aluno, Pro-
fessor, Livro e Telefone. As classes relacionam-se entre si de diferentes maneiras. Acompanhe,
no Quadro 1, como ocorre esse relacionamento.

Quadro 1 Tipos de relacionamento entre classes.


RELACIONAMENTO SÍMBOLO CLASSES RELACIONADAS

Aluno (subclasse) e Professor


Herança (subclasse) são filhas da classe Pessoa
(superclasse).

Pessoa (agregador) tem Telefone


Agregação
(agregado).

Pessoa associa-se com Livro e vice-


Associação
versa.
108 © Programação Orientada a Objetos

6. ORGANIZAÇÃO DAS CLASSES DE UM SISTEMA


Antes de iniciarmos a programação orientada a objetos, é necessário compreendermos
que as classes em Java podem ser organizadas em pacotes (packages). Tais pacotes têm como
finalidade manter agrupadas as classes que tenham vínculo, como aquelas pertencentes a um
mesmo módulo de um sistema ou classes que são partes de um componente. Os pacotes ofere-
cem mecanismos de nomeação e de restrição de visibilidade.

Pacotes (Packages)
Para organizar as classes em Java, primeiro é permitida, em um arquivo Java, a declaração
de um package, que diz ao compilador em qual pacote as classes serão definidas. Se você omitir
a declaração package, as classes serão definidas no pacote-padrão que não tem nome.
O compilador Java utiliza os diretórios do sistema de arquivo para armazenar os pacotes.
Assim, se você declarar uma classe dentro de um pacote chamado meupacote, então o arquivo-
fonte daquela classe estará armazenado em um diretório chamado meupacote. Lembre-se de
que as letras maiúsculas e minúsculas do diretório devem corresponder àquelas do nome do
pacote.
A forma geral da declaração package é:
package pac1.pac2.pac3;

Como exemplo de declaração de pacotes, temos:


package escola.secretaria;
package escola.biblioteca.emprestimo;

Podem ser criadas hierarquias de pacotes dentro de um pacote, separando os níveis com
pontos. Lembre-se de que essas hierarquias devem refletir no sistema de arquivos de seu am-
biente de desenvolvimento Java.
Para codificar as classes do diagrama da Figura 1, adotaremos o package biblioteca como
pacote das classes que desenvolveremos. Para isso, é preciso executar a ferramenta BlueJ e
realizar a criação de um pacote. Ao executar o BlueJ, o último projeto utilizado será reexibido.
Recomendamos a você que utilize o projeto "poo" neste momento. Caso o BlueJ não exiba o
projeto "poo", então feche o atual projeto, acesse o menu “Project” (Projeto) e escolha a opção
"Close” (Fechar).
Para abrir o antigo projeto “poo”, acesse o menu “Project" e escolha a opção "Open Pro-
ject" (Abrir Projeto), o que resultará na abertura de uma nova janela, parecida com um geren-
ciador de arquivo, que possibilitará a escolha do projeto "poo". Caso você tenha seguido nossas
orientações do início desta obra, o projeto "poo" estará acessível em "C:\poo".
Para criar um pacote no BlueJ, você pode usar a opção do menu superior “Edit" (Editar) e
selecionar a opção "New Package...” (Novo Pacote). Como resultado dessa operação, uma nova
janela será exibida (Figura 2). Você deverá digitar o nome "biblioteca" e clicar no botão "Ok"
para confirmar a operação. Ao finalizar esse procedimento, um novo símbolo será exibido na
área de visualização de classes da ferramenta BlueJ, conforme demonstra a Figura 3.

Centro Universitário Claretiano


© Relacionamento entre Objetos 109

Figura 2 Definição de pacote. Figura 3 Pacote biblioteca no BlueJ.

Na prática, um novo pacote na linguagem de programação Java corresponderá a uma nova


pasta para armazenamento de classes. O pacote chamado “biblioteca” será uma pasta de nome
"biblioteca" dentro do projeto "poo". Pacotes podem ser criados dentro de pacotes, gerando
subpastas dentro de pastas. Recomendamos que utilize o gerenciador de arquivos de seu com-
putador e verifique o conteúdo da pasta "c:\poo".
Assim, no BlueJ, para criarmos classes dentro do pacote "biblioteca", você deverá dar um
clique duplo com o botão esquerdo do mouse sobre o símbolo do pacote (Figura 3). Como resul-
tado, a ferramenta exibirá uma nova janela, conforme demonstra a Figura 4, apresentando uma
nova área em branco para a criação de classes. Desse modo, para criar classes nessa nova área,
você deverá seguir os mesmos procedimentos usados na Unidade 2.
Dentro da área de trabalho dos pacotes, você encontrará um símbolo semelhante à repre-
sentação de pacotes, porém identificado pelo nome "go up" (subir). Essa opção ficará sempre
acessível dentro dos pacotes da ferramenta BlueJ, pois, por meio dela, você poderá subir ou
retornar ao nível anterior do pacote (no nosso caso, o nível raiz em que se encontram as outras
classes do projeto "poo"). Para subir ou retornar ao nível anterior do pacote, basta dar um clique
duplo com o botão esquerdo do mouse sobre a pasta “go up” (Figura 4).

Figura 4 Visão inicial do pacote biblioteca no BlueJ.


110 © Programação Orientada a Objetos

Uma vez que o pacote "biblioteca" esteja criado e acessível no BlueJ (Figura 4), inicia-
remos a codificação das classes, seguindo as indicações do diagrama da UML apresentado na
Figura 1.

7. INICIANDO A CODIFICAÇÃO DA CLASSE PESSOA NO PACOTE BIBLIOTECA


Iniciaremos a implementação pela classe Pessoa, mas antes é necessário analisar os tipos
de dados e os modificadores de acesso que serão utilizados nos atributos da classe. O diagrama
de classes da Figura 1 não traz informações a respeito desses detalhes. Assim, definiremos, para
as implementações desta unidade, que as classes e os métodos serão de acesso público (public).
Já os atributos serão definidos como privados (private), com acesso restrito apenas à própria
classe. A utilização de atributos privados nas classes reforça o conceito de Encapsulamento, pois
isola os detalhes internos da classe dos objetos externos.

Métodos de acesso (gets e sets)


Para que os atributos da classe sejam acessíveis a outras classes, a Orientação a Objetos
convenciona a criação de métodos de acesso ou métodos acessores. No diagrama de classes da
Figura 1, é possível verificar a existência de um par de métodos para cada um dos atributos da
classe. Por exemplo, na classe Pessoa, temos o atributo nome que é acessível pelos métodos
getNome e setNome.
O método getNome retorna o valor do atributo nome de um objeto do tipo "Pessoa". Já
o método setNome recebe como parâmetro um valor que atualizará o atributo nome do objeto
que executou o método. Convenciona-se a utilização dos prefixos get e set para definição dos
métodos de acesso das classes Java.
Ressaltamos que os prefixos get e set, usados no início dos nomes dos métodos de acesso,
são apenas recomendações, e não são exigências da linguagem Java, porém fazem parte de uma
convenção adotada pelos programadores da linguagem Java e de outras linguagens orientadas
a objetos.
Esta unidade será prática. Para compreender como são implementadas as classes em um
diagrama, é necessário que você reproduza todos os códigos contidos neste material, compile
os programas e acompanhe cada passo descrito.
Com base no diagrama da UML e nas considerações anteriores, teremos a seguinte codifi-
cação para a classe Pessoa. Crie uma nova classe na ferramenta BlueJ chamada “Pessoa”, dentro
do pacote “biblioteca”. Utilize como código da classe a seguinte codificação:
código 1
package biblioteca; // pacote biblioteca
public class Pessoa
{ // classe Pessoa
private String nome; // atributo privado
private String dataDeNascimento; // atributo privado
// Método construtor
public Pessoa(String nome, String data) // método construtor com dois parâmetros
{
// Atribui o valor do parâmetro nome à variável nome
this.nome = nome;
// atribui o valor do parâmetro data à variável dataDeNascimento
dataDeNascimento = data;
}

Centro Universitário Claretiano


© Relacionamento entre Objetos 111
void retiraLivro( ) // método
{
// sem implementação no momento
}
public String getNome() // método acessor (GET) do atributo nome
{
return nome; // retorna valor do atributo
}
public void setNome(String nome) // método acessor (SET) do atributo nome
{
this.nome = nome; // atualiza atributo com o valor do parâmetro
}
public String getData() // método acessor (GET) do atributo dataDeNascimento
{
return dataDeNascimento; // retorna valor do atributo
}
// método acessor (SET) do atributo dataDeNascimento
public void setData(String data)
{
dataDeNascimento = data; // atualiza atributo com o valor do parâmetro
}
}

fim código 1

Classe Executa
Para testarmos a codificação da classe Pessoa e de todas as demais classes do diagrama de
classes da Figura 1, criaremos uma nova classe BlueJ denominada classe “Executa”. Assim, após
criar a classe Pessoa, você deverá criar também uma nova classe no BlueJ chamada “Executa”,
dentro do pacote "biblioteca". Utilize como código da classe a codificação a seguir:
código 2
package biblioteca; // pacote biblioteca
class Executa
{ // classe de testes
public static void main(String args[])
{ // método que executa programa
// criação de um objeto do tipo “Pessoa”
Pessoa jose = new Pessoa(“Jose”,”01/06/1975”);
// exibição dos atributos do objeto jose
System.out.println(“Nome = “ + jose.getNome() + “ - Data de Nascimento = “ + jose.
getData() );
}
}

fim código 2

Agora que as duas classes já estão criadas, o BlueJ incluirá uma "seta" interligando as
classes “Pessoa” e “Executa”. Essa seta indica que a classe Executa realiza referências em seu
código para a classe Pessoa. Em outras palavras, a classe Executa declara objetos do tipo da
classe Pessoa.

Compilação das Classes Pessoa e Executa


Para prosseguirmos com a implementação, precisamos, inicialmente, compilar as novas
classes. Assim, clique sobre o botão "Compile” (Compilar), localizado na coluna lateral esquerda
(área cinza). Caso o processo de compilação resulte em erros, verifique novamente os códigos
que você digitou, comparando-os com os códigos desta obra.
Uma vez compiladas as classes, vamos realizar a execução do método main da classe “Exe-
cuta” (Figura 5). Nessa execução, não é necessária a passagem de parâmetros, conforme de-
monstra a Figura 6. Clique no botão "Ok” e visualize as mensagens retornadas pelo objeto criado
na declaração do método main da classe “Executa” (Figura 7).
112 © Programação Orientada a Objetos

Figura 5 Visão inicial do pacote biblioteca no BlueJ.

Figura 6 BlueJ: parâmetros do método main.

Figura 7 BlueJ: mensagens.

Ao analisar o código da classe Executa, você notará que a referência, a seguir, cria um ob-
jeto da classe Pessoa dentro do método main da classe Executa.
Pessoa jose = new Pessoa(“Jose”,”01/06/1975”);

Centro Universitário Claretiano


© Relacionamento entre Objetos 113

A execução do método construtor Pessoa, ao receber informações, permite a inicialização


do novo objeto a ser instanciado com os valores repassados por parâmetro. Como resultado
da execução do método main, a classe "Executa" mostrará, na janela de mensagens, os valores
atribuídos aos atributos do objeto jose.
Para uma maior compreensão dos exemplos, recomendamos que você consulte as unidades
anteriores, pois elas apresentam as orientações iniciais sobre as regras de codificação em Java.
Prosseguindo com a criação das classes do diagrama da Figura 1, realizaremos agora a im-
plementação das classes Aluno e Professor. Para tanto, veja como o Java trabalha com o conceito
de Herança.

Herança simples e Herança múltipla em Java


Na linguagem Java, a Herança pode ser criada por meio do operador extends. O formato
geral de utilização do comando é:
nome-classe-filha extends nome-classe-pai

O operador extends só possibilita referência a uma única classe. Dessa forma, o Java ofere-
ce suporte apenas à Herança simples. Um artifício que a linguagem Java oferece para suprir essa
restrição da linguagem em relação à Herança múltipla é utilizar o operador implements que faz
referência a uma interface, na qual descreve os métodos que serão codificados na classe filha.
A interface, em sua implementação, lembra, em parte, a sintaxe da codificação de uma classe,
porém possui grandes diferenciações:
• Os métodos são abstratos, isto é, não possuem codificação, e sim apenas declaração
com o valor de retorno e a lista de parâmetros. Isso é feito para que tais métodos sejam
codificados nas classes que os implementam.
• Os atributos, quando existentes, devem ser declarados, obrigatoriamente, como glo-
bais (operador static), constantes (operador final) e ter seus valores inicializados. Não
existem atributos de objetos em interfaces.
Observe, a seguir, um exemplo genérico de uma interface e uma classe que a referencia.
código 3
public interface nome-da-interface
{ // contém 3 constantes
public static final String constante1 = valor1; // constante
public static final int constante2 = valor2; // constante
public static final float constanteN = valorN; // constante
// contém 3 declarações de métodos
public void nome-método1(); // declaração abstrata (não
possui código)
public String nome-método2(int param1); // declaração abstrata (não
possui código)
public boolean nome-métodoN(float param1, int param2); // declaração abstrata (não possui
código)
}

// herança simples: extends para a classe pai


// herança múltipla: implements para várias interfaces
public class nome-classe-filha extends nome-classe-pai implements nome-da-interface
{
// Atributos da classe-filha
private String atributo1;
private int atributo2;
private float atributoN;
114 © Programação Orientada a Objetos

// Codificação dos métodos da classe-filha


...

// Codificação dos métodos declarados na interface


public void nome-método1()
{
// implementação do método1
}

// Codificação dos métodos declarados na interface


public String nome-método2(int param1)
{
// implementação do método2
return tipo-String;
}

// Codificação dos métodos declarados na interface


public boolean nome-método3(float param1, int param2)
{
// implementação do método3
return tipo-boolean;
}

fim código 3

Em Java, uma classe pode herdar características de apenas uma única classe (relação de he-
rança e uso do operador extends), porém, por meio das interfaces (declaração interface e uso do
operador implements), uma classe poderá implementar os métodos de várias interfaces. O efeito
prático disso é que a classe que implementa os métodos de uma interface possui o mesmo com-
portamento da interface e, portanto, pode ser declarado compatível com o tipo da interface.
Para simplificar nossa codificação, iremos implementar apenas classes que possuem he-
rança simples. Recomendamos a você que aprofunde seus conhecimentos, estudando exemplos
e casos de implementação que utilizam o conceito de interface como solução para a herança
múltipla entre classes.

Codificação das Classes Aluno e Professor


Baseado no diagrama da Figura 1 e nas considerações anteriores sobre Herança em Java,
iniciamos agora a codificação das classes Aluno e Professor. Acompanhe atentamente as codifi-
cações para as classes Aluno e Professor.
Classe Aluno
Crie uma nova classe na ferramenta BlueJ chamada “Aluno”, dentro do pacote “bibliote-
ca”. Utilize, como código da classe, a codificação a seguir:
código 4
package biblioteca; // pacote biblioteca
public class Aluno extends Pessoa
{ // Aluno herda de Pessoa
private String ra; // atributo privado
private String curso; // atributo privado
// Método construtor
public Aluno(String nome, String data, String ra, String curso) // método construtor
com 4 parâmetros
{
// invoca o construtor da classe pai (Pessoa)
// super é um apelido para o método construtor da classe pai (Pessoa)
// todos os parâmetros exigidos pelo método construtor devem ser repassados
// explicações detalhadas serão apresentadas mais abaixo nessa unidade
super(nome, data);
// Atribui o valor do parâmetro ra à variável ra
this.ra = ra;
// atribui o valor do parâmetro curso à variável curso

Centro Universitário Claretiano


© Relacionamento entre Objetos 115
this.curso = curso;
}
void retiraLivro( ) // método
{
// sem implementação no momento
}
public String getRa() // método acessor (GET) do atributo ra
{
return ra; // retorna valor do atributo
}
public void setRa(String ra) // método acessor (SET) do atributo ra
{
this.ra = ra; // atualiza atributo com o valor do parâmetro
}
public String getCurso() // método acessor (GET) do atributo curso
{
return curso; // retorna valor do atributo
}
public void setCurso(String curso) // método acessor (SET) do atributo curso
{
this.curso = curso; // atualiza atributo com o valor do parâmetro
}
}

fim código 4

Classe Professor
Crie outra classe na ferramenta BlueJ chamada “Professor”, dentro do pacote “biblioteca”.
Utilize, como código da classe, a codificação a seguir:
código 5
package biblioteca; // pacote biblioteca
public class Professor extends Pessoa
{ // Professor herda de Pessoa
private String titulacao; // atributo privado
private String dataContratacao; // atributo privado
// Método construtor
public Professor(String nome, String data, String titulacao, String dataContratacao) //
método construtor com 4 parâmetros
{
// invoca o construtor da classe pai (Pessoa)
// super é um apelido para o método construtor da classe pai (Pessoa)
// todos os parâmetros exigidos pelo método construtor devem ser repassados
// explicações detalhadas serão apresentadas mais abaixo nessa unidade
super(nome, data);
// Atribui o valor do parâmetro titulacao à variável titulacao
this.titulacao = titulacao;
// atribui o valor do parâmetro dataContratacao à variável dataContratacao
this.dataContratacao = dataContratacao;
}
void retiraLivro( ) // método
{
// sem implementação no momento
}
// método acessor (GET) do atributo titulacao
public String getTitulacao()
{
// retorna valor do atributo
return titulacao;
}
// método acessor (SET) do atributo titulacao
public void setTitulacao(String titulacao)
{
// atualiza atributo com o valor do parâmetro
this.titulacao = titulacao;
}
// método acessor (GET) do atributo dataContratacao
public String getDataContratacao()
{
// retorna valor do atributo
return dataContratacao;
116 © Programação Orientada a Objetos

}
// método acessor (SET) do atributo dataContratacao
public void setDataContratacao(String dataContratacao)
{
// atualiza atributo com o valor do parâmetro
this.dataContratacao = dataContratacao;
}
}

fim código 5

Herança
Após criarmos as duas classes, o BlueJ incluirá duas novas "setas" interligando as classes
"Aluno" – “Pessoa” e “Professor” – "Pessoa", conforme demonstra a Figura 8. Essa seta é di-
ferente da gerada anteriormente e corresponde à representação de herança entre as classes
relacionadas. A classe Aluno herda informações da classe Pessoa, e a classe Professor herda in-
formações da classe Pessoa. Isso quer dizer que todo "Aluno" é uma "Pessoa" e todo "Professor"
também é uma "Pessoa".
Assim, ao instanciarmos objetos da classe Aluno, notaremos que um objeto aluno terá como
características os atributos definidos tanto na classe Aluno como na classe Pessoa. De modo simi-
lar, ao instanciarmos objetos da classe Professor, notaremos que um objeto professor terá como
características os atributos definidos tanto na classe Professor como na classe Pessoa.

Figura 8 Herança entre as classes Aluno – Pessoa e Professor – Pessoa.

Para compreendermos melhor a relação de Herança existente entre classes, vamos reali-
zar inicialmente a compilação de todas as classes e, na sequência, utilizar o BlueJ para instanciar
objetos manualmente. Caso o processo de compilação resulte em erros, verifique novamente os
códigos que você digitou, comparando-os com os códigos descritos nesta obra.

Centro Universitário Claretiano


© Relacionamento entre Objetos 117

Criar um objeto aluno (maria)


Para criar objetos com base em uma classe compilada, você deve clicar com o botão direi-
to do mouse sobre a representação visual da classe, conforme demonstra a Figura 9, e escolher
a opção relacionada à criação de objetos (New Aluno). Essa operação abrirá uma nova janela
(Figura 10), que solicitará a informação do "Name of Instance" (Nome da Instância), bem como
os valores para configurar o novo objeto.
Sugerimos que modifique o nome da instância (ou o nome do objeto) para "maria" e di-
gite as seguintes informações, que correspondem aos parâmetros do método construtor Aluno
(nome, data, ra, curso): "Maria de Souza", "10/11/1976", "111111” e “Computação” (Figura 10).
Clique no botão "Ok" para confirmar a criação do objeto e visualize, na parte inferior da ferra-
menta BlueJ, a representação visual do objeto instanciado em memória (Figura 11).

Figura 9 BlueJ: menu da classe Aluno.

Figura 11 BlueJ: objeto


Figura 10 BlueJ: novo objeto aluno. aluno instanciado.

Inspecionar o objeto aluno


Para poder visualizar completamente as características de um objeto, você deve clicar com
o botão direito do mouse sobre o objeto "maria" e executar a opção "Inspect" (Inspecionar),
conforme mostra a Figura 12. Como resultado dessa ação, todas as informações referentes aos
atributos (características) do objeto serão exibidas, observe a Figura 13.
118 © Programação Orientada a Objetos

Figura 12 BlueJ: novo objeto – maria.

Figura 13 BlueJ: “inspect” sobre o objeto maria.

Considerando as características de herança entre classes, note que um objeto instancia-


do da classe Aluno contém como atributos aqueles que estão declarados na classe Aluno (ra
e curso), bem como os atributos declarados na classe Pessoa (nome e dataDeNascimento). A
herança garante que objetos instanciados da subclasse agrupem as características declaradas na
superclasse. Dessa forma, podemos afirmar que todo Aluno é do tipo Pessoa, já o inverso não
podemos afirmar, uma vez que temos a classe Professor que também herda suas definições da
classe Pessoa.
Do mesmo modo, como os atributos, os métodos da superclasse também estão acessíveis
aos objetos instanciados pela subclasse. Note na Figura 14 que a referência "inherited from Pes-
soa" (herdado de pessoa) oferece acesso aos métodos que estão declarados e acessíveis (public)
na classe Pessoa. Para realizar a execução de um deles, basta clicar sobre o nome do método.
Por exemplo, clique no método getNome(), e você obterá a informação referente ao atributo
nome do objeto "maria".

Centro Universitário Claretiano


© Relacionamento entre Objetos 119

Figura 14 BlueJ: métodos herdados da classe Pessoa sobre a visão do objeto maria (aluno).

Figura 15 BlueJ: método getNome() executado sobre o objeto maria (aluno).

A herança proporciona um excelente grau de reaproveitamento na codificação de progra-


mas, pois permite que declarações (atributos e métodos) definidas em uma classe (superclasse)
sejam reutilizadas em outras classes (subclasses).
Para aprimorar o aprendizado e a compreensão dos conceitos de herança, recomendamos
que realize a instanciação de um objeto do tipo "Professor". Faça o mesmo procedimento apre-
sentado anteriormente para criar um novo objeto. Utilize a opção "Inspect" sobre o objeto pro-
fessor para visualizar por completo as características do objeto. Realize acesso sobre métodos
do objeto professor, para executar tanto métodos definidos na classe Professor, como também
na classe Pessoa. As classes servem como definição de tipos de dados. A classe "Executa" exem-
plifica como podemos criar objetos para utilizar as declarações realizadas pelas classes: Pessoa,
Aluno, Professor etc.

Modificar a Classe Executa


Uma vez que as classes “Aluno” e “Professor” foram definidas, adicionaremos na classe
Executa a instanciação de novos objetos. Para isso, é necessário modificar o código da classe
Executa para incluir comandos que permitam instanciar objetos das classes “Aluno” e “Profes-
sor”. Adicione, no código da classe Executa, o trecho a seguir em negrito.
120 © Programação Orientada a Objetos

código 6
package biblioteca; // pacote biblioteca
class Executa
{ // classe de testes
public static void main(String args[])
{ // método que executa programa
// criação de um objeto do tipo “Pessoa”
Pessoa jose = new Pessoa(“Jose”,”01/06/1975”);
// exibição dos atributos do objeto jose
System.out.println(“Nome = “ + jose.getNome() +
“-Data de Nascimento = “ + jose.getData() );
// criação de um objeto do tipo “Aluno”
Aluno maria = new Aluno(“Maria”,”10/11/1976”,”111111”,”Computacao”);
// exibição dos atributos do objeto maria
System.out.println(“Nome = “ + maria.getNome() +
“ - Data de Nascimento = “ + maria.getData() +
“ - RA = “ + maria.getRa() +
“ - Curso = “ + maria.getCurso() );
// criação de um objeto do tipo “Professor”
Professor pedro = new Professor(“Pedro”,”05/05/1970”,”Mestre”,”02/02/2007”);
// exibição dos atributos do objeto pedro
System.out.println(“Nome = “ + pedro.getNome() +
“ - Data de Nascimento = “ + pedro.getData() +
“ - Titulacao = “ + pedro.getTitulacao() +
“ - Contratado em = “ + pedro.getDataContratacao() );
}
}

fim código 6

Uma vez modificado o código da classe Executa, realize a compilação das classes. Caso
o processo de compilação resulte em erros, verifique novamente os códigos que você digitou,
comparando-os com os códigos descritos nesta obra.

Executar o método main da classe Executa


Uma vez compiladas as classes, vamos realizar a execução do método main da classe Exe-
cuta (Figura 16). Nessa execução, não é necessária a passagem de parâmetros (Figura 17). Clique
no botão "Ok” e visualize as mensagens retornadas pelos objetos criados na declaração do mé-
todo main da classe Executa, conforme Figura 18.

Figura 16 Área de trabalho do BlueJ após criar herança entre classes.

Centro Universitário Claretiano


© Relacionamento entre Objetos 121

Figura 17 BlueJ: execução do método main.

Figura 18 BlueJ: mensagens.

Detalhar as características da herança em Java


Ao analisar o código da classe Executa, note que a referência, a seguir, cria um objeto da
classe Aluno dentro do método main da classe Executa.
Aluno maria = new Aluno(“Maria”,”10/11/1976”,”111111”,”Computacao”);

Dessa forma, a execução do método construtor Aluno permite a inicialização do novo ob-
jeto maria recebendo, como informação de inicialização, os valores repassados como parâmetro
do método. Como resultado da execução do método main, a classe Executa mostrará, na janela
de mensagens, os valores atribuídos aos atributos do objeto maria.
Já a referência, a seguir, cria um objeto da classe Professor dentro do método main da
classe Executa.
Professor pedro = new Professor(“Pedro”,”05/05/1970”,”Mestre”,”02/02/2007”);

A execução do método construtor Professor permite a inicialização do novo objeto pedro


recebendo, como informação de inicialização, os valores repassados como parâmetro do mé-
todo. Como resultado da execução do método main, a classe Executa mostrará, na janela de
mensagens, os valores atribuídos aos atributos do objeto pedro.
Os procedimentos apresentados na classe Executa correspondem, exatamente, aos pro-
cedimentos manuais realizados no BlueJ para a criação de objetos derivados das classes Aluno
e Professor. Na programação orientada a objetos, as classes servem como tipos abstratos de
dados e seu uso só é possível por meio da instanciação de objetos.
Quando trabalhamos com Herança, às vezes é necessário fazer alguma referência entre a
classe filha (subclasse) e sua classe pai (superclasse). Para isso, a linguagem Java disponibiliza a
referência super, como forma de a subclasse referenciar métodos da superclasse. Podemos uti-
lizar, por exemplo, a referência super.<nome_do_método_da_classe_pai> para invocar de dentro da
implementação de um método da subclasse, outro método implementado em sua superclasse.
122 © Programação Orientada a Objetos

Método super
Agora veremos mais uma maneira de utilizar a referência super, que é invocar o método
construtor da superclasse. O método super utilizado, por exemplo, na classe Aluno, dentro do
método construtor Aluno, faz uma referência direta ao construtor de sua superclasse. A super-
classe de “Aluno” é a classe Pessoa, assim o método super é uma referência ao método constru-
tor da classe Pessoa.
super(nome, data) --> Método Construtor : Pessoa (String nome, String data)

O método super, invocado na classe Professor, de maneira análoga à descrita na classe


Aluno, também referencia o método construtor da classe Pessoa (superclasse). A referência su-
per deve ser o primeiro comando do método construtor de uma classe filha (subclasse). Esse co-
mando realizará a execução do método construtor da classe pai (superclasse) e posteriormente
prosseguirá com a execução dos demais comandos do método construtor da classe filha.
Na classe Executa, temos os comandos: maria.getNome(), maria.getData(), pedro.getNo-
me() e pedro.getData(), porém não existem as declarações dos métodos getNome() e getData()
dentro das classes Aluno e Professor. Na execução da classe Executa, os valores do nome e da data
de nascimento do aluno (maria) e do professor (pedro) são corretamente recuperados, pois tais
referências são direcionadas à classe Pessoa, por meio da herança que existe entre as classes.
Em decorrência desta característica e baseado no diagrama de classes da Figura 1, pode-
mos afirmar que todo Aluno é uma Pessoa, e que todo Professor é uma Pessoa. O inverso não
pode ser dito, pois uma Pessoa pode ser um Aluno ou um Professor.

Codificar a classe Telefone


Continuando com a implementação do sistema de biblioteca, criaremos agora a classe
Telefone, que está relacionada à classe Pessoa, por meio de uma relação do tipo agregação.
Observe que, na agregação, conforme exibida na Figura 1, uma Pessoa tem ou possui um
Telefone. A agregação vincula um objeto do tipo Telefone a um objeto do tipo Pessoa. Esse vín-
culo de agregação acontece em tempo de criação dos objetos do tipo Pessoa.
Baseado no diagrama de classes da Figura 1, definiremos a seguinte codificação para a
classe Telefone. Crie uma classe nova na ferramenta BlueJ chamada Telefone, dentro do pacote
“biblioteca”. Utilize, como código da classe, a codificação a seguir:
código 7
package biblioteca; // pacote biblioteca
public class Telefone { // classe Telefone
private String ddd; // atributo privado
private String numero; // atributo privado
// Método construtor
public Telefone (String ddd, String numero) // método construtor com 2 parâmetros
{
// Atribui o valor do parâmetro ddd à variável ddd
this.ddd = ddd;
// atribui o valor do parâmetro numero à variável numero
this.numero = numero;
}
// Método construtor vazio (cria objeto com valores null)
public Telefone () // método construtor sem parâmetros
{
}
public String getDdd() // método acessor (GET) do atributo ddd
{
return ddd; // retorna valor do atributo

Centro Universitário Claretiano


© Relacionamento entre Objetos 123
}
public void setDdd(String ddd) // método acessor (SET) do atributo ddd
{
this.ddd = ddd; // atualiza atributo com o valor do parâmetro
}
public String getNumero() // método acessor (GET) do atributo numero
{
return numero; // retorna valor do atributo
}
public void setNumero(String numero) // método acessor (SET) do atributo numero
{
this.numero = numero; // atualiza atributo com o valor do parâmetro
}
}

fim código 7

Note que, na classe Telefone, existem dois métodos construtores, um com dois parâme-
tros e outro sem parâmetros. Esse tipo de implementação, também denotada como sobrecarga
(ou overloaded), possibilita que objetos sejam criados de duas maneiras diferentes. Em ambos
os métodos, um objeto é instanciado em memória, contendo a estrutura definida, conforme a
declaração existente na classe, porém, somente no método com dois parâmetros é que ocorrerá
a atribuição de valores aos atributos do objeto criado.
De modo geral, na sobrecarga ou overloaded, os métodos possuem o mesmo nome (iden-
tificação), porém, se distinguem pela quantidade e pelos tipos de parâmetros. Nesse caso, dize-
mos que tais métodos possuem assinaturas diferentes.
Diferentemente do que acontece na Herança, na agregação não existem comandos na
linguagem Java para implementar tal conceito de forma específica. A codificação da agregação
entre a classe Pessoa e a classe Telefone ocorre por meio da inclusão de um novo atributo na
classe Pessoa, para indicar um objeto do tipo “Telefone” associado a objetos do tipo “Pessoa”.
Assim, definiremos o atributo fone como do tipo Telefone. Na programação OO, é comum
usarmos as classes criadas como novos tipos de dados.

Modificar a classe Pessoa (representar a agregação)


Veja a seguir, a codificação da classe Pessoa após adaptá-la à relação de agregação com a
classe Telefone. Recomendamos que edite o código da classe Pessoa, adicionando nele os tre-
chos a seguir indicados em negrito.
código 8
package biblioteca; // pacote biblioteca
public class Pessoa { // classe Pessoa
private String nome; // atributo privado
private String dataDeNascimento; // atributo privado
private Telefone fone; // atributo que permitirá a agregação
// Método construtor
public Pessoa(String nome, String data) // método construtor com dois parâmetros
{
// Atribui o valor do parâmetro nome à variável nome
this.nome = nome;
// atribui o valor do parâmetro data à variável dataDeNascimento
dataDeNascimento = data;
// cria objeto do tipo Telefone
fone = new Telefone();
}
void retiraLivro( ) // método
{
// sem implementação no momento
}
public String getNome() // método acessor (GET) do atributo nome
{
124 © Programação Orientada a Objetos

return nome; // retorna valor do atributo


}
public void setNome(String nome) // método acessor (SET) do atributo nome
{
this.nome = nome; // atualiza atributo com o valor do parâmetro
}
public String getData() // método acessor (GET) do atributo dataDeNascimento
{
return dataDeNascimento; // retorna valor do atributo
}
// método acessor (SET) do atributo dataDeNascimento
public void setData(String data)
{
dataDeNascimento = data; // atualiza atributo com o valor do parâmetro
}
public String getFone() // método acessor (GET) do atributo fone (AGREGADO)
{
return “(“ + fone.getDdd() +”)” + fone.getNumero() ; // retorna valor do
// atributo
}
// método acessor (SET) do atributo fone (AGREGADO)
public void setFone(String ddd, String num)
{
fone.setDdd( ddd ); // chama método que atualiza ddd
fone.setNumero( num ); // chama método que atualiza numero
}
}

fim código 8

Uma vez criada a classe Telefone e modificada a classe Pessoa, você deverá recompilar as
classes do pacote biblioteca. Caso o processo de compilação resulte em erros, verifique novamen-
te os códigos digitados, comparando-os com os códigos da obra. Se a compilação das classes for
realizada com sucesso, o BlueJ exibirá a área de trabalho, conforme mostra a Figura 19.

Figura 19 Área de trabalho do BlueJ após criar agregação entre classes.

Para compreendermos melhor a relação de agregação existente entre classes, utilizare-


mos o BlueJ para instanciar objetos manualmente.
Centro Universitário Claretiano
© Relacionamento entre Objetos 125

O procedimento que utilizaremos corresponde exatamente ao de criação do objeto "ma-


ria", realizado anteriormente neste tópico.

Criar um objeto aluno


Para criar objetos com base em uma classe Aluno, clique com o botão direito do mouse
sobre a representação visual da classe Aluno (retorne no conteúdo e veja a Figura 9) e escolha
a opção relacionada à criação de objetos (New Aluno). Esta operação abrirá uma nova janela
(Figura 10), que solicitará a informação do "Name of Instance" (Nome da Instância), bem como
os valores para configurar o novo objeto.
Sugerimos que modifique o nome da instância (ou o nome do objeto) para "maria" e di-
gite as seguintes informações que correspondem aos parâmetros do método construtor Aluno
(nome, data, ra, curso): "Maria de Souza", "10/11/1976", "111111” e “Computação” (Figura 10).
Clique no botão "Ok" para confirmar a criação do objeto e visualize, na parte inferior da ferra-
menta BlueJ, a representação visual do objeto instanciado em memória (Figura 11).
Para visualizar por completo as características do objeto "maria", clique com o botão di-
reito do mouse sobre o objeto “maria” e execute a opção "Inspect" (Inspecionar), conforme de-
monstra a Figura 20. Como resultado dessa ação, todas as informações referentes aos atributos
(características) do objeto serão exibidas (Figura 21).

Figura 20 BlueJ: novo objeto – maria.

Figura 21 BlueJ: “inspect” sobre o objeto maria.


126 © Programação Orientada a Objetos

Em decorrência das características de agregação entre as classes Pessoa e Telefone, um


novo atributo denominado fone foi adicionado à definição da classe Pessoa, e, como a classe
Aluno (subclasse) herda as características da classe Pessoa (superclasse), o atributo fone tam-
bém foi incorporado à estrutura do objeto "maria" (tipo "Aluno").
O atributo fone do objeto “maria” apresenta um aspecto diferenciado dos demais atribu-
tos (tipo String). A representação utilizada no BlueJ indica que existe vinculado àquele atributo
um objeto do tipo Telefone. Para você visualizar as características desse objeto fone, selecione o
atributo (marcação em amarelo, conforme mostra a Figura 21) e clique sobre o botão "Inspect”
(Inspecionar) da mesma janela.
Como resultado dessa ação, o BlueJ exibirá uma nova janela (Figura 22) com as proprieda-
des do objeto fone (tipo “Telefone”). Note que os valores exibidos inicialmente para esse objeto
constam como null. Essa representação significa que valores não foram atribuídos à declaração
dos atributos por meio do método construtor da classe Telefone.

Figura 22 BlueJ: “inspect” sobre o atributo fone do objeto maria.

Figura 23 BlueJ: métodos herdados da classe Pessoa sobre a visão do objeto maria (Aluno).

Criar um objeto agregado –­ Telefone


O comando, a seguir, presente no código do método construtor da classe Pessoa, ocasiona a
criação de um novo objeto do tipo "Telefone", porém sem repassar valores como parâmetros.
fone = new Telefone();

Observe, na classe Telefone, que tal método construtor (veja representação a seguir) não
possui tratamento para o recebimento de valores por meio de parâmetros. Como resultado da
Centro Universitário Claretiano
© Relacionamento entre Objetos 127

execução desse método, um novo objeto é instanciado, porém o valor de seus atributos perma-
nece ausente, ocasionando a indicação de null como conteúdo dos atributos do objeto.
public Telefone () // método construtor sem parâmetros
{
}

Para instanciar objetos do tipo "Telefone" que realizem a inicialização de atributos, é reco-
mendada a execução do outro método construtor da classe Telefone.
Verifique que o objeto vinculado ao atributo fone não se encontra representado na parte
inferior da ferramenta BlueJ, junto ao objeto “maria” (Figura 20). O objeto fone está acessível
apenas por meio do atributo do objeto "maria", e o acesso a ele só pode ser realizado por meio
dos métodos disponíveis na classe Pessoa.

Invocar métodos da classe Telefone


Se considerarmos a Herança existente entre as classes Aluno e Pessoa, os métodos da
superclasse também estão acessíveis aos objetos instanciados pela subclasse. Note, na Figura
23, que a referência inherited from Pessoa (herdado de Pessoa) oferece acesso aos métodos
que estão declarados e acessíveis (public) na classe Pessoa. Localize nessa relação de métodos
herdados a referência setFone(). Este método é o responsável por realizar a alteração nos atri-
butos do objeto do tipo "Telefone", representado em "maria" pelo atributo fone. Para realizar
a execução do método setFone(), basta clicar sobre o nome do método. Como resultado dessa
ação, o BlueJ exibirá uma nova janela solicitando informações sobre o ddd e o num (número) do
telefone, de acordo com a Figura 24.

Figura 24 BlueJ: método setFone() executado sobre o objeto maria (Aluno).

Figura 25 BlueJ: “inspect” sobre o objeto maria.


128 © Programação Orientada a Objetos

Agora, digite os valores de Telefone (ddd e num) e clique no botão "Ok" para confirmar a
execução do método. Como resultado dessa ação, os valores passados por parâmetro atualiza-
rão os atributos do objeto telefone de "maria". Para verificar se a alteração foi devidamente rea-
lizada, clique com o botão direito do mouse sobre o objeto “maria” e execute a opção "Inspect”
(Inspecionar), conforme demonstra a Figura 20.
Como resultado dessa ação, todas as informações referentes aos atributos (característi-
cas) do objeto "maria" serão exibidas (Figura 21). Para visualizar as características do objeto
telefone vinculado ao atributo fone, selecione o atributo (observe a marcação em amarelo na
Figura 21) e clique sobre o botão "Inspect" (Inspecionar) da mesma janela. Como consequência,
o BlueJ exibirá uma nova janela (Figura 25) com as propriedades do objeto fone (tipo “Telefo-
ne"). Note que os valores exibidos nos atributos correspondem aos valores dos parâmetros do
método setFone().
Assim como a Herança, a agregação proporciona um bom reaproveitamento de código,
pois permite que uma classe possa ser definida como uma parte da definição de uma outra
classe. Na agregação, chamamos de classe agregadora aquela que utiliza uma classe como parte
da definição de sua estrutura (exemplo: classe Pessoa). Já a classe que é utilizada como parte da
definição de outra (como a classe Telefone, por exemplo) é identificada como classe agregada.
Na agregação de classes, o objeto agregado (objeto do tipo "Telefone") fica vinculado ao
objeto agregador (objeto "maria") por meio de um atributo (fone). O tempo de vida do objeto
agregado não depende do tempo de vida do objeto agregador. Assim, o objeto Telefone pode
ser vinculado a outro objeto do tipo Pessoa. Para que o objeto agregado não seja removido
junto com o objeto agregador, deve-se primeiro obter uma referência ao objeto agregado e só
posteriormente remover o objeto agregador.
Para aprimorar o aprendizado e a compreensão dos conceitos de agregação, sugerimos
que realize a instanciação de um objeto do tipo "Professor". Reproduza os mesmos procedi-
mentos apresentados anteriormente para criar um novo objeto. Utilize a opção "Inspect” sobre
o objeto professor, para visualizar por completo suas características. Realize acesso sobre os mé-
todos do objeto professor, para executar tanto os métodos definidos na classe Professor, como
na classe Pessoa. Crie um telefone para o objeto professor, executando o método setFone().

Modificar a classe Executa


Após a definição da classe Telefone e a modificação da classe Pessoa para agregar um
objeto telefone, vamos adicionar, na classe Executa, a instanciação de novos objetos. Para isso,
modifique o código da classe Executa, para incluir os comandos que permitam associar objetos
da classe Telefone. Adicione, no código da classe Executa, o trecho a seguir em negrito.
código 9
package biblioteca; // pacote biblioteca
class Executa { // classe de testes
public static void main(String args[]) { // método que executa programa
// criação de um objeto do tipo “Pessoa”
Pessoa jose = new Pessoa(“Jose”,”01/06/1975”);
// exibição dos atributos do objeto jose
System.out.println(“Nome = “ + jose.getNome() +
“-Data de Nascimento = “ + jose.getData() );

// criação de um objeto do tipo “Aluno”


Aluno maria = new Aluno(“Maria”,”10/11/1976”,”111111”,”Computacao”);
// atribui valores ao telefone de maria
maria.setFone(“019”,”98765432”);
// exibição dos atributos do objeto maria

Centro Universitário Claretiano


© Relacionamento entre Objetos 129
System.out.println(“Nome = “ + maria.getNome() +
“-Data de Nascimento = “ + maria.getData() +
“-RA = “ + maria.getRa() +
“-Curso = “ + maria.getCurso() );
// exibe o telefone de maria
System.out.println(“Telefone de “ + maria.getNome() + “ = “ + maria.getFone());

// criação de um objeto do tipo “Professor”


Professor pedro = new Professor(“Pedro”,”05/05/1970”,”Mestre”,”02/02/2007”);
// atribui valores ao telefone de pedro
pedro.setFone(“019”,”12345678”);
// exibição dos atributos do objeto pedro
System.out.println(“Nome = “ + pedro.getNome() +
“-Data de Nascimento = “ + pedro.getData() +
“-Titulacao = “ + pedro.getTitulacao() +
“-Contratado em = “ + pedro.getDataContratacao() );
// exibe o telefone de pedro
System.out.println(“Telefone de “ + pedro.getNome() + “ = “ + pedro.getFone());
}
}

fim código 9

Uma vez modificado o código da classe Executa, realize a compilação das classes. Caso o
processo de compilação resulte em erros, verifique novamente os códigos digitados, comparan-
do-os com os códigos descritos nesta obra.

Executar o método main da classe Executa


Depois de compiladas as classes, vamos realizar a execução do método main da classe
Executa (Figura 26). Nessa execução, não é necessária a passagem de parâmetros, conforme
demonstra a Figura 27. Clique no botão "Ok” e visualize as mensagens retornadas pelos objetos
criados na declaração do método main da classe Executa (Figura 28).

Figura 26 Área de trabalho do BlueJ após criar agregação entre classes.


130 © Programação Orientada a Objetos

Figura 27 BlueJ: execução do método main.

Figura 28 BlueJ: mensagens.

Detalhar as características da agregação em Java


Ao analisar o código da classe Executa, você notará que a referência, a seguir, permite a
execução de métodos sobre objetos instanciados. Veja o comando, por exemplo.
maria.setFone(“019”,”98765432”);

A chamada do método setFone() sobre o objeto "maria" resulta na execução de outros


métodos sobre o atributo fone declarado na classe Pessoa. Veja, a seguir, o código do método
setFone() declarado na classe Pessoa.
public void setFone(String ddd, String num)
{
fone.setDdd( ddd ); // chama método que atualiza ddd
fone.setNumero( num ); // chama método que atualiza numero
}

Note que os comandos fone.setDdd() e fone.setNumero() realizam a chamada dos respec-


tivos métodos sobre o objeto fone que está associado ao objeto "maria". Observe, a seguir, o
código de tais métodos que estão declarados na classe Telefone.
public void setDdd(String ddd) // método acessor (SET) do atributo ddd
{
this.ddd = ddd; // atualiza atributo com o valor do parâmetro
}
public void setNumero(String numero) // método acessor (SET) do atributo numero
{
this.numero = numero; // atualiza atributo com o valor do parâmetro
}

Os métodos anteriores recebem os valores como parâmetros e realizam a atualização dos


atributos ddd e numero do objeto fone, conforme codificação da classe Telefone.

Centro Universitário Claretiano


© Relacionamento entre Objetos 131

Até o momento, já realizamos a codificação das relações de Herança e agregação. Seguin-


do as especificações do diagrama de classes do sistema de biblioteca (Figura 1), prosseguiremos
agora com a implementação da relação de associação entre as classes Livro e Pessoa.

8. IMPLEMENTAÇÃO DA RELAÇÃO DE ASSOCIAÇÃO


Neste tópico, implementaremos a relação de associação entre as classes Livro e Pessoa do
sistema de biblioteca.

Codificar a classe Livro


Vamos criar a classe Livro, a qual está relacionada à classe Pessoa por meio de uma asso-
ciação.
Observe que, pela associação exibida no diagrama de classes da Figura 1, uma “Pessoa”
faz a retirada de “Livros”. Dessa forma, a associação vincula um objeto do tipo "Livro" a um ob-
jeto do tipo "Pessoa". Para que esse vínculo aconteça, os objetos a serem associados (Pessoa e
Livro) devem estar instanciados no sistema.
Não existe na linguagem Java um comando específico para se codificar diretamente a as-
sociação entre classes. Na verdade, a implementação desse conceito poderá ser realizada de vá-
rias maneiras. De forma geral, a codificação da associação envolve a criação de vínculos entre os
objetos associados. Esses vínculos podem ser atributos que armazenam os objetos vinculados,
ou até mesmo uma nova classe que armazena os objetos relacionados.
Para codificar a associação, adotaremos a criação de um atributo em cada uma das classes
relacionadas (“Pessoa” e “Livro”).
Vale ressaltar que, em decorrência dessa alteração, será necessário incluir um conjunto de
métodos que auxiliarão no controle da associação entre as classes. Basicamente, os novos méto-
dos adicionados realizarão as operações de inserção, remoção e consulta aos objetos associados.

Criar a classe Livro


Baseado no diagrama de classes da Figura 1, definimos a seguinte codificação para a
classe Livro. Assim, crie uma nova classe na ferramenta BlueJ chamada “Livro”, dentro do pa-
cote “biblioteca”. Para isso, utilize, como código da classe, a codificação a seguir:
código 10
package biblioteca; // pacote biblioteca
public class Livro { // classe Livro
private String nome; // atributo privado
private String editora; // atributo privado
private String isbn; // atributo privado
private Pessoa pessoa; // atributo privado (ASSOCIACAO)
// Método construtor
public Livro (String nome, String editora, String isbn)
{
// Atribui o valor do parâmetro nome à variável nome
this.nome = nome;
// atribui o valor do parâmetro editora à variável editora
this.editora = editora;
// atribui o valor do parâmetro editora à variável isbn
this.isbn = isbn;
}
132 © Programação Orientada a Objetos

// método que associa um Livro a uma Pessoa


void emprestaLivro( Pessoa pessoa )
{
if (pessoa != null) { // verifica se objeto existe
this.pessoa = pessoa; // vincula objeto pessoa ao atributo pessoa
pessoa.addLivro( this ); // chama método que adiciona livro ao objeto pessoa
}
}
public String getNome() // método acessor (GET) do atributo nome
{
return nome; // retorna valor do atributo
}
public void setNome(String nome) // método acessor (SET) do atributo nome
{
this.nome = nome; // atualiza atributo com o valor do parâmetro
}
public String getEditora() // método acessor (GET) do atributo editora
{
return editora; // retorna valor do atributo
}
public void setEditora(String editora) // método acessor (SET) do atributo editora
{
this.editora = editora; // atualiza atributo com o valor do parâmetro
}
public String getIsbn() // método acessor (GET) do atributo isbn
{
return isbn; // retorna valor do atributo
}
public void setIsbn(String isbn) // método acessor (SET) do atributo isbn
{
this.isbn = isbn; // atualiza atributo com o valor do parâmetro
}
public Pessoa getPessoa() // método acessor (GET) do atributo pessoa
{
return pessoa; // retorna valor do atributo
}
// método acessor (SET) do atributo pessoa
public void setPessoa(Pessoa pessoa)
{
this.pessoa = pessoa; // atualiza atributo com o valor do parâmetro
}
// método que desassocia do Livro a Pessoa
public void devolveLivro() {
setPessoa( null ); // chama metodo com valor null
}
// mostra o nome da pessoa que retirou o livro
public void comQuemEsta() {
if (pessoa != null) { // verifica se existe pessoa associada ao livro
System.out.println(“O livro “+nome+” esta com: “+pessoa.getNome());
} else { // não tem livro associado
System.out.println(“O livro “+nome+” esta disponivel para retirada.”);
}
}
// método que verifica se livro esta disponivel
public boolean livroDisponivel( ) {
if (pessoa != null) return false; // atualiza atributo com valor null
return true;
}
// método que mostra os valores dos atributos do livro
public void mostrar() {
System.out.println(“Nome :” + nome);
System.out.println(“Editora :” + editora);
System.out.println(“ISBN :” + isbn);
}
}

fim código 10

Associação entre classes em Java


De forma similar à implementação da agregação em Java, para representar a relação de
associação entre as classes, será necessária a inclusão de um novo atributo na classe Livro para

Centro Universitário Claretiano


© Relacionamento entre Objetos 133

indicar que um objeto do tipo "Livro" está associado a um objeto do tipo "Pessoa". Assim, defi-
niremos o atributo pessoa como sendo do tipo Pessoa. Na programação OO, é comum usarmos
as classes criadas como novos tipos de dados.
Desse modo, para representarmos a associação entre as classes Pessoa e Livro, adiciona-
remos, também, um novo atributo na classe Pessoa. Esse novo atributo permitirá o vínculo de
vários livros a uma única pessoa.

Modificar a classe Pessoa (representar a associação)


Veja a seguir a codificação da classe Pessoa após adaptá-la à relação de associação com
a classe Livro. Para tanto, é necessário que edite o código da classe Pessoa, adicionando os tre-
chos a seguir indicados em negrito.
código 11
package biblioteca; // pacote biblioteca
import java.util.ArrayList; // importação da classe ArrayList
public class Pessoa { // classe Pessoa
private String nome; // atributo privado
private String dataDeNascimento; // atributo privado
private Telefone fone; // atributo que permitirá a agregação
// atributo que permitirá a associacao (armazena os livros retirados)
private ArrayList livros;

// Método construtor
public Pessoa(String nome, String data) // método construtor com dois parâmetros
{
// Atribui o valor do parâmetro nome à variável nome
this.nome = nome;
// atribui o valor do parâmetro data à variável dataDeNascimento
dataDeNascimento = data;
// cria objeto do tipo Telefone
fone = new Telefone();
// inicializa a estrutura de controle de livro retirados
livros = new ArrayList();
}

// método que associa o Livro a Pessoa


void retiraLivro( Livro livro )
{
if (livro != null) { // verifica se existe o objeto
addLivro( livro ); // adiciona o objeto livro na lista de retirados
livro.setPessoa( this ); // vincula a pessoa ao Livro
}
}

public String getNome() // método acessor (GET) do atributo nome


{
return nome; // retorna valor do atributo
}
public void setNome(String nome) // método acessor (SET) do atributo nome
{
this.nome = nome; // atualiza atributo com o valor do parâmetro
}
public String getData() // método acessor (GET) do atributo dataDeNascimento
{
return dataDeNascimento; // retorna valor do atributo
}

// método acessor (SET) do atributo dataDeNascimento


public void setData(String data)
{
dataDeNascimento = data; // atualiza atributo com o valor do parâmetro
}
public String getFone() // método acessor (GET) do atributo fone (AGREGADO)
{
return “(“ + fone.getDdd() +”)” + fone.getNumero() ; // retorna valor do atributo
134 © Programação Orientada a Objetos

}
// método acessor (SET) do atributo fone (AGREGADO)
public void setFone(String ddd, String num)
{
fone.setDdd( ddd ); // chama método que atualiza ddd
fone.setNumero( num ); // chama método que atualiza numero
}

// método que adiciona um livro na lista de livros retirados (ASSOCIACAO)


public void addLivro( Livro livro )
{
if (livro != null) { // verifica se existe o parâmetro
livros.add( livro ); // adiciona o livro na lista de retirados
}
}

// método que mostra os livros vinculados a pessoa


public void listaLivrosRetirados( )
{
// verifica se lista existe e se tem objetos
if (livros != null && livros.size() > 0 ) {
Livro livro; // variavel que recebera livro da lista
System.out.println(“Livros retirados por “+nome+” :”);
// percorre toda a lista de livros
for(int aux = 0; aux < livros.size(); aux++)
{
// pega o proximo objeto da lista de livros
livro = (Livro)livros.get(aux);
System.out.println(“LIVRO - “+(aux+1)+”:”);
// imprime os valores do livro
livro.mostrar();
}
} else { // Não existem livros associados a pessoa
System.out.println(nome+” nao tem livro(s) retirado(s).”);
}
}

// método que retira vinculo de livro com pessoa


public void devolveLivro( Livro livroDevolvido )
{
// verifica se lista existe e se tem objetos
if (livros != null && livros.size() > 0 ) {
Livro livro; // variavel que recebera livro da lista
// percorre toda a lista de livros
for(int aux = 0; aux < livros.size(); aux++)
{
// pega o proximo objeto da lista de livros
livro = (Livro)livros.get(aux);
if ( livro.getIsbn().equals( livroDevolvido.getIsbn() ) ) {
// retira objeto da lista
livros.remove(aux);
// desassocia livro de pessoa
livroDevolvido.devolveLivro();
}
}
}
}

// mostra os valores dos atributos da pessoa


public void mostrar()
{
System.out.println(“Nome :” + nome);
System.out.println(“Data Nascimento :” + dataDeNascimento);
}
}

fim código 11

Uma vez criada a classe Livro e modificada a classe Pessoa, recomendamos que recompile as
classes do pacote biblioteca. Caso o processo de compilação resulte em erros, verifique novamen-
te os códigos digitados, comparando-os com os códigos da obra. Se a compilação das classes for
realizada com sucesso, o BlueJ exibirá a área de trabalho, conforme mostra a Figura 29.

Centro Universitário Claretiano


© Relacionamento entre Objetos 135

Figura 29 Área de trabalho do BlueJ após criar associação entre classes.

Para compreender melhor a relação de associação existente entre classes, utilizaremos o


BlueJ para instanciar objetos manualmente. Para criar a associação, é necessário primeiro ins-
tanciar os objetos relacionados (livro e pessoa).

Criar um objeto livro


Para instanciar objetos com base na classe Livro, clique com o botão direito do mouse so-
bre a representação visual da classe Livro (Figura 30) e escolha a opção relacionada à criação de
objetos ("New Livro"). Essa operação abrirá uma nova janela (Figura 31), que solicitará o nome
do objeto ("Name of Instance”), bem como os valores para configurar o novo objeto.
Sugerimos que modifique o nome da instância (ou o nome do objeto) para "java" e di-
gite as seguintes informações que correspondem aos parâmetros do método construtor Livro
(nome, editora, isbn): "Java básico", "Livros e Cia" e "1111” (Figura 31). Clique no botão "Ok"
para confirmar a criação do objeto e visualize, na parte inferior da ferramenta BlueJ, a represen-
tação visual do objeto instanciado em memória (Figura 32).

Figura 30 BlueJ: menu da classe Livro.


136 © Programação Orientada a Objetos

Figura 31 BlueJ: novo objeto livro.

Inspecionar o objeto livro


Para visualizar completamente as características do objeto "java", clique com o botão
direito do mouse sobre o objeto “java” e execute a opção "Inspect" (Inspecionar), conforme
mostra a Figura 32. Como resultado dessa ação, todas as informações referentes aos atributos
(características) do objeto serão exibidas (Figura 33).

Figura 32 BlueJ: novo objeto – Java.

Centro Universitário Claretiano


© Relacionamento entre Objetos 137

Figura 33 BlueJ: “inspect” sobre o objeto Java.

Observando as características do objeto "java”, note que o atributo pessoa (marcação em


amarelo na Figura 33) apresenta como conteúdo o valor null. Tal indicação representa que não
existem objetos associados a tal livro.
Agora iremos instanciar um objeto do tipo "Pessoa". O procedimento que realizaremos cor-
responde exatamente ao procedimento de criação do objeto "maria" realizado anteriormente.

Criar um objeto aluno


Para criar objetos com base em uma classe Aluno, clique com o botão direito do mouse
sobre a representação visual da classe Aluno (retorne no conteúdo e veja Figura 9) e escolha a
opção relacionada à criação de objetos (New Aluno). Essa operação abrirá uma nova janela (Fi-
gura 10), que solicitará a informação do "Name of Instance" (Nome da Instância), bem como os
valores para configurar o novo objeto.
Sugerimos que modifique o nome da instância (ou o nome do objeto) para "maria" e di-
gite as seguintes informações que correspondem aos parâmetros do método construtor Aluno
(nome, data, ra, curso): "Maria de Souza", "10/11/1976", "111111" e "Computação" (Figura 10).
Clique no botão "Ok" para confirmar a criação do objeto e visualize, na parte inferior da ferra-
menta BlueJ, a representação visual do objeto instanciado em memória (Figura 11).

Inspecionar o objeto aluno


Para visualizar completamente as características do objeto "maria", clique com o botão
direito do mouse sobre o objeto “maria” e execute a opção "Inspect” (Inspecionar), de acordo
com a Figura 34. Como resultado dessa ação, todas as informações referentes aos atributos (ca-
racterísticas) do objeto serão exibidas (Figura 35).
138 © Programação Orientada a Objetos

Figura 34 BlueJ: novo objeto – maria.

Figura 35 BlueJ: “inspect” sobre o objeto maria.

Note que, devido à característica de associação entre as classes Pessoa e Livro, um novo
atributo denominado livros foi adicionado à definição da classe Pessoa, e, como a classe Aluno
(subclasse) herda as características da classe Pessoa (superclasse), o atributo livros também foi
incorporado à estrutura do objeto "maria" (tipo "Aluno").

Classe Arraylist (lista de objetos)


O atributo livros do objeto "maria" é do tipo ArrayList, que é uma classe da biblioteca
"util" da linguagem Java que permite o armazenamento de objetos em sua estrutura. Esse tipo
de objeto utiliza a mesma lógica do vetor nas linguagens de programação estruturada (Pascal, C,
...), e a diferença é que a classe ArrayList oferece gerenciamento dinâmico de seu tamanho, isto
é, a estrutura é capaz de incrementar a quantidade de espaço conforme surge a necessidade de
armazenar novos elementos.

Centro Universitário Claretiano


© Relacionamento entre Objetos 139

Para visualizar o conteúdo da estrutura ArrayList representada no objeto “maria” pelo


atributo livros, selecione o atributo livros (marcação em amarelo na Figura 35) e clique sobre o
botão "Inspect" da própria janela. Como resultado dessa ação, o BlueJ exibirá uma nova janela,
conforme demonstra a Figura 36.
O ArrayList gerencia o armazenamento de objetos em sua estrutura. A propriedade “size”
(tamanho) quantifica os elementos armazenados. No atributo livros do objeto “maria”, o atribu-
to “size" exibe valor zero, o que indica que a lista de objetos armazenados está vazia. Para visu-
alizar a lista de objetos armazenados no ArrayList, selecione o atributo elementData (marcação
em amarelo na Figura 36) e clique sobre o botão "Inspect” da mesma janela. O BlueJ exibirá,
como resultado dessa ação, uma nova janela contendo informações sobre os objetos armaze-
nados na estrutura (Figura 37).

Figura 36 BlueJ: “inspect” sobre o objeto livros do objeto maria. Figura 37 Relação de objetos do ArrayList livros do
objeto maria.

Como vimos anteriormente, a estrutura está vazia (size igual a zero) e nenhum objeto
encontra-se armazenado no momento. Podemos constatar isso observando as marcações com
valor null em todos os dez espaços que se encontram inicialmente disponíveis no ArrayList.
Como vimos na Unidade 3, em Java, assim como na linguagem C, a primeira posição do Array é
referenciada com [0].

Associar objetos (aluno versus livro)


Uma vez que os objetos “maria” (tipo Pessoa) e “java” (tipo Livro) estejam instanciados,
realizaremos a associação entre eles. Para isso, vamos utilizar o método retiraLivro() que se en-
contra disponível na classe Pessoa. Para executá-lo, clique com o botão direito do mouse sobre
o objeto “maria” e execute a opção retiraLivro() (Figura 38), localizada no submenu “inherited
from Pessoa" (herdado de Pessoa). Como resultado dessa ação, o BlueJ exibirá uma nova janela
contendo informações sobre o livro que será associado a “maria” (Figura 39).
140 © Programação Orientada a Objetos

Figura 38 BlueJ: métodos herdados da classe Pessoa sobre a visão do objeto maria (Aluno).

Figura 39 Método retiraLivro executado sobre o objeto maria.

Note, pela declaração do método retiraLivro(), que o parâmetro esperado para tal método
é um objeto do tipo "Livro". Assim, recomendamos que digite o nome do objeto que se deseja
relacionar ao objeto "maria". Conforme indicado na Figura 39, digite o termo java e clique no
botão "Ok" para confirmar a execução do método. O termo java deve ser digitado sem aspas,
pois o nome refere-se ao objeto do tipo “Livro”, que instanciamos anteriormente e encontra-se
representado (quadrado vermelho) na barra inferior da ferramenta BlueJ.
Como resultado da ação anterior, o BlueJ realizará a associação do objeto "java” com o
objeto “maria”. A ferramenta BlueJ não exibe qualquer representação visual na tela principal
sobre a associação entre os objetos. Isso acontece porque o vínculo entre tais objetos foi estabe-
lecido por meio de atributos dentro dos objetos. Para visualizar a associação, você deve analisar
as propriedades de cada objeto. Assim, orientamos que realize os procedimentos apresentados
anteriormente, para visualizar as características de cada objeto (opção "Inspect” sobre os obje-
tos). Inicialmente, recomendamos que analise o objeto do tipo Livro.

Centro Universitário Claretiano


© Relacionamento entre Objetos 141

Inspecionar os objetos aluno e livro


Com relação ao objeto "java" do tipo Livro (Figura 40), a visualização de suas característi-
cas indica que agora existe, no atributo pessoa, do tipo Pessoa, um objeto vinculado. Devemos
entender essa associação como uma situação em que o livro foi retirado da biblioteca pelo
aluno. Para visualizar quem foi o aluno (Pessoa) que retirou o livro, selecione o atributo pessoa
do objeto “Livro” (marcação em amarelo da Figura 40) e clique sobre o botão "Inspect". Como
resultado, uma nova janela será exibida e nela será apresentado um objeto do tipo "Pessoa" e
será apresentado o objeto "maria" (Figura 41).

Figura 40 Inspect sobre o objeto java (Livro).

Figura 41 Inspect sobre o atributo pessoa do objeto java (Livro).

Já que as informações do objeto "maria" encontram-se acessíveis no BlueJ, vamos analisar


o atributo livros para verificar como a associação afetou o objeto Pessoa. Para isso, selecione o
atributo livros (marcação em amarelo na Figura 41) e clique sobre o botão "Inspect" da própria
janela. Como resultado dessa ação, o BlueJ exibirá uma nova janela (Figura 42) indicando que
existem armazenados neste momento um (1) objeto na estrutura do ArrayList.
142 © Programação Orientada a Objetos

Inspecionar o Arraylist de livros


Para visualizar a lista de objetos armazenados no ArrayList, selecione o atributo elemen-
tData (marcação em amarelo na Figura 42) e clique sobre o botão "Inspect” da mesma janela.
O BlueJ exibirá, como resultado dessa ação, uma nova janela contendo informações sobre os
objetos armazenados na estrutura (Figura 43). Note que a primeira posição do ArrayList ( [0] )
indicará a existência de um objeto associado. Em seguida, clique sobre essa posição (marcação
em amarelo na Figura 43) e, em seguida, sobre o botão "Inspect" da própria janela. A ferramenta
exibirá uma nova janela contendo as características do objeto do tipo Livro (objeto “java”) que
se encontra associado ao objeto “maria” (Figura 44).

Figura 42 BlueJ: “inspect” sobre o objeto livros do objeto maria.

Figura 43 Relação de objetos do ArrayList livros do objeto maria.

Centro Universitário Claretiano


© Relacionamento entre Objetos 143

Figura 44 "Inspect" sobre a posição zero do ArrayList (livros) do objeto maria.

Veja como a linguagem Java, por meio dos atributos localizados nos objetos Livro e Pessoa,
estabeleceu vínculos cruzados entre os objetos associados. Essa característica possibilita que
informações sobre os objetos vinculados sejam facilmente obtidas.

Modificar a classe Executa


Para testar se a associação está funcionando corretamente, vamos adicionar, na classe
Executa, a instanciação de novos objetos e realizar a execução de métodos que estabelecem a
associação entre os objetos. Para isso, modifique o código da classe Executa, adicionando, no
código, o trecho a seguir em negrito. Aceite a sugestão de testar se a associação está funcionan-
do corretamente., obedeça às instruções do código a seguir.
código 12
package biblioteca; // pacote biblioteca
class Executa { // classe de testes
public static void main(String args[]) { // método que executa programa
// criação de um objeto do tipo “Pessoa”
Pessoa jose = new Pessoa(“Jose”,”01/06/1975”);
// exibição dos atributos do objeto jose
System.out.println(“Nome = “ + jose.getNome() +
“-Data de Nascimento = “ + jose.getData() );

// criação de um objeto do tipo “Aluno”


Aluno maria = new Aluno(“Maria”,”10/11/1976”,”111111”,”Computacao”);
// atribui valores ao telefone de maria
maria.setFone(“019”,”98765432”);
// exibição dos atributos do objeto maria
System.out.println(“Nome = “ + maria.getNome() +
“-Data de Nascimento = “ + maria.getData() +
“-RA = “ + maria.getRa() +
“-Curso = “ + maria.getCurso() );
// exibe o telefone de maria
System.out.println(“Telefone de “ + maria.getNome() + “ = “ + maria.getFone());

// criação de um objeto do tipo “Professor”


Professor pedro = new Professor(“Pedro”,”05/05/1970”,”Mestre”,”02/02/2007”);
// atribui valores ao telefone de pedro
pedro.setFone(“019”,”12345678”);
// exibição dos atributos do objeto pedro
System.out.println(“Nome = “ + pedro.getNome() +
“-Data de Nascimento = “ + pedro.getData() +
144 © Programação Orientada a Objetos

“-Titulacao = “ + pedro.getTitulacao() +
“-Contratado em = “ + pedro.getDataContratacao() );
// exibe o telefone de pedro
System.out.println(“Telefone de “ + pedro.getNome() + “ = “ + pedro.getFone());

Livro java = new Livro(“Java basico”,”Livros e Cia”,”1111”);


Livro oo = new Livro(“Orientacao a Objetos”,”Livros e Cia”,”2222”);
maria.retiraLivro( java );
maria.retiraLivro( oo );
maria.listaLivrosRetirados();
java.comQuemEsta();
oo.comQuemEsta();
maria.devolveLivro( java );
java.comQuemEsta();
pedro.listaLivrosRetirados();
}
}

fim código 12

Uma vez modificado o código da classe Executa, realize a compilação das classes. Caso o
processo de compilação resulte em erros, verifique novamente os códigos digitados, comparan-
do-os com os códigos apresentados anteriormente.

Executar o método main da classe Executa


Depois de compiladas as classes, vamos realizar a execução do método main da classe
Executa (Figura 45). Nessa execução, não é necessária a passagem de parâmetros (Figura 46).
Clique no botão "Ok" e visualize as mensagens retornadas pelos objetos criados na declaração
do método main da classe Executa, conforme mostra a Figura 47.

Figura 45 Área de trabalho do BlueJ após criar associação entre classes.

Centro Universitário Claretiano


© Relacionamento entre Objetos 145

Figura 46 BlueJ: execução do método main.

Figura 47 BlueJ: mensagens.

A implementação da associação resultou na criação de um conjunto de métodos que não


estavam inicialmente descritos no diagrama de classes da Figura 1. Ao implementar um sistema,
muitas vezes os programadores necessitam criar métodos e atributos para que seja possível a
implementação do sistema.
Para aprimorar seus conhecimentos no uso da estrutura ArrayList, recomendamos que
estude os códigos implementados nas classes Pessoa e Livro. Para maior compreensão, foram
adicionados comentários a cada linha do código.

Classe Arraylist e seus métodos


O ArrayList é uma classe disponível na biblioteca "util" da linguagem Java e sua utilização
é difundida entre os programadores da linguagem. A seguir, destacamos os principais métodos
que possibilitam a manipulação de objetos usando essa estrutura.
146 © Programação Orientada a Objetos

Quadro 1 Manipulação de objetos usando a estrutura ArrayList.


PRINCIPAIS MÉTODOS DA ESTRUTURA ARRAYLIST
Operação Comando Exemplo de Uso no Código
Criar nova lista new ArrayList(); public Pessoa(String nome, String data) // método
de objetos construtor com dois parâmetros
{
// Atribui o valor do parâmetro nome à variável nome
this.nome = nome;
// atribui o valor do parâmetro data à variável
dataDeNascimento
dataDeNascimento = data;
// cria objeto do tipo Telefone
fone = new Telefone();
// inicializa a estrutura de controle de livro
retirados
livros = new ArrayList();
}
Quantidade livros.size() // Origem = Classe Pessoa
de objetos // Método: listaLivrosRetirados
armazenados
...
// percorre toda a lista de livros
for(int aux = 0; aux < livros.size(); aux++)
{
...
}
...
Acessar objetos livros.get(int) // Origem = Classe Pessoa
// método que mostra os livros vínculos a pessoa
public void listaLivrosRetirados( )
em que:
{
// verifica se lista existe e se tem objetos
int é o índice ou if (livros != null && livros.size() > 0 ) {
posição do elemento Livro livro; // variavel que recebera livro da lista
na lista System.out.println(“Livros retirados por “+nome+” :”);
// percorre toda a lista de livros
for(int aux = 0; aux < livros.size(); aux++)
{
// pega o próximo objeto da lista de livros
livro = (Livro)livros.get(aux);
System.out.println(“LIVRO - “+(aux+1)+”:”);
// imprime os valores do livro
livro.mostrar();
}
} else { // Não existem livros associados a pessoa
System.out.println(nome+” nao tem livro(s)
retirado(s).”);
}
}
Incluir objetos lista.add( objeto ) // Origem = Classe Pessoa
na lista // método que adiciona um livro na lista de livros retirados
(ASSOCIACAO)
public void addLivro( Livro livro )
{
if (livro != null) { // verifica se existe o parâmetro
// adiciona o livro na lista de retirados
livros.add( livro );
}
}

Centro Universitário Claretiano


© Relacionamento entre Objetos 147

PRINCIPAIS MÉTODOS DA ESTRUTURA ARRAYLIST


Operação Comando Exemplo de Uso no Código
Excluir objetos livros.remove(int) // método que retira vinculo de livro com pessoa
da lista public void devolveLivro( Livro livroDevolvido )
{
em que:
// verifica se lista existe e se tem objetos
if (livros != null && livros.size() > 0 ) {
int é o índice ou Livro livro; // variavel que recebera livro da lista
posição do elemento // percorre toda a lista de livros
a ser removido da for(int aux = 0; aux < livros.size(); aux++)
lista. {
// pega o próximo objeto da lista de livros
livro = (Livro)livros.get(aux);
if ( livro.getIsbn().equals( livroDevolvido.
getIsbn() ) ) {
// retira objeto da lista
livros.remove(aux);
// desassocia livro de pessoa
livroDevolvido.devolveLivro();
}
}
}
}

É importante lembrar que a modelagem orientada a objetos (diagrama de classes), criada


pelo analista de sistemas, não restringe a implementação de novos métodos e atributos, mas,
sim, oferece uma especificação à equipe de programação das funcionalidades e regras que o
sistema deverá atender.
Um importante detalhe que podemos adicionar à implementação do sistema de biblioteca
é a utilização de classes abstratas.

Classes Abstratas
Classe Abstrata é uma classe que não permite a instanciação de objetos, isto é, o operador
new não funciona quando utilizado em uma classe abstrata.
Vimos que as classes são criadas como resultado do processo de classificação e represen-
tam características e comportamentos de um grupo de objetos semelhantes. Assim, qual é a
utilidade de uma classe que não permite a criação de objetos? Uma justificativa para o uso de
classes abstratas é que elas podem ser utilizadas para criar definições de tipos de dados (classes)
que serão reutilizados por outras classes por meio da herança.
No sistema da biblioteca (Figura 1), a classe Pessoa pode ser definida como abstrata, e
apenas os objetos do tipo “Aluno” e “Professor” existirão no sistema. Essa regra é interessante,
pois a biblioteca só permite a retirada de livros por alunos ou professores.
O operador Java, responsável pela criação de classes abstratas, é abstract. Para tornar
abstrata a classe Pessoa, é necessário incluir o operador abstract antes do termo class. Veja, a
seguir, como deve ficar a linha de definição da classe Pessoa:
public abstract class Pessoa { // classe Pessoa

Reproduza a alteração anterior no código da classe Pessoa, incluindo o comando abstract


na linha de declaração da classe. Para testar se a adaptação da classe abstrata funcionou cor-
retamente, recomendamos que inclua um comentário no arquivo da classe Executa, conforme
exibido no trecho, a seguir em negrito. Essa alteração é importante, pois uma vez que a classe
Pessoa tenha sido declarada como abstract, a instanciação de objetos diretamente por meio
dela será restringida pela linguagem Java.
148 © Programação Orientada a Objetos

código 13
package biblioteca; // pacote biblioteca
class Executa { // classe de testes
public static void main(String args[]) { // método que executa programa
/*
// criação de um objeto do tipo “Pessoa”
Pessoa jose = new Pessoa(“Jose”,”01/06/1975”);
// exibição dos atributos do objeto jose
System.out.println(“Nome = “ + jose.getNome() +
“-Data de Nascimento = “ + jose.getData() );
*/
// criação de um objeto do tipo “Aluno”
Aluno maria = new Aluno(“Maria”,”10/11/1976”,”111111”,”Computacao”);
// atribui valores ao telefone de maria
maria.setFone(“019”,”98765432”);
// exibição dos atributos do objeto maria
System.out.println(“Nome = “ + maria.getNome() +
“-Data de Nascimento = “ + maria.getData() +
“-RA = “ + maria.getRa() +
“-Curso = “ + maria.getCurso() );
// exibe o telefone de maria
System.out.println(“Telefone de “ + maria.getNome() + “ = “ + maria.getFone());

// criação de um objeto do tipo “Professor”


Professor pedro = new Professor(“Pedro”,”05/05/1970”,”Mestre”,”02/02/2007”);
// atribui valores ao telefone de pedro
pedro.setFone(“019”,”12345678”);
// exibição dos atributos do objeto pedro
System.out.println(“Nome = “ + pedro.getNome() +
“-Data de Nascimento = “ + pedro.getData() +
“-Titulacao = “ + pedro.getTitulacao() +
“-Contratado em = “ + pedro.getDataContratacao() );
// exibe o telefone de pedro
System.out.println(“Telefone de “ + pedro.getNome() + “ = “ + pedro.getFone());

Livro java = new Livro(“Java basico”,”Livros e Cia”,”1111”);


Livro oo = new Livro(“Orientacao a Objetos”,”Livros e Cia”,”2222”);
maria.retiraLivro( java );
maria.retiraLivro( oo );
maria.listaLivrosRetirados();
java.comQuemEsta();
oo.comQuemEsta();
maria.devolveLivro( java );
java.comQuemEsta();
pedro.listaLivrosRetirados();
}
}

fim código 13

Uma vez modificado os códigos das classes Pessoa e Executa, realize a sua compilação.
Caso o processo de compilação resulte em erros, verifique novamente os códigos digitados,
comparando-os com os códigos descritos nesta obra.
Agora que as classes estão compiladas, vamos realizar a execução do método main da classe
Executa. Nessa execução, não é necessária a passagem de parâmetros. Clique no botão "Ok” e
visualize as mensagens retornadas pelos objetos criados na declaração do método main da classe
Executa. Note que a alteração anterior realizada não mais instanciará objetos do tipo Pessoa. To-
das as demais classes criadas continuarão funcionando da mesma forma como antes.
Vale destacar que o operador abstract também pode ser aplicado sobre os métodos de
uma classe. Um método abstrato é parecido com um método normal, porém não contém codi-
ficação. A classe que contém um método declarado como abstrato deve, também, ser declarada
abstrata. Assim, a implementação do método abstrato será realizada nas classes filhas as quais
herdam o método da classe pai. O conceito de sobrescrever a implementação de um método é
denominado Overriding. Para ser considerado overriding, o método definido na subclasse tem a

Centro Universitário Claretiano


© Relacionamento entre Objetos 149

mesma assinatura de um método existente na superclasse. Entendem-se como de mesma assi-


natura dois métodos que tenham o mesmo nome, tipo de retorno e lista de parâmetros iguais.
Outro conceito similar é o overloaded, que é caracterizado como a sobreposição de méto-
dos que têm o mesmo nome, mas com diferentes assinaturas e definições, por meio de diferen-
tes listas de parâmetros, tanto em número quanto em tipo dos argumentos.

9. EXEMPLO PRÁTICO
Neste tópico, vamos realizar a codificação das relações existentes entre as classes do sis-
tema de controle de orientações e defesas de Tcc. Nesta unidade, você tem a oportunidade de
aprender como as relações de Herança, agregação e associação podem ser codificadas usando a
linguagem de programação Java. Agora, com base no diagrama de classes do novo projeto (Figu-
ra 48), vamos realizar as modificações necessárias para finalizar o projeto do novo sistema.

Aluno Curso Coordenador


matricula nome
nome ramal
sigla cargaHoraria
ra area
fazMatricula trocarCoordenador

Tcc Banca Professor


titulo nome
ano data
parecer titulacao
situacao email
notas
vincularAluno atribuirProfessor
vincularBanca
Figura 48 Diagrama de classes do sistema de orientações e defesas de Tcc (UML).

Antes de realizarmos qualquer nova implementação, vamos executar a ferramenta BlueJ


e preparar nosso ambiente de desenvolvimento. Possivelmente, a sua ferramenta BlueJ está
exibindo as classes do projeto "poo". Precisamos retornar ao projeto "tcc" para continuar o de-
senvolvimento do novo sistema. Assim, recomendamos que você feche o atual projeto ("poo")
e abra o projeto "tcc" localizado em seu computador.
Uma vez que o ambiente de desenvolvimento do BlueJ esteja configurado, podemos en-
tão iniciar o desenvolvimento das relações existentes entre as classes do novo trabalho. Neste
primeiro momento, iniciaremos as alterações nas classes Coordenador e Professor, de modo
que represente no código a relação de Herança que é estabelecida entre as classes.

Herança: Coordenador e Professor


Conforme já estudamos, a relação de Herança indica que existe uma relação de proximi-
dade entre as classes relacionadas, de modo que permita afirmar que uma classe é do tipo da
150 © Programação Orientada a Objetos

outra. No nosso caso, a classe Coordenador herda as definições da classe Professor, assim pode-
mos dizer que um Coordenador é um Professor.
A vantagem da Herança entre classes é permitir que a subclasse (Coordenador) herde to-
das as definições realizadas na superclasse (Professor), ou seja, os atributos e métodos declara-
dos em Professor (superclasse) fazem parte da definição de Coordenador. A Herança possibilita
um alto nível de reutilização de código, pois concentra na superclasse todas as definições que
são compartilhadas com as subclasses.
Conforme você estudou nesta unidade, a relação de Herança é representada em lingua-
gem Java por meio do comando extends. Em termos de codificação, as principais mudanças
acontecerão na classe Coordenador (subclasse), pois ela deverá indicar que herda as definições
da classe Professor (superclasse). Além disso, a indicação de Herança exigirá que o método cons-
trutor da classe Coordenador seja modificado, pois uma vez que o Coordenador é um Professor,
ele possuirá um conjunto maior de atributos e, portanto, precisará receber parâmetros para
atribuir valores a todos os atributos do modificado objeto Coordenador.
Vale ressaltar, em relação à implementação da Herança, que a superclasse Professor não
sofrerá qualquer alteração por conta de sua relação com a subclasse Coordenador. Essa afirma-
ção é verdadeira, pois uma classe já definida (superclasse) não poderá sofrer interferência em
seu código devido a outras classes (subclasses) herdarem posteriormente suas definições.

Modificar a classe Coordenador


As mudanças anteriormente indicadas encontram-se disponíveis no código a seguir e es-
tão ressaltadas em negrito. Você deverá modificar o código-fonte da classe Coordenador.
código 14
/**
* Classe Coordenador.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Coordenador extends Professor
{
// variáveis da instância que representam as características do Coordenador
private String ramal;
private String cargaHoraria;
/**
* Método Construtor responsável por criar objetos do tipo Coordenador
*/
public Coordenador(String nome, String sigla, String email, String ramal, String
cargaHoraria)
{
// super é o sinônimo para o método construtor da superclasse
super(nome, sigla, email);
// atribui valores para as variáveis da instância (objeto)
this.ramal = ramal;
this.cargaHoraria = cargaHoraria;
}
/**
* Método que exibe informações sobre o Coordenador
*/
public void exibeInformacoes()
{
// super é referência para a superclasse
super.exibeInformacoes();
System.out.println(“Informações sobre Coordenador:”);
System.out.println(“Ramal: “+ramal);
System.out.println(“Carga Horária: “+cargaHoraria);
}
}

fim código 14

Centro Universitário Claretiano


© Relacionamento entre Objetos 151

Modificar a classe Executa


Em razão das mudanças realizadas na classe Professor, precisaremos, também, modificar
a classe Executa, pois ela realiza chamada ao método construtor que foi modificado na classe
Coordenador. Assim, para testarmos se a Herança está funcionando corretamente entre as clas-
ses Coordenador e Professor, vamos modificar o código da classe Executa com base no código a
seguir em negrito.

código 15
class Executa
{ // classe de teste do projeto tcc
public static void main(String args[]) // método que inicia o teste
{
Aluno jose; // variável jose é do tipo Aluno
Curso computacao; // variável computacao é do tipo Curso
Coordenador carlos; // variável carlos é do tipo Coordenador
Tcc trabalho; // variável trabalho é do tipo Tcc
Banca banca; // variável banca é do tipo Banca
Professor paulo; // variável paulo é do tipo Professor

try {
// cria objeto usando o método construtor e
// associa o objeto criado a variável do tipo correspondente
jose = new Aluno(“Jose”,”111111”);
jose.exibeInformacoes(); // invoca um método sobre o objeto

computacao = new Curso(“Computação”,”COMP”,”exatas”);


computacao.exibeInformacoes(); // invoca um método sobre o objeto

carlos = new Coordenador(“Carlos”,”Doutorado”,”carlos@email.com”,”123”,”40”);


carlos.exibeInformacoes(); // invoca um método sobre o objeto

trabalho = new Tcc(“Orientação a Objetos”, 2010, “Aprovado”, 9);


trabalho.exibeInformacoes(); // invoca um método sobre o objeto

banca = new Banca(“01/06/2010”,”Favorável”);


banca.exibeInformacoes(); // invoca um método sobre o objeto

paulo = new Professor(“Paulo”,”Mestrado”,”paulo@email.com”);


paulo.exibeInformacoes(); // invoca um método sobre o objeto

} catch(Exception e) {
// inserir aqui o tratamento das exceções
// exibe a mensagem correspondente à exceção ocorrida
System.out.println( e.getMessage() );
} finally {
// inserir aqui as últimas instruções a serem executadas após o bloco try
// finaliza os objetos para liberar espaço de memória para outras alocações
jose = null; // finaliza objeto do tipo Aluno
computacao = null; // finaliza objeto do tipo Curso
carlos = null; // finaliza objeto do tipo Coordenador
trabalho = null; // finaliza objeto do tipo Tcc
banca = null; // finaliza objeto do tipo Banca
paulo = null; // finaliza objeto do tipo Professor
}
}
}

fim código 15

Uma vez modificado o código da classe Executa, realize a compilação das classes. Caso o
processo de compilação resulte em erros, verifique novamente os códigos digitados, comparan-
do-os com os códigos apresentados nesta obra.
152 © Programação Orientada a Objetos

Executar o método main da classe Executa


Após a compilação das classes, o ambiente de trabalho no BlueJ terá uma aparência seme-
lhante à exibida na Figura 49. Modifique a posição das classes para visualizar a seta indicativa de
Herança entre as classes Coordenador e Professor.
Vamos agora realizar a execução do método main da classe Executa. Nessa execução, não
é necessária a passagem de parâmetros. Clique no botão "Ok" e visualize, a seguir, as mensa-
gens retornadas pelos objetos criados na declaração do método main da classe Executa.

Figura 49 Área de trabalho do BlueJ após criar herança entre classes.

Veja, a seguir, a saída do código 15.

Informações sobre Aluno:


Nome: Jose
Ra: 111111
Informações sobre Curso:
Nome: Computação
Sigla: COMP
Area: exatas
Informações sobre o Professor:
Nome: Carlos
Titulação: Doutorado
Email: carlos@email.com
Informações sobre Coordenador:
Ramal: 123
Carga Horária: 40
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
Situação: Aprovado
Nota: 9.0

Centro Universitário Claretiano


© Relacionamento entre Objetos 153
Informações sobre a Banca:
Data: 01/06/2010
Parecer: Favorável
Informações sobre o Professor:
Nome: Paulo
Titulação: Mestrado
Email: paulo@email.com

Nas mensagens exibidas pela execução do método main da classe Executa foram destaca-
das, em negrito, aquelas que envolvem, diretamente, as modificações realizadas sobre a classe
Coordenador. Note que agora as impressões realizadas sobre o objeto do tipo Coordenador
também exibem dados que antes faziam parte apenas de objetos do tipo Professor. Essa cons-
tatação exemplifica como a Herança realmente proporciona um alto grau de reaproveitamento
de código.

Agregação
Continuando com o desenvolvimento do sistema de controle de orientações e defesas de
Tcc, vamos agora focar nas relações do tipo agregação. O diagrama de classes do projeto (Figura
48) exibe quatro relações de agregação que ocorrem entre as respectivas classes: Curso e Coor-
denador, Tcc e Aluno, Banca e Professor, e Tcc e Banca.
Conforme vimos anteriormente, a relação de agregação indica uma relação do tipo "parte-
todo", em que a classe agregadora utiliza como parte de sua definição e estrutura a classe agre-
gada. Com base no novo projeto, observamos que:
a) Curso é a classe agregadora e Coordenador é a classe agregada.
b) Tcc é a classe agregadora e Aluno é a classe agregada.
c) Banca é a classe agregadora e Professor é a classe agregada.
d) Tcc é a classe agregadora e Banca é a classe agregada.
Como visto nesta unidade, a implementação de agregação entre classes é realizada por
meio da adição de um novo atributo na classe agregadora. Esse novo atributo, declarado como
uma variável do tipo da classe agregada, armazenará a referência ao objeto agregado. Acompa-
nhe, a seguir, a implementação das agregações existentes no projeto.

Agregação: Curso e Coordenador


A relação de agregação entre Curso e Coordenador será implementada adicionando um
novo atributo à classe Curso. Esse novo atributo será declarado como uma variável do tipo Co-
ordenador e servirá para armazenar a referência ao objeto agregado.
Como a modificação realizada na classe Curso envolve a adição de um novo atributo, então
precisaremos adicionar, também, um método para permitir que o objeto agregado coordenador
seja vinculado à classe Curso. Note que o diagrama de classes da Figura 48 exibe um método
chamado "trocarCoordenador" que servirá exatamente para esse propósito.

Modificar a classe Curso


As mudanças indicadas encontram-se disponíveis no código a seguir e estão ressaltadas
em negrito. Você deverá modificar o código-fonte da classe Curso.
154 © Programação Orientada a Objetos

código 16
/**
* Classe Curso.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Curso
{
// variáveis da instância que representam as características do Curso
private String nome;
private String sigla;
private String area;
// Novo atributo inserido devido à agregação entre Curso e Coordenador
private Coordenador coord;

/**
* Método Construtor responsável por criar objetos do tipo Curso
*/
public Curso(String nome, String sigla, String area)
{
// atribui valores para as variáveis da instância (objeto)
this.nome = nome;
this.sigla = sigla;
this.area = area;
}

/**
* Método que exibe informações sobre o Curso
*/
public void exibeInformacoes()
{
System.out.println(“Informações sobre Curso:”);
System.out.println(“Nome: “+nome);
System.out.println(“Sigla: “+sigla);
System.out.println(„Area: „+area);
// Exibe informacoes sobre o Coordenador do Curso
if (coord == null) System.out.println(“Curso não tem coordenador”);
else System.out.println(“Curso tem coordenador e seu nome é “ + coord.getNome());
}

/**
* Método que troca o Coordenador de Curso
*/
public void trocarCoordenador(Coordenador c)
{
coord = c;
}
}

fim código 16

Modificar a classe Professor


O código da classe Curso foi modificado para possibilitar o registro do coordenador. Essa
modificação ocasionou a inclusão de um novo atributo chamado "coord" que armazenará um
objeto do tipo coordenador. Por conta dessa mudança, uma melhoria foi feita no método "exi-
beInformacoes()" da classe Curso. Agora, este método exibirá o nome do coordenador do curso,
caso ele possua. Se não possuir, o método exibirá uma mensagem informando que não existe
coordenador atribuído.
Por conta dessa pequena melhoria, o método "exibeInformacoes()" precisará recuperar
o nome do coordenador. O nome do coordenador é um atributo definido na classe Professor. A
classe Coordenador herda as definições da classe Professor, por isso podemos afirmar que todo
Coordenador é um Professor.

Centro Universitário Claretiano


© Relacionamento entre Objetos 155

Com base nessa informação, vamos focar nosso olhar sobre a classe Professor. Nela os
atributos estão todos definidos como private, isto é, de acesso restrito à classe. Dessa forma,
nenhum acesso externo será permitido ao atributo nome. E assim, precisaremos realizar uma
modificação na classe Professor. Por conta da boa prática de encapsulamento, não vamos expor
os atributos da classe às classes externas usando o modificador de acesso public. A melhor e
mais indicada solução para esse caso é criar um novo método para acessar o atributo nome.
Conforme já estudamos, esse método de acesso é conhecido como método de acesso.
Acompanhe, no código disponível a seguir, as modificações que estão ressaltadas em ne-
grito e que deverão ser realizadas na classe Professor.
código 17
/**
* Classe Professor.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Professor
{
// variáveis da instância que representam as características do Professor
private String nome;
private String titulacao;
private String email;

/**
* Método Construtor responsável por criar objetos do tipo Professor
*/
public Professor(String nome, String titulacao, String email)
{
// atribui valores para as variáveis da instância (objeto)
this.nome = nome;
this.titulacao = titulacao;
this.email = email;
}

/**
* Método que exibe informações sobre o Professor
*/
public void exibeInformacoes( )
{
System.out.println(“Informações sobre o Professor:”);
System.out.println(“Nome: “+nome);
System.out.println(“Titulação: “+titulacao);
System.out.println(“Email: “+email);
}

/**
* Método acessor do atributo nome
*/
public String getNome() {
return nome;
}
}

fim código 17

Modificar a classe Executa


Para testarmos se a agregação entre Curso e Coordenador está funcionando corretamente,
vamos adicionar na classe Executa algumas chamadas de métodos. Essas chamadas consistem,
basicamente, da invocação do método "trocarCoordenador", repassando como parâmetro um
objeto do tipo Coordenador, e da invocação do método "exibeInformacoes()", antes e depois
da vinculação do objeto coordenador ao objeto curso. Modifique o código da classe Executa,
adicionando, no código, o trecho a seguir em negrito.
156 © Programação Orientada a Objetos

Lembre-se de que os comentários existentes nos códigos não precisam ser adicionados à
sua codificação, pois não influenciam na compilação e na execução das classes. Os comentários
servem apenas para repassar mais informações sobre as modificações realizadas.
código 18
class Executa
{ // classe de teste do projeto tcc
public static void main(String args[]) // método que inicia o teste
{
Aluno jose; // variável jose é do tipo Aluno
Curso computacao; // variável computacao é do tipo Curso
Coordenador carlos; // variável carlos é do tipo Coordenador
Tcc trabalho; // variável trabalho é do tipo Tcc
Banca banca; // variável banca é do tipo Banca
Professor paulo; // variável paulo é do tipo Professor

try {
// cria objeto usando o método construtor e
// associa o objeto criado a variável do tipo correspondente
jose = new Aluno(“Jose”,”111111”);
jose.exibeInformacoes(); // invoca um método sobre o objeto

computacao = new Curso(“Computação”,”COMP”,”exatas”);


computacao.exibeInformacoes(); // invoca um método sobre o objeto

carlos = new Coordenador(“Carlos”,”Doutorado”,”carlos@email.com”,”123”,”40”);


carlos.exibeInformacoes(); // invoca um método sobre o objeto

trabalho = new Tcc(“Orientação a Objetos”, 2010, “Aprovado”, 9);


trabalho.exibeInformacoes(); // invoca um método sobre o objeto

banca = new Banca(“01/06/2010”,”Favorável”);


banca.exibeInformacoes(); // invoca um método sobre o objeto

paulo = new Professor(“Paulo”,”Mestrado”,”paulo@email.com”);


paulo.exibeInformacoes(); // invoca um método sobre o objeto

// Vincula um coordenador ao curso (Agregação)


computacao.trocarCoordenador( carlos );
computacao.exibeInformacoes(); // invoca um método sobre o objeto

} catch(Exception e) {
// inserir aqui o tratamento das exceções
// exibe a mensagem correspondente à exceção ocorrida
System.out.println( e.getMessage() );
} finally {
// inserir aqui as últimas instruções a serem executadas após o bloco try
// finaliza os objetos para liberar espaço de memória para outras alocações
jose = null; // finaliza objeto do tipo Aluno
computacao = null; // finaliza objeto do tipo Curso
carlos = null; // finaliza objeto do tipo Coordenador
trabalho = null; // finaliza objeto do tipo Tcc
banca = null; // finaliza objeto do tipo Banca
paulo = null; // finaliza objeto do tipo Professor
}
}
}

fim código 18

Uma vez realizada a última modificação necessária, compile todas as classes. Caso o pro-
cesso de compilação resulte em erros, verifique novamente os códigos digitados, comparando-
-os com os códigos exibidos neste conteúdo.

Executar o método main da classe Executa


Após a compilação das classes, o ambiente de trabalho no BlueJ terá uma aparência seme-
lhante à exibida na Figura 50. Modifique a posição das classes para visualizar a seta indicativa de
relação de agregação entre as classes Curso e Coordenador.
Centro Universitário Claretiano
© Relacionamento entre Objetos 157

Vamos agora realizar a execução do método main da classe Executa. Nessa execução, não
é necessária a passagem de parâmetros. Clique no botão "Ok" e visualize, a seguir, as mensa-
gens retornadas pelos objetos criados na declaração do método main da classe Executa.

Figura 50 Área de trabalho do BlueJ após criar a agregação entre as classes Coordenador e Curso.

Veja a seguir a saída do Código 18.

Informações sobre Aluno:


Nome: Jose
Ra: 111111
Informações sobre Curso:
Nome: Computação
Sigla: COMP
Area: exatas
Curso não tem coordenador
Informações sobre o Professor:
Nome: Carlos
Titulação: Doutorado
Email: carlos@email.com
Informações sobre Coordenador:
Ramal: 123
Carga Horária: 40
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
158 © Programação Orientada a Objetos

Situação: Aprovado
Nota: 9.0
Informações sobre a Banca:
Data: 01/06/2010
Parecer: Favorável
Informações sobre o Professor:
Nome: Paulo
Titulação: Mestrado
Email: paulo@email.com
Informações sobre Curso:
Nome: Computação
Sigla: COMP
Area: exatas
Curso tem coordenador e seu nome é Carlos

Nas mensagens exibidas pela execução do método main da classe Executa foram desta-
cadas em negrito aquelas que envolvem diretamente as modificações realizadas sobre as clas-
ses Curso e Professor. Note que agora as impressões realizadas sobre o objeto do tipo Curso
também exibem se existe coordenador vinculado. Veja, no detalhe, que a primeira chamada ao
método "exibeInformacoes()" do objeto "computacao" não trouxe coordenador vinculado, en-
quanto, na segunda chamada ao método "exibeInformacoes()", é exibida uma mensagem com
o nome do coordenador agregado.

Agregação: Tcc e Aluno


De forma similar à implementação anterior, a relação de agregação entre Tcc e Aluno será
implementada adicionando um novo atributo à classe Tcc. Esse novo atributo será declarado
como uma variável do tipo Aluno e servirá para armazenar a referência ao objeto agregado.
Como a modificação realizada na classe Tcc envolve a adição de um novo atributo, então
precisaremos adicionar, também, um método para permitir que o objeto agregado aluno seja
vinculado à classe Tcc. Note que o diagrama de classes da Figura 48 exibe um método chamado
"vincularAluno", que servirá exatamente para esse propósito.

Modificar a classe Tcc


As mudanças descritas encontram-se disponíveis no código a seguir e estão ressaltadas
em negrito. Você deverá modificar o código-fonte da classe Tcc.
código 19
/**
* Classe Tcc.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Tcc
{
// variáveis da instância que representam as características do Tcc
private String titulo;
private int ano;
private String situacao;
private float nota;
// Novo atributo inserido devido a agregação entre Tcc e Aluno
private Aluno aluno;

/**
* Método Construtor responsável por criar objetos do tipo Tcc
*/
public Tcc(String titulo, int ano, String situacao, float nota)
{
// atribui valores para as variáveis da instância (objeto)
this.titulo = titulo;

Centro Universitário Claretiano


© Relacionamento entre Objetos 159
this.ano = ano;
this.situacao = situacao;
this.nota = nota;
}

/**
* Método que exibe informações sobre o Tcc
*/
public void exibeInformacoes( )
{
System.out.println(“Informações sobre Tcc:”);
System.out.println(“Título: “+titulo);
System.out.println(“Ano: “+ano);
System.out.println(“Situação: “+situacao);
System.out.println(“Nota: “+nota);
// Exibe quem é o Aluno responsavel pelo Tcc
if (aluno == null) System.out.println(“Tcc não tem aluno vinculado”);
else System.out.println(“Este Tcc é de “ + aluno.getNome());
}
/**
* Método que vincula o Aluno ao Tcc
*/
public void vincularAluno(Aluno a)
{
aluno = a;
}
}

fim código 19

Modificar a classe Aluno


O código da classe Tcc foi modificado para possibilitar o registro do aluno. Essa modifica-
ção ocasionou a inclusão de um novo atributo chamado "aluno" que armazenará um objeto do
tipo aluno. Por conta dessa mudança, uma melhoria foi feita no método "exibeInformacoes()"
da classe Tcc. Agora este método exibirá o nome do aluno responsável pelo tcc, caso ele possua.
Se não possuir, o método exibirá uma mensagem informando que não existe aluno atribuído.
Em razão dessa pequena melhoria, o método "exibeInformacoes()" precisará recuperar
o nome do aluno. O nome do aluno é um atributo definido na classe Aluno. Nela os atributos
estão todos definidos como private, isto é, de acesso restrito à classe. Dessa forma, nenhum
acesso externo será permitido ao atributo nome. E, assim, precisaremos realizar uma modifica-
ção na classe Aluno. Por conta da boa prática de encapsulamento, não vamos expor os atributos
da classe às classes externas usando o modificador de acesso public. A melhor e mais indicada
solução para esse caso é criar um novo método para acessar o atributo nome. Conforme já es-
tudamos, esse método de acesso é conhecido como método acessor.
Acompanhe, no código disponível a seguir as modificações que estão ressaltadas em ne-
grito e que deverão ser realizadas na classe Aluno.
código 20
/**
* Classe Aluno.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Aluno
{
// variáveis da instância que representam as características do Aluno
private String nome;
private String ra;

/**
* Método Construtor responsável por criar objetos do tipo Aluno
160 © Programação Orientada a Objetos

*/
public Aluno(String nome, String ra)
{
// atribui valores para as variáveis da instância (objeto)
this.nome = nome;
this.ra = ra;
}

/**
* Método que exibe informações sobre o Aluno
*/
public void exibeInformacoes( )
{
System.out.println(“Informações sobre Aluno:”);
System.out.println(“Nome: “+nome);
System.out.println(“Ra: “+ra);
}

/**
* Método acessor do atributo nome
*/
public String getNome()
{
return nome;
}
}

fim código 20

Modificar a classe Executa


Para testarmos se a agregação entre Tcc e Aluno está funcionando corretamente, vamos
adicionar na classe Executa algumas chamadas de métodos. Essas chamadas consistem basi-
camente da invocação do método "vincularAluno", repassando como parâmetro um objeto do
tipo Aluno, e da invocação do método "exibeInformacoes()", antes e depois da vinculação do
objeto aluno ao objeto tcc. Modifique o código da classe Executa, adicionando, no código, o
trecho a seguir em negrito.
Lembre-se de que os comentários existentes nos códigos não precisam ser adicionados
à sua codificação, pois não influenciam na compilação e execução das classes. Os comentários
servem apenas para repassar mais informações sobre as modificações realizadas.
código 21
class Executa
{ // classe de teste do projeto tcc
public static void main(String args[]) // método que inicia o teste
{
Aluno jose; // variável jose é do tipo Aluno
Curso computacao; // variável computacao é do tipo Curso
Coordenador carlos; // variável carlos é do tipo Coordenador
Tcc trabalho; // variável trabalho é do tipo Tcc
Banca banca; // variável banca é do tipo Banca
Professor paulo; // variável paulo é do tipo Professor

try {
// cria objeto usando o método construtor e
// associa o objeto criado a variável do tipo correspondente
jose = new Aluno(“Jose”,”111111”);
jose.exibeInformacoes(); // invoca um método sobre o objeto

computacao = new Curso(“Computação”,”COMP”,”exatas”);


computacao.exibeInformacoes(); // invoca um método sobre o objeto

carlos = new Coordenador(“Carlos”,”Doutorado”,”carlos@email.com”,”123”,”40”);


carlos.exibeInformacoes(); // invoca um método sobre o objeto

trabalho = new Tcc(“Orientação a Objetos”, 2010, “Aprovado”, 9);

Centro Universitário Claretiano


© Relacionamento entre Objetos 161
trabalho.exibeInformacoes(); // invoca um método sobre o objeto

banca = new Banca(“01/06/2010”,”Favorável”);


banca.exibeInformacoes(); // invoca um método sobre o objeto

paulo = new Professor(“Paulo”,”Mestrado”,”paulo@email.com”);


paulo.exibeInformacoes(); // invoca um método sobre o objeto

// Vincula um coordenador ao curso (Agregação)


computacao.trocarCoordenador( carlos );
computacao.exibeInformacoes(); // invoca um método sobre o objeto

// Vincula um aluno ao tcc (Agregação)


trabalho.vincularAluno( jose );
trabalho.exibeInformacoes(); // invoca um método sobre o objeto

} catch(Exception e) {
// inserir aqui o tratamento das exceções
// exibe a mensagem correspondente à exceção ocorrida
System.out.println( e.getMessage() );
} finally {
// inserir aqui as últimas instruções a serem executadas após o bloco try
// finaliza os objetos para liberar espaço de memória para outras alocações
jose = null; // finaliza objeto do tipo Aluno
computacao = null; // finaliza objeto do tipo Curso
carlos = null; // finaliza objeto do tipo Coordenador
trabalho = null; // finaliza objeto do tipo Tcc
banca = null; // finaliza objeto do tipo Banca
paulo = null; // finaliza objeto do tipo Professor
}
}
}

fim código 21

Uma vez realizada a última modificação necessária, compile todas as classes. Caso o pro-
cesso de compilação resulte em erros, verifique novamente os códigos digitados, comparando-
-os com os códigos descritos nesta obra.

Executar o método main da classe Executa


Após a compilação das classes, o ambiente de trabalho no BlueJ terá uma aparência seme-
lhante à exibida na Figura 51. Modifique a posição das classes para visualizar a seta indicativa de
relação de agregação entre as classes Tcc e Aluno.
Vamos agora realizar a execução do método main da classe Executa. Nessa execução, não
é necessária a passagem de parâmetros. Clique no botão "Ok” e visualize, a seguir, as mensa-
gens retornadas pelos objetos criados na declaração do método main da classe Executa.
162 © Programação Orientada a Objetos

Figura 51 Área de trabalho do BlueJ após criar a agregação entre as classes Tcc e Aluno.

Veja a seguir a saída do código 21.

Informações sobre Aluno:


Nome: Jose
Ra: 111111
Informações sobre Curso:
Nome: Computação
Sigla: COMP
Area: exatas
Curso não tem coordenador
Informações sobre o Professor:
Nome: Carlos
Titulação: Doutorado
Email: carlos@email.com
Informações sobre Coordenador:
Ramal: 123
Carga Horária: 40
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
Situação: Aprovado
Nota: 9.0
Tcc não tem aluno vinculado
Informações sobre a Banca:
Data: 01/06/2010
Parecer: Favorável

Centro Universitário Claretiano


© Relacionamento entre Objetos 163
Informações sobre o Professor:
Nome: Paulo
Titulação: Mestrado
Email: paulo@email.com
Informações sobre Curso:
Nome: Computação
Sigla: COMP
Area: exatas
Curso tem coordenador e seu nome é Carlos
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
Situação: Aprovado
Nota: 9.0
Este Tcc é de Jose

Nas mensagens exibidas pela execução do método main da classe Executa foram destaca-
das, em negrito, aquelas que envolvem diretamente as modificações realizadas sobre as classes
Tcc e Aluno. Note que agora as impressões realizadas sobre o objeto do tipo Tcc também exibem
se existe aluno vinculado. Veja, no detalhe, que a primeira chamada ao método "exibeInforma-
coes()" do objeto "trabalho" não trouxe aluno vinculado, enquanto, na segunda chamada ao
método "exibeInformacoes()", é exibida uma mensagem com o nome do aluno agregado.

Agregação: Banca e Professor


De forma similar à implementação anterior, a relação de agregação entre Banca e Profes-
sor será implementada adicionando atributo(s) à classe Banca. Diferentemente das agregações
realizadas anteriormente, a classe Banca agrega dois objetos (Professor), e não apenas um ob-
jeto como nos casos anteriores. A forma como essa agregação será codificada depende apenas
da decisão do programador. Basicamente, a solução para essa situação é criar um ou dois atri-
butos que serão declarados, respectivamente, como uma variável composta homogênea (vetor)
ou duas variáveis simples do tipo Professor. Estas servirão para o mesmo intuito: armazenar as
referências aos dois objetos agregados do tipo Professor.
Nessa codificação, realizaremos a solução da agregação usando uma variável composta
(vetor). Como a modificação realizada na classe Banca envolve a adição de um novo atributo,
então precisaremos adicionar, também, um método para permitir que os objetos agregados do
tipo professor sejam vinculados à classe Banca. Note que o diagrama de classes da Figura 48
exibe um método chamado "vincularProfessor", que servirá exatamente para esse propósito.

Modificar a classe Banca


As mudanças descritas encontram-se disponíveis no código a seguir e estão ressaltadas
em negrito. Você deverá modificar o código-fonte da classe Banca.
código 22
/**
* Classe Banca.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Banca
{
// variáveis da instância que representam as características da Banca
private String data;
private String parecer;
// Novo atributo (vetor) inserido devido a agregação entre Banca e Professor
private Professor[] professores = new Professor[2];
164 © Programação Orientada a Objetos

/**
* Método Construtor responsável por criar objetos do tipo Banca
*/
public Banca(String data, String parecer)
{
// atribui valores para as variáveis da instância (objeto)
this.data = data;
this.parecer = parecer;
}

/**
* Método que exibe informações sobre a Banca
*/
public void exibeInformacoes( )
{
System.out.println(“Informações sobre a Banca:”);
System.out.println(“Data: “+data);
System.out.println(“Parecer: “+parecer);
// Exibe quem são os Professores vinculados a Banca
if (professores[0] == null) System.out.println(“Não existem Professores vinculados
à Banca”);
else System.out.println(“Os Professores vinculados são: “ + professores[0].
getNome() + “ e “ + professores[1].getNome() );
}

/**
* Método que vincula Professor a Banca
*/
public void vincularProfessor(Professor p1, Professor p2)
{
// vincula Professores nas posicoes do vetor
professores[0] = p1;
professores[1] = p2;
}
}

fim código 22

O código da classe Banca foi modificado para possibilitar o registro dos dois professores.
Essa modificação ocasionou a inclusão de um novo atributo (vetor) chamado "professores", que
armazenará dois objetos do tipo professor. Em razão dessa mudança, uma melhoria foi feita no
método "exibeInformacoes()" da classe Banca. Agora este método exibirá o nome dos professo-
res vinculados à banca, caso eles possuam. Se não possuírem, o método exibirá uma mensagem
informando que não existem professores atribuídos.
Por conta dessa pequena melhoria, o método "exibeInformacoes()" precisará recuperar o
nome do professor, que é um atributo definido na classe Professor. Nela os atributos estão todos
definidos como de acesso restrito à classe, porém existe o método acessor de acesso público
chamado "getNome()”, que foi criado anteriormente na codificação da agregação entre Tcc e
Aluno. Em razão disso, não precisaremos modificar a classe Professor, apenas realizaremos a
invocação ao método "getNome()". Note que esse método acessor preserva o encapsulamento
da classe Professor.

Modificar a classe Executa


Para testarmos se a agregação entre Banca e Professor está funcionando corretamente,
vamos adicionar na classe Executa algumas chamadas de métodos. Essas chamadas consistem
basicamente da invocação do método “vincularProfessor”, repassando como parâmetros dois
objetos do tipo Professor, e da invocação do método "exibeInformacoes()", antes e depois das
vinculações do objeto professor ao objeto banca. Modifique o código da classe Executa, adicio-
nando, no código, o trecho a seguir em negrito.

Centro Universitário Claretiano


© Relacionamento entre Objetos 165

Lembre-se de que os comentários existentes nos códigos não precisam ser adicionados à
sua codificação, pois não influenciam na compilação e na execução das classes. Os comentários
servem apenas para repassar mais informações sobre as modificações realizadas.
código 23
class Executa
{ // classe de teste do projeto tcc
public static void main(String args[]) // método que inicia o teste
{
Aluno jose; // variável jose é do tipo Aluno
Curso computacao; // variável computacao é do tipo Curso
Coordenador carlos; // variável carlos é do tipo Coordenador
Tcc trabalho; // variável trabalho é do tipo Tcc
Banca banca; // variável banca é do tipo Banca
Professor paulo; // variável paulo é do tipo Professor

try {
// cria objeto usando o método construtor e
// associa o objeto criado a variável do tipo correspondente
jose = new Aluno(“Jose”,”111111”);
jose.exibeInformacoes(); // invoca um método sobre o objeto

computacao = new Curso(“Computação”,”COMP”,”exatas”);


computacao.exibeInformacoes(); // invoca um método sobre o objeto

carlos = new Coordenador(“Carlos”,”Doutorado”,”carlos@email.com”,”123”,”40”);


carlos.exibeInformacoes(); // invoca um método sobre o objeto

trabalho = new Tcc(“Orientação a Objetos”, 2010, “Aprovado”, 9);


trabalho.exibeInformacoes(); // invoca um método sobre o objeto

banca = new Banca(“01/06/2010”,”Favorável”);


banca.exibeInformacoes(); // invoca um método sobre o objeto

paulo = new Professor(“Paulo”,”Mestrado”,”paulo@email.com”);


paulo.exibeInformacoes(); // invoca um método sobre o objeto

// Vincula um coordenador ao curso (Agregação)


computacao.trocarCoordenador( carlos );
computacao.exibeInformacoes(); // invoca um método sobre o objeto

// Vincula um aluno ao tcc (Agregação)


trabalho.vincularAluno( jose );
trabalho.exibeInformacoes(); // invoca um método sobre o objeto

// Vincula dois professores à Banca (Agregação)


banca.vincularProfessor( paulo, carlos );
banca.exibeInformacoes();

} catch(Exception e) {
// inserir aqui o tratamento das exceções
// exibe a mensagem correspondente à exceção ocorrida
System.out.println( e.getMessage() );
} finally {
// inserir aqui as últimas instruções a serem executadas após o bloco try
// finaliza os objetos para liberar espaço de memória para outras alocações
jose = null; // finaliza objeto do tipo Aluno
computacao = null; // finaliza objeto do tipo Curso
carlos = null; // finaliza objeto do tipo Coordenador
trabalho = null; // finaliza objeto do tipo Tcc
banca = null; // finaliza objeto do tipo Banca
paulo = null; // finaliza objeto do tipo Professor
}
}
}

fim código 23

Uma vez realizada a última modificação necessária, compile todas as classes. Caso o pro-
cesso de compilação resulte em erros, verifique novamente os códigos digitados, comparando-
-os com os códigos exibidos nesta obra.
166 © Programação Orientada a Objetos

Executar o método main da classe Executa


Após a compilação das classes, o ambiente de trabalho no BlueJ terá uma aparência seme-
lhante à exibida na Figura 52. Modifique a posição das classes para visualizar a seta indicativa de
relação de agregação entre as classes Tcc e Aluno.
Vamos agora realizar a execução do método main da classe Executa. Nessa execução, não
é necessária a passagem de parâmetros. Clique no botão "Ok” e visualize, a seguir, as mensa-
gens retornadas pelos objetos criados na declaração do método main da classe Executa.

Figura 52 Área de trabalho do BlueJ após criar a agregação entre as classes Banca e Professor.

Veja a seguir a saída do Código 23.

Informações sobre Aluno:


Nome: Jose
Ra: 111111
Informações sobre Curso:
Nome: Computação
Sigla: COMP
Area: exatas
Curso não tem coordenador
Informações sobre o Professor:
Nome: Carlos

Centro Universitário Claretiano


© Relacionamento entre Objetos 167
Titulação: Doutorado
Email: carlos@email.com
Informações sobre Coordenador:
Ramal: 123
Carga Horária: 40
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
Situação: Aprovado
Nota: 9.0
Tcc não tem aluno vinculado
Informações sobre a Banca:
Data: 01/06/2010
Parecer: Favorável
Não existem Professores vinculados à Banca
Informações sobre o Professor:
Nome: Paulo
Titulação: Mestrado
Email: paulo@email.com
Informações sobre Curso:
Nome: Computação
Sigla: COMP
Area: exatas
Curso tem coordenador e seu nome é Carlos
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
Situação: Aprovado
Nota: 9.0
Este Tcc é de Jose
Informações sobre a Banca:
Data: 01/06/2010
Parecer: Favorável
Os Professores vinculados são: Paulo e Carlos

Nas mensagens exibidas pela execução do método main da classe Executa foram destaca-
das, em negrito, aquelas que envolvem diretamente as modificações realizadas sobre as classes
Banca e Professor. Note que agora as impressões realizadas sobre o objeto do tipo Banca tam-
bém exibem se existem professores vinculados. Veja, no detalhe, que a primeira chamada ao
método "exibeInformacoes()" do objeto "banca" não trouxe professores vinculados, enquanto,
na segunda chamada ao método "exibeInformacoes()", é exibida uma mensagem com os nomes
dos professores agregados.

Agregação: Tcc e Banca


A relação de agregação entre Tcc e Banca será implementada adicionando um novo atri-
buto à classe Tcc. Esse novo atributo será declarado como uma variável do tipo Banca e servirá
para armazenar a referência ao objeto agregado.
Como a modificação realizada na classe Tcc envolve a adição de um novo atributo, então
precisaremos adicionar, também, um método para permitir que o objeto agregado banca seja
vinculado à classe Tcc. Note que o diagrama de classes da Figura 48 exibe um método chamado
"vincularBanca", que servirá exatamente para esse propósito.

Modificar a classe Tcc


As mudanças indicadas encontram-se disponíveis no código a seguir e estão ressaltadas
em negrito. Você deverá modificar o código-fonte da classe Tcc.
168 © Programação Orientada a Objetos

código 24
/**
* Classe Tcc.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Tcc
{
// variáveis da instância que representam as características do Tcc
private String titulo;
private int ano;
private String situacao;
private float nota;
// Novo atributo inserido devido a agregação entre Tcc e Aluno
private Aluno aluno;
// Novo atributo inserido devido a agregação entre Tcc e Banca
private Banca banca;

/**
* Método Construtor responsável por criar objetos do tipo Tcc
*/
public Tcc(String titulo, int ano, String situacao, float nota)
{
// atribui valores para as variáveis da instância (objeto)
this.titulo = titulo;
this.ano = ano;
this.situacao = situacao;
this.nota = nota;
}

/**
* Método que exibe informações sobre o Tcc
*/
public void exibeInformacoes( )
{
System.out.println(“Informações sobre Tcc:”);
System.out.println(“Título: “+titulo);
System.out.println(“Ano: “+ano);
System.out.println(“Situação: “+situacao);
System.out.println(“Nota: “+nota);
// Exibe quem é o Aluno responsavel pelo Tcc
if (aluno == null) System.out.println(“Tcc não tem aluno vinculado”);
else System.out.println(“Este Tcc é de “ + aluno.getNome());
// Exibe quem é o Aluno responsavel pelo Tcc
if (banca == null) System.out.println(“Tcc não possui banca vinculada”);
else {
Professor[] profs = banca.getProfessores();
if (profs[0] == null) System.out.println(“Tcc possui banca porém sem
professores vinculados”);
else System.out.println(“Os Professores da Banca são: “ + profs[0].getNome() +
“ e “ + profs[1].getNome() );
}
}

/**
* Método que vincula o Aluno ao Tcc
*/
public void vincularAluno(Aluno a)
{
aluno = a;
}

/**
* Método que vincula a Banca ao Tcc
*/
public void vincularBanca(Banca b)
{
banca = b;
}
}

fim código 24

Centro Universitário Claretiano


© Relacionamento entre Objetos 169

Modificar a classe Banca


O código da classe Tcc foi modificado para possibilitar o registro da banca. Essa modifica-
ção ocasionou a inclusão de um novo atributo chamado "banca" que armazenará um objeto do
tipo banca. Por conta dessa mudança, uma melhoria foi feita no método "exibeInformacoes()"
da classe Tcc. Agora este método exibirá se o tcc possui ou não uma banca vinculada, e, caso
possua, os nomes dos professores que fazem parte da banca do tcc. Caso o tcc possua uma ban-
ca e ela não possua professores vinculados, o método exibirá uma mensagem informando que
não existem professores atribuídos na banca.
Em razão dessa pequena melhoria, o método "exibeInformacoes()" precisará recuperar os
nomes dos professores. Os professores estão representados em um atributo definido na classe
Banca. Nela os atributos estão todos definidos como private, isto é, de acesso restrito à classe.
Desse modo, nenhum acesso externo será permitido ao atributo professores (vetor). E, assim,
precisaremos realizar uma modificação na classe Banca.
Não vamos expor os atributos da classe Banca às classes externas usando o modificador
de acesso public, pois assim estaríamos comprometendo o encapsulamento da classe. A melhor
e mais indicada solução para esse caso é criar um novo método para acessar o atributo profes-
sores. Conforme já estudamos, esse método de acesso é conhecido como método acessor.
Acompanhe, no código disponível a seguir, as modificações que estão ressaltadas em ne-
grito e que deverão ser realizadas na classe Banca.
código 25
/**
* Classe Banca.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Banca
{
// variáveis da instância que representam as características da Banca
private String data;
private String parecer;
// Novo atributo (vetor) inserido devido a agregação entre Banca e Professor
private Professor[] professores = new Professor[2];

/**
* Método Construtor responsável por criar objetos do tipo Banca
*/
public Banca(String data, String parecer)
{
// atribui valores para as variáveis da instância (objeto)
this.data = data;
this.parecer = parecer;
}

/**
* Método que exibe informações sobre a Banca
*/
public void exibeInformacoes( )
{
System.out.println(“Informações sobre a Banca:”);
System.out.println(“Data: “+data);
System.out.println(“Parecer: “+parecer);
// Exibe quem são os Professores vinculados a Banca
if (professores[0] == null) System.out.println(“Não existem Professores vinculados
à Banca”);
else System.out.println(“Os Professores vinculados são: “ + professores[0].
getNome() + “ e “ + professores[1].getNome() );
}

/**
170 © Programação Orientada a Objetos

* Método que vincula Professor a Banca


*/
public void vincularProfessor(Professor p1, Professor p2)
{
// vincula Professores nas posicoes do vetor
professores[0] = p1;
professores[1] = p2;
}

/**
* Método acessor do atributo Professor
*/
public Professor[] getProfessores()
{
return professores;
}
}

fim código 25

Modificar a classe Executa


Para testarmos se a agregação entre Tcc e Banca está funcionando corretamente, vamos
adicionar na classe Executa algumas chamadas de métodos. Essas chamadas consistem, basica-
mente, da invocação do método "vincularBanca", repassando como parâmetro um objeto do
tipo Banca, e da invocação do método "exibeInformacoes()" em três momentos:
• antes de vincular uma banca ao tcc;
• depois de vincular uma banca ao tcc, porém, com a banca sem professores vincula-
dos;
• depois de vincular uma banca ao tcc, porém, com a banca com professores vincula-
dos.
Modifique o código da classe Executa, adicionando, no código, o trecho a seguir em ne-
grito.
Lembre-se de que os comentários existentes nos códigos não precisam ser adicionados à
sua codificação, pois não influenciam na compilação e na execução das classes. Os comentários
servem apenas para repassar mais informações sobre as modificações realizadas.
código 26
class Executa
{ // classe de teste do projeto tcc
public static void main(String args[]) // método que inicia o teste
{
Aluno jose; // variável jose é do tipo Aluno
Curso computacao; // variável computacao é do tipo Curso
Coordenador carlos; // variável carlos é do tipo Coordenador
Tcc trabalho; // variável trabalho é do tipo Tcc
Banca banca; // variável banca é do tipo Banca
Professor paulo; // variável paulo é do tipo Professor

try {
// cria objeto usando o método construtor e
// associa o objeto criado a variável do tipo correspondente
jose = new Aluno(“Jose”,”111111”);
jose.exibeInformacoes(); // invoca um método sobre o objeto

computacao = new Curso(“Computação”,”COMP”,”exatas”);


computacao.exibeInformacoes(); // invoca um método sobre o objeto

carlos = new Coordenador(“Carlos”,”Doutorado”,”carlos@email.com”,”123”,”40”);


carlos.exibeInformacoes(); // invoca um método sobre o objeto

Centro Universitário Claretiano


© Relacionamento entre Objetos 171
trabalho = new Tcc(“Orientação a Objetos”, 2010, “Aprovado”, 9);
trabalho.exibeInformacoes(); // invoca um método sobre o objeto

banca = new Banca(“01/06/2010”,”Favorável”);


banca.exibeInformacoes(); // invoca um método sobre o objeto

// Vincula uma banca ao tcc (Agregação)


trabalho.vincularBanca( banca );
trabalho.exibeInformacoes();

paulo = new Professor(“Paulo”,”Mestrado”,”paulo@email.com”);


paulo.exibeInformacoes(); // invoca um método sobre o objeto

// Vincula um coordenador ao curso (Agregação)


computacao.trocarCoordenador( carlos );
computacao.exibeInformacoes(); // invoca um método sobre o objeto

// Vincula um aluno ao tcc (Agregação)


trabalho.vincularAluno( jose );
trabalho.exibeInformacoes(); // invoca um método sobre o objeto

// Vincula dois professores à Banca (Agregação)


banca.vincularProfessor( paulo, carlos );
banca.exibeInformacoes();

// Exibe informações sobre o tcc


trabalho.exibeInformacoes();

} catch(Exception e) {
// inserir aqui o tratamento das exceções
// exibe a mensagem correspondente à exceção ocorrida
System.out.println( e.getMessage() );
} finally {
// inserir aqui as últimas instruções a serem executadas após o bloco try
// finaliza os objetos para liberar espaço de memória para outras alocações
jose = null; // finaliza objeto do tipo Aluno
computacao = null; // finaliza objeto do tipo Curso
carlos = null; // finaliza objeto do tipo Coordenador
trabalho = null; // finaliza objeto do tipo Tcc
banca = null; // finaliza objeto do tipo Banca
paulo = null; // finaliza objeto do tipo Professor
}
}
}

fim código 26

Uma vez realizada a última modificação necessária, compile todas as classes. Caso o pro-
cesso de compilação resulte em erros, verifique novamente os códigos digitados, comparando-
-os com os códigos descritos nesta obra.

Executar o método main da classe Executa


Após a compilação das classes, o ambiente de trabalho no BlueJ terá uma aparência seme-
lhante à exibida na Figura 53. Modifique a posição das classes para visualizar a seta indicativa de
relação de agregação entre as classes Tcc e Banca.
Vamos agora realizar a execução do método main da classe Executa. Nessa execução, não
é necessária a passagem de parâmetros. Clique no botão "Ok” e visualize, a seguir, as mensa-
gens retornadas pelos objetos criados na declaração do método main da classe Executa.
172 © Programação Orientada a Objetos

Figura 53 Área de trabalho do BlueJ após criar a agregação entre as classes Tcc e Banca.

Veja a seguir a saída do Código 26.

Informações sobre Aluno:


Nome: Jose
Ra: 111111
Informações sobre Curso:
Nome: Computação
Sigla: COMP
Area: exatas
Curso não tem coordenador
Informações sobre o Professor:
Nome: Carlos
Titulação: Doutorado
Email: carlos@email.com
Informações sobre Coordenador:
Ramal: 123
Carga Horária: 40
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
Situação: Aprovado
Nota: 9.0
Tcc não tem aluno vinculado
Tcc não possui banca vinculada
Informações sobre a Banca:

Centro Universitário Claretiano


© Relacionamento entre Objetos 173
Data: 01/06/2010
Parecer: Favorável
Não existem Professores vinculados à Banca
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
Situação: Aprovado
Nota: 9.0
Tcc não tem aluno vinculado
Tcc possui banca porém sem professores vinculados
Informações sobre o Professor:
Nome: Paulo
Titulação: Mestrado
Email: paulo@email.com
Informações sobre Curso:
Nome: Computação
Sigla: COMP
Area: exatas
Curso tem coordenador e seu nome é Carlos
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
Situação: Aprovado
Nota: 9.0
Este Tcc é de Jose
Tcc possui banca porém sem professores vinculados
Informações sobre a Banca:
Data: 01/06/2010
Parecer: Favorável
Os Professores vinculados são: Paulo e Carlos
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
Situação: Aprovado
Nota: 9.0
Este Tcc é de Jose
Os Professores da Banca são: Paulo e Carlos

Nas mensagens exibidas pela execução do método main da classe Executa, foram destaca-
das, em negrito, aquelas que envolvem diretamente as modificações realizadas sobre as classes
Tcc e Banca. Note que agora as impressões realizadas sobre o objeto do tipo Tcc também exibem
se existe banca vinculada a ele. Veja, no detalhe, que a primeira chamada ao método "exibeIn-
formacoes()" do objeto "trabalho" não trouxe banca vinculada, e, na segunda chamada ao mé-
todo "exibeInformacoes()", é exibida uma mensagem informando que existe banca, pórem sem
professores, enquanto, na terceira chamada ao método "exibeInformacoes()", é exibida uma
mensagem informando que existe banca com os nomes dos professores agregados.

Associação
Continuando com o desenvolvimento do sistema de controle de orientações e defesas de
Tcc, vamos agora focar nas relações do tipo associação. O diagrama de classes do projeto (Figura
48) exibe duas relações de associação que ocorrem entre as respectivas classes: Aluno e Curso
e Tcc e Banca.
Como visto nesta unidade, a implementação da associação entre classes é realizada por
meio da adição de novos atributos e métodos nas classes associadas. O diagrama de classes da
Figura 48 indica apenas que existe a relação entre as classes, porém a forma pela qual a asso-
ciação será codificada depende apenas da decisão do programador. No caso da codificação da
associação, existem muitas variações possíveis para realizar a programação. Entre as possíveis
soluções estão:
• Criação de um novo atributo em uma das classes associadas, bem como a criação de
um novo método na classe que recebeu o novo atributo para associar os objetos vin-
culados.
174 © Programação Orientada a Objetos

• Criação de novos atributos nas duas classes associadas, bem como a criação de novos
métodos em uma ou nas duas classes, de modo que permita a associação dos objetos
vinculados.
• Criação de uma nova classe contendo dois atributos, sendo cada um deles do tipo das
classes associadas, bem como um método que permitirá associar os objetos vincula-
dos.
As formas descritas são apenas algumas variações possíveis de como poderíamos imple-
mentar as associações do novo sistema. Algumas podem ser mais fáceis e rápidas de se im-
plementar, enquanto outras são um pouco mais trabalhosas. Cabe ao programador escolher a
forma que mais se ajusta às classes associadas.
Apesar das variações possíveis, todas as soluções se baseiam em criar novos atributos que
armazenarão referências aos objetos associados. Acompanhe, a seguir, a implementação das
associações existentes no projeto.

Associação: Aluno e Curso (matrícula)


A associação entre as classes Aluno e Curso é estabelecida pela relação de matrícula que
ocorre entre as classes. Nessa relação, um aluno pode se matricular em apenas um curso, porém
em um curso existem vários alunos matriculados. Esse tipo de análise entre aluno e curso nos
remete à análise realizada em banco de dados, quando no modelo conceitual se identifica os
tipos de relacionamentos (um para um, um para vários e vários para vários).
Não devemos confundir os conceitos, pois, em nossa implementação, todos os objetos
são armazenados em memória e não existe armazenamento persistente como o que ocorre com
as bases de dados. O intuito em fazermos um paralelo com a análise feita em banco de dados é
que, ao analisarmos a quantidade de objetos relacionados na associação, poderemos escolher a
solução mais adequada no que se refere à codificação das classes.
Uma solução adequada para a associação entre Aluno e Curso é criarmos um novo atributo
em cada uma das classes. Na classe Aluno, devemos adicionar um novo atributo do tipo da clas-
se Curso, que armazenará uma referência ao objeto curso no qual o aluno está matriculado.
Já na classe Curso, deveremos adicionar um novo atributo que permita armazenar várias
referências para objetos do tipo aluno que estão matriculados no curso. Uma forma simples,
porém trabalhosa, de se realizar o armazenamento de vários objetos é utilizar um ArrayList. O
ArrayList é uma classe da biblioteca "util” da linguagem Java que permite o gerenciamento de
uma lista de objetos de tamanho dinâmico, possibilitando inserções e remoções. Essa solução
de tamanho dinâmico é melhor que a solução estática baseada em vetores.
Além dos novos atributos adicionados, devemos, também, criar um método para geren-
ciar o vínculo entre as classes associadas. Conforme o diagrama de classes do sistema (Figura
48), o método "fazMatricula" foi proposto na classe Aluno e será responsável por estabelecer,
nos novos atributos das classe Aluno e Curso, as referências aos objetos vinculados.

Modificar a classe Curso


As mudanças descritas encontram-se disponíveis no código a seguir e estão ressaltadas em
negrito. Para prosseguir com o projeto, você deverá modificar o código-fonte da classe Curso.
Centro Universitário Claretiano
© Relacionamento entre Objetos 175

código 27
/**
* Classe Curso.
*
* @author (your name)
* @version (a version number or a date)
*/
import java.util.ArrayList; // importação da classe ArrayList da biblioteca util do Java
public class Curso
{
// variáveis da instância que representam as características do Curso
private String nome;
private String sigla;
private String area;
// Novo atributo inserido devido a agregação entre Curso e Coordenador
private Coordenador coord;
// Novo atributo inserido devido a associação entre Aluno e Curso
private ArrayList alunos = new ArrayList();

/**
* Método Construtor responsável por criar objetos do tipo Curso
*/
public Curso(String nome, String sigla, String area)
{
// atribui valores para as variáveis da instância (objeto)
this.nome = nome;
this.sigla = sigla;
this.area = area;
}

/**
* Método que exibe informações sobre o Curso
*/
public void exibeInformacoes()
{
System.out.println(“Informações sobre Curso:”);
System.out.println(“Nome: “+nome);
System.out.println(“Sigla: “+sigla);
System.out.println(„Area: „+area);
// Exibe informacoes sobre o Coordenador do Curso
if (coord == null) System.out.println(“Curso não tem coordenador”);
else System.out.println(“Curso tem coordenador e seu nome é “ + coord.getNome());
// Exibe a quantidade de alunos matriculados
System.out.println(“Quantidade de Alunos matriculados: “ + alunos.size());
}

/**
* Método que troca o Coordenador de Curso
*/
public void trocarCoordenador(Coordenador c)
{
coord = c;
}

/**
* Método que matricula Aluno no Curso adicionando um objeto do tipo Aluno no atributo
aluno
*/
public void matricAluno(Aluno a)
{
if (a != null) alunos.add(a); // adiciona se objeto não for null
}

/**
* Método acessor do atributo nome do Curso
*/
public String getNome()
{
return nome;
}

/**
* Método que lista os Alunos matriculados no Curso
*/
176 © Programação Orientada a Objetos

public void listarAlunosMatriculados()


{
// verifica se existem alunos matriculados
if (alunos.size() == 0) System.out.println(“Não existem alunos matriculados no
curso”);
else {
System.out.println(“Lista de alunos matriculados no curso “ + nome);
// percorre toda a lista de alunos matriculados
for(int aux = 0; aux < alunos.size(); aux++)
{
// pega o proximo objeto da lista de alunos para imprimir seu nome
Aluno aluno = (Aluno)alunos.get(aux);
System.out.println(“ - “ + aluno.getNome());
}
}
}
}

fim código 27

As modificações realizadas na classe Curso estão comentadas. Leia com atenção para me-
lhor compreender o novo código.
O código da classe Curso foi modificado para possibilitar o registro de vários alunos ma-
triculados. Essa modificação ocasionou a inclusão de um novo atributo chamado "alunos", que
armazenará objetos do tipo aluno. Para permitir o uso e o acesso a esse novo atributo, também
foram adicionados alguns novos métodos:
• “public void matricAluno(Aluno a)" : método auxiliar que será chamado pela classe
Aluno de dentro do método "fazMatricula" e servirá para incluir objetos alunos no Ar-
rayList alunos da classe Curso.
• “public String getNome()" : método acessor que será chamado pela classe Aluno de
dentro do método "exibeInformacoes" para exibir o nome do curso no qual o aluno
está matriculado.
• “public void listarAlunosMatriculados()" : método adicional que imprimirá o nome dos
alunos que estão matriculados no Curso. Esse método percorre o ArrayList alunos ob-
tendo de cada objeto aluno armazenado o seu respctivo nome.

Modificar a classe Aluno


Acompanhe, no código disponível a seguir, as modificações que estão ressaltadas em ne-
grito que deverão ser realizadas na classe Aluno.
código 28
/**
* Classe Aluno.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Aluno
{
// variáveis da instância que representam as características do Aluno
private String nome;
private String ra;
// Novo atributo inserido devido a associação entre Aluno e Curso
private Curso curso;

/**
* Método Construtor responsável por criar objetos do tipo Aluno
*/
public Aluno(String nome, String ra)
{
// atribui valores para as variáveis da instância (objeto)

Centro Universitário Claretiano


© Relacionamento entre Objetos 177
this.nome = nome;
this.ra = ra;
}

/**
* Método que exibe informações sobre o Aluno
*/
public void exibeInformacoes( )
{
System.out.println(“Informações sobre Aluno:”);
System.out.println(“Nome: “+nome);
System.out.println(“Ra: “+ra);
// Exibe o nome do curso onde aluno está matriculado
if (curso == null) System.out.println(“Aluno não está matriculado em Curso”);
else System.out.println(“Aluno está matriculado no curso “ + curso.getNome());
}

/**
* Método acessor do atributo nome
*/
public String getNome() {
return nome;
}

/**
* Método que matricula Aluno em Curso
*/
public void fazMatricula(Curso c) {
// adiciona referência do objeto do tipo Curso ao atributo curso
curso = c;
// invoca método auxiliar na classe Curso para adicionar aluno na lista de
matriculados do curso
// this referencia o objeto atual do tipo aluno onde se está executando o método
fazMatricula
c.matricAluno( this );
}
}

fim código 28

Modificar a classe Executa


Para testarmos se a associação entre Aluno e Curso está funcionando corretamente, va-
mos adicionar na classe Executa algumas chamadas de métodos. Essas chamadas consistem,
basicamente, da invocação do método "fazMatricula", repassando como parâmetro um objeto
do tipo Curso, e da invocação do método "exibeInformacoes()", antes e depois da vinculação do
objeto aluno ao objeto curso. Outra chamada adicionada é a invocação do método "listarAlu-
nosMatriculados", que possibilita a impressão dos nomes dos alunos matriculados em um cur-
so. Modifique o código da classe Executa adicionando no código o trecho a seguir em negrito.
Lembre-se de que os comentários existentes nos códigos não precisam ser adicionados à
sua codificação, pois não influenciam na compilação e na execução das classes. Os comentários
servem apenas para repassar mais informações sobre as modificações realizadas.
código 29
class Executa
{ // classe de teste do projeto tcc
public static void main(String args[]) // método que inicia o teste
{
Aluno jose; // variável jose é do tipo Aluno
Curso computacao; // variável computacao é do tipo Curso
Coordenador carlos; // variável carlos é do tipo Coordenador
Tcc trabalho; // variável trabalho é do tipo Tcc
Banca banca; // variável banca é do tipo Banca
Professor paulo; // variável paulo é do tipo Professor

try {
// cria objeto usando o método construtor e
178 © Programação Orientada a Objetos

// associa o objeto criado a variável do tipo correspondente


jose = new Aluno(“Jose”,”111111”);
jose.exibeInformacoes(); // invoca um método sobre o objeto

computacao = new Curso(“Computação”,”COMP”,”exatas”);


computacao.exibeInformacoes(); // invoca um método sobre o objeto

carlos = new Coordenador(“Carlos”,”Doutorado”,”carlos@email.com”,”123”,”40”);


carlos.exibeInformacoes(); // invoca um método sobre o objeto

trabalho = new Tcc(“Orientação a Objetos”, 2010, “Aprovado”, 9);


trabalho.exibeInformacoes(); // invoca um método sobre o objeto

banca = new Banca(“01/06/2010”,”Favorável”);


banca.exibeInformacoes(); // invoca um método sobre o objeto

// Vincula uma banca ao tcc (Agregação)


trabalho.vincularBanca( banca );
trabalho.exibeInformacoes();

paulo = new Professor(“Paulo”,”Mestrado”,”paulo@email.com”);


paulo.exibeInformacoes(); // invoca um método sobre o objeto

// Vincula um coordenador ao curso (Agregação)


computacao.trocarCoordenador( carlos );
computacao.exibeInformacoes(); // invoca um método sobre o objeto

// Vincula um aluno ao tcc (Agregação)


trabalho.vincularAluno( jose );
trabalho.exibeInformacoes(); // invoca um método sobre o objeto

// Vincula dois professores à Banca (Agregação)


banca.vincularProfessor( paulo, carlos );
banca.exibeInformacoes();

// Exibe informações sobre o tcc


trabalho.exibeInformacoes();

// Matricula aluno jose no curso computacao


jose.fazMatricula( computacao );
jose.exibeInformacoes(); // invoca um método sobre o objeto

// lista nomes de alunos matriculados no curso computacao


computacao.listarAlunosMatriculados();

} catch(Exception e) {
// inserir aqui o tratamento das exceções
// exibe a mensagem correspondente à exceção ocorrida
System.out.println( e.getMessage() );
} finally {
// inserir aqui as últimas instruções a serem executadas após o bloco try
// finaliza os objetos para liberar espaço de memória para outras alocações
jose = null; // finaliza objeto do tipo Aluno
computacao = null; // finaliza objeto do tipo Curso
carlos = null; // finaliza objeto do tipo Coordenador
trabalho = null; // finaliza objeto do tipo Tcc
banca = null; // finaliza objeto do tipo Banca
paulo = null; // finaliza objeto do tipo Professor
}
}
}

fim código 29

Uma vez realizada a última modificação necessária, compile todas as classes. Caso o pro-
cesso de compilação resulte em erros, verifique novamente os códigos digitados, comparando-
-os com os códigos apresentados nesta obra.

Centro Universitário Claretiano


© Relacionamento entre Objetos 179

Executar o método main da classe Executa


Após a compilação das classes, o ambiente de trabalho no BlueJ terá uma aparência seme-
lhante à exibida na Figura 54. Modifique a posição das classes para visualizar a seta indicativa de
relação de agregação entre as classes Aluno e Curso.
Vamos agora realizar a execução do método main da classe Executa. Nessa execução, não
é necessária a passagem de parâmetros. Clique no botão "Ok” e visualize, a seguir, as mensa-
gens retornadas pelos objetos criados na declaração do método main da classe Executa.

Figura 54 Área de trabalho do BlueJ após criar a associação entre as classes Aluno e Curso.

Veja a seguir a saída do código 29.

Informações sobre Aluno:


Nome: Jose
Ra: 111111
Aluno não está matriculado em CursoInformações sobre Curso:
Nome: Computação
Sigla: COMP
Area: exatas
Curso não tem coordenador
Quantidade de Alunos matriculados: 0
Informações sobre o Professor:
Nome: Carlos
180 © Programação Orientada a Objetos

Titulação: Doutorado
Email: carlos@email.com
Informações sobre Coordenador:
Ramal: 123
Carga Horária: 40
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
Situação: Aprovado
Nota: 9.0
Tcc não tem aluno vinculado
Tcc não possui banca vinculada
Informações sobre a Banca:
Data: 01/06/2010
Parecer: Favorável
Não existem Professores vinculados à Banca
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
Situação: Aprovado
Nota: 9.0
Tcc não tem aluno vinculado
Tcc possui banca porém sem professores vinculados
Informações sobre o Professor:
Nome: Paulo
Titulação: Mestrado
Email: paulo@email.com
Informações sobre Curso:
Nome: Computação
Sigla: COMP
Area: exatas
Curso tem coordenador e seu nome é Carlos
Quantidade de Alunos matriculados: 0
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
Situação: Aprovado
Nota: 9.0
Este Tcc é de Jose
Tcc possui banca porém sem professores vinculados
Informações sobre a Banca:
Data: 01/06/2010
Parecer: Favorável
Os Professores vinculados são: Paulo e Carlos
Informações sobre Tcc:
Título: Orientação a Objetos
Ano: 2010
Situação: Aprovado
Nota: 9.0
Este Tcc é de Jose
Os Professores da Banca são: Paulo e Carlos
Informações sobre Aluno:
Nome: Jose
Ra: 111111
Aluno está matriculado no curso Computação
Informações sobre Curso:
Nome: Computação
Sigla: COMP
Area: exatas
Curso tem coordenador e seu nome é Carlos
Quantidade de Alunos matriculados: 1
Lista de alunos matriculados no curso Computação
- Jose

Nas mensagens exibidas pela execução do método main da classe Executa foram destaca-
das, em negrito, aquelas que envolvem diretamente as modificações realizadas sobre as classes
Aluno e Curso. Note que agora as impressões realizadas sobre o objeto do tipo Aluno exibem
informações sobre sua matrícula em Curso. Já as impressões realizadas sobre o objeto do tipo
Curso exibem a quantidade de alunos matriculados, enquanto as impressões realizadas pelo
método "listarAlunosMatriculados" exibem os nomes dos alunos matriculados em um curso.

Centro Universitário Claretiano


© Relacionamento entre Objetos 181

Você deve ter notado que a associação é talvez a relação que gera maior quantidade de
codificação se comparada com as relações de Herança e agregação. Um dos motivos para justifi-
car tal aumento de código, e consequentemente maior dificuldade de programação, é o fato de
que objetos relacionados devem ser registrados nas duas classes, o que exige modificações nos
códigos dos dois lados da relação da associação.
Além dos métodos descritos no diagrama de classes do projeto, você perceberá que mui-
tas vezes faz-se necessário criar outros métodos que auxiliarão nas implementações desejadas.
Quando um programador recebe um diagrama de classes como referência para sua programa-
ção, ele deve respeitar e seguir as indicações do diagrama, porém possui certa liberdade para
criar a solução usando sua criatividade e experiência.
Ressaltamos que a implementação proposta soluciona de maneira simplificada e parcial a
relação de associação entre as classes Aluno e Curso, pois faltam métodos que permitam, por
exemplo, realizar o cancelamento da matrícula de um aluno em um curso. O método "listarAlu-
nosMatriculados" é um exemplo de um método não descrito no diagrama de classes da Figura 48,
porém foi codificado para permitir melhor visualização nos testes realizados na classe Executa.
Parabéns! Você finalizou a implementação do projeto do sistema de controle de orienta-
ções e defesa de Tcc. Esperamos que tenha obtido êxito na realização deste pequeno sistema.

10. QUESTÕES AUTOAVALIATIVAS


Confira, a seguir, as questões propostas para verificar o seu desempenho no estudo desta
unidade:
1) Qual a importância do uso de pacotes (package) para um projeto definido em linguagem Java?

2) Em um sistema orientado a objetos, os objetos interagem entre si por meio da invocação de seus métodos.
Imagine que a estrutura de uma classe foi modificada (atributos e métodos). Qual seria o reflexo dessa alteração
em um sistema?

3) Com base na questão autoavaliativa 3 da Unidade 2, escreva o código Java das classes envolvidas na relação de
Herança.

4) Com base na questão autoavaliativa 3 da Unidade 2, escreva o código Java das classes envolvidas na relação de
agregação.

5) Com base na questão autoavaliativa 3 da Unidade 2, escreva o código Java das classes envolvidas na relação de
associação.

6) Qual a utilidade das classes abstratas na codificação de um sistema orientado a objetos?

Gabarito
Confira, a seguir, as respostas corretas para as questões autoavaliativas propostas:
1) Um pacote (package) é uma estruturação que permite organizar as classes em pastas ou diretórios, que reúne,
em um mesmo local, as classes que possuam alguma relação sistêmica. Além disso, podem-se criar hierarquias
de pacotes dentro de um pacote, para permitir uma melhor organização das estruturas de classes.

2) Se a alteração realizada modificou a interface da classe, isto é, modificou o conjunto de atributos e métodos
acessíveis de uma classe, então essa alteração também deverá ser realizada sobre as demais classes que aces-
sam a interface modificada. Essa modificação é necessária para se evitar a ocorrência de erros no momento da
execução do sistema.
Caso as modificações sejam realizadas sobre atributos e métodos de acesso restrito à própria classe, então não
serão necessárias modificações nas demais classes, pois a propriedade do encapsulamento esconde os detalhes
internos da implementação da classe.
182 © Programação Orientada a Objetos

3) Nesta questão, você deverá codificar as classes existentes na questão autoavaliativa 3 da Unidade 2, que estão
envolvidas com a relação de Herança. Para simplificar a solução, vamos omitir alguns detalhes internos da clas-
se, para focar nos comandos mais relevantes que possibilitam estabelecer a relação de Herança entre classes.
Acompanhe, a seguir, a codificação das classes envolvidas.

código 1
public class Pessoa
{

private String nome, data_de_nascimento, telefone_residencial, telefone_celular,


endereco;

/**
* Construtor da classe Pessoa
*/
public Pessoa(String nome, String data_de_nascimento, String telefone_residencial,
String telefone_celular, String endereco)
{
this.nome = nome;
this.data_de_nascimento = data_de_nascimento;
this.telefone_residencial = telefone_residencial;
this.telefone_celular = telefone_celular;
this.endereco = endereco;
}

fim código 1

código 2
public class Responsavel extends Pessoa
{

private String cpf, parentesco;

/**
* Construtor da classe Responsavel
*/
public Responsavel(String cpf, String parentesco, String nome, String data_de_
nascimento, String telefone_residencial, String telefone_celular, String endereco)
{
super(nome, data_de_nascimento, telefone_residencial, telefone_celular, endereco);
this.cpf = cpf;
this.parentesco = parentesco;
}

fim código 2

código 3
public class Professor extends Pessoa
{

private String codigo_funcionario, formacao;

/**
* Construtor da classe Professor
*/
public Professor(String codigo_funcionario, String formacao, String nome, String data_
de_nascimento, String telefone_residencial, String telefone_celular, String endereco)
{
super(nome, data_de_nascimento, telefone_residencial, telefone_celular, endereco);
this.codigo_funcionario = codigo_funcionario;
this.formacao = formacao;
}

fim código 3

Centro Universitário Claretiano


© Relacionamento entre Objetos 183

4) Nesta questão, você deverá codificar as classes existentes na questão autoavaliativa 3 da Unidade 2, que estão
envolvidas com a relação de agregação. Para simplificar a solução, vamos omitir alguns detalhes internos da
classe, para focar nos comandos mais relevantes que possibilitam estabelecer a relação de agregação entre
classes. Acompanhe, a seguir, a codificação das classes envolvidas.

código 5
public class Aluno
{
private String nome, codigo, data_de_nascimento, pai, mae;
private Responsavel resp;

/**
* Construtor da classe Aluno
*/
public Aluno(String nome, String codigo, String data_de_nascimento, String pai, String
mae, Responsavel resp)
{
this.nome = nome;
this.codigo = codigo;
this.data_de_nascimento = data_de_nascimento;
this.pai = pai;
this.mae = mae;
this.resp = resp;
}

fim código 5

código 6
public class Turma
{
private String codigo, nome, ano, sala;
private Professor prof_responsavel;
/**
* Construtor da classe Turma
*/
public Turma(String codigo, String nome, String ano, String sala, Professor prof_
responsavel)
{
this.codigo = codigo;
this.nome = nome;
this.ano = ano;
this.sala = sala;
this.prof_responsavel = prof_responsavel;
}
}

fim código 6

código 7
public class Atividade
{
private String nome, descricao;
private float valor;
private Professor prof_responsavel;
/**
* Construtor da classe Atividade
*/
public Atividade(String nome, String descricao, float valor, Professor prof_
responsavel)
{
this.nome = nome;
this.descricao = descricao;
this.valor = valor;
this.prof_responsavel = prof_responsavel;
}
}

fim código 7
184 © Programação Orientada a Objetos

5) Nesta questão, você deverá codificar as classes existentes na questão autoavaliativa 3 da Unidade 2, que estão
envolvidas com a relação de associação. Para simplificar a solução, vamos omitir alguns detalhes internos da
classe, para focar nos comandos mais relevantes que possibilitam estabelecer a relação de associação entre
classes. Acompanhe, a seguir, a codificação das classes envolvidas.

código 6
import java.util.ArrayList;
public class Turma
{
private String codigo, nome, ano, sala;
private Professor prof_responsavel;
private ArrayList alunos = new ArrayList();

/**
* Construtor da classe Turma
*/
public Turma(String codigo, String nome, String ano, String sala, Professor prof_
responsavel)
{
this.codigo = codigo;
this.nome = nome;
this.ano = ano;
this.sala = sala;
this.prof_responsavel = prof_responsavel;
}

/**
* Matricula Aluno na Turma
*/
public void matriculaAlunoTurma(Aluno a)
{
if (a != null) alunos.add(a);
}
}

fim código 6

código 7
import java.util.ArrayList;
public class Atividade
{
private String nome, descricao;
private float valor;
private Professor prof_responsavel;
private ArrayList alunos = new ArrayList();

/**
* Construtor da classe Atividade
*/
public Atividade(String nome, String descricao, float valor, Professor prof_
responsavel)
{
this.nome = nome;
this.descricao = descricao;
this.valor = valor;
this.prof_responsavel = prof_responsavel;
}

/**
* Matricula Aluno na Atividade
*/
public void matriculaAlunoAtividade(Aluno a)
{
if (a != null) alunos.add(a);
}
}

fim código 7

6) A importância das classes abstratas no desenvolvimento orientado a objetos é permitir a definição de tipos de
dados (classes) que são reutilizados por outras classes por meio da Herança. Por regra, uma classe abstrata não
permite a instanciação de objetos, porém sua estrutura (atributos e métodos) pode ser totalmente reaproveitada.

Centro Universitário Claretiano


© Relacionamento entre Objetos 185

11. CONSIDERAÇÕES
Nesta unidade, você teve a oportunidade de aprofundar seus conhecimentos sobre a
programação orientada a objetos por meio da linguagem Java. Você acompanhou a criação de
classes e a instanciação de objetos, praticou a implementação dos relacionamentos entre clas-
ses (Herança, agregação e associação) e observou os reflexos desses relacionamentos sobre os
objetos. Além disso, interpretou os diagramas de classe com a visão de um programador, se
preocupando em como codificar os conceitos representados.
Neste estudo, você teve a oportunidade de aprender que a orientação a objetos é um
importante paradigma que pode ser utilizado em vários aspectos da computação, tais como
modelagem de sistemas e programação. Você pôde, também, observar que a linguagem Java
oferece pleno suporte aos conceitos estudados e que, por meio dela, podemos criar sistemas
com base em especificações utilizando diagramas de classes.
Espero que, ao final deste estudo, você tenha alcançado os objetivos propostos e esteja
apto para o desenvolvimento da programação orientada a objetos.
Parabéns pelo esforço!

12. E-REFERÊNCIAS

Sites pesquisados
BLUEJ. The Interactive Java Environment. Disponível em:<http://www.bluej.org>. Acesso em: 09 dez. 2010.
SUN DEVELOPERS NETWORK (SDN). Sun Microsystems. Disponível em:<http://java.sun.com>. Acesso em: 09 dez. 2010.

13. REFERÊNCIAS BIBLIOGRÁFICAS


CADENHEAD, R.; LEMAY, L. Aprenda em 21 dias Java 2. Tradução de Daniel Vieira. 4. ed. Rio de Janeiro: Elsevier, 2005.
DEITEL, H. M.; DEITEL, P. J. Java: como programar. Tradução de Edson Furmankiewicz. 6. ed. São Paulo: Pearson Prentice Hall,
2007.
BOOCH, G.; RUMBAUGH, J.; JACOBSON, I. UML: guia do usuário. Tradução de Fábio Freitas da Silva et al. 2 ed. rev. atual. Rio de
Janeiro: Elsevier, 2005.
186 © Programação Orientada a Objetos

APÊNDICE 1
DOWNLOAD E INSTALAÇÃO DO KIT DE DESENVOLVIMENTO JAVA (JDK)

1. DOWNLOAD DO KIT DE DESENVOLVIMENTO JAVA (JDK)


Inicialmente será necessário obter o JDK compatível com o sistema operacional da sua
máquina de desenvolvimento. No endereço <http://java.sun.com/javase/downloads/index.
jsp>, você conseguirá fazer o download da plataforma Java (Java Development Kit) correspon-
dente à versão 6 (versão recomendada atualmente).
Vale ressaltar que a versão do JDK é atualizada com frequência. Assim, quando você aces-
sar futuramente, talvez encontre uma nova versão que será a recomendada para download. As
versões do JDK passam por atualizações e melhorias. A versão atual do Java é a 6 e a sua atua-
lização é a 20.
Para fazer o download da versão 6, observe os passos a seguir. Veja a tela inicial do down-
load na Figura 1:

Figura 1 Sítio do JDK – tela do Java SE Downloads.

Centro Universitário Claretiano


© Apêndice 1 187

ATENÇÃO!
As Figuras de 1 a 4 estão disponíveis em: <http://java.sun.com>. Acesso em: 4 jul. 2010.

Para iniciar o processo de download, primeiro clique no botão “Download JDK” da opção
"JDK 6 Update 20” (primeiro botão vermelho ou link JDK apontados pelas setas de cor azul sobre
a Figura 1) e aguarde o carregamento da próxima tela (observe a Figura 2).

Figura 2 Sítio do JDK – tela de download do JDK 6 Update 20.

Nesta etapa do processo de download, você deverá escolher a versão de plataforma com-
patível com a versão do sistema operacional de sua máquina de desenvolvimento. Exemplifica-
remos o download do JDK selecionando a versão compatível com o sistema operacional Windo-
ws. Caso o seu sistema operacional não seja este, escolha uma versão de plataforma compatível
com a de sua máquina de desenvolvimento.
Após selecionar a plataforma de seu sistema operacional, clique no botão vermelho “Do-
wnload” (seta de cor azul) e aguarde o carregamento de uma pequena janela de login (opcional)
sobre a atual tela (Figura 3).
188 © Programação Orientada a Objetos

Figura 3 Sítio do JDK – tela de login (opcional).

Esta etapa de login é uma fase opcional do processo de download do JDK. Caso deseje
receber futuramente mensagens sobre atualizações de versão, artigos técnicos e descontos em
treinamentos, faça sua inscrição seguindo as orientações no próprio site. Caso não queira se
registrar, clique sobre a opção "Skip this Step” (seta azul), localizada na parte inferior da janela
(Figura 3). Após alguns instantes, uma nova janela será exibida (Figura 4).

Figura 4 Sítio do JDK – tela de download do Java SE Development Kit 6 u20.

Centro Universitário Claretiano


© Apêndice 1 189

Nesta última etapa, clique no link jdk-6u20-windows-i586.exe (seta azul) para iniciar o
download do JDK. Neste momento, será exibida uma nova janela, conforme mostrado na Figura
5, em que recomendamos a escolha da opção "Salvar" (botão Salvar), indicando um diretório de
sua preferência para armazenar o arquivo e, posteriormente, proceder à instalação.

Figura 5 Sítio do JDK – tela de download de arquivo.

2. INSTALAÇÃO DO KIT DE DESENVOLVIMENTO JAVA (JDK)


Para facilitar ainda mais a instalação do kit de desenvolvimento Java, apresentaremos, a
seguir, uma sequência de telas referentes a todo o processo de instalação do JDK. Esse procedi-
mento de instalação somente poderá ser executado após o download do JDK. Mais informações
sobre o processo de download, consulte o Passo 1 do Apêndice 1.
Após finalizar o download do JDK, conforme descrito nas informações do Passo 1 da Uni-
dade 2, localize o diretório em que o arquivo foi salvo e execute o programa para iniciar o pro-
cesso de instalação.

Figura 6 Instalação do JDK – tela inicial.


190 © Programação Orientada a Objetos

Depois de executar o arquivo, aguarde o início do processo de instalação. A janela anterior,


conforme demonstra a Figura 6, permanece por alguns instantes e, posteriormente, é exibida a
tela de confirmação de licença de uso (veja a Figura 7).

Figura 7 Instalação do JDK – confirmação de licença de uso do JDK.

Nesta etapa, correspondente à Figura 7, clique no botão "Accept>” (seta azul) para aceitar
a licença de uso do software e prossiga com a instalação. O JDK é de uso gratuito e não será exi-
gida qualquer licença para sua utilização.

Figura 8 Instalação do JDK – configuração da instalação.

Centro Universitário Claretiano


© Apêndice 1 191

Observe a Figura 8 e verifique que você pode modificar o diretório de instalação. Para isso,
clique no botão "Change” (seta azul) e informe um novo diretório. Recomendamos a você que
mantenha a configuração indicada e clique no botão "Next” (abaixo da seta azul) para prosseguir
com a instalação.

Figura 9 Instalação do JDK – instalação em andamento do JDK.

Neste momento, conforme demonstrado na Figura 9, você deve aguardar o término da


instalação do JDK. Essa etapa pode demorar alguns minutos, dependendo da configuração de
seu computador. Ao término desse processo, será exibida a tela referente à instalação do JRE, ou
seja, o ambiente de execução Java, conforme você pode ver na Figura 10.

Figura 10 Instalação do JDK – instalação do ambiente de execução Java (JRE).


192 © Programação Orientada a Objetos

Nesta etapa do processo, você pode modificar, caso deseje, o diretório de instalação do
JRE (veja a Figura 10). Para isso, clique no botão "Change” (seta azul) e informe um novo diretó-
rio. Como sugestão, orientamos que mantenha a configuração indicada. Para prosseguir com a
instalação, clique no botão "Next” (localizado no canto inferior direito da janela) e acompanhe
por alguns minutos a tela de instalação do JRE, conforme mostra a Figura 11.

Figura 11 Instalação do JDK – instalação em andamento do JRE.

Ao término do processo de instalação do JRE, será exibida a mensagem de sucesso (veja a


Figura 12). Então, clique no botão "Finish” (seta azul) para concluir a instalação.

Figura 12 Instalação do JDK – término da instalação do Java.

Centro Universitário Claretiano


© Apêndice 1 193

Possivelmente, após o término do processo de instalação do JDK, uma janela do navegador


de internet será aberta e exibirá uma página de registro para o JDK. Reforçamos novamente que
o registro do JDK é opcional, assim, você pode desconsiderar também essa etapa, fechar a janela
e prosseguir com a utilização do ambiente de desenvolvimento Java em seu computador.
Para verificar se a instalação do JDK foi realizada corretamente, recomendamos a você que
abra uma janela de "Prompt de Comando” e digite o comando: “java – version” (Figura 13). Caso
a instalação esteja correta, uma mensagem exibindo a versão do Java será mostrada.

Figura 13 Java Version – verificação da instalação do JDK.

Parabéns! Você concluiu a instalação do kit de desenvolvimento Java. Lembre-se de que


você deverá realizar, também, a instalação da ferramenta BlueJ. Para obter mais detalhes sobre
a instalação da ferramenta BlueJ, siga as orientações do Apêndice 2.

INSTALAÇÃO DO JDK–––––––––––––––––––––––––––––––––––––––––––––––––––––––––
Na instalação do JDK em sistema operacional Linux, a compilação final resultará em um diretório local com o nome
da versão do Java. Para tornar o JDK acessível, você deverá movê-lo para o diretório/usr/local.
Durante a instalação do JDK, também serão apresentadas as telas de configuração do runtime do Java, que habili-
tarão seu browser para suportar os programas desenvolvidos em Java (applets).
–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
194 © Programação Orientada a Objetos

APÊNDICE 2
DOWNLOAD E INSTALAÇÃO DA FERRAMENTA BLUEJ

1. DOWNLOAD DA FERRAMENTA BLUEJ


Agora que você já finalizou a instalação do JDK, vamos realizar o download da ferramenta
interativa e visual BlueJ. O sítio oficial do BlueJ na web está disponível em: <www.bluej.org>.
Acesso em: 4 jul. 2010.
Ao acessar o site, localize, na lateral esquerda, o link de download, clique nele e seu aces-
so será direcionado para uma nova página. Verifique nela quais são os links disponíveis para
download da ferramenta, juntamente com a plataforma que está disponível e o tamanho do
arquivo.
a) Disponível em: <http://www.bluej.org/download/files/bluejsetup-300.exe>. Acesso
em: 4 jul. 2010. (plataforma Windows) (5.6Mb)
b) Disponível em: <http://www.bluej.org/download/files/BlueJ-300.zip>. Acesso em: 4
jul. 2010. (plataforma MacOS X) (5.2 Mb)
c) Disponível em: <http://www.bluej.org/download/files/bluej-300.deb>. Acesso em: 4
jul. 2010. (plataforma Debian, Ubuntu e outros sistemas baseados em Debian) (5.1
Mb)
d) Disponível em: <http://www.bluej.org/download/files/bluej-300.jar>. Acesso em: 4
jul. 2010. (outras plataformas) (5.3 Mb)
Note que foram apresentados links diferentes conforme a versão do sistema operacional.
Dessa forma, é fundamental que você escolha o link correspondente ao sistema operacional de
sua máquina de desenvolvimento.
Para exemplificar o download do BlueJ, escolhemos a versão compatível com o sistema
operacional Windows. Ao acessar o link de sua escolha em um navegador web, será exibida
uma nova janela, conforme exibido na Figura 1. Recomendamos que você escolha a opção
"Salvar", indicando um diretório de sua preferência para armazenar o arquivo, para, poste-
riormente, proceder à instalação.

Figura 1 Sítio do BlueJ - Download.

Centro Universitário Claretiano


© Apêndice 2 195

2. INSTALAÇÃO DA FERRAMENTA BLUEJ


Para facilitar a instalação da ferramenta BlueJ, apresentaremos a seguir a sequência com-
pleta das telas referentes a todo o processo de instalação. Esse procedimento somente poderá
ser executado após o download da ferramenta. Para obter mais informações sobre o processo
de download, consulte o Passo 3 da Unidade 2.
Após finalizar o download da ferramenta BlueJ, localize o diretório em que o arquivo foi
salvo e execute o programa para iniciar o processo de instalação.

Figura 2 Instalação do BlueJ – tela inicial.

Depois de executar o arquivo, será exibida a tela inicial do processo de instalação (veja a
Figura 2). Para prosseguir com a instalação, clique no botão "Next”.

Figura 3 Instalação do BlueJ – local de instalação.


196 © Programação Orientada a Objetos

A próxima etapa (Figura 3) refere-se ao local de instalação da ferramenta. Como sugestão,


o software de instalação indica a pasta destino: C:\Bluej. Realize a modificação se desejar. Orien-
tamos que adote as sugestões do instalador. Para prosseguir com a instalação, clique no botão
"Next”.

Figura 4 Instalação do BlueJ – nome do aplicativo no menu de programas do Windows.

Observe a Figura 4, cuja etapa se refere ao nome que o aplicativo BlueJ será identificado
no menu de programas do Windows. Como sugestão, o software de instalação indica o nome
BlueJ. Se desejar, realize a modificação do nome. Contudo, orientamos que adote as sugestões
do instalador. Para prosseguir com a instalação, clique no botão "Next”.

Figura 5 Instalação do BlueJ – criação de ícones na área de trabalho.

Centro Universitário Claretiano


© Apêndice 2 197

Esta etapa, conforme demonstra a Figura 5, permite confirmar a criação de um atalho para
o aplicativo BlueJ na área de trabalho de seu computador (Windows). Se desejar, selecione a
opção e clique no botão "Next" para prosseguir com a instalação.

Figura 6 Instalação do BlueJ – resumo das opções escolhidas na instalação.

Nessa etapa da instalação, como você pode verificar na Figura 6, o software de instalação
exibirá um resumo das opções escolhidas nas etapas anteriores. Caso deseje modificar alguma
etapa, clique no botão "Back” para retornar aos passos anteriores e realizar as devidas corre-
ções. Para prosseguir com a instalação, clique no botão "Install”.

Figura 7 Instalação do BlueJ – instalação em andamento.


198 © Programação Orientada a Objetos

Neste momento da instalação, como pode ser observado na Figura 7, o software de ins-
talação copiará os arquivos da ferramenta BlueJ para o seu computador e realizará as devidas
configurações no sistema operacional.
Ao término desta etapa, conforme demonstra a Figura 8, será exibida a janela de finaliza-
ção da instalação. Como sugestão para completar a instalação, recomendamos que desmarque
todas as opções e clique no botão "Finish" para finalizar o processo de instalação da ferramenta
BlueJ.

Figura 8 Instalação do BlueJ – instalação em andamento.

Parabéns! Você concluiu a instalação da ferramenta BlueJ. Agora retorne ao conteúdo da


Unidade 2, para aprender a utilizar esta ferramenta adequadamente.

3. E-REFERÊNCIA
Figura 1 Sítio do BlueJ. Disponível em:<http://www.bluej.org>. Acesso em: 4 jul. 2010.

Centro Universitário Claretiano

Você também pode gostar