Modelagem Orientada a Objetos - Volume 3

Prévia do material em texto

Recife, 2010
Modelagem 
Orientada a Objetos
Eduardo Araújo Oliveira
Patrícia Azevedo Tedesco
Volume 3
Universidade Federal Rural de Pernambuco
Reitor: Prof. Valmar Corrêa de Andrade
Vice-Reitor: Prof. Reginaldo Barros
Pró-Reitor de Administração: Prof. Francisco Fernando Ramos Carvalho
Pró-Reitor de Extensão: Prof. Paulo Donizeti Siepierski
Pró-Reitor de Pesquisa e Pós-Graduação: Prof. Fernando José Freire
Pró-Reitor de Planejamento: Prof. Rinaldo Luiz Caraciolo Ferreira
Pró-Reitora de Ensino de Graduação: Profª. Maria José de Sena
Coordenação Geral de Ensino a Distância: Profª Marizete Silva Santos
Produção Gráfica e Editorial
Capa e Editoração: Allyson Vila Nova, Rafael Lira, Italo Amorim, Gláucia Fagundes e Arlinda Torres
Revisão Ortográfica: Marcelo Melo
Ilustrações: Diego Almeida
Coordenação de Produção: Marizete Silva Santos
Sumário
Apresentação ...................................................................................................4
Conhecendo o Volume 3 .................................................................................5
Capítulo 1 - Classes Abstratas .......................................................................7
Classes Abstratas ..........................................................................................7
Modificador final ........................................................................................... 11
Capítulo 2 - A Linguagem Java .....................................................................21
A Linguagem Java .......................................................................................21
Tipos de Dados ............................................................................................29
Utilizando os Tipos de Dados ......................................................................30
Casting .........................................................................................................33
Capítulo 3 - Java: Estruturas condicionais, estruturas de repetição e 
arrays ..............................................................................................................40
Estruturas Condicionais ...............................................................................40
Estruturas de Repetição ..............................................................................44
Estruturas de Dados - Arrays .......................................................................46
Considerações Finais ....................................................................................56
Conhecendo os Autores ................................................................................58
Apresentação
Caro(a) Cursista,
Seja bem-vindo(a) ao terceiro módulo do curso Modelagem Orientada a Objetos. 
Neste terceiro módulo, vamos aprofundar os estudos que iniciamos no módulo passado, 
refletindo sobre as classes abstratas e sua importância na hierarquia de classes e, 
aprenderemos mais sobre a programação orientada a objetos. Para a implementação, 
vamos continuar estudando a linguagem JAVA, que como já vimos, é a linguagem OO 
mais utilizada no mundo. Aprenderemos agora um pouco mais sobre a sintaxe Java, 
as estruturas condicionais e de repetição, os tipos de dados e outros. Para auxiliar 
o entendimento, preparamos vários exemplos de exercícios resolvidos e também 
sugerimos vários exercícios para praticar. Como você já deve ter visto, na programação, 
a prática é a chave do aprendizado.
O objetivo principal deste terceiro módulo é aprofundar os conceitos aprendidos até 
agora para começar a construir sistemas mais avançados, com mais recursos. Assim, 
poderemos refletir mais profundamente sobre como os conceitos que vimos até agora, 
particulares da orientação a objetos, fazem diferença na construção dos sistemas. E aí, 
vamos ao trabalho?
Bons estudos!
Eduardo Oliveira e Patricia Tedesco
Conhecendo o Volume 3
Neste terceiro volume, você irá encontrar o Módulo 3 da disciplina Modelagem 
Orientada a Objetos. Para facilitar seus estudos, veja a organização deste segundo 
módulo.
Módulo 3 - Programação OO
Carga Horária do Módulo 03: 15 h/aula
Objetivo do Módulo 3
√ Apresentar as Classes Abstratas e aprofundar os estudos de programação 
OO (sintaxe Java, estruturas condicionais e de repetição, tipos de dados...).
Conteúdo Programático do Módulo 3
√ Classes Abstratas
√ Tipos de dados Java
√ Estruturas condicionais
√ Estruturas de repetição
6
Modelagem Orientada a Objetos
Capítulo 1
O que vamos estudar neste capítulo?
Neste capítulo, vamos estudar o seguinte tema:
» Classes Abstratas
Metas
Após o estudo deste capítulo, esperamos que você consiga:
» Compreender e utilizar classes abstratas
» Analisar a importância destes conceitos para a abordagem 
Orientada a Objetos
7
Modelagem Orientada a Objetos
Capítulo 1 - Classes Abstratas
Vamos conversar sobre o assunto?
Olá, seja bem vindo(a) ao terceiro volume do curso de Modelagem 
Orientada a Objetos! 
Neste terceiro volume, iremos aprofundar os estudos que iniciamos 
no volume passado, refletindo um pouco mais sobre as Hierarquias 
de Classes – e as possibilidades que a organização dos objetos em 
hierarquias nos trazem. Neste volume teremos ainda a oportunidade 
de praticar mais o conhecimento adquirido, através de exercícios 
práticos de programação, que resolveremos utilizando linguagem 
Java. 
É importantíssimo para a sua formação que você seja um 
estudante autônomo. Para isto, o primeiro passo é buscar outras 
fontes de aprendizado. Leia outros livros – nós sugerimos várias 
opções na lista de referências! Não se limite às informações contidas 
neste volume. Participe do fórum de discussão, converse e discuta 
com seu tutor, professores e outros colegas de sala. Lembre que 
apesar de estudar a distância, você não está sozinho... Vamos lá...
Classes Abstratas
Até agora, vimos apenas classes concretas, isto é, todas as 
classes que construímos podem originar objetos. Classes concretas 
são estruturas definidas e prontas para instanciarem objetos [JAVA 
STARTER].
As classes abstratas nunca podem ser instanciadas de forma 
direta. A classe abstrata tem como maior objetivo ser estendida e, 
por este motivo, uma classe abstrata se comporta de forma diferente 
de uma classe concreta. Para que serve a classe abstrata? Quando 
devemos utilizá-la? Para entender isto melhor, vamos refletir sobre 
o exemplo do funcionário (já apresentado no volume 2) e revisto a 
seguir:
8
Modelagem Orientada a Objetos
Figura 1. Representação em UML de herança
Como podemos visualizar na Figura 1, a classe Funcionário 
é herdada pelas classes Diretor, Professor e Secretaria. Quando 
vamos criar um objeto do tipo Funcionário, não instanciamos a 
própria classe Funcionário. Devemos criar um objeto do tipo Diretor 
ou Professor ou Secretaria, que são Funcionários. Como forma de 
evitarmos que a classe Funcionário seja instanciada de maneira 
errada e desnecessária, devemos criar a classe Funcionário como 
uma classe abstrata, que deverá, obrigatoriamente, ser estendida. 
As classes abstratas servem para agrupar todas as propriedades que 
são comuns a seus descendentes, desta forma facilitam o reuso de 
código.
public abstract class Funcionario {
Para transformar uma classe concreta em uma classe abstrata, 
adicionamos a palavra reservada abstract na declaração da classe. 
Feita a transformação, não podemos mais instanciar diretamente a 
classe Funcionário. Mais concretamente, quando definimos a classe 
funcionário como abstrata, a tentativa de criação de um objeto do 
tipo Funcionario “Funcionario func = new Funcionario();” não seria 
permitida.
Utilizando uma classe abstrata garantimos que nunca haverá 
um objeto da classe Funcionário e sim, sempre, de uma de suas 
subclasses (Diretor, Professor, Secretaria).
Vamos agora entender um pouco mais sobre os comportamentos 
de classes abstratas. Tomemos a classe Funcionário como exemplo:
public abstract class Funcionario {
9
Modelagem Orientadaa Objetos
 private String depto; 
 private double salario; 
 private double beneficio;
 public double getBeneficio() { 
 return beneficio;
 }
 public void setBeneficio(double beneficio) { 
 this.beneficio = beneficio;
 }
 public String getDepto() { 
 return depto;
 }
 public void setDepto(String depto) { 
 this.depto = depto;
 }
 public double getSalario() { 
 return salario;
 }
 public void setSalario(double salario) { 
 this.salario = salario;
 }
 public void baterPonto(){ 
 System.out.println(“Funcionario bateu o ponto”); 
 }
 public void escreverRelatorioMensal(){ 
 //colocar aqui o código do método 
 }
}
Em classes abstratas, podemos ter métodos abstratos ou 
concretos. No exemplo da classe Funcionário, os métodos que não 
possuem a palavra reservada abstract são concretos e podem ser 
sobrescritos por subclasses. Se quisermos garantir que um método 
de uma classe abstrata seja obrigatoriamente sobrescrito, devemos 
utilizar a palavra reservada abstract na assinatura do método e, não 
devemos implementá-lo. Vejamos o exemplo a seguir:
10
Modelagem Orientada a Objetos
public abstract class Funcionario {
 private String depto; 
 private double salario; 
 private double beneficio;
 public double getBeneficio() { 
 return beneficio;
 }
 public void setBeneficio(double beneficio) { 
 this.beneficio = beneficio;
 }
 public String getDepto() { 
 return depto;
 }
 public void setDepto(String depto) { 
 this.depto = depto;
 }
 public double getSalario() { 
 return salario;
 }
 public void setSalario(double salario) { 
 this.salario = salario;
 }
	 public	abstract	void	baterPonto();
 public void escreverRelatorioMensal(){ 
 //colocar aqui o código do método 
 }
}
Adicionando a palavra reservada abstract no método baterPonto 
(e retirando sua implementação), garantimos que qualquer 
subclasse de Funcionário terá, obrigatoriamente, que sobrescrever 
o método baterPonto(). Fazemos isto se soubermos que todos os 
descendentes da classe Funcionario têm que ter baterPonto() em seu 
comportamento, mas todos fazem isto de maneiras diferentes.
public class Testes extends Funcionario{
11
Modelagem Orientada a Objetos
 public static void main(String[] args) { 
 Diretor dir = new Diretor(); 
 dir.baterPonto();
 }
	 @Override	
	 public	void	baterPonto()	{	
	 	 //	TODO	Auto-generated	method	stub
	 }
}
Uma classe abstrata pode conter apenas métodos abstratos, 
concretos ou ambos. A presença de um método abstrato torna, 
obrigatoriamente, a classe abstrata também [Java Starter]. Se 
lembrarmos um pouco das interfaces, perceberemos que as interfaces 
são como classes totalmente abstratas (todos os métodos da interface 
devem ser implementados). No entanto, vale lembrar que as classes 
abstratas são uma espécie de modelo para a codificação de classes 
concretas, enquanto que as interfaces contém somente as assinaturas 
dos métodos. Assim, quando quisermos definir a estrutura (variáveis, 
constantes, etc) e comportamentos básicos (regras e a maneira como 
os objetos devem realizar determinados tipos de comportamento), 
devemos definir classes abstratas. Se só estivermos preocupados 
em criar a forma como objetos devem realizar determinadas ações 
(métodos) devemos optar por interfaces.
Outro modificador bastante utilizado é o final. De certa forma, o 
modificador final tem o objetivo inverso do abstract, como veremos 
abaixo.
Modificador final
O modificador final quando utilizado em classes ou métodos 
bloqueia, respectivamente, a extensão e a sobrescrita, isto é, 
utilizamos este modificador quando não desejamos que nossa 
classe tenha subclasses ou o método seja sobrescrito [Java Starter]. 
Um método que é declarado final não pode ser redefinido em uma 
subclasse. Os métodos que são declarados static e private são 
implicitamente final [DEITEL, 2005]. Assim como os métodos, as 
classes que são declaradas final não podem ser superclasses (ou 
seja, uma classe final não pode ser herdada).
Lembrete
Devido às suas 
características o 
modificador final 
deve ser utilizado 
com cuidado e 
sabedoria pois 
ele vai contra 
um dos pilares 
da orientação a 
objetos: o reuso 
de código através 
da herança e/ou 
sobrescrita [Java 
Starter].
12
Modelagem Orientada a Objetos
Vamos visualizar um exemplo do modificador final em código? 
Tomemos como exemplo, mais uma vez, a classe Funcionario e suas 
subclasses.
public final class Diretor extends Funcionario {
 public void demitirFuncionario(){ 
 //colocar aqui o código do método
 }
 public void contratarFuncionario(){ 
 //colocar aqui o código do método
 }
 public void baterPonto(){ 
 System.out.println(“Diretor bateu o ponto”);
 }
}
Ao adicionarmos o modificador final na classe Diretor, estamos 
assumindo que esta classe (Diretor) não pode ser herdada (ser 
superclasse). Contudo, isto não tem impacto algum na superclasse. 
Lembram que a superclasse sequer tem conhecimento sobre 
suas subclasses? E se quiséssemos modificar apenas um/alguns 
método(s)?
public class Diretor extends Funcionario {
 public void demitirFuncionario(){ 
 //colocar aqui o código do método
 }
 public void contratarFuncionario(){ 
 //colocar aqui o código do método
 }
 public final void baterPonto(){ 
 System.out.println(“Diretor bateu o ponto”);
 }
}
Neste outro exemplo, a classe Diretor poderia ser estendida (ser 
superclasse de alguma subclasse, ser herdada), mas o método 
baterPonto() não poderia ser sobrescrito. Como uma classe abstrata 
13
Modelagem Orientada a Objetos
pode ter métodos concretos, isto garante que o método implementado 
na classe sempre funcionará com o comportamento da superclasse. A 
classe seria herdada, mas o método não. Quando você for utilizar, se 
for utilizar, o modificador final pense sempre nas implicações e nos 
objetivos que espera obter com o seu uso. 
Conheça Mais
Aprofunde seus conhecimentos sobre classes abstratas. Consulte 
outras fontes de informação na internet e os livros indicados neste 
volume. Ao encontrar boas fontes de leitura, compartilhe este novo 
conhecimento com os demais colegas de sala. Compartilhe também 
os códigos que anda encontrando e desenvolvendo, desta forma 
aprenderemos de maneira mais fácil e ágil. É importante que você 
complemente os estudos deste capítulo com a leitura do capítulo 8 do 
livro de DEITEL. Bons estudos!
Excelente material em PDF:
http://www.t2ti.com/java_starter/modulos/Java_Basico_Modulo_08.pdf
Tutorial genérico, que discute bem as classes abstratas
http://javafree.uol.com.br/artigo/871497/
Material sobre classes (concretas e abstratas) do prof. Waldeck
http://www.dm.ufscar.br/~waldeck/curso/java/part27.html
Aprenda Praticando
Vamos agora representar os Eletrodomésticos através da POO. 
Pensemos ainda na relação entre TV e Rádio com esta classe. Para 
demonstrar, usaremos uma classe abstrata chamada Eletrodomestico, 
que servirá de modelo para todos os objetos que possam ser 
eletrodomésticos.
package classeAbstrata;
public abstract class Eletrodomestico {
 private boolean ligado; 
 private int voltagem;
14
Modelagem Orientada a Objetos
 // métodos abstratos //
 /*
 * não possuem corpo, da mesma forma que
 * as assinaturas de método de uma interface
 */
 public abstract void ligar();
 public abstract void desligar();
 // método construtor //
 /*
 * Classes Abstratas também podem ter métodos 
 * construtores, porém, não podem ser usados para
 * instanciar um objeto diretamente
 */
 public Eletrodomestico(boolean ligado, int voltagem) { 
 this.ligado = ligado;
 this.voltagem = voltagem;
 }
 // métodos concretos
 /*
 * Uma classe abstrata pode possuir métodos não abstratos 
 */
 public void setVoltagem(int voltagem) {
 this.voltagem = voltagem;
 }
 public int getVoltagem() {
 return this.voltagem;
 }
 public void setLigado(boolean ligado) {
 this.ligado = ligado;
 }
15
Modelagem Orientada a Objetos
 public boolean isLigado() {
 returnligado;
 }
}
Como podemos observar, criamos um modelo de classe que 
compreende a uma gama enorme de outros objetos. Isto é o que 
buscamos com a POO, não é mesmo? Desta forma poderemos 
aplicar o conceito de herança.
Note que agora, qualquer objeto que derivar desse modelo deve 
ter sua voltagem especificada e dizer se está ligado ou não.
Vamos agora pensar em outras classes que herdem as 
características da classe abstrata.
A primeira é a classe TV:
package classeAbstrata;
public class TV extends Eletrodomestico {
 private int tamanho;
 private int canal;
 private int volume;
 public TV(int tamanho, int voltagem) {
 super (false, voltagem); //construtor classe abstrata 
 this.tamanho = tamanho;
 this.canal = 0;
 this.volume = 0;
 }
 /* implementação dos métodos abstratos */
 public void desligar() {
 super.setLigado(false);
 setCanal(0);
 setVolume(0);
 }
 public void ligar() {
16
Modelagem Orientada a Objetos
 super.setLigado(true);
 setCanal(3);
 setVolume(25);
 }
 //abaixo teríamos todos os métodos construtores
 //get e set...
}
E agora veremos uma outra classe. A classe Radio.
package classeAbstrata;
public class Radio extends Eletrodomestico {
 public static final short AM = 1;
 public static final short FM = 2;
 private int banda;
 private float sintonia;
 private int volume;
 public Radio(int voltagem) {
 super(false, voltagem);
 setBanda(Radio.FM);
 setSintonia(0);
 setVolume(0);
 }
 /* implementação dos métodos abstratos */
 public void desligar() {
 super.setLigado(false);
 setSintonia(0);
 setVolume(0);
 }
 public void ligar() {
 super.setLigado(true);
 setSintonia(88.1f);
17
Modelagem Orientada a Objetos
 setVolume(25);
 }
 // abaixo teríamos todos os métodos construtores
 // get e set...
}
Como podemos notar, temos duas classes totalmente diferentes 
que têm como base o mesmo modelo. Também é perceptível o fato 
de que em ambas as classes, os métodos abstratos ligar() e 
desligar() foram implementados, porém, não há a implementação 
dos outros métodos como setVoltagem() ou isLigado().
As classes abstratas servem de base para codificação de uma 
classe inteira, diferentemente das interfaces que são apenas 
assinaturas dos métodos. Quando temos que definir variáveis, 
constantes, regras, e pequenas ações definidas devemos usar classes 
abstratas. Mas, se formos apenas criar a forma como objetos devem 
realizar determinadas ações (métodos) devemos optar por interfaces.
Abaixo está uma classe que testa a funcionalidade dessas classes.
package classeAbstrata;
public class Main {
 public static void main(String[] args) {
 TV tv1 = new TV(29, 110);
 Radio radio1 = new Radio(110);
 /*
 * chamando os métodos abstratos implementados
 * dentro de cada classe (TV e Radio)
 */
 tv1.ligar();
 radio1.ligar();
 System.out.print(“A TV está “);
 if(tv1.isLigado()){
 System.out.println(“ligada”);
 } else {
18
Modelagem Orientada a Objetos
 System.out.println(“desligada”);
 }
 System.out.print(“e o Rádio está “);
 if(radio1.isLigado()){
 System.out.println(“ligado”);
 } else {
 System.out.println(“desligado”);
 }
 }
}
Atividades e Orientações de Estudo
Exercícios
Para estes exercícios, elaborem as respostas em um documento 
WORD e postem como atividade no ambiente para que os tutores 
revisem as respostas. A última questão deve ser postada também 
no fórum, para que todos tenham acesso às soluções dos demais 
colegas e discutam em conjunto.
1– Qual a diferença entre interface e classes abstratas? 
2– Faça uma diferenciação entre os métodos não-abstract e os 
métodos abstract.
3– É possível criar instâncias de classes abstratas? Justifique sua 
resposta.
4– Escreva um código orientado a objetos para representar 
diferentes tipos de veículos (carros, motos, aviões, barcos). 
A classe abstrata veículos deve possuir os métodos voar(), 
navegar(), dirigir(), pilotar(), frear(), acelerar() e buzinar(). O avião 
não tem buzina, o carro buzina “FOM FOM”, a moto buzina “BI 
BI” e o barco buzina “FOOOMMM”. O carro pode ainda buzinar 
seguidas vezes, quantas o motorista quiser (valor recebido por 
parâmetro). Identifique que métodos devem ser concretos e que 
métodos devem ser abstratos (justifique sua escolha através de 
19
Modelagem Orientada a Objetos
comentários inseridos no código). Considere os conceitos vistos 
durante o curso (encapsulamento, herança...), caso necessário 
aplicá-los. Sobrescreva e sobrecarregue os métodos que julgar 
necessário. Ao final, discuta sua solução com o tutor e colegas. 
Represente sua solução em UML, através do ArgoUML ou 
ASTAH1.
Atividade de Pesquisa
Em duplas, criem um quadro resumo falando das classes concretas, classes 
abstratas, interfaces e modificadores vistos durante o curso. Expliquem quando 
devemos utilizar cada um deles. As soluções devem ser postadas no fórum.
Exemplo: As classes concretas são utilizadas para ... . Estas classes podem ser 
instanciadas diretamente, não podem ter métodos ... , etc...
As interfaces possuem métodos que diferem dos métodos das classes concretas 
porque... Etc...
Vamos Revisar?
Resumo
Neste capítulo aprendemos sobre as classes abstratas. Vimos que estas classes 
não podem ser instanciadas, que são usadas para organizar características 
comuns a diversas subclasses e que são desenvolvidas para serem herdadas. 
Estas classes não possuem instâncias diretas, só indiretas. Vimos ainda que 
as classes abstratas podem definir métodos sem implementação, chamados 
abstratos e que classes concretas não podem ter métodos abstratos (senão 
viram classes abstratas). Por fim, aprendemos sobre o modificador de acesso 
final, que pode ser utilizado em métodos e em classes, mas que quando utilizado 
não permite sobrescrita/herança. Este modificador é importante para garantir 
integridade e segurança de dados.
Lembrete
1 ASTAH – http://
jude.change-
vision.com/jude-
web/index.html
20
Modelagem Orientada a Objetos
Capítulo 2
O que vamos estudar neste capítulo?
Neste capítulo, vamos estudar o seguinte tema:
» A Linguagem Java
Metas
Após o estudo deste capítulo, esperamos que você consiga:
» Compreender e utilizar melhor a linguagem Java;
21
Modelagem Orientada a Objetos
Capítulo 2 - A Linguagem Java
Vamos conversar sobre o assunto?
Olá, seja bem vindo(a) ao segundo capítulo do terceiro volume do 
curso de Modelagem Orientada a Objetos! 
Até aqui, nos nossos estudos sobre o paradigma Orientado a 
Objetos, já vimos o que é uma Classe, aprendemos também que um 
objeto nada mais é do que a instanciação de uma classe e que o 
encapsulamento e a hierarquia de classes são pilares da orientação 
a objetos. Estudamos ainda um pouco sobre a linguagem Java e a 
linguagem UML.
Neste capítulo nós iremos continuar nossos estudos sobre a 
programação Orientada a Objetos. Iremos agora aprofundar nossos 
conhecimentos sobre a linguagem Java. Aprenderemos mais sobre 
seus tipos de dados e sobre as estruturas condicionais e de repetição.
É importantíssimo que você busque outras fontes de aprendizado. 
Leia outros livros! Não se acomode às informações contidas neste 
volume. Consulte a referência [CAELUM] e os livros de [DEITEL, 
2005; DEITEL, 2006]. Participe do fórum de discussão, converse e 
discuta com seu tutor, professores e outros colegas de sala. Vamos 
lá...
A Linguagem Java
Vamos agora entender um pouco mais sobre a linguagem Java e 
sua sintaxe. Até o momento aprendemos bastante sobre o paradigma 
da orientação a objetos e agora vamos aprender mais sobre a 
linguagem Java, que é uma linguagem orientada a objetos. Alguns dos 
conceitos que veremos a seguir já foram vistos em outros volumes, 
em exemplos de códigos comentados.
Antes de vermos os tipos de dados suportados pela linguagem 
Java e suas estruturas de controle e repetição, vamos identificar as 
palavras reservadas desta linguagem (sintaxe) [SABINO, 2003].
22
Modelagem Orientada a Objetos
Modificadores de acesso
»Como já vimos em nosso Volume 1 os modificadores de acesso 
proveem permissões de acesso aos atributos e métodos das 
classes. Utilizados para encapsular dados.
 public: acesso a partir de qualquer classe
 private: acesso apenas dentro da própria classe
 protected: acesso por classes no mesmo pacote e subclasses
Exemplo:
public class Exemplos {
 private String nome;
 private int idade;
public String getNome() {
 return nome;
 }
 public void setNome(String nome) {
 this.nome = nome;
 }
 public int getIdade() {
 return idade;
 }
 public void setIdade(int idade) {
 this.idade = idade;
 }
 public static void main(String[] args) {
 System.out.println(“Exemplos de modificadores 
de acesso de atributos e métodos”);
 }
}
Modificadores de classes, variáveis ou métodos
» Alguns dos modificadores de classes, variáveis ou métodos 
23
Modelagem Orientada a Objetos
suportados pela linguagem Java foram vistos durante os 
volumes 1, 2 e neste terceiro volume. 
 abstract: classe que não pode ser instanciada ou método que 
precisa ser implementado por uma subclasse não abstrata
 class: especifica uma classe
 extends: indica a superclasse que a subclasse está estendendo
 final: impossibilita que uma classe seja estendida, que um 
método seja sobrescrito ou que uma variável seja reinicializada
 implements: indica as interfaces que uma classe irá 
implementar
 interface: especifica uma interface
 native: indica que um método está escrito em uma linguagem 
dependente de plataforma, como o C
 new: instancia um novo objeto, chamando seu construtor
 static: faz um método ou variável pertencer à classe ao invés 
de às instâncias
 strictfp: usado em frente a um método ou classe para indicar 
que os números de ponto flutuante seguirão as regras de ponto 
flutuante em todas as expressões
 synchronized: indica que um método só pode ser acessado 
por uma thread de cada vez
 transient: impede a serialização de campos
 volatile: indica que uma variável pode ser alterada durante o 
uso de threads
Exemplo:
public class Exemplos extends SuperClasseExemplos 
implements InterfaceExemplos{
 private String nome;
 private int idade;
 //atributo com modificadores static e final
 private static final double PI = 3.14;
 public String getNome() {
24
Modelagem Orientada a Objetos
 return nome;
 }
 public void setNome(String nome) {
 this.nome = nome;
 }
 public int getIdade() {
 return idade;
 }
 public void setIdade(int idade) {
 this.idade = idade;
 }
 public final void metodoComFinal(){
 //nao poderia ser herdado
 //possui modificador final
 }
 public static void main(String[] args) {
 //cria instancia da classe Exemplos
 Exemplos ex = new Exemplos();
 //imprime uma saída
 System.out.println(“Exemplos de modificadores de 
classe/atributos/métodos”);
 }
}
Controle de fluxo dentro de um bloco de código
» Algumas das palavras reservadas de controle de fluxo foram 
vistas durante os volumes 1, 2 e neste terceiro volume. As 
palavras reservadas para o controle de fluxos servem para a 
criação e controle de estruturas condicionais e de repetição 
(exemplos a seguir) Algumas palavras reservadas de Java tem 
o mesmo comportamento de palavras reservadas já estudadas 
durante a disciplina da linguagem C (switch, case, if, break, 
continue e return).
25
Modelagem Orientada a Objetos
 break: sai do bloco de código em que ele está
 case: executa um bloco de código dependendo do teste do 
switch
 continue: pula a execução do código que viria após essa linha 
e vai para a próxima passagem do loop
 default: executa esse bloco de código caso nenhum dos teste 
de switch-case seja verdadeiro
 do: executa um bloco de código uma vez, e então realiza um 
teste em conjunto com o while para determinar se o bloco 
deverá ser executado novamente
 else: executa um bloco de código alternativo caso o teste if seja 
falso
 for: usado para realizar um loop condicional de um bloco de 
código
 if: usado para realizar um teste lógico de verdadeiro o falso
 instanceof: determina se um objeto é uma instância de 
determinada classe, superclasse ou interface
 return: retorna de um método sem executar qualquer código 
que venha depois desta linha (também pode retornar uma 
variável)
 switch: indica a variável a ser comparada nas expressões case 
(semelhante ao que já estudamos em C)
 while: executa um bloco de código repetidamente até que uma 
certa condição seja verdadeira
Exemplo:
public class Exemplos {
 //declaração do método principal - main
 public static void main(String[] args) {
 /*declaração de uma estrutura de repeticao contada 
(FOR) que vai de 1 ate 50 e verifica se o numero MOD 5 é 
igual a 0 se o contador da estrutura MOD 5 for zero, o 
break é executado. Quando o break é executado, o FOR para 
de ser executado. A estrutura para de repetir e vai para 
a proxima linha do programa.*/
26
Modelagem Orientada a Objetos
 for (int i = 1; i < 50; i++) {
 if(i%5==0){
 break;
 }
 System.out.println(“Valor impresso 1o FOR = “ 
+ i);
 }
 /*declaração de uma estrutura de repeticao contada 
(FOR) que vai de 1 ate 50 e verifica se o numero MOD 5 
é igual a 0 se o contador da estrutura MOD 5 for zero, 
o continue é executado. Quando o continue é executado, 
o FOR pula da instrução de continue para o inicio da 
estrutura de repeticao. Em outras palavras, se o i (que 
é o contador) for igual a 5 (5 MOD 5 == 0), o comando 
continue será executado. Neste momento, a linha seguinte 
a ser executada será o FOR com o i = 6. O system out nao 
será executado.*/
 for (int i = 1; i < 50; i++) {
 if(i%5==0){
 continue;
 }
 System.out.println(“Valor impresso 2o FOR = “ 
+ i);
 }
 //declaracao de um atributo i (os outros atributos
 //utilizados nos FOR eram atributos locais e não
 //são visiveis fora das estruturas
 int i = 10;
 /*Estrutura de repetição condicional. Repetirá 
enquanto a condição for verdadeira. Neste caso, o i começa 
em 10. 10 MOD 3 nao é igual a 0, pois este MOD tem resto. 
Entao o break nao será executado quando o i for igual 
a 10. O valor 10 será impresso, o i será decrementado 
e o while rodará novamente. Nesta nova execucao, com 
i == 9, o MOD será 0. O MOD sendo = 0, o break será 
executado. Quando o break for executado, o programa irá 
27
Modelagem Orientada a Objetos
executar a linha seguinte após a estrutura de repetição, 
saindo da repeticao. Neste caso, sequer o system out será 
executado. */
 while(i>1){
 if(i%3==0){
 break;
 }
 System.out.println(“Valor impresso WHILE == “ 
+ i);
 i--;
 }
 //volta o valor de i para 10
 i = 10;
 /*Estrutura de repetição condicional. Repetirá 
enquanto a condição for verdadeira. Neste caso, o i 
começa em 10. 10 MOD 5 é igual a 0, pois este MOD nao 
tem resto. Ao entrar no condicional (pois a operação com 
o MOD resultará em uma resposta true), o continue será 
executado. O continue ira executar novamente o inicio do 
while, sem imprimir o valor do atributo e sem decrementar 
seu valor. Qual o resultado disto? A aplicação entrará em 
loop.*/
 while(i>1){
 if(i%5==0){
 continue;
 }
 System.out.println(“Valor impresso WHILE == “ 
+ i);
 i--;
 }
 /**
 * Um excelente exercício é refazer estes exemplos 
 * em seu Eclipse. Execute e entenda cada uma das
 * instruções aqui comentadas.
28
Modelagem Orientada a Objetos
 */
 }
}
Tratamento de erros
» O tratamento de erros ou exceções permite detectar erros 
e manipular esses erros, ou seja, tratá-los. Este assunto não 
foi tratado durante esta disciplina, mas você pode aprender a 
respeito em: http://www.fundao.wiki.br/articles.asp?cod=172 e http://
camilolopes.wordpress.com/2009/02/04/tratamento-de-excecoes-em-java/. 
 assert: testa uma expressão condicional para verificar uma 
suposição do programador
 catch: declara o bloco de código usado para tratar uma exceção
 finally: bloco de código, após um try-catch,que é executado 
independentemente do fluxo de programa seguido ao lidar com 
uma exceção
 throw: usado para passar uma exceção para o método que o 
chamou
 throws: indica que um método pode passar uma exceção para 
o método que o chamou
 try: bloco de código que tentará ser executado, mas que pode 
causar uma exceção
Controle de pacotes
 import: importa pacotes ou classes para dentro do código
 package: especifica a que pacote todas as classes de um 
arquivo pertencem
Tipos de Dados Primitivos
» São 8 os tipos de dados primitivos suportados em Java
 boolean: um valor indicando verdadeiro ou falso
 byte: um inteiro de 8 bits (signed)
 char: um caracter unicode (16-bit unsigned)
 double: um número de ponto flutuante de 64 bits (signed)
29
Modelagem Orientada a Objetos
 float: um número de ponto flutuante de 32 bits (signed)
 int: um inteiro de 32 bits (signed)
 long: um inteiro de 64 bits (signed)
 short: um inteiro de 32 bits (signed)
Variáveis de referência
 super: refere-se a superclasse imediata
 this: refere-se a instância atual do objeto
Retorno de um método
 void: indica que o método não tem retorno
Palavras reservadas não utilizadas
 const: Não utilize para declarar constantes; use public static 
final
 goto: não implementada na linguagem Java por ser considerada 
prejudicial
Literais reservados
De acordo com a Java Language Specification2, null, true e 
false são tecnicamente chamados de valores literais, e não palavras 
reservadas Se você tentar criar algum identificador com estes nomes, 
você também terá um erro de compilação.
Tipos de Dados
Java é uma linguagem que possui oito tipos de dados primitivos3, 
conforme apresentado na Tabela 1 e na Tabela 2.
Hiperlink
2 Java Language 
Specification 
- http://java.sun.
com/docs/books/
jls/
Lembrete
3 Tipos de Dados 
Primitivos – são 
tipos de dados 
mais simples, 
não objetos.
30
Modelagem Orientada a Objetos
Tabela 1. Tipos de dados Java 
 
Tipo de Dados Tamanho
boolean 1 bit
byte 1 byte
short 2 bytes
char 2 bytes
int 4 bytes
float 4 bytes
long 8 bytes
double 8 bytes
Tabela 2. Descrição dos tipos de dados primitivos de Java 
 
Tipo Descrição
boolean Valores true ou false
char
Caractere em notação Unicode de 16 bits. Armazena dados 
alfanuméricos. Também pode ser usado como um dado inteiro com 
valores na faixa entre 0 e 65535.
byte Inteiro de 8 bits em notação de complemento de dois. Pode assumir valores entre -27 = -128 e 27 -1 = 127
short Inteiro de 16 bits em notação de complemento de dois. Os valores possíveis cobrem a faixa de -2-15 = -32.768 a 215 -1 = 32 .767
int Inteiro de 32 bits em notação de complemento de dois. Pode assumir valores entre -231 = 2.147.483.648 e 231 -1 = 2.147.483.647.
long Inteiro de 64 bits em notação de complemento de dois. Pode assumir valores entre -263 e 263-1
float
Representa números em notação de ponto flutuante normalizada em 
precisão simples de 32 bits em conformidade com a norma IEEE 
754-1985. O menor valor positivo representável por esse tipo é 
1.40239846 e -46 e o maior é 3.40282347 e +38
double
Representa números em notação de ponto flutuante normalizada em 
precisão dupla de 64 bits em conformidade com a norma IEEE 754-
1985. O menor valor positivo representável é 4.94065645841246544 
e o maior é 1.7976931348623157 e +308
Utilizando os Tipos de Dados
Podemos declarar variáveis dentro e fora de métodos da classe. 
As variáveis que são declaradas fora dos métodos têm escopo global, 
31
Modelagem Orientada a Objetos
e podem ser acessadas a partir de qualquer local da classe. Já as 
variáveis que são declaradas dentro dos métodos têm escopo local, 
ou seja, são acessadas apenas dentro dos métodos em que foram 
declaradas (visibilidade restrita). Vale lembrar que em Java, todas as 
variáveis são declaradas da seguinte maneira:
tipoDaVariavel nomeDaVariavel;
Independente do tipo da variável ser de um tipo primitivo ou ser um 
objeto (uma classe que tenhamos criado, por exemplo), toda variável 
é declarada da mesma forma. 
Vamos a um exemplo:
public class Funcionario {
 private String depto; 
 private double salario; 
 private double beneficio;
 public double getBeneficio() { 
 return beneficio;
 }
 public void setBeneficio(double beneficio) { 
 this.beneficio = beneficio;
 }
 public String getDepto() { 
 return depto;
 }
 public void setDepto(String depto) { 
 this.depto = depto;
 }
 public double getSalario() { 
 return salario;
 }
 public void setSalario(double salario) { 
 double salarioNovo = salario *10; 
 this.salario = salario;
 }
 public void escreverRelatorioMensal(){
32
Modelagem Orientada a Objetos
 //colocar aqui o código do método
 }
}
Na classe Funcionário, podemos notar a criação de três variáveis 
globais (declaradas no escopo da classe), de nomes depto (do 
tipo String, por lidar com nomes de departamentos), salario (do 
tipo double, por manipular valores reais) e beneficio (também do 
tipo double, como o atributo salário, por também manipular valores 
reais. Se olharmos o método getBeneficio(), perceberemos que este 
método retorna o valor contido em uma variável de nome beneficio, 
do tipo double. Esta variável foi declarada na classe e por isto possui 
visibilidade global. Por este motivo, ela pode ser acessada dentro dos 
métodos, mesmo sem ter sido declarada dentro deles.
No exemplo do método setBeneficio(double), percebemos algo 
diferente. Em Java, a atribuição é feita através do comando =. Dentro 
do método há a seguinte atribuição this.beneficio = beneficio. O que 
este comando nos diz? A palavra reservada this, como já visto em 
volumes anteriores, se refere a uma variável da classe. Portanto, este 
comando de atribuição está simplesmente atribuindo o valor recebido 
por parâmetro (variável local) a uma variável da classe (variável 
global). Por conta desta atribuição no método setBeneficio(double), 
o método getBeneficio() terá o valor da variável beneficio atualizado.
Ainda na classe Funcionário, se analisarmos o método 
setSalario(double) perceberemos a criação de uma nova variável 
local, de nome salarioNovo. Esta variável, do tipo double, é visível 
apenas dentro do método setSalario(double) (assim como o valor, 
recebido por parâmetro). Esta variável tem escopo local. Se tentarmos 
acessar a variável salarioNovo fora do método, teremos um erro de 
compilação (porque outros métodos não têm conhecimento sobre ela, 
não sabem que ela existe).
Caso quiséssemos criar um objeto do tipo Funcionário, a 
declaração seria feita da seguinte maneira:
Funcionario funcionário;
O primeiro nome se refere à classe Funcionário, que é um tipo 
de variável (objeto). O segundo funcionário é simplesmente o 
identificador, o nome da variável.
Os tipos de dados primitivos e os objetos definidos pelo 
33
Modelagem Orientada a Objetos
desenvolvedor ou já disponíveis pela biblioteca Java (String, por 
exemplo) podem ser utilizados como tipos de retornos em métodos, 
como parâmetros em métodos e construtores e nas estruturas 
condicionais e de repetição do Java. 
Exemplo:
//método com tipo de retorno int
 public int getCodigo() { 
 return codigo;
 }
 //método com parâmetro int
 public void setCodigo(int codigo) { 
 this.codigo = codigo;
}
Casting
Alguns valores são incompatíveis se tentarmos fazer uma 
atribuição direta. Se tentarmos atribuir um valor double (real) a uma 
variável int não conseguiremos [CAELUM]. Isto não é permitido 
porque, conforme apresentado na Tabela 1, um integer é um tipo de 
dado menor que um double. Ao tentarmos guardar um valor double 
em um integer, teríamos que admitir a perda de valores (visto que 
um double é maior que um inteiro). Por conta desta perda, Java não 
permite a conversão direta dos valores. Para compreender melhor, 
vamos a alguns exemplos.
 public static void main(String[] args) {
 int valorInteiro = 10; 
 double valorReal = 5.5;
 //aqui teríamos erro de compilação
 valorInteiro = valorReal;
 //as demaisatribuições estão corretas e seriam
 //permitidas
 valorReal = valorInteiro; 
 valorInteiro = (int)valorReal;
 }
34
Modelagem Orientada a Objetos
No código acima, criamos duas variáveis (valorInteiro e valorReal): 
uma de valor inteiro e outra de valor double. A primeira atribuição, 
onde tentamos atribuir um valor real (double) em uma variável do 
tipo inteiro (int) não seria permitida (pelos motivos explicados acima). 
O compilador acusaria erro. No segundo caso, uma variável do tipo 
real poderia receber o valor contido em uma variável do tipo inteiro 
sem problemas. Isto porque um double tem tamanho suficiente para 
receber valores do tipo inteiro. Por fim, na última atribuição do método 
main chegamos ao Cast. Caso o desenvolvedor entenda o que está 
fazendo, ele pode assumir os riscos de atribuir uma variável de um 
tipo maior em uma variável de um tipo menor. No exemplo, temos um 
valor inteiro recebendo um valor do tipo real. Neste caso, o compilador 
trunca o valor real para que este valor possa ser adicionado a 
um inteiro. Isto foi possível por conta do cast. Um cast informa ao 
compilador que o desenvolvedor entende os riscos da atribuição. Por 
conta disto, o compilador permite a atribuição. O único tipo primitivo 
que não pode ser atribuído a nenhum outro tipo é o boolean.
Na Tabela 3, estão relacionados todos os casts possíveis na 
linguagem Java, mostrando a conversão de um valor para outro. A 
indicação Impl. quer dizer que aquele cast é implícito e automático, 
ou seja, você não precisa indicar o cast explicitamente (lembrando 
que o tipo boolean não pode ser convertido para nenhum outro tipo) 
[CAELUM].
Tabela 3. Castings possíveis [CAELUM] 
 
PARA:
byte short char int long float double
DE:
byte - - - - - Impl. (char) Impl. Impl. Impl. Impl.
short (byte) - - - - - (char) Impl. Impl. Impl. Impl.
char (byte) (short) - - - - - Impl. Impl. Impl. Impl.
int (byte) (short) (char) - - - - - Impl. Impl. Impl.
long (byte) (short) (char) (int) - - - - - Impl. Impl.
float (byte) (short) (char) (int) (long) - - - - - Impl.
double (byte) (short) (char) (int) (long) (float) - - - - -
Agora que aprendemos sobre os tipos de dados primitivos 
suportados em Java, vamos aprender um pouco mais sobre as 
estruturas condicionais e de repetição da linguagem no capítulo a 
seguir.
35
Modelagem Orientada a Objetos
Conheça Mais
Aprofunde seus conhecimentos sobre os tipos de dados primitivos 
suportados pela linguagem Java e os casts entre estes. Este 
conhecimento é muito importante para a manipulação de objetos (e 
seus casts), é complementar a toda a base que vimos de modelagem 
orientada a objetos.
Excelente material em PDF:
www.caelum.com.br - Apostila FJ-11. Java e Orientação a Objetos
Aprenda Praticando
Vamos agora identificar novos cenários de tipos de dados e seus 
casts.
public class Exemplos {
 public static void main(String[] args) {
 int valorInteiro = 10;
 double valorReal = 5.5;
 String nome = “Bob”;
 //aqui teríamos erro de compilação (caso nao 
 //fizéssemos o cast) com o cast, o valor double é 
 //truncado para que caiba em um atributo do tipo 
 //inteiro. Como mostrado na tabela 2, faremos um 
 //cast de double para int, por isso utilizamos o 
 //cast (int).
 valorInteiro = (int)valorReal;
 System.out.println(“Valor inteiro == 
“+valorInteiro);
 //as demais atribuições estão corretas e seriam
 //permitidas
36
Modelagem Orientada a Objetos
 valorReal = valorInteiro;
 valorInteiro = (int)valorReal;
 //agora lidando com String (cast entre um tipo de
 //dado primitivo e um objeto).
 /*O cast de valores numéricos para String pode ser
 * feito através da concatenação do valor com “”.
 * A utilização da aspas garante que o dado
 * manipulado é do tipo String, por isso, ao
 * concaternarmos um valor double ou int com um
 * String, estes tipos primitivos se tornam String. */ 
 nome = valorInteiro+””;
 System.out.println(“Nome == “ + nome);
 /*No caso de um cast de um objeto para um tipo 
 * primitivo, temos algumas APIs (bibliotecas) Java
 * de apoio. No caso de um cast de um objeto para um
 * inteiro, temos a biblioteca parseInt, dentro da
 * classe Integer. As APIs disponíveis podem ser
 * acessadas aqui: java.sun.com/javase/6/docs/api/ */
 valorInteiro = Integer.parseInt(nome);
 System.out.println(“Valor Inteiro == “ + 
valorInteiro);
 }
}
Atividades e Orientações de estudo
Exercícios
Para o código abaixo, siga as instruções comentadas dentro do 
código e realize as modificações solicitadas (crie um novo projeto 
Java no Eclipse, adicione uma nova classe de nome Funcionario a 
37
Modelagem Orientada a Objetos
este projeto, e utilize este código como o código inicial da classe). 
Com este exercício praticaremos conceitos de encapsulamento e 
manipulação de dados (inclusive com casts). 
import javax.swing.JOptionPane;
public class Funcionario {
 private int codigo; 
 private String cpf; 
 private String nome; 
 private int idade; 
 private double salario;
 //crie os métodos SET e GET para manipular os atributos
 //encapsulados da classe
 public static void main(String[] args) {
 //crie uma instancia da classe para acessar os
 //métodos (fora do main) da classe
 /* utilize a função
 * JOptionPane.showInputDialog(Object) para ler
 * dados de entrada (digitados pelo usuário) para
 * os atributos. exemplo: JOptionPane.showInputDialog
 * (“Digite um cpf”); O valor digitado pelo usuario,
 * para cada um dos atributos existentes, deve ser 
 * armazenado nestes através de chamadas realizadas 
 * aos métodos SET correspondentes. Se voce leu um 
 * CPF, deve chamar o método setCpf, de dentro do
 * método main, fornecendo o valor do cpf que foi
 * lido. Alguns casts serão necessários. */
 /*
 * crie um método de nome castDoubleInt(double), 
 * que recebe um valor double como parametro.
 * realize uma chamada, a partir do método main, a 
 * este método, passando o salario como parametro.
 * dentro do método que voce criou (castDoubleInt),
38
Modelagem Orientada a Objetos
 * realize o cast de salario para um valor inteiro
 * e retorne o resultado (inteiro).
 * Imprima este valor no método main.
 */
 }
}
Este exercício deve ser entregue no ambiente para que seja 
corrigido e discutido pelo tutor. Em caso de dificuldades, lembre 
sempre de participar no fórum. Conte sempre com a ajuda de outros 
colegas e de seu tutor/professor. Nosso curso é a distância. É muito 
importante a sua participação.
Vamos Revisar?
Resumo
Neste capítulo você conheceu um pouco mais sobre a linguagem Java. Vimos 
os tipos de dados primitivos suportados pela linguagem, como e quando realizar 
Casts. A partir de agora, com este conhecimento, aprofundaremos ainda mais os 
conceitos sobre a linguagem Java.
39
Modelagem Orientada a Objetos
Capítulo 3
O que vamos estudar neste capítulo?
Neste capítulo, vamos estudar o seguinte tema:
» Java: Estruturas condicionais, estruturas de repetição e arrays.
Metas
Após o estudo deste capítulo, esperamos que você consiga:
» Compreender e utilizar melhor a linguagem Java;
40
Modelagem Orientada a Objetos
Capítulo 3 - Java: Estruturas 
condicionais, estruturas de 
repetição e arrays
Vamos conversar sobre o assunto?
Olá, seja bem vindo(a) ao terceiro capítulo do terceiro volume do 
curso de Modelagem Orientada a Objetos! 
Até aqui, nos nossos estudos sobre o paradigma Orientado a 
Objetos, já vimos o que é uma classe, o que é um objeto, vimos os 
conceitos de encapsulamento e hierarquia de classes. Estudamos 
ainda um pouco sobre a linguagem ML e neste volume estamos 
aprendendo mais sobre a linguagem Java.
Neste capítulo nós iremos aprofundar nossos conhecimentos 
sobre a linguagem Java. Aprenderemos mais sobre suas estruturas 
condicionais e de repetição, e sobre os as estruturas de dados 
homogêneos multidimensionais - arrays.
É importantíssimo que você busque outrasfontes de aprendizado. 
Leia outros livros! Não se acomode às informações contidas neste 
volume. Consulte a referência [CAELUM] e os livros de [DEITEL, 
2005; DEITEL, 2006]. Participe do fórum de discussão, converse e 
discuta com seu tutor, professores e outros colegas de sala. Vamos 
lá... 
Estruturas Condicionais
Como já vimos na disciplina de introdução a algoritmos, as 
estruturas condicionais são estruturas que operam em função de 
uma condição verdadeira ou falsa. Uma condicional (estrutura IF ou 
comandos de repetição while ou do-while) precisa, obrigatoriamente, 
de um valor que seja verdadeiro ou falso. Este valor pode ser obtido 
através de uma operação de comparação (>, <, >=, <=) ou de um 
booleano (variável que possui valor verdadeiro ou falso). Em Java, a 
estrutura condicional IF possui a seguinte sintaxe, e pode ser simples 
ou composta, como mostram os exemplos abaixo:
41
Modelagem Orientada a Objetos
Estrutura condicional simples
» Estrutura condicional simples se preocupa apenas com a 
condição verdade. Caso a condição seja verdadeira, executar 
o que está dentro do bloco. Caso a condição seja falsa, não 
executar o que está dentro do bloco. O programa segue a 
execução após o bloco do condicional (após o delimitador do if, 
a chave fechada).
if (condição){
 //caso a condição seja verdadeira, este bloco (o bloco
 //está delimitado entre a chave aberta e a chave 
 //fechada) é executado
}
Exemplo:
 private int velocidadeAtual = 60;
 private boolean estaCorrendo = false;
//codigos…
 private void acelerar(){
 if (velocidadeAtual <=60){
 velocidadeAtual++;
 estaCorrendo = true;
 }
 }
 private void frear(){
 if (estaCorrendo){ 
 velocidadeAtual--;
 }
 }
//codigos…
Estrutura condicional composta
Este tipo de estrutura lida com os dois possíveis cenários de 
condição. Caso a condição seja verdadeira, executar o que está 
42
Modelagem Orientada a Objetos
dentro do bloco. Caso a condição seja falsa, executar o bloco else 
do IF. Perceba que sempre, para o caso de uma estrutura condicional 
composta, um dos blocos e somente um, obrigatoriamente será 
executado. Ou a condição é verdade ou falsa.
if(condicao){
//se for verdade, execute este bloco 
}else{
//se for falso, execute este bloco 
}
Exemplo:
 private int velocidadeAtual = 60;
 private boolean estaCorrendo = false;
//codigos…
 private void acelerar(){
 if (velocidadeAtual <=60){
 velocidadeAtual++;
 estaCorrendo = true;
 } else {
 //carro não acelera pois percebe que
 //já está correndo. Limite de 60km/h.
 estaCorrendo = true;
 }
 }
 private void frear(){
 if (estaCorrendo){ 
 velocidadeAtual--;
 }
 }
//codigos…
Podemos também, como já vimos em períodos anteriores, agrupar 
vários condicionais. O tipo de estrutura resultante é chamado de 
43
Modelagem Orientada a Objetos
Estrutura condicional composta aninhada. Estrutura condicional 
composta aninhada agrupa diversos condicionais. Apenas um dos 
blocos é executado.
if (condicao){
} else if (condicao){
} else if (condicao){
} else{
}
Exemplo:
if (idade > 0 && idade<=5){
//nadador pre-mirim
}else if (idade >5 && idade <=10){
//nadador mirim
}else if (idade>10 && idade <=17){
//nadador juvenil
}else if (idade>=18){
//nadador adulto
}else if (idade <0){
//idade invalida
}
Note que neste último exemplo, um novo operador surgiu. O && é 
o operador lógico E do Java. O || é o operador lógico OU. Percebam 
que estes operadores fornecem respostas do tipo lógicas (verdadeiras 
ou falsas), em acordo com as estruturas condicionais.
Conforme já dito no início desta seção, as estruturas condicionais 
podem ter em suas cláusulas tipos de dados booleanos (o próprio 
atributo, que possui valor unicamente verdadeiro ou falso). Vamos a 
mais um exemplo:
 public static void main(String[] args) {
 //atributo que vai checar se um usuario é maior de
 //idade ou nao
 boolean maiorIdade = false;
44
Modelagem Orientada a Objetos
 //atributo que guarda valor da idade
 int idade = 18;
 if (idade >=18){
 maiorIdade = true;
 }
 if (maiorIdade){
 System.out.println(“O usuário é maior de 
idade”);
 }
 }
Neste exemplo, temos uma variável do tipo boolean que é avaliada 
diretamente dentro de uma cláusula de IF. Se maiorIdade possuir um 
valor true, o bloco do condicional será executado. Caso o valor seja 
false, por se tratar de uma estrutura condicional simples (sem else), 
nada será feito.
As estruturas condicionais são também utilizadas pelas estruturas 
de repetição condicionais, que executam determinado trecho de 
código com base no resultado da condicional. Vamos agora entender 
um pouco mais sobre o funcionamento destas estruturas em Java.
Estruturas de Repetição
Como também já vimos na disciplina de introdução a algoritmos, 
as estruturas de repetição podem ser de dois tipos: condicional ou 
contada. A seguir, vamos conhecer cada uma delas em Java.
A estrutura de repetição condicional WHILE repete o código que 
está dentro do bloco da estrutura de repetição enquanto a condição 
for verdadeira. A checagem da condição é feita no início da estrutura, 
ou seja, sempre antes da execução do bloco de código. Desta forma, 
o bloco de código da estrutura pode ser executado ou não. Para 
relembrar, apresentamos abaixo a estrutura while.
while (condicao){
//executar enquanto a condicao for verdadeira
}
Exemplo:
45
Modelagem Orientada a Objetos
int contador = 0;
while(contador < 50){
 System.out.println(“Contador == “ + contador);
 contador = contador + 1;
}
No entanto, às vezes é útil termos uma estrutura condicional 
que teste a condição só ao final – isto é, execute primeiro o bloco 
de código e depois cheque a condição. Nestes casos, podemos 
utilizar a estrutura de repetição condicional DO-WHILE, que repete o 
código que está dentro do bloco da estrutura de repetição enquanto 
a condição for verdadeira. A checagem da condição é feita no fim da 
estrutura, desta forma, o bloco de código da estrutura é executado 
pelo menos uma vez. Abaixo apresentamos a estrutura e um exemplo 
de sua utilização.
do{
//executar enquanto a condição for verdadeira
}while (condição);
Exemplo:
int contador = 0;
do{
System.out.println(“Contador == “ + contador);
//operador unário, equivalente a contador = contador + 1;
contador++;
}while(contador <50);
No caso das estruturas while e do-while, não podemos ter certeza 
de quantas vezes o bloco de código da estrutura será executado 
(porque dependem de uma condição). Quando precisamos que o 
bloco seja executado um número determinado/conhecido de vezes, a 
melhor opção é utilizar uma estrutura contada, como a estrutura FOR. 
Esta estrutura repete de maneira contada o código que está dentro do 
bloco da estrutura de repetição. Esta é a única estrutura de repetição 
que conseguimos saber com precisão quantas vezes será repetida. 
Nas estruturas condicionais não temos como prever o número de 
loops porque estes dependem de uma condição que varia durante a 
execução do código.
46
Modelagem Orientada a Objetos
for (inicializacao; condicao; incremento) {
//codigo;
}
Exemplo:
for (int i = 0; i < 50; i++) {
System.out.println(i);
}
Note que a variável da estrutura de repetição pode ser declarada 
dentro da própria estrutura. Esta é uma variável local que só existe 
durante a execução da estrutura (mas a estrutura poderia se utilizar 
de uma outra variável, local ou global, já declarada anteriormente). 
Como já aprendemos nas disciplinas de introdução aos algoritmos 
e introdução a C, utilizamos bastante as estruturas de repetição 
contada para a manipulação de estruturas de dados. Daremos 
continuidade a nossos estudos aprendendo um pouco mais sobre 
estas estruturas em Java.
Estruturas de Dados - Arrays
Os arrays são estruturas de dados que consistem em itens de 
dados relacionados do mesmo tipo. Arrays são estruturas “estáticas” 
no sentido de que, uma vez criados, eles mantêm o mesmotamanho, 
embora uma referência de array possa ser reatribuída a um novo 
array de tamanho diferente [DEITEL, 2005].
Os arrays guardam em memória posições consecutivas de dados 
de um mesmo tipo, conforme apresentado na Figura 2 e Figura 3.
47
Modelagem Orientada a Objetos
funcionário [0] Eduardo
funcionário [1] Patrícia
funcionário [2] Isabella
funcionário [3] Rafael
funcionário [4] Renata
funcionário [5] Antonio
funcionário [6] Auricea
funcionário [7] Bruno
funcionário [8] Ana
Figura 2. Array de funcionários do tipo String
numeros [0] 10
numeros [1] 51
numeros [2] 7
numeros [3] -9
numeros [4] 100
numeros [5] 5018
numeros [6] 16
numeros [7] 0
numeros [8] 4
Figura 3. Array de números do tipo int
Os arrays demonstrados na Figura 2 e Figura 3 podem ser 
declarados em Java da seguinte maneira:
 String funcionarios[] = new String[9];
 int numeros[] = new int[9];
Perceba que o atributo funcionarios é declarado com os colchetes 
[ ] e depois é declarado o tamanho do array que deve ser alocado. 
Esta declaração poderia ser feita também da seguinte maneira:
String funcionarios[];
 funcionarios = new String[9];
48
Modelagem Orientada a Objetos
 int numeros[];
 numeros = new int[9];
Ainda tomando os arrays funcionarios e numeros como exemplo, 
poderíamos, através das manipulação dos índices (vale ressaltar que 
neste caso estamos tratando ainda de arrays unidimensionais, pois 
temos apenas um índice), realizar operações aritméticas, atribuições, 
etc. Vamos ver alguns exemplos com o vetor de inteiros, identificado 
como ‘numeros’:
public class Exercicio01 {
 public static void main(String[] args) {
 //declaração do array unidimensional de nome
 // numeros, do tipo inteiro
 int numeros[] = new int[9];
 //estrutura de repetição que varrerá todo o array, 
 // populando-o. note aqui o uso do .length. esta 
 // função retorna o tamanho do array. neste caso o 
 // tamanho é 10, pois o array vai do indice 0 ao 
 // indice 9.
 for (int i = 0; i < numeros.length; i++) {
 //numeros[na posicao i] = receberá o valor de i 
 numeros[i] = i;
 }
 //numeros[na posicao 7 ou no indice 7] = receberá o 
 // valor inteiro 77
 numeros[7] = 77;
 //numeros[na posicao 3, que é o resultado da 
 // operação] = receberá o valor inteiro 33
 numeros[1+2] = 33;
 //numeros[na posicao 4, que é o resultado da 
 // operação] = receberá o valor inteiro 44
 numeros[2*2] = 44;
49
Modelagem Orientada a Objetos
 //estrutura de repetição que varrerá todo o array, 
 // para imprimi-lo
 for (int i = 0; i < numeros.length; i++) {
 //imprime os valores contidos no array, nas posicoes 
 // de 0 ate 9
 System.out.println(numeros[i]);
 }
 }
}
Os arrays podem ser passados como parâmetros para métodos, 
e podem ser utilizados também como tipos de retorno, conforme 
exemplo abaixo:
public class Exercicio01 {
 //metodo criado para imprimir arrays do tipo inteiro
 private void imprimeArray(int num[]){
 //estrutura de repetição que varrerá todo o array, 
 // para imprimi-lo
 for (int i = 0; i < num.length; i++) {
 //imprime os valores contidos no array, nas posicoes 
 // de 0 ate 9
 System.out.println(num[i]);
 }
 }
 public static void main(String[] args) {
 //instância da classe exercicio01
 Exercicio01 exerc = new Exercicio01();
 //declaração do array unidimensional de nome 
 // numeros, do tipo inteiro
 int numeros[] = new int[9];
 //estrutura de repetição que varrerá todo o array, 
50
Modelagem Orientada a Objetos
 // populando-o. note aqui o uso do .length. esta 
 // função retorna o tamanho do array. neste caso o 
 // tamanho é 10, pois o array vai do indice 0 ao 
 // indice 9.
 for (int i = 0; i < numeros.length; i++) {
 //numeros[na posicao i] = receberá o valor de i
 numeros[i] = i;
 }
 //numeros[na posicao 7 ou no indice 7] = receberá o 
 // valor inteiro 77
 numeros[7] = 77;
 //numeros[na posicao 3, que é o resultado da 
 // operação] = receberá o valor inteiro 33
 numeros[1+2] = 33;
 //numeros[na posicao 4, que é o resultado da 
 // operação] = receberá o valor inteiro 44
 numeros[2*2] = 44;
 //chamada ao método passando o array como parametro
 exerc.imprimeArray(numeros);
 }
}
Até o momento vimos arrays unidimensionais. Como sabemos, 
os arrays são estruturas de dados homogêneos, contudo, não 
obrigatoriamente devem ser unidimensionais. Podemos ter arrays 
multidimensionais. Vamos aprender um pouco mais sobre eles.
O tipo mais conhecido de array multidimensional são as matrizes 
(que, como você se lembra, são estruturas com linhas e colunas). 
Estes arrays (matrizes) são bidimensionais, pois trabalharemos 
com dois índices. Um índice representará as linhas e outro índice 
representará as colunas do array criado. A Figura 4 nos mostra um 
exemplo de matriz e como cada elemento desta seria identificado em 
um array de nome ‘numero’, bidimensional.
51
Modelagem Orientada a Objetos
coluna [0] coluna [1] coluna [2]
linha [0] numero [0] [0] numero [0] [1] numero [0] [2]
linha [1] numero [1] [0] numero [1] [1] numero [1] [2]
Figura 4. Array multidimensional
Os arrays bidimensionais têm sempre o primeiro índice se 
referindo a linha e o segundo índice se referindo a coluna da matriz. 
Esta ordem nunca é invertida. Você deve estar se perguntando, mas 
como eu declaro um array multidimensional? Vamos aos exemplos.
Vamos declarar um array de nome números:
int numeros[][] = new int[2][3];
Note que o array possui dois índices e que, para cada um, um 
tamanho é fornecido para que este seja alocado em memória. Neste 
exemplo de trecho de código, criamos um array com duas linhas e 
três colunas (como a matriz apresentada na Figura 4).
Poderíamos criar arrays com ainda mais índices, se assim fosse 
necessário:
int numero[][][] = new int [2][3][5];
Neste trecho de código, criamos 2 matrizes de 3 linhas e 5 
colunas. Temos uma estrutura tridimensional. Teríamos agora que 
nos preocupar com a manipulação sempre dos três índices. Neste 
fascículo focaremos nos arrays unidimensionais e nos bidimensionais, 
por serem os mais utilizados comumente.
Já vimos como declarar e como utilizar os arrays unidimensionais, 
mas e os bidimensionais? Como o nome já nos indica, teremos que 
nos preocupar sempre com dois índices, um que representa a linha e 
outro que representa a coluna. No array bidimensional, os dois índices 
representam um único elemento.
Vamos acompanhar agora um exemplo em código para facilitar o 
entendimento:
public class Exercicio02 {
 public static void main(String[] args) {
 //declaracao do array bidimensional
 int numeros[][] = new int[2][3];
52
Modelagem Orientada a Objetos
 //estrutura de repeticao para varrer as linhas
 for (int i = 0; i < numeros.length; i++) {
 //estrutura de repeticao para varrer as colunas
 for (int j = 0; j < numeros[i].length; j++) {
 numeros[i][j]= i+j;
 }
 }
 //estruturas de repetição contada aninhadas, para
 // imprimir o array bidimensional
 for (int i = 0; i < numeros.length; i++) {
 for (int j = 0; j < numeros[i].length; j++) {
 System.out.println(numeros[i][j]);
 }
 }
 
 }
}
Da mesma forma que o array unidimensional, os arrays 
multidimensionais podem ser utilizados como tipo de retorno ou como 
parâmetro em métodos. 
Agora que já aprendemos muitos fundamentos da linguagem 
Java, que tal praticarmos nossos conhecimentos? Em breve teremos 
um projeto para implementar, como forma de avaliação da disciplina. 
Vamos aproveitar este momento para praticar. É muito importante 
que todos acessem o fórum de discussões e esclareçam as dúvidas. 
Respondas as atividades sugeridas neste capítulo e a lista de 
exercícios que foi disponibilizada. Bons estudos!
Conheça Mais
Aprofunde seus conhecimentos sobre a linguagem Java. 
Consulte os livros de [DEITEL, 2005], [DEITEL, 2006] e a apostila da 
53
Modelagem Orientada a Objetos
[CAELUM]. Ao encontrar boas fontes de leitura, compartilheeste novo 
conhecimento com os demais colegas de sala. Compartilhe também 
os códigos que anda encontrando e desenvolvendo, desta forma 
aprenderemos de maneira mais fácil e ágil. Bons estudos!
http://www.guj.com.br
http://javafree.uol.com.br/forum.jbb
Conheça mais! Aproveite este momento!
Aprenda Praticando
Vamos agora revisar os conceitos vistos durante este volume? 
Neste exercício faremos uma revisão sobre as estruturas condicionais 
e estruturas de repetição da linguagem Java.
Imprima os fatoriais de 1 a 13.
public class Exercicio01 {
 public static void main(String[] args) {
 //atributo que terá o valor do fatorial
 int fatorial = 1;
 //estrutura de repetição contada - calcular 13
 //fatoriais
 for (int i = 1; i <= 13; i++) {
//checa se o fatorial é diferente de 1, porque o fatorial 
//de 1 é 1, não precisa ser calculado.
 if(i!=1){
 //se o fatorial é diferente de 1, executa um 
 //for. o for varia de 1 até o número do 
 //fatorial a ser calculado
 for (int j = 1; j <= i; j++) {
 //calcula o fatorial e atribui o valor 
 //ao atributo ‘fatorial’.
 fatorial = fatorial * j;
54
Modelagem Orientada a Objetos
 }
 }
 //saída do programa
 System.out.println(“O fatorial de “ + i + “ é 
== “ + fatorial);
 //reinicia o valor de fatorial, para ser 
 //calculado novamente
 fatorial = 1;
 }
 }
}
Atividade e Orientações de estudo
Exercícios
Cada aluno deve implementar a solução para os problemas a 
seguir no Eclipse. Após a finalização dos exercícios, todos devem 
postar as soluções encontradas no ambiente. O exercício 3 e 4 devem 
ser postados também no fórum, para discussões.
1. Faça um programa que imprima todos os números de 100 a 
170.
2. Faça um programa que receba valores inteiros de um usuário 
(utilize o JOptionPane - JOptionPane.showInputDialog(“Digite 
um valor”);) até que -1 seja fornecido como entrada. Exiba os 
valores fornecidos pelo usuário.
3. Faça um programa que imprima todos os múltiplos de 5, entre 
500 e 580 (utilizar o operador MOD – em Java representado 
por %).
4. Faça um programa que imprima a série Fibonacci (1 1 2 3 5 8...) 
com 12 elementos. Para a série, você começa com 0 e 1, e 
então produz o próximo número de Fibonacci somando os dois 
anteriores para formar o próximo.
55
Modelagem Orientada a Objetos
5. Considere um array de inteiros 2 por 3 de nome ‘ex’
» crie um novo projeto java para a implementação deste exercício
» escreva uma declaração para o array ex
» quantas linhas tem ex?
» quantas colunas tem ex?
» quantos elementos tem ex?
» escreva os nomes de todos os elementos na segunda linha de 
ex
» escreva os nomes de todos os elementos na terceira coluna de 
ex
» escreva uma única instrução que configura o elemento de t na 
linha 1 e na coluna 2 como 0
» escreva uma estrutura for aninhada que inicializa cada elemento 
de ex como zero
» escreva uma instrução que insere os valores para os elementos 
de ex a partir do teclado (valores fornecidos pelo usuário – 
utilize a classe JOptionPane, como no exercício 2)
» escreva uma série de instruções que determina e imprime o 
menor valor no array ex
Em caso de dúvidas, consulte o fórum de discussões do ambiente. 
Converse com seus colegas, professor e tutor.
Vamos Revisar?
Resumo
Neste capítulo você conheceu um pouco mais sobre a linguagem Java. Vimos as 
estruturas condicionais e de repetição da linguagem. Aprendemos ainda como 
manipular os arrays multidimensionais. A partir de agora você pode elaborar e 
desenvolver programas com ainda mais recursos. Não esqueça de organizar o 
seu sistema com o suporte da linguagem UML e os conceitos da orientação a 
objetos.
56
Modelagem Orientada a Objetos
Considerações Finais
Olá, cursista!
Neste volume, conhecemos o conceito de classes abstratas e 
aprendemos mais sobre a linguagem Java. Vimos quais são os tipos 
de dados primitivos suportados pela linguagem, além das estruturas 
condicionais e de repetição e os arrays.
Nosso foco agora será a elaboração de um projeto Java. Através 
deste projeto, praticaremos os conceitos de orientação a objetos e da 
linguagem UML vistos até o momento. 
Bons estudos e até o projeto final da disciplina.
Até lá e bons estudos!
57
Modelagem Orientada a Objetos
Referências
 [DEITEL, 2006] DEITEL, M. D.; DEITEL, P. J.: C++: Como 
Programar. 5a. Edição. Pearson. 2006.
 [DEITEL, 2005] DEITEL, M. D.; DEITEL, P. J.: Java, Como 
Programar. 6a. Edição. Bookman. 2005.
 [CORNEL, 2005] CORNEL, G., HORSTMANN C. S.: Core Java 
2. Fundamentos. 7a Edição. Alta Books. 2005.
 [ARNOLD, 2007] ARNOLD, KEN; GOSLING, JAMES: A 
Linguagem de Programação Java. 4a. Edição.Bookman.2007.
58
Modelagem Orientada a Objetos
Conhecendo os Autores
Eduardo Araujo Oliveira
http://lattes.cnpq.br/3887722014128939
Possui graduação em Ciencia da Computação pela Universidade 
Católica de Pernambuco (2005), mestrado em Ciência da Computação 
pela Universidade Federal de Pernambuco (2006-2008) e atualmente 
é doutorando pela UFPE. Trabalha como engenheiro de sistemas do 
Centro de Estudos e Sistemas Avançados do Recife (C.E.S.A.R) em 
projetos da Motorola desde 2004, tendo experiência com aplicações 
Java SE e Java ME. Possui certificação Java [SCJP]. Atua como 
Professor Conteudista no curso de Bacharelado em Sistemas de 
Informação da UAB/UFRPE e é professor titular da Faculdade 
Maurício de Nassau. Tem experiência nas áreas de Inteligência 
Artificial e Educação a Distância, tendo trabalhado e pesquisado com 
ambientes virtuais de ensino e aprendizado, agentes inteligentes e 
linguagens de programação.
Patrícia Tedesco
http://lattes.cnpq.br/7465148175791735
Possui graduação em Ciência da Computação pela Universidade 
Federal de Pernambuco (1994), mestrado em Ciência da Computação 
pela Universidade Federal de Pernambuco, na área de Inteligência 
Artificial Aplicada à Educação (1997) e doutorado em Ciência da 
Computação - University Of Leeds Computer Based Learning Unit 
(2001). Atualmente é professora adjunta do Centro de Informática 
- UFPE. Tem experiência na área de Ciência da Computação, 
com ênfase em Inteligência Artificial, atuando principalmente nos 
seguintes temas: Sistemas Multiagentes e Atores Sintéticos, Trabalho 
Colaborativo Apoiado por Computador, Contexto Computacional e 
Educação a Distância.