Baixe o app para aproveitar ainda mais
Leia os materiais offline, sem usar a internet. Além de vários outros recursos!
My arquivo Livro_texto_OO
Compartilhar
Prévia do material em texto
Linguagem de
Programação Orientada a
Objetos
Linguagem de
Programação Orientada
a Objetos
Organizado por Universidade Luterana do Brasil
Universidade Luterana do Brasil – ULBRA
Canoas, RS
2015
Mauricio da Silva Escobar
Conselho Editorial EAD
Andréa de Azevedo Eick
Ângela da Rocha Rolla
Astomiro Romais
Claudiane Ramos Furtado
Dóris Gedrat
Honor de Almeida Neto
Maria Cleidia Klein Oliveira
Maria Lizete Schneider
Luiz Carlos Specht Filho
Vinicius Martins Flores
Obra organizada pela Universidade Luterana do Brasil.
Informamos que é de inteira responsabilidade dos autores
a emissão de conceitos.
Nenhuma parte desta publicação poderá ser reproduzida
por qualquer meio ou forma sem prévia autorização da
ULBRA.
A violação dos direitos autorais é crime estabelecido na Lei
nº 9.610/98 e punido pelo Artigo 184 do Código Penal.
ISBN: 978-85-68453-83-4
Dados técnicos do livro
Diagramação: Marcelo Ferreira
Revisão: Igor Campos Dutra
Dados Internacionais de Catalogação na Publicação – CIP
Setor de Processamento Técnico da Biblioteca Martinho Lutero – ULBRA/Canoas
E74l Escobar, Mauricio da Silva.
Linguagem de programação orientada a objetos / Mauricio da Silva Escobar ;
organizado por Universidade Luterana do Brasil. – Canoas: Ed. ULBRA, 2015.
150 p. : il.
1. Computação. 2. Linguagem de programação orientada a objetos. 3. Java.
I. Universidade Luterana do Brasil. II. Título.
CDU 681.3.438JAVA
Introdução à Orientação a Objetos e à Linguagem Java ................1
Elementos Fundamentais da Linguagem Java ..............................12
Fundamentos de Orientação a Objetos em Java ..........................28
Relacionamento Entre Objetos .....................................................44
Herança e Métodos Construtores .................................................60
Polimorfismo ...............................................................................76
Pacotes e Modificadores de Visibilidade .......................................90
Classes Abstratas e Interfaces ....................................................106
Utilizando Arrays e Coleções de Dados ......................................119
Tratamento de Exceções e Interfaces Gráficas com o Usuário .....134
Sumário
Introdução à
Orientação a Objetos
e à Linguagem Java1
1 Doutor em Ciência da Computação pela PUCRS. Professor na ULBRA Canoas/RS.
Capítulo 1
Mauricio da Silva Escobar1
2 Linguagem de Programação Orientada a Objetos
O Java é a base para praticamente todos os tipos de apli-
cações em rede e é o padrão global para o desenvolvimento e
distribuição de aplicações móveis e incorporadas, jogos, con-
teúdo baseado na Web e softwares corporativos. Com mais
de 9 milhões de desenvolvedores em todo o mundo, de forma
eficiente, o Java permite que você desenvolva, implante e use
aplicações e serviços estimulantes (Java, 2013).
De laptops a datacenters, consoles de games a supercom-
putadores científicos, telefones celulares à Internet, o Java está
em todos os lugares (Java, 2013):
 97% dos Desktops Corporativos executam o Java;
 89% dos Desktops (ou Computadores) nos EUA Execu-
tam Java;
 9 Milhões de Desenvolvedores de Java em Todo o
Mundo;
 A Escolha Nº 1 para os Desenvolvedores;
 Plataforma de Desenvolvimento Nº 1;
 3 Bilhões de Telefones Celulares Executam o Java;
 100% dos Blu-ray Disc Players Vêm Equipados com o
Java;
 5 bilhões de Placas Java em uso;
 125 milhões de aparelhos de TV executam o Java;
 5 dos 5 Principais Fabricantes de Equipamento Original
Utilizam o Java ME.
Capítulo 1 Introdução à Orientação a Objetose à Linguagem Java 3
Por que os Desenvolvedores de Software
Escolhem o Java (Java, 2013)
O Java foi testado, refinado, estendido e comprovado por
uma comunidade dedicada de desenvolvedores, arquitetos
e entusiastas do Java. Ele foi projetado para permitir o de-
senvolvimento de aplicações portáteis de alto desempenho
para a mais ampla variedade possível de plataformas de
computação.
Ao disponibilizar aplicações entre ambientes heterogêneos,
as empresas podem fornecer mais serviços e aumentar a pro-
dutividade, a comunicação e a colaboração do usuário final
— além de reduzir drasticamente o custo de propriedade das
aplicações da empresa e do consumidor.
O Java tornou-se inestimável para os desenvolvedores,
permitindo que eles:
 Gravem software em uma plataforma e o executem vir-
tualmente em qualquer outra plataforma;
 Criem programas que podem ser executados dentro em
um web browser e acessem web services disponíveis;
 Desenvolvam aplicações do servidor para fóruns on-line,
armazenamentos, pesquisas, processamento de forms
HTML e mais;
 Combinem aplicações ou serviços usando a linguagem
Java para criar aplicações ou serviços altamente perso-
nalizáveis;
4 Linguagem de Programação Orientada a Objetos
 Criem aplicações potentes e eficientes para telefones
celulares, processadores remotos, microcontrolado-
res, módulos sem fio, sensores, gateways, produtos
de consumo e praticamente qualquer outro dispositivo
eletrônico.
Principais Características do Java
Orientada a Objetos: o Java é uma linguagem que imple-
menta os principais conceitos de orientação a objetos ao mes-
mo tempo que preserva tipos primitivos de dados. Ela permite
a definição de herança, interfaces e relacionamentos avança-
dos entre objetos, favorecendo a reutilização de código.
Distribuída: fornece uma grande quantidade de classes para
a manipulação de objetos em redes ou na Internet, utilizando
os principais protocolos de rede tais como o TCP/IP e HTTP.
Segura: por possuir suporte à programação em rede e am-
bientes heterogêneos, o Java recebeu grande atenção na sua
implementação no que diz respeito às características de segu-
rança.
Portável: a linguagem Java foi desenvolvida de forma que
suas aplicações sejam portáveis, ou seja, que elas possam
executar em diferentes plataformas. Por exemplo, uma mesma
aplicação Java pode executar tanto em um ambiente Linux ou
Windows, sem que modificações precisem ser feitas no progra-
ma original. Isso é um grande ganho, pois você implementa
uma vez o aplicativo, evitando retrabalho.
Capítulo 1 Introdução à Orientação a Objetose à Linguagem Java 5
Principais Tecnologias do Java
JDK – Java Development Kit: consiste no conjunto de fer-
ramentas e APIs para o desenvolvimento de aplicações Java.
JVM – Java Virtual Machine: consiste na Máquina Virtual
Java. A máquina virtual Java é uma implementação nativa,
feita para cada plataforma de hardware/software. A função da
máquina virtual é executar as aplicações Java, abstraindo os
detalhes do sistema da plataforma, permitindo que as aplica-
ções sejam, dessa forma, multiplataforma.
JRE – Java Runtime Environment: o JRE é um subcon-
junto do JDK. Ele é destinado a usuários finais que desejam
apenas executar aplicações Java, e não desenvolvê-las. O JRE
inclui a JVM e o conjunto base de bibliotecas de código Java
necessários para a execução das aplicações.
JSE – Java Standard Edition: distribuição principal do
Java. Contêm todas as classes (API) que formam a base da
linguagem.
JME – Java Micro Edition: distribuição do Java para o
desenvolvimento de aplicações para dispositivos móveis e in-
tegrados, tais como celulares, set-top boxes, reprodutores de
discos Blu-ray, dispositivos de mídia digital, módulos M2M, im-
pressoras etc.
JEE – Java Enterprise Edition: distribuição do Java para
o desenvolvimento de aplicações normalmente corporativas,
distribuídas fisicamente.
6 Linguagem de Programação Orientada a Objetos
JSP – Java Server Pages: tecnologia para a criação de
páginas web dinâmicas, que permite combinar HTML com o
Java.
Principais Ferramentas de
Desenvolvimento
O Javapossui diversas ferramentas de desenvolvimento, al-
gumas também chamadas de IDEs (Integrated Development
Environment), devido a quantidade de recursos oferecidos
por elas.
As principais IDEs de mercado são o Eclipse2 e o NetBe-
ans3. Ambas se destacam pelos recursos oferecidos, pela gran-
de base de documentos, plug-ins, extensões, e pela comunida-
de que apoia essas ferramentas.
Se você já possui experiência em desenvolvimento de apli-
cações, pode se aventurar nessas ferramentas. Caso não seja
esse seu caso, sugerimos que utilize ferramentas mais simples,
que focam no aprendizado dos elementos base da linguagem
Java e da Orientação a Objetos, como no caso da ferramenta
BlueJ4, que foi criada com o propósito de ser uma ferramenta
intuitiva, de fácil utilização para estudantes de Java.
2 http://eclipse.org/
3 http://netbeans.org/
4 http://www.bluej.org/
Capítulo 1 Introdução à Orientação a Objetose à Linguagem Java 7
Configurando o Ambiente de
Desenvolvimento
O primeiro passo é fazer o download e instalação do Java
SDK, que pode ser obtido diretamente do site da Oracle, em:
http://www.oracle.com/technetwork/pt/java/javase/downloa-
ds/jdk7-downloads-1880260.html
Após instalar o JDK, faça o download instalação do BlueJ
em:
http://www.bluej.org/download/download.html
A tela inicial do BlueJ pode ser vista como a seguir:
8 Linguagem de Programação Orientada a Objetos
O primeiro passo é criar um novo projeto. Na área central,
ficarão todas as classes Java que você criará para seu projeto.
Por questões de organização, sugerimos que você crie um pro-
jeto por capítulo deste livro.
Após criar um novo projeto, o BlueJ habilitará a criação de
classes, como ilustrado no exemplo a seguir. Ao criar uma nova
classe (botão “New Class...”), ela ficará com traços na diago-
nal, indicando que ela possui alteração de código. Neste caso,
precisamos compilar a classe por meio do botão “Compile”.
De uma forma resumida, compilar significa verificar a correta
utilização da linguagem Java na programação das classes de
uma aplicação. Os erros mais comuns de programação acon-
tecem nessa etapa. Após compilar, caso não ocorram erros, o
programa está pronto para execução.
Para alterar o código-fonte da classe, você deve clicar duas
vezes sobre a mesma para que o BlueJ abra o editor de códi-
go, como ilustrado a seguir:
Capítulo 1 Introdução à Orientação a Objetose à Linguagem Java 9
O método main indica o ponto de início de uma aplicação
Java. Para executar o exemplo ilustrado anteriormente, você
deve compilar a classe, clicar com o botão direito sobre ela e
chamar o método main, como ilustrado na imagem a seguir:
10 Linguagem de Programação Orientada a Objetos
A saída da aplicação será mostrada no console do BlueJ,
como ilustrado a seguir:
Neste ponto, você já está com o ambiente configurado e
apto a prosseguir com os estudos em Java. Até o próximo ca-
pítulo.
ATIVIDADES
1. Cite duas características da Linguagem Java
2. Defina, com suas palavras, a importância da máqui-
na virtual Java.
3. Defina, com suas palavras, o que é portabilidade.
4. Em que situação é melhor utilizar o JEE?
5. Para que serve a linguagem JSP?
Capítulo 1 Introdução à Orientação a Objetose à Linguagem Java 11
GABARITO
1. Portável: uma mesma aplicação pode executar em diferen-
tes plataformas de software/hardware. Distribuída: a lin-
guagem dispõe de recursos para permitir que aplicações
em rede possam se comunicar.
2. A máquina virtual é implementada para cada plataforma.
Sua função é criar uma camada de abstração, executando
as aplicações Java.
3. É a possibilidade de uma mesma aplicação executar em
diferentes ambientes/plataformas sem que ela precise ser
reescrita com código nativo.
4. Quando a aplicação precisa de recursos avançados de
distribuição (física) ou grandes aplicações corporativas.
5. Para permitir a programação de páginas web dinâmicas.
O JSP permite incorporar código Java juntamente com as
tags HTML.
Elementos Fundamentais
da Linguagem Java
ÂÂ Este capítulo mostra como os conceitos básicos de pro-gramação, principalmente os aprendidos nas discipli-
nas de algoritmos, são implementados em Java. Tais con-
ceitos envolvem a utilização e declaração de variáveis,
controle de repetição (loops), comandos condicionais,
dentre outros. O código será desenvolvido utilizando a
ferramenta BlueJ1, apresentada no capítulo 1.
1 O BlueJ é uma ferramenta para o aprendizado de Java, disponível gratuitamente
em http://www.bluej.org
Mauricio da Silva Escobar
Capítulo 2
Capítulo 2 Elementos Fundamentais da Linguagem Java 13
O exemplo a seguir representa um programa simples em
Java, que mostra uma mensagem no console.
1
2
3
4
5
6
public class Exemplo1
{
public static void main(String [] args){
System.out.println(“Olá Java”);
}
}
É importante prestar atenção aos diversos detalhes que
compõem uma classe em Java. Primeiramente, o Java é case-
-sensitive, isto é, ele diferencia letras maiúsculas de minúsculas.
A palavra public é chamada de modificar de visibilidade, e
será tradada adiante no livro. A palavra reservada class in-
dica que, naquele momento, estamos declarando uma classe.
A próxima palavra (também chamada de identificador) indica
o nome da classe.
Ao declarar uma classe, você deve respeitar algumas regras
de formação, como, por exemplo, não iniciar com números,
não possuir espaços em branco. É recomendável, como boa
prática, que o nome de uma classe sempre inicie com letra
maiúscula, podendo alternar quando seu nome for composto.
Exemplos de nomes de classes válidos:
 Pessoa
 PessoaFisica
 Pessoa_Juridica
14 Linguagem de Programação Orientada a Objetos
Um nome inválido será facilmente detectado como um erro
de compilação. A classe inicia de fato com as chaves { }. As
chaves indicam uma parte ou bloco de código. No caso da
classe, as chaves delimitam o corpo da classe, e nele você
pode declarar seus atributos e métodos.
Na classe de exemplo, temos somente um método chama-
do main. Note que o método main possui uma assinatura
padrão no Java, dessa forma, o Java saberá que esse método
é o primeiro que deve ser chamado ao executar a aplicação.
Uma aplicação pode ter diversos métodos main, ficando a
critério do desenvolvedor indicar qual deve ser executado ao
iniciar a aplicação.
Dentro do método main, é chamado o método prin-
tln (System.out.println), que mostrará no console
de aplicação o valor textual passado por parâmetro, e finaliza
com quebra de linha.
Após compilar a classe, clique com o botão direito e sele-
cione o método main. O resultado deve ser exibido no conso-
le, como ilustrado na figura a seguir.
Em geral, a maioria das classes Java serão armazenadas
em um arquivo próprio, de extensão .java. O Java permite
que classes sejam aninhadas, porém, uma classe pública deve
possuir seu próprio arquivo .java.
Capítulo 2 Elementos Fundamentais da Linguagem Java 15
Tipos de dados
O Java é uma linguagem fortemente tipada. Assim, toda va-
riável deve ser declarada indicando seu tipo de dado. O Java
possui duas categorias de tipos de dados: primitivos e objetos.
São oito tipos básicos (primitivos). Os tipos primitivos servem
para armazenar valores e são sempre passados por cópia. Os
objetos são estruturas compostas, definidos a partir do nome
de alguma classe definida no seu programa ou pelas classes
existentes do Java. Ao longo do livro, será dada mais atenção
aos tipos objetos. Note que existem muitos detalhes tratando-
-se de tipos de dados em Java, que você aprenderá ao longo
do curso e em estudos complementares.
Os tipos primitivos em Java são:
 int: inteiro de 32 bits
 short: inteiro de 16 bits
 long: inteiro de 64 bits
 byte: inteiro de 8 bits
 float: número fracionário (ponto flutuante) de 32 bits
 double: número fracionário (ponto flutuante) de 64 bits
 char: caractere
 boolean: valor true ou false
Declarando variáveisNo Java, toda variável possui obrigatoriamente um tipo de dado
e um nome. O nome da variável é um identificador e segue a
16 Linguagem de Programação Orientada a Objetos
mesma regra de formação do nome da classe. Diferente da
classe, aconselha-se que o nome da variável inicie por minús-
cula, podendo alternar caso seu nome seja composto, como
por exemplo: dataNascimento, dataCriacao, item_compra etc.
O tipo de dado pode ser um tipo primitivo ou objeto. No
caso do tipo objeto, você deve usar como tipo alguma classe
do seu programa ou uma classe do Java. Em programas mais
avançados, podemos ainda utilizar bibliotecas de código de
terceiros e, nesse caso, novas classes também podem ser utili-
zadas como tipos de dados.
Exemplos de declarações:
 int nroPortas;
 float valorVenda;
 boolean vendido;
 Pessoa p1;
 Carro c1;
Note que toda variável termina com ponto-e-vírgula. O
ponto-e-vírgula no Java é utilizado para finalizar uma instru-
ção. É importante salientar que você não pode utilizar as pa-
lavras reservadas do Java como nome de variáveis.
Você pode agrupar a declaração de variáveis de mesmo
tipo, separando-as entre vírgulas.
Exemplos de declarações:
 int a, b, c;
Capítulo 2 Elementos Fundamentais da Linguagem Java 17
 float x, y, z;
 Pessoa p1, p2, p3;
Principais operadores
Operadores aritméticos:
 Soma:
o int a = 10;
o int b = 20;
Âint res = a + b;
Âa + = 10; // mesmo que a = a + 10
o int r = 10 + 20;
 Subtração (operador “-“), multiplicação (operador “*”)
e divisão operador “/”): mesma forma de utilização da
soma.
 Resto da divisão: operador %
o int x = 10 % 2;
O Java dispõe de operadores de incremento e decremento.
Essas operações incrementam ou decrementam uma variável
em uma unidade. Esses operadores podem ser utilizados de
duas formas, chamados de pré-incremento ou pré-decremento
ou pós-incremento e pós-decremento. Na pós, primeiro atribui
o valor e depois realiza a operação, na pré, primeiro faz-se o
incremento/decremento e depois atribui-se o valor.
Exemplo de pós-incremento:
18 Linguagem de Programação Orientada a Objetos
o Inicializa x com o valor 10. Após copiar o valor de x (10)
para a variável r, x passará a ter o valor 11.
Âint x = 10;
Âint r = x++;
Exemplo de pré-decremento:
o Inicializa x com o valor 10. Primeiro é decrementado o
valor de x. Após, é copiado o valor atual de x para r, isto
é, o valor 9.
Âint x = 10;
Âint r = --x;
Operadores Relacionais:
 Maior que: operando1 > operando2
 Menor que: operando1 < operando2
 Igual: operando1 == operando2
 Maior ou igual: operando1 >= operando2
 Menor ou igual: operando1 <= operando2
 Diferente: operando1 != operando2
Operadores Condicionais:
Os operadores condicionais servem para a construção de ex-
pressões booleanas a serem utilizadas como testes condicio-
Capítulo 2 Elementos Fundamentais da Linguagem Java 19
nais nas estruturas que envolvem decisão, como, por exemplo,
nas estruturas “se”, “para” e “enquanto”.
 Operador “e” lógico (AND) – é verdadeiro quando to-
das as expressões testadas resultam em verdadeiro
o Operando1 && Operando2
 Operador “ou” lógico (OR) – é verdadeiro quando pelo
menos uma das expressões testadas resulta em verda-
deiro
o Operando1 || Operando2
 Negação (NOT) – inverte um valor lógico
o ! Operando1
Principais construções da linguagem
Estruturas de decisão:
if-else
Sintaxe:
if ( expressão booleana ) {
// código executado caso a expressão seja verdadeira
}
else {
// código executado caso o teste condicional falhe
}
20 Linguagem de Programação Orientada a Objetos
Exemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
public class ExemploIfElse
{
public static void main(String [] args) {
int idade = 20;
if(idade >= 18) {
System.out.println(“Já pode tirar a CNH.”);
}
else {
System.out.println(“Ainda não :(“);
}
}
}
if-else-if
Exemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ExemploIfElseIf
{
public static void main(String [] args) {
int idade = 17;
if(idade < 16) {
System.out.println(“Ainda não pode votar.”);
}
else if (idade < 18) {
System.out.println(“Voto facultativo.”);
}
else {
System.out.println(“Voto obrigatório.”);
}
}
}
Capítulo 2 Elementos Fundamentais da Linguagem Java 21
switch-case
No bloco switch, vai a variável a ser utilizada, e, em cada
bloco case, vai um valor a ser testado. O break é utilizado
para finalizar a instrução switch-case. Você pode especificar
uma condição especial que será chamada caso nenhum bloco
case seja executado, por meio do bloco default.
Exemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class ExemploSwitchCase
{
public static void main(String [] args){
int mes = 10;
switch( mes ){
case 1:
System.out.println(“Janeiro”);
break;
case 2:
System.out.println(“Fevereiro”);
break;
// demais meses
default:
System.out.println(“Mês desconhecido.”);
break;
}
}
}
for (para)
Sintaxe:
for( valor inicial; expressão booleana; incremento ) {
// código a ser executado pelo for
}
22 Linguagem de Programação Orientada a Objetos
Exemplo:
1
2
3
4
5
6
7
8
9
public class ExemploFor
{
public static void main(String [] args) {
for(int i=0; i<10; i++){
System.out.println(“Posição atual: “ + i);
}
}
}
while (enquanto)
Sintaxe:
while( expressão booleana ) {
// código a ser executado pelo while
}
ou
do {
// código a ser executado pelo while
} while( expressão booleana );
Exemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
public class ExemploWhile
{
public static void main(String [] args) {
int i=0;
while( i < 10 ){
System.out.println(“Posição atual: “ + i);
i++;
}
}
}
Capítulo 2 Elementos Fundamentais da Linguagem Java 23
Por fim, você pode utilizar a instrução break para finalizar
(sair) uma estrutura condicional ou de repetição ou o operador
continue para, em uma estrutura de repetição, avançar para
a próxima iteração.
ATIVIDADES
1. Considerando o código a seguir:
1
2
3
4
5
6
7
8
9
10
11
public class Atividade1
{
public static void main(String [] args){
int x = 50;
int a = x++;
int b = x++;
int c = --x;
}
}
Qual o valor das variáveis a, b, c e x ao final da execução do
método main?
2. Considerando o código a seguir:
1
2
3
4
5
6
7
public class Atividade2
{
public static void main(String [] args){
boolean a = true;
boolean b = true;
if( a || b ) {
24 Linguagem de Programação Orientada a Objetos
8
9
10
11
12
13
14
15
16
17
18
19
20
System.out.println(“Entrei 1”);
}
if( a && b ) {
System.out.println(“Entrei 2”);
}
a = !b;
if( a && b ) {
System.out.println(“Entrei 3”);
}
}
}
O que será exibido na tela ao final da execução do método
main?
3. Considerando o código a seguir:
1
2
3
4
5
6
7
8
9
public class Atividade3
{
public static void main(String [] args){
for(int i=0; i<3; i++) {
System.out.println(“Posição “ + i);
break;
}
}
}
O que será exibido na tela ao final da execução do método
main?
4. Considerando o código a seguir:
Capítulo 2 Elementos Fundamentais da Linguagem Java 25
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Atividade4
{
public static void main(String [] args){
int idade = 17;
switch(idade){
case 16:
System.out.println(“Facultativo”);
case 17:
System.out.println(“Facultativo”);
case 18:
System.out.println(“Obrigatório”);
}
}
}
O que será exibido na tela ao final da execução do método
main?
5. Considerando o código a seguir:
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Atividade5
{
public static void main(String [] args){
int a = 0;
while(true){
a++;
if(a == 4)
break;
if(a % 2 == 0){System.out.println(“par”);
26 Linguagem de Programação Orientada a Objetos
14
15
}
else {
System.out.println(“ímpar”);
}
}
}
}
O que será exibido na tela ao final da execução do método
main?
GABARITO
1.
a = 50
b = 51
c = 51
x = 51
2.
Entrei 1
Entrei 2
3.
Posição 0
4.
Facultativo
Obrigatório
Capítulo 2 Elementos Fundamentais da Linguagem Java 27
A falta do comando break pode fazer com que outros
blocos case sejam executados.
5.
ímpar
par
ímpar
Fundamentos de
Orientação a Objetos
em Java
ÂÂ Este capítulo apresenta os conceitos fundamentais de orientação a objetos e como estes conceitos são imple-
mentados na linguagem Java.
Mauricio da Silva Escobar
Capítulo 3
Capítulo 3 Fundamentos de Orientação a Objetos em Java 29
Em orientação a objetos, temos dois elementos fundamentais:
classes e objetos. Uma classe é utilizada para representar um
conjunto de características e comportamentos que são
comuns a um conjunto de objetos. A classe pode ser vista
como um modelo, que é utilizado para a criação de diversos
objetos.
Por exemplo, imagine uma pessoa. Em geral, as pessoas
possuem características em comum tais como: cor, sexo, reli-
gião, idade, nome, entre outras. Como comportamentos co-
muns, podemos citar: falar, caminhar, correr etc.
As características são mapeadas como atributos em
uma classe. Já os comportamentos são mapeados como mé-
todos (também chamados de operações).
Os objetos são instâncias de uma classe, isto é, são in-
divíduos de um tipo (de uma classe) em um sistema. Dessa
forma, um programa orientado a objetos pode ser visto como
um conjunto de objetos capaz de interagir.
Todos os objetos de uma mesma classe compartilham as
mesmas características (conjunto de atributos), porém cada
objeto possui valores diferentes para essas características. Esse
conceito chama-se estado. Todo objeto possui um estado,
que é o valor de todos os seus atributos em um determinado
momento em um programa. O objeto, dessa forma, pode al-
terar seu estado a partir da execução de seus métodos.
Considere o exemplo a seguir:
A classe Pessoa é responsável pela definição de objetos
(instâncias) do tipo Pessoa.
30 Linguagem de Programação Orientada a Objetos
 João é um objeto do tipo Pessoa.
 Maria é outro objeto do tipo Pessoa.
 João e Maria possuem o mesmo conjunto de atribu-
tos (sexo, nome, idade etc.), porém cada um possui seus
próprios valores.
 João possui 22 anos, enquanto Maria possui 30. João é
do sexo masculino, Maria, feminino.
 João e Maria possuem comportamentos semelhantes,
porém eles o realizam de maneira diferente.
o Ambos caminham, mas João caminha mais rá-
pido que Maria.
o Ambos falam, mas João fala mais de uma lín-
gua.
Definindo classes em java
Em Java, cada classe (com exceção das classes internas e ani-
nhadas) é definida em arquivo próprio, de extensão “.java”,
nesse caso, a classe Pessoa mencionada no exemplo anterior
seria definida em um arquivo chamado Pessoa.java.
O código a seguir ilustra a estrutura geral da classe Pessoa.
1
2
3
4
public class Pessoa
{
// corpo da classe
}
Capítulo 3 Fundamentos de Orientação a Objetos em Java 31
A primeira palavra indica a visibilidade da classe, que, nes-
se caso, é a palavra public. Um arquivo Java pode possuir
somente uma classe pública, cujo nome deve ser o mesmo do
seu arquivo. Os detalhes sobre os modificadores de visibili-
dade serão mostrados adiante no livro. Por enquanto, tenha
em mente que o modificador public indica que a classe em
questão pode ser acessada de qualquer parte do programa.
A palavra class indica que estamos declarando uma classe.
Seguido da palavra class, deve ser definido o nome da classe.
Como boa prática de programação orientada a objetos,
aconselha-se que o nome da classe inicie com letra maiúscula,
podendo, dessa forma, alternar entre maiúscula ou minúscula
caso o nome da classe seja composto, melhorando, assim, a
legibilidade do código-fonte. Além da escrita, o nome da clas-
se deve ser autoexplicativo, de fácil entendimento, sem espa-
ços em branco, acentuação etc. Alguns de nomes de classes:
Pessoa, PessoaFisica, Mensagem, CalculadoraCientifica.
Após o nome da classe, é definido o corpo da classe, de-
limitado pelas chaves { }. É no corpo da classe que podemos
definir seus atributos e métodos.
Estrutura de um atributo
Os atributos ou métodos podem ser definidos em qualquer
parte dentro do corpo da classe, não havendo, dessa forma,
uma ordem. É comum encontrar classes cujos atributos são
definidos a partir do início do seu corpo, e após, são definidos
todos os seus métodos.
32 Linguagem de Programação Orientada a Objetos
Todo atributo possui uma visibilidade (opcional), um tipo e
um nome. O tipo de atributo pode ser um dos tipos primitivos
ou uma classe disponível na aplicação ou de bibliotecas do
Java, como, por exemplo, a classe String, que é muito utilizada
para representar valores textuais (cadeias de caracteres).
Exemplos de atributos:
 int idade;
 Date dataNascimento;
 String nome;
 String email;
A utilização da visibilidade será omitida por enquanto.
Note que toda declaração de atributo deve ser finalizada com
ponto-e-vírgula, indicando o final da sentença. O capítulo an-
terior apresentou algumas regras para a declaração de variá-
veis que também servem para atributos.
Um atributo possui estrutura semelhante a uma variável.
Em orientação a objetos, é fácil diferenciar um atributo de uma
variável. Se a “variável” for declarada diretamente no corpo
da classe, então ela é um atributo. Se for declarada dentro
de um método, então é uma variável local (ao método). Esse
conceito chama-se escopo. Os atributos são visíveis ao longo
de toda a classe (todos os seus métodos), ao contrário da va-
riável, que é vista somente no método em que ela foi declara-
da. Dessa forma, outra diferença é que a variável não possui
modificador de visibilidade, pois ela só poderá ser usada no
método em que foi declarada.
Capítulo 3 Fundamentos de Orientação a Objetos em Java 33
Exemplo de definição de atributos em uma classe:
1
2
3
4
5
6
7
8
public class Pessoa
{
String nome;
String email, website;
int idade;
String telefone;
String nacionalidade = “Brasileiro”;
}
Assim como ocorre com as variáveis, os atributos também po-
dem ser inicializados no momento da sua declaração (linha 7).
Estrutura de um método
Os métodos são utilizados para definir as operações que os
objetos realizam, os comportamentos que são exercidos etc.
Uma televisão, por exemplo, ligar, desligar, avançar o ca-
nal, aumentar ou diminuir o volume etc. Os métodos também
pode representar operações utilitárias como, por exemplo, cal-
cular uma soma, calcular a idade de uma pessoa a partir de
sua data de nascimento, comparando com a data corrente,
mostrar uma mensagem na tela etc.
De forma geral, os métodos, além de representarem os
comportamentos comuns de objetos, servem para realizar al-
guma ação ou operação dinâmica dentro de uma aplicação,
visto que os atributos ou variáveis servem somente para arma-
zenar valores em memória.
34 Linguagem de Programação Orientada a Objetos
Os métodos podem ser definidos em qualquer parte do
corpo da classe. Por questão de organização do código, nor-
malmente os métodos são definidos após os atributos. Assim
como os atributos, os métodos também possuem uma visibili-
dade. Estrutura geral de um método:
 Visibilidade (opcional)
 Tipo de retorno
 Nome
 Parâmetros (zero ou mais)
 Corpo
O tipo de retorno pode ser void, indicando que o método
não precisa retornar um valor, um tipo primitivo ou um tipo Ob-
jeto. Nos dois últimos casos, o método deve obrigatoriamente
retornar um elemento compatível com o tipo de retorno especi-
ficado. Para retornar um valor, é utilizado o comando return.
Os parâmetros servem para a definição de valores que o
método pode receber ao ser chamado,delimitados pelos pa-
rênteses. Esses parâmetros poderão ser manipulados dentro
do corpo do método como variáveis locais. Um parâmetro
consiste basicamente em um tipo e em um nome. Para especi-
ficar mais de um parâmetro, basta separá-los por vírgula.
Por fim, o corpo do método (delimitado pelas chaves) serve para
especificarmos o conjunto de comandos que o método executa.
Caso o método deva retornar um valor, o comando return deverá
ser o último comando a ser executado dentro do corpo do método.
A figura a seguir ilustra a declaração de métodos em uma Classe:
Capítulo 3 Fundamentos de Orientação a Objetos em Java 35
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class TV
{
int canalAtual = 1;
void avancarCanal() {
canalAtual = canalAtual + 1;
}
void voltarCanal() {
canalAtual = canalAtual - 1;
}
void pularParaCanal(int canal) {
canalAtual = canal;
}
int getCanalAtual() {
return canalAtual;
}
}
O exemplo define uma classe TV (especificada em um ar-
quivo chamado TV.java) que possui um atributo chamado ca-
nalAtual e quatro métodos. O exemplo ilustra métodos com
e sem parâmetros, bem como um exemplo de retorno de valor.
O operador this
Agora que você já conhece a estrutura de um atributo, variá-
vel e método, é importante saber manipular corretamente tais
elementos dentro do corpo de um método.
36 Linguagem de Programação Orientada a Objetos
Considere o exemplo a seguir:
1
2
3
4
5
6
7
8
public class ExemploThis
{
String palavra;
void falar(String palavra) {
System.out.println(palavra);
}
}
Note que a classe possui um atributo chamado palavra,
e que o método falar recebe um parâmetro também chamado
palavra. O comando System.out.println na linha 6 serve para
mostrar um valor no console. Nesse caso, considerando a cha-
mada ao método falar, será exibido o valor do atributo ou o
do parâmetro?
O Java permite que você tenha variáveis locais ou pa-
râmetros com o mesmo nome de atributos. Para o progra-
mador, pode parecer confuso ou ambíguo, porém o Java
fornece uma palavra reservada para tornar explícito o ele-
mento que está sendo utilizado. A palavra this serve para
indicar (tornar explícito) que estamos acessando um elemento
da classe (atributo ou método). O this também é conhecido
como autorreferência da classe. Dessa forma, podemos ago-
ra diferenciar a chamada a um elemento local do método ou
a um elemento definido no corpo da classe, como ilustra o
código a seguir:
Capítulo 3 Fundamentos de Orientação a Objetos em Java 37
1
2
3
4
5
6
7
8
9
public class ExemploThis
{
String palavra;
void falar(String palavra) {
System.out.println(palavra);
System.out.println(this.palavra);
}
}
O código da linha 6 mostrará na tela o valor que está che-
gando por parâmetro palavra (linha 5) e o da linha 7 mostrará
o valor atual do atributo palavra.
O operador new
Ao longo do capítulo, você aprenderá mais formas de executar
uma aplicação e criar objetos. Vimos, neste capítulo, que po-
demos definir classes, que é uma estrutura capaz de representar
as características e comportamentos de um conjunto de objetos.
Após definir uma classe, você pode criar diversos objetos
em uma aplicação por meio do operador new. O new é co-
nhecido como o operador de instanciação. Ele é responsável
por alocar toda a memória necessária para o objeto sendo ins-
tanciado, e por gerar uma referência a esse objeto permitindo
que ele possa ser acessado no programa.
Por exemplo, se tiver uma classe Pessoa, e quisermos criar
dois objetos, devemos chamar duas vezes o operador new,
como ilustrado a seguir:
38 Linguagem de Programação Orientada a Objetos
Pessoa joao = new Pessoa();
Pessoa maria = new Pessoa();
Acabamos de criar dois objetos (joao e maria). O nome
do objeto é importante, pois é por meio dele que poderemos
acessar seus atributos e métodos. O nome do objeto deve ser
único no escopo em que ele é declarado. Existem diversos de-
talhes que envolvem a criação de objetos e a manipulação de
seus elementos internos que serão vistos ao longo dos cursos.
Para testar o exemplo, crie no BlueJ uma classe chamada
Pessoa, substitua o código padrão pelo código a seguir, com-
pile a classe, e, clicando com o botão direito sobre a classe,
chame o método main, como mostrado na imagem a seguir:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Pessoa
{
String nome;
void falar(){
System.out.println(this.nome);
}
public static void main(String [] args) {
Pessoa joao = new Pessoa();
Pessoa maria = new Pessoa();
joao.nome = “Joao”;
maria.nome = “Maria”;
joao.falar();
maria.falar();
}
}
Capítulo 3 Fundamentos de Orientação a Objetos em Java 39
ATIVIDADES
1. Uma classe é formada por _____________ e _____________.
2. Qual operador deve ser utilizado para diferenciar um atri-
buto de uma variável local de mesmo nome dentro de um
método?
3. Qual a estrutura de um método em Java?
4. Crie uma classe em Java que contém as quatro operações
aritméticas básicas: soma, subtração, multiplicação e di-
visão. Cada operação possui dois parâmetros de entrada
do tipo inteiro, chamados termo1 e termo2. O tipo de re-
torno dos métodos soma, subtração e multiplicação deve
ser inteiro. O tipo de retorno do método divisão deve float.
Para testar, crie um método main, e nele execute as quatro
operações criadas.
5. Altere o exemplo anterior. Agora, crie uma classe para
cada operação aritmética. Cada classe deve possuir um
método calcular que recebe dois inteiros por parâmetro
e retorna o respectivo resultado da operação. Crie uma
40 Linguagem de Programação Orientada a Objetos
classe chamada Calculadora2. Nessa classe, crie um mé-
todo main que irá instanciar as quatro operações, execu-
tando seus respectivos métodos calcular.
GABARITO
1. Atributos e métodos.
2. O operador this.
3. Visibilidade (opcional), tipo de retorno, nome, zero ou mais
parâmetros e corpo, onde são definidos os comandos que
o método executa.
4. Crie uma classe Calculadora e substitua o código padrão
pelo código a seguir:
public class Calculadora
{
int soma(int termo1, int termo2) {
int resultado = termo1 + termo2;
return resultado;
}
int subtrai(int termo1, int termo2) {
int resultado = termo1 - termo2;
return resultado;
}
int multiplica(int termo1, int termo2) {
int resultado = termo1 * termo2;
return resultado;
}
float divide(int termo1, int termo2) {
Capítulo 3 Fundamentos de Orientação a Objetos em Java 41
float resultado = termo1 / termo2;
return resultado;
}
public static void main(String [] args) {
Calculadora c = new Calculadora();
int r1 = c.soma(1, 1);
System.out.println(“Soma: “ + r1);
int r2 = c.subtrai(1, 2);
System.out.println(“Subtração: “ + r2);
int r3 = c.multiplica(2, 5);
System.out.println(“Multiplicação: “ + r3);
float r4 = c.divide(10, 3);
System.out.println(“Divisão: “ + r4);
}
}
5. Tenha cuidado para colocar cada classe pública em seu
respectivo arquivo Java.
public class Soma
{
int calcula(int termo1, int termo2)
{
int res = termo1 + termo2;
return res;
}
}
42 Linguagem de Programação Orientada a Objetos
public class Subtracao
{
int calcula(int termo1, int termo2)
{
int res = termo1 - termo2;
return res;
}
}
public class Multiplicacao
{
int calcula(int termo1, int termo2)
{
int res = termo1 * termo2;
return res;
}
}
public class Divisao
{
int calcula(int termo1, int termo2)
{
int res = termo1 / termo2;
return res;
}
}
Capítulo 3 Fundamentos de Orientação a Objetos em Java 43
public class Calculadora2
{
public static void main(String [] args) {
Soma so = new Soma();
Subtracao su = new Subtracao();
Multiplicacao mu = new Multiplicacao();
Divisao di =new Divisao();
int r1 = so.calcula(1, 1);
int r2 = su.calcula(1, 2);
int r3 = mu.calcula(2, 5);
int r4 = di.calcula(10, 3);
System.out.println(“Soma: “ + r1);
System.out.println(“Subtração: “ + r2);
System.out.println(“Multiplicação: “ + r3);
System.out.println(“Divisão: “ + r4);
}
}
Relacionamento
Entre Objetos
ÂÂ Vimos, no capítulo anterior, que uma classe pode ser definida para representar elementos do mundo real
ou do mundo computacional. Um objeto, por sua vez, é
dito como uma instância de uma classe, podendo, assim,
termos diversos objetos em um sistema derivados de uma
ou mais classes.
Mauricio da Silva Escobar
Capítulo 4
Capítulo 4 Relacionamento Entre Objetos 45
As classes, por sua vez, definem atributos, que são as infor-
mações que elas devem manter, e os métodos, que são as
operações que elas realizam. Os atributos podem ser de di-
versos tipos e os métodos podem manipular diferentes tipos de
elementos.
Uma classe pode relacionar-se com outras classes de dife-
rentes formas, como, por exemplo: ela pode possuir um atri-
buto definido em função de uma outra classe, ela pode possuir
um método que recebe por parâmetro objetos definidos em
função de outras classes etc.
A forma mais simples de relacionamento chama-se asso-
ciação. A associação indica que uma classe possui um atributo
definido em função de uma classe.
Por exemplo, considere uma pessoa e sua data de nasci-
mento. Há, pelo menos, duas formas de modelar esse proble-
ma em orientação a objetos. A primeira é definir uma classe
Pessoa e um atributo do tipo String chamado dataNascimento,
como no código abaixo.
1
2
3
4
public class Pessoa
{
String dataNascimento;
}
Como o atributo dataNascimento é do tipo String, ele acei-
ta qualquer valor textual. Fica a critério do programador veri-
ficar se o formato da data está, por exemplo, no formato de
data correto.
46 Linguagem de Programação Orientada a Objetos
Outra abordagem seria definir uma nova classe, chamada
Data, que possui três atributos: dia, mês e ano, ambos do tipo
inteiro. Dessa forma, podemos relacionar a classe Pessoa à
classe Data, como ilustrado no código a seguir:
1
2
3
4
5
6
public class Data
{
int dia;
int mes;
int ano;
}
1
2
3
4
5
public class Pessoa
{
String nome;
Data dataNascimento;
}
Note que a classe Pessoa possui um atributo do tipo Data,
caracterizando, dessa forma, a associação entre Pessoa e
Data. A classe Data não depende da Pessoa. Ela pode evoluir
(ser modificada) independentemente da classe Pessoa. Porém,
do ponto de vista da classe Pessoa, modificações feitas na
classe Data podem refletir diretamente na forma como como
essa data é utilizada.
A classe Teste, mostrada a seguir, demonstra como utilizar
a classe Pessoa juntamente com a classe Data.
Capítulo 4 Relacionamento Entre Objetos 47
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Teste
{
public static void main(String [] args){
Data d1 = new Data();
d1.dia = 25;
d1.mes = 12;
d1.ano = 1642;
Pessoa p1 = new Pessoa();
p1.nome = “Isaac”;
p1.dataNascimento = d1;
}
}
Como a classe Pessoa depende da classe Data, primeiro
criamos a data (linha 4) e informamos seus valores (linhas 5,
6 e 7). Na linha 9, é criado um objeto Pessoa e, na linha 11,
associamos a data à pessoa. Como o Java manipula objetos
por referência, o comando executado pela linha 11 indica que
p1.dataNascimento aponta para o mesmo objeto definido por
d1, na linha 4. Qualquer alteração feita em d1 será refletida
em p1.dataNascimento, pois agora elas apontam para uma
mesma área em memória.
Analise o código a seguir. Qual será o valor impresso nas
linhas 13 e 17?
48 Linguagem de Programação Orientada a Objetos
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Teste
{
public static void main(String [] args){
Data d1 = new Data();
d1.dia = 25;
d1.mes = 12;
d1.ano = 1642;
Pessoa p1 = new Pessoa();
p1.nome = “Isaac”;
p1.dataNascimento = d1;
System.out.println(p1.dataNascimento.dia);
d1.dia = 99;
System.out.println(p1.dataNascimento.dia);
}
}
Ao executar o comando da linha 13, será impresso na tela
o valor 25, pois a data não foi alterada desde sua inicialização.
Note que o comando da linha 17 utiliza p1.dataNascimento.dia,
e na linha 15 alteramos d1.dia. Como p1.dataNascimento e d1
apontam para o mesmo objeto, qualquer alteração no estado
do objeto apontado por eles será refletida na aplicação. Dessa
forma, ao executar a linha 17, será mostrado o valor 99 na tela.
Outro tipo de relacionamento ocorre quando definimos
métodos que recebem objetos por parâmetro. O parâmetro,
nesse caso, é uma referência ao objeto original previamente
criado. Qualquer alteração que o método faça no objeto rece-
bido será automaticamente refletida na memória da aplicação.
Capítulo 4 Relacionamento Entre Objetos 49
Considere o seguinte cenário: duas pessoas estão assis-
tindo uma mesma TV. A TV é compartilhada, isto é, um único
objeto na aplicação. Precisamos de duas classes para modelar
esse problema: TV e Pessoa, conforme o código a seguir:
1
2
3
4
public class TV
{
int canal = 0;
}
1
2
3
4
5
6
public class Pessoa
{
void avancaCanal(TV televisao) {
televisao.canal++;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Teste
{
public static void main(String [] args){
TV t = new TV();
Pessoa p1 = new Pessoa();
Pessoa p2 = new Pessoa();
p1.avancaCanal(t);
p1.avancaCanal(t);
p2.avancaCanal(t);
p1.avancaCanal(t);
System.out.println(t.canal);
}
}
50 Linguagem de Programação Orientada a Objetos
Analisando a classe Teste, a TV foi instanciada na linha 4 e
dois objetos Pessoa foram instanciados nas linhas 6 e 7. Note
que a referência à TV utilizada nas linhas 9 a 12 é a mesma.
Dessa forma, tanto p1 quanto p2 estão manipulando um mes-
mo objeto em memória, que é passado por referência para o
método avancaCanal da classe Pessoa.
Vamos considerar um segundo cenário. Uma partida de
tênis possui dois atletas e cada atleta possui um técnico. No
início da partida, deve ser exibido o nome do atleta seguido do
nome do seu técnico. Ao final da partida, deve ser exibido o
nome do atleta seguido se sua pontuação final. Esse exemplo
busca trabalhar a associação entre classes e o uso de objetos
como parâmetros de um método.
A primeira classe a ser modelada, por não depender de
outras classes, é a Técnico:
1
2
3
4
public class Tecnico
{
String nome;
}
Após, podemos definir a classe atleta, que, além do seu
nome, possui uma pontuação e um técnico (linha 6).
1
2
3
4
5
6
7
public class Atleta
{
String nome;
int pontos;
Tecnico t;
}
Capítulo 4 Relacionamento Entre Objetos 51
Por fim, podemos modelar a classe Partida, que possui
dois Atletas e os métodos de controle. O método iniciaParti-
da recebe os atletas e mostra suas informações na tela. Já o
método finalizaPartida mostra o nome dos atletas e sua pon-
tuação final.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Partida
{
Atleta jogador1;
Atleta jogador2;
void iniciaPartida(Atleta a1, Atleta a2)
{
this.jogador1 = a1;
this.jogador2 = a2;
System.out.println(jogador1.nome);
System.out.println(“\tTécnico: “ +
jogador1.t.nome);
System.out.println(jogador2.nome);
System.out.println(“\tTécnico: “ +
jogador2.t.nome);
}
void finalizaPartida()
{
System.out.println(jogador1.nome +
“:” + jogador1.pontos);
System.out.println(jogador2.nome +
“:” + jogador2.pontos);
}
}
52 Linguagem de Programação Orientada a Objetos
O último passo é criar uma classe de Teste para verificar a
ordem em que os objetos devem ser criados e relacionados.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Teste
{
public static voidmain(String [] args)
{
Tecnico t1 = new Tecnico();
t1.nome = “Annacone”;
Tecnico t2 = new Tecnico();
t2.nome = “Severin”;
Atleta a1 = new Atleta();
a1.nome = “Sampras”;
a1.t = t1;
Atleta a2 = new Atleta();
a2.nome = “Federer”;
a2.t = t2;
Partida part = new Partida();
part.iniciaPartida(a1, a2);
// gera alguns pontos
part.finalizaPartida();
}
}
Ao executar a aplicação, serão mostradas as seguintes in-
formações no console da aplicação. Você pode adicionar um
código de testes na linha 22 para simular a pontuação dos
dois atletas e executar novamente a aplicação.
Capítulo 4 Relacionamento Entre Objetos 53
ATIVIDADES
1. Utilizando os conhecimentos sobre associação entre clas-
ses, crie uma classe Pessoa Física que possui um nome,
CPF e uma Conta Corrente, que possui um número da
conta, número da agência e um saldo. Uma conta corren-
te deve possuir uma pessoa como titular da conta e op-
cionalmente uma pessoa de dependente no caso de conta
conjunta.
2. Utilizando os conhecimentos sobre associação entre clas-
ses, crie uma classe Computador que possui uma marca
e modelo, um Processador, que possui uma velocidade e
marca e uma Memória, que possui uma velocidade e uma
capacidade de armazenamento.
3. Modele uma classe funcionário, que possui um nome, um
valor por hora trabalhada e uma carga horária semanal.
Crie também uma classe setor, que possui 5 funcionários
e uma classe folha de pagamento, que possui um método
que recebe o setor e calcula o valor total da folha de pa-
gamento do mês.
54 Linguagem de Programação Orientada a Objetos
4. Modele uma classe Veículo e Fabricante. Um veículo pos-
sui um preço, modelo e fabricante. Um Fabricante pos-
sui apenas um nome. Crie uma classe Teste, instanciando
pelo menos 5 veículos de pelo menos 2 fabricantes.
5. Crie uma classe Forma e uma classe Editor. Uma forma
possui uma posição x e y em um plano 2D e uma cor.
A classe editor possui duas operações sobre uma forma:
mover, deslocando de uma forma para um novo valor x e
y; e, altera cor, que troca a cor de uma forma.
GABARITO
1.
public class PessoaFisica
{
String nome;
String CPF;
}
public class ContaCorrente
{
String agencia;
String conta;
double saldo;
PessoaFisica titular;
PessoaFisica dependente;
}
Capítulo 4 Relacionamento Entre Objetos 55
2.
public class Processador
{
String marca;
int velocidade;
}
public class Memoria
{
int velocidade;
long capacidade;
}
public class Computador
{
String marca;
String modelo;
Processador cpu;
Memoria ram;
}
3.
public class Funcionario
{
String nome;
float valorHora;
// carga horaria semanal
int cargaHoraria;
}
public class Setor
{
Funcionario f1, f2, f3, f4, f5;
}
56 Linguagem de Programação Orientada a Objetos
public class FolhaPagamento
{
void calculaFolha(Setor s){
float total = 0;
total += folhaMes(s.f1);
total += folhaMes(s.f2);
total += folhaMes(s.f3);
total += folhaMes(s.f4);
total += folhaMes(s.f5);
System.out.println(“Folha do mês: R$ “ + total);
}
float folhaMes(Funcionario f){
float totalFunc = f.valorHora * f.cargaHoraria * 4;
return totalFunc;
}
public static void main(String [] args) {
Funcionario f1 = new Funcionario();
f1.nome = “João”;
f1.valorHora = 10;
f1.cargaHoraria = 40;
Funcionario f2 = new Funcionario();
f2.nome = “Maria”;
f2.valorHora = 12;
f2.cargaHoraria = 20;
Funcionario f3 = new Funcionario();
f3.nome = “José”;
f3.valorHora = 15;
f3.cargaHoraria = 20;
Capítulo 4 Relacionamento Entre Objetos 57
Funcionario f4 = new Funcionario();
f4.nome = “Pedro”;
f4.valorHora = 20;
f4.cargaHoraria = 30;
Funcionario f5 = new Funcionario();
f5.nome = “Carlos”;
f5.valorHora = 5;
f5.cargaHoraria = 10;
Setor rh = new Setor();
rh.f1 = f1;
rh.f2 = f2;
rh.f3 = f3;
rh.f4 = f4;
rh.f5 = f5;
FolhaPagamento folha = new FolhaPagamento();
folha.calculaFolha( rh );
}
}
4.
public class Fabricante
{
String nome;
}
public class Veiculo
{
String modelo;
float preco;
Fabricante fab;
}
58 Linguagem de Programação Orientada a Objetos
public class Teste
{
public static void main(String [] args){
Fabricante ford = new Fabricante();
ford.nome = “Ford Motors”;
Fabricante gm = new Fabricante();
gm.nome = “Chevrolet”;
Veiculo focus = new Veiculo();
focus.preco = 69000.00f;
focus.modelo = “Focus Hath 2.0”;
focus.fab = ford;
Veiculo fiesta = new Veiculo();
fiesta.preco = 45000.00f;
fiesta.modelo = “New Fiesta Hatch 1.6”;
fiesta.fab = ford;
Veiculo mustang = new Veiculo();
mustang.preco = 130000.00f;
mustang.modelo = “Mustang GT Premium”;
mustang.fab = ford;
Veiculo cruze = new Veiculo();
cruze.preco = 67000.00f;
cruze.modelo = “Cruze Hatch”;
cruze.fab = gm;
Veiculo sonic = new Veiculo();
sonic.preco = 40000.00f;
sonic.modelo = “Sonic LT”;
sonic.fab = gm;
}
}
Capítulo 4 Relacionamento Entre Objetos 59
5.
public class Forma
{
int x, y;
String cor;
}
public class Editor
{
void movimenta(Forma f, int x, int y){
f.x = x;
f.y = y;
}
void alteraCor(Forma f, String novaCor){
f.cor = novaCor;
}
}
Herança e Métodos
Construtores
Mauricio da Silva Escobar
Capítulo 5
Capítulo 5 Herança e Métodos Construtores 61
O conceito de herança é um dos mais importantes da Orien-
tação a Objetos. Nas linguagens imperativas como no C, você
possui basicamente dois elementos para criar seus programas:
variáveis e métodos. As variáveis guardam o estado do pro-
grama (valores) e os métodos alteram o estado do programa,
manipulando as variáveis.
Na orientação a objetos, temos novos elementos a dispo-
sição que permitem a organização de um programa em par-
tes menores chamadas Classes. Um dos principais objetos da
orientação a objetos é permitir a reutilização de código. Imple-
mentar uma solução sempre do zero não é uma boa prática.
Além disso, para uma empresa de desenvolvimento, isso signi-
fica que o desenvolvedor gastará mais tempo para desenvolver
uma solução e, consequentemente, o projeto será mais caro.
A herança permite que classes sejam reutilizadas para a
formação de novas classes. Quando uma classe estende ou-
tra, ela herda toda a estrutura da sua classe Mãe, isto é, ela
herda os atributos e métodos. O ganho é muito grande nesse
caso. Considere que a classe mãe já foi desenvolvida, seu có-
digo já foi testado e validado. Todas as correções ou ajustes
que ocorram na classe mãe serão automaticamente refletidos
nas classes filhas. A classe filha preocupa-se, dessa forma, so-
mente com a implementação de novas funcionalidades.
Além da herança simples, em orientação a objetos, existe
o conceito de herança múltipla, permitindo que uma classe
estenda mais de uma outra classe. A linguagem Java, por sua
vez, não implementa herança múltipla – uma classe pode es-
tender somente uma outra classe.
62 Linguagem de Programação Orientada a Objetos
Para o melhor entendimento do conceito de herança, con-
sidere o exemplo da classificação de espécies usada na biolo-
gia, conforme Figura a seguir.
Em relação ao exemplo, podemos dizer que um Cão é um
Mamífero, e que também é um Animal. Mamíferos e répteis
herdam todas as características de Animal. Crocodilos e la-
gartos herdam todas as características de Réptil.
No capítulo anterior, foi estudado o relacionamento entre
classes, conhecido também como associação. Na associação,
dizemos que uma classe possui outra classe, por exemplo:
Uma pessoa, definida pela classe Pessoa, possui uma data
de nascimento, definida pela classe Data. A associação indi-
cabasicamente que uma classe utiliza outra classe. No caso
da herança, a semântica do relacionamento é outra. Agora,
dizemos que uma classe é uma outra classe. No exemplo an-
terior, existe um relacionamento de hierarquia entre Mamífero
e Animal. Dessa forma, pode-se dizer que todo mamífero tam-
bém é um animal, dado o relacionamento de herança entre
eles. Assim, o mamífero pode ser tratado tanto como animal
(elemento mais geral) como propriamente mamífero (elemento
mais específico).
Capítulo 5 Herança e Métodos Construtores 63
Antes de discutirmos como a herança é implementada no
Java, considere o seguinte exemplo:
O exemplo possui três classes: Pessoa, Pessoa Física e Pes-
soa Jurídica. A classe Pessoa possui três atributos: Nome, En-
dereço e Telefone. As classes Pessoa Física e Pessoa Jurídica
são do tipo pessoa, porém, cada classe define novas caracte-
rísticas (especialização), que não são comuns na superclasse.
Uma pessoa física possui um CPF e um RG, porém não possui
razão social nem CNPJ. Dessa forma, é necessária a criação
de uma nova classe para organizar essas informações, chama-
da Pessoa Jurídica.
Em relação ao relacionamento de herança, dizemos que
a classe Mãe (Pessoa) é a superclasse, enquanto que suas
classes filhas (Pessoa Física e Pessoa Jurídica) são subclasses.
64 Linguagem de Programação Orientada a Objetos
Herança em Java
Em Java, para especificar um relacionamento de herança, a
subclasse deve especificar a superclasse por meio da palavra
reservada extends. O exemplo a seguir ilustra a declaração
das ilustradas anteriormente. Note a utilização da palavra ex-
tends, seguida do nome da classe a ser estendida na linha 1
das classes PessoaFisica e PessoaJuridica. Em Java,
qualquer classe que não especifique uma superclasse, auto-
maticamente deriva (herda) da classe padrão Objetct.
É importante relembrar alguns conceitos importantes do
Java. Cada classe pública (public class) deve ser decla-
rada em um arquivo próprio, de extensão “.java”. Além disso,
o nome das classes deve ser iniciado com letra maiúscula, e
não pode possuir acentuação, caracteres especiais nem espa-
ços em branco.
1
2
3
4
public class Pessoa
{
// atributos e métodos de pessoa
}
1
2
3
4
public class PessoaFisica extends Pessoa
{
// atributos e métodos de pessoa física
}
1
2
3
4
public class PessoaJuridica extends Pessoa
{
// atributos e métodos de pessoa jurídica
}
Capítulo 5 Herança e Métodos Construtores 65
O Java dispõe de um operador especial, chamado super,
para que uma subclasse possa acessar explicitamente atributos
e/ou métodos da sua superclasse, como ilustrado no exemplo
a seguir:
1
2
3
4
5
public class Pessoa
{
String nome;
String telefone;
}
1
2
3
4
6
7
8
9
10
11
12
13
14
public class PessoaFisica extends Pessoa
{
String CPF;
String RG;
void exibeInformacoes() {
System.out.println(“==== Pessoa Fisica ====”);
System.out.println(“Nome: “ + super.nome);
System.out.println(“Telefone: “ + super.telefone);
System.out.println(“CPF: “ + this.CPF);
System.out.println(“RG: “ + this.RG);
}
}
Em relação ao exemplo, primeiramente, é feita a relação
de herança por meio do uso da palavra extends, na linha
1 da classe PessoaFisica. Nessa mesma classe, foi criado
um método chamado exibeInformacoes, na linha 7. Esse
método simplesmente exibe as informações de uma pessoa
física na tela. As informações nome e telefone são herdadas.
Para acessá-las, é utilizado o comando super (linhas 9 e 10).
66 Linguagem de Programação Orientada a Objetos
Métodos construtores
Outro conceito importante, tratando-se de herança e constru-
ção de objetos, são os métodos construtores. O método cons-
trutor serve para construir objetos, possuindo todo o código
que deve ser executado na inicialização de um novo objeto.
Em Java, uma classe pode conter várias declarações de
métodos construtores. Dessa forma, podemos ter um constru-
tor para cada tipo de inicialização que um objeto requer.
O método construtor possui a seguinte estrutura:
 Visibilidade (ex. public, protected, private ou
default (omitindo o tipo de visibilidade) ). A visibilidade
será explicada após este capítulo.
 Não possui tipo de retorno (void também é conside-
rado um tipo válido para retorno – indicando que o mé-
todo não retorna nada, logo, o construtor também não
pode ser do tipo void)
 O nome do construtor deve levar o mesmo nome da
classe.
 Parâmetros: o construtor pode possuir zero ou mais pa-
râmetros de entrada.
Em Java, o construtor que não recebe parâmetros de entra-
da é chamado de construtor padrão (default), como ilustrado
no exemplo a seguir, que define uma classe pessoa, dois atri-
butos e um método construtor padrão. Note que o constru-
tor obrigatoriamente deve possuir o mesmo nome da classe e
Capítulo 5 Herança e Métodos Construtores 67
não deve possuir tipo de retorno. A visibilidade (public nesse
caso) é opcional.
1
2
3
4
5
6
7
8
9
public class Pessoa
{
String nome;
String telefone;
public Pessoa(){
// construtor default
}
}
O método construtor padrão não é obrigatório. Só faz
sentido ter um método construtor quando de fato ele realiza
algum código de inicialização. Opcionalmente, o construtor
pode receber parâmetros de entrada, utilizando-os como va-
lores iniciais para os atributos do objeto, como ilustrado no
exemplo a seguir:
1
2
3
4
5
6
7
8
9
10
public class Pessoa
{
String nome;
String telefone;
public Pessoa(String nome, String telefone){
this.nome = nome;
this.telefone = telefone;
}
}
68 Linguagem de Programação Orientada a Objetos
No exemplo anterior, o construtor Pessoa recebe dois parâ-
metros. Note que os nomes dos parâmetros casualmente são
iguais aos nomes dos atributos. Para diferenciá-los, tornan-
do explícito a operação sendo realizada, é usado o operador
this. Esse operador é usado para referenciar-se ao objeto,
e não a variáveis locais. Nesse caso, o this.nome da linha
7 faz referência ao atributo nome da linha 3. Esse atributo,
por sua vez, recebe o valor do parâmetro nome, assim como
ocorre para o atributo telefone, na linha 8. Você pode in-
terpretar esse código como: “Toda pessoa, ao ser criada na
aplicação, deve possuir um nome e um telefone.”.
Você também pode ter, em uma mesma classe, vários mé-
todos construtores, como ilustrado a seguir:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Pessoa
{
String nome;
String telefone;
public Pessoa(String nome){
this.nome = nome;
this.telefone = “Não possui.”;
}
public Pessoa(String nome, String telefone){
this.nome = nome;
this.telefone = telefone;
}
}
Capítulo 5 Herança e Métodos Construtores 69
A classe Pessoa possui agora dois construtores. O primeiro
com apenas um parâmetro e o segundo com dois parâmetros.
No primeiro construtor, note que, mesmo não informando o
telefone por parâmetro, o construtor pode fazer alguma inicia-
lização no atributo. Nesse caso, ele inicializa o atributo tele-
fone com o valor “Não possui.” (linha 8).
Quando possuímos vários construtores em uma classe, e es-
tes construtores fazem operações similares, podemos simplificar
o código utilizando o operador this, fazendo uma referência
a outro construtor da classe. Compare o exemplo anterior e o
exemplo a seguir, que utiliza o operador this para simplificar
o código do primeiro construtor, visto que eles são semelhan-
tes. Esse tipo de código é importante quando temos diversos
construtores e diversos parâmetros de entrada, para evitar ficar
repetindo o mesmo código nesses métodos construtores.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Pessoa
{
String nome;
String telefone;
public Pessoa(String nome){
this(nome, “Não possui.”);
}
public Pessoa(String nome, String telefone){
this.nome = nome;
this.telefone = telefone;
}
}
70 Linguagem de Programação Orientada a Objetos
Por fim, você deve ter cuidadoao criar construtores ao
mesmo tempo que utiliza herança. Quando a superclasse
define um construtor que não seja o padrão, a subclasse é
obrigada a chamar explicitamente esse construtor, utilizando o
operador super.
Considerando a classe Pessoa do exemplo anterior, o
exemplo a seguir ilustra a chamada explícita ao construtor da
superclasse:
1
2
3
4
5
6
7
8
9
10
11
12
13
public class PessoaFisica extends Pessoa
{
String CPF;
String RG;
public PessoaFisica(String nome, String telefone,
String CPF, String RG) {
super(nome, telefone);
this.CPF = CPF;
this.RG = RG;
}
}
O construtor da classe PessoaFisica recebe quatro
parâmetros. Dois desses parâmetros (nome e telefone) são
enviados para o construtor da classe Pessoa por meio do
operador super. Os demais parâmetros são atribuídos nor-
malmente aos atributos da classe.
É importante observar que, caso seja necessário utilizar o
super para referenciar algum construtor da superclasse, este
Capítulo 5 Herança e Métodos Construtores 71
deve ser declarado na primeira linha do método construtor
(conforme linha 8 do exemplo anterior).
Testando o exemplo
Para testar os exemplos apresentados, você deve criar uma
nova classe chamada Teste e nela um método main, con-
forme ilustrado no código abaixo.
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Teste
{
public static void main(String [] args){
Pessoa p1 = new Pessoa();
Pessoa p2 = new Pessoa(“João”);
Pessoa p3 = new Pessoa(“Maria”,
“+55 51 32100123”);
PessoaFisica pf1 =
new PessoaFisica(“José”, “Nro Tel”,
“Nro CPF”, “Nro RG”);
}
}
O exemplo apresentará um erro de compilação na linha 4.
Esse erro ocorre porque o Java identificará que a classe Pes-
soa não possui um construtor padrão. Altere-o, informando
parâmetros válidos ou remova essa linha. As demais declara-
ções funcionarão normalmente. Crie, na classe Pessoa e na
classe PessoaFisica, um método exibeInformacoes
que imprima na tela o valor dos atributos dessas classes. Após,
72 Linguagem de Programação Orientada a Objetos
altere o método main de forma a exibir as informações dos
objetos p2, p3 e pf1.
ATIVIDADES
1. Como pode ser definido o conceito “Herança” na orien-
tação a objetos (cite pelo menos duas vantagens em sua
utilização)?
2. O que diferencia um método construtor dos demais méto-
dos de uma classe?
3. Crie classes para representar os seguintes elementos, suas
principais características, comportamentos e relaciona-
mentos de herança:
 Professor
 Professor Integral
 Professor Horista
4. Crie classes para representar um editor de formas geo-
métricas. Utilize herança para maximizar a reutilização de
código.
São duas formas básicas: círculo e quadrado.
Toda forma geométrica possui uma cor e uma posição em um
plano cartesiano (x e y).
Crie um método construtor para inicializar a forma com uma
posição inicial e uma cor.
Crie métodos para alterar a cor, mover e desenhar a forma.
Capítulo 5 Herança e Métodos Construtores 73
5. Em Java, a palavra-chave que implementa uma relação de
herança de classes é:
a) derives
b) inherits
c) subClassOf
d) extends
e) instantiates
GABARITO
1. A herança permite que novas classes sejam criadas a partir
de classes existentes. Vantagens: Reutilização, Organiza-
ção de Código, Facilidade de manutenção.
2. O método construtor NÃO possui tipo de retorno e DEVE
ter o mesmo nome da classe.
3.
public class Professor
{
String nome;
String nroRegistro;
String areaAtuacao;
String titulacao;
}
public class ProfessorHorista extends Professor
{
float valorHora;
int cargaHorariaSemanal;
}
74 Linguagem de Programação Orientada a Objetos
public class ProfessorIntegral extends Professor
{
int nivel;
int cargaHoraria = 40;
}
4.
public class Forma
{
int x, y;
String cor;
public Forma(int x, int y, String cor){
this.x = x;
this.y = y;
this.cor = cor;
}
public void mover(int novoX, int novoY) {
this.x = novoX;
this.y = novoY;
}
public void alteraCor(String novaCor){
this.cor = novaCor;
}
}
public class Circulo extends Forma
{
float raio;
public Circulo(int x, int y, String cor, float raio){
super(x, y, cor);
Capítulo 5 Herança e Métodos Construtores 75
this.raio = raio;
}
public void desenhar(){
System.out.println(“o”);
}
}
public class Quadrado extends Forma
{
int largura, altura;
public Quadrado(int x, int y, String cor, int
largura, int altura){
super(x, y, cor);
this.largura = largura;
this.altura = altura;
}
public void desenhar(){
System.out.println(“[]”);
}
}
5. D.
Polimorfismo
Mauricio da Silva Escobar
Capítulo 6
Capítulo 6 Polimorfismo 77
Assim como a herança, o polimorfismo é um dos principais
conceitos da orientação a objetos. Ele consiste, basicamente,
na capacidade de um mesmo objeto assumir diversas for-
mas em uma mesma aplicação, dependendo da perspectiva
em que ele é tratado. O conceito ficará mais claro à medida
que formos verificando as formas de polimorfismo e como ele
é de fato implementado pela linguagem Java. Na linguagem
Java, existem dois tipos de polimorfismo: estático e dinâmico.
Polimorfismo estático
O polimorfismo estático ocorre quando definimos méto-
dos com o mesmo nome dentro de uma mesma classe. A deci-
são de qual método invocar é feita em tempo de compilação,
baseada na ordem e tipo dos parâmetros que são enviados
para o método.
Tal utilização é chamada de sobrecarga de método. Você
encontrará, em outros livros e artigos na Internet, inclusive na
própria linguagem Java, o termo em inglês overloading, que
significa sobrecarregar.
Antes de irmos para um exemplo, é importante destacar-
mos o conceito de assinatura de um método. Lembre que, em
Java, um método possui a seguinte estrutura:
 Visibilidade;
 Tipo de retorno;
 Nome;
78 Linguagem de Programação Orientada a Objetos
 Área de parâmetros (cada parâmetro possui um tipo e
um nome que o identifica);
 Corpo (implementação do método).
A assinatura do método leva em consideração o nome do
método, a ordem e o tipo dos seus parâmetros. Métodos com
mesma assinatura são considerados erro de programação, e
serão detectados na fase de compilação.
Exemplo de métodos com mesma assinatura (erro de com-
pilação):
1
2
3
4
5
6
7
8
9
10
public class ExemploAssinaturas
{
void metodo1(int a){ }
void metodo1(int b) { }
void metodo2(String a, float b) { }
void metodo2(String p1, float p2) { }
}
A classe apresentada possui dois métodos chamados me-
todo1 e dois métodos chamados metodo2. Embora o nome
dos parâmetros sejam diferentes, o que caracteriza a assinatura
do método é o nome do método, a ordem e tipo dos parâme-
tros, dessa forma, para o compilador, os métodos são iguais.
Voltando para o polimorfismo, o exemplo a seguir ilustra
a sobrecarga de métodos em uma classe Java. Note que o
Capítulo 6 Polimorfismo 79
método somar possui duas sobrecargas, uma que recebe dois
valores inteiros e outra que recebe dois valores do tipo float.
1
2
3
4
5
6
7
8
9
10
public class ExemploSobrecarga
{
int somar(int a, int b){
return a + b;
}
float somar(float a, float b){
return a + b;
}
}
11
12
13
14
15
16
17
18
19
class Teste {
public static void main(String [] args) {
ExemploSobrecarga ex
= new ExemploSobrecarga();
ex.somar(1.2f, 3.2f);
ex.somar(1, 2);
}
}
Como no polimorfismo estático o compilador consegue di-
ferenciar os métodos que serão chamados, podemos dizer que
a chamada da linha 16 refere-se ao método da linha 7, e a
chamada da linha 17 refere-se ao método da linha 3.
O polimorfismo estático também pode ser aplicado aos
métodos construtores de uma classe, como ilustrado no exem-
plo a seguir:
80 Linguagem de Programação Orientada a Objetos
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16public class Pessoa
{
public Pessoa() { }
public Pessoa(String nome) { }
public Pessoa(String nome, String email) { }
public Pessoa(String nome, int peso) { }
public static void main( String [] args ) {
Pessoa p1 = new Pessoa();
Pessoa p2 = new Pessoa ( “Maria” );
Pessoa p3 = new Pessoa ( “Joao”, 75 );
}
}
A classe Pessoa define quatro construtores, variando em
tipo e ordem de parâmetros. Por polimorfismo, ao criarmos
uma pessoa, dependendo do tipo dos parâmetros passados, o
Java decidirá qual método invocar, como ilustrado no método
main (linha 11).
Polimorfismo dinâmico
Ao contrário do polimorfismo estático, o polimorfismo di-
nâmico presume que haja um relacionamento de herança
entre duas classes.
O polimorfismo dinâmico ocorre quando um método da
superclasse é redefinido pela subclasse. Nesse caso, dizemos
que o método foi sobrescrito (cujo termo em inglês é override).
Capítulo 6 Polimorfismo 81
A decisão de qual método deve ser invocado é tomada somen-
te em tempo de execução da aplicação.
Esse tipo de polimorfismo é utilizando quando precisamos
redefinir um comportamento que é implementado pela super-
classe. Por exemplo, considerando uma hierarquia de classes
entre veículos. Temos veículos de um modo geral, veículos
aquáticos, veículos terrestres e veículos aéreos. Todos os ve-
ículos se locomovem, porém cada tipo específico de veículo
se locomove de uma maneira. Essa especificidade pode ser
implementada em uma linguagem de programação utilizan-
do a noção de sobrescrita (ou redefinição de método). Fica a
critério do desenvolvedor, sobrescrever ou não um método da
superclasse.
Ao contrário da sobrecarga, a sobrescrita deve manter
a mesma assinatura do método, conforme definido na super-
classe. O exemplo a seguir ilustra a redefinição de um método
por uma subclasse:
1
2
3
4
5
6
public class Veiculo
{
void locomover() {
System.out.println(“Veículo: locomover”);
}
}
7
8
9
10
11
12
13
public class VeiculoTerrestre extends Veiculo
{
void locomover() {
System.out.println(“Veículo Terrestre:
locomover”);
}
}
82 Linguagem de Programação Orientada a Objetos
14
15
16
17
18
19
20
21
22
23
24
public class TesteVeiculos {
public static void main(String [] args){
Veiculo v1 = new Veiculo();
Veiculo v2 = new VeiculoTerrestre();
VeiculoTerrestre v3 = new VeiculoTerrestre();
v1.locomover();
v2.locomover();
v3.locomover();
}
}
Note que existe uma relação de herança entre as classes
(linha 7) e a sobrescrita do método (linha 9), a partir da rede-
finição do seu comportamento padrão.
A classe TesteVeiculos é importante para percebermos
o momento exato em que ocorre o polimorfismo. O conceito
de herança é importante nesse momento. Como um veículo
terrestre também é um veículo, podemos ter um objeto do tipo
veículo guardando a referência para um objeto do tipo veículo
terrestre, como ilustrado na linha 17.
As chamadas das linhas 20, 21 e 22 chamarão um mesmo
método chamado locomover, que é definido pela superclasse
Veiculo. No caso das chamadas nas linhas 21 e 22, como
a classe instanciada foi VeiculoTerrestre, será chamado
somente o método polimórfico, ou seja, o método sobrescrito
pela subclasse. Ao executar a classe TesteVeiculos a saí-
da do programa será como ilustrado na imagem a seguir.
Capítulo 6 Polimorfismo 83
O operador super
O operador super, também visto no capítulo sobre métodos
Construtores, serve para fazer referência para a superclasse
em qualquer classe que possua relacionamento de herança.
Ele pode ser usado para acessarmos diretamente atributos e
métodos da superclasse.
Em relação ao polimorfismo, quando um método sobres-
crito é invocado, o método original deixa de ser chamado.
Nesse caso, se for necessário chamar explicitamente o méto-
do da superclasse, você deve utilizar o operador super. Os
exemplos a seguir ilustram esses comportamentos.
No primeiro momento, não utilizados a chamada à super-
classe.
1
2
3
4
5
public class Animal {
public void falar(){
System.out.println(“Animal Falando > “);
}
}
84 Linguagem de Programação Orientada a Objetos
6
7
8
9
10
public class Cao extends Animal {
public void falar(){
System.out.println(“Woof Woof”);
}
}
11
12
13
14
15
class Gato extends Animal {
public void falar(){
System.out.println(“Meow”);
}
}
16
17
18
19
20
21
22
23
24
25
26
public class TesteSuper {
public static void main(String [] args){
Animal a = new Animal();
Animal b = new Cao();
Animal c = new Gato();
a.falar();
b.falar();
c.falar();
}
}
Note que não utilizamos o super. A saída no console, após
executar o método main da classe TesteSuper deverá ser:
Capítulo 6 Polimorfismo 85
Podemos alterar a classe Cao, adicionando a ela uma cha-
mada explícita ao mesmo método, só que da superclasse, uti-
lizando o operador super e executar novamente o método
main, obteremos a seguinte saída:
1
2
3
4
5
6
public class Cao extends Animal {
public void falar(){
super.falar();
System.out.println(“Woof Woof”);
}
}
Note que o texto “Animal Falando >”, que pertente à classe
Animal, foi mostrado duas vezes, uma por meio da chama-
da explícita a partir de um objeto do tipo Animal e outra pela
chamada utilizando o super, na classe Cao.
O operador final
Além de permitir a declaração de constantes em Java, o ope-
rador final pode ser usado em combinação com a herança
86 Linguagem de Programação Orientada a Objetos
para: (i) evitar que uma classe seja estendida e, (ii) evitar que
um método seja sobrescrito em uma classe filha, ou seja, para
indicar que sua implementação não possa ser alterada, pre-
servando um determinado comportamento do objeto.
Os exemplos a seguir ilustram como declarar classes e mé-
todos final.
1
2
3
4
public final class Criptografia {
// atributos e métodos da classe
}
1
2
3
4
5
6
public class FolhaPagamento {
public final void calculaFolha(){
// lógica do método
}
}
ATIVIDADES
1. Diferencie sobrecarga de sobrescrita.
2. Em uma mesma classe, é possível ocorrer sobrecarga entre
métodos construtores?
3. Crie uma classe Calculadora com e pelo menos uma sub-
classe que realize sobrescrita de método.
4. Crie uma classe Impressora que implemente sobrecarga
de métodos.
Capítulo 6 Polimorfismo 87
5. Utilizando a noção sobre formas geométricas em duas di-
mensões, crie pelo menos uma superclasse e uma sub-
classe. Implemente sobrecarga nos métodos construtores e
utilize o operador super.
GABARITO
1.
Sobrecarga é quando uma classe possui métodos com mesmo
nome, porém com assinaturas diferentes. Sobrescrita ocorre
em um relacionamento de herança, quando a subclasse rees-
creve um método da superclasse. Nesse caso, a assinatura é
mantida.
2.
Sim, desde que possuam assinaturas diferentes. Ex.:
class Pessoa {
Pessoa(String nome) {
}
Pessoa(String nome, int idade) {
}
}
3.
public class Calculadora
{
public void calcular(int a, int b) {
}
}
public class Somadora extends Calculadora
88 Linguagem de Programação Orientada a Objetos
{
public void calcular(int a, int b){
int resultado = a + b;
System.out.println(“Resultado: “ + resultado);
}
}
4.
public class Impressora
{
public void imprimir(String dados) {
System.out.println(“Imprimindo dados em
texto “ + dados);
}
public void imprimir(int dados) {
System.out.println(“Imprimindo um valor
inteiro “ + dados);
}
public void imprimir(char dado) {
System.out.println(“Imprimindo um caractere
“ + dado);
}
}
5.
public class Forma2D
{
public int posicaoX, posicaoY;
public Forma2D(int x, int y){
this.posicaoX = x;
this.posicaoY = y;
Capítulo 6 Polimorfismo 89
}
}
class Circulo2D extends Forma2D {
public int raio;
public Circulo2D (int x, int y) {
super(x, y);
this.raio = 0;
}
public Circulo2D (int
Continue navegando
Materiais relacionados
38 pág.
45 pág.
172 pág.
44 pág.
Perguntas relacionadas
Compartilhar