P. 1
Logica_de_Programacao

Logica_de_Programacao

|Views: 12.080|Likes:
Publicado porrobnilsonm13

More info:

Published by: robnilsonm13 on Sep 09, 2011
Direitos Autorais:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

01/26/2015

pdf

text

original

Sumário

NOÇÕES DE LÓGICA.............................................................................................................. 3
O QUE É LOG!CA? ..................................................................................................................... 3
OBJET!vOS DA LOG!CA ............................................................................................................... 3
O QUE É LOG!CA DE PROGRANAÇÁO? .............................................................................................. 3
O QUE É UN ALGOR!TNO? ........................................................................................................... +
!NPORTANC!A DA CONSTRUÇÁO DE ALGOR!TNOS ................................................................................ +
REPRESENTAÇÁO DE ALGOR!TNOS.................................................................................................. +
EXERCÍC!OS DE F!XAÇÁO............................................................................................................. 7
CONCEITOS BÀSICOS SOBRE ALGORITMOS......................................................................... S
T!POS PR!N!T!vOS .................................................................................................................... 8
vAR!AvEL............................................................................................................................... 8
CONSTANTES .......................................................................................................................... 9
!DENT!F!CAÇÁO DAS vAR!AvE!S PARA A L!NGUAGEN JAvA .................................................................... 10
CONENTAR!OS....................................................................................................................... 11
OPERADORES ........................................................................................................................ 12
Operador de atribuiçao .................................................................................................... 12
Operadores aritméticos.................................................................................................... 12
Operadores relacionais .................................................................................................... 13
Operadores lógicos.......................................................................................................... 1+
TABELA-vERDADE ................................................................................................................... 1+
PRECEDÊNC!A DOS OPERADORES ................................................................................................. 15
REGRAS PARA CR!AÇÁO DE BONS ALGOR!TNOS................................................................................. 16
NÉTODO PARA DESENvOLv!NENTO DE ALGOR!TNOS .......................................................................... 17
EXERCÍC!OS DE F!XAÇÁO........................................................................................................... 18
ESTRUTURAS DE CONTROLE............................................................................................... 20
ESTRUTURA SEQUENC!AL .......................................................................................................... 20
Passagem de parametros em Java .................................................................................... 20
Conversao de Tipos e Casting........................................................................................... 21
Conversoes Automaticas .................................................................................................. 21
Cast de Tipos !ncompativeis............................................................................................. 21
Uso do teclado para a entrada de dados ............................................................................ 23
Algoritmos Resolvidos...................................................................................................... 25
EXERCÍC!OS DE F!XAÇÁO - ESTRUTURA SEQUENC!AL ......................................................................... 27
ESTRUTURAS DE SELEÇÁO ......................................................................................................... 29
Seleçao Simples .............................................................................................................. 29
Seleçao Composta........................................................................................................... 30
Seleçao Encadeada ......................................................................................................... 32
Seleçao encadeada Heterogênea ...................................................................................... 32
Seleçao encadeada Homogênea........................................................................................ 33
Seleçao de multipla escolha.............................................................................................. 35
Algoritmos Resolvidos...................................................................................................... 37
EXERCÍC!OS DE F!XAÇÁO - ESTRUTURA DE SELEÇÁO.......................................................................... +0
ESTRUTURAS DE REPET!ÇÁO....................................................................................................... +5
Repetiçao com teste no inicio ........................................................................................... +5
Repetiçao com teste no final ............................................................................................ +8
Repetiçao com variavel de controle ................................................................................... +9
Comparaçao entre estruturas de repetiçao......................................................................... 50
Outros exemplos complementares .................................................................................... 55
EXERCÍC!OS GERA!S - ESTRUTURAS DE CONTROLE ...................................................................... 68
FUNÇÕES MATEMÀTICAS E DE STRING EM JAVA ............................................................... 75

FUNÇOES NATENAT!CAS ........................................................................................................... 75
FUNÇOES DE STR!NG ............................................................................................................... 77
EXERCÍC!OS DE F!XAÇÁO - FUNÇOES NATENAT!CAS E DE STR!NGS ......................................................... 79
VETORES E MATRIZES......................................................................................................... S0
vAR!AvE!S CONPOSTAS HONOGÊNEAS........................................................................................... 80
vAR!AvE!S CONPOSTAS UN!D!NENS!ONA!S (vETORES) ....................................................................... 80
Declaraçao ..................................................................................................................... 80
Nanipulaçao ................................................................................................................... 80
vAR!AvE!S CONPOSTAS NULT!D!NENS!ONA!S (NATR!ZES) ................................................................... 97
Declaraçao ..................................................................................................................... 97
Nanipulaçao ................................................................................................................... 97
EXERCÍC!OS DE F!XAÇÁO - vETORES E NATR!ZES.............................................................................107
MODULARIZAÇÀO ............................................................................................................. 10S
DECONPOS!ÇÁO....................................................................................................................108
PROCED!NENTOS...................................................................................................................108
Chamada de procedimentos ............................................................................................109
FUNÇOES ............................................................................................................................111
ESCOPO DE vAR!AvE!S ............................................................................................................112
PARANETROS .......................................................................................................................113
Parametros formais ........................................................................................................113
Parametros reais............................................................................................................113
PASSAGEN DE PARANETROS......................................................................................................11+
Passagem de parametros por valor ..................................................................................11+
Passagem de parametros por referência ...........................................................................11+
EXERCÍC!OS DE F!XAÇÁO - NODULAR!ZAÇÁO..................................................................................121
ARQUIVOS......................................................................................................................... 124
!NTRODUÇÁO .......................................................................................................................12+
DEF!N!ÇÁO DE ARQU!vOS.........................................................................................................12+
NAN!PULAÇÁO......................................................................................................................125
T!POS DE ARQU!vOS...............................................................................................................126
FORNAS DE ACESSO ...............................................................................................................126
ARQU!vO SEQUENC!AL - OPERAÇÁO DE !NCLUSÁO..........................................................127
ARQU!vO SEQUENC!AL - OPERAÇÁO DE CONSULTA .........................................................130
ARQU!vO SEQUENC!AL - OPERAÇÁO DE ALTERAÇÁO........................................................132
ARQU!vO SEQUENC!AL - OPERAÇÁO DE EXCLUSÁO..........................................................135
REPRESENTAÇÁO DA NAN!PULAÇÁO DE ARQU!vOS DE ACESSO ALEATOR!O ..............................................137
ARQU!vO DE ACESSO ALEATOR!O - OPERAÇÁO DE !NCLUSÁO..........................................137
ARQU!vO DE ACESSO ALEATOR!O - OPERAÇÁO DE CONSULTA .........................................139
ARQU!vO DE ACESSO ALEATOR!O - OPERAÇÁO DE ALTERAÇÁO........................................1+1
ARQU!vO DE ACESSO ALEATOR!O - OPERAÇÁO DE EXCLUSÁO..........................................1++
EXENPLOS D!vERSOS - UT!L!ZANDO AS CLASSES AWT, SW!NG E EvENT .................................................1+6
EXERCÍC!OS DE F!XAÇÁO - ARQU!vOS ..........................................................................................152
PROGRAMAÇÀO ORIENTADA A OBJETOS ......................................................................... 156
CONCE!TOS PREL!N!NARES.......................................................................................................156
!NTRODUÇÁO .......................................................................................................................156
O PROCESSO DE ABSTRAÇÁO.....................................................................................................156
OPERAÇOES DE ABSTRAÇÁO ......................................................................................................156
Classificaçaof!nstanciaçao...............................................................................................156
GeneralizaçaofEspecializaçao...........................................................................................157
AgregaçaofDecomposiçao ...............................................................................................158
Associaçao ....................................................................................................................161
EXERCÍC!OS DE F!XAÇÁO - CONCE!TOS BAS!COS DE OO....................................................................161
O MODELO DE OBJETOS.................................................................................................... 162

CONCE!TOS FUNDANENTA!S......................................................................................................162
CLASSES E OBJETOS...............................................................................................................162
ATR!BUTO...........................................................................................................................162
NÉTODO.............................................................................................................................162
TERNOS ENPREGADOS NA POO .................................................................................................163
JAVA E O MODELO DE OBJETOS........................................................................................ 165
PROGRANAÇÁO ESTRUTURADA...................................................................................................166
O NODELO DE OBJETOS..........................................................................................................170
Objetos, métodos e variaveis...........................................................................................170
Agregaçao.....................................................................................................................170
Nensagens....................................................................................................................171
Classes e instancias........................................................................................................172
Herança........................................................................................................................172
Sobrecarga de Operadores e Polimorfismo........................................................................173
INTRODUÇÀO ÀS CLASSES................................................................................................ 175
DEF!N!ÇÁO DE UNA CLASSE EN JAvA ...........................................................................................175
Criando a Classe Caixa....................................................................................................175
A saida do programa sera ...............................................................................................176
O volume e +1+0.0.........................................................................................................176
!NTRODUÇÁO AOS NÉTODOS .....................................................................................................176
!ncluindo um Nétodo na Classe Caixa...............................................................................177
Retornando um valor .....................................................................................................178
!ncluindo um Nétodo com Parametros a Classe Caixa ........................................................178
CONSTRUTORES ....................................................................................................................179
GARBAGE COLLECT!ON............................................................................................................180
O NÉTODO F!NAL!ZE()............................................................................................................180
MAIS DETALHES SOBRE CLASSES E MÉTODOS................................................................. 1S1
SOBRECARGA DE NÉTODOS ......................................................................................................181
SOBRECARGA DE CONSTRUTORES ...............................................................................................182
A PALAvRA-CHAvE STAT!C .......................................................................................................183
A PALAvRA-CHAvE F!NAL .........................................................................................................183
HERANÇA........................................................................................................................... 1S3
FUNDANENTOS DE HERANÇA.....................................................................................................183
EXENPLO DE HERANÇA............................................................................................................18+
SOBREPOS!ÇÁO DE NÉTODOS....................................................................................................185
Aplicando a Sobreposiçao de Nétodos ..............................................................................185
CLASSES ABSTRATAS ..............................................................................................................186
PACOTES E INTERFACES................................................................................................... 1S7
PACOTES ............................................................................................................................187
Criando um Pacote.........................................................................................................187
A variavel de Ambiente CLASSPATH.................................................................................188
CONTROLE DE ACESSO............................................................................................................188
!NPORTANDO UN PACOTE ........................................................................................................189
!NTERFACES.........................................................................................................................189
TRATAMENTO DE EXCEÇÀO............................................................................................... 190
FUNDANENTOS DO TRATANENTO DE EXCEÇÁO................................................................................190
T!POS DE EXCEÇÁO................................................................................................................191
TRY-CATCH..........................................................................................................................191
THROW ..............................................................................................................................191
THROWS .............................................................................................................................192
F!NALLY..............................................................................................................................193
EXCEÇOES PADROES EN JAvA....................................................................................................19+

CR!ANDO UNA EXCEÇÁO ..........................................................................................................19+
ENTRADAJSAÍDA .............................................................................................................. 195
STREANS ............................................................................................................................195
Streams de Bytes e de Caracteres....................................................................................195
Streams Predefinidas......................................................................................................196
LENDO DADOS DO TECLADO .....................................................................................................196
Leitura de Caracteres do Teclado.....................................................................................197
Leitura de Strings do Teclado ..........................................................................................198
ESCREvENDO NO TERN!NAL......................................................................................................198
LE!TURA E ESCR!TA DE ARQU!vOS ..............................................................................................198
APPLETS............................................................................................................................ 201
!NTRODUÇÁO AOS APPLETS.......................................................................................................201
ESQUELETO BAS!CO DE UN APPLET .............................................................................................202
!niciaçao e Finalizaçao de um Applet ................................................................................203
CORES DO APPLET .................................................................................................................203
DESENHANDO FORNAS GEONÉTR!CAS..........................................................................................20+
ANEXO A:........................................................................................................................... 205
CONCE!TOS SOBRE A L!NGUAGEN JAvA.........................................................................................205
Um Breve histórico.........................................................................................................205
Principios basicos de um ambiente Java classico................................................................205
Por Dentro da Plataforma Java ........................................................................................207
Compilador e Ambiente de Execuçao Java.........................................................................208
ANEXO B............................................................................................................................ 209
RESUNO DOS CONCE!TOS ABORDADOS SOBRE A L!NGUAGEN JAvA. .......................................................209
RECURSOS ..........................................................................................................................209
COLETA DE L!XO ...................................................................................................................209
ANB!ENTE JAvA DE CONP!LAÇÁO................................................................................................209
DURANTE O PROCESSO DE CONP!LAÇÁO.......................................................................................210
ARQU!vOS DO JDK ................................................................................................................210
ALGUNAS DEF!N!ÇOES ............................................................................................................210
CONP!LADOR JAvAC ...............................................................................................................211
PARA !NTERPRETAR O PROGRANA...............................................................................................212
PALAvRAS RESERvADAS...........................................................................................................212
vAR!AvE!S...........................................................................................................................212
NOD!F!CADORES DE vAR!AvE!S .................................................................................................213
CONENTAR!OS......................................................................................................................213
NOD!F!CADORES DE CLASSES ....................................................................................................213
NOD!F!CADORES DE NÉTODOS E vAR!AvE!S_NENBRO.......................................................................213
EXCEÇOES...........................................................................................................................213
DESCR!ÇÁO DE ALGUNAS CLASSES...............................................................................................215
CLASSES NA!S UT!L!ZADAS .......................................................................................................215
1. String....................................................................................................................215
2. Classe que representa datas - java.util.date..............................................................216
3. Classes de Entrada e Saida......................................................................................217
+. File.......................................................................................................................218
ANEXO C............................................................................................................................ 220

3
Noções de Lógica

O que é lógica?

palavra lógica é originária do grego logos, que significa linguagem racional. De acordo com o
dicionário Michaelis, lógica é a análise das formas e leis do pensamento, mas não se preocupa
com a produção do pensamento, quer dizer, não se preocupa com o conteúdo do pensamento,
mas sim com a forma deste, isto é, com a maneira pela qual um pensamento ou uma idéia são
organizados e apresentados, possibilitando que cheguemos a uma conclusão por meio do
encadeamento dos argumentos.
Os argumentos podem ser dedutivos ou indutivos. Os argumentos indutivos são aqueles com
que, a partir dos dados, se chega a uma resposta por meio de analogia, ou seja, pela comparação
com algo conhecido, porém esse tipo de raciocínio não oferece certeza de que a resposta será de
fato verdadeira. É necessário conhecer os fatos ou as situações para que se possa fazer a
comparação.
Já os argumentos dedutivos são aqueles cuja conclusão é obtida como conseqüência das
premissas, isto é, por meio da análise das situações ou fatos, pode-se obter a resposta. Trabalha-se
com a forma das sentenças, sem que haja necessidade do conhecimento prévio das situações ou
fatos.

Exemplos:
a)
todo mamífero é um animal.
todo cavalo é um mamífero.
portanto, todo cavalo é um animal.

b)
Kaiton é um país do planeta Stix.
Todos os Xipins são de Kaiton.
Logo, todos os Xipins são Stixianos.

c)
Gerson é cientista.
Todo cientista é estudioso.
Logo, Gerson é estudioso.

A lógica é a “arte do bem pensar”, que é a “ciência das formas do pensamento”. Visto que a
forma mais complexa do pensamento é o raciocínio, a lógica estuda a “a correção do raciocínio”.
Podemos ainda dizer que a lógica tem em vista a “ordem da razão”.

Objetivos da lógica

Estudo das técnicas de formalização, dedução e análise que permitam verificar a
validade de argumentos.
A lógica também objetiva a criação de uma representação mais formal, que se
contrapõe à linguagem natural, que é suscetível a argumentações informais.

O que é lógica de programação?

Significa o uso correto das leis do pensamento, da “ordem da razão” e de processos de
raciocínio e simbolização formais na programação de computadores, objetivando racionalidade e o
desenvolvimento de técnicas que cooperem para a produção de soluções logicamente válidas e
coerentes, que resolvam com qualidade os problemas que se deseja programar.
O raciocínio é algo abstrato, intangível. Os seres humanos têm a capacidade de expressa-lo
através da palavra falada ou escrita, que por sua vez se baseia em um determinado idioma, que
segue uma série de padrões (gramática). Um mesmo raciocínio pode ser expresso em qualquer um
dos inúmeros idiomas existentes, mas continuará representando o mesmo raciocínio, usando apenas
outra convenção.
A
4
Algo similar ocorre com a lógica de programação, que pode ser concebida pela mente
treinada e pode ser representada em qualquer uma das inúmeras linguagens de programação
existentes. Estas, por sua vez, são muito atreladas a uma grande diversidade de detalhes
computacionais, que pouco têm a ver com o raciocínio original. Para escapar dessa “Torre de Babel”
e, ao mesmo tempo, representar mais fielmente o raciocínio da lógica de programação, utilizamos os
algoritmos.

O que é um algoritmo?

Um algoritmo pode ser definido como uma seqüência de passos que visam atingir um
objetivo bem definido.
Quando elaboramos um algoritmo devemos especificar ações claras e precisas, que a partir
de um estado inicial, após um período de tempo finito, produzem um estado final previsível e bem
definido. Isto significa que o algoritmo fixa um padrão de comportamento a ser seguido, uma norma
de execução a ser trilhada, com vistas a alcançar, como resultado final, a solução de um problema,
garantindo que sempre que executado, sob as mesmas condições, produza o mesmo resultado.

importância da construção de algoritmos

Representar mais fielmente o raciocínio envolvido na lógica de programação e, dessa
forma, permite-nos abstrair de uma série de detalhes computacionais, que podem ser
acrescentados mais tarde. Assim podemos focalizar nossa atenção naquilo que é
importante: a lógica da construção de algoritmos.
Uma vez concebida uma solução algorítmica para um problema, esta pode ser
traduzida para qualquer linguagem de programação e ser agregada das
funcionalidades disponíveis nos diversos ambientes; costumamos denominar esse
processo de codificação.


Representação de algoritmos

Um algoritmo é uma linha de raciocínio, que pode ser descrito de diversas maneiras, como
por exemplo: pseudicódigo, descrição narrativa, fluxograma ou diagrama de Chapin.

Exemplo: Algoritmo para trocar lâmpadas (considerando 10 lâmpadas)

Descrição narrativa

Ir até o interruptor;
Enquanto a quantidade de soquetes testados for menor que dez, faça
Acionar interruptor;
Se a lâmpada não acender, então
Pegar uma escada;
Posicionar a escada embaixo da lâmpada;
Buscar uma lâmpada nova;
Acionar o interruptor;
Subir na escada;
Retirar a lâmpada queimada;
Colocar uma lâmpada nova;
Enquanto a lâmpada não acender, faça
Retirar a lâmpada queimada;
Colocar uma lâmpada nova;
Ir até o interruptor do próximo soquete;


5
Diagrama Chapin ou N-S




















Pseudocódigo ou portugol


Inicio
Declaração de variáveis;
Enquanto (soquetes testados) < 10 faça
Acionar o interruptor;
Se (lâmpada não acendeu) então
Pegar uma escada;
Colocar a escada embaixo do soquete;
Buscar lâmpada nova;
Acionar interruptor;
Subir na escada;
Retirar a lâmpada queimada;
Colocar lâmpada nova;
Enquanto (lâmpada não acender) faça
Retirar lâmpada queimada;
Colocar lâmpada nova;
Fim enquanto;
Ir para o próximo soquete;
Fim se;
Fim enquanto;
Fim;




Ir para o primeiro soquete
Soquetes testados < 10
Acionar o interruptor
Lâmpada não
acendeu?
Pegar uma escada
Colocar a escada embaixo do
soquete
Buscar uma lâmpada nova
Acionar o interruptor
Subir na escada
Retirar a lâmpada queimada
Colocar a lâmpada nova

Lâmpada não acendeu?
Retirar lâmpada queimada
colocar lâmpada nova
Ir para o próximo soquete
F V
6
Fluxograma ou Diagrama em blocos
























































início
Soquetes testados
< 10
Ir para o primeiro soquete
Acionar o interruptor
Lâmpada não
acendeu?
Pegar uma escada
Colocar a escada embaixo do
soquete
Buscar a lâmpada nova
Acionar interruptor
Subir na escada
Retirar a lâmpada queimada
colocar lâmpada nova
Lâmpada não
acendeu?
Retirar a lâmpada queimada
Colocar lâmpada nova
Ir para próximo soquete
fim
7
Exercícios de Fixação

1. Descreva com suas palavras o que você entende por:
• ação;
• processo;
• estado;
• evento;
• padrão de comportamento.

2. Escreva um algoritmo para descrever como você faz para ir da sua casa até a Faculdade.
3. O que você entende por aspecto estático e aspecto dinâmico de um algoritmo? Qual o conceito
que relaciona estes dois aspectos?
4. Quais são as três estruturas básica de controle com as quais podemos desenvolver qualquer
algoritmo?
5. O que é um programa?
6. O que é um bom programa?
7. Com relação as aspecto de documentação, qual a vantagem de se utilizar uma pseudolinguagem
para desenvolvimento de programas?


8
Conceitos básicos sobre algoritmos

s dados são na verdade, os valores que serão utilizados para a resolução de um problema.
Esses valores podem ser fornecidos pelo usuário do programa, podem ser originados a partir
de processamentos (cálculos) ou, então, a partir de arquivos, bancos de dados ou outros
programas.

Tipos primitivos

Para entender os tipos primitivos, voltemos nossa atenção para um conceito muito
importante: informação.
Informação é a matéria-prima que faz com que seja necessária a existência dos
computadores, pois eles são capazes de manipular e armazenar um grande volume de dados com
alta performance, liberando o Homem para outras tarefas nas quais seu conhecimento é
indispensável.
Os dados são armazenados temporariamente em variáveis para que sejam processados de
acordo com as especificações do algoritmo. Para que haja integridade no resultado obtido, os dados
devem ser classificados de acordo com o tipo do valor a ser armazenado na variável, isto é, para
evitar problemas que podem ser ocasionados devido ao fornecimento de valores inadequados à
operação que será realizada.
Aproximando-nos da maneira pela qual o computador manipula as informações, vamos dividi-
las em quatro tipos primitivos, que serão os tipos básicos que usaremos na construção de algoritmos.
Como os dados manipulados pelos computadores durante a execução dos programas são
armazenados na memória, esses tipos seguem características de formato e espaço disponível nessa
memória.
Definir o tipo de dados mais adequado para ser armazenado em uma variável é uma questão
de grande importância para garantir a resolução do problema. Ao desenvolver um algoritmo, é
necessário que se tenha conhecimento prévio do tipo de informação (dado) que será utilizado para
resolver o problema proposto. A partir daí, escolhe-se o tipo adequado para a variável que
representará esse valor. Na confecção de algoritmos, utilizamos os tipos de dados primitivos (literal,
inteiro, real e lógico), uma vez que os algoritmos apenas representam a resolução dos problemas. Já
na confecção de programas, existem desdobramentos para esses tipos de dados a fim de adequá-los
melhor ao propósito de cada linguagem e à resolução prática dos problemas.

Variável

Um dado é classificado como variável quando tem a possibilidade de ser alterado em algum
instante no decorrer do tempo, ou seja, durante a execução do algoritmo em que é utilizado, o valor
do dado sofre alteração ou o dado é dependente da execução em um certo momento ou
circunstância.
Quando um algoritmo é transcrito para uma determinada linguagem de programação, as
variáveis também terão a função de armazenar dados temporariamente, mas na memória RAM do
computador. Esses dados serão utilizados durante o processamento para a resolução do problema
em questão.
Prìmìtìvos Esµecíjìcos µara a lìnyuayem de Proyramaçáo Java
TIpos de dados 0efInIção TIpos de
dados
CapacIdade de armazenamento na memórIa
do computador, de acordo com a IInguagem
Java.
LIteral - também conhecIdo
como texto ou caractere.
Poderá receber letras, numeros
e simbolos.
D8S: os numeros armazenados
em uma varIável cujo tIpo de
dado é lIteral não poderão ser
utIlIzados para cálculos.
char 16 bIts - armazena unIcodes.
byte 8 bIts - de (·128) até (127)
short 16 bIts - de (·J2.768) até (J2.767)
O
9
Prìmìtìvos Esµecíjìcos µara a lìnyuayem de Proyramaçáo Java
Ìnt

J2 bIts - de (·2.147.48J.648) até
(2.147.48J.647)

long 64 bIts - de (·9.22J.J72.0J6.854.775.808) até
(9.22J.J72.0J6.854.775.807)
float J2 bIts - de (·J,4E·J8) até (·J,4E+J8) Feal - também conhecIdo
como ponto flutuante.
Poderá receber numeros reaIs,
Isto é, com casas decImaIs,
posItIvos ou negatIvos. double 64 bIts - de (·1,7E·J08) até (+1,7E+J08)
LogIco - também conhecIdo
como booleano.
Poderá receber verdadeIro (1)
ou falso(0).
boolean 8 bIts - em java pode·se armazenar true ou
]clse.

Inteiros
Java define quatro tipos inteiros: byte, short, int e long. Todos os tipos inteiros são
sinalizados, ou seja, podem assumir valores positivos e negativos. Java não suporta tipos não
sinalizados (inteiros somente positivos).
O tamanho de um tipo inteiro não deve ser visto como a quantidade de memória para
armazenar o dado e sim o comportamento apresentado pelo dado. O ambiente de execução Java
pode utilizar qualquer tamanho de memória para armazenar o dado desde que o comportamento
correto seja mantido. A variação dos valores que cada tipo de dado inteiro pode assumir é mostrada
na tabela acima.
Tipos de Dados de Ponto Flutuante
Os números de ponto flutuante, também conhecidos como números reais, são utilizados em
operações que necessitam de precisão fracionária, tais como raiz quadrada, seno e cosseno. Java
define dois tipos de dados de ponto flutuante: float e double, que representam números de precisão
simples e dupla, respectivamente. A variação dos valores dos tipos de dados de ponto flutuante
podem assumir é mostrado na tabela acima.

Caracteres
Em Java o tipo de dados utilizado para armazenar um caractere é o char. O tipo char em
Java é diferente do char no C/C++. Em C/C++, char é um inteiro de 8 bits. Java utiliza o Unicode
para representar seus caracteres. O Unicode define um conjunto de caracteres internacional que
representa todos os caracteres encontrados em todos os idiomas humanos. É uma união de doze
conjuntos de caracteres, como Latim, Grego e Árabe. Para isso os caracteres unicode necessitam de
16 bits para serem representados. Assim, em Java, os caracteres tem o tamanho de 16 bits variando
de O a 65.536, não existindo valores para este tipo de dado.
Booleanos
Para valores lógicos, Java possui o tipo boolean. Uma variável booleana pode assumir valor
true (verdadeiro) ou false (falso). Este tipo de dado é retornado por todos os operadores relacionais,
como a < b. Além disso, boolean é o tipo de dado requerido por condicionais que controlam
estruturas de controle como if e for.

Constantes

Entendemos que um dado é constante quando não sofre nenhuma variação no decorrer do tempo, ou
seja, seu valor é constante desde o início até o fim da execução do algoritmo ou da execução do
programa, assim como é constante para execuções diferentes no tempo.
Em Java, uma constante é uma variável declarada com o modificar final. Por exemplo:

final float pi = 3.1415f;

10
NOTA: modificadores sao utilizados para modificar a atribuiçao de classes, variaveis ou métodos.


Identificação das variáveis para a linguagem Java

Toda variável deve ser identificada, isto é, deve receber um nome ou identificador. O nome de
uma variável deve ser único e deve estar de acordo com algumas regras.
Em Java, os nomes para as variáveis são case-sensitive, isto é, nomes com letras maiúsculas
são diferenciados de nomes com letras minúsculas. Por exemplo: soma_total é diferente de
Soma_Total e também de Soma_total.
• Nomes devem começar com uma letra, um caractere 'sublinha' ou 'underline' (_) ou o
símbolo cifrão ($). Os caracteres subseqüentes podem também ser algarismos.
• Não utilizar caracteres especiais, como acentos, símbolos (? / : # etc), ç, entre outros,
exceto os acima citados.
• As letras podem ser maiúsculas ou minúsculas.
• Não podem ser utilizadas palavras reservadas, como final, float, for, int etc.

A linguagem Java exige que todas as variáveis tenham um tipo de dado definido antes de serem
utilizadas no programa, ou seja, elas devem ser obrigatoriamente declaradas, independentemente do
ponto do programa, tanto faz, seja no início, no meio ou no final, desde que seja antes de sua
utilização no programa. Essa característica difere da maioria das linguagens de programação.
Quando as variáveis são declaradas, a linguagem Java atribui a elas valores-padrão, a menos que
especificado de maneira contrária pelo programador. Atribui-se a todas as variáveis dos tipos: char,
byte, short, int long, long e double o valor 0 (zero) por default. Já as variáveis do tipo boolean, por
default, atribui-se false. Entretanto, dependendo do ponto do programa em que a variável é utilizada,
torna-se obrigatório sua inicialização com algum valor, mesmo com a linguagem possuindo esses
valores padrão.

A forma básica de uma declaração é a seguinte:
tipo identificador [= valor], identificador [= valor],...

O tipo é um dos tipos elementares de Java, ou o nome de uma classe ou de um a interface. O
identificador é o nome da variável. Uma variável pode ser iniciada especificando-se um sinal de
igualdade e um valor. Para se declarar mais de uma variável do mesmo tipo basta utilizar uma vírgula
como separador. A seguir são mostrados alguns exemplos de declarações de variáveis:

int a, b, c; // declaração de três inteiros a, b,c
int d=1,e,f,g=2; // declaração de mais quatro inteiros
// iniciando d e g
byte x = 22; //inicia x com 22
double PI = 3.1416; // declara uma aproximação de PI
char y = 'Y'; // a variável x é iniciada com 'Y'

Iniciação Dinâmica

Embora os exemplos anteriores tenham exibido apenas variáveis sendo iniciadas com
valores constantes, Java permite que as variáveis sejam iniciadas dinamicamente, utilizando
expressões válidas no momento da declaração. Por exemplo, a seguir é mostrado um trecho de
código onde é calculado o comprimento da hipotenusa de um triângulo retângulo com os valores dos
dois catetos:

// demonstração de iniciação dinâmica
class DinIni {
public static void main(String args[]) {
double cateto_oposto = 3.0, cateto_adjacente = 5.0;
// hipotenusa é iniciado dinamicamente
double hipotenusa = Math.sqrt(cateto_oposto*cateto_oposto +
cateto_adjacente*cateto_adjacente);
System.out.println("A hipotenusa é " + hipotenusa);
}
11
}
As variáveis cateto_oposto e cateto_adjacente são iniciadas por constantes. Entretanto, a
variável hipotenusa é iniciada dinamicamente utilizando o Teorema de Pitágoras. O programa utiliza
também o método embutido, sqrt(), que é um membro da classe Math, para calcular a raiz quadrada.
Escopo e Tempo de Vida de uma Variável
Como dito anteriormente, Java permite que as variáveis sejam declaradas em qualquer bloco.
Um bloco define um escopo. Assim, sempre que um novo bloco é iniciado, um novo escopo é criado.
Um escopo define que objetos são visível para outras partes do código do programa. O escopo define
também o tempo de vida de uma variável.
Em linguagens procedurais existem dois tipos de escopo: global e local. Contudo, devido ao
seu modelo orientado a objeto, estes tipos de escopo não se aplicam à Java. Em Java existem dois
tipos principais de escopo, um é definido por uma classe e o outro é definido por um método. A seguir
é mostrado um exemplo em Java mostrando estes conceitos:

// Demonstra o escopo de blocos
class Escopo{
public static void main(String args[]) {
int x; // acessível por todo o código dentro do método m
x = 10;
if (x == 10) { // início de um novo escopo
int y - 20; // acessível apenas neste bloco

// x e y são acessíveis neste trecho
x - y * 3;
}
// y não é acessível fora do bloco "if"
// x ainda é acessível neste trecho
System.out.println("x é " + x);
}
}

Um aspecto importante a ser lembrado é que as variáveis são criadas apenas quando o seu
escopo é iniciado e são destruídas tão logo seu escopo chega ao fim. Isto significa, que uma variável
não guardará seu valor uma vez que tenha saído do seu escopo. Assim, o tempo de vida de uma
variável dura enquanto seu escopo estiver ativo.

Comentários

Os comentários são linhas adicionadas ao programa que servem para facilitar seu
entendimento por parte do programador, ou ainda por uma outra pessoa que consulte o programa.
Essas linhas não afetam o programa em si, pois não são consideradas parte do código. O Java aceita
três tipos de comentários: de uma linha, de múltiplas linhas e de documentação.
Para inserir comentários de linha única utilizam-se // (duas barras) em qualquer local do
programa e tudo o que estiver escrito depois deste sinal e na mesma linha será considerado um
comentário.
Para inserir comentários que envolvam várias linhas, utiliza-se /* (barra asterisco) para
demarcar o início e */ (asterisco barra) para o final, ou seja, tudo o que estiver entre dois sinais será
considerado comentário.
O terceiro tipo é semelhante ao comentário de múltiplas linhas, entretanto tem o propósito de
possibilitar a documentação do programa por meio de um utilitário (javadoc) fornecido pela Sun junto
com o SDK. Esse tipo de comentário inicia-se com /** e é encerrado com */.

Exemplo:
/**Exemplo1:
Essa classe demonstra a utilização de variáveis em uma
classe em Java. São declaradas as variáveis do tipo int e double.
O exemplo também demonstra como imprimir o conteúdo das
variáveis na tela.
*/
public class Exemplo1{
12
public static void main (String args[]){
//declaração de variáveis do tipo inteiro
int x = 10, y = 20;
double dolar = 2.92;
/* As linhas seguintes enviam o conteúdo das variáveis
para a tela */
System.out.println(x);
System.out.println(y);
System.out.println(dolar);
}
}

/**Exemplo2:
imprimindo múltiplas linhas de texto com uma única instrução
*/
public class Exemplo2{
public static void main (String args[]){
//o método main inicia a execução deo aplicativo java
System.out.println(“Bem\nvindos\nao\nJava”);
}
}

Seqüëncìa de escaµe 0escrìçáo
\n Nova lInha. PosIcIona o cursor de tela no InicIo da proxIma lInha.
\t Tabulação horIzontal. |ove o cursor de tela para a proxIma parada de
tabulação.
\r Fetorno de carro. PosIcIona o cursor de tela no InicIo da lInha atual; não
avança para a proxIma lInha. Qualquer saida de caracteres depoIs do
retorno de carro sobrescreve a saida anterIor de caracteres na lInha
atual.
\\ 8arra InvertIda. UtIlIzada para ImprImIr um caractere barra InvertIda.
\" Aspas duplas. UtIlIzada para ImprImIr um caractere aspas duplas.
Algumas seqüências comuns de escape.


Operadores

Os operadores são utilizados para representar expressões de cálculo, comparação, condição
e atribuição. Temos os seguintes tipos de operadores: de atribuição, aritméticos, relacionais e lógicos.

Operador de atribuição

São utilizados para expressar o armazenamento de um valor em uma variável. Esse valor
pode ser pré-definido (variante ou não) ou pode ser o resultado de um processamento.

Ex:
nome = “fulano de tal”;
resultado = a + 5;
valor = 3;

Nota: para algoritmos podemos utilizar <-- para indicar atribuiçao.



Operadores aritméticos

São utilizados para realização dos diversos cálculos matemáticos. São eles:

13
0µerador Reµresentaçáo utìlìzando-se a
notaçáo alyorìtmìca
Reµresentaçáo utìlìzando-se a
notaçáo µara a lìnyuayem Java
Exemµlos em Java
Ìncremento UtIlIza·se uma expressão.
Por exemplo: a + 1
++ AdIcIona 1 ao valor de a.
Exemplo: a++ (retorna o valor
de a e depoIs adIcIona 1 a esse
valor); ++a (adIcIona 1 ao valor
de a antes de retorná·lo).
0ecremento UtIlIza·se uma expressão.
Por exemplo: a · 1
·· SubtraI 1 do valor de a.
Exemplo: a·· (retorna o valor
de a e depoIs subtraI 1 desse
valor); ··a (subtraI 1 do valor
de a antes de retornar).
|ultIplIcação * * a * b (multIplIca a por b)
0IvIsão / / a/b (dIvIde o valor de a por b)

0µerador Reµresentaçáo utìlìzando-se a
notaçáo alyorìtmìca
Reµresentaçáo utìlìzando-se a
notaçáo µara a lìnyuayem Java
Exemµlos em Java
ExponencIação ´ ou **.
Por Exemplo: 2
J
é 2´J.
UtIlIza método.
|odulo mod.
Por exemplo: a mod b.
º a º b (retorna o resto da
dIvIsão InteIra de a por b. Por
exemplo, se o valor de a fosse
9 e o valor de b fosse 2,
teriamos 9 º 2; o resultado da
dIvIsão serIa 4 e o resto(mod)
serIa 1).
AdIção + + a + b (o valor de a é somado ao
valor de b).
Subtração · · a · b (do valor de a é subtraido
o valor de b).

Operadores relacionais

São utilizados para estabelecer uma relação de comparação entre valores ou expressões. O
resultado dessa comparação é sempre um valor lógico (booleano) verdadeiro ou falso.


0µerador Reµresentaçáo utìlìzando-se a
notaçáo alyorìtmìca
Reµresentaçáo utìlìzando-se a
notaçáo µara a lìnyuayem Java
Exemµlos em Java
|aIor · · a · b (se o valor de a for maIor
do que o valor de b, retornará
verdadeIro. Senão, retornará
falso).
|aIor ou Igual ·= ·= a ·= b (se o valor de a for
maIor ou Igual ao valor de b,
retornará verdadeIro. Senão,
retornará falso).
|enor · · a · b (se o valor de a for menor
do que o valor de b, retornará
verdadeIro. Senão, retornará
falso).
|enor ou Igual ·= ·= a ·= b (se o valor de a for
menor ou Igual ao valor de b,
retornará verdadeIro. Senão,
retornará falso).
14
0µerador Reµresentaçáo utìlìzando-se a
notaçáo alyorìtmìca
Reµresentaçáo utìlìzando-se a
notaçáo µara a lìnyuayem Java
Exemµlos em Java
Ìgual a '= '== a == b (se o valor de a for Igual
ao valor de b, retornará
verdadeIro. Senão, retornará
falso.
0Iferente de ·· != a != b (se o valor de a for
dIferente do valor de b,
retornará verdadeIro. Senão,
retornará falso.



Operadores lógicos

São utilizados para concatenar ou associar expressões que estabeleçam uma relação de
comparação entre valores. O resultado dessas expressões é sempre um valor lógico (booleano)
verdadeiro ou falso.

0µerador Reµresentaçáo utìlìzando-se a
notaçáo alyorìtmìca
Reµresentaçáo utìlìzando-se a
notaçáo µara a lìnyuayem Java
Exemµlos em Java
E .e. EE A = 5 EE b != 9 (caso o valor
de a seja Igual a 5 e o valor de
b seja dIferente de 9, então
retornará verdadeIro. Caso
contrárIo, retornará falso).
Du .ou. ¦¦ A = 5 ¦¦ b != 9 (caso o valor de
a seja Igual a 5 e o valor de b
seja dIferente de 9, então
retornará verdadeIro. Se ambas
as comparações retornarem
falso, o resultado será falso).
não .não. ! !a · 5 (se o valor de a for
maIor do que 5, retornará
falso. Caso contrárIo, retornará
verdadeIro).

Tabela-verdade

A tabela verdade expressa o conjunto de possibilidades existentes para a combinação de
variáveis ou expressões e operadores lógicos. Veja o exemplo abaixo:

Dperador
ûû (.e.) || (.ou.) ! (.não.)
Expressão
aIgorItmIca
A = 5 ß ·> º A = 5 .e. ß ·> º A = 5 .ou. ß ·> º .não. A = 5
Expressão em
Java
A == 5 ß != º A == 5 ûû b != º A == 5 || ß != º !A == 5
.7. .7. .7. .7. .F.
.7. .F. .F. .7. .F.
.F. .7. .F. .7. .7.
PesuItados
possíveIs
.F. .F. .F. .F. .7.





15
Precedência dos operadores

As linguagens de programação normalmente estabelecem uma ordem de avaliação
considerando a precedência dos operadores quando mais de um operador é usado em uma
expressão. Veja abaixo a precedência dos operadores:
Os operadores são mostrados em ordem crescente de precedência, de cima para baixo:



Dperador TIpo AssocIatIvIdade
( ) Parënteses 0a esquerda para a dIreIta
[ ] SubscrIto de array
. Seleção de membro
++ Pos·Incremento unárIo 0a dIreIta para a esquerda
·· Pos·decremento unárIo
++ Pré·Incremento unárIo 0a dIreIta para a esquerda
·· Pré·decremento unárIo
+ |aIs unárIo
· |enos unárIo
! Negação logIca unárIa
- Complemento unárIo sobre bIts
( tIpo ) Coerção unárIa
* |ultIplIcação 0a esquerda para a dIreIta
/ 0IvIsão
º |odulo
+ AdIção 0a esquerda para a dIreIta
· Subtração


Dperador TIpo AssocIatIvIdade
·· 0eslocamento de bIts para a esquerda 0a esquerda para a dIreIta
·· 0eslocamento de bIts para a dIreIta com
extensão de sInal

··· 0eslocamento de bIts para a dIreIta com
extensão de zeros

· FelacIonal menor que 0a esquerda para a dIreIta
·= FelacIonal menor ou Igual a
· FelacIonal maIor que
·= FelacIonal maIor ou Igual a
Ìnstanceof Comparação de tIpo
== FelacIonal é Igual a 0a esquerda para a dIreIta
!= FelacIonal não é Igual a
E E sobre bIts 0a esquerda para a dIreIta
´ DU exclusIvo sobre bIts
DU exclusIvo logIco booleano
0a esquerda para a dIreIta
¦ DU InclusIvo sobre bIts
DU InclusIvo logIco booleano
0a esquerda para a dIreIta
EE E logIco 0a esquerda para a dIreIta
¦¦ DU logIco 0a esquerda para a dIreIta
:: TernárIo condIcIonal 0a dIreIta para a esquerda
= AtrIbuIção 0a dIreIta para a esquerda
+= AtrIbuIção de adIção
·= AtrIbuIção de subtração
*= AtrIbuIção de multIplIcação
/= AtrIbuIção de dIvIsão
º= AtrIbuIção de modulo
E= AtrIbuIção E sobre bIts
´= AtrIbuIção DU exclusIva sobre bIts
¦= AtrIbuIção DU InclusIva sobre bIts
··= AtrIbuIção de deslocamento para a esquerda
··= AtrIbuIção de deslocamento de bIts para a
dIreIta com extensão de sInal

16
···= AtrIbuIção de deslocamento de bIts para a
dIreIta com extensão de zeros.


De maneira geral, temos:

Parênteses mais internos
Operadores aritméticos
Operadores relacionais
Operadores lógicos


class Exemplo3{
public static void main (String args[]){
//declaração e inicialização de variáveis
int x = 10, y = 3;
// várias operações com as variáveis
System.out.println(“x = “+ x);
System.out.println(“y = “+ y);
System.out.println(“-x = “ +(-x));
System.out.println(“x/y = “ +(x/y));
System.out.println(“Resto de x por y = “ +(x%y));
System.out.println(“Inteiro de x por y = “ +(int)(x/y));
System.out.println(“x + 1 = “ +(++x));
}
}


Regras para criação de bons algoritmos

• Use comentários com freqüência. Isto torna o algoritmo mais legível e facilita o entendimento
da lógica empregada. Seus algoritmos deverão ser lidos e entendidos por outras pessoas (e
por você mesmo) de tal forma que possam ser corrigidos e receber manutenção.

Obs: Não se esqueça de atualizar os comentários, em caso de manutenção. Pior do que um
programa sem comentários, é um programa com comentários errados.

• Use comentários, também, no cabeçalho do algoritmo, incluindo, principalmente:
o descrição do que faz o algoritmo
o autor
o data de criação
• Escolha nomes de variáveis significativos, todavia evite nomes muito longos.
Ex: Prefira SalBruto ou SalarioBruto ao invés de SB ou VAR1
Prefira TotAlunosAprovDireta ao invés de TotalAlunosAprovacaoDireta
• Destaque as palavras-chave das estruturas de controle e comandos com sublinhado.
Ex: se media >= 7 então
• ...
senão
• ...
fim-se
• Utilize espaços e linhas em branco para melhorar a legibilidade.
• Coloque apenas um comando por linha. Vários comandos em uma linha causa ilegibilidade e
dificulta a depuração.
• Utilize parênteses para aumentar a legibilidade e prevenir-se de erros.
• Use identação nos comandos de acordo com o nível que estejam, ou seja, alinhe comandos
de mesmo nível e desloque comandos de nível inferior.






17

Ex.:
início
comando 1;
se condicao1 então
comando2;
comando3;
senão
comando4;
comando5;
fim-se
comando6;
fim

Método para desenvolvimento de algoritmos

1. Faça uma leitura de todo o problema até o final, a fim de formar a primeira impressão. A
seguir, releia o problema e faça anotações sobre os pontos principais.
2. Verifique se o problema foi bem entendido. Questione, se preciso, ao autor da especificação
sobre suas dúvidas. Releia o problema quantas vezes for preciso para tentar entendê-lo.
3. Extraia do problema todas as suas saídas.
4. Extraia do problema todas as suas entradas.
5. Identifique qual é o processamento principal.
6. Verifique se será necessário algum valor intermediário que auxilie a transformação das
entradas em saídas. Esta etapa pode parecer obscura no início, mas com certeza no desenrolar do
algoritmo, estes valores aparecerão naturalmente.
7. Teste cada passo do algoritmo, com todos os seus caminhos para verificar se o
processamento está gerando os resultados esperados.
8. Crie valores de teste para submeter ao algoritmo.
9. Reveja o algoritmo, checando as boas normas de criação.




18
Exercícios de fixação

1. Dadas as expressões a seguir, identificar o resultado verdadeiro ou falso que cada uma delas
retornaria, em função dos valores dados. Supondo A = 2 e B = 7.
a) A = 3 .e. B = 7
b) A < 3 .ou. B <> 7
c) A <= 2 .e. B = 7
d) .não. A = 2 .e. B = 7
e) A < 5 .e. B > 2 .ou. B <> 7

2. Verifique se as variáveis abaixo possuem nomes corretos e justifique as alternativas falsas:
a) n#1 b) tempo c) n_1 d) $din e) n 1
f) K2K g) n1 h) U F i) 2nome j) dep
k) nome2 l) val#r

3. Sabe-se que o uso incorreto da precedência de operadores ocasiona erros. Pensando nisso,
avalie as expressões a seguir e:

a) classifique a ordem em que as operações devem ser executadas;
b) determine o resultado das operações.

Considere os seguintes valores para as variáveis:
A <-- 8; B <-- 5; C <-- -4; D <-- 2

a) Delta <-- B
2
– 4 * A * C
b) J <-- “Hoje” <> “HOJE”
c) Media <--(A + B + C+ D)/4
d) Media <-- A + B + C + D/4
e) Resultado <-- A mod D/5
f) Resultado <-- (A mod D)/5
g) X <-- (A + B) – 10 * C
h) X <-- A + B – 10 * C
i) Y <-- A > 8 .e. B + C > D
j) Y <-- A > 3 * 2 .OU. B + C <> D

4. Considere a seguinte atribuição de valores para as variáveis:

A <-- 3, B <--4 e C <-- 8

a) A > 3 .e. C = 8
b) A <> 2 .ou. B <= 5
c) A = 3 .ou. B >= 2 .e. C = 8
d) A = 3 .e. .nâo. B >= 4 .e. C = 8
e) A <> 8 .ou. B = 4 .e. C > 2
f) B > A .e. C <> A
g) A > B .ou. B < 5
h) A <> B .e. B = C
i) C > 2 .ou. A < B
j) A > B .ou. B > A .e. C <> B

5. Complete a tabela-verdade a seguir:

0µerador
.e. .ou. .não.
Expressão A = 4 8 ·· 5 A = 4 .e. 8 ·· 5 A = 4 .ou. 8 ·· 5 .não. A = 4
Fesultados
possiveIs

19
0µerador



6. Construa a tabela-verdade para as expressões:

a) A >= 3 .ou. B = 5
b) A <> 9 .e. B <= 6
c) .não. A = 2 .OU. B >= 1
d) A > 3 .e. B <> 5 .ou. C < 8

7. Dada a declaração de variáveis:
A,B,C :inteiro;
x,y,z : real;
Nome, Rua :literal;
L1 : lógico;

e atribuindo-se a essas variáveis os valores:

A <-- 1 X <-- 2.5 Nome <-- “Pedro”
B <-- 2 Y <-- 10.0 Rua <-- “Girassol”
C <-- 3 Z <-- -1.0 L1 <-- .v.

Determine o resultado das expressões a seguir:
a) Nome = Rua
b) X > Y .e. C <= B
c) (C – 3 * A) < (X + 2 * Z)
d) ((Y/2) = X) .ou. ((B * 2) >= (A + C))
e) .não. L1
f) .não. C = B .e. X + Y <= 20 .OU. L1 <> .v.



20
Estruturas de controle

a criação de algoritmos utilizamos os conceitos de blocos lógicos, entrada e saída de dados,
variáveis, constantes, atribuições, expressões lógicas, relacionais e aritméticas, bem com
comandos que traduzam esses conceitos de forma a representar o conjunto de ações.
Para que esse conjunto de ações se torne viável, deve existir uma perfeita relação lógica
intrínseca ao modo pelo qual essas ações são executadas, ao modo pelo qual é regido o fluxo de
execução do algoritmo.
Através das estruturas básicas de controle do fluxo de execução – sequenciação, seleção,
repetição – e da combinação delas, poderemos criar algoritmos para solucionar nossos problemas.
Quando fazemos um programa, devemos saber construí-lo para prever qualquer intenção que
o usuário tenha ao utilizar esse programa.
É importante ressaltar a seqüência de fatos que fundamentam a lógica computacional: a
entrada de dados que serão processados para obter a saída. Os dados que entram em
processamento sofrem transformações resultantes do processo e uma saída é produzida,
representando a solução de um problema.






Estrutura Seqüencial

A estrutura seqüencial de um algoritmo corresponde ao fato de que o conjunto de ações
primitivas será executado em uma seqüência linear de cima para baixo e da esquerda para a direita,
isto é, na mesma ordem em que foram escritas. Convencionaremos que as ações serão seguidas por
um ponto-e-vírgula (;), que objetiva separar uma ação da outra e auxiliar a organização seqüencial
das ações, pois após encontrar um (;) deveremos executar o próximo comando da seqüência.
Mostramos abaixo o modelo geral de um algoritmo:

Início ff identificaçao do inicio do bloco correspondente ao algoritmo

ff declaraçao das variaveis

ff corpo do algoritmo
açao 1;
açao 2;
açao 3;
.
.

açao n;
fim. ff fim do algoritmo


Passagem de parâmetros em Java

Uma aplicação Java pode receber valores a partir da linha de comando, isto é, no momento
em que ele é executado. Quando um parâmetro é recebido por um programa, ele pode ser
manipulado internamente e usado em um procedimento qualquer. O exemplo a seguir, demonstra a
utilização da passagem de parâmetros a um programa. Este exemplo apresenta na tela as palavras
que o usuário digitar no momento da execução do programa por meio da linha de comando.

Exemplo 4:
N
PROCESSAMENTO ENTRADA SAÍDA
21

class Exemplo4{
public static void main (String args[]){
System.out.println(args[0]); //imprima o 1º argumento na tela;
System.out.println(args[1]); //imprima o 2º argumento na tela;

}
}

Ao executar o exemplo4, o usuário deve colocar o comando no seguinte formato:

java Exemplo4 argumento1 argumento2

Exemplo:
java Exemplo4 Aprendendo Java

Os argumentos passados na linha de comando sempre se referem a “variáveis” do tipo String
devido à sintaxe utilizada no método principal (main), ou seja, args é um vetor de String. Por esse
motivo, mesmo que sejam passados números como parâmetros, eles serão considerados como
caracteres.


Conversão de Tipos e Casting

Como vimos anteriormente, todos os dados recebidos como argumentos em uma aplicação
referem-se a valores do tipo String. Essa característica gera um inconveniente no caso de ser
necessária a utilização de valores de outro tipo. Em diversos tipos de programas em Java, necessita-
se realizar a conversão entre os diversos tipos primitivos existentes.
Em programação é comum atribuir a uma variável de um tipo um valor de outro tipo. Sempre
que os dois tipos forem compatíveis, a conversão será feita automaticamente em Java. Por exemplo,
é sempre possível atribuir a uma variável long um valor do tipo int. Contudo nem todos os tipos são
compatíveis e, portanto, nem todas as conversões são feitas automaticamente. Por exemplo, não
existe nenhuma convenção definida de double para byte. Felizmente, é possível converter tipos que
a princípio são incompatíveis. Para tanto, basta fazer uso do cast, que executa uma conversão de
tipos de forma explícita.
Conversões Automáticas
Quanto um tipo de dados é atribuído a uma variável de outro tipo, uma conversão automática
de tipos é feita desde que estas duas condições sejam satisfeitas:
• Os dois tipos são compatíveis.
• O tipo de destino é maior do que o tipo de origem.
Por exemplo, um long (64 bits) sempre poderá receber um int (32 bits), um short (16 bits) ou
um byte (8 bits). Isto porque são todos compatíveis (tipos inteiros) e o long do que todos os outros.


Cast de Tipos Incompatíveis

Embora a conversão automática de tipos seja de grande ajuda, ela não atende todas as
necessidades. Por exemplo, uma conversão de int para byte não é automática pois, embora sejam
tipos compatíveis, o byte é menor do que o int. Nestes casos, pode-se utilizar o cast para fazer a
conversão de forma explícita da seguinte forma:
(tipo desejado) valor
A seguir é mostrado um exemplo de casting e de conversão automática de tipos:

class Conversao{
public static void main(String args[]) {
byte b = 2;
int i;
22
double d - 2.987;

//conversão automática de byte para int
i = b;
System.out.println("Conversão de int para byte.");
System.out.println("i = " + i + " e b » " + b);
// conversão forçada de double para int
i = (int) d;
System.out.println("Conversão de double para int.");
System.out.println("d = " + d + " e i = " + i);
}
}

Este programa sera a seguinte saída:
Conversão de int para byte. i = 2 e b = 2
Conversão de double para int. d = 2.987 e i = 2


A linguagem Java possui uma série de classe que realizam essa tarefa de conversão. Segue
abaixo tabela mostrando essa tarefa:

Suµondo a varìável x Converter em A varìável y recebe o valor convetìjo
Int x = 10 float float y = (float) x
Int x = 10 double double y = (double) x
float x = 10.5 Int Int y = (Int) x
StrIng x = "10" Int Int y = Ìnteger.parseÌnt(x)
StrIng x = "20.54" double float y = Float.parseFloat(x)
StrIng x = "20.54" double double y = 0ouble.parse0ouble(x)
StrIng x = "java" 7etor de bytes byte b[] = x.get8ytes()
Int x = 10 StrIng StrIng y = StrIng.valueDf(x)
float x = 10.J5 StrIng StrIng y = StrIng.valueDf(x)
double x = 254.J5 StrIng StrIng y = StrIng.valueDf(x)
byte x[] ·( x é um vetor de bytes) StrIng StrIng y = new StrIng(x)

O exemplo 5 demonstra a criação de uma classe que recebe três valores da linha de
comando (nota1, nota2 e trabalho) e calcula a média entre as notas, utilizando para isso o conversor
de tipo String para double. Para que este exemplo seja executado com sucesso, existe a necessidade
de o usuário entrar com três dados numéricos na linha de comando, conforme mostrado abaixo:

Exemplo 5:

class Exemplo5{
public static void main (String args[]){
double nota1, nota2, trabalho, media;
nota1 = Double.parseDouble(args[0]);
nota2 = Double.parseDouble(args[1]);
trabalho = Double.parseDouble(args[2]);
media = (nota1+ nota2 + trabalho)/3;
System.out.println(“Media = “+ media);

}
}





23
Uso do teclado para a entrada de dados

Apesar de uma aplicação provavelmente não necessitar receber dados pelo prompt durante a
execução do programa, pois existem meios mais eficientes de fazer isso, é interessante verificar
como é possível entrar com dados via teclado. O exemplo 5 ilustra a resolução do problema
apresentado no exemplo 4 utilizando entrada via teclado:

Exemplo 6:

import java.io.*;
class Exemplo6{
public static void main(String args[]){
String s = " ";
float nota1 =0, nota2 =0, trabalho=0, media=0;
DataInputStream dado;
try{
System.out.println("Entre com a nota 1");
dado = new DataInputStream(System.in);
s = dado.readLine();
nota1 = Float.parseFloat(s);

System.out.println("Entre com a nota 2");
dado = new DataInputStream(System.in);
s = dado.readLine();
nota2 = Float.parseFloat(s);

System.out.println("Entre com a nota do trabalho");
dado = new DataInputStream(System.in);
s = dado.readLine();
trabalho = Float.parseFloat(s);

media = (nota1+ nota2+ trabalho)/3;
System.out.println("Media = "+ media);
}
catch(IOException e)
{
System.out.println("Houve erro na entrada de dados");
}
catch(NumberFormatException e)
{
System.out.println("Houve erro na conversao, digite apenas
caracteres numericos");
}
}
}

Uma breve explicação do exemplo:
• A linha 1 contém uma diretiva de compilação, isto é, contém um apontamento para uma classe
externa que será usada durante o processo de compilação. A instrução import indica que um
determinado pacote de classes deve ser carregado no momento da compilação. Isso é necessário
quando uma classe precisa utilizar recursos já definidos em outras classes. Neste exemplo está
sendo chamado o pacote java.io que contém uma série de classes especializadas em entrada e
saída de dados. No exemplo está sendo usada a classe DataInputStream que pertence ao pacote
java.io. Entenda o pacote como um grupo de classes de mesmo tipo armazenadas em uma pasta
qualquer. O asterisco presente em import java.io.* indica que devem ser carregadas todas as
classes presentes no pacote java.io. Uma alternativa é realizar a declaração da seguinte forma:
import java.io.DatInputStream, indicando que será utilizada apenas a classe DataInputStream.
• A linha 8 declara um objeto chamado dado a partir da classe DataInputStream. DataInputStream
é uma classe que possibilita a entrada de dados via teclado.
• A linha 9 contém o bloco try (tente). Um bloco constitui-se num trecho de código delimitado por
abre e fecha chaves. O bloco try sempre atua em conjunto com um ou vários blocos catch. O
interpretador Java tentará executar o bloco try e se algum erro ocorrer, a execução do programa
será desviada para um dos blocos catch, dependendo do erro gerado na aplicação. Neste
exemplo poderá ocorrer um erro de entrada de dados pelo teclado (IOException) e um erro na
conversão de String em float (NumberFormatException).
24
• Na linha 12 o objeto dado recebe o que foi digitado pelo usuário por meio de new
DataInputStream(System.in). Esta linha pode gerar algum tipo de erro, uma vez que manipula
troca de dados entre um periférico (teclado) e a memória. Caso ocorra algum erro, a execução do
programa será desviado para a linha 29 que trata de erros de entrada e saída de dados.
• Na linha 13, a variável s recebe o conteúdo do objeto dado (o que foi digitado pelo usuário).
• Na linha 14, o conteúdo da variável s é convertido em uma variável numérica do tipo float por
meio de Float.parseFloat. Neste momento pode ocorrer um erro de conversão, caso o usuário
tenha digitado um conteúdo diferente de número. Caso ocorra algum erro, a execução do
programa será desvida para a linha 33 que trata de erros de conversão de tipos.

Exemplo 7:
Neste exemplo o programa pergunta qual é o nome do usuário e o escreve novamente na tela.

import java.io.*;
class Exemplo7{
public static void main(String args[]){
BufferedReader entrada;
entrada = new BufferedReader (new InputStreamReader System.in));
String nome;
try{
System.out.println("Qual o seu nome?");
nome = entrada.readLine();
System.out.println(nome);
}
catch(Exception e)
{
System.out.println("Houve erro durante a leitura");
}
}
}

Uma breve explicação do exemplo:
• A cláusula import indica a utilização do pavote de entrada e saída de dados (java.io.*) da
linguagem Java nesse programa. Embora isso seja desnecessário para a saída de dados, a
linguagem requer um tratamento de entrada de dados para sua leitura correta.
• class Exemplo6 indica o nome do programa e, novamente, public static void main (String args[])
indica o bloco de instruções que serão executados quando o programa for requisitado pelo
usuário.
• Nas linhas 4 e 5 estão a declaração e a criação da variável entrada que será utilizada para a
leitura do teclado. Isso é necessário para garantir que a leitura seja armazenada na memóira com
o formato de uma seqüência de caracteres (String) para que seu valor possa ser manipulado
senmpre da mesma forma. A vantagem dessa sintace é que o programador pode utilizar apenas
uma varipavel de entrada e depois convertê-la para os valores desejados quantas vezes forem
necessárias.
• A variável nome está sendo declarada para receber e armazenar na memória o valor escrito pelo
usuário. Como se deseja a entrada de um texto, ela é declarada como do tipo String.
• As linhas 11, 12 e 13 definem um bloco de tratamento de erros característico da linguagem Java.
Sempre que houver entrada de dados na linguagem Java, um tratamento de erros similar será
necessário.
• A variável nome recebe, por meio do método readLine(), o valor que o usuário escreveu. A
variável entrada é um objeto que permite a utilização desse método para leitura. Essa maneira de
chamar métodos é típica da orientação a objetos.
• Após a leitura da variável, ela é mostrada na tela como saída de dados.

OBSERVAÇÀO:

A linguagem Java possui um pacote de classes padrão que é carregada toda vez que uma
classe é compilada. Trata-se do pacote java.lang. Caso esse pacote defaut não fosse carregado
automaticamente, mesmo para enviar qualquer informação na tela por meio de System.out.println,
seria necessário declarar explicitamente a diretiva. No caso da classe System, seria necessária a
seguinte declaração: import java.lang.System.
25
A utilização do * não gera overhead (sobrecarga) no programa e normalmente é utilizado para
reduzir o tamanho do código. A utilização do * pode gerar uma certa confusão, uma vez que ele deve
ser usado apenas para identificar um grupo de classes e não um grupo de pacotes. Por exemplo,
suponha que um programa utiliza os pacotes java.util.* (o asterisco indica todas as classes do pacote
util) e java.net.* (o asterisco indica todas as classes do pacote net). Não é possível utilizar java.*
achando que os dois pacotes (util e net) serão incorporados ao programa.

Exemplos:

a) Construa um algoritmo que calcule a média aritmética entre quatro notas semestrais
quaisquer fornecidas por um aluno (usuário).
b) Construa um algoritmo que calcule a quantidade de latas de tinta necessárias e o custo para
pintar tanques cilíndricos de combustível, em que são fornecidos a altura e o raio desse
cilindro.
Sabendo que:
• A lata de tinta custa R$ 50,00;
• Cada lata contém 5 litros;
• Cada litro de tinta pinta 3 metros quadrados.

c) Construa um algoritmo para calcular as raízes de uma equação do 2º grau (ax
2
+ bx + c),
sendo que os valores de a, b e c são fornecidos pelo usuário (considere que a equação
possui duas raízes reais).
d) Construa um algoritmo que, tendo como dados de entrada dois pontos quaisquer do plano
P(x
1
,y
1
) e Q(x
2
,y
2
), imprima a distância entre eles.
e) Faça um algoritmo para calcular o volume de uma esfera de raio R, em que R é um dado
fornecido pelo usuário.
f) Faça um algoritmo que receba duas variáveis numéricas, calcule e imprima:
• soma dos dois números;
• subtração do primeiro pelo segundo;
• subtração do segundo pelo primeiro;
• multiplicação dos dois números;
• divisão do primeiro pelo segundo;
• divisão do segundo pelo primeiro;
• quociente inteiro da divisão do primeiro pelo segundo;
• quociente inteiro da divisão do segundo pelo primeiro;
• resto da divisão do primeiro pelo segundo;
• resto da divisão do segundo pelo primeiro.

Algoritmos Resolvidos



Soluções em Java:

a)

class CalcMedia {
public static void main(String args[]){
double n1,n2,n3,n4,media;
n1 = Double.parseDouble(args[0]);
n2 = Double.parseDouble(args[1]);
n3 = Double.parseDouble(args[2]);
n4 = Double.parseDouble(args[3]);
media = (n1+n2+n3+n4)/4;
System.out.println("A media anual e: "+media);
}
}

b)
class tintas{
26
public static void main(String args[]){
double custo,Area,h,r,qtde_latas,total_litros;
h = Double.parseDouble(args[0]);
r = Double.parseDouble(args[1]);
Area = 3.14*Math.pow(r,2)+2*3.14*r*h;
total_litros = Area/3;
qtde_latas = total_litros/5;
custo = qtde_latas*50;
System.out.println("A quantidade de latas necessarias e:
"+(int)(qtde_latas));
System.out.println("O custo total da pintura e: "+(int)(custo));
}
}

c)
class Equacao {
public static void main(String args[]){
double a,b,c,x1,x2,delta;
a = Double.parseDouble(args[0]);
b = Double.parseDouble(args[1]);
c = Double.parseDouble(args[2]);
delta = Math.pow(b,2) - 4*a*c;
x1= (-b + Math.sqrt(delta))/2*a;
x2= (-b - Math.sqrt(delta))/2*a;
System.out.println("As raizes sao: x1 = "+x1 +" e x2 = " + x2);
}
}

d)
class DistPontos {
public static void main(String args[]){
double x1,x2,y1,y2,distancia;
x1 = Double.parseDouble(args[0]);
y1 = Double.parseDouble(args[1]);
x2 = Double.parseDouble(args[2]);
y2 = Double.parseDouble(args[3]);
distancia = Math.sqrt(Math.pow((x2-x1),2)+ Math.pow((y2-y1),2));
System.out.println("A distancia entre os pontos e: "+distancia);
}
}



e)
class RaioEsfera {
public static void main(String args[]){
double r,volume;
r = Double.parseDouble(args[0]);
volume = (4/3)*3.14*Math.pow(r,3);
System.out.println("O volume da esfera de raio "+r+" e: "+volume);
}
}

f)
class Operacoes{
public static void main(String args[]){
double x,y;
x = Double.parseDouble(args[0]);
y = Double.parseDouble(args[1]);
System.out.println("A soma do primeiro com o segundo e r = "+ (x+y));
System.out.println("A subtracao do primeiro pelo segundo e r = "+ (x-
y));
System.out.println("A subtracao do segundo pelo primeiro e r = " +(y-
x));
System.out.println("A multiplicacao do primeiro pelo segundo e r = "
+x*y);
27
System.out.println("A quociente do primeiro pelo segundo e r = "
+(int)(x/y));
System.out.println("A quociente do segundo pelo primeiro e r = "
+(int)(y/x));
System.out.println("O resto da divisao do primeiro pelo segundo e r =
" +(x%y));
System.out.println("O resto da divisao do segundo pelo primeiro e r =
" +(y%x));
}
}


Exercícios de Fixação - Estrutura seqüencial

1) Faça um algoritmo que receba dois números inteiros e imprima a soma desses dois números.
2) Faça um algoritmo que receba dois números reais, calcule e imprima a subtração do primeiro
número pelo segundo.
3) Faça um algoritmo que receba dois números inteiros, calcule e imprima a divisão do primeiro
número pelo segundo.
4) Faça um algoritmo que receba três notas de um aluno, calcule e imprima a média aritmética entre
essas notas.
5) Faça um algoritmo que receba duas notas de um aluno e seus respectivos pesos, calcule e
imprima a média ponderada dessas notas.
6) Faça um algoritmo que receba um valor de um depósito e o valor da taxa de juros. Calcule e
imprima o valor do rendimento e o valor total depois do rendimento.
7) Faça um algoritmo que receba um número inteiro, calcule e imprima a tabuada de multiplicação
desse número.
8) Faça um algoritmo que receba um número real, calcule e imprima:
• a parte inteira do número;
• a parte fracionária do número;
• arredondamento do número.
9) Faça um algoritmo que receba a medida de um ângulo em graus, calcule e imprima o seno e o
cosseno desse ângulo.
10) Faça um algoritmo que receba dois números, calcule e imprima um elevado ao outro.
11) Faça um programa que receba um número inteiro, calcule e imprima:
• a raiz quadrada desse número;
• esse número elevado ao quadrado.
12) Faça um algoritmo que receba o valor do salário de um funcionário e o valor do salário
mínimo. Calcule e imprima quantos salários mínimos ganha esse funcionário.
13) Faça um algoritmo que calcule e imprima a área das seguintes figuras geométricas:
• triângulo;
• quadrado;
• círculo;
• trapézio;
• retângulo;
• losango.

14) Calcular e exibir a área de um quadrado a partir do valor de sua diagonal que será digitado.
15) Faça um algoritmo que receba o salário de um funcionário, calcue e imprima o valor do
imposto de renda a ser pago, sabendo que o imposto equivale a 5% do salário.
16) Faça um algoritmo que receba o salário de um funcionário, calcule e imprima o novo salário
sabendo-se que este sofreu um aumento de 25%.
17) sabe-se que o kilowatt de energia custa um quinto do salário mínimo. Faça um algoritmo que
receba o valor do salário mínimo e a quantidade de quilowatts gasta por uma residência. Calcule e
imprima:
• o valor, em reais, de cada kilowatt;
• o valor, em reais, a ser pago por essa residência;
• o novo valor a ser pago por essa residência, a partir de um desconto de 15%.
18) Faça um algoritmo que receba o peso de uma pessoa, um valor inteiro, calcule e imprima:
• o peso dessa pessoa em gramas;
• se essa pessoa engordar 5%, qual será seu novo peso em gramas.

28
19) Faça um algoritmo que receba o ano de nascimento de uma pessoa e o ano atual. Calcule e
imprima:
• a idade dessa pessoa;
• essa idade convertida em semanas.

20) Crie um programa que receba três nomes quaisquer por meio da linha de execução do
programa, e os imprima na tela da seguinte maneira: o primeiro e o último nomes serão impressos
na primeira linha um após o outro, o outro nome (o segundo) será impresso na segunda linha.
21) Faça um programa que receba a quantidade e o valor de três produtos, no seguinte formato:
quantidade1 valor1 quantidade2 valor2 quantidade3 valor3. O programa deve calcular esses
valores seguindo a fórmula total = quantidade1* valor1 + quantidade2 * valor2 + quantidade3 *
valor3. O valor total deve ser apresentado no final da execução do programa.
22) Crie um programa que receba a largura e o comprimento de um lote de terra e mostre a área
total existente.
23) Crie um programa que receba valores quaisquer e mostre a média entre eles, o somatório
entre eles e o resto da divisão do somatório por cada um dos valores.
24) Uma determinada pessoa que trabalha com construção de piscinas precisa de um programa
que calcule o valor das construções solicitadas pelos clientes, sabendo-se que os clientes sempre
fornecem o comprimento, a largura e a profundidade da piscina a ser construída. Leve em
consideração que o valor da construção é cobrado por m
3
de água que a piscina conterá e o preço
é de R$ 45.00 por m
3
.
25) Entrar via teclado com o valor de cinco produtos. Após as entradas, digitar um valor referente
ao pagamento da somatória destes valores. Calcular e exibir o troco que deverá ser devolvido.
26) Escreva um algoritmo para trocar os valores de três variáveis A, B e C de modo que A fique
com o valor de B, B fique com o valor de C e C fique com o valor de A.




























29
Estruturas de seleção

Uma estrutura de seleção permite a escolha de um grupo de ações (bloco) a ser executado
quando determinadas condições, representadas por expressões lógicas ou relacionais, são ou não
satisfeitas.

Palavras-chave em Java
abstract boolean break byte case
catch char class cotinue default
do double else extends false
final finaly float for if
implements import instanceof int interface
long native new null package
private protected public return short
static super switch
syncronized this
throw throws transient true try
void volatile while
Palavras-chave que são reservadas mas não são utilizadas por Java
const goto
Palavras-chave em Java

Seleção Simples

Quando precisamos testar uma condição antes de executar uma ação, usamos uma seleção
simples, que segue o seguinte modelo:
se <condição> então
C; // comando único (ação primitiva)
fimse;
onde:
<condição> é uma expressão lógica que, quando inspecionada, pode gerar um resultado
falso ou verdadeiro.

Quando existir apenas uma ação após a cláusula, então basta escrevê-la; já quando
precisamos colocar diversas ações é necessário usar um bloco, delimitado por inicio e fim, conforme
o seguinte modelo:

se <condição> então
inicio // inicio do bloco verdade
C1;
C2; // seqüência de comandos
.
.
Cn;
fim; //fim do bloco verdade
fimse;

Se <condição> for verdadeira, então, o “bloco verdade” (seqüência de comandos C1 . . . Cn)
será executado; caso contrário (<condição> for falsa), nada é executado, encerrando-se a seleção
(fimse). A existência do bloco (demarcado por inicio e fim) é necessária devido à existência de um
conjunto de ações primitivas sob a mesma cláusula então.
Em Java esta estrutura possui as seguintes sintaxes:

a) if (<condição>)
C; // comando único (ação primitiva)
b) if (<condição>) { // inicio do bloco verdade
C1;
30
C2; // seqüência de comandos
.
.
Cn;
} //fim do bloco verdade

Observe que a condição deve sempre aparecer entre parênteses, item obrigatório na
linguagem Java.

Exemplo: Construa um algoritmo que calcule a média aritmética entre quatro notas semestrais
quaisquer fornecidas por um aluno (usuário). O programa deve informar, caso o aluno obtenha nota
maior ou igual a seis, o programa deverá emitir a mensagem “Aluno aprovado”.

a) algoritmo em pseudocódigo
inicio
//declaração de variáveis
n1,n2,n3,n4,ma:real;
leia(n1,n2,n3,n4); //entrada de dados
ma := (n1+n2+n3+n4)/4; //processamento
escreva(ma); //saída de dados
se (ma >= 6) então
escreva(“aluno aprovado”);
fimse;
fim.

b) programa em Java

class CalcMedia {
public static void main(String args[]){
double n1,n2,n3,n4,ma;
n1 = Double.parseDouble(args[0]);
n2 = Double.parseDouble(args[1]);
n3 = Double.parseDouble(args[2]);
n4 = Double.parseDouble(args[3]);
ma = (n1+n2+n3+n4)/4;
System.out.println("A media anual e: "+media);
if (ma >= 6)
System.out.println("Aluno aprovado");
}
}


Seleção Composta

Quando tivermos situações em que duas alternativas dependem de uma mesma condição,
uma das condições ser verdadeira e outra condição ser falsa, usamos a estrutura de seleção
composta. Supondo que um conjunto de ações dependa da avaliação verdadeiro e uma única ação
primitiva dependa da avaliação falso, usaremos uma estrutura de seleção semelhante ao seguinte
modelo:

se <condição> então
inicio // inicio do bloco verdade
C1;
C2; // seqüência de comandos
.
.
Cn;
fim; //fim do bloco verdade
senão
C; //ação primitiva
fimse;

31
Observamos que a existência do bloco verdade continua, sendo que este será executado
caso <condição> (expressão lógica) seja verdadeiro; porém, a seleção agora é composta, pois, caso
o resultado seja falso, teremos a execução do comando C (ação primitiva) que segue a cláusula
senão.

Em Java esta estrutura possui a seguinte sintaxe:

if (<condição>) { // inicio do bloco verdade
C1;
C2; // seqüência de comandos
.
.
Cn;
} //fim do bloco verdade
else
C;

Assim como a maioria das instruções Java, o conjunto if else deve ser utilizado em
minúsculas e caso haja apenas uma instrução a ser executada, tanto no if como no else, o uso das
chaves se faz desnecessário. Lembre-se de que as chaves são utilizadas quando se necessita que
um bloco de instruções seja executado.

Exemplo: Construa um algoritmo que calcule a média aritmética entre quatro notas semestrais
quaisquer fornecidas por um aluno (usuário). O programa deve informar, caso o aluno obtenha nota
maior ou igual a seis, o programa deverá emitir a mensagem “Aluno aprovado”, caso contrário, “Aluno
reprovado”.

a) algoritmo em pseudocódigo
inicio
//declaração de variáveis
n1,n2,n3,n4,ma:real;
leia(n1,n2,n3,n4); //entrada de dados
ma := (n1+n2+n3+n4)/4; //processamento
escreva(ma); //saída de dados
se (ma >= 6) então
escreva(“aluno aprovado”);
senao
escreva(“aluno reprovado”);
fimse;
fim.

b) programa em Java

class CalcMedia {
public static void main(String args[]){
double n1,n2,n3,n4,ma;
n1 = Double.parseDouble(args[0]);
n2 = Double.parseDouble(args[1]);
n3 = Double.parseDouble(args[2]);
n4 = Double.parseDouble(args[3]);
ma = (n1+n2+n3+n4)/4;
System.out.println("A media anual e: "+media);
if (ma >= 6)
System.out.println("Aluno aprovado!, Parabéns!");
else
System.out.println("Aluno reprovado!, Estude mais! ");
}
}





32
Seleção Encadeada

Quando, devido à necessidade de processamento, agruparmos várias seleções, formaremos
uma seleção encadeada. Normalmente, tal formação ocorre quando uma determinada ação ou bloco
deve ser executado se um grande conjunto de possibilidades ou combinações de situações for
satisfeita.

Seleção encadeada Heterogênea

Podemos construir uma estrutura de seleção de diversas formas, sendo que, ao
encadearmos várias seleções, as diferentes possibilidades de construção tendem a um número
elevado.
Quando não conseguimos identificar um padrão lógico de construção em uma estrutura de
seleção encadeada, dizemos que esta é uma estrutura de seleção encadeada heterogênea.

se <condição1> então
se <condição2> então
inicio // bloco verdade1
C1;
C2; // seqüência de comandos
.
.
Cn;
fim; //bloco verdade1
fimse;
senão
se <condição3> então
inicio // bloco verdade2
C1;
C2; // seqüência de comandos
.
.
Cn;
fim; //bloco verdade2
senão
se <condição4> então
se <condição5> então
CV; // comando verdade
fimse;
senão
CF; //comando verdade
fimse;
fimse;
fimse;

Podemos resumir todas as variações possíveis da seleção encadeada do modelo anterior em
uma tabela de decisão, conforme a tabela abaixo:

Condìçáo 1 Condìçáo 2 Condìçáo 3 Condìçáo 4 Condìçáo 5 Açáo executada
V V - - - ßIoco verdade1
F - V - - ßIoco verdade2
F - F V V Comando verdadeIro
F - F F - Comando faIso

Exemplo: Dados três valores A, B e C, verificar se eles podem ser os comprimentos dos lados de
um triângulo e, se forem, verificar se compõem um triângulo equilátero, isósceles ou escaleno.
Informar se não compuserem nenhum triângulo.

a) algoritmo em pseudocódigo
33
inicio
a,b,c:inteiro;
leia(a,b,c);
se ((a < b + c) e (b < a + c) e (c < a + b)) então
se (a = b) e (b = c) então
escreva(“Triângulo equilátero”);
senão
se ((a = b) ou (a = c) ou (b = c)) então
escreva(“Triângulo isósceles”);
senão
escreva(“Triângulo escaleno”);
fimse;

senão
escreva(“Estes valores não formam um triângulo”);
fimse;
fim.

b) programa em Java

class triangulo{
public static void main(String args[]){
int a,b,c;
a = Integer.parseInt(args[0]);
b = Integer.parseInt(args[1]);
c = Integer.parseInt(args[2]);
if ((a < b + c)&&(b < a + c) && (c < a + b)){
if ((a == b) && (b == c))
System.out.println("Triangulo equilatero");
else
if ((a == b) || (a == c) || (b == c))
System.out.println("Triangulo isosceles");
}
else
System.out.println("Os lados nao formam um triangulo");
}
}

Seleção encadeada Homogênea

Chamamos de seleção encadeada homogênea a construção de diversas estruturas de
seleção encadeada que seguem um determinado padrão lógico.

• Se Então se
Vamos supor que, em um dado algoritmo, um comando genérico W deva ser executado
apenas quando forem satisfeitas as condições <condição1>, <condição2>. <condição3> e
<condição4>. Teríamos:

se <condição1> então
se <condição2> então
se <condição3> então
se <condição4> então
W;
fimse;
fimse;
fimse;
fimse;

Esta construção segue um padrão. Após cada então existe outro se, e não existem senões;
temos uma estrutura homogênea. Outro fato importante é que o comando W sé será executado
quando todas as condições forem ao mesmo tempo verdadeiras; portanto, seria equivalente a
escrever, simplificadamente:

34
se <condição1> e <condição2> e <condição3> e <condição4> então
W;
fimse;

A tabela abaixo expressa nitidamente a necessidade de todas as condições serem
verdadeiras, simultaneamente:

Condìçáo1 Condìçáo2 Condìçáo3 Condìçáo4 Açáo executada
V V V V W

• Se senão se

Vamos supor que em determinado algoritmo uma variável X possa assumir apenas quatro
valores, sendo eles V1, V2, V3, V4, e que exista um comando diferente que será executado para
cada valor armazenado em X.
Teremos, por exemplo, a seguinte situação:

se (X = V1) então
C1;
fimse;
se (X = V2) então
C2;
fimse;
se (X = V3) então
C3;
fimse;
se (X = V4) então
C4;
fimse;

A tabela de decisão para o exemplo é:

X = V1 X = V2 X = V3 X = V4 Açáo
V F F F C1
F V F F C2
F F V F C3
F F F V C4

Somente um e apenas um, comando pode ser executado, isto é, trata-se de uma situação
excludente (se X é igual a V3, não é igual a V1, nem a V2, nem a V4).
Não se trata de uma estrutura encadeada, pois as seleções não estão interligadas. Por isso
todas as condições (X = Vn) serão avaliadas e ocorrerão testes desnecessários. Para melhorar a
performance dessa estrutura, podemos transformá-la em um conjunto de seleções encadeadas,
conforme o seguinte modelo:

se (X = V1) então
C1;
senão se (X = V2) então
C2;
senão se (X = V3) então
C3;
senão se (X = V4) então
C4;
fimse;
fimse;
fimse;
fimse;

Essa nova estrutura de seleção gera a tabela de decisão mostrada abaixo:
35

X = V1 X = V2 X = V3 X = V4 Açáo
V - - - C1
F V - - C2
F F V - C3
F F F V C4

Nessa estrutura, o número médio de testes a serem executados foi reduzido. Se o conteúdo
de X for igual a V2, serão executados apenas dois testes (X = V1) e (X = V2) e um comando (C2),
enquanto na estrutura anterior seriam inspecionados quatro condições, embora um único comando
(C2) tenha sido executado.
Essa construção segue um padrão, após cada senão existe outro comando se e depois do
então existe uma ação qualquer (que não seja outra seleção), compondo uma estrutura típica que
denominaremos se-senão-se.
Por constituir um encadeamento homogêneo, pode ser simplificado, e para tal utilizaremos
uma nova estrutura, a seleção de múltipla escolha.


Seleção de múltipla escolha

Quando um conjunto de valores discretos precisa ser testado e ações diferentes são
associadas a esses valores, estamos diante de uma seleção encadeada homogênea do tipo se-
senão-se. Como esta situação é bastante freqüente na construção de algoritmos que dependem de
alternativas, utilizaremos uma estrutura específica para estes casos, a seleção de múltipla escolha.
O modelo que expressa as possibilidades do exemplo anterior é o seguinte:

escolha x
caso V1: C1;
caso V2: C2;
caso V3: C3;
caso V4: C4;
.
.
.
caso Vn:Cn
fimescolha;

Caso o conteúdo da variável X seja igual ao valor de Vn, então, o comando Cn será
executado; caso contrário, serão inspecionados os outros casos até ser encontrada uma igualdade ou
terminarem os casos.
Para executarmos um comando que possui mais de um valor em que se verifica sua
necessidade, agrupamos todos esses valores em um único caso. E, para executarmos um comando
que se verifica com todos os outros valores, exceto os discriminados caso a caso, incluímos outra
situação: caso contrário.
O exemplo genérico a seguir mostra uma estrutura de seleção encadeada homogênea se-
senão-se:

se (X = V1) então
C1;
senão se (X = V2) então
C2;
senão se (X = V3) então
C2;
senão se (X = V4) então
C3;
senão se (X = V5) então
C4;
senão
C5;
fimse;
36
fimse;
fimse;
fimse;
fimse;

que ao ser reescrita utilizando a estrutura de múltipla escolha fica da seguinte maneira:
escolha x
caso V1: C1;
caso V2,V3: C2;
caso V4: C3;
caso V5: C4;
caso contrário:C5;
fimescolha;



Exemplos:

1. Construa um algoritmo que, tendo como dados de entrada o preço de um produto e seu código de
origem, mostre o preço junto de sua procedência. Caso o código não seja nenhum dos
especificados, o produto deve ser encarado como importado. Siga a tabela de código a seguir:
Còdìyo de orìyem Procedëncìa
1 sul
2 norte
J leste
4 oeste
5 ou 6 nordeste
7,8 ou 9 sudeste
10 Centro·oeste
25 nordeste

2. Crie um programa que receba pelo teclado (use DataInputStream) o valor de um produto e um
código de aumento, segundo a tabela seguinte:
Còdìyo X aumento
1 15
J 20
4 J5
8 40
Utilizando a estrutura switch-case, mostre na tela o novo valor do produto depois de
acrescida a porcentagem correspondente. Realize também o
controle dos possíveis erros que podem ocorrer durante a execução do
programa.

3) Faça um aplicativo que receba três números inteiros na linha de comando e mostre o maior dentre
eles.
4) Crie um programa para cálculo do salário líquido em que três valores devem ser informados pelo
usuário na linha de comando: a quantidade de horas trabalhadas, o salário hora e o número de
dependentes. O programa deve mostrar na tela as informações contidas no lado esquerdo da
tabela seguinte. Os cálculos correspondentes aparecem no lado direito.
lnjormaçáo Cálculo
SalárIo bruto Horas trabalhadas * salárIo hora + (50*nº dependentes)
37
lnjormaçáo Cálculo
0esconto ÌNSS · se salárIo bruto ·= 1000
ÌNSS = salárIo bruto*8.5/100
· se salárIo bruto · 1000
ÌNSS = salárIo bruto *9/100
0esconto ÌF · se salárIo bruto ·= 500
ÌF = 0
· se salárIo bruto · 500 e ·= 1000
ÌF = salárIo bruto *5/100
· se salárIo bruto · 1000
ÌF = salárIo bruto *7/100
SalárIo LiquIdo SalárIo bruto - ÌNSS · ÌF

5) A empresa XKW Ltda. Concedeu um bônus de 20 por cento do valor do salário a todos os
funcionários com tempo de trabalho na empresa igual ou superior a cinco anos e dez por cento
aos demais. Calcular e exibir o valor do bônus.


Algoritmos Resolvidos
1)
inicio
//declaração de variáveis
preco:real;
origem:inteiro;
leia(preco,origem);
escolha origem
caso 1: escreva(preco, “ - produto do Sul”);
caso 2: escreva(preco, “ - produto do Norte”);
caso 3: escreva(preco, “ - produto do Leste”);
caso 4: escreva(preco, “ - produto do Oeste”);
caso 7.8,9: escreva(preco, “ - produto do Sudestel”);
caso 10: escreva(preco, “ - produto do Centro-Oeste”);
caso 5,6,25: escreva(preco, “ - produto do Nordeste”);
caso contrario: escreva(preco, “ - produto importado”);
fimescolha;
fim.

4)

inicio
//declaração de variáveis
salario, bonus :real;
tempo:inteiro;
leia(salario, tempo);
se(tempo >=5) então
bonus = salario*0.20;
senão
bonus = salario*0.10;
fimse;
escreva(“O valor do bonus e: “, bonus);
fim.

Soluções em Java:

1)
import java.io.*;
class ExSelecao4{
public static void main(String args[]){
BufferedReader entrada;
entrada = new BufferedReader (new InputStreamReader (System.in));
38
double preco;
int origem;
try{
System.out.println("Entre com o preço do produto:");
preco = Double.parseDouble(entrada.readLine());

System.out.println("Entre com o codigo de origem:");
origem = Integer.parseInt(entrada.readLine());

switch(origem){
case 1:System.out.println("R$ " +preco + " - produto do
Sul");break;
case 2:System.out.println("R$ " +preco + " - produto do
Norte");break;
case 3:System.out.println("R$ " +preco + " - produto do
Leste");break;
case 4:System.out.println("R$ " +preco + " - produto do
Oeste");break;
case 7:
case 8:
case 9:System.out.println("R$ " +preco + " - produto do
Sudeste");break;
case 10:System.out.println("R$ " +preco + " - produto do Centro-
Oeste");break;
case 5:
case 6:
case 25:System.out.println("R$ " +preco + " - produto do
Nordeste");break;
default: System.out.println("R$ " +preco +"Produto importado");
}
}
catch(Exception e)
{
System.out.println("Houve erro durante a leitura");
}
}
}



2)
import java.io.*;
class ExSelecao1{
public static void main(String args[]){
String s = " ";
float valor = 0;
int codigo;
DataInputStream dado;
try{
System.out.println("Entre com o valor do produto:");
dado = new DataInputStream(System.in);
s = dado.readLine();
valor = Float.parseFloat(s);

System.out.println("Entre com o codigo do aumento:");
dado = new DataInputStream(System.in);
s = dado.readLine();
codigo = Integer.parseInt(s);

switch(codigo){
case 1:System.out.println("O valor com o aumento e:
"+(valor+(valor*0.15)));break;
case 3:System.out.println("O valor com o aumento e:
"+(valor+(valor*0.20)));break;
case 4:System.out.println("O valor com o aumento e:
"+(valor+(valor*0.35)));break;
39
case 8:System.out.println("O valor com o aumento e:
"+(valor+(valor*0.40)));break;
default: System.out.println("Codigo invalido");
}
}
catch(IOException e)
{
System.out.println("Houve erro na entrada de dados");
}
catch(NumberFormatException e)
{
System.out.println("Houve erro na conversao, digite apenas
caracteres numericos");
}
}
}

3)
class ExSelecao2{
public static void main(String args[]){
int a,b,c,aux;
a = Integer.parseInt(args[0]);
b = Integer.parseInt(args[1]);
c = Integer.parseInt(args[2]);
if(a>b){
aux = a;
a = b;
b = aux;
}
if(a>c){
aux = a;
a = c;
c = aux;
}
if(b>c){
aux = b;
b = c;
c = aux;
}
System.out.println(" "+a+ " " +b+ " "+c);
}
}

3)

import java.io.*;
class ExSelecao3{
public static void main(String args[]){
BufferedReader entrada;
entrada = new BufferedReader (new InputStreamReader (System.in));
double HT, SH, ND,Sal_Bruto, INSS=0, IR=0, Sal_Liquido;
try{
System.out.println("Entre com a quantidade de horas trabalhadas:");
HT = Double.parseDouble(entrada.readLine());

System.out.println("Entre com o valor da hora trabalhada:");
SH = Double.parseDouble(entrada.readLine());

System.out.println("Entre com o numero de dependentes:");
ND = Double.parseDouble(entrada.readLine());

//calculo do salario bruto

Sal_Bruto = HT * SH + (50*ND);

//calculo do INSS
if(Sal_Bruto <=1000)
40
INSS = Sal_Bruto*8.5/100;
if(Sal_Bruto >1000)
INSS = Sal_Bruto*9/100;

//calculo do Imposto de Renda
if(Sal_Bruto <=500)
IR = 0;
if((Sal_Bruto >500)&&(Sal_Bruto <=1000))
IR = Sal_Bruto*5/100;
if(Sal_Bruto >1000)
IR = Sal_Bruto*7/100;

//Calculo do salario liquido
Sal_Liquido = Sal_Bruto - INSS - IR;

//Impressão do resultado
System.out.println("O salario bruto e de: " +Sal_Bruto);
System.out.println("O Desconto de INSS foi de: " +INSS);
System.out.println("O Desconto de IR foi de: " +IR);
System.out.println("O salario Liquido e de: " +Sal_Liquido);


}
catch(Exception e)
{
System.out.println("Houve erro durante a leitura");
}
}
}

+)

import java.io.*;
class ExSelecao4{
public static void main(String args[]){
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));
float salario,bonus;
int tempo;

try{
System.out.println("Entre com o salario:");
salario = Float.parseFloat(entrada.readLine());
System.out.println("Quanto tempo esta na empresa?");
tempo = Integer.parseInt(entrada.readLine());
if(tempo >=5)
bonus = salario*0.20f;
else
bonus = salario*0.10f;
System.out.println("O valor do bonus e: "+ bonus);
}catch(IOException e){
System.out.println("Ocorreu erro durante a leitura");
}
}

}

Exercícios de fixação - Estrutura de seleção

1) Faça um programa que receba quatro notas de um aluno, calcule e imprima a média aritmética
das notas e a mensagem de aprovado para média superior ou igual a 7.0 ou a mensagem de
reprovado para média inferior a 7.0.
2) Uma empresa decide dar um aumento de 30% aos funcionários cujo salário é inferiora 500 reais.
Escreva um programa que receba o salário de um funcionário e imprima o valor do salário
reajustado ou uma mensagem caso o funcionário não tenha direito ao aumento.
41
3) Faça um programa que verifique a validade de uma senha fornecida pelo usuário. A senha é um
conjunto de caracteres que são: 'ASDFG'. O programa deve imprimir mensagem de permissão ou
negação de acesso.
4) Faça um programa que receba a idade de uma pessoa e imprima mensagem de maioridade ou
não.
5) Faça um programa que calcule e imprima o salário reajustado de um funcionário de acordo com a
seguinte regra:
• salários até 300, reajuste de 50%;
• salários maiores que 300, reajuste de 30%.
6) Faça um programa que receba a altura e o sexo de uma pessoa, calcule e imprima o seu peso
ideal, utilizando as seguintes fórmulas:
• para homens: (72.7 * H) - 58;
• para mulheres: (62.1 * H) – 44.7.
7) Faça um programa que receba a idade de um nadador e imprima a sua categoria seguindo as
regras:

categoria idade
infantil A 5 – 7 anos
infantil B 8 – 10 anos
juvenil A 11 – 13 anos
juvenil B 14 – 17 anos
sênior maiores de 18 anos

8) No curso de Desenvolvimento de Software, a nota final do estudante é calculada a partir de 3
notas atribuídas respectivamente a um trabalho de laboratório, a uma avaliação semestral e a um
exame final. As notas variam de 0 a 10 e a nota final é média ponderada das 3 notas
mencionadas. A tabela a seguir fornece os pesos das notas:
Laboratório - peso 2
Av. Semestral - peso 3
Exame final - peso 5
Faça um programa que receba as 3 notas do estudante, calcule e imprima a
média final e o conceito desse estudante.
O conceito segue a tabela abaixo:
média final conceito
8.0 |__| 10.0 A
7.0 |__ 8.0 B
6.0 |__ 7.0 C
5.0 |__ 6.0 D
< 5.0 E

9) Faça um programa que receba o preço de um produto e o seu código de orígem e imprima a sua
procedência. A procedência obedece a seguinte tabela:
Código Procedência
1 Sul
2 Norte
3 Leste
4 Oeste
5 ou 6 Nordeste
7.8 ou 9 Sudeste
10 até 20 Centro-Oeste
21 até 30 Nordeste

10) Faça um programa que receba um número, verifique se este número é par ou ímpar e
imprima a mensagem.
11) Faça um programa que receba dois números e imprima o menor dos dois.
12) Faça um programa que receba três notas de um aluno, calcule e imprima a média aritmética
entre essas três notas e uma mensagem que segue a tabela abaixo:
Média Mensagem
0.0 |__ 5.0 reprovado
5.0 |__ 7.0 exame
7.0 |__| 10.0 aprovado

42
13) Faça um programa que receba a idade de uma pessoa e classifique-a seguindo o critério a
seguir:
ìdade Classìjìcaçáo
0 a 2 anos Fecém·nascIdo
J a 11 anos crIança
12 a 19 anos adolescente
20 a 55 anos adulto
AcIma de 55 anos Idoso

14) Faça um programa que receba o código correspondente ao cargo de um funcionário e
imprima seu cargo e o percentual de aumento ao qual este funcionário tem direito seguindo a
tabela:
Còdìyo Caryo Percentual
1 EscrIturárIo 50,00º
2 SecretárIo J5,00º
J CaIxa 20,00º
4 Cerente 10,00º
5 0Iretor Não tem aumento

15) Faça um programa que mostre um menu com as seguintes opções:
• soma
• raiz quadrada
• finalizar
O programa deve receber a opção desejada, receber os dados necessários para a
operação de cada opção, realizar a operação e imprimir o resultado. Na opção
finalizar nada deve acontecer.

16) Uma companhia de seguros tem três categorias de seguros baseadas na idade e na
ocupação do segurado. Somente pessoas com pelo menos 18 anos e não mais de 70 anos podem
adquirir apólices de seguros. Quanto às classes de ocupações foram definidos três grupos de
risco. A tabela a seguir fornece as categorias em função da caixa de idade e do grupo de risco:

Cruµo de rìsco
ìdade
ßaIxo hédIo AIto
18 a 24 7 8 9
25 a 40 4 5 6
41 a 70 1 2 J

Faça um programa que receba a idade e o grupo de risco (b, m ou a) e
determine e imprima o código do seguro.

17) Faça um programa que receba a medida de um ângulo em graus, um número inteiro.
Determine e imprima o quadrante em que se localiza este ângulo. Considere os quadrantes
abaixo:
Ângulo Quadrante
0 |__ 90 1º quadrante
90 |__ 180 2º quadrante
180 |__ 270 3º quadrante
270 |__ 360 4º quadrante
0 __ -90 1º quadrante
43
Ângulo Quadrante
-90 |__ -180 2º quadrante
-180 |__ -270 3º quadrante
-270 |__| -360 4º quadrante
Para ângulos maiores que 360 graus, reduza ao intervalo de 0 a 360.

18) Uma empresa decidiu dar uma gratificação de Natal aos seus funcionários, baseada no
número de horas extras e no número de horas que o funcionário faltou ao trabalho. O valor do
prêmio é obtido pela consulta na tabela a seguir, em que:
H = (número de horas extras) – (2/3*(número de horas-falta))

H (mìnutos) Prëmìo ($)
· 240 500
1800 __¦ 2400 400
1200 __¦ 1800 J00
600 __¦ 1200 200
·= 600 100
Faça um programa que receba o número de horas extras e o número de
horas- falta em minutos de um funcionário. Imprima o número de horas
extras em horas, o número de horas, o número de horas-falta em horas e o
valor do prêmio.
19) Faça um programa que receba o valor do salário mínimo, o número de horas trabalhadas, o
número de dependentes do funcionário e a quantidade de horas extras trabalhadas. Calcule e
imprima o salário a receber do funcionário seguindo as regras abaixo:
• o valor da hora trabalhada é igual a 1/5 do salário mínimo;
• o salário do mês é igual ao número de horas trabalhadas vezes o valor da hora
trabalhada;
• para cada dependente acréscimo de 32 reais;
• para cada hora extra trabalhada o cálculo do valor da hora trabalhada acrescida de 50%;
• o salário bruto é igual ao salário do mês mais os valores dos dependentes mais os
valores das horas extras;
• o cálculo do valor do imposto de renda retido na fonte segue a tabela abaixo:
lRRF Salárìo bruto
Isento ÌnferIor a 200
10,00º de 200 até 500
20,00º superIor a 500

• o salário líquido é igual ao salário bruto menos IRRF;
• a gratificação segue a próxima tabela:
Salário líquido Gratificação
Até 350 100 reais
Superior a 350 50 reais

• o salário a receber do funcionário é igual ao salário líquido mais a gratificação.
20) Faça um programa para resolver equações do 2º grau.
21) Faça um programa que receba uma frase, conte e imprima o número de vogais desta frase.
22) Faça um programa que receba uma frase, conte e imprima o número de palavras desta frase.
23) Faça um programa que receba uma frase, conte e imprima a quantidade de vezes em que
aparece a palavra “aula”.
24) Escreva um programa que leia três valores inteiros e mostre-os em ordem crescente.
25) Escreva um programa que calcule o que deve ser pago por um produto, considerando o preço
normal de etiqueta e a escolha da condição de pagamento. Utilize os códigos da tabela a seguir
para ler qual a condição de pagamento escolhida e efetuar o cálculo adequado:
Còdìyo Condìçáo de µayamento
44
Còdìyo Condìçáo de µayamento
1 A vIsta em dInheIro ou cheque, recebe 10º de desconto.
2 A vIsta no cartão de crédIto, recebe 5º de desconto.
J Em 2 vezes, preço normal de etIqueta sem juros.
4 Em J vezes, preço normal de etIqueta maIs juros de 10º.

26) Escreva um programa que leia o valor de dois números inteiros e a operação aritmética
desejada: calcule, então, a reposta adequada. Utilize os símbolos da tabela a seguir para ler qual
a operação aritmética escolhida:
Símbolo 0µeraçáo arìtmètìca
+ adIção
· subtração
* multIplIcação
/ dIvIsão

27) Construa um programa que seja capaz de concluir qual dentre os seguintes animais foi
escolhido, através de perguntas e respostas. Animais possíveis: leão, cavalo, homem, macaco,
morcego, baleia, avestruz, pinguim, pato, águia, tartaruga, crocodilo e cobra.
Exemplo:
é mamífero? Sim
é quadrúpede? Sim
é carnívoro? Não
é herbívoro? Sim
então o animal escolhido foi o cavalo
utilize as seguintes classificações:
Carnívoro Leão
Quadrúpede
Herbívoro Cavalo

Mamíferos Onívoro Homem
Bípede
Frutíferos Macaco

Voadores Morcego
Aquáticos Baleia

Tropical Avestruz
Não-voadoras
Polar Pinguim
Aves
Nadadoras Pato
De rapina Águia

Com casco Tartaruga
Répteis Carnívoro Crocodilo
Sem patas cobra


45
28. O que será impresso depois de executado o seguinte algoritmo:
a) num = 20
b) num = -3
c) num = 0

leia(num)
se num > 0 então
quale = 'NUMERO POSITIVO'
senão
se num < 0 então
quale = 'NUMERO NEGATIVO'
senão
quale = 'zero';
fim se;
fim se;
escreva(quale);


29. Verificar se dados três valores inteiros quaisquer os mesmo formam um triângulo. Se formar
informar o tipo, caso contrário, informar que os lados não formam um triângulo.
30. Efetuar a leitura de quatro número e apresentar os números que são divisíveis por 2 e 3.



Estruturas de repetição

Imaginemos a situação problema de construir um algoritmo para calcular a média aritmética
de 50 alunos de uma turma. Como visto anteriormente, podemos solucionar este problema
escrevendo o algoritmo da seção anterior uma vez para cada aluno. Ou seja, no caso dos 50 alunos,
teríamos de escrevê-lo 50 vezes. Trata-se de uma solução simples, porém inviável.
Outro modo de resolver essa questão seria utilizar a mesma seqüencia de comandos
novamente, ou seja, teríamos de realizar um retrocesso – ao início dos comandos – para cada aluno,
fazendo, portanto, com que fluxo de execução repetisse certo trecho do algoritmo, o que nesta
aplicação corresponderia a repetir o mesmo trecho 50 vezes, sem, no entanto, ter de escrevê-lo 50
vezes.
A esses trechos de algoritmos que são repetidos damos o nome de laços de repetição. O
número de repetições pode ser indeterminado, porém, necessariamente finito.
Para construir um laço finito, podemos proceder de dois modos:

• calcular média enquanto a quantidade de médias calculadas for menor ou igual a 50;
• calcular a média até que o número de médias calculadas atinja 50.


Repetição com teste no início

Consiste em uma estrutura de controle de fluxo que permite repetir diversas vezes um mesmo
trecho de algoritmo, porém, sempre verificando antes de cada execução se é “permitido” executar o
mesmo trecho.
Para realizar a repetição com teste no início, utilizamos a estrutura enquanto, que permite
que um bloco ou uma ação primitiva seja repetida enquanto uma determinada <condição> for
verdadeira. O modelo genérico deste tipo de repetição é o seguinte:

a) em pseudocódigo
enquanto <condição> faça
C1;
C2;
.
.
.
Cn;
fimenquanto;

46
b) em Java

while(<condicao>){
}

Quando o resultado de <condição> for falso, o comando de repetição é abandonado. Se já da
primeira vez o resultado é falso, os comandos não são executados nenhuma vez, o que representa a
característica principal desse modelo de repetição.
Para exemplificar, voltemos ao problema da média da turma de 50 alunos. Em primeiro lugar
devemos pensar na condição. No caso desse problema a condição seria que ele calcularia enquanto
as quantidades de médias fossem inferiores ou iguais a 50. Para isso precisamos contar as vezes em
que foi realizado o cálculo. Porém a estrutura enquanto não possui este recurso; portanto, devemos
estabelecer um modo de contagem, o que pode ser feito através de um contador representado por
uma variável com um dado valor inicial, o qual é incrementado a cada repetição.

inicio
//declaração de variáveis
n1,n2,n3,n4,ma:real;
con:inteiro;

con = 0; //inicializacao do contador
enquanto (con < 50) faça //teste da condição de parada
leia(n1,n2,n3,n4); //entrada de dados
ma = (n1+n2+n3+n4)/4; //calculo da media
escreva(“Media anual = “, MA);
se (MA >= 6) entao
escreva(“Aluno aprovado! - parabéns”);
senão
escreva(“Aluno reprovado! - estude mais”);
fimse;
con = con + 1; //incrementar o contador em 1
fimenquanto;
fim.

Devemos observar que contador CON foi inicializado com o valor 0 antes do laço, e que cada
iteração era incrementado em um.
Em uma variação do algoritmo acima, poderíamos calcular a média geral da turma, que seria
a média aritmética das 50 médias anuais, utilizando uma expressão aritmética, como mostrado
abaixo:

(M1+M2+M3+M5+ . . . + M49 + M50)/50

o que se torna inviável. Podemos utilizar nessa situação as vantagens da estrutura de repetição.
Fazendo um laço que cada execução acumule em uma variável, conhecida conceitualmente como
acumulador, o somatório das médias anuais de cada aluno. Após o término da repetição, teríamos a
soma de todas as médias de acumulação, restando apenas dividí-la pela quantidade de médias
somadas (50).
Uma solução para o algoritmo que deve ler a nota de 50 alunos e calcular a média aritmética
da turma seria:

inicio
//declaração de variáveis
ma,acm,mat:real;
con:inteiro;

con = 0; //inicializacao do contador
acm = 0;// inicializando o acumulador
enquanto (con < 50) faça //teste da condição de parada
leia(MA); //entrada de dados
acm = acm + ma; //soma em ACM dos valores lidos em MA
con = con + 1; //contagem do nº de médias fornecidas
fimenquanto;
47
MAT = ACM/50; //calculo da media anual da turma
escreva(“Media anual da turma =”, MAT);
fim.


O algoritmo acima utiliza um pré-conhecimento da quantidade de alunos da turma da qual se
desejava a média geral. Se não soubéssemos quantos eram os alunos, o que faríamos para controlar
o laço de repetição? Teríamos de encontrar outro critério de parada, o que pode ser feito utilizando
um valor predefinido como finalizador de uma seqüencia de valores.
Para aplicar tal conceito ao algoritmo da média geral da turma, usaremos como finalizador o
valor -1, que quando encontrado encerra o laço sem ter seu valor computado ao acumulador.

inicio
//declaração de variáveis
ma, acm, mat:real;
con:inteiro;

con = 0; //inicializacao do contador
acm = 0;// inicializando o acumulador
leia(MA);
enquanto (MA <> -1) faça //teste da condição de parada
acm = acm + ma; //soma em ACM dos valores lidos em MA
leia(MA);
con = con + 1; //contagem do nº de médias fornecidas
fimenquanto;
MAT = ACM/CON; //calculo da media anual da turma
escreva(“Media anual da turma =”, MAT);
fim.

Devemos observar que o contador CON inicia em 0 e que a leitura da primeira média anual
MA acontece antes do laço de repetição. Após a leitura da segunda média, o contador incrementa em
um, estando, portanto, sempre defasado em uma unidade do número total de leituras, o que garante
q não influência da leitura do finalizador -1 no cálculo da média da turma.

Exemplo:
Construa um algoritmo que calcule a média aritmética de um conjunto de números pares que forem
fornecidos pelo usuário. O valor de finalização será a entrada do número 0.

a) pseudocódigo

inicio
//declaração de variáveis
n,con, acm:inteiro;
mnp : real;

con = 0; //inicializacao do contador
acm = 0;// inicializando o acumulador
leia(n); //lê o primeiro número
enquanto (n <> 0) faça //teste da condição de parada
se ((n mod 2) == 0) então
acm = acm + n; //acumula em ACM a soma dos nº pares
con = con + 1; //contagem dos nº pares
fimse;
leia(n);
fimenquanto;
se (cont >0) então //houve nºs pares, pelo menos um
mnp = acm/con; //calcula a média dos nºs pares
escreva(“Media : “, mnp);
senão //nenhum par
escreva(“Nenhum par foi fornecido!”);
fimse;
fim.
48

Repetição com teste no final

Para realizar a repetição com teste no final, utilizamos a estrutura repita, que permite que um
bloco ou ação primitiva seja repetido até que uma determinada condição seja verdadeira. O modelo
genérico deste tipo de repetição é o seguinte:

repita
C1;
C2;
.
.
.
Cn;
até <condição>;

Pela sintaxe da estrutura, que o bloco (C1...Cn) é executado pelo menos uma vez,
independente da validade da condição. Isto ocorre porque a inspeção da condição é feita após a
execução do bloco, o que representa a característica principal desse modelo de repetição.

Exemplos:
1) Reescreva o algoritmo das médias usando acumulador, que lê a média anual de 50 alunos e
calcula a média geral da turma, e utilizando a estrutura de repetição com teste no final, teríamos:

a) pseudocódigo

inicio
//declaração de variáveis
ma,acm,mat:real;
con:inteiro;

con = 0; //inicializacao do contador
acm = 0;// inicializando o acumulador
repita
leia(MA); //entrada de dados
acm = acm + ma; //soma em ACM dos valores lidos em MA
con = con + 1; //contagem do nº de médias fornecidas
até (con >= 50); //teste da condição de parada
MAT = ACM/50; //calculo da media anual da turma
escreva(“Media anual da turma =”, MAT);
fim.

b) programa em Java



2) Construa um algoritmo que permita fazer um levantamento do estoque de vinho de uma adega,
tendo como dados de entrada tipos de vinho, sendo: T para tinto, B para branco e R para rosê.
Especifique a porcentagem de cada tipo sobre o total geral de vinhos; a quantidade de vinhos é
desconhecida, utilize como finalizador F de fim.

a) pseudocódigo

inicio
//declaração de variáveis
tv: inteiro;
pt,pb,pr:real;
conv, ct,cb,cr:inteiro;
//inicialização dos vários contadores
conv = 0;
ct = 0;
49
cb = 0;
cr = 0;
repita
leia(tv); //entrada de dados
escolha tv
caso '1': ct = ct + 1;
caso '2': cb = cb + 1;
caso '3': cr = cr + 1;
fimescolha;
conv = conv + 1;
até (tv = '4'); //teste da condição de parada
conv = conv – 1;
se (conv > 0) então
pt = (ct*100)/conv;
pb = (cb*100)/conv;
pr = (cr*100)/conv;
escreva(“Percentual de tintos =”, pt);
escreva(“Percentual de brancos =”, pb);
escreva(“Percentual de roses =”, pr);
senão
escreva(“nenhum tipo de vinho foi fornecido”);
fimse;
fim.

b) Programa em Java



Observações:
• além do contador geral de vinhos (CONV), foi necessário utilizar um contador para cada
tipo de vinho, CT, CB e CR;
• é uma aplicação típica da seleção de múltipla escolha, em que cada tipo de vinho
corresponde a um caso;
• após o laço de repetição, o contador geral de vinhos foi dcrementado em um, para
descontar o finalizador F.


Repetição com variável de controle

Nas estruturas de repetição vistas até agora, ocorrem casos em que se torna difícil
determinar o número de vezes em que o bloco será executado. Sabemos que ele será executado
enquanto uma condição for satisfeita – enquanto - , ou até que uma condição seja satisfeita – repita.
A estrutura para repete a execução do bloco um número definido de vezes pois ela possui limites.
O modelo genérico para a estrutura de repetição para é o seguinte:

para v:= vi até vf faça
C1;
C2;
.
.
.
Cn;
fimpara;

Em que:
• v é a variável de controle;
• vi é o valor inicial da variável v;
• vf é o valor final da variável v, ou seja, o valor até o qual ela vai chegar;

Exemplos:

50
1) voltemos ao cálculo da média aritmética de uma turma fixa de a 50 alunos, resolvendo o problema
com a repetição para, teríamos:

a) pseudocódigo

inicio
//declaração de variáveis
ma,acm,mat:real;
con:inteiro;

acm = 0;// inicializando o acumulador
para con = 1 ate 50 faca
leia(MA); //entrada de dados
acm = acm + ma; //soma em ACM dos valores lidos em MA
fimpara;
MAT = ACM/50; //calculo da media anual da turma
escreva(“Media anual da turma =”, MAT);
fim.

b) programa em Java

2) Elabore um algoritmo que efetue a soma de todos os números ímpares que são múltiplos de 3 e
que se encontram no conjunto de números de 1 até 500.

a) pseudocódigo

inicio
//declaração de variáveis
i, si:inteiro;

si = 0;
para i = 1 ate 500 faca
se ( i mod 2 = 1) então
se (i mod 3 = 0) então
si = si + i;
fimse;
fimse;
fimpara;
escreva(“Soma =”, si);
fim.

b) programa em Java

Comparação entre estruturas de repetição

Podemos estabelecer duas observações que relacionam a estrutura de repetição:
• toda estrutura enquanto pode ser convertida para repita e vice-versa;
• toda estrutura para pode ser convertida em enquanto, mas nem toda estrutura enquanto
pode ser convertida em para.

Exemplos:

1) Crie um algoritmo para que este imprima a tabuada de qualquer número.
OBS:o flag para as estruturas enquanto e repita é -1.

a) pseudocódigo

- enquanto

inicio
//declaração de variáveis
n,cont:inteiro;
51

leia(n);
enquanto (n <> -1) faça
cont = 1;// inicializando o acumulador
enquanto (cont <= 10) faça
escreva(cont, “ X “, n, “ = “, cont * n);
cont = cont + 1;
fimenquanto;
leia(n);
fimenquanto;
fim.

- repita

inicio
//declaração de variáveis
n,cont:inteiro;

leia(n);
repita
cont = 1;// inicializando o acumulador
repita
escreva(cont, “ X “, n, “ = “, cont * n);
cont = cont + 1;
ate (cont > 10);
leia(n);
ate (n = -1);
fim.

- para

inicio
//declaração de variáveis
n,cont:inteiro;

leia(n);
para cont = 1 ate 10 faca
escreva(cont, “ X “, n, “ = “, cont * n);
fimpara;
fim.

2) Veja os exemplo abaixo:

a)
class ExRepeticao10{
public static void main(String args[]){
Thread t; //cria um objeto t para o controle do tempo
t = new Thread();
t.start();
int A,B;
for(A=0;A <=10;A++){
System.out.println(A + " ");
}
System.out.println();
for(A=50;A >=0;A=A-5){
System.out.println(A + " ");
}
System.out.println();
for(A=10;A >=-10;A=A-2){
System.out.println(A + " ");
for(B=0;B<50000000;B++);
}
System.out.println();
int H,M,S; //simula um relogio digital
52
System.out.println("Para encerrar pressione CTRL+C");
for(H=0;H <24;H++)//controla as horas
for(M=0;M <60;M++)//controla os minutos
for(S=0;S <60;S++) { //controla os segundos
//exibe as horas na tela
System.out.println(H + " h: "+M+" m: "+S + " s ");
try{
t.sleep(1000);
if(S==5) System.exit(0);
}catch(InterruptedException e){
}
}
}
}

b)

class ExRepeticao11{
public static void main(String args[]){
Thread tempo;
tempo = new Thread();
tempo.start();
int A;
try{
A = Integer.parseInt(args[0]);
while(A >0){ //inicio da estrutura while
System.out.println(" "+A);
tempo.sleep(1000); //pausa de um segundo
A--;
}//fim da estrutura while

System.out.println("Fim da 1ª contagem");
System.out.println(); //pula uma linha
tempo.sleep(1000);

do {//inicio da estrutura do-while
System.out.println(" "+A);
tempo.sleep(1000);
A++;
}while(A >0); //fim da estrutura do-while
System.out.println("Fim da 2ª contagem");

}catch(ArrayIndexOutOfBoundsException E){ //não foi digitado
argumento
System.out.println("Digite um argumento!");

}
catch(InterruptedException E){ //interrupção do timer
System.out.println("Algo interrompeu a contagem!");

}
catch(NumberFormatException E){ //se o argumento for invalido
System.out.println("Nao foi fornecido um numero inteiro
valido!");
}
}
}


Exercícios de Fixação - Estrutura de repetição

1. Exibir a soma dos números positivos no intervalo de um a cem.
2. Exibir o produto dos números inteiros positivos no intervalo de um a cem.
3. Elaborar um programa que apresente no final o somatório dos valores pares existentes entre 1 e
500.
53
4. Entrar com dois valores via teclado, onde o segundo deverá ser maior que o primeiro. Caso
contrário solicitar novamente apenas o segundo valor.
5. Fazer um programa que leia 20 idades de pessoas. Calcule e escreva a idade média deste grupo.
6. Fazer um programa que leia um conjunto de idades de pessoas. O final do conjunto de valores é
conhecido através do valor -1. Calcule e escreva a idade média deste conjunto.
7. Fazer um programa que leia um conjunto de alturas de pessoas. O final do conjunto de valores é
conhecido através do valor zero. Escreva a menor altura deste conjunto.
8. Fazer um programa que leia um conjunto de dados contendo o sexo e a altura de 50 pessoas.
Escreva a altura média das mulheres.
9. Fazer um programa que leia a nota final de 50 alunos e escreva o total de aprovados. É
considerado aprovado o aluno com nota final maior ou igual a 6.
10. Fazer um programa que leia a nota final de 50 alunos e escreva:
a) o total de reprovados;
b) a nota média da turma;
c) a menor e maior nota da turma;
É considerado aprovado o aluno com nota final maior ou igual a 6.
11. Dados três valores a,b e c, calcular e imprimir a média harmônica destes valores:
média harmônica = 1
(1/a) + (1/b) + 1/c)

12. Elaborar um programa para ler três valores distintos e exibir o maior deles.
13. Construir um programa que some todos os números fornecidos pelo usuário até que o número lido
seja iguala a zero e mostre a soma.
14. Escreva um programa que escreva todos o números ímpares entre 100 e 200.
15. Fazer um programa que leia um conjunto de valores. Cada valor deverá ser armazenado na
variável X. Para cada valor lido calcule e escreva o valor de Y pela fórmula: Y = 2.5*cos|X/2|. O
último valor do conjunto de valores, cujo conteúdo não será processado, deverá conter um valor
negativo.
16. Escrever um programa que leia 50 valores, encontre o maior e o menor e mostre o resultado.
17. Construir um programa que leia uma quantidade desconhecida de valores, e conte quantos deles
estão no intervalo [10,20] e quantos estão fora do intervalo, escrevendo estas informações.
18. Construir um programa que leia uma quantidade desconhecida de valores e conte quantos deles
estão nos seguintes intervalos: [0,25], [26,50], [51,75] e [76,100]. A entrada de dados deve
terminar quando for lido um número negativo. Mostrar o resultado final.
19. Escrever um programa que leia a matrícula do aluno e suas três notas; calcule a média ponderada
do aluno, considerando que o peso para a maior nota seja 4 e para as duas restantes, 3; mostre a
matrícula do aluno, suas três notas, a média calculada e uma mensagem “aprovado” se a média
for maior ou igual a 5 e “Reprovado” se a média dor menor que 5; e repita a operação até que a
matrícula lida seja zero.
20. Escreva um programa que leia um número não determinado de valores diferentes de zero e
calcule a média aritmética dos valores lidos, a quantidade de valores positivos, a quantidade de
valores negativos e o percentual dos valores negativos e positivos. O final será o valor lido igual a
zero. Mostrar os resultados.
21. Deseja-se fazer um levantamento a respeito da ausência de alunos à primeira prova de
programação de computadores. É fornecido um conjunto de valores com as letras P ou A, para
caso o aluno estar presente ou ausente. Fazer um programa que calcule a porcentagem de
ausência. O final do conjunto de valores é conhecido através do valor FIM.
22. Construa um programa que, dado um conjunto de valores inteiros e positivos, determine qual é o
menor e o maior valor do conjunto. O final do conjunto de valores é conhecido através do valor -1,
que não deve ser considerado.
23. A conversão de graus Farenheit para centígrados é obtida pela fórmula C = (5/9)*(F – 32). Escreva
um programa que calcule e escreva uma tabela de graus centígrados em função de graus
Farenheit que variam de 50 a 150 de 1 em 1.
24. Uma rainha requisitou os serviços de um monge e disse-lhes que pagaria qualquer preço. O
monge, necessitando de alimentos, perguntou à rainha se o pagamento poderia ser feito com
grãos de trigo dispostos em um tabuleiro de xadrez, de tal forma que o primeiro quadro contivesse
apenas um grão e os quadros subsequentes, o dobro do quadro anterior. A rainha considerou o
pagamento barato e pediu que o serviço fosse executado, sem se dar conta de que seria
impossível efetuar o pagamento. Faça um programa para calcula o número de grãos que o monge
esperava receber.
25. Em uma eleição presidencial, existem quatro candidatos. Os votos são informados atravé sde
código. Os dados utilizados para a escrutinagem obedecem a seguinte codificação:
54
• 1,2,3,4 = voto para os respectivos candidatos;
• 5 = voto nulo;
• 6 = voto em branco.

Elabore um programa que calcule e escreva:
a) total de votos para cada candidato;
b) total de votos nulos;
c) total de votos em branco;
d) percentual dos votos em branco e nulos sobre o total.
Como finalizador do conjunto de votos, tem-se o valor 0.

26. Escreva um programa que imprima todas as possibilidades de que no lançamento de dois dados
tenhamos o valor 7 como resultado da soma dos valores de cada dado.
27. Escreva um programa que imprima todos os números primos existentes entre N1 e N2, em que N1
e N2 são números naturais fornecidos pelo usuário.
28. Construa um programa que leia um conjunto de dados contendo altura e sexo (M para masculino
e F para feminino) de 50 pessoas e, depois, calcule e escreva:
• a maior e a menor altura do grupo;
• a média de alturas das mulheres;
• o número de homens e a diferença percentual entre estes e as mulheres.

29. Uma agência de publicidade quer prestar serviços somente para as maiores companhias – em
número de funcionários – em cada uma das classificações: grande, média, pequena e
microempresa. Para tal, consegue um conjunto de dados com o código, o número de funcionários
e o porte da empresa. Construa um algoritmo que liste o código da empresa com maiores recursos
humanos dentro de sua categoria. Utilize como finalizador o código da empresa igual a 0.
30. Calcule o imposto de renda de um grupo de 10 contribuintes, considerando que os dados de cada
contribuinte, número do CPF, número de dependentes e renda mensal são valores fornecidos pelo
usuário. Para cada contribuinte será feito um desconto de 5% do salário mínimo por dependente.
Os valores da alíquota para cálculo do imposto são:

Renda líquìda Alíquota
Até 2 salárIos minImos Ìsento
2 a J salárIos minImos 5,00º
J a 5 salárIos minImos 10,00º
5 a 7 salárIos minImos 15,00º
AcIma de 7 salárIos minImos 20,00º
Observe que deve ser fornecido o valor atual do salário mínimo para que o programa
calcule os valores corretamente.

31. Anacleto tem 1,50 metros e cresce 2 centímetros por ano, enquanto Felisberto tem 1,10 metros e
cresce 3 centímetros por ano. Construa um algoritmo que calcule e imprima quantos anos serão
necessários para que Felisberto seja maior que Anacleto.
32. Um cinema possui capacidade para 100 lugares e está sempre com ocupação total. Certo dia,
cada espectador respondeu a um questionário, no qual constava:
• sua idade;
• sua opinião com relação ao filme, segundo as seguintes notas:

Nota Sìynìjìcado
A DTÌ|D
8 8D|
C FECULAF
0 FUÌ|
E PÉSSÌ|D
Elabore um programa que, lendo estes dados, calcule e imprima:
• a quantidade de respostas ótimo;
• a diferença percentual entre respostas bom e regular;
55
• a média de idade das pessoas que responderam ruim;
• a perdentagem de respostas péssimo e a maior idade que utilizou esta opção;
• a diferença de idade entre a maior idadeque respondeu ótimo e a maior idade que
respondeu ruim.

33. Em um prédio há três elevadores denominados A, B e C. para otimizar o sistema de controle dos
elevadores, foi realizado um levantamento no qual cada usuário respondia:
• o elevador que utilizava com mais freqüência;
• o período que utilizava o elevador, entre:
• M = matutino;
• V = vespertino;
• N = noturno;
Construa um algoritmo que calcule e imprima:
• qual é o elevador mais frequentado e em período se concentra o maior fluxo;
• qual o período mais usado de todos e a que elevador pertence;
• qual a diferença percentual entre o mais usado dos horários e o menos usado;
• qual a percentagem sobre o total de serviços prestados do elevador de média utilização.

34. Uma loja utiliza os seguintes códigos para as transações de cada dia:
v – para compras à vista
p – para compras a prazo
É dada uma lista de transações contendo o valor de cada compra e o respectivo
código de transação. Faça um programa que calcule e imprima:
• valor total das compras à vista ;
• valor total das compras a prazo;
• valor total das compras efetuadas;
• valor a receber pelas compras a prazo, isto é, primeira parcela, sabendo que estas serão
pagas em três vezes.
Sabe-se que são efetuadas 25 transações por dia.

35. Em um campeonato de futebol, cada time tem uma lista oficial de 23 jogadores. Cada time prepara
uma lista contendo o peso e a idade de cada um dos seus jogadores. Os 40 times que participam
do torneio enviam essas listas para o CPD da confederação. Faça um programa que apresente as
seguintes informações:
• o peso médio e a idade média de cada um dos times;
• o peso médio e a idade de todos os participantes.


Outros exemplos complementares

Ex1) fazer um programa que leia três valores inteiros, determine e imprima o menor deles:
a) Algoritmo resolvido

inicio
//declaracao de variáveis
a,b,c,menor:inteiro;
escreva("Entre com o valor de A: ");leia(a);
escreva("Entre com o valor de B: ");leia(b);
escreva("Entre com o valor de C: ");leia(c);
se( (a < c) e (a < c))entao
menor = a;
senao
se (b < c) entao
menor = b;
senao
menor = c;
escreva("O menor valor e: "+menor);
fim.

b) Programa em Java

import java.io.*;
56
class ExemplosGerais1{
public static void main(String args[]){
int a,b,c,menor;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
System.out.println("Entre com o valor de A: ");
a = Integer.parseInt(entrada.readLine());
System.out.println("Entre com o valor de B: ");
b = Integer.parseInt(entrada.readLine());
System.out.println("Entre com o valor de C: ");
c = Integer.parseInt(entrada.readLine());
if( (a < c) && (a < c))
menor = a;
else{
if (b < c)
menor = b;
else
menor = c;
}
System.out.println("O menor valor e: "+menor);
}catch(Exception e){
System.out.println("Ocorreu um erro durante a leitura");
}
}
}


Ex2) Dados três valores distintos, fazer um programa que, após a leitura destes dados, coloque-os
em ordem crescente.

a) algoritmo em pseudocodigo


inicio
//declaracao de variaveis
a,b,c,aux:intueiro;

escreva('Entre com o valor de A: ');leia(a);
escreva('Entre com o valor de B: ');leia(b);
escreva('Entre com o valor de C: ');leia(c);
se ((a > b) ou (a > c)) entao
se (b < c) entao
aux = a;
a= b;
b= aux;
senao
aux = a;
a= c;
c= aux;
se (b > c) entao
aux = b;
b= c;
c= aux;
escreva(a,' ',b,' ',c);

fim.

b) programa em Java

import java.io.*;
class ExemplosGerais2A{
public static void main(String args[]){
int a,b,c,aux;
57
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
System.out.println("Entre com o valor de A: ");
a = Integer.parseInt(entrada.readLine());
System.out.println("Entre com o valor de B: ");
b = Integer.parseInt(entrada.readLine());
System.out.println("Entre com o valor de C: ");
c = Integer.parseInt(entrada.readLine());
if ((a > b) || (a > c)){
if (b < c){
aux = a;
a= b;
b= aux;
}
else{
aux = a;
a= c;
c= aux;
}
if (b > c){
aux = b;
b= c;
c= aux;
}
}
System.out.println("Os valores ordenados sao: "+a+" "+b+" "+c);

}catch(Exception e){
System.out.println("Ocorreu um erro durante a leitura");
}
}
}


Ex3) Fazer um programa para determinar a soma dos números pares desde 100 até 200 inclusive.

a) algoritmos em psudocodigo

Solução 1: (enquanto)

inicio
soma, par:inteiros;
soma = 0;
par = 100;
enquanto (par <= 200) faca
soma = soma + par;
par = par + 2;
fimenquanto;
escreva('A soma dos pares entre 100 e 200 (inclusive) e: ',soma);
fim.


Solução 2: (para)

inicio
soma, n:inteiro;
soma = 0;
para n= 50 ate 100 faca
soma := soma + 2*n;
escreva('A soma dos pares entre 100 e 200 (inclusive) e: ',soma);
fim.

Solução 3: (Repita)
58

inicio
soma, par:inteiro;
soma = 0;
par = 100;
repita
soma := soma + par;
par := par + 2;
ate (par > 200);
escreva('A soma dos pares entre 100 e 200 (inclusive) e: ',soma);
fim.

b) programa em Java (usando for)

class ExemplosGerais3{
public static void main(String args[]){
int soma=0, n;

for(n=50;n<=100;n++)
soma = soma + 2*n;
System.out.println("A soma dos pares entre 100 e 200 (inclusive) e: "+soma);

}
}

Ex4) Fazer um programa que calcule o fatorial de um número inteiro.

a) algoritmo em pseudocodigo

Solução:

inicio
fat, i, n: inteiro;
fat = 1;
escreva(´Entre com o valor de n: ´);leia(n);
para i = 1 ate n faca
fat = fat * i;
escreva(´O fatorial de ´,n,´ e ´,fat);
fim

b) Programa em Java

import java.io.*;
class ExFatorial{
public static void main(String args[]){
int fat,i,n;

BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));
fat=1;
try{
System.out.println("Entre com o valor de n: ");
n = Integer.parseInt(entrada.readLine());

for(i=1;i<=n;i++){
fat *= i;
}
System.out.println("O fatorial de "+n+ " e: " +fat);

}catch(Exception e){
System.out.println("Ocorreu algum erro na entrada!!!");
}
}
}

59
Ex5) Uma pessoa aplicou seu capital a juros e deseja saber, trimestralmente, a posição de seu
investimento C (capital) inicial. Chamando de I a taxa de juros do trimestre, escrever uma tabela que
dê para cada trimestre o rendimento auferido e o saldo acumulado durante um período de X anos,
supondo-se que nenhuma retirada tenha sido feita.
OBS:
ci) os valores de C, I e X estão disponíveis em uma unidade de entrada;
cii) a fórmula para capitalização composta é dada por:
M
n
= C(1 + I)
n
Onde:
M
n
- montante após terem decorridos n trimestres;
C – capital inicial investido;
I – taxa de juros;
n – número de períodos decorridos (trimestres)

a) algoritmo em pseudocódigo
Solução:

inicio
c, montante, taxa, rendimento: real;
n, trimestre, x: inteiro;
escreva('Entre com o capital: ');leia(c);
escreva('Entre com a taxa: ');leia(taxa);
escreva('Entre com o periodo: ');leia(x);
Montante = c;
taxa = taxa / 100;
n = 4 * x;
para trimestre = 1 ate n faca
rendimento= taxa*montante;
montante = montante * (1 + taxa);
fimpara;
escreva('O rendimento e: ',rendimento);
escreva('O montante e: ',montante);
fim.

b) Programa em Java

import java.io.*;
class ExemplosGerais5{
public static void main(String args[]){
double c, montante, taxa, rendimento=0;
int n, trimestre, x;
String s = " ";
DataInputStream dado;

try{
System.out.println("Entre com o capital: ");
dado = new DataInputStream(System.in);
s = dado.readLine();
c = Double.parseDouble(s);

System.out.println("Entre com a taxa: ");
dado = new DataInputStream(System.in);
s = dado.readLine();
taxa = Double.parseDouble(s);

System.out.println("Entre com o periodo: ");
dado = new DataInputStream(System.in);
s = dado.readLine();
x = Integer.parseInt(s);

montante = c;
taxa = taxa / 100;
n = 4 * x;
for (trimestre = 1;trimestre <= n;n++){
rendimento= taxa*montante;
60
montante = montante * (1 + taxa);
}
System.out.println("O rendimento e: "+rendimento);
System.out.println("O montante e: "+montante);
}catch(Exception e){
System.out.println("Ocorreu algum erro na entrada!");
}
}
}


Ex6) Num frigorífico existem 90 bois. Cada boi traz preso em seu pescoço um cartão contendo seu
número de identificação e seu peso. Fazer um programa que escreva o número e o peso do boi mais
gordo e do boi mais magro.

a) algoritmo em pseudocodigo

Solução:

inicio
bois, gordo, magro,num:inteiro;
peso, MaiorPeso, MenorPeso: real;
maiorpeso = 0;
menorpeso = 100000;
para bois = 1 ate 90 faca
escreva('Entre com o numero do boi: ');leia(num);
escreva('Entre com o peso do boi: ');leia(peso);
se (peso > maiorpeso) entao
maiorpeso = peso;
gordo = num;
fimse;
se (peso < menorpeso) entao
menorpeso := peso;
magro := num;
fimse;
escreva('O boi mais gordo e o ',gordo,' e o seu peso e ',maiorpeso);
escreva('O boi mais magro e o ',magro,' e o seu peso e ',menorpeso);
fim.

b) Programa em Java

import java.io.*;
class ExemplosGerais6{
public static void main(String args[]){
int bois, gordo=0, magro=0,num;
double peso, maiorpeso=0, menorpeso=100000;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
for (bois = 1;bois<=90;bois++){
System.out.println("Entre com o numero do boi: ");
num=Integer.parseInt(entrada.readLine());

System.out.println("Entre com o peso do boi: ");
peso = Double.parseDouble(entrada.readLine());

if(peso > maiorpeso){
maiorpeso = peso;
gordo = num;
}
if (peso < menorpeso){
menorpeso = peso;
magro = num;
}
61
}

System.out.println("O boi mais gordo e o "+gordo+" e o seu peso e
"+maiorpeso);
System.out.println("O boi mais magro e o "+magro+" e o seu peso e
"+menorpeso);

}catch(Exception e){
System.out.println("Houve algum erro na entrada");
}

}
}

Ex7) Uma pesquisa sobre algumas características físicas da população de determinada região
coletou os seguintes dados, referentes a cada habitante, para serem analisados:
i. sexo (masculino, feminino);
ii. cor dos olhos (azuis, verdes, castanhos, pretos);
iii. cor dos cabelos (louros, castanhos, pretos);
iv. idade em anos;

Para cada habitante, foi digitada uma linha com esses dados e a última linha, que não corresponde a
ninguém, conterá o valor de igualdade igual a –1. fazer um programa que determine e escreva:
a) a maior idade dos habitantes;
b) a porcentagem de indivíduos do sexo feminino cuja idade está entre 18 e 35 anos, inclusive, e que
tenham olhos verdes e cabelos louros.

a) algoritmo em pseudocódigo

Solução:

inicio
idade, totalpessoas, maioridade, pessoas: inteiro;
porcentagem: real;
cabelos, olhos, sexo: caracter;
maioridade = 0;
TotalPessoas = 0;
pessoas = 0;
escreva('Entre com o sexo do indiv¡duo: ');leia(sexo);
escreva('Entre com a cor dos olhos do indiv¡duo: ');leia(olhos);
escreva('Entre com a cor dos cabelos do indiv¡duo: ');leia(cabelos);
escreva('Entre com a idade do indiv¡duo: ');leia(idade);
enquanto (idade <> -1) faca
se (idade > maioridade) então
maioridade := idade;
fimse;
totalpessoas := totalpessoas + 1;
se (idade >= 18) e (idade <= 35) e (olhos = 'v') e (cabelos = 'L') e (sexo = 'F') entao
pessoas := pessoas + 1;
fimse;
escreva('Entre com o sexo do indiv¡duo: ');leia(sexo);
escreva('Entre com a cor dos olhos do indiv¡duo: ');leia(olhos);
escreva('Entre com a cor dos cabelos do indiv¡duo: ');leia(cabelos);
escreva('Entre com a idade do indiv¡duo: ');leia(idade);
fimenquanto;
porcentagem := (pessoas * 100/totalpessoas);
escreva('A maior idade e: ',maioridade);
escreva('A percentual de individuos selecionados: ',porcentagem);
fim.

b) Programa em Java

import java.io.*;
62
class ExPesquisa{
public static void main(String args[]){
int idade, totalpessoas=0,maioridade=0,pessoas=0;
float porcentagem;
int cabelos,olhos,sexo;

BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
System.out.println("Entre com o sexo: (1 = masculino;2 =
feminino)");
sexo = Integer.parseInt(entrada.readLine());

System.out.println("Entre com a cor dos olhos: (1 = azul;2 =
verde;3 = castanho;4= preto)");
olhos = Integer.parseInt(entrada.readLine());

System.out.println("Entre com a cor dos cabelos: (1 = louro;2 =
castanho; 3 = preto)");
cabelos = Integer.parseInt(entrada.readLine());

System.out.println("Entre com a idade: ");
idade = Integer.parseInt(entrada.readLine());

while(idade != -1){
if(idade > maioridade)
maioridade = idade;
totalpessoas++;
if((idade>=18)&& (idade <=35)&&(olhos ==2)&&(cabelos ==
1)&&(sexo ==2)){
pessoas++;
}
System.out.println("Entre com o sexo: (1 = masculino;2 =
feminino)");
sexo = Integer.parseInt(entrada.readLine());

System.out.println("Entre com a cor dos olhos: (1 =
azul;2 = verde;3 = castanho;4= preto)");
olhos = Integer.parseInt(entrada.readLine());

System.out.println("Entre com a cor dos cabelos: (1 =
louro;2 = castanho; 3 = preto)");
cabelos = Integer.parseInt(entrada.readLine());

System.out.println("Entre com a idade: ");
idade = Integer.parseInt(entrada.readLine());
}
porcentagem=(pessoas*100)/totalpessoas;
System.out.println("A maior idade e: "+maioridade);
System.out.println("O percentual de selecionados e:
"+porcentagem);
}catch(Exception e){
System.out.println("Houve algum erro na entrada!");
}

}
}


Ex8) Para determinar o número de lâmpadas necessárias para cada cômodo de uma residência,
existem normas que dão o mínimo de potência de iluminação exigida por metro quadrado (m²),
conforme a utilização deste cômodo.
Seja o seguinte quadro tomado como exemplo:

UTILIZAÇÅD CLASSE PDTÈNCIAlm
Quarto 1 15
63
Sala de T7 1 15
Sala 2 18
CozInha 2 18
7aranda 2 18
EscrItorIo J 20
banheIro J 20


Supondo que só serão utilizadas lâmpadas de 60W, fazer um programa que:
a) leia um número indeterminado de linhas contendo cada uma:
a) cômodo de uma residência
b) classe de iluminação deste cômodo
c) as duas dimensões do cômodo

b) calcule e escreva:
b.1) para cada cômodo:
a) o cômodo.
b) a área do cômodo
c) a potência de iluminação
d) número de lâmpadas necessárias
b.2) para toda a residência:
a) total de lâmpadas
b) total de potência

Observações:
1.Se o número calculado de lâmpadas for fracionário, considerar o menor inteiro que contenha esse
número. Ex.:8,3 -> 9; 8,7 -> 9.
2. A última linha, que não entrará nos cálculos, conterá no lugar do cômodo a palavra vazio.

Solução:

a) algoritmo em pseudocódigo

inicio
classe, lampadas, TotalLampadas:inteiro;
aux, comprimento, largura, area, potencia, TotalPotencia: real;
comodo: caracter;
TotalLampadas = 0;
TotalPotencia = 0;
escreva('Entre com o tipo do comodo: ');
escreva('Entre com q para quarto');
escreva('Entre com s para sala');
escreva('Entre com t para sala de TV');
escreva('Entre com c para cozinha');
escreva('Entre com v para varanda');
escreva('Entre com e para escritorio');
escreva('Entre com b para banheiro');
leia(comodo);
escreva('Entre com a classe do comodo: ');
escreva('quarto e sala de TV = classe 1');
escreva('sala, cozinha e varanda = classe 2');
escreva('escritorio e banheiro = classe 3');
leia(classe);
escreva('Entre com o comprimento do comodo: ');leia(comprimento);
escreva('Entre com a largura do comodo: ');leia(largura);
enquanto (comodo != '*') faca
area := comprimento * largura;
se (classe = 1) entao
potencia = area * 15;
senao
se (classe = 2) entao
64
potencia = area * 18
senao
potencia = area * 20;
fimse;
fimse;
lampadas = trunc(potencia/60);
aux := potencia/60 - lampadas;
se (aux > 0) entao
lampadas := lampadas + 1;
fimse;
TotalLampadas := TotalLampadas + lampadas;
TotalPotencia := TotalPotencia + Potencia;
escreva('O comodo e: ', comodo);
escreva('A area do comodo e: ', area:2:2);
escreva('A potencia utilizada e: ', potencia:2:2);
escreva('A quanrtidade de lampadas e: ', lampadas);
escreva('Entre com o tipo do comodo: ');leia(comodo);
escreva('Entre com a classe do comodo: ');leia(classe);
escreva('Entre com o comprimento do comodo: ');leia(comprimento);
escreva('Entre com a largura do comodo: ');leia(largura);
fimenquanto;
escreva('O total de lampadas para os comodos e: ', totalLampadas);
escreva('O total de potencia para os comodos e: ', totalPotencia:2:2);
fim.

b) programa em Java

import java.io.*;
class ExIluminacao{
public static void main(String args[]){
int classe,lampadas, TotalLampadas=0,comodo;
double aux, comprimento, largura, area, potencia, totalPotencia=0;

BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
System.out.println("Entre com o tipo do comodo:");
System.out.println();
System.out.println("Entre com 1 para quarto");
System.out.println("Entre com 2 para sala");
System.out.println("Entre com 3 para sala de TV");
System.out.println("Entre com 4 para cozinha");
System.out.println("Entre com 5 para varanda");
System.out.println("Entre com 6 para escritorio");
System.out.println("Entre com 7 para banheiro");
comodo = Integer.parseInt(entrada.readLine());
System.out.println();
System.out.println("Entre com a classe do comodo: ");
System.out.println("quarto e sala de TV = classe 1");
System.out.println("sala, cozinha e varanda = classe 2");
System.out.println("escritorio e banheiro = classe 3");
classe = Integer.parseInt(entrada.readLine());
System.out.println("Entre com o comprimento do comodo: ");
comprimento = Double.parseDouble(entrada.readLine());
System.out.println("Entre com a largura do comodo: ");
largura = Double.parseDouble(entrada.readLine());
while (comodo != -1){
area = comprimento * largura;
if (classe == 1)
potencia = area * 15;
else
if (classe == 2)
potencia = area * 18;
else
potencia = area * 20;
65
lampadas = (int)(Math.ceil(potencia/60));
aux = potencia/60 - lampadas;
if (aux > 0)
lampadas ++;
TotalLampadas = TotalLampadas + lampadas;
totalPotencia = totalPotencia + potencia;
System.out.println();
System.out.println("O comodo e: "+ comodo);
System.out.println("A area do comodo e: "+ area);
System.out.println("A potencia utilizada e: "+
potencia);
System.out.println("A quanrtidade de lampadas e: "+
lampadas);
System.out.println();
System.out.println("Entre com o tipo do comodo: ");
comodo = Integer.parseInt(entrada.readLine());
System.out.println("Entre com a classe do comodo: ");
classe = Integer.parseInt(entrada.readLine());
System.out.println("Entre com o comprimento do comodo:
");
comprimento = Double.parseDouble(entrada.readLine());
System.out.println("Entre com a largura do comodo: ");
largura = Double.parseDouble(entrada.readLine());;
}
System.out.println("O total de lampadas para os comodos e: "+
TotalLampadas);
System.out.println("O total de potencia para os comodos e: "+
totalPotencia);
}catch(Exception e){
System.out.println("Houve algum erro na entrada!");
}

}
}


Ex9) Fazer um programa que:
1) Leia e escreva o número e a altura das moças inscritas em um concurso de beleza. Para cada
moça existe uma linha em uma unidade de entrada contendo seu número e sua altura. A última linha,
que não corresponde a nenhuma moça, conterá o zero no lugar do número.

2) Calcule e escreva as duas maiores alturas e quantas moças as possuem.


a) algoritmo em pseudocódigo

Solução:

inicio
altura, maior1, maior2:real;
cont1,cont2, num:inteiro;
cont1 = 0;
cont2 = 0;
maior1 =-1;
maior2 = -1;
escreva('Entre com o numero de inscricao: ');leia(num);
escreva('Entre coma altura da candidata: ');leia(altura);
enquanto (num > 0) faca
escreva('o numero de inscricao e','',num,'','e a altura e ',altura);
se (altura > maior1) entao
maior2 = maior1;
cont2 = cont1;
maior1 = altura;
cont1 = 1;
senao
66
se (altura = maior1) entao
cont1 = cont1 + 1
senao
se (altura > maior2) entao
maior2 = altura;
cont2 = 1;
senao
se (altura > maior2) entao
maior2 = altura;
cont2 = 1;
senao
se (altura == maior2) entao
cont2 := cont2 + 1;
fimse;
fimse;
fimse;
fimse;
fimse;
escreva('Entre com o numero de inscricao: ');leia(num);
escreva('Entre coma altura da candidata: ');leia(altura);
fimenquanto;
escreva(maior1, cont1, maior2, cont2);
fim.

b) programa em Java



Ex10) Escrever um programa para fazer uma tabela de senA, com A variando de 0 a 16, radiano de
décimo em décimo de radiano, usando a série:
SenA = A- A
3
+ A
5
- ...
3! 5!
Com erro inferior a 0,0001. Imprimir também o número de termos usados.
Em séries alternadas, o valor absoluto do erro cometido com a interrupção da série é inferior
ao valor absoluto do primeiro termo abandonado.
Observe-se que a estrutura para-ate-faca não permite variável de controle, valores inicial e
final reais. Para se contornar esta restrição, usou-se a variável inteira I, variando de 0 a 16. e obteve-
se A, dividindo-se cada I por 10.

Solução:

a) algoritmo em pseudocódigo

inicio
n,i : inteiro;
a, senA, t: real;
escreva('A senA N');
para i = 0 ate 16 faca
a= i/10;
senA = 0;
t = a;
n = 0;
enquanto (abs(t) >= 0.0001) faca
senA := senA + t;
n := n + 1;
t := -t * a * a/(2 * n * (2 * n + 1))
fimenquanto;
escreva(a:3:1,senA:11:7,n:3);
fimpara;
fim.

67
Ex11) Para cada aluno da disciplina Programação de Computadores deste semestre, será digitada
uma linha com os seguintes dados:
1. A identificação da turma (A,B, ...,R, nesta ordem)
2. Número de matrícula
3. Nota final
Após o último aluno de cada turma, virá uma linha com dados, que não correspondem a nenhum
aluno, contendo zero no lugar do número de matrícula. Deseja-se, através de um computador, ler
estes dados e imprimir, para cada turma, a sua identificação,o número de alunos aprovados ( nota
final> 60), a média das notas e a melhor nota. Após todas as turmas serem processadas, deseja-se
imprimir também o total de alunos aprovados, a média geral e a melhor nota na disciplina,neste
semestre.

Solução:

a) algoritmo em pseudocódigo

inicio
NDisc, AprovDisc, n, aprov, aluno: inteiro;
MediaDisc, SomaDisc, MelhorDisc, media, soma, melhor, nota: real;
turma: caracter;
SomaDisc := 0;
NDisc := 0;
AprovDisc := 0;
MelhorDisc := 0;
escreva('Para sair entre com R');
repeat
n= 0;
aprov = 0;
melhor = -1;
soma= 0;
escreva('Entre com o nome da turma: ');leia(turma);
escreva('Entre com a matricula do aluno: ');leia(aluno);
escreva('Entre com a nota do aluno: ');leia(nota);
enquanto (aluno != 0) faca
n := n + 1;
soma = soma + nota;
se (nota > 60) entao
aprov = aprov + 1;
fimse;
se (nota > melhor) entao
melhor := nota;
escreva('Entre com o nome da turma: ');leia(turma);
escreva('Entre com a matricula do aluno: ');leia(aluno);
escreva('Entre com a nota do aluno: ');leia(nota);
fimenquanto;
media = soma/n;
escreva(aprov:3,media:6:2,melhor:6:2);
SomaDisc =SomaDisc + soma;
AprovDisc = AprovDisc + Aprov;
NDisc = NDisc + n;
se (melhor > melhorDisc) entao
melhorDisc := melhor;
fimse;
ate (turma = 'R');
MediaDisc := SomaDisc/NDisc;
escreva(AprovDisc:3, MediaDisc:6:2, MelhorDisc:6:2);
fim.




68
EXERCÍCIOS GERAIS - Estruturas de controle

1) Fazer um programa que:
- Leia um número indeterminado de linhas contendo cada uma a idade de um indivíduo. A
última linha, que não entrará nos cálculos, contém o valor da idade igual a zero;
- Calcule e escreva a idade média deste grupo de indivíduos.

2) Tem-se um conjunto d3e dados contendo a altura e o sexo (masculino e feminino) de 50 pessoas.
Fazer um programa que calcule e escreva:
- a maior e a menor altura do grupo;
- a média de altura das mulheres;
- o número de homens;

3) A conversão de graus Fahrenheit para centígrados é obtida por C = 5 ( F- 32 ).
9
Fazer um programa que calcule e escreva uma tabela de centígrados em função de graus Fahrenheit,
que variam de 50 a 150 de 1 em 1.

4) Um comerciante deseja fazer o levantamento do lucro das mercadorias que ele comercializa. Para
isto, mandou digitar uma linha para cada mercadoria com o nome, preço de compra e preço de venda
das mesmas. Fazer um programa que:
Compra e preço de venda das mesmas. Fazer um programa que:
- Determine e escreva quantas mercadorias proporcionam:
- Lucro < 100%
- 10% < lucro < 20%
- Lucro > 20%
- Determine e escreva o valor total de compra e de venda de todas as mercadorias, assim
como o lucro total.
Observação: o aluno deve adota um flag.

5) Supondo que a população de um país A seja da ordem de 90.000.000 de habitantes comum à taxa
anual de crescimento de 3% e que a população de um país B seja, aproximadamente , de
200.000.000 de habitantes com uma taxa anual de crescimento de 1,5%, fazer um programa que
calcule e escreva o número de anos necessários para que a população do país A ultrapasse ou
iguale a população do país B, mantidas essas taxas de crescimento.

6) Um determinado material radioativo perde metade de sua massa a cada 50 segundos. Dada a
massa inicial, em gramas, fazer um programa que determine o tempo necessário para que essa
massa se torne menor do que 0,5 grama. Escreva a massa inicial, a massa final e o tempo calculado
em horas, minutos e segundos.

7) Deseja-se fazer um levantamento a respeito da ausência de alunos à primeira prova de
Programação de Computadores para cada uma das 14 turmas existentes. Para cada turma, é
fornecido um conjunto de valores, sendo que os dois primeiros valores do conjunto correspondem à
identificação da turma (A, ou B, ou C,...) e ao número de alunos matriculados, e os demais valores
deste conjunto contêm o número de matrícula do aluno e a letra A ou P para o caso de o aluno estar
ausente ou presente, respectivamente. Fazer um programa que:
- Para cada turma, calcule a porcentagem de ausência e escreva a identificação da turma e a
porcentagem calculada;
- Determine e escreva quantas turmas tiveram porcentagem de ausência superior a 5%.

8) Uma certa firma fez uma pesquisa de mercado para saber se as pessoas gostaram ou não de um
novo produto lançado o mercado. Para isso, forneceu o sexo do entrevistado e sua resposta (sim ou
não). Sabendo-se que foram entrevistadas 2.000 pessoas, fazer um programa que calcule e escreva:

- O número de pessoas que responderam sim;
- o número de pessoas que responderam não;
- a porcentagem de pessoas do sexo feminino que responderam sim;
- a porcentagem de pessoas do sexo masculino que responderam não;

9) Foi feita uma pesquisa para determinar o índice de mortalidade infantil em um certo período. Fazer
um programa que:
69
a) leia inicialmente o número de crianças nascidas no período;
b) leia, em seguida, um número indeterminado de linhas, contendo, cada uma, o sexo de uma
criança morta ( masculino, feminino ) e o número de meses de vida da criança. A última linha,
que não entrará nos cálculos, contém no lugar do sexo a palavra “vazio”;
c) Determine e imprima:
i. a porcentagem de crianças mortas no período;
ii. a porcentagem de crianças do sexo masculino mortas no período;
iii. a porcentagem de crianças que viveram 24 meses ou menos no período.

10) Foi feira uma pesquisa de audiência de canal de TV em várias casas de uma certa cidade, num
determinado dia. Para cada casa visitada, é fornecido o número do canal (4, 5, 7, 12) e o número de
pessoas que o estavam assistindo naquela casa. Se a televisão estivesse desligada, nada era
anotado, ou seja esta casa não entrava na pesquisa. Se a televisão estivesse desligada, nada era
anotado, ou seja esta casa não entrava na pesquisa. Fazer um programa que :
a) Leia um número indeterminado de dados, sendo que o “FLAG” corresponde ao número do
canal igual a zero;
b) Calcule a porcentagem de audiência para cada emissora;
c) Escreva o número do canal e a sua respectiva porcentagem.

11) Uma universidade deseja fazer um levantamento a respeito de seu concurso vestibular. Para
cada curso, é fornecido o seguinte conjunto de valores:
a) o código do curso;
b) número de vagas;
c) número de candidatos do sexo masculino;
d) número de candidatos do sexo feminino;
O último conjunto, para indicar fim de dados, contém o código do curso igual a zero. Fazer um
programa que:
i. calcule e escreva para cada curso, o número de candidatos por vaga e a porcentagem de
candidatos do sexo feminino ( escreva também o código correspondente do curso);
ii. determine o maior número de candidatos por vaga e escreva esse número juntamente com o
código do curso correspondente (supor que não haja empate);
iii. calcule e escreva o total de candidatos.

12) O sistema de avaliação de uma determinada disciplina obedece aos seguintes critérios:
a) Durante o semestre são dadas três notas;
b) A nota final é obtida pela média aritmética das notas dadas durante o curso;
c) É considerado aprovado o aluno que obtiver a nota final superior ou igual a 60 e que tiver
comparecido a um mínimo de 40 aulas.
Fazer um programa que:
a) Leia um conjunto de dados contendo o número de matrícula, as três notas e a freqüência (número
de aulas freqüentadas) de 100 alunos.
b) Calcule:
i. a nota final de cada aluno;
ii. a maior e a menor nota da turma;
iii. a nota média da turma;
iv. o total de alunos reprovados;
v. a porcentagem de alunos reprovados por infreqüência.

c) Escreva:
a) para cada aluno, o número de matrícula, a freqüência, a nota final e o código (aprovado ou
reprovado);
b) o que foi calculado no item b (2,3,4, e 5).

13) Deseja-se fazer uma pesquisa a respeito do consumo mensal de energia elétrica em uma
determinada cidade. Para isso, após fornecidos os seguintes dados:
a) preço do kWh consumido;
b) o número do consumidor;
c) quantidade de kWh consumidos durante o mês;
d) código do tipo de consumidor (residencial, comercial, industrial);
O número do consumidor igual a zero deve ser usado como flag. Fazer um programa que:
a) leia os dados descritos acima;
b) calcule:
70
c) para cada consumidor, o total a pagar;
d) o maior consumo verificado;
e) o menor consumo verificado;
f) o total do consumo para cada um dos três tipos de consumidores;
g) a média geral de consumo;
h) escreva:
1) para cada consumidor, o seu número e o total a pagar;
2) o que foi calculado nos itens b, c, d, e acima especificados.

14) Tem-se uma estrada ligando várias cidades. Cada cidade tem seu marco quilométrico. Fazer um
programa que:

a) leia vários pares de dados, contendo cada par os valores dos marcos quilométricos, em ordem
crescente, de duas cidades. O último par contém estes dois valores iguais;
b) calcule os tempos decorridos para percorrer a distância entre estas duas cidades, com as
seguintes velocidades: 20, 30, 40, 50, 60, 70 e 80 km/hora, sabendo-se que:

t = e , onde t = tempo; e = espaço; v = velocidade;
v
c) escreva os marcos quilométricos, a velocidade e o tempo decorrido entre as duas cidades,
apenas quando este tempo for superior a 2 horas.

15) Os bancos atualizam diariamente as contas de seus clientes. Essa atualização envolve a análise
dos depósitos e retiradas de cada conta. Numa conta de saldo mínimo, uma taxa de serviço é
deduzida se a conta cai abaixo de uma certa quantia especificada.
Suponha que uma conta particular comece o dia com um saldo de R$ 60,00. O saldo mínimo exigido
é R$30,00 e se o saldo de fim de dia for menor do que isso, uma taxa é debitada da conta. A fim de
que esta atualização fosse feita utilizando computador, é fornecido, para cada conta, o seguinte
conjunto de dados:
a) a primeira linha contém o número da conta, o valor do saldo atual e do saldo mínimo diário,
quantidade de transações e taxa de serviço;
b) as linhas seguintes contêm o valor e o código da transação (depósito ou retirada).
Escrever um programa que:
a) calcule o saldo (crédito/débito) da conta a o fim do dia (se o resultado for negativo, isto significa
insuficiência de fundos na conta);
b) escreva para cada conta, o seu número e o saldo calculado. Se não houver fundos, imprima o
número da conta e a mensagem “NÃO HÁ FUNDOS”.
c) Utilize como flag o nº da conta igual a zero.

16) Uma empresa decidiu fazer um levantamento em relação aos candidatos que se apresentarem
para preenchimento de vagas no seu quadro de funcionários, utilizando processamento eletrônico.
Supondo que você seja o programador encarregado desse levantamento, fazer um programa que:
a) leia um conjunto de dados para cada candidato contendo:
b) número de inscrição do candidato,
c) idade,
d) sexo (masculino, feminino);
e) experiência no serviço (sim ou não);
O último conjunto contém o número de inscrição do candidato igual a zero.
Calcule:
a) o número de candidatos do sexo feminino,
b) o número de candidatos do sexo masculino,
c) idade média dos homens que já têm experiência no serviço,
d) porcentagem dos homens com mais de 45 anos entre o total de homens,
e) número de mulheres que têm idade inferior a 35 anos e com experiência no serviço,
f) a menor idade entre mulheres que já têm experiência no serviço;
Escreva:
• o número de inscrição das mulheres pertencentes ao grupo descrito no item e,
• o que foi calculado em cada item acima especificado.


17) Uma companhia de teatro planeja dar uma série de espetáculos. A direção calcula que, a
R$15,00 o ingresso, serão vendidos 120 ingressos, e as despesas montarão R$600,00. A uma
71
diminuição de R$3,00 no preço dos ingressos espera-se que haja um aumento de 26 ingressos
vendidos.
Fazer um programa que escreva uma tabela de valores do lucro esperado em função do preço do
ingresso, fazendo-se variar este preço de R$15,00 a R$3,00 de R$3,00 em R$3,00. Escreva, ainda, o
lucro máximo esperado, o preço e o número de ingressos correspondentes.

18) A comissão organizadora de um rallye automobilístico decidiu apurar os resultados da competição
através de um processamento eletrônico.
Um dos programas necessários para a classificação das equipes concorrentes é o que emite uma
listagem geral do desempenho das equipes, atribuindo pontos segundo determinadas normas.
O programa deverá:

a) Ler:
a. 1) uma linha contendo os tempos-padrão (em minutos decimais) para as três fases de competição;
a .2) um conjunto de linhas contendo cada uma o número de inscrição da equipe e os tempos (em
minutos decimais) que as mesmas despenderam ao cumprir as três diferentes etapas. A última linha
(flag), que não entrará nos cálculos, contém o número 9999 como número de inscrição.

b) Calcular:
b.1) os pontos de cada equipe em cada uma das etapas, seguindo o seguinte critério: Seja
o valor absoluto da diferença entre o tempo-padrão (lido na primeira linha) e o tempo despendido pela
equipe numa etapa:
DELTA < 3 minutos - atribuir 100 pontos à etapa
3 < DELTA < 5 minutos – atribuir 80 pontos à etapa
DELTA > 5 minutos – atribuir 80 – DELTA – 5 pontos à etapa;
5
b.2) o total de pontos de cada equipe nas três etapas;
b.3) a equipe vencedora.

c) Escrever:
c.1) para cada equipe, o número de inscrição, os pontos obtidos em cada etapa e o total de pontos
obtidos.

19) Numa certa loja de eletrodomésticos, o comerciário encarregado da seção de televisores recebe,
mensalmente, um salário mínimo mais comissão. Essa comissão é calculada em relação ao tipo e ao
número de televisores vendidos por mês, obedecendo ao quadro abaixo:

TIPD N° 0E TELEVISDPES VEN0I0DS CDhISSDES
A cores
|aIor ou Igual a 10
|enor ou Igual a 10
14º do preço por televIsor vendIdo
1Jº do preço por televIsor vendIdo
Preto e branco
|aIor ou Igual a 20
|enor do que 20
1Jº do preço por televIsor vendIdo
12º do preço por televIsor vendIdo

Sabe-se ainda, que ele tem um desconto de 8% sobre seu salário bruto para o INSS.Se o seu salário
total (mínimo + comissões – INSS), for maior que o limite de isenção do imposto de renda, ele ainda
terá um desconto de 15% sobre o que ultrapassar o limite de isenção retido na fonte. Sabendo-se que
existem 20 empregados nesta seção, leia os valores do salário mínimo, do limite de isenção de IRRF,
os preços dos televisores em cores e preto e branco e, para cada comerciário, o número de sua
inscrição, o número de televisores a cores e o número de televisores preto e branco vendidos; calcule
e escreva o número de inscrição de cada empregado, seu salário bruto e seu salário líquido.

20) O dia da semana para uma data qualquer pode ser calculado pela seguinte fórmula:
Dia da Semana = RESTO (( TRUNCA(2,6 X M – 0,1 ) + D + A + QUOCIENTE (A,4) + QUOCIENTE
(S,4) – 2 X S),7)
Onde:
M – representa o número do mês. Janeiro e fevereiro são os meses 11 e 12 do ano precedente,
março é o mês 1 e dezembro é o mês 10:
D – representa o dia do mês;
A - representa o número formado pelos dois últimos algarismos do ano;
S – representa o número formado pelos dois primeiros algarismos do ano.
Os dias da semana são numerados de zero a seis; domingo corresponde a 0, segunda a 1, e assim
por diante.
72
Fazer um programa que:
a) leia um conjunto de 50 datas (doa, mês, ano);
b) - determine o dia da semana correspondente à data lida, segundo o método especificado;
c) escreva, para cada data lida, o dia, mês, ano e o dia da semana calculado.

21) Numa fábrica trabalham homens e mulheres divididos em três classes:
A – os que fazem até 30 peças por mês;
B – os que fazem de 31 a 35 peças por mês;
C – os que fazem mais de 35 peças por mês.
A classe A recebe salário mínimo. A classe B recebe salário mínimo e mais 3% do salário mínimo por
peça, acima das 30 iniciais. A classe C recebe salário mínimo e mais 5% do salário mínimo por peça
acima das 30 iniciais.
Fazer um programa que:
a) leia várias linhas, contendo cada uma:
• o número do operário,
• o número de peças fabricadas por mês,
• o sexo do operário;
b) calcule e escreva:
a) o salário de cada operário,
b) o total da folha mensal de pagamento da
fábrica,
c) o número total de peças fabricadas por
mês,
d) a média de peças fabricadas pelos homens
de cada classe,
e) a média de peças fabricadas pelas
mulheres em cada classe,
f) o número do operário ou operária de maior
salário (não existe empate).
Observação: A última linha, que servirá de flag, terá o número do operário igual a zero.

22) Uma determinada fábrica de rádios possui duas linhas de montagem distintas: standart e luxo. A
linha de montagem standart comporta um máximo de 24 operários; cada rádio standart dá um lucro X
e gasta um homem-dia para sua confecção. A linha de montagem comporta no máximo 32 operários;
cada rádio luxo dá um lucro Y e gasta 2 homens-dia para sua confecção. A fábrica possui 40
operários. O mercado é capaz de absorver toda a produção e o fabricante deseja saber qual
esquema de produção a adotar de modo a maximizar seu lucro diário.
Fazer um programa que leia os valores de X e Y e escreva, para esse esquema de lucro
máximo, o número de operários na linha standart e na linha luxo, o número de rádios standart e luxo
produzidos e o lucro.

23) Fazer um programa para calcular o número de dias decorridos entre duas datas (considerar
também a ocorrência de anos bissextos), sabendo-se que:
• cada par de datas é lido numa linha, a última linha contém o número do dia negativo;
• a primeira data na linha é sempre a mais antiga
• o ano está digitado com quatro dígitos;
• um ano será bissexto se for divisível por 400, ou se for divisível por 4 e não o for por 100.

PROBLEMAS ENVOLVENDO CÁLCULO DE SOMATÓRIOS
24) Fazer um programa que calcule e escreva o valor de S:

S= 1 + 3 + 5 + 7 +...+ 99
1 2 3 4 50

25) Fazer um programa que calcule e escreva a seguinte soma:

2
1
+ 2
2
+ 2
3
+...+ 2
50

50 49 48 1

26) Fazer um programa para calcular e escrever a seguinte soma:

S= 37 X 38 + 36 X 37 + 35 X 36 +...+ 1 X 2
73
1 2 3 37

27) Fazer um programa que calcule e escreva o valor de S onde:

S= 1 - 2 + 3 - 4 + 5 - 6 ...- 10
1 4 9 16 25 36 100

28) Fazer um programa que calcule e escreva a soma dos 50 primeiros termos da seguinte série:

1.000 - 997 + 994 - 991 +...
1 2 3 4

29) Fazer um programa que calcule e escreva a soma dos 30 primeiros termos da série:

480 - 475 + 470 - 465 +...
10 11 12 13

30) escrever um programa para gerar e escrever uma tabela com os valores do seno de um ângulo A
radianos, utilizando a série de Mac-Laurin Truncada, apresentada a seguir:

sen A = A – A
3
+ A
5
– A
7

6 120 5.040

Condições: os valores dos ângulos A devem variar de 0.0 a 6.3, inclusive, de 0.1 em 0.1.

31) Fazer um programa para calcular e escrever o valor do número , com precisão de 0,0001,
usando a série:

= 4 – 4 + 4 – 4 + 4 – 4 +...
3 5 7 9 11

Para obter a precisão desejada, adicionar apenas os termos cujo valor absoluto seja maior ou igual
0,0001.

32) O valor aproximado de pode ser calculado usando-se a série

S= 1 - 1 + 1 - 1 + 1 ...
1
3
3
3
5
3
7
3
9
3
Sendo =
3
S X 32
Fazer um programa para calcular e escrever o valor de com 51 termos.

33) Fazer um programa que:
a) leia o valor de X de uma unidade de entrada;
b) calcule e escreva o valor do seguinte somatório:

S= X
25
- X
24
+ X
23
- X
22
+...+ X
1 2 3 4 25

34) Fazer um programa que calcule e escreva a soma de S no seguinte somatório:

S= 1 - 2 + 4 - 8 +...+ 16.384
225 196 169 144 1

35) Fazer um programa que calcule e escreva a soma dos 20 primeiros termos da série:

100 + 99 + 98 + 97 +...
0! 1! 2! 3!

36) Elaborar um programa que:
1. calcule e escreva o valor da série abaixo com precisão menor que um décimo de milionésimo
(0,0000001);
2. indique quantos termos foram usados.
74

S= 63 + 61 + 59 + 57 +...
1! 2! 3!

37) Fazer um programa que calcule e escreva a soma dos 50 primeiros termos da série:

1! – 2! + 3! – 4! + 5! -...
1 3 7 15 31

38) Fazer um programa que calcule o valor de e
x
através da série:

e
x
= x
0
+ x
1
+ x
2
+ x
3
+...

1! 2! 3!
De modo que o mesmo difira do valor calculado através da função Exp de, no máximo, 0,0001.
O valor de x deve ser lido de uma unidade de entrada. O programa deverá escrever o valor de x, o
valor calculado através da série, o valor dado pela função Exp e o número de termos utilizados da
série.

39) Fazer um programa para determinar e escrever o valor do seguinte somatório:

S = X - X
2
+ X
4
- X
6
+...

3! 5! 7!


40) Fazer um programa que:
• calcule o valor do co-seno de x através de 20 termos da série seguinte:

co-seno(x) = 1 - x
2
+ x
4
– x
6
+ x
8
-...

2! 4! 6! 8!
• calcule a diferença entre o valor calculado no item a e o valor fornecido pela função
Cós(X);
• imprima o que foi calculado nos itens a e b.

Observação: o valor de x é fornecido como entrada.


75
Funções matemáticas e de String em Java

Funções matemáticas

s funções matemáticas permitem efetuar diversos tipos de cálculos matemáticos. Para realizar
esses cálculos, são utilizados os métodos da classe Math que devem apresentar a seguinte
sintaxe:

Math.<nome da função ou método>(<argumentos ou lista de argumentos);

Não é necessário importar a classe Math em um programa para poder utilizar seus recursos,
pois ela já faz parte do pacote java.lang, importado automaticamente pelo compilador de Java.

A classe Math define duas constantes matemáticas, Math.PI – o valor de pi ( =
3.14159265358979323846) e Math.E que se refere ao valor da base para logaritmos naturais
(2.7182818284590452354).
A seguir são apresentadas as principais funções (ou métodos) da classe Math:

junçáo 0escrìçáo Sìntaxe
ceìl() A função ceìl(), ou método, como é chamado em
Java, é utIlIzada para arredondar um numero do tIpo
double para o seu proxImo InteIro.
|ath.ceIl(·valor do tIpo double·);
jloor() A função ]loor() é utIlIzada para arredondar um
determInado numero, porém esse numero é
arredondado para o seu InteIro anterIor.
|ath.floor(·valor do tIpo double·);
max() A função mcx() é utIlIzada para verIfIcar o maIor
valor entre soIs numeros, que podem ser do tIpo
double, ]loct, ìnt ou lony.
|ath.max(·valor1·,·valor2·);
mìn() A função mìn() fornece o resultado contrárIo da
função mcx(), sendo então utIlIzada para obter o
valor minImo entre doIs numeros.
|ath.mIn(·valor1·,·valor2·);
sqrt() Quando há necessIdade de calcular a raIz quadrada
de um determInado numero, utIlIza·se a função
sqrt(), sendo que o numero do qual de deseja extraIr
a raIz quadrada deve ser do tIpo double e o
resultado obtIdo também será um numero do tIpo
double.
|ath.sqrt(·valor do tIpo double·);
µow() AssIm, como é possivel extraIr a raIz quadrada de
um numero, também é possivel fazer a operação
Inversa, ou seja, elevar um determInado numero ao
quadrado ou a qualquer outro valor de potëncIa.
|ath.pow(·base·,·expoente·);
random() A função random() é utIlIzada para gerar valores de
forma aleatorIa. Toda vez que uma função random()
é chamada, será sorteada um valor do tIpo double
entre 0.0 e 1.0 (o valor 1 nunca será sorteado). Nem
sempre esta faIxa de valores é sufIcIente para uma
aplIcação real. Por exemplo, para sImular o sorteIo
de numeros entre 0 e 99 para um jogo de loterIa
qualquer, torna·se necessárIo o sorteIo de numeros
InteIros aleatorIos no Intervalo de 0 a 99. Para que
esses numeros possam ser sorteados, é necessárIa a
utIlIzação do operador de multIplIcação em conjunto
com a função rcndom(). Com Isso torna·se possivel
defInIr o Intervalo em que o numero será sorteado.
D conversor ìnt também pode ser usado para truncar
a parte do ponto flutuante para que um numero
InteIro seja gerado.
(Int) (|ath.random()*100);

Exemplos:
A
76

a) funções matemáticas

class ExemplosFuncMat{
public static void main(String args[]){
double a = 5.2, b = 5.6, c= -5.8, C= -5.9,D = -4.5;
double x = 900, y = 30.25;
double base = 5.5, expoente = 2;
int A = 10, B = 15;

//função ceil()
System.out.println("FUNCAO ceil()");
System.out.println("Arredondando 5.2 = " + Math.ceil(a));
System.out.println("Arredondando 5.6 = " + Math.ceil(b));
System.out.println("Arredondando -5.8 = " + Math.ceil(c));
System.out.println();
//função floor()
System.out.println("FUNCAO floor()");
System.out.println("Arredondando 5.2 = " + Math.floor(a));
System.out.println("Arredondando 5.6 = " + Math.floor(b));
System.out.println("Arredondando -5.8 = " + Math.floor(c));
System.out.println();
//função max()
System.out.println("FUNCAO max()");
System.out.println("O maior entre 10 e 15 e = " + Math.max(A,B));
System.out.println("O maior entre -5.9 e -4.5 e = " + Math.max(C,D));
System.out.println("O maior entre 10 e -5.9 e = " + Math.max(A,C));
System.out.println();
//função min()
System.out.println("FUNCAO min()");
System.out.println("O menor entre 10 e 15 e = " + Math.min(A,B));
System.out.println("O menor entre -5.9 e -4.5 e = " + Math.min(C,D));
System.out.println("O menor entre 10 e -5.9 e = " + Math.min(A,C));
System.out.println();
//função sqrt()
System.out.println("FUNCAO sqrt()");
System.out.println("A raiz quadrada de 900 e = " + Math.sqrt(x));
System.out.println("A raiz quadrada de 30.25 e = " + Math.sqrt(y));
System.out.println();
//função pow()
System.out.println("FUNCAO pow()");
System.out.println("5.5 elevado a 2 e = " + Math.pow(base,expoente));
System.out.println("25 elevado a 0.5 e = " + Math.pow(25,.5));

System.out.println("5678 elevado a 0 e = " + Math.pow(5678,0));

}
}

b) Função random()

class ExemploRandom{
public static void main(String args[]){
for(int qtd = 1; qtd <= 5;qtd++){
for(int x = 1;x<=6;x++){
int num = (int) (Math.random()*99);
System.out.print(num+" ");
}
System.out.println();
}
}
}



77
Funções de String

Uma String corresponde à união de um conjunto de caracteres. Em Java, as strings são
instâncias da classe string. Essas strings podem ser manipuladas de várias formas. Por exemplo é
possível verificar seu comprimento, retirar um pedaço dela, acessa ou mudar caracteres individuais.
As strings constituem-se uma cadeia de caracteres entre aspas.
Exemplo: S = “Linguagem Java”.

Da mesma forma que as funções matemáticas, existem diversas funções (ou métodos se
preferir) para manipulação de strings. Estas funções acompanham a seguinte sintaxe:

<nome da string>.<função>(<argumento/s>);

junçáo 0escrìçáo Sìntaxe
lenyth() A função lenythl() é utIlIzada para retornar o
tamanho de uma determInada strìny, IncluIndo os
espaços em branco presentes nela. Esta função
retorna sempre um valor do tIpo ìnt.
·strIng·length();
charAt() A função chcrAt() é utIlIzada para retornar um
caractere de uma determInada strìny de acordo
com um indIce especIfIcado entre parënteses.
Esse indIce refere·se à posIção do caractere na
strìny, sendo 0 o indIce do prImeIro caractere, 1
o do segundo e assIm por dIante.
·strIng·.charAt(·indIce·);
toUµµerCase() Transforma todas as letras de uma strìny em
maIusculas.
·strIng·.toUpperCase()
toLowerCase() Transforma todas as letras de uma strìny em
mInusculas.
·strIng·.toLowerCase()
substrìny() A função substrìny() é utIlIzada para retornar
uma copIa de caracteres de uma strìny a partIr
de doIs indIces InteIros especIfIcados,
funcIonando basIcamente da mesma forma que a
função charAt dentro de um loopìny.
·strIng·.substrIng(·indIce
InIcIal·,[·indIce fInal·]);
trìm() A função trìm() tem por objetIvo remover todos
os espaços em branco que aparecem no InicIo e
no fInal de uma determInada strìny. Dbserve que
serão removIdos apenas os espaços do InicIo e do
fIm da strìny; não serão removIdos os espaços
entre as palavras.
·strIng·.trIm();
reµlace() A função replcce() é utIlIzada para substItuIção
de caracteres IndIvIduaIs em uma determInada
strìny. Para seu funcIonamento é necessárIo
Informar o caractere que deseja substItuIr e por
qual caractere ele será substItuido. Caso não haja
na strìny nenhuma ocorrëncIa do caractere a ser
substItuido, a strìny orIgInal é retornada.
·strIng·.replace(·caracter a ser
substItuIdo·.·substItuIção·)


Exemplos:

a) funções de String

class ExemplosFunString{
public static void main(String args[]){
String A = "Aprendendo Java";
String a = "ARROZ", b = "batata";
String frase = " Cristo: o rei dos reis ";
String x = "banana nanica";
int tamanho = A.length();
System.out.println("Exempo da funcao length()");
78
System.out.println("String: " + A);
System.out.println("O tamanho da string e: "+ tamanho);
System.out.println();
System.out.println("Exemplo da funcao charAt()");
System.out.println("Caracter = "+A.charAt(5));
for(int i = 11;i<=14;i++)
System.out.println(A.charAt(i));
System.out.println();
System.out.println("Exemplo das funcoes toUpperCase() e
toLowerCaser()");
System.out.println("ARROZ em minuscula = "+a.toLowerCase());
System.out.println("batata em maiuscula = "+b.toUpperCase());
System.out.println("SaLaDa em minuscula = "+"SaLaDa".toLowerCase());
System.out.println();
System.out.println("Exemplo da funcao substring()");
System.out.println(A);
System.out.println("do 3 caractere ate o fim = "+A.substring(2));
System.out.println("do 1 caractere ate o 10 = "+A.substring(0,10));
System.out.println("do 12 caractere ate o 15 = "+A.substring(11,15));
System.out.println();
System.out.println("Exemplo das funcao trim()");
System.out.println("Com espacos: "+ "*" + frase + "*");
System.out.println("Sem espacos: "+ "*" + frase.trim() + "*");
System.out.println();
System.out.println("Exemplo das funcao replace()");
System.out.println("String: " + x);
System.out.println();
System.out.println("Trocar caracter 'a' por 'u': " +
x.replace('a','u'));
System.out.println("Trocar caracter 'n' por 'N': " +
x.replace('n','N'));
System.out.println("Trocar caracter espaco por '_': " + x.replace('
','_'));

}
}

b) Criação de Banners

class ExemploBanners{
public static void main(String args[]){
String palavra = ""; //a variavel palavra sera usaa no banner
if (args.length==1){
System.out.println("Mostra a palavra letra a letra");
System.out.println("Para encerrar pressione CTRL+C");
palavra = args[0]; //a variavel palavra recebe a palavra
digitada
while(true) { //looping infinito
for(int i =0;i<palavra.length();i++){ //varre os
caracteres da palavra
System.out.println(palavra.charAt(i));
for(int x=0;x<50000000;x++); //temporizador1

}
System.out.println();
for(int y=0;y<100000000;y++); //temporizador2

}
}
else
System.out.println("Entre com uma palavra qualquer");
}
}



79
Exercícios de fixação - funções matemáticas e de Strings

1. Crie um programa que simule a jogada de um dado (de seis lados) dez vezes e mostre o resultado
na tela.
2. Um ciclista criou um aparelho que marca quantas voltas a roda de sua bicicleta dá em um
determinado percurso. Com o uso desse aparelho é possível descobrir qual a distância percorrida
em um percurso, desde que o raio do pneu da bicicleta seja conhecido. Faça um programa que
calcule a distância percorrida, em que deve ser fornecida a quantidade de voltas que a roda da
bicicleta deu e o diâmetro dessa roda em metros. Para saber o comprimento da roda a partir do
diâmetro fornecido, use a fórmula: c = pi*d/2 (em que c = comprimento, pi = 3.1416 e d = diâmetro
da circunferência). Sabendo o comprimento da roda, basta multiplicá-lo pelo número de voltas
para descobrir a distância do percurso. Arredonde o resultado para seu próximo inteiro.
3. Crie um programa que clacule quantos metros cúbicos de água suporta uma determinada cx
d'água em forma de cubo (todos os aldos são iguais). O usuário deve informar o valor do lado, e o
volume de água será calculado pela fórmula: volume = lado
3
. Arredonde o resultado para seu
inteiro anterior.
4. Crie um aplicativo que receba uma frase qualquer e mostre-a de forma invertida.
Exemplo:
frase digitada: Java Ensino Didatico
resultado esperado:
ocitadiD onisnE avaJ

5. Crie um aplicativo que mostre o efeito apresentado no exemplo abaixo para uma determinada
palavra.
Exemplo:
palavra digitada: Java
efeito:
J
Ja
Jav
Java
Jav
Ja
J

80
Vetores e matrizes

Variáveis compostas homogêneas

ssim como na teoria dos conjuntos, uma variável pode ser interpretada como um elemento e
uma estrutura de dados, como um conjunto. Quando determinada estrutura de dados é
composta por varáveis com o mesmo tipo primitivo, temos um conjunto homogêneo de dados.

Variáveis compostas unidimensionais {vetores)

Declaração

<identificador>: vetor [li..lf] de tipo;
Em que:
Li representa o limite inicial do vetor;
Lf representa o limite final do vetor;
Identificador é o nome dado ao vetor
tipo representa qualquer tipo básico ou tipo anteriormente definido.

Exemplo:
Um vetor de 10 posições de reais poderia ter a seguinte definição e declaração:

v: vetor[0..9] de real;


Índice 0 1 2 3 4 5 6 7 8 9
Elemento 1º 2º 3º 4º 5º 6º 7º 8º 9º 10º
Variável v[0] v[1] v[2] v[3] v[4] v[5] v[6] v[7] v[8] v[9]
Valor 58 4 -5.7 2 3.2 6 9 7 0 -1

Manipulação

O nome do vetor é denominado por meio do identificador que foi utilizado na definição de
variáveis, e a posição por meio da constante, da expressão aritmética ou da variável que estiver
dentro dos colchetes, também denominada índice.
Para manipularmos um determinado valor (elemento) em um vetor, precisamos fornecer o
nome do vetor (identificador) e o índice do elemento desejado. Esse índice determina a posição em
que o elemento está inserido na estrutura. Cada posição contém exatamente um valor que pode ser
manipulado individualmente.
Após isolar um único elemento de um vetor, poderemos manipulá-lo através de qualquer
operação de entrada, saída ou atribuição.

Exemplo:
V[5] = 6;
leia(v[5]);
escreva(v[5]);





As estruturas de dados são estritamente relacionadas com os algoritmos. Então, para uma
melhor percepção desses conceitos, utilizaremos a situação de construir um algoritmo que calcule a
média aritmética geral de uma classe com dez alunos e imprimir a quantidade de notas acima da
média calculada.

Exemplo
a) algoritmo em pseudocódigo

inicio
A,B,C,D,E,F,G,H,I,J,NotaAcima:inteiro;
A
58 4 -5.7 2 3.2 6 9 7 0 -1
0 1 2 3 4 5 6 7 8 9

81
media:real;
leia(A,B,C,D,E,F,G,H,I,J);
media = (A+B+C+D+E+F+G+H+I+J)/10;
se(A >media) entao
NotaAcima = NotaAcima+1;
fimse;
se(B >media) entao
NotaAcima = NotaAcima+1;
fimse;
se(C >media) entao
NotaAcima = NotaAcima+1;
fimse;
se(D >media) entao
NotaAcima = NotaAcima+1;
fimse;
se(E >media) entao
NotaAcima = NotaAcima+1;
fimse;
se(F >media) entao
NotaAcima = NotaAcima+1;
fimse;
se(G >media) entao
NotaAcima = NotaAcima+1;
fimse;
se(H >media) entao
NotaAcima = NotaAcima+1;
fimse;
se(I >media) entao
NotaAcima = NotaAcima+1;
fimse;
se(J >media) entao
NotaAcima = NotaAcima+1;
fimse;
escreva(NotaAcima);
fim.

b) programa em Java

import java.io.*;
class NotaAcimaM{
public static void main(String args[]){
int a,b,c,d,e,f,g,h,i,j,NotaAcima=0;
float media;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
System.out.println("Entre com a media do 1 aluno: ");
a = Integer.parseInt(entrada.readLine());
System.out.println("Entre com a media do 2 aluno: ");
b = Integer.parseInt(entrada.readLine());
System.out.println("Entre com a media do 3 aluno: ");
c = Integer.parseInt(entrada.readLine());
System.out.println("Entre com a media do 4 aluno: ");
d = Integer.parseInt(entrada.readLine());
System.out.println("Entre com a media do 5 aluno: ");
e = Integer.parseInt(entrada.readLine());
System.out.println("Entre com a media do 6 aluno: ");
f = Integer.parseInt(entrada.readLine());
System.out.println("Entre com a media do 7 aluno: ");
g = Integer.parseInt(entrada.readLine());
System.out.println("Entre com a media do 8 aluno: ");
h = Integer.parseInt(entrada.readLine());
System.out.println("Entre com a media do 9 aluno: ");
i = Integer.parseInt(entrada.readLine());
82
System.out.println("Entre com a media do 10 aluno: ");
j = Integer.parseInt(entrada.readLine());
media = (a+b+c+d+e+f+g+h+i+j)/10;
if(a > media)
NotaAcima +=1;
if(b > media)
NotaAcima +=1;
if(c > media)
NotaAcima +=1;
if(d > media)
NotaAcima +=1;
if(e > media)
NotaAcima +=1;
if(f > media)
NotaAcima +=1;
if(g > media)
NotaAcima +=1;
if(h > media)
NotaAcima +=1;
if(i > media)
NotaAcima +=1;
if(j > media)
NotaAcima +=1;
System.out.println("A quantidade de alunos com nota acima da
media e: "+NotaAcima);

}catch(Exception E){
System.out.println("Houve erro na entrada de dados");
}
}
}


O algoritmo mostrado acima torna-se impraticável para uma grande quantidade de notas.
Seria muito mais coerente se usássemos uma única variável que comportasse muitos dados, isto é,
um vetor armazenando cada nota em uma posição diferente do mesmo. Vejamos como ficaria o
exemplo utilizando vetor:


Exemplo:

a) algoritmo em pseudocódigo

inicio
//declaração do vetor vclasse e das variaveis
vclasse= vetor[1..10] de reais;
soma,media:real;
NotaAcima,x:inteiro;

//inicialização de variáveis
soma =0;
NotaAcima = 0;

//leitura do vetor vclasse
para x=1 ate 10 faca
leia(vclasse[x]);
fimpara;

//laço para acumular em soma os valores de vclasse
para x=1 ate 10 faca
soma = soma +vclasse[x];
fimpara;
media = soma/10;

//laço para veificar os valores de vclasse que estão acima da media
83
para x=1 ate 10 faca
se (vclasse[x] > media) entao
NotaAcima = NotaAcima+1;
fimse;
fimpara;

//numero de valores acima da media
escreva(NotaAcima);
fim.

b) programa em Java

import java.io.*;
class NotaAcimaM_Vet{
public static void main(String args[]){
float classe[] = new float[10]; //declaracao do array de 10 posicoes
de inteiros
int i,NotaAcima=0;
float soma=0, media;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
//entrada de dados
System.out.println("Entre com as notas dos alunos:");
for(i=0;i<=9;i++)
classe[i] = Float.parseFloat(entrada.readLine());
//soma dos valores
for(i=0;i<=9;i++)
soma +=classe[i];
//calculo da media
media = soma/10;
for(i=0;i<=9;i++){
if (classe[i] > media)
NotaAcima +=1;
}
System.out.println("A quantidade de alunos com nota acima da
media e: "+NotaAcima);
}catch(Exception e){
System.out.println("Houve erro na entrada de dados!");
}

}
}

Exemplos:

1) Elabore um algoritmo que leia, some e imprima o resultado da soma, entre dois vetores inteiros de
50 posições.

Solução:

a) algoritmo em pseudocódigo

inicio
v1,v2,v3:vetor[1..50] de inteiros;
i:inteiro;
para i=1 ate 50 faca
leia(v1[i],v2[i]);
fimpara;

para i=1 ate 50 faca
v3 = v1[i] + v2[i];
escreva(v3[i]);
fimpara;
84
fim.


b) programa em Java

import java.io.*;
class SomaVet{
public static void main(String args[]){
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));
int v1[] = new int[50];
int v2[] = new int[50];
int v3[] = new int[50];
int i;
try{
//leitura do vetor v1
System.out.println("Entre com os valores para o vetor A:");
for(i=0;i<=49;i++){
v1[i] = Integer.parseInt(entrada.readLine());

}
//leitura do vetor v2
System.out.println("Entre com os valores para o vetor B:");
for(i=0;i<=49;i++){
v2[i] = Integer.parseInt(entrada.readLine());
}
//calculo da soma de v1 com v2
System.out.println("Vetor resultante da soma de v1 com v2:");
for(i=0;i<=49;i++){
v3[i] = v1[i]+v2[i];
System.out.println(" "+v3[i]);
}
}catch(Exception e){
System.out.println("Houve erro na entrada de dados!!!");
}
}
}

2) Construa um algoritmo que preenha um vetor de 100 elementos inteiros, colocando 1 na posição
correspondente a um número par e 0 a um número ímpar.

Solução:

a) algoritmo em pseudocódigo

inicio
a:vetor[1..100] de inteiros;
i:inteiro;
para i=1 ate 100 faca
se (i mod 2 == 0) então
a[i] = 1;
senao
a[i] = 0;
fimse;
fimpara;

para i=1 ate 100 faca
escreva(a[i]);
fimpara;
fim.

b) programa em Java

class PreencheVet{
public static void main(String args[]){
85
int a[] = new int[10];
int i;
for(i =0;i<=9;i++){
if((i % 2) == 0)
a[i] = 1;
else
a[i] = 0;
}
for(i =0;i<=9;i++)
System.out.print(" "+a[i]);
System.out.println();
}
}

3) Desenvolva um algoritmo que efetue a leitura de cinco elementos para um vetor A. No final,
apresentar a soma de todos os elementos que sejam ímpares.

Solução:

a) algoritmo em pseudocódigo

inicio
soma,i:inteiro;
a:vetor[1..5] de inteiros;

soma=0;
para i=1 ate 5 faca
leia(a[i]);
fimpara;
para i=1 ate 5 faca
se ((a[i] mod 2) != 0) entao
soma = soma + a[i];
fimse;
fimpara;
escreva('A soma e: ', soma);
fim.

b) programa em Java

import java.io.*;
class SomaImpar{
public static void main(String args[]){
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));
int soma=0,i;
int a[] = new int[5];
try{
System.out.println("Entre com os valores do vetor A:");
for(i=0;i<=4;i++)
a[i] = Integer.parseInt(entrada.readLine());
for(i=0;i<=4;i++){
if((a[i] % 2) != 0)
soma += a[i];
}
System.out.println("A soma dos elementos impares e: "+soma);
}catch(Exception e){
System.out.println("Houve algum erro na entrada");
}
}
}


4) Faça um algoritmo para calcular a média das temperaturas verificadas durante a semana a partir
das médias diárias já obtidas.

86
Solução:

a) algoritmo em pseudocódigo

inicio
temp:vetor[1..7] de reais;
soma,media:real;
i:inteiro;
temp[1] = 19.0;
temp[2] = 23.0;
temp[3] = 21.0;
temp[4] = 25.0;
temp[5] = 22.0;
temp[6] = 20.0;
temp[7] = 24.0;
soma = 0;
para i=1 ate 7 faca
soma = soma + temp[i];
fimpara;
media = soma/7;
escreva('A media de temperaturas da semana e:', media);
fim.


b) programa em Java

class MediaTemp{
public static void main(String args[]){
float soma=0,media;
int i;
float temp[] = new float[7];
temp[0] = 19;
temp[1] = 23;
temp[2] = 21;
temp[3] = 25;
temp[4] = 22;
temp[5] = 20;
temp[6] = 24;
for(i=0;i<=6;i++)
soma += temp[i];
media = soma/7;
System.out.println("A media das temperaturas e: "+media);
}
}

5) Faça um algoritmo para efetuar a ordenação dos elementos considerados no exemplo anterior,
exibindo o maior e o menor deles.

Solução

a) algoritmo em pseudocódigo

inicio
temp:vetor[1..7] de reais;
i,j:inteiro;
temp[1] = 19.0;
temp[2] = 23.0;
temp[3] = 21.0;
temp[4] = 25.0;
temp[5] = 22.0;
temp[6] = 20.0;
temp[7] = 24.0;
para i=1 ate 6 faca
87
para j = i+1 ate 7 faca
se(temp[j] < temp[i]) entao
min = j;
x = temp[min];
temp[min] = temp[i];
temp[i] = x;
fimse;
fimpara;
fimpara;
escreva('O menor valor e:', temp[1]);
escreva('O maior valor e:', temp[7]);
fim.



b) programa em Java

class OrdenaVet{
public static void main(String args[]){
final int diasemana = 7;
int i,j,min;
float aux;
float temp[] = new float[diasemana];
temp[0] = 19;
temp[1] = 23;
temp[2] = 21;
temp[3] = 25;
temp[4] = 22;
temp[5] = 20;
temp[6] = 24;
for(i=0;i< diasemana -1;i++){
min = i;
for(j=i+1;i<diasemana;i++){
if(temp[j] < temp[min]){
min = j;
aux = temp[min];
temp[min] = temp[i];
temp[i] = aux;
}
}
}
System.out.println();
System.out.println("A temperatura minima da semana e: "+temp[0]);
System.out.println("A temperatura maxima da semana e: "+temp[6]);
}
}

6) Fazer um programa que leia uma variável de 100 elementos numéricos e verificar se existem
elementos iguais a 30. Se existirem, escrever as posições em que estão armazenadas.

Solução:

a) algoritmo em pseudocódigo

inicio
numero:vetor[1..100] de inteiros;
i:inteiro;
para i= 1 ate 100 faca
leia(numeros[i]);
fimpara;
para i=1 ate 100 faca
se(numeros[i] == 30) entao
escreva(i);
fimse;
fimpara;
88
fim.

b) programa em Java

import java.io.*;
class Pesquisa{
public static void main(String args[]){
int numeros[] = new int[100];
int i;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
System.out.println("Entre com os valores: ");
for(i=0;i<=99;i++)
numeros[i] = Integer.parseInt(entrada.readLine());
for(i=0;i<=99;i++){
if(numeros[i] == 30)
System.out.println("A posicao do elemento no vetor
e:"+(i+1));
}
}catch(Exception e){
System.out.println("Houve algum erro na entrada de dados");
}
}
}

7) A coordenação de Tecnologia em Desenvolvimento de Software do ICESAM deseja saber se
existem alunos cursando, simultaneamente, as disciplinas “Lógica de Programação” e
“Organização de Computadores”. Existem disponíveis em uma unidade de entrada os números de
matrícula dos alunos de “Lógica de Programação”(no máximo 150) e de “Organização de
Computadores”(no máximo 220 alunos). Cada conjunto dos números de matrícula dos alunos de
uma disciplina tem a matrícula fictícia 9999 no final. Fazer um programa que imprima o número de
matrícula dos alunos que estão cursando estas disciplinas simultaneamente.

LP
... 9999
1 2 J 4 5 6 7 150

OC
... 9999
1 2 J 4 5 6 7 220

Solução:

a) algoritmo em pseudocódigo

inicio
LP:vetor[1..151] de inteiros;
OC:vetor[1..221] de inteiros;
i,j:inteiro;

//leitura da matricula dos alunos que estao cursando LP
i=1;
leia(LP[i]);
enquanto (LP[i] != 9999) faca
i = i + 1;
leia(LP[i]);
fimenquanto;

//leitura da matricula dos alunos que estao cursando OC
89
i=1;
leia(OC[i]);
enquanto (OC[i] != 9999) faca
i = i + 1;
leia(OC[i]);
fimenquanto;

//verificacao da matricula simultanea em LP e OC
i=1;
enquanto (LP[i] != 9999) faca
j = i;
enquanto ((OC[j] != 9999) e (LP[i] != OC[j])) faca
j = j + 1;
fimenquanto;
se (LP[i] = OC[j]) entao
escreva(LP[i]);
fimse;
i = i + 1;
fimenquanto;
fim.

b) programa em Java

import java.io.*;
class VerifMatric{
public static void main(String args[]){
int LP[] = new int[151];
int OC[] = new int[221];
int i,j;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
//leitura da matricula dos alunos que estao cursando LP
System.out.println("Entre com os numeros de matricula em LP:");
i=1;
LP[i] = Integer.parseInt(entrada.readLine());
while(LP[i] != 9999){
i++;
LP[i] = Integer.parseInt(entrada.readLine());
}

//leitura da matricula dos alunos que estao cursando OC
System.out.println("Entre com os numeros de matricula em OC:");
i=1;
OC[i] = Integer.parseInt(entrada.readLine());
while(OC[i] != 9999){
i++;
OC[i] = Integer.parseInt(entrada.readLine());
}

//verificacao da matricula simultanea em LP e OC
System.out.println("Alunos matriculados em LP e OC
simultaneamente:");
i=1;
while(LP[i] != 9999){
j = 1;
while((OC[j] != 9999) && (LP[i] != OC[j]))
j++;
if(LP[i] == OC[j])
System.out.println(LP[i]);
i++;
}
}catch(Exception e){
System.out.println("Houve erro na entrada de dados!!");
}
90

}
}

8) Escrever um programa que faça reserva de passagens aéreas de uma companhia. Além da leitura
do número dos vôos e quantidade de lugares disponíveis, ler vários pedidos de reserva,
constituídos do número da carteira de identidade do cliente e do número do vôo desejado. Para
cada cliente, verificar se há disponibilidade no vôo desejado. Em caso afirmativo, imprimir o
número da identidade do cliente, e o número do vôo, atualizando o número de lugares disponíveis.
Caso contrário, avisar ao cliente da inexistência de lugares. Indicando o fim dos pedidos de
reserva, existe um passageiro cujo número da carteira de identidade é 9999. Considerar fixo e
igual a 37 o número de vôos da companhia.
Estruturas de dados necessárias:

1
727 15

2
442 16 Cliente NVoo
3
331 0

.
. .

.
. .

.
. .

35
447
1
90

36
221 16

37
291 15

Solução:

a) algoritmo em pseudocódigo

inicio
Voos,LDisp:vetor[1..37] de inteiros;
cliente, Nvoo, apont, i:inteiro;

para i = 1 ate 37 faca
leia(Voos[i],LDisp[i]);
fimpara;
leia(cliente,Nvoo);

//verificação da existencia do voo
enquanto(cliente != 9999) faca
i = 1;
enquanto ((i<=37) e (Nvoo != Voos[i])) faca
i = i+1;
fimenquanto;
se (Nvoo ==Voos[i]) entao
apont =i;
senao
escreva('Cliente: ', cliente, 'Voo ',Nvoo, ' inexistente');
apont = 0;
fimse;
se (apont != 0) entao
se (LDisp[apont] > 0) entao
escreva('Cliente: ',cliente, ' numero do voo: ',Nvoo);
Ldisp[apont] = Ldisp[apont] – 1;
else
91
escreva('Cliente: ',cliente, ' numero do voo: ',Nvoo, ' lotado');
fimse;
fimse;
leia(cliente,Nvoo);
fimenquanto;
fim.

b) programa em Java

import java.io.*;
class ReservaVoo{
public static void main(String args[]){
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));
int Voos[] = new int[37] ,LDisp[] = new int[37];
int cliente,NVoo, apont, i;
try{
for(i=0;i<=36;i++){
System.out.println("Entre com o voo e a quantidade de
lugares disponiveis neste voo:");
Voos[i] = Integer.parseInt(entrada.readLine());
LDisp[i] = Integer.parseInt(entrada.readLine());
}
cliente = Integer.parseInt(entrada.readLine());
NVoo = Integer.parseInt(entrada.readLine());

//verificação da existencia do voo
while((i <= 37)&&(NVoo != Voos[i])){
i=1;
if(NVoo == Voos[i]){
apont = i;
}else{
System.out.println("O cliente: "+cliente+ " voo
"+NVoo+" inexistente");
apont = 0;
}
//verificação da existencia de lugar
if (apont != 0){
System.out.println("O cliente: "+cliente+ " numero
do voo "+NVoo);
LDisp[apont] --;
}else
System.out.println("O cliente: "+cliente+ " numero
do voo "+NVoo+ " lotado");
System.out.println("Entre com o voo e a quantidade de
lugares disponiveis neste voo:");
cliente = Integer.parseInt(entrada.readLine());
NVoo = Integer.parseInt(entrada.readLine());

}
}catch(Exception e){
System.out.println("Houve algum erro na entrada de dados");
}
}
}

9) Escrever um programa para corrigir provas de múltipla escolha. Cada prova tem 10 questões,
cada questão valendo um ponto. O primeiro conjunto de dados a ser lido será o gabarito para a
correção da prova. Os outros dados são os números dos alunos e suas respectivas respostas e o
último número, do aluno fictício, será 9999.
O programa deverá calcular e imprimir:
a) para cada aluno, o seu número e sua nota.
b) A porcentagem de aprovação, sabendo-se que a nota mínima de aprovação é 6.
c) A nota que teve maior freqüência absoluta, ou seja, a nota que aparece maior número de vezes
(supondo a inexistência de empates).

92
Estrutura de dados principal:

Gabarito número nota


Respostas Aprovados Total


Freqüências Maior Porcentagem



Solução:

a) algoritmo em pseudocódigo

inicio
gabarito,resposta:vetor[1..10] de caracter;
frequencia:vetor[0..10] de inteiros;
i, aprovados,maior, nota,notamaio,numero,total:inteiro;
porcent:real;

//atribuição dos valores iniciais necessários
total = 0;
para i=0 ate 10 faca
frequencia[i] = 0;
fimpara;
escreva('Entre com o gabarito da prova');
para i=1 ate 10 faca
leia(gabarito[i]);
fimpara;
leia(numero);
enquanto(numero != 9999) faca
para i=1 ate 10 faca
leia(resposta[i]);
fimpara;
//correcao da prova
nota = 0;
para i=1 ate 10 faca
se (gabarito[i] == resposta[i]) entao
nota = nota + 1;
fimse;
fimpara;
escreva('Numero ', numero, ' - nota: ', nota);
total = total +1;
//determinação da frequencia das notas
frequencia[nota] = frequencia[nota] + 1;
leia(numero);
fimenquanto;

//determinação da porcentagem de aprovaçao
aprovados = 0;
para i= 6 ate 10 faca
aprovados = aprovados + frequencia[i];
fimpara;
porcent = aprovados/total*100;
//deteminacao da nota de maior frequencia
maior =0;
para i= 0 ate 10 faca
se (frequencia[i] > maior) entao
maior = frequencia[i];
93
notamaior = i;
fimse;
fimpara;
escreva(' ',' porcentagem de alunos aprovados: ',porcent);
escreva(' ',' Nota de maior frequencia: ',notamaior);
fim.


b) programa em Java

import java.io.*;
class CorrecaoProva{
public static void main(String args[]){
String gabarito[] = new String[10], respostas[]= new String[10];
int frequencia[] = new int[11];
int i,aprovados=0, maior=0, nota=0, notamaior=0,numero, total=0;
double porcent;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
for(i=0; i<=10;i++)
frequencia[i] = 0;
System.out.println("Entre com o gabarito da prova:");
for(i=0;i<=9;i++)
gabarito[i] = entrada.readLine();
System.out.println("Entre com o numero do aluno:");
numero = Integer.parseInt(entrada.readLine());
while (numero != 9999){
for(i=0;i<=9;i++)
respostas[i] = entrada.readLine();
//correcao da prova
for (i=0;i<=9;i++)
if(gabarito[i] == respostas[i])
nota ++;
System.out.println("Numero "+numero+ " - Nota: "+nota );
total++;
//determinação da frequencia das notas
frequencia[nota] ++;
System.out.println("Entre com o numero do aluno:");
numero = Integer.parseInt(entrada.readLine());
}
for (i=7;i<=9;i++)
aprovados += frequencia[i];
porcent = aprovados/total*100;
//Determinacao da nota de maior frequencia
for(i=0;i<=10;i++)
if (frequencia[i] > maior){
maior = frequencia[i];
notamaior = i;
}
System.out.println(" "+"Porcentagem de alunos aprovados:
"+porcent);
System.out.println(" "+"Nota de maior frequencia: "+notamaior);
}catch(Exception e){
System.out.println("Houve algum erro na entrada!!");
}
}
}


10) Estão disponíveis num
equipamento de entrada de dados informações sobre o estoque de mercadorias de uma loja. São
dados os códigos das mercadorias e as respectivas quantidades existentes. A seguir, estão os
pedidos dos clientes. Escrever um programa para a atualização do estoque, tal que:
94
a) seja lido e listado o
estoque inicial (máximo de 100 mercadorias).
b) Sejam lidos
os pedidos dos clientes, constituídos, cada um, do número do cliente, código da
mercadoria e quantidade desejada;
c) Seja
verificado, para cada pedido, se ele pode ser integralmente atendido. Em caso negativo,
imprimir o número do cliente e a mensagem “Estoque insuficiente”.
d) Seja
atualizado o estoque após cada operação;
e) Seja listado
o estoque final.

Observação: considerar que, separando os dados do estoque inicial dos de pedidos, existe
um dado código de mercadoria é 9999 e. encerrando os pedidos, há um cliente fictício, cujo
número é 9999.

Solução:

a) algoritmo em pseudocódigo

inicio
Estoque,codigo:vetor[1..101] de inteiros;
cliente,i,mercadoria,n,quantidade:inteiro;
i = 1;
//leitura e escrita do estoque incial
leia(codigo[i],Estoque[i]);
enquanto (codigo[i] != 9999) faca
escreva(codigo[i],estoque[i]);
i = i+1;
leia(codigo[i],Estoque[i]);
fimenquanto;
n = i – 1;
leia(cliente,mercadoria,quantidade);
enquanto (cliente != 9999) faca
//verificacao da existencia da mercadoria
i = 1;
enquanto ((i!= n) e (mercadoria != codigo[i]) faca
i = i+1;
fimenquanto;
se (mercadoria = codigo[i]) entao
se (Estoque[i] >= quantidade) entao
Estoque[i] = Estoque[i] – quantidade;
senao
escreva('cliente: ',cliente, ' - mercadoria: ',mercadoria, ' - não temos a
mercadoria em estoque suficiente');
fimse;
senao
escreva('cliente: ',cliente, ' - mercadoria: ',mercadoria, ' - não existe a
mercadoria pedida');
fimse;
leia(cliente,mercadoria,quantidade);
fimenquanto;
//escrita do estoque final
enquanto(codigo[i] != 9999) faca
escreva(codigo[i], Estoque[i]);
i = i+1;
fimenquanto;
fim.


b) programa em Java
95

import java.io.*;
class Controle_Estoque{
public static void main(String args[]){
int Estoque[] = new int[101], codigo[] = new int[101];
int i, cliente, n, mercadoria, quantidade;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));
try{
i=1;
//leitura e escrita do estoque inicial
System.out.println("Entre com o codigo e a quantidade em
estoque:");
codigo[i] = Integer.parseInt(entrada.readLine());
Estoque[i] = Integer.parseInt(entrada.readLine());
while (codigo[i] != 9999){
System.out.println("Codigo\tEstoque");
System.out.println(codigo[i]+"\t"+Estoque[i]);
i++;
System.out.println("Entre com o codigo e a quantidade em
estoque:");
codigo[i] = Integer.parseInt(entrada.readLine());
Estoque[i] = Integer.parseInt(entrada.readLine());
}
n=i-1;
System.out.println("Entre com o codigo do cliente, o codigo da
mercadoria e a quantidade:");
cliente = Integer.parseInt(entrada.readLine());
mercadoria = Integer.parseInt(entrada.readLine());
quantidade = Integer.parseInt(entrada.readLine());
while (cliente != 9999){
//verificacao da existencia da mercadoria
i = 1;
while((i != n)&&(mercadoria != codigo[i]))
i++;
if (mercadoria == codigo[i]){
if (Estoque[i] >= quantidade)
Estoque[i] -= quantidade;
else
System.out.println("'Cliente: "+cliente + "
- mercadoria: "+mercadoria+ " - nao temos a mercadoria em estoque suficiente");
}else{
System.out.println("'Cliente: "+cliente + " -
mercadoria: "+mercadoria+ " - nao temos a mercadoria pedida");
}
System.out.println("Entre com o codigo do cliente, o
codigo da mercadoria e a quantidade:");
cliente = Integer.parseInt(entrada.readLine());
mercadoria = Integer.parseInt(entrada.readLine());
quantidade = Integer.parseInt(entrada.readLine());

}
//escrita do estoque final
i = 1;
while(codigo[i] != 9999){
System.out.println("Codigo\tEstoque");
System.out.println(codigo[i]+"\t"+Estoque[i]);
i++;
}
}catch(Exception e){
System.out.println("Houve algum erro na entrada");
}
}
}


11) Este exemplo demonstra a utilização de um array para armazenar um conjunto de
argumentos do tipo inteiro, passado pelo usuário na linha de execução.
96

Solução:
class Exemplo11Vetor{
public static void main(String args[]){
int i, total=0;
int N[] = new int[10]; //declara um array N de 10 elementos do tipo
int
if(args.length > 0){
try{
for(i=0;i<args.length;i++){
//armazena cada um dos elementos no array
N[i] = Integer.parseInt(args[i]);
total = total + N[i]; //acumula o somatorio
dos elementos
}
System.out.println("Os numeros digitados na ordem inversa
foram:");
for(i = args.length-1;i>=0;i--)
System.out.println(N[i] + " ");
System.out.println();
System.out.println("O somatorio dos numeros, "+ total);
System.out.println("A media entre eles , "+
(total/args.length));
}catch(NumberFormatException e){
System.out.println("Os argumentos devem ser numerso do
tipo inteiro");
}
}
else
System.out.println("Digite pelo menos um numero!");
}
}


12) Este exemplo demonstra a criação e inicialização simultanea de um array

Solução:

class Exemplo12Vetor{
public static void main(String args[]){
String nomes = "";
char CaracterArray[] = {'a','b','c','d','e','f','g'}; //array de
caracteres
System.out.println("Mostrando o array: "+
String.valueOf(CaracterArray));
System.out.println("Quant. de elementos: "+ CaracterArray.length);
System.out.println("1 e 3 caracteres " +
String.valueOf(CaracterArray,0,3));
System.out.println();
//criando um array de Strings
String StringArray[] = {"Aprendendo","a","Linguagem","Java"};
for(int i=0;i <StringArray.length;i++) //armazena os nomes do array
nomes = nomes + StringArray[i] + " ";
System.out.println("Mostrando o array: "+nomes);
System.out.println("Quant. de elementos do array:
"+StringArray.length);
System.out.println("Mostrando o 1 elemento do array:
"+StringArray[0]);
System.out.println("Monstrando o ultimo elemento do array:
"+StringArray[StringArray.length -1]);
}
}





97
Variáveis compostas multidimensionais {matrizes)

As variáveis composta multidimensionais, como o próprio nome diz, permitem a criação de
vetores com mais de um índice. A essas estruturas indexadas damos o nome de matrizes. Em
particular, daremos ênfase as de duas dimensões.

Declaração

<identificador>: matriz [li1..lf1,li2..lf2] de tipo;
Em que:
Li1 representa o limite inicial da primeira dimensão da matriz;
Lf1 representa o limite final da primeira dimensão da matriz;
Li2 representa o limite inicial da segunda dimensão da matriz;
Lf2 representa o limite final da segunda dimensão da matriz;
Identificador é o nome dado a matriz.
tipo representa qualquer tipo básico ou tipo anteriormente definido.

Exemplo:
Um vetor de 10 posições de reais poderia ter a seguinte definição e declaração:

msala: matriz[0..3,0..3] de real;

Manipulação

Para acessar um elemento em uma estrutura composta multidimensional – matriz –
precisamos da linha e da coluna onde está armazenado o elemento.

0 1 2 J
0
1
2
J



Para utilizar o vetor, nós o inserimos em um único laço de repetição, fazendo com que haja
variação em seu índice. Como em uma estrutura multidimensional possuímos mais de um índice, faz-
se necessária a utilização de mais laços de repetição, em mesmo número do que o número de
dimensões da matriz.

Para percorre uma matriz podemos utilizar duas técnicas que poderão ser utilizadas de
acordo com a necessidade da solução, são elas:
1) fixar a linha e variar a coluna
2) fixar a coluna e varia a linha


Exemplos:

1) Construa um algoritmo que efetue a leitura, a soma e a impressão do resultado entre duas
matrizes inteiras que comportem 25 elementos.

Solução:

a) algoritmo em pseudocódigo

inicio
ma = matriz[1..5,1..5] de inteiros;
mb = matriz[1..5,1..5] de inteiros;
mr = matriz[1..5,1..5] de inteiros;
i,j:inteiro;
i = 1;
Índices de coluna
Índices de linhas
msala[1,2]
98
enquanto (i <= 5) faca
j = 1;
enquanto (j <= 5) faca
leia(ma[i,j],mb[i,j]);
mr[i,j] = ma[i,j] = mb[i,j];
j = j + 1;
fimenquanto;
i = i+1;
fimenquanto;
j = 1;
enquanto (j <= 5) faca
i = 1;
enquanto (i <= 5) faca
escreva(mr[i,j]);
i = i + 1;
fimenquanto;
j = j+1;
fimenquanto;
fim.

b) programa em Java

import java.io.*;
class ExemploMat1{
public static void main(String args[]){
int ma[][] = new int [5][5];
int mb[][] = new int [5][5];
int mr[][] = new int [5][5];
int i,j;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));
try{
//preenchimento da matriz A
System.out.println("Entre com os valores para a matriz A:");
i=0;
while (i < 5){
j=0;
while (j <5){
ma[i][j] = Integer.parseInt(entrada.readLine());

j++;
}
i++;
}
//preenchimento da matriz B
System.out.println("Entre com os valores para a matriz B:");
i=0;
while (i < 5){
j=0;
while (j <5){
mb[i][j] = Integer.parseInt(entrada.readLine());

j++;
}
i++;
}
//matriz resultante da soma de ma com mb
System.out.println("Matriz soma mr:");
j=0;
while (j < 5){
i=0;
while (i <5){
mr[i][j] = ma[i][j] + mb [i][j];
System.out.print(" "+mr[i][j]);
i++;
}
99
System.out.println();
j
++;
}
}catch(Exception e){
System.out.println("Ocorreu algum erro na entrada de dados");
}

}
}


2) Elabore um algoritmo que leia duas matrizes A e B di tipo (3x3) e calcule em uma matriz R sua
multiplicação, ou seja R = A * B.

Solução:

a) algoritmo em pseudocódigo

inicio
ma,mb,mr:matriz[1..3,1..3] de inteiros;
i,j,k:inteiro;

//entrada de dados – matriz A
para i = 1 ate 3 faca
para j = 1 ate 3 faca
leia(ma[i,j]);
fimpara;
fimpara;

//entrada de dados – matriz B
para i = 1 ate 3 faca
para j = 1 ate 3 faca
leia(mb[i,j]);
fimpara;
fimpara;

//multiplicação de A por B
para i = 1 ate 3 faca
para j = 1 ate 3 faca
mr[i,j] = 0;
para k = 1 ate 3 faca
mr[i,j] = mr[i,j] + ma[i,k] * mb[k,j];
fimpara;
fimpara;
fimpara;

//saída de dados – matriz R
para i = 1 ate 3 faca
para j = 1 ate 3 faca
escreva(mr[i,j]);
fimpara;
fimpara;
fim.

b) programa em Java

import java.io.*;
class ExemploMat2{
public static void main(String args[]){
int ma[][] = new int [3][3];
int mb[][] = new int [3][3];
int mr[][] = new int [3][3];
int i,j,k;
100
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader (System.in));

try{
//entrada de dados - matriz A
System.out.println("MATRIZ A:");
for(i =0;i<3;i++){
for(j=0;j<3;j++){
System.out.println("Entre com o valor A["+i+",
"+j+"]");
ma[i][j] = Integer.parseInt(entrada.readLine());
}
}
//entrada de dados - matriz B
System.out.println("MATRIZ B:");
for(i =0;i<3;i++){
for(j=0;j<3;j++){
System.out.println("Entre com o valor B["+i+",
"+j+"]");
mb[i][j] = Integer.parseInt(entrada.readLine());
}
}
//Multiplicacao de A por B
System.out.println("A matriz produto R e: ");
for(i =0;i<3;i++){
for(j=0;j<3;j++){
mr[i][j] = 0;
for(k=0;k<3;k++){
mr[i][j] += ma[i][k] * mb[k][j];

}
System.out.print(" "+mr[i][j]);
}
System.out.println();
}
}catch(Exception e){
System.out.println("Ocorreu algum erro na entrada de dados");
}
}
}


3) Dada uma matriz de 6 linhas e 2 colunas de inteiros, calcular e exibir a média geométrica dos
valores de cada uma das linhas. A média geométrica é calculada pela seguinte expressão: sqrt(x1 *
x2), representa a raiz quadrada do resultado da multiplicação dos elementos da coluna 1 (x1) pelos
elementos da coluna 2 (x2).

Solução:

a) algoritmo em pseudocódigo

inicio
g:matriz[1..6,1..2] de inteiros;
i,j:inteiro;
prod:real;

para i = 1 ate 6 faca
prod = 1;
para j = 1 ate 2 faca
leia(g[i,j]);
prod = prod * g[i,j];
fimpara;
escreva(‘linha ‘, i, ‘ = ‘, sqrt(prod));
fimpara;
fim.

101

b) programa em Java

import java.io.*;
class ExemploMat3{
public static void main(String args[]){
int g[][] = new int [6][2];
int i,j;
double prod;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));
try{

for (i=0;i<6;i++){
prod = 1;
for(j=0;j<2;j++){
System.out.println("Entre com os valores de
G["+i+", "+j+"]");
g[i][j] = Integer.parseInt(entrada.readLine());

prod *= g[i][j];
}
System.out.println("Linha - " + 1 + ":
"+Math.sqrt(prod));
}

}catch(Exception e){
System.out.println("Ocorreu algum erro na entrada de dados");
}

}
}


4) Média dos alunos de uma disciplina. Considere uma matriz de 30 linhas e 3 colunas. Cada linha
está associada a um aluno de uma determinada disciplina, e as colunas estão associadas às notas
das três provas referentes àquele estudante. O procedimento abaixo descreve a média de cada
estudante e a média da turma em cada prova.

Solução:

a) algoritmo em pseudocódigo

inicio
const
nProvas = 3;
nAlunos = 30;
NotaProva : matriz{1..nAlunos,1..nProvas] de reais;
MedAlunos:vetor[1..nAlunos] de reais;
MedProvas: vetor[1..nProvas] de reais;
I,j:inteiro;
Soma : real;
Para i = 1 ate nAlunos faca
Soma = 0;
Para j = 1 ate nProvas faca
Soma = soma + NotaProva[i,j];
MedAlunos[i] = soma/nProvas;
fimpara;
fimpara;

Para j = 1 ate nProvas faca
Soma = 0;
Para i = 1 ate nProvas faca
Soma = soma + NotaProva[i,j];
MedProvas[j] = soma/nAlunos;
102
fimpara;
fimpara;

para i = 1 ate nAlunos faca
escreva(MedAlunos[i]);
fimpara;
para i = 1 ate nProvas faca
escreva(MedProvas[i]);
fimpara;

fim.

b) programa em Java

import java.io.*;
class ExemploMat4{
public static void main(String args[]){
final int nprovas = 3;
final int nalunos = 30;
float NotaProva[][] = new float [nalunos][nprovas];
float MedAlunos[] = new float [nalunos];
float MedProvas[] = new float [nprovas];
float soma;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
for (int i = 0; i< nalunos;i++){
soma = 0;
for (int j =0;j <nprovas;j++){
System.out.println("Entre com a nota do
aluno["+i+"],nota ["+j+"]");
NotaProva[i][j] =
Float.parseFloat(entrada.readLine());
soma += NotaProva[i][j];
MedAlunos[i] = soma/nprovas;
}
}
for (int j = 0; j< nprovas;j++){
soma = 0;
for (int i =0;i <nalunos;i++){
soma += NotaProva[i][j];
MedProvas[j] = soma/nalunos;
}
}
for (int i = 0; i< nalunos;i++){
System.out.println("A media do aluno ["+i+"] =
"+MedAlunos[i]);
}
for (int i =0;i <nprovas;i++){
System.out.println("Media da prova ["+i+"] =
"+MedProvas[i]);
}

}catch(Exception e){
System.out.println("Ocorreu algum erro na entrada de dados!!!");
}
}
}



5) Escrever um programa que leia uma matriz 4x4, multiplique os elementos da diagonal principal por
uma constante k, também lida, e escreva a matriz resultante.

Solução:
103
a) algoritmo em pseudocódigo

inicio
A:matriz[1..4,1..4] de inteiros;
I,j,k:inteiro;

//leitura da matriz A e da constante k
para i =1 ate 4 faca
para j = 1 ate 4 faca
leia(A[i,j]);
fimpara;
fimpara;
leia(k);
//calculo do produto de K pela diagonal principal de A
para i = 1 ate 4 faca
a[i,i] = a[i,i] * k;
fimpara;
//saída de dados
para i =1 ate 4 faca
para j = 1 ate 4 faca
escreva(A[i,j]);
fimpara;
fimpara;
fim.

b) programa em Java

import java.io.*;
class ExemploMat5{
public static void main(String args[]){
int A[][] = new int[4][4];
int i,j,k;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
System.out.println("Entre com os valores da matriz A:");
for(i =0;i<4;i++){
for(j =0;j<4;j++){
System.out.println("Entre com o elemento
A["+i+","+j+"]");
A[i][j] = Integer.parseInt(entrada.readLine());
}
}
System.out.println("Entre com o valor de k:");
k = Integer.parseInt(entrada.readLine());
for(i=0;i<4;i++)
A[i][i] = A[i][i] * k;
System.out.println("A nova matriz A e: ");
for(i =0;i<4;i++){
for(j =0;j<4;j++){
System.out.print(" "+A[i][j]);

}
System.out.println();
}
}catch(Exception e){
System.out.println("Ocorreu algum erro na saida!!");
}
}
}

6) Dada uma tabela de 4x5 elementos, calcular a soma de cada linha e a soma de todos os
elementos.

Solução:

a) algoritmo em pseudocódigo
104

inicio
Mat:matriz[1..4,1..5] de inteiros;
I,j,total,somalinha:inteiro;

Total = 0;
//leitura da matriz Ma
para i =1 ate 4 faca
para j = 1 ate 5 faca
leia(Ma[i,j]);
fimpara;
fimpara;
//soma dos elementos da linha
para i =1 ate 4 faca
somalinha = 0;
para j = 1 ate 5 faca
somalinha = somalinha +Mat[i,j];
fimpara;
escreva(‘LINHA ‘, i, ‘ : ‘,somalinha);
total = total + somalinha;
fimpara;
//saída de dados
escreva(‘Total: ‘, total);
fim.

b) programa em Java

import java.io.*;
class ExemploMat6{
public static void main(String args[]){
int Mat[][] = new int[4][5];
int i,j,total=0,somalinha;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
System.out.println("Entre com os valores da matriz Mat:");
for(i =0;i<4;i++){
for(j =0;j<5;j++){
System.out.println("Entre com o elemento
Mat["+i+","+j+"]");
Mat[i][j] = Integer.parseInt(entrada.readLine());
}
}
for(i =0;i<4;i++){
somalinha = 0;
for(j =0;j<5;j++){
somalinha += Mat[i][j];

}
System.out.println("Linha "+i+": "+somalinha);
total +=somalinha;
}
System.out.println("O total da somatoria das linha e: "+total);
}catch(Exception e){
System.out.println("Ocorreu algum erro na saida!!");
}
}
}






105
7) Uma certa fábrica produziu dois tipos de motores M1 e M2 nos meses de janeiro a Dezembro, e o
número de motores foi registrado na tabela a seguir:

M1 M2
Jan 30 20
Fev 5 10
Mar 7 15
.
.
.
.
.
.
.
.
.
Dez 18 25


O setor de controle de vendas tem uma tabela do custo e do lucro (em mil reais) obtidos com cada
motor:
Custo Lucro
M1 10 3
M2 15 2

Fazer um algoritmo que, a partir da produção mensal de motores M1 e M2 e seus respectivos custos
e lucros, calcule o custo e o lucro em cada um dos meses e o custo e o lucros anuais.
Solução:

a) algoritmo em pseudocódigo

inicio
Producao,CLM:matriz[1..12,1..2] de inteiros; //produção mensal e custo e lucro
mensal
Valores: matriz[1..2,1..2] de inteiros; //custo e lucro de cada motor
CLÃ: vetor[1..2] de inteiros; //custo e lucro anuais dos motores
I,j,k:inteiro;

//leitura da matriz producao
para i =1 ate 12 faca
para j = 1 ate 2 faca
leia(Producao[i,j]);
fimpara;
fimpara;

//inserção do custo e do lucro de cada motor
para i =1 ate 2 faca
para j = 1 ate 2 faca
leia(Valores[i,j]);
fimpara;
fimpara;

//Calculo do custo e do lucro mensais
para i =1 ate 12 faca
para j = 1 ate 2 faca
CLM[i,j] = 0;
para k = 1 ate 2 faca
CLM[i,,j] = CLM[i,j] + Producao[i,k] * Valores[k,j];
fimpara;
fimpara;
fimpara;

//calculo do custo e do lucro anuais
para i =1 ate 2 faca
CLÃ[j] = 0;
para j = 1 ate 12 faca
CLA[j] = CLÃ[j] = CLM [i,j];
fimpara;
106
fimpara;
//saída de dados
para i =1 ate 12 faca
para j = 1 ate 2 faca
escreva(CLM[i,j]);
fimpara;
fimpara;
escreva(‘Custo anual: ‘, CLA[1], ‘ Lucro anual: ‘, CLA[2]);
fim.

b) programa em Java

import java.io.*;
class ExemploMat7{
public static void main(String args[]){
int Producao[][] = new int[12][2];
int CLM[][] = new int[12][2];
int Valores[][] = new int[2][2];
int CLA[] = new int[2];
int i,j,k;
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
System.out.println("Entre com os valores da matriz Producao:");
for(i =0;i<12;i++){
for(j =0;j<2;j++){
System.out.println("Entre com o elemento
Producao["+i+","+j+"]");
Producao[i][j] =
Integer.parseInt(entrada.readLine());
}
}
System.out.println("Entre com o custo e lucro de cada motor:");
for(i =0;i<2;i++){
for(j =0;j<2;j++){
Valores[i][j] =
Integer.parseInt(entrada.readLine());
}
}
for(i =0;i<12;i++){
for(j =0;j<2;j++){
CLM[i][j] = 0;
for(k=0;k<2;k++){
CLM[i][j] += Producao[i][k] * Valores[k][j];
}
}
}
for(j =0;j<2;j++){
CLA[j] = 0;
for(i =0;i<12;i++){
CLA[j] += CLM[i][j];
}
}
System.out.println("Custo e lucro mensais:");
for(i =0;i<12;i++){
for(j =0;j<2;j++){
System.out.print(" "+CLM[i][j]);
}
System.out.println();
}
System.out.println("Custo anual: "+CLA[0]+"\nLucroAnul:
"+CLA[1]);
}catch(Exception e){
System.out.println("Ocorreu algum erro na saida!!");
}
}
107
}

Exercícios de Fixação - vetores e matrizes

1) Crie um aplicativo que leia 10 valores inteiros quaisquer e imprima na tela os que são maiores
que a média dos valores coletados.
2) Crie um aplicativo que colete uma indefinida quantidade de números pela linha de execução e
no final mostre o menor o maior número fornecido.
3) Faça um programa que colete 10 nomes de pessoas e os armazene em array. No final
verifique se uma determinada pessoa foi cadastrada no array, informando o usuário.
4) Uma escola precisa de um programa que controle a média das notas dos alunos de cada
classe e a média das notas de todos os alunos da escola. Sabendo que essa escola possui
três classes com 5 alunos em cada classe, gerando um total de 15 notas, crie um programa
que receba as notas de cada aluno de cada classe w no final apresente a média de cada
classes e a média a escola em geral.
5) Faça um programa que utilize um método para organizar uma quantidade qualquer de
números inteiros fornecidos pelo usuário na linha de execução do programa, sendo que
esses números deverão ser organizados da seguinte forma: primeiro os números pares em
ordem crescente e depois os números ímpares em ordem decrescente.











































108
Modularização

Um problema complexo pode ser simplificado quando dividido em vários subproblemas. Para
acompanhar essa abordagem, serão apresentados conceitos e técnicas que permitem a divisão de
um algoritmo em módulos ou subalgoritmos.

Decomposição

A decomposição de um problema é fator determinante para a redução da complexidade.
Lembremos que complexidade é sinônimo de variedade, ou seja, a quantidade de situações
diferentes que um problema pode apresentar. Assim, quando decompomos um problema em
subproblemas, estamos invariavelmente dividindo também a complexidade e, por conseqüência,
simplificando a resolução. Outra grande vantagem da decomposição é que permite focalizar a
atenção em um problema pequeno de cada vez, o que ao final produzirá uma melhor compreensão
do todo.
É conveniente que adotemos, então, um critério para orientar o processo de decomposição:
Dividir o problema em suas partes principais;
Analisar a divisão obtida para garantir coerência;
Se alguma parte ainda permanecer complexa, decompô-la também;
Analisar o resultado para garantir entendimento e coerência.

Esse processo de decomposição contínuo também é conhecido como Refinamentos
Sucessivos, porque se parte de um problema complexo e abrangente, que é sucessivamente dividido
até resultar em problemas mais simples e específicos.

Procedimentos

Um procedimento também conhecido como sub-rotina, é um conjunto de instruções que
realiza determinada tarefa. Um algoritmo de procedimento é criado da mesma que outro algoritmo
qualquer: deve ser identificado, possui variáveis, operações e até funções.

Pseudocódigo:
procedimento nome_procedimento (lista de parâmetros)
//declaração das variáveis locais ao procedimento
//instruções do procedimento
fimprocedimento;

Java:
<modificadores> <tipo_retorno> <nome_método> (<argumentos>){
<tipo_retorno> <nome_variável> = <valor_inicial>;
<instruções>;
return <nome_variável_retorno>;
}

Onde:
d) <nome_método>: é um identificador válido da linguagem. Obedece às mesmas
regras que os identificadores de classe, objeto e variável.
e) <argumentos>: indica a lista de argumentos que serão passados como parâmetros
para os método. A sintaxe dos argumentos é a de declaração de
variáveis: tipo identificador, e os vários parâmetros são separados por
vírgulas.
f) <tipo_retorno>: indica o tipo do valor retornado pelos métodos. Esse tipo pode ser um
tipo primitivo, uma classe ou void, no caso de não retornar valor
(equivalente a um procedimento).
g) return: palavra reservada que indica o valor que será devolvido para o programa,
sendo associada com a variável que armazena esse valor. No caso de
um método com tipo de retorno void, nada é devolvido, portanto não há
retorno e é desnecessário utilizar return.
h) <modificadores>: são elementos que caracterizam o método quanto ã visibilidade
(escopo) e qualidade. Os métodos, como classes e as variáveis, podem
possuir mais de um modificador, não importando sua ordem.
109

Os modificadores mais utilizados são:
public: pode ser invocado livremente. Indica um método que é visível para qualquer
um que enxergue a classe.
protected: pode ser utilizado apenas no mesmo pacote e em subclasses.
private: pode ser invocado apenas na classe.
final: não pode ser sobrescrito. Equivale à declaração de constante.
static: não necessita de objeto. Pode ser invocado a partir do nome da classe. Por
exemplo: Integer.parseInt(<String>).

Além desses, existem outros modificadores, como por exemplo: abstract, native, transient,
volatile e synchronized.
Se não há modificador, o método pode ser chamado apenas no mesmo pacote.

Chamada de procedimentos

A chamada de um procedimento é o momento em que o procedimento é acionado e seu
código é executado, isto é, a tarefa associada a ele é realizada pelo algoritmo principal.

Algoritmo principal
//declaração de variáveis utilizadas no algoritmo principal
//Declaração do procedimento
Procedimento nome_do_procedimento()
ffdeclaracao das variaveis locais ao procedimento
inicio_do_procedimento
instruçoes do procedimento
fim_do_procedimento
Inicio do algoritmo principal
instruções do algoritmo principal
fim do algoritmo principal

Exemplos:

• Elaborar um algoritmo que realize a operação aritmética escolhida pelo usuário, a saber: adição,
subtração, multiplicação ou divisão, entre dois valores fornecidos por ele. Deverá ser criado um
menu de opções para o usuário.













Solução:

a) algoritmo em pseudocódigo

inicio
opcao:inteiro;

Procedimento ModAdicao();
v1,v2,res:real;
inicio
leia(v1,v2);
res = v1 + v2;
escreva (res);
Módulo
principal
(menu)
Módulo
principal
(menu)
Módulo
principal
(menu)
Módulo
principal
(menu)
Módulo
principal
(menu)
110
fim.

Procedimento ModSubtr();
v1,v2,res:real;
inicio
leia(v1,v2);
res = v1 - v2;
escreva (res);
fim.

Procedimento ModMultip();
v1,v2,res:real;
inicio
leia(v1,v2);
res = v1 * v2;
escreva (res);
fim.

Procedimento ModAdicao();
v1,v2,res:real;
inicio
leia(v1,v2);
res = v1 / v2;
escreva (res);
fim.

//inicio do algoritmo principal
leia(opcao);
escolha (opcao)
caso 1: ModAdicao();
caso 2: ModSubtr();
caso 3: ModMultip();
caso 4: ModDiv();
casocontrario: escreva('sair do programa');
fimescolha;
fim.


b) programa em Java

import java.io.*;
class Menu{
public static void main(String args[]){
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));
try{
System.out.println("1 : Adicao");
System.out.println("2 : Subtracao");
System.out.println("3 : Multiplicacao");
System.out.println("4 : Divisao");
System.out.println("Qual a opcao desejada?");
int opcao = Integer.parseInt(entrada.readLine());
switch (opcao){
case 1 : modAdicao(); break;
case 2 : modSubtr(); break;
case 3 : modMultip(); break;
case 4 : modDiv(); break;
default : System.out.println("Fim do programa");
}
}catch(Exception e){
System.out.println("Ocorreu algum erro na entrada de dados");
}
}
//modulo de adicao
111
static void modAdicao(){
BufferedReader entraSoma;
entraSoma = new BufferedReader(new InputStreamReader(System.in));
try{
System.out.println("Qual e o primeiro numero?");
float num1 = Float.parseFloat(entraSoma.readLine());
System.out.println("Qual e o segundo numero?");
float num2 = Float.parseFloat(entraSoma.readLine());
float resultado = num1 + num2;
System.out.println("Soma = "+resultado);
}catch(Exception e){
System.out.println("Ocorreu algum erro na entrada de dados");
}
}
//modulo de subtracao
static void modSubtr(){
BufferedReader entraSub;
entraSub = new BufferedReader(new InputStreamReader(System.in));
try{
System.out.println("Qual e o primeiro numero?");
float num1 = Float.parseFloat(entraSub.readLine());
System.out.println("Qual e o segundo numero?");
float num2 = Float.parseFloat(entraSub.readLine());
float resultado = num1 - num2;
System.out.println("Soma = "+resultado);
}catch(Exception e){
System.out.println("Ocorreu algum erro na entrada de dados");
}
}
//modulo de Multiplicacao
static void modMultip(){
BufferedReader entraMult;
entraMult = new BufferedReader(new InputStreamReader(System.in));
try{
System.out.println("Qual e o primeiro numero?");
float num1 = Float.parseFloat(entraMult.readLine());
System.out.println("Qual e o segundo numero?");
float num2 = Float.parseFloat(entraMult.readLine());
float resultado = num1 * num2;
System.out.println("Soma = "+resultado);
}catch(Exception e){
System.out.println("Ocorreu algum erro na entrada de dados");
}
}
//modulo de Divisao
static void modDiv(){
BufferedReader entraDiv;
entraDiv = new BufferedReader(new InputStreamReader(System.in));
try{
System.out.println("Qual e o primeiro numero?");
float num1 = Float.parseFloat(entraDiv.readLine());
System.out.println("Qual e o segundo numero?");
float num2 = Float.parseFloat(entraDiv.readLine());
float resultado = num1 / num2;
System.out.println("Soma = "+resultado);
}catch(Exception e){
System.out.println("Ocorreu algum erro na entrada de dados");
}
}
}

Funções

As funções são criadas e chamadas da mesma maneira que os procedimentos. A diferença
entre eles é que as funções podem ser utilizadas em expressões, como se fossem variáveis, pois as
funções retornam valores que são associados ao seu nome e para esses valores se faz necessária a
declaração do tipo de dado a ser retornado.
112

função nome_da_função (lista de parâmetros):tipo_de_dado da função
ffdeclaraçao dos objetos pertencentes a esta funçao (objetos locais)
inicio
instruções da função
fim;


Exemplos:

1) Ler um numero fornecido pelo usuário e calcular o fatorial.

Solução:

a) algoritmo em pseudocódigo

função fatorial(n:inteiro):inteiro;
i,fat:inteiro;
inicio
leia(n);
se (n == 0) então
fatorial = 1;
senão
para i = 1 ate n-1 faca
fat = fat * i;
fimpara;
fatorial = fat;
fimse;
retornar(fatorial);
fim.


b) programa em Java

import java.io.*;
class ExmploFunc1{
public static void main(String args[]){
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

try{
System.out.println("Qual o numero? ");
int num = Integer.parseInt(entrada.readLine());
int fat = fatorial(num);
System.out.println("fatorial = "+fat);
}catch(Exception e){
System.out.println("Ocorreu erro na entrada");
}
}
static int fatorial(int numero){
int fat = 1;
for(int i= 1;i<=numero;i++){
fat *=i;
}
return fat;
}
}

Escopo de variáveis

A utilização de variáveis locais pode ocasionar redundância na declaração de variáveis que
se fazem necessárias em vários módulos. Para resolver este problema, existe a possibilidade de
serem declaradas variáveis globais.
113
As variáveis globais são declaradas no algoritmo principal e podem ser utilizadas por todos os
algoritmos hierarquicamente inferiores. Já as variáveis locais podem ser utilizadas pelo algoritmo em
que foram declaradas e nos algoritmos hierarquicamente inferiores.

Parâmetros

Parâmetros são variáveis ou valores que podem ser transferidos do algoritmo principal para
um módulo que está sendo chamado. Eles funcionam como comunicadores entre módulos. Existem
dois tipos de parâmetros: os formais e os reais.

Parâmetros formais

São declarados nos módulos como as variáveis. O algoritmo que chama a função ou o
procedimento informa os calores que substituirão esses parâmetros.

Exemplo:

a) algoritmo em pseudocódigo

procedimento multiplica*a,b:real)
res:real;
inicio
res = a * b;
escreva(res);
fim;


b) programa em Java

static float multiplicar (float a, float b){
float res;
res = a * b;
return res;
}

Parâmetros reais

Os parâmetros reais são os valores que substituem os parâmetros formais. O algoritmo que
chama a função ou o procedimento informa esses valores ou variáveis.

Exemplo:

a) algoritmo em pseudocódigo

inicio
procedimento multiplica*a,b:real)
res:real;
inicio
res = a * b;
escreva(res);
fim;

num1,num2:real;
leia(num1,num2);
multiplicar(num1,num2);
fim.


b) programa em Java

import Java.io.*;
class Multiplicar{
114
public static void main(String args[]){
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));
try{
System.out.println(“Qual e o numero 1?”);
int num1 = Integer.parseInt(entrada.readLine());
System.out.println(“Qual e o numero 2?”);
int num2 = Integer.parseInt(entrada.readLine());
multiplicar(num1,num2);
} catch(Exception e){
System.out.println(“Ocorreu erro na entrada”);
}
}

static float multiplicar (float a, float b){
float res;
res = a * b;
return res;
}
}

Passagem de parâmetros

A passagem de parâmetros ocorre por meio da correspondência argumento/parâmetro, em
que os argumentos são valores constantes ou variáveis informadas no módulo chamador, ou principal
– isto é, passagem de parâmetros é a substituição dos parâmetros formais pelos parâmetros reais.
Os argumentos devem ser fornecidos na mesma ordem dos parâmetros.
Os parâmetros podem ser passados por valor ou por referência.

Passagem de parâmetros por valor

Na passagem de parâmetros por valor, o valor do parâmetro é real é copiado para parâmetro
formal do módulo, preservando, assim, o valor original do parâmetro.
Nota: Na linguagem Java, os objetos (String, Data, etc) e os arrays são sempre passados por
referência. O Java passa o valor da variável quando o método é chamado e quaisquer alterações
feitas na variável tornam-se permanentes

Passagem de parâmetros por referência

Na passagem de parâmetros por referência, toda alteração feita nos parâmetros formais,
reflete-se nos parâmetros reais: assim, o parâmetro é de entrada e saída.

Exemplos - métodos

EX1) O exemplo abaixo mostra a chamada de um método (imprime) que imprime na tela uma frase
qualquer.

class ExemploMetodo1{
public static void main(String args[]){
imprime();
}
public static void imprime(){ //declaracao do metodo imprime
System.out.println(“Aprendendo a Linguagem Java”);
}
}

EX2) Utiliza-se de um método para imprimir o conteúdo de uma variável qualquer, funcionando da
mesma forma como System.out.println().

class ExemploMetodo2{
public static void main(String args[]){
String frase1 = "Sou muito feliz";
String frase2 = "feliz porque sei";
String frase3 = "que DEUS me ama!";
115
limpaTela(); //invoca o metodo para limpar a tela
tela(frase1); //invoca o metodo para imprimir na tela
tela(""); //invoca o método e imprime uma linha em branco
tela(frase2);
tela("");
tela(frase3);
}
public static void tela(String S){ //declaracao do metodo tela
System.out.println(S);
}
public static void limpaTela(){ //declaracao do metodo limpaTela
for (int i=1;i<=25;i++)
System.out.println();
}
}

EX3) O exemplo abaixo apresenta outra classe com dois métodos que não retornam valores (além do
main) em que os métodos são executados em cascata, uma vez que o método main chamará tela
que, por sua vez, chamará tempo.

class ExemploMetodo3{
public static void main(String args[]){
String frase1 = "Sou muito feliz";
String frase2 = "feliz porque sei";
String frase3 = "que DEUS me ama!";
tela(frase1); //invoca o metodo para imprimir na tela
tela(frase2);
tela(frase3);
}
public static void tela(String S){ //declaracao do metodo tela
System.out.println(S);
tempo(1);
}
public static void tempo(int segundos){ //declaracao do metodo tempo
try{
Thread t;
t = new Thread();
t.start();
t.sleep(segundos*1000);
}catch(InterruptedException e){ }
}
}

EX4) O exemplo abaixo demonstra a utilização de um método que recebe duas variáveis tipo String
(args[0] e args[1]) e retorna a soma entre elas na forma de número tipo inteiro.

class ExemploMetodo4{
public static void main(String args[]){
if (args.length==2)
System.out.println("Resultado = "+ soma(args[0],args[1]));
else
System.out.println("Entre com dois valores inteiros!");
}

public static int soma(String num1, String num2){
int x=0,y=0;
try{
x = Integer.parseInt(num1);
y = Integer.parseInt(num2);
}catch(NumberFormatException e){
System.out.println("Digite apenas caracteres numericos!");
System.exit(0); //caso houver erro encerra o programa
}
return(x+y); //retorna a soma dos argumentos passados
}
}
116

EX5) O exemplo abaixo mostra a recursividade gerada para imprimir o fatorial dos números inteiros
de 0 a 10.

class ExemploMetodo5{
public static void main(String args[]){
for(long i=0;i<=10;i++)
System.out.println(i + "! = "+ fatorial(i));
}
public static long fatorial(long num){
if(num <=1)
return 1;
else
return num*fatorial(num-1); //metodo recursivo de fatorial
}
}


EX6) O exemplo abaixo demonstra um método de mesmo nome sendo declarado três vezes, isto é,
utilizando o recurso de sobrecarga.

class ExemploMetodo6{
public static void main(String args[]){
System.out.println("Area de um quadrado ... "+area(3));
System.out.println("Area de um retangulo ... "+area(3,2));
System.out.println("Area de um cubo ... "+area(3,2,5));
}
public static double area(int x){
return x*x;
}
public static double area(int x,int y){
return x*y;
}
public static double area(int x,int y,int z){
return x*y*z;
}
}


EX7) O exemplo abaixo mostra o uso de métodos de outras classes já desenvolvidas en exemplos
anteriores para simular um relógio.

class ExemploMetodo7{
public static void main(String args[]){
int H,M,S;
ExemploMetodo2.limpaTela();
for(H=0;H<24;H++)
for(M=0;M<60;M++)
for(S=0;S<60;S++){
System.out.println("Para encerrar pressione CTRL+C
"+H+" h:"+M+" m: "+S+"s");
ExemploMetodo3.tempo(1);
ExemploMetodo2.limpaTela();
}
}
}

EX8) Este exemplo traz uma classe chamada Diversos, em que existem vários métodos específicos
à entrada de dados via teclado e cálculos numéricos. Esses métodos podem ser chamados por
outras classes quantas vezes for necessário. Com o recurso de reaproveitamento de código são
criados os packages (pacotes) em Java que agrupam classes de mesma natureza.

a) Classe Diversos:

117
import java.io.*;
class Diversos{
static BufferedReader entrada = new BufferedReader(new
InputStreamReader(System.in));

public static float leNumeroFloat(float minimo, float maximo){
float n =0;
try{
while(true){ //loop infinito
n = Float.parseFloat(entrada.readLine());
if(n < minimo || n > maximo)
System.out.println("Entrada fora da faixa
permitida!");
else
break; //encerra o loop infinito
}
}catch(IOException e){
System.out.println("Erro na leitura do teclado!");
}
catch(NumberFormatException e){
System.out.println("Digite apenas numeros!");
n = -1; //erro de tipo
}
return (n);
}
public static int leNumeroInt(int minimo, int maximo){
int n =0;
try{
while(true){ //loop infinito
n = Integer.parseInt(entrada.readLine());
if(n < minimo || n > maximo)
System.out.println("Entrada fora da faixa
permitida!");
else
break; //encerra o loop infinito
}
}catch(IOException e){
System.out.println("Erro na leitura do teclado!");
}
catch(NumberFormatException e){
System.out.println("Digite apenas numeros!");
n = -1; //erro de tipo
}
return (n);
}
public static String leString(){
String nome ="";
try{
nome = entrada.readLine();
}catch(IOException e){
System.out.println("Erro nos dados!");
}
return (nome);
}
public static float soma(float num1, float num2){
return (num1+num2);
}
public static float sub(float num1, float num2){
return (num1-num2);
}
public static float divisao(float num1, float num2){
return (num1/num2);
}
public static float mult(float num1, float num2){
return (num1*num2);
}
public static int media(int num1, int num2, int num3){
return ((num1+num2+num3)/3);
118
}
public static int quadrado(int num1){
return (num1*num1);
}
}

b) classe UsaDiversos

class UsaDiversos{
public static void main(String args[]){
System.out.println("Entre com uma nota de prova");
float n = -1;
while(n ==-1) //le enquanto o usuario nao digitar um numero
n = Diversos.leNumeroFloat(0,10);
System.out.println("Nota digitada = "+n);
System.out.println("Entre com uma idade");
int i = -1;
while(i ==-1) //le enquanto o usuario nao digitar um numero
i = Diversos.leNumeroInt(0,150);
System.out.println("Idade digitada = "+i);
System.out.println("Entre com um nome");
System.out.println(Diversos.leString());
System.out.println("A media de 1,3,5 = "+ Diversos.media(1,3,5));

}
}


Ex9) Dados três valores distintos, colocá-los em ordem crescente.

Solução:

a) algoritmo em pseudocódigo

inicio
procedimento troca(a,b:real);
aux:real;
inicio
aux = a;
a = b;
b = aux;
fim;
l,m,n:real;
leia(l,m,n);
se (l > m) ou (l > n) entao
se (m < n) entao
troca(l,m);
senao
troca(l,n);
fimse;
fimse;
se (m > n) entao
troca(m,n);
fimse;
escreva(l,m,n);
fim.


b) programa em Java

import java.io.*;
class ExemploFunc9{
public static void main(String args[]){
BufferedReader entrada;
119
entrada = new BufferedReader(new InputStreamReader(System.in));
try{
System.out.println("Entre com os valores de L, M e N:");
System.out.print("L = ");
float L = Float.parseFloat(entrada.readLine());
System.out.print("M = ");
float M = Float.parseFloat(entrada.readLine());
System.out.print("N = ");
float N = Float.parseFloat(entrada.readLine());
if((L > M)||(L > N)){
if(M < N)
troca(L,M);
else
troca(L,N);
}
if(M > N){
troca(M,N);
}
System.out.println("Os valores ordenados sao: " +L+", "+M+",
"+N);
}catch(Exception e){
System.out.println("Ocorreu algum erro na entrada de dados");
}
}
public static void troca(float a, float b){
float aux;
aux = a;
a = b;
b = aux;
}
}

Ex10) Escrever um programa que leia as medidas das arestas a, b e c de um paralelepípedo, calcule
e escreva o valor de sua diagonal.



L = A
2
+ B
2

c D
D = L
2
+ c






Ex11) Escrever uma função lógica que receba:
9) Uma variável composta unidimensional M;
10) O número N de elementos de M;
11) Um valor X;
E devolva o valor true, se X for igual a algum dos elementos de M ou false, em caso de contrário.
Escrever um programa que leia um conjunto de 20 números inteiros, seguido de outro conjunto de 10
números inteiros e determine quais destes 10 números são iguais a um dos 20 primeiros.

Ex12) escrever uma função que calcule a distancia entre dois pontos de um plano, sendo fornecidas
as coordenadas X1, Y1, X2, Y2, e X3, Y3 e determine a área do triângulo formado por estes pontos.
Imprimir, ara cada registro, as coordenadas lidas e a área determinada.

EX13) Fazer um programa que:
- leia vários pares de números inteiros positivos, M e P. O último para terá o valor zero para M e P;
- calcule e imprima o número de arranjos e combinações de M elementos P a P, dados pelas
fórmulas:

A
p
m
= M!___ C
p
m
= M!___
(M – P) P! (M – P)!

120
Se M < P, por definição

A
p
m
= 0 e C
p
m
= 0

Ex14) Fazer uma função que transforme horas, minutos e segundos em segundos.
Ex: 2h40min 10s 9610s.
Fazer um procedimento que transforme segundos em horas, minutos e segundos.
Ex. 11030 s 3h 3min 50s.

Fazer um programa que:
- leia um conjunto de linhas contendo, cada uma, o número de um empregado, a hora do início
(horas, minutos e segundos) e a hora do término (horas, minutos e segundos) de uma determinada
tarefa. A última linha (flag) conterá o número do empregado negativo;
- calcule, para cada empregado, a duração da tarefa que ele executou, num mesmo dia,
utilizando os dois módulos anteriormente definidos;
- imprima, para cada empregado, o seu número e a duração de sua tarefa em horas, minutos e
segundos.

Ex15) Fazer um programa que calcule o máximo divisor comum entre dois números inteiros
(método das divisões sucessivas ou “jogo da velha”).
Fazer um programa que:
- leia 50 linhas contendo, cada uma, um par de números inteiros;
- imprima, utilizando o procedimento anterior, os números primos entre si.

Dois números são primos entre si quando só admitem como divisor comum a unidade.

Ex16) Fazer um procedimento que, dado um número inteiro N, retorne a soma dos divisores deste
número, exceto ele próprio.
Fazer um programa que, utilizando o procedimento anterior, determine e escreva todos os pares de
números amigos em um intervalo [A,B]. Os valores de A e B (A<B), inteiros maiores que zero,
deverão ser lidos.
Dois números M e N são amigos se a soma dos divisores de M, excluindo M, é igual a N e a soma
dos divisores de N, excluindo N, é igual a M.
Antes de se elaborar um programa para este problema, algumas observações se fazem necessárias:
a) se um número inteiro X possui um divisor Y menor que sua raiz quadrada, o quociente da divisão
de X por Y será maior que a raiz quadrada de X, e será também, um divisor de X.
Exemplo:
X = 64 X/Y = 16>V64 e é também, divisor de 64.
Y = 4
b) se um número inteiro X possui um divisor Y igual a sua raiz quadrada, o quociente da divisão de X
por Y será o próprio divisor Y. Exemplo:
X = 64 X/Y = 8,que é igual a V64
Y = 8

Ex17) Escrever um programa que emita um relatório e forneça dados estatísticos a respeito de uma
turma (no máximo, 50 alunos) do !.º período do Ciclo Básico do Instituto de Ciências Exatas da
UFMG.
O programa deve:

• ler a freqüência mínima exigida como requisito parcial para a aprovação do aluno em
Geometria Analítica, Programação de Computadores e Cálculo I, nesta ordem;
• ler o número de matrícula de cada aluno e sua nota final em cada disciplina ( na
mesma ordem citada na alínea a ), além de sua freqüência (ou seja, a quantas aulas assistiu)
por disciplina;
• conter um procedimento que verifique se um aluno tem direito de fazer exame
especial numa disciplina (isto é, se o aluno é freqüente e obteve, no mínimo, 40 pontos);
• conter um procedimento para calcular e percentagem dos alunos que já foram
aprovados (sem exame especial) em uma disciplina, cuja nota mínima de aprovação é 60;
• conter um procedimento que classifique os elementos de um conjunto de informações
de duas grandezas diferentes em ordem crescente de uma delas;
• determinar (utilizando o procedimento da alínea c)quais alunos podem fazer exame
especial em cada disciplina;
121
• escrever, para cada disciplina, o número de matrícula dos alunos que têm condições
legais de fazer o exame especial, em ordem crescente, com suas notas respectivas,
utilizando o procedimento definido na alínea e;
• calcular e escrever, para cada disciplina, a percentagem de alunos já aprovados,
utilizando o procedimento da alínea d e a percentagem dos que têm direito ao exame
especial.


Exercícios de Fixação - Modularização

OBS: todos os algoritmo devem ser resolvidos utilizando os conceitos de modularização

• Crie um aplicativo que receba o raio de uma esfera (do tipo double) e chame o método
volumeEsfera para calcular e exibir o volume da esfera na tela. Para cálculo do volume deve ser
usada a fórmula: volume = (4.0/3.0)*pi*raio
2
.
• Crie um aplicativo que receba uma temperatura qualquer em Farenheit e apresente seu
correspondente em Celsius por meio de um método. Para o cálculo utilize a seguinte fórmula:
Celsius = 5.0/9.0*(f-32)
• Crie um aplicativo que faça a contagem regressiva de um número inteiro informado pelo
usuário. O usuário deve informar também o espaço de tempo entre cada contagem (em
segundos). Controle o tempo com um método tempo() contido em outra classe. Crie uma nova
classe para esse método do tempo() ou aproveite do exemplo 3.
• Crie um método chamado aleatório que sorteie uma determinada quantidade de
números de acordo com um argumento. O usuário deve informar a quantidade de números a ser
gerada e a faixa de números válidos para o sorteio, por exemplo: se o usuário informar os
argumentos 4 e 100 (aleatório(4,100)), devem ser gerados quatro números aleatórios entre 1 e
100.
• Escreva um algoritmo para:
• preencher uma matriz A de ordem 3;
• ordenar os elementos da matriz A;
• gerar uma matriz somente com os números pares da matriz A;
• gerar uma matriz somente com os números múltiplos de 5;
• criar um menu para acessar os itens anteriores

g) Construa um algoritmo que, a partir de um vetor de 100 inteiros, possiblite:

3. a digitação dos valores no vetor;
4. imprimir o valor do somatório de seus itens;
5. imprimir a média dos valores fornecidos;
6. substituir por zero todos os valores negativos;
7. substituir por zero todos os valores repetidos (maiores que zero);
8. Criar um menu para acessar os itens anteriores.

h) Construa um algoritmo que verifique se um dado número é divisível por outro. Ambos devem
ser fornecidos pelo usuário.
i) Faça um algoritmo que possibilite o arredondamento de um número real para um número
inteiro seguindo os padrões científicos.
j) Elabore um algoritmo que escreva por extenso um número inteiro com até dez dígitos
fornecido pelo usuário.
k) Construa um algoritmo que verifique, sem utilizar a função mod, se um número é divisível por
outro.
l) Escreva um algoritmo que calcule o mdc de dois números fornecidos pelo usuário.
m) Necessita-se calcular alguns dados correspondentes aos animais de uma fazenda. Os
animais pertencem a espécies diferentes, a saber:bovinos, ovinos e caprinos. Construa um
algoritmo para calcular a média de peso de cada espécie para os animais de sexo feminino e do
sexo masculino, a partir de dados fornecidos pelo usuário.
n) Dada uma data abreviada, escreva-a por extenso.
o) Faça a leitura de mil números pelo processo de sorteio automático. Os números devem estar
entre 0 e 100. Verifique:
1. qual foi o número sorteado mais vezes;
2. qual foi o número sorteado menos vezes;
122
3. qual foi o maior número;
4. qual foi o menor número;
p) Escreva um algoritmo que calcule a somatória dos n primeiros números de um conjunto. O
valor de n deverá ser fornecido pelo usuário.
q) Escreva um algoritmo que calcule o número de horas de determinado período estabelecido
por duas datas.
r) Construa um algoritmo que identifique se um número é ou não primo.
s) Construa um algoritmo que calcule a somatória de todos os números primos contidos em um
conjunto de n elementos. O valor de n deverá ser fornecido pelo usuário.
t) Construa um algoritmo que calcule o somatório dos n primeiros termos da série de
Fibonnacci.
u) A avaliação de aproveitamento de uma certa disciplina é feita através de quatro provas
mensais no valor de 20 pontos e uma prova final no valor de 40 pontos. A nota final é obtida
somando-se as três melhores notas, dentre as provas mensais, com a nota da prova final.
O conceito final é dado atendendo-se ao seguinte critério:

De 90 a 100 – conceito A
De 80 a 89 - conceito B
De 70 a 79 - conceito C
De 60 a 69 - conceito D
De 40 a 59 - conceito E
De 0 a 39 - conceito F

Fazer um procedimento que, recebendo como parâmetro 4 (quatro) números inteiros, devolva ao
módulo que o chamou a soma dos 3 (três) maiores números dentre os 4 (quatro) números recebidos.
Fazer um programa que:
9) leia um conjunto de 80 linhas contendo, cada uma, o número do aluno
as quatro notas mensais e a nota da prova final;
10) calcule, para cada aluno, sua nota final, utilizando o procedimento anterior;
11) verifique o conceito obtido;
12) escreva, para cada aluno, o seu número a sua nota final e o seu conceito.

• Fazer um programa para avaliar as apostas da LOTO. O programa deverá ler, inicialmente, as
cinco dezenas sorteadas e, a seguir, ler várias linhas, uma para cada aposta, contendo:
• número da aposta;
• quantidade de dezenas apostadas (no máximo, 10 );
• as dezenas apostadas.
A última linha, que não entrará nos cálculos, conterá o número da aposta igual a zero.
O programa deverá escrever o número de todas as apostas que tiverem três, quatro ou cinco
dezenas sorteadas e ao final, a quanti8dade de apostadores que fizeram o terno (três dezenas
sorteadas), a quadra (quatro dezenas sorteadas) e a quina (cinco dezenas sorteadas). Neste
programa deverá ser utilizado um procedimento que faça a avaliação do número de pontos de cada
aposta.

• Construir uma função que receba como parâmetro de entrada um número inteiro positivo e
devolva um dígito verificador.
Escrever um programa capaz de :
• ler um conjunto indeterminado de linhas, contendo, cada uma, o
nome de uma pessoa e seu número de CPF (nº de inscrição no Cadastro de Pessoas
Físicas)
• imprimir, para cada pessoa, os seus dados de entrada mais a
mensagem “VÁLIDO”, ou “INVÁLIDO”, conforme a situação do número de CPF;
• utiliza e função acima para calcular os dígitos verificadores.
OBS: Um n° de CPF é validado através de seus dois últimos dígitos (dígitos verificadores,
denominados controle). Por exemplo, o CPF de número 23086025620 é validado pelos dígitos
verificadores 20. o esquema de verificação é o seguinte:

230860256
função
dígito verificador igual a 2

2308602562
função
dígito verificador igual a 0


123

• Fazer um procedimento que, dados N números, determine o número que apareceu mais vezes.
Supor que os valores possíveis de cada número estão entre 1 e 6, inclusive, e que sempre haverá
um único número vencedor.
Sabendo-se que um jogo de dados ocorre 40 vezes por dia e que a cada dia é digitada uma linha
contendo os 40 números que saíram, fazer um programa que:
• leia os dados contidos em 30 linhas, correspondentes a um mês de
jogo;
• escreva este número e a mensagem “Resultado Diário”.;
• verifique também qual o número ganhador do mês;
• escreva este número e a mensagem “Resultado mensal do jogo”.

• Fazer um procedimento, cujo cabeçalho é dado por QuantosDias (Dia,Mês,Ano, N) onde:
• Dia, Mês e Ano são parâmetros de entrada;
• N é um parâmetro de saída que conterá o número de dias do ano
até a data fornecida.
Para calcular quantos dias tem no ano até uma data fornecida é preciso verificar o número de dias de
cada mês. O mês de fevereiro pode ter 28 ou 29 dias, dependendo do ano ser bissexto ou não. Todo
ano bissexto é divisível por 4.
Fazer um programa que:
• leia um conjunto de linhas contendo, cada uma, duas datas. A
última linha, que será utilizada como flag, conterá os valores 0,0,0,0,0,0;
• verifique se as datas estão corretas (1< Mês < 12, dia de acordo
com o mês e se ambas estão dentro do mesmo ano). Se algumas das datas não
estiver correta, escreva”Data incorreta” e os valores de Dia, Mês e Ano das duas
datas;
• verifique, se as datas estiverem corretas, qual a diferença, em dias,
entre estas duas datas;
• escreva as datas lidas e a diferença entre elas.

2. Escrever um programa que leia um conjunto de 1.000 linhas contendo, cada uma, uma palavra em
inglês e a sua tradução em português. Em seguida, leia um número indeterminado de linhas
contendo, cada uma:
• a letra I (indicando inglês) e uma palavra qualquer das 1.000 em
inglês; ou
• a letra P (indicando português) e uma palavra qualquer das 1.000
em português.
Para cada uma destas linhas, escrever a palavra lida e a sua tradução. A última linha, indicando o fim
de dados, terá a primeira letra diferente de I e P.
A tradução da palavra lida deve ser feita através de um procedimento que recebe as listas de
palavras em inglês e português, a letra I ou P e a palavra que se deseja traduzir, devolvendo a
tradução da mesma.




















124

Arquivos

Introdução

Até então utilizamos variáveis simples para armazenar as informações necessárias à
resolução de determinado problema. Estes problemas tinham uma limitação: quantidade de
informações que poderia ser armazenada para resolve-los. Os algoritmos eram limitados conforme a
capacidade finita das estruturas de dados utilizadas (registros e/ou vetores).
Estudaremos, a partir daqui, arquivos. Muito comum em nosso cotidiano, o arquivo tem como
finalidade o armazenamento de grandes quantidades de informação, por um grande período de
tempo, como, por exemplo, os arquivos mantidos por uma companhia telefônica a cerca de seus
assinantes, ou as informações armazenadas na Receita Federal sobre os contribuintes.
Um arquivo é um conjunto de registros (ou seja, uma estrutura de dados) no qual cada
registro não ocupa uma posição fixa dentro da estrutura, não possuindo, portanto, tamanho
preestabelecido. Os registros, como sabemos, são formados por unidades de informação
denominados campos.

Definição de arquivos

Um arquivo é um local reservado para se guardar informações escritas. Um bom exemplo são
os arquivos de aço utilizados para armazenar fichas contendo dados de clientes, produtos e
pacientes, entre outros.
O arquivo de computador é uma maneira de armazenar informações em meios magnéticos,
como por exemplo discos rígidos, discos flexíveis e CD-ROM, entre outros. Esses dados podem ser
utilizados diversas vezes pelos programas associados ao arquivo.

Ex1: biblioteca

Ficha catalográfica

Código do livro:
Título:
Autor:
Assunto:
Editora: Ano:




Conjunto de Fichas catalográficas




Código do livro:
Título:
Autor:
Assunto:
Editora: Ano:



125






Item da ficha
(campo)
Arquivo de aço
(arquivo)
Ficha
(registro)



Manipulação

Generalizando, podemos admitir que todo arquivo possui maneiras semelhantes de ser
manipulado, independentemente de como foi concebido. Exemplificando, diante de um arquivo de
livros de uma biblioteca, você poderia ter apenas dois tipos de atitudes diferentes:
5. No caso de ser um leitor, você procura a informação sobre a localização de certo livro
através das fichas que registram o acervo.
6. Como funcionário (da biblioteca), você intenciona manipular (inserir, modificar,
remover) alguma informação a respeito de algum livro.

Concluímos que podemos consultar e/ou manipular alguma informação no arquivo. Podemos,
então, sugerir os seguintes algoritmos básicos:


Consultar arquivo Acrescentar dados

1. Abrir gaveta do arquivo 1. Abrir gaveta do arquivo

2. Achar a ficha procurada 2. Achar posição da inserção

3. Copiar informações da ficha 3. Guardar ficha nova

4. Fechar gaveta do arquivo 4. Fechar gaveta do arquivo


Modificar dados Eliminar dados

1. Abrir gaveta do arquivo 1. Abrir gaveta do arquivo

2. Achar a ficha procurada 2. Achar a ficha procurada

3. Alterar os dados da ficha 3. Retirar a ficha do arquivo

4. Fechar gaveta do arquivo 4. Fechar gaveta do arquivo



Podemos observar que os algoritmos apresentados são muito semelhantes, que tanto o leitor
(que consulta o arquivo) quanto o funcionário (que manipula as informações) atuam de forma muito
parecida. Mesmo as diferentes operações que o funcionário pode desempenhar (inserir. Eliminar ou
modificar dados) também são muito similares. Percebemos também que os passos 1 e 4 são sempre
idênticos em todos os casos, enquanto o passo 2 está sempre relacionado a uma pesquisa.
Entretanto, o passo 3 é o que parece diferenciar realmente cada uma delas. Muito embora ainda seja
possível perceber algo de comum entre as atividades do passo 3 – todas estão relacionadas ao fluxo
de informações -, em alguns casos o fluxo é da pessoa para o arquivo e em outros é do arquivo para
a pessoa, ou seja, a diferença está apenas no sentido em que os dados trafegam.

126
Independentemente do tipo de um arquivo, ele tem a capacidade de executar algumas
operações em comum, tais como: abertura, leitura e fechamento,

Tipos de arquivos

Arquivo texto

As informações de um arquivo texto são organizadas em registros. Os registros por sua vez,
são organizados em campos e nos campos é que são inseridas as informações.

campos
Nome Endereço CEP Telefone
Zé Mané Rua dos bosque, 10 69025-952 251-8547
Maria Xiquinha Rua da Gruta, 247 69025-852 542-8756
R
e
g
i
s
t
r
o
s
Jurubeba Silva Av. Leste-Oeste, 1002 69054-584 236-8547

12) Na interface, são representados os nomes dos campos, que devem ser legíveis para o
usuário, isto é, o usuário deve ler e entender o que deverá ser digitado nos espaços reservados
para as informações.
13) Na interface também deve existir um espaço para que o usuário faça a entrada dos dados,
isto é, o local no qual serão digitadas ou selecionadas as informações.
14) No programa, deve existir uma variável para cada informação que será digitada na interface.
15) No arquivo, deve existir um campo para cada variável cuja informação deve ser armazenada.

No arquivo, cada linha representa um registro. Um registro é um conjunto de campos, isto é,
um conjunto de informações sobre um determinado assunto. Cada campo recebe dados que são
armazenados no arquivo por meio da associação da variável da interface com o campo do arquivo.


Formas de acesso

Os arquivos criados em meios magnéticos podem ser acessados para leitura e/ou escrita na
forma seqüencial, direta ou indexada, como definidos a seguir:

Acesso seqüencial. Ocorre quando o processo de gravação e leitura é feito de
forma contínua, um a após o outro. Desta forma, para gravar um novo registro, é
necessário percorrer todo o arquivo a partir do primeiro registro, registro a registro, até
localizar a primeira posição vazia após o último registro. O processo de leitura também
ocorre de forma seqüencial. Se o registro a ser lido for o último, primeiro é necessário ler
todos os registros que o antecedem.
Acesso direto. Conhecido também como randômico, ocorre por meio de uma
campo chave previamente definido. Desta forma, passa-se a possuir um vínculo entre um
dos campos do registro e sua posição de armazenamento, por meio da chave. Assim
sendo, o acesso a um registro tanto para leitura quanto para escrita pode ser feito de
modo instantâneo. Isto implica o fato de que os registros de um arquivo direto possuem
um lugar (chave) previamente “reservado” para serem armazenados.
Acesso indexado. Ocorre quando se acessa de forma direta um arquivo seqüencial,
por meio de um arquivo índice que possui a chave de busca para esse arquivo. Para
trabalhar com esta técnica, basta criar um arquivo direto que será o índice de consulta do
arquivo seqüencial, passando este a ser o arquivo indexado. Existem dois arquivos: o
arquivo índice (arquivo direto) e o arquivo indexado (arquivo seqüencial). Os acessos
serão feitos como em um livro. Primeiro consulta-se o arquivo índice, o qual possui a
chave de pesquisa, no caso seria o número da página, depois basta posicionar de forma
direta na página (no caso de um livro) identificada no índice, ou seja, no registro do
arquivo indexado.



127
Exemplos – acesso seqüencial:

ARQUIVO SEQUENCIAL – OPERAÇÃO DE INCLUSÃO

• Construa um agenda que armazene nomes, endereços e telefones.

Solução:

a) algoritmo em pseudocódigo

inicio
tipo
reg_agenda = registro
nome:caracter;
endereco: caracter;
telefone:caracter;
fimregistro;
arq_agenda: arquivo sequencial de reg_agenda;

auxiliar:reg_agenda;
agenda:arq_agenda;
abrir(agenda);
repita
avancar(agenda);
ate EOF (agenda);
leia (auxiliar.nome, auxiliar.endereco, auxiliar.telefone);
armazenar(agenda,auxiliar);
fechar(agenda);
fim.


Nos algoritmos, deve-se, primeiramente, declarar uma estrutura do tipo registro com todos os
campos cujas informações pretende-se armazenar.
tipo
reg_agenda = registro
nome:caracter;
endereco: caracter;
telefone:caracter;
fimregistro;
arq_agenda: arquivo sequencial de reg_agenda;


É necessário também declarar um identificador do tipo arquivo, mencionando o tipo de
arquivo que será utilizado. Esse identificador é associado ao arquivo que será formado pelos registros
de reg_agenda.
As variáveis Auxiliar e Agenda são variáveis de registro e de arquivo, respectivamente.
Para que seja possível a manipulação do arquivo, esse deve ser aberto:
Abrir(nome da variável de arquivo)

Será disponibilizado o primeiro registro armazenado. Para acessar os próximos registros,
utiliza-se a instrução:
Avancar(nome da variável de arquivo)

No caso de se desejar que o arquivo seja posicionado no último registro, utiliza-se uma
estrutura de repetição que provoque o avanço pelos registros até o final do arquivo:
repita
avancar(agenda);
ate EOF (agenda);

Nota: Por se tratar de um arquivo seqüencial, para se chegar ao último registro, percorre-se o arquivo
todo, passando por todos os registros armazenados, como, por exemplo, em uma fita cassete.

128
Para processar a inclusão de um registro, é necessário que seus campos sejam preenchidos
na mesma ordem e com os mesmos campos do arquivo. Por isso, a variável de registro é declarada
com o tipo da estrutura declarada para o registro do arquivo. No caso do Exemplo acima:

3. Declaração da estrutura de dados do tipo registro:
tipo
reg_agenda = registro
nome:caracter;
endereco: caracter;
telefone:caracter;
fimregistro;
arq_agenda: arquivo sequencial de reg_agenda;


4. Declaração da variável do tipo registro, que terá o mesmo formato da estrutura de dados
criada para o registro, isto é, Auxiliar.Nome,Auxiliar.End, Auxiliar.Tel:

auxiliar:reg_agenda;

5. Preenchimento dos campos:

leia (auxiliar.nome, auxiliar.endereco, auxiliar.telefone);

Depois de representar o preenchimento dos campos, será necessário representar o
armazenamento do conteúdo no arquivo. Para isso utiliza-se a instrução:
armazenar(nome da variável de arquivo, nome da variável de registro);
armazenar(agenda,auxiliar);

A variável de arquivo Agenda receberá o conteúdo da variável de registro Auxiliar.

Por último, o arquivo deve ser fechado:

Fechar(nome da variável de arquivo);

b) programa em Java

class regAgenda{
private String nome;
private String endereco;
private String telefone;

public regAgenda(String nom, String ender, String telef){
nome = nom;
endereco = ender;
telefone = telef;
}
public String mostraNome(){
return nome;
}
public String mostraEndereco(){
return endereco;
}
public String mostraTelefone(){
return telefone;
}
}

Para representar uma estrutura do tipo registro em Java, utilizou-se uma classe regAgenda
que possui como atributos: nome, end e tel, conforme trecho de código acima. Essa forma de
representação é necessária, uma vez que o Java trabalha com objetos, conforme citado no capítulo
4. Assim, cada entrada em regAgenda corresponde a um novo registro e refere-se a um novo objeto
da classe regAgenda, que possui características próprias, ou seja, um nome, um endereço e um
telefone que o distinguem dos demais objetos existentes.
129
A declaração da classe correspondente ao registro é feita nas linhas de 1 a 4. Nas linhas de 6
a 9 é definido o método construtor, responsável pela instanciação de novos objetos da classe ou,
para o nosso caso, de novas entradas de registros em regAgenda.
Para exibir os atributos de cada novo objeto instanciado, criaram-se os métodos
mostraNome(), mostaEndereco() e mostraTelefone(), que retornam os respectivos dados.
O algoritmo codificado em Java relativo ao exemplo acima e que utiliza a classe regAgenda
para definição das entradas de novos registros na agenda é apresentado a seguir.

Cuidado! Java é uma linguagem case-sensitive. As referências às variáveis e métodos devem ser
feitas exatamente da forma que estes foram declarados, considerando as letras maiúsculas e
minúsculas.

import java.io.*;
class usaAgenda{
public static void main(String args[]){
try{
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

BufferedWriter saida;
saida= new BufferedWriter(new FileWriter("agenda.txt",true));

System.out.println("Entre com o nome:");
String nome = entrada.readLine();
System.out.println("Entre com o endereco:");
String endereco = entrada.readLine();
System.out.println("Entre com o telefone:");
String telefone = entrada.readLine();

regAgenda regAg1 = new regAgenda(nome,endereco,telefone);
saida.write(regAg1.mostraNome() + "\t");
saida.write(regAg1.mostraEndereco() + "\t");
saida.write(regAg1.mostraTelefone() + "\n");
saida.flush();
saida.close();
}catch(Exception e){
System.out.println("Erro de gravacao!");
}
}
}

Para ler a entrada dos dados via teclado, declarou-se uma variável entrada, que é contêiner
que recebe os caracteres de entrada digitados via teclado (linhas 5 e 6). Seguindo a mesma filosofia
da entrada de dados, utilizam-se classes (e objetos) de apoio definidos na linguagem Java para
trabalhar o acesso e gravação de arquivos.
Nas linhas 7 e 8 está a declaração da variável (objeto) que será o contêiner do arquivo. Essa
declaração é muito semelhante à declaração das variáveis que receberão a entrada de dados, mas,
em vez de se utilizar um objeto do tipo InputStreamReader, que define uma entrada de caracteres,
utiliza-se um objeto do tipo FileWriter (linha 8), que define uma saída para o arquivo Agenda.txt. Um
detalhe particular deve ser observado nessa declaração: na linha 8 , quando se define o nome do
arquivo destinado ao armazenamento dos dados, no trecho FileWrite (“ Agenda.txt”, true),tem-se, na
verdade, uma chamada de um método com passagem dos parâmetros “Agenda.txt” e true. O primeiro
é o nome do arquivo, conforme já foi dito, e o segundo significa que o arquivo será acessado com a
condição append = true, ou seja, os dados gravados serão sempre inseridos ao final do arquivo. Vale
ressaltar ainda que, caso o arquivo não exista, ele será criado automaticamente.
O processo de entrada dos dados é executado a partir das instruções das linhas 9 a 14,
segundo as quais os caracteres lidos a partir do teclado serão transferidos para as respectivas
variáveis de armazenamento: Nome, Endereço e Telefone.
Na linha 15, ocorre a chamada do método construtor da classe. RegAgenda, com a
respectiva passagem dos parâmetros Nome, Endereço e Telefone, instanciando-se um novo objeto
regAg1 da classe regAgenda. No trecho de código anterior (classe regAgenda), pode- se verificar a
declaração do método nas linhas 6 a 9.
A saída de dados é feita por meio do código nas linhas 16 a 18, com a chamada dos métodos
que retornam os atributos do novo objeto criado. Por exemplo, em:
130

saída.write(regAg1.mostraNOme() + “\t”);

temos a chamada do método que retorna o atributo nome do objeto regAg1 e a transferência do
resultado para a saída. O atributo “\t” associado ao nome indica que, após a dado, será gravado
também um espaço de tabulação como separador.
Ao final da transferência do último dado, também é passado o caractere de controle “\n” (nova
linha), utilizado como separador, indicando o final do registro. O motivo da utilização desses
separadores será visto nos exemplos posteriores.
Nas linhas 19 e 20, são chamados os métodos saida.flush () e saida.close(), que fazem a
transferência definitiva dos dados da memória para o arquivo e o fechamento do arquivo,
respectivamente.

Nota: Pode-se perguntar por que os dados obtidos da entrada via teclado não são transferidos
diretamente para o arquivo,uma vez que eles estariam disponíveis sem a necessidade de instanciar
um objeto da classe regAgenda. O motivo é a necessidade de satisfazer os princípios da orientação a
objetos, segundo os quais cada novo dado ou registro é um objeto e assim deve ser tratado. Como
será visto posteriormente, a manipulação dos atributos dos objetos deve seguir esses princípios,
garantindo-se que alterações nesses atributos somente poderão ser feitas mediante a chamada de
métodos, que permitirão ou não as alterações. Os atributos de um objeto definem sua estrutura, e as
operações, seu comportamento. Os métodos implementam essas operações que permitem
alterações nos objetos e na sua estrutura, preservando sua integridade (princípio do
encapsulamento).

ARQUIVO SEQUENCIAL – OPERAÇÃO DE CONSULTA

A operação de consulta pode ser realizada de duas maneiras:

6. saltando manualmente de um registro para o outro: nesse caso, o usuário visualizará todos os
registros até que se chegue ao registro desejado;
7. saltando automaticamente para o registro desejado: nesse caso, utiliza-se uma variável que
recebe a informação a ser encontrada no arquivo e, por meio de uma estrutura de repetição,
é provocado o avanço pelos registros até que seja encontrado o registro desejado.

Nota: Quando se trabalha com arquivos seqüenciais, em ambos os casos todos os registros são
percorridos até que chegue ao registro desejado.

No exemplo a seguir, será utilizado o recurso de consulta automática. Para isso, será
declarada a variável Buscar, que receberá o nome a ser consultado.

1) Busca seqüencial em arquivo

Solução:

a) algoritmo em pseudocódigo

inicio
tipo
reg_agenda = registro
nome:caracter;
endereco: caracter;
telefone:caracter;
fimregistro;
arq_agenda: arquivo sequencial de reg_agenda;

auxiliar:reg_agenda;
agenda:arq_agenda;
buscar:caracter;
abrir(agenda);
leia(buscar);
repita
avancar(agenda);
131
ate (auxiliar.nome = buscar) ou (EOF (agenda));
se (auxiliar.nome = buscar) entao
escreva(auxiliar.endereco, auxiliar.telefone);
senao
escreva(“Nao cadastrado”);
fimse;
fechar(agenda);
fim.

Nesse exemplo, foi utilizada a variável Buscar, que recebeu o nome a ser consultado. A
estrutura de repetição Repita provoca o avanço pelos registros do arquivo até que se encontre o
nome desejado ou o final do arquivo. Se tivermos sucesso na consulta, isto é, se o nome desejado for
encontrado, então o programa exibirá o endereço e o telefone.

b) programa em Java

import java.io.*;
class usaAgenda2{
public static void main(String args[]){
try{
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

BufferedReader arqentrada;
arqentrada = new BufferedReader(new FileReader("agenda.txt"))

System.out.println("Entre com o nome:");
String nome = entrada.readLine();
StringBuffer memoria = new StringBuffer();
String linha;
while((linha = arqentrada.readLine()) != null){
memoria.append(linha + "\n");
}
int inicio = -1;
inicio = memoria.indexOf(nome);
if (inicio != -1){
int fim = memoria.indexOf("\n",inicio);
char[] destino = new char[fim - inicio];
memoria.getChars(inicio, fim, destino, 0);
linha = "";
for(int i = 0; i < fim - inicio;i++){
linha += destino[i];
}
System.out.println(linha);
}else{
System.out.println("Item nao encontrado!!");

}
entrada.close();
}catch(FileNotFoundException erro){
System.out.println("Arquivo nao encontrado!");
}catch(Exception erro){
System.out.println("Erro de leitura!");
}
}
}

Na implementação desse exemplo, cria-se uma estrutura chamada memoria, que é uma
variável de memória do tipo StringBuffer. Em Java, esse tipo de variável é semelhante ao tipo String,
mas permite uma estrutura de trabalho mais avançado como, por exemplo, append, adiciona um novo
conteúdo ao conteúdo já existente, sem perda de dados.
A linha 13 define a condicional de uma estrutura de armazenamento de dados que repetirá
enquanto houver dados a serem lidos, isto é, lerá todos os dados até o fim do arquivo. Essa
condicional é equivalente à determinação de EOF (end of file).
A busca é feita na variável memoria, com o método IndexOf, que recebe Nome como
parâmetros, dado obtido pela entrada de dados via teclado na linha 10. Esse método retorna a
132
posição onde se inicia o caractere pesquisado. As posições são numeradas a partir de 0, significando
que o teste de condição na linha 18 verifica se o valor atribuído inicialmente à variável inicio foi
alterado. Em caso afirmativo, ou seja, se inicio é diferente de -1, executam-se os comandos internos
do laço.
Para que seja possível obter a seqüencia de caracteres correspondentes ao registro
completo, é necessário determinar o seu final. Isso é feito por meio do comando na linha 19, que
busca o caractere “\n” (nova linha) imediatamente após o primeiro caractere encontrado. É importante
observar que o método indexOf é chamado novamente, porém, dessa vez, são passados dois
parâmetros: “\n” e inicio, para que a nova busca ocorra a partir da posição em que foi encontrado o
primeiro caracteres do item pesquisado.
Na linha 21, utiliza-se o método getChars para se obter os caracteres correspondentes ao
registro, passando-se os parâmetros inicio e fim como delimitadores. A string obtida é armazenada na
própria variável linha, que será utilizada para exibição dos dados (linha 26).
Foram feitos dois tratamentos de erro nas linhas 31 e 33, para determinar problemas quando
o arquivo não for encontrado ou quando ocorrerem outros erros genéricos, respectivamente.


ARQUIVO SEQUENCIAL – OPERAÇÃO DE ALTERAÇÃO

13) Alteração em arquivo seqüencial

Solução:

a) algoritmo em pseudocódigo

inicio
tipo
reg_agenda = registro
nome:caracter;
endereco: caracter;
telefone:caracter;
fimregistro;
arq_agenda: arquivo sequencial de reg_agenda;

auxiliar:reg_agenda;
agenda:arq_agenda;
buscar:caracter;
novo_endereco: caracter;
novo_telefone: caracter;
abrir(agenda);
leia(buscar);
copiar(agenda,auxiliar);
enquanto (auxiliar.nome <> buscar) e (nao EOF (agenda)) faca
avancar(agenda);
copiar(agenda);
fimenquanto;
se (auxiliar.nome = buscar) entao
inicio
escreva(auxiliar.endereco, auxiliar.telefone);
escreva(“Novo endereco: “);
leia(novo_endereco);
auxiliar.endereco = novo_endereco;
escreva(“Novo telefone: “);
leia(novo_telefone);
auxiliar.telefone = novo_telefone;
armazenar(agenda,auxiliar);
fim;
senao
escreva(“Nao cadastrado”);
fimse;
fechar(agenda);
fim.
133

No algoritmo acima é feita uma consulta similar à do Algoritmo de consulta. Se o registro for
encontrado, é recomendado que seja exibido antes da alteração. Para a alteração, devem-se declarar
as variáveis que receberão os novos valores, preencher os novos valores e depois atribuir esses
valores às variáveis de registro:

escreva(“Novo endereco: “);
leia(novo_endereco);
auxiliar.endereco = novo_endereco;

b) programa em Java

class regAgenda{
private String nome;
private String endereco;
private String telefone;

public regAgenda(String nom, String ender, String telef){
nome = nom;
endereco = ender;
telefone = telef;
}
public String mostraNome(){
return nome;
}
public String mostraEndereco(){
return endereco;
}
public String mostraTelefone(){
return telefone;
}
public void alteraEndereco(String novoEndereco){
endereco = novoEndereco;
}
public void alteraTelefone(String novoTelefone){
telefone = novoTelefone;
}
}

A classe regAgenda sofreu alterações para suportar as novas necessidades do algoritmo.
Foram incluídos os métodos alteraEnd e alteraTel (linha 20 a 25) para que os objetos permitam
alterações no endereço e no número do telefone. Assim, para que seja possível a alteração desses
atributos, é necessário invocar (ou chamar) esses métodos, como será feito no trecho de código a
seguir.

import java.io.*;
class usaAgenda3{
static StringBuffer memoria = new StringBuffer();
public static void main(String args[]){
try{
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

BufferedReader arqentrada;
arqentrada = new BufferedReader(new FileReader("agenda.txt"));

System.out.println("Entre com o nome:");
String nome = entrada.readLine();
String endereco = "";
String telefone = "";
String linha;
while((linha = arqentrada.readLine()) != null){
memoria.append(linha + "\n");
}
int inicio = -1;
inicio = memoria.indexOf(nome);
if (inicio != -1){
134
int ultimo = memoria.indexOf("\t",inicio);
nome = ler(inicio,ultimo);
int primeiro = ultimo +1;
ultimo = memoria.indexOf("\t",primeiro);
endereco = ler(primeiro,ultimo);
primeiro = ultimo +1;
int fim = memoria.indexOf("\n",primeiro);
telefone = ler(primeiro, fim);
regAgenda regAg1 = new regAgenda (nome,endereco,
telefone);
System.out.println("Endereco: "+regAg1.mostraEndereco()+
"Telefone: " +regAg1.mostraTelefone());
System.out.println("Entre com o novo endereco:");
endereco = entrada.readLine();
regAg1.alteraEndereco(endereco);
System.out.println("Entre com o novo telefone:");
telefone = entrada.readLine();
regAg1.alteraTelefone(telefone);
memoria.replace(inicio, fim, regAg1.mostraNome()+
"\t"+regAg1.mostraEndereco() + "\t" +regAg1.mostraTelefone());
gravar();
arqentrada.close();
}else{
System.out.println("Item nao encontrado!!");

}
arqentrada.close();
}catch(FileNotFoundException erro){
System.out.println("Arquivo nao encontrado!");
}catch(Exception erro){
System.out.println("Erro de leitura!");
}
}
public static String ler(int primeiro, int ultimo){
String dados = "";
char[] destino = new char[ultimo - primeiro];
memoria.getChars (primeiro, ultimo, destino, 0);
for (int i =0; i < destino.length;i++){
dados += destino[i];
}
return dados;
}

public static void gravar(){
try{
BufferedWriter saida;
saida= new BufferedWriter(new FileWriter("agenda.txt"));
saida.write(memoria.toString());
saida.flush();
saida.close();
}catch(Exception e){
System.out.println("Erro de gravacao!");
}

}
}

Atenção: Observe que para a execução do programa de Exemplo acima, o arquivo Agenda.txt deverá
conter pelo menos um registro de entrada. Portanto, é necessário executar o programa do Exemplo 1
para a inclusão dos registros desejados.

Os mesmos recursos de entrada de dados e busca em arquivo do Exemplo de consulta foram
utilizados. Porém, para obtermos os dados dos diversos campos separadamente, buscamos “ \ t”
(tabulação) após a busca para localizar a primeira posição do nome e assim obter os caracteres
correspondentes somente ao nome. Por exemplo, suponha que fosse incluído o seguinte registro:

Gilberto da Silva Rua A n 203 apto 102 25834911
135

Para obtermos somente o campo nome (Gilberto da Silva),efetuamos a busca passando para
o método indexOf os parâmetros “\t” e inicio, que correspondem respectivamente à tabulação e à
posição em que foi encontrado o primeiro caractere do nome (variável inicio). Para obtermos os
caracteres referentes ao campo nome, utilizamos o método ler, fornecendo como parâmetros as
posições de inicio e ultimo, correspondentes ao primeiro e ao último caracteres do nome.
Observe também que foram incluídas as variáveis primeiro e ultimo em relação ao Exemplo
9.2. Essas variáveis cumprem o papel de obter as posições de inicio e fim de cada campo, visto que
precisamos preservar o valor das variáveis inicio e fim, conforme explicaremos a seguir.
As variáveis inicio e fim se prestam a guardar as posições de início e fim do registro e foram
utilizadas para invocar o método replace na linha 38, que faz a atualização do contêiner dos dados
que estão na memória. Para tanto, é necessário identificar corretamente as posições e os dados que
serão substituídos. Note que os parâmetros passados para os métodos são: inicio, fim e uma string
composta pela concatenação regAg1.mostraNome () + “\t” + regAg1.mostraEnd () + “\t” +
regAg1.mostraTel (). Usando o exemplo citado acima e supondo que o endereço de Gilberto da Silva
fosse alterado para Rua Alfazema n 203 apto 102, a string resultante que seria passada para
atualização seria.

Gilberto da Silva Rua Alfazema n 203 apto 102 25834911

O método ler, implementado a partir da linha 52, tem a finalidade de obter e retornar uma
string de caracteres (variável dados), corresponde às posições fornecidas (primeiro e ultimo), de
forma similar à utilizada no exemplo anterior.
Também foi implementado um método chamado gravar, cujo código encontra-se a partir da
linha 61. Esse método usa os mesmos princípios apresentados no primeiro Exemplo. Note que ele
não recebe nem retorna nenhum valor, executando a transferência dos dados do contêiner memoria
para o arquivo.

ARQUIVO SEQUENCIAL – OPERAÇÃO DE EXCLUSÃO

1) Exclusão em arquivo seqüencial

Solução:

a) algoritmo em pseudocódigo

inicio
tipo
reg_agenda = registro
nome:caracter;
endereco: caracter;
telefone:caracter;
fimregistro;
arq_agenda: arquivo sequencial de reg_agenda;

auxiliar:reg_agenda;
agenda:arq_agenda;
buscar:caracter;
resposta: caracter;
abrir(agenda);
leia(buscar);
copiar(agenda,auxiliar);
repita
copiar(agenda);
avancar(agenda);
ate ((auxiliar.nome = buscar) ou (EOF(agenda)));
se (auxiliar.nome = buscar) entao
inicio
escreva(auxiliar.endereco, auxiliar.telefone);
escreva(“Deseja excluir? (Digite S ou N) “);
leia(resposta);
auxiliar.endereco = novo_endereco;
136
se (resposta = “S”) entao
deletar(agenda);
fimse;
fim;
senao
escreva(“Nao cadastrado”);
fimse;
fechar(agenda);
fim.

Para facilitar o processo de exclusão, é recomendado que seja feita uma busca automática,
conforme visto anteriormente no Algoritmo de consulta. A exclusão será feita com a instrução Deletar
(nome da variável de arquivo).

b) programa em Java

import java.io.*;
class usaAgenda4{
static StringBuffer memoria = new StringBuffer();
public static void main(String args[]){
try{
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

BufferedReader arqentrada;
arqentrada = new BufferedReader(new FileReader("agenda.txt"));

System.out.println("Entre com o nome:");
String nome = entrada.readLine();
String linha;
while((linha = arqentrada.readLine()) != null){
memoria.append(linha + "\n");
}
int inicio = -1;
inicio = memoria.indexOf(nome);
if (inicio != -1){
int fim = memoria.indexOf("\t",inicio);
linha = ler(inicio,fim);
System.out.println("Deseja excluir? Digite S ou N");
System.out.println(linha);
String resp = entrada.readLine();
if (resp.equalsIgnoreCase ("S")){
memoria.delete(inicio,fim+1);
System.out.println("Registro excluído");
}
gravar();
}else{
System.out.println("Item nao encontrado!!");

}
arqentrada.close();
}catch(FileNotFoundException erro){
System.out.println("Arquivo nao encontrado!");
}catch(Exception erro){
System.out.println("Erro de leitura!");
}
}
public static String ler(int primeiro, int ultimo){
String dados = "";
char[] destino = new char[ultimo - primeiro];
memoria.getChars (primeiro, ultimo, destino, 0);
for (int i =0; i < destino.length;i++){
dados += destino[i];
}
return dados;
}

137
public static void gravar(){
try{
BufferedWriter saida;
saida= new BufferedWriter(new FileWriter("agenda.txt"));
saida.write(memoria.toString());
saida.flush();
saida.close();
}catch(Exception e){
System.out.println("Erro de gravacao!");
}

}
}

Poucas modificações foram necessárias em relação ao código do Exemplo 9.3 para
implementar a exclusão de registro. Utilizou-se para tanto uma String resp que recebe a entrada feita
pelo teclado (linha 23), o que permite a interação com o usuário, pedindo-se uma confirmação da
exclusão. Observe a particularidade da expressão de avalia a resposta. Usa-se equalsIgnoreCase,
um método da classe String, para verificara condição de igualdade desconsiderando maiúsculas e
minúsculas. Atitude bastante salutar, pois o usuário pode não perceber a condição do teclado no
momento (Caps Lock ativado ou não) e não obter sucesso no processo. Qualquer outra tecla digitada
nesse momento invalida a exclusão. A exclusão ocorre no trecho de código na linha 25 (exclusão dos
caracteres entre as posições inicio e fim +1) somente no contêiner memória. A atualização do arquivo
ocorre somente quando é chamado o método gravar. Note ainda que foi utilizado fim + 1, pois a
posição fim correspondente ao final do registro não considera o caractere \n.


Representação da Manipulação de Arquivos de Acesso Aleatório

As informações de um arquivo de acesso aleatório ou randômico têm sua ordem de inserção
definida por um campo denominado chave. O campo chave de um registro não pode ter o seu
conteúdo repetido; ele deve ser único no arquivo para que possibilite a identificação do registro. Por
meio do campo chave, o registro pode ser localizado diretamente, sem que haja necessidade de se
percorrerem todos os registros anteriores. O campo chave deve ser declarado juntamente com as
demais variáveis que irão compor o registro.

Nota: Os arquivos de acesso aleatório ou randômico são também chamados de arquivos de acesso
direto.

Um arquivo de acesso aleatório ou randômico pode ser comparado a um CD-ROM com
músicas pelo qual se pode ouvir a primeira música, depois saltar para a décima, sem que haja
necessidade de percorrer todas as músicas intermediárias.
Para que seja possível a manipulação de arquivos se acesso aleatório ou randômico, será
necessário:

• Declarar o registro e o arquivo.
• Declarar as variáveis de arquivos.
• Abrir o arquivo.
• Fechar o arquivo.

Esses passos são utilizados para qualquer operação de manipulação de arquivos e já foram
explicados anteriormente no Algoritmo 1 da seção de arquivos seqüenciais – Operação de inclusão.
No exemplo a seguir, será feita a construção de um cadastro de clientes que armazene
código do cliente, nome, telefone e e-mail.

Exemplos – arquivo de acesso direto

ARQUIVO DE ACESSO ALEATÓRIO – OPERAÇÃO DE INCLUSÃO

1) Operação de inclusão – arquivo de acesso direto.

Solução:

138
a) algoritmo em pseudocódigo

inicio
tipo
reg_cliente = registro
cod_cli:inteiro;
nome: caracter;
telefone:caracter;
email:caracter;
fimregistro;
arq_cliente: arquivo direto de reg_cliente;

auxiliar:reg_cliente;
cliente:arq_cliente;
abrir(cliente);
leia(auxiliar.cod_cli, auxiliar.nome, auxiliar.telefone, auxiliar.email);
posicionar(cliente, auxiliar);
armazenar(cliente, auxiliar);
fechar(cliente);
fim.

A instrução Posicionar (nome da variável de arquivo, nome da variável de registro) é utilizada
para posicionar o novo registro corretamente. Essa posição é determinada pelo campo chave. No
algoritmo acima, o campo chave é o Cod_Cli. È necessário que seja indicado também o
armazenamento do registro para que este seja definitivamente inserido no arquivo por meio da
instrução Armazenar (nome da variável de arquivo, nome da variável de registro).


b) programa em Java

import java.io.*;
class usaCliente{
static StringBuffer memoria = new StringBuffer();
public static void main(String args[]){
try{
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

BufferedReader arqentrada;
arqentrada = new BufferedReader(new FileReader("cliente.txt"));
String linha="";

while((linha = arqentrada.readLine()) != null){
memoria.append(linha + "\n");
}
int cod_cli = 1;
if (memoria.length() != 0){
int inicio = memoria.lastIndexOf("#");
int fim = memoria.indexOf("\t",inicio);
cod_cli = Integer.parseInt(ler(inicio + 1,fim));
cod_cli +=1;
}
System.out.println("Codigo do cliente: "+ cod_cli);
System.out.println("Entre com o nome:");
String nome = entrada.readLine();
System.out.println("Entre com o telefone:");
String telefone = entrada.readLine();
System.out.println("Entre com o e_mail:");
String email = entrada.readLine();

regCliente regCli1 = new regCliente(cod_cli,
nome,telefone,email);
linha = "#" + regCli1.mostraCod() + "\t"
+ regCli1.mostraNome() + "\t"
+ regCli1.mostraTelefone() + "\t"
139
+ regCli1.mostraEmail() + "\n";
gravar(linha);
}catch(FileNotFoundException erro){
System.out.println("Arquivo nao encontrado!");
}catch(Exception erro){
System.out.println("Erro de leitura!");
}
}
public static String ler(int primeiro, int ultimo){
String dados = "";
char[] destino = new char[ultimo - primeiro];
memoria.getChars (primeiro, ultimo, destino, 0);
for (int i =0; i < destino.length;i++){
dados += destino[i];
}
return dados;
}

public static void gravar(String linha){
try{
BufferedWriter saida;
saida= new BufferedWriter(new FileWriter("cliente.txt",true));
saida.write(linha);
saida.flush();
saida.close();
}catch(Exception e){
System.out.println("Erro de gravacao!");
}

}
}
Essa implementação do algoritmo considera que os códigos dos clientes são numerados a partir de 1.
O programa efetua uma busca no contêiner memoria, desde que ele não esteja vazio (verificação
feita na linha 15), para obter o código atribuído ao último cliente cadastrado. Como o arquivo de
dados é um arquivo texto, utilizou-se um marcador (caractere #) que precede todos os números de
código dos clientes. Dessa forma, a posição do último # é obtido com a busca feita linha 16 e o fim do
campo código é obtido com a instrução da linha seguinte. Passamos as posições dos índices de
início e fim para o método ler, que retorna o código. Como esse código está representado por
caracteres, já que se origina de um arquivo texto, o resultado obtido é uma string de caracteres.
Utilizamos o método parseInt da classe Integer para converter a string para inteiro. Como esse código
é o que foi atribuído ao último cliente cadastrado, ele precisa ser acrescido de 1, garantindo a
seqüencia e a unicidade de identificação. Obtêm-se os demais dados por meio da entrada via teclado
e instancia-se um objeto, como feito anteriormente.
Para gravar os dados no arquivo, utilizaremos uma variável linha, do tipo String, que será
passada como parâmetro para o método gravar. A variável linha recebe a concatenação dos diversos
campos do objeto, retornados pelos respectivos métodos e dos caracteres separados, inclusive o
caractere # indicador do número de código do cliente (linha 29).

Atenção: Lembre-se de que o arquivo precisa ser criado antecipadamente, com o mesmo nome
usado no código.


ARQUIVO DE ACESSO ALEATÓRIO – OPERAÇÃO DE CONSULTA

1) Operação de consulta – arquivo de acesso direto.

Solução:

a) algoritmo em pseudocódigo

inicio
tipo
reg_cliente = registro
cod_cli:inteiro;
nome: caracter;
140
telefone:caracter;
email:caracter;
fimregistro;
arq_cliente: arquivo direto de reg_cliente;

auxiliar:reg_cliente;
cliente:arq_cliente;
consulta_codcli:inteiro;
abrir(cliente);
leia(consulta_codcli);
se (consulta_codcli = auxiliar.cod_cli) entao
posicionar(cliente, auxiliar.cod_cli);
senao
escreva(“Registro nao cadastrado”);
fimse;
fechar(cliente);
fim.

Nota: O acesso direto/aleatório ao registro a ser consultado é feito por meio do campo chave.

b) programa em Java

import java.io.*;
class usaCliente2{
static StringBuffer memoria = new StringBuffer();
public static void main(String args[]){
try{
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

BufferedReader arqentrada;
arqentrada = new BufferedReader(new FileReader("cliente.txt"));
String linha="";

while((linha = arqentrada.readLine()) != null){
memoria.append(linha + "\n");
}
System.out.println("Digite o codigo:");
String consulta_codcli = entrada.readLine();
int inicio = -1;
if (memoria.length() != 0){
inicio = memoria.lastIndexOf("#" + consulta_codcli);
if (inicio == -1){
System.out.println("Codigo nao encontrado!!");

}
}else{
System.out.println("O arquivo esta vazio!!!");

}
}catch(FileNotFoundException erro){
System.out.println("Arquivo nao encontrado!");
}catch(Exception erro){
System.out.println("Erro de leitura!");
}
}

}

A implementação da busca direta é feita por meio do código do cliente, resultando da entrada
via teclado, e do caractere associado a esse código (caractere #). A instrução na linha 18 executa
essa operação e o método usado é o mesmo dos casos anteriores: indexOf, que retorna a posição
inicial do dado pesquisado no contêiner de memória e, conseqüentemente, do arquivo originário.
Foram introduzidos dois testes de verificação para garantir a execução correta do programa.
Um deles, na linha 17, se o contênier de memória´
141
está vazio, executando a busca somente no caso de existirem dados, ou seja, o tamanho de
memória obtido pelo método length deve retornar um valor diferente de 0. A outra verificação indica
se a variável inicio recebeu um valor diferente do atribuído quando de sua inicialização (-1),
significando que o código foi encontrado. Caso o código tenha sido encontrado, a variável inicio terá
um valor igual ou maior que 0 e corresponderá à posição de início do campo pesquisado.


ARQUIVO DE ACESSO ALEATÓRIO – OPERAÇÃO DE ALTERAÇÃO

1) Operação de alteração – arquivo de acesso direto.

Solução:

a) algoritmo em pseudocódigo

inicio
tipo
reg_cliente = registro
cod_cli:inteiro;
nome: caracter;
telefone:caracter;
email:caracter;
fimregistro;
arq_cliente: arquivo direto de reg_cliente;

auxiliar:reg_cliente;
cliente:arq_cliente;
altera_codcli:inteiro;
novo_nome, novo_tel, novo_end, novo_email:caracter;
abrir(cliente);
leia(altera_codcli);
se (altera_codcli = auxiliar.cod_cli) entao
inicio
posicionar(cliente, auxiliar.cod_cli);
escreva(auxiliar.nome, auxiliar.telefone, auxiliar.endereco, auxiliar.email);
leia( novo_nome, novo_tel, novo_end, novo_email);
auxiliar.nome = novo_nome;
auxiliar.telefone = novo_tel;
auxiliar.endereco = novo_end;
auxiliar.email = novo_email;
armazenar(cliente, auxiliar);
fim;
senao
escreva(“Registro nao cadastrado”);
fimse;
fechar(cliente);
fim.

A classe regCliente deve ser modificada para a inclusão dos métodos que permitem alteração
dos atributos nome, tel e e-mail; tais métodos devem ser compatíveis com os nomes utilizados no
programa desse exemplo: alteraNome, alteraTel e alteraEmail. Caso você queira atribuir outros
nomes aos métodos, não há problema, desde que eles sejam compatíveis, lembrando a questão das
letras maiúsculas e minúsculas, que não pode ser desprezada, pois Java é case-sensitive.

b) programa em Java

public class regCliente{
private int cod_cli;
private String nome;
private String telefone;
private String email;

public regCliente(int cod, String nom, String telef, String e_mail){
142
cod_cli = cod;
nome = nom;
telefone = telef;
email = e_mail;
}
public int mostraCod(){
return cod_cli;
}
public String mostraNome(){
return nome;
}
public String mostraTelefone(){
return telefone;
}
public String mostraEmail(){
return email;
}
public void alteraNome(String novoNome){
nome = novoNome;
}
public void alteraTel(String novoTelefone){
telefone = novoTelefone;
}
public void alteraEmail(String novoEmail){
email = novoEmail;
}
}


import java.io.*;
class usaCliente3{
static StringBuffer memoria = new StringBuffer();
public static void main(String args[]){
try{
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

BufferedReader arqentrada;
arqentrada = new BufferedReader(new FileReader("cliente.txt"));
String linha="";

while((linha = arqentrada.readLine()) != null){
memoria.append(linha + "\n");
}
System.out.println("Digite o codigo:");
String altera_codcli = entrada.readLine();
int primeiro = -1;
if (memoria.length() != 0){
primeiro = memoria.lastIndexOf("#" + altera_codcli);
if (primeiro != -1){
int fim = memoria.indexOf("\t",primeiro);
int cod_cli = Integer.parseInt(ler(primeiro += 1,
fim));
primeiro = fim + 1;
fim = memoria.indexOf("\t",primeiro);
String nome = ler (primeiro, fim);
int inicio = fim +1;
fim = memoria.indexOf("\t",inicio);
String tel = ler(inicio,fim);
inicio = fim + 1;
fim = memoria.indexOf("\n",inicio);
String email = ler(inicio,fim);

System.out.println(nome + " " + tel + " " + email);

regCliente regCli1 = new regCliente(cod_cli, nome,
tel, email);
System.out.println("Entre com o novo nome:");
143
nome = entrada.readLine();
System.out.println("Entre com o novo telefone:");
tel = entrada.readLine();
System.out.println("Entre com o novo email:");
email = entrada.readLine();
regCli1.alteraNome(nome);
regCli1.alteraTel(tel);
regCli1.alteraEmail(email);
memoria.replace(primeiro, fim, regCli1.mostraNome()
+ "\t" + regCli1.mostraTelefone() + "\t"+ regCli1.mostraEmail());
gravar();
}else{
System.out.println("Codigo nao encontrado!");

}
}else{
System.out.println("O arquivo esta vazio!");
}
}catch(FileNotFoundException erro){
System.out.println("Arquivo nao encontrado!");
}catch(Exception erro){
System.out.println("Erro de leitura!");
}
}
public static String ler(int primeiro, int ultimo){
String dados = "";
char[] destino = new char[ultimo - primeiro];
memoria.getChars (primeiro, ultimo, destino, 0);
for (int i =0; i < destino.length;i++){
dados += destino[i];
}
return dados;
}

public static void gravar(){
try{
BufferedWriter saida;
saida= new BufferedWriter(new FileWriter("cliente.txt",true));
saida.write(memoria.toString());
saida.flush();
saida.close();
}catch(Exception e){
System.out.println("Erro de gravacao!");
}

}
}

O código do cliente a ser pesquisado é atribuído à variável alteraCod_cli e a busca é feita nos
moldes do Exemplos anteriores. Porém, neste caso, utiliza-se uma variável adicional: primeiro, que
armazena a posição inicial do trecho que será alterado quando da atualização do contênier memoria.
A variável primeiro é utilizada durante o percurso pelo registro até que ela represente a posição inicial
do campo Nome, quando então se passa a utilizar a variável inicio em conjunto com a variável fim
para o percurso e a recuperação dos demais campos do registro. Isso se deve ao fato de que se
pretende preservar o campo código do cliente, que é um campo de controle e não pode ser alterado
pelo usuário.
Na linha 18, a variável primeiro recebe a posição inicial do caractere # e o código do cliente,
caso ele tenha sido encontrado. Na linha 19, testa-se a condição de primeiro ter recebido um índice
válido. Na linha 20, efetua-se a busca a partir da posição encontrada e a próxima posição de
tabulação, isolando-se as posições de início e fim do código do cliente. Observe que, para a
passagem de posições para o método ler, a variável primeiro é incrementada em 1, visto que o
campo propriamente dito inicia-se a partir da posição seguinte, que corresponde aos caracteres do
número do código do cliente. Deve-se desprezar o caractere #. Na linha 21, a variável Cod_cli recebe
os dados do código do cliente, que é convertido para inteiro, seu tipo de dado original, como foi
declarado em regAgenda. Na linha 22, a variável primeiro recebe a posição fim + 1, pois o próximo
campo a ser recuperado é o campo Nome, que está na seqüencia. Sua primeira posição equivale a
144
uma posição além do final do campo código. Na linha 25 passa-se a utilizar a variável inicio,
permitindo-se que o valor da variável primeiro permaneça com o valor da posição que lhe foi atribuída
por último. A tabela a seguir apresenta resumidamente um exemplo de possíveis posições que os
campos de um registro poderiam assumir e as variáveis utilizadas para recuperar as posições de
cada campo. Logo a seguir mostramos um teste de mesa aplicado a esse exemplo. A coluna 'LINHA'
corresponde à linha do programa.
É importante destacar que, no momento em que é feita a atualização dos dados no contêiner
da memória, são passadas as posições referentes ao valor das variáveis primeiro e fim, que
correspondem ao intervalo de caracteres que vai de Nome até Email. No exemplo, esse intervalo vai
da posição 3 até a 39.


posição 0 1 2 3 a 8 9 10 a 17 18 19 a 38 39
conteúdo # Código \ t Nome \ t Tel \ t Email \ n
variável primeiro primeiro fim primeiro Fim inicio fim inicio fim
Posições possíveis para os campos de um registro


Linha primeiro inicio fim
16 -1
18 0
20 0 2
22 3 2
23 3 9
25 3 10 9
26 3 10 18
28 3 19 18
29 3 19 39
Teste de mesa


ARQUIVO DE ACESSO ALEATÓRIO – OPERAÇÃO DE EXCLUSÃO

• Operação de exclusão – arquivo de acesso direto.

Solução:

a) algoritmo em pseudocódigo

inicio
tipo
reg_cliente = registro
cod_cli:inteiro;
nome: caracter;
telefone:caracter;
email:caracter;
fimregistro;
arq_cliente: arquivo direto de reg_cliente;

auxiliar:reg_cliente;
cliente:arq_cliente;
consulta_codcli:inteiro;
resposta:caracter;
abrir(cliente);
leia(consulta_codcli);
se (consulta_codcli = auxiliar.cod_cli) entao
145
inicio
posicionar(cliente, auxiliar.cod_cli);
escreva(“Deseja excluir? (Digite S ou N) “);
leia(resposta);
auxiliar.endereco = novo_endereco;
se (resposta = “S”) entao
deletar(cliente,auxiliar);
fimse;
fim;
senao
escreva(“Registro nao cadastrado”);
fimse;
fechar(cliente);
fim.

b) programa em Java

import java.io.*;
class usaCliente4{
static StringBuffer memoria = new StringBuffer();
public static void main(String args[]){
try{
BufferedReader entrada;
entrada = new BufferedReader(new InputStreamReader(System.in));

BufferedReader arqentrada;
arqentrada = new BufferedReader(new FileReader("cliente.txt"));
String linha="";

while((linha = arqentrada.readLine()) != null){
memoria.append(linha + "\n");
}
System.out.println("Digite o codigo:");
String consulta_codcli = entrada.readLine();
int inicio = -1;
if (memoria.length() != 0){
inicio = memoria.indexOf("#" + consulta_codcli);
if (inicio != -1){
int fim = memoria.indexOf("\t",inicio);
int cod_cli = Integer.parseInt(ler(inicio + 1,
fim));
System.out.println("Deseja excluir cliente: " +
cod_cli + "? S/N");
String resposta = entrada.readLine();
if (resposta.equalsIgnoreCase("S")){
fim = memoria.indexOf("\n",inicio);
memoria.delete(inicio, fim +1);
gravar();
}
}else{
System.out.println("Codigo nao encontrado!");

}
}else{
System.out.println("O arquivo esta vazio!");
}
}catch(FileNotFoundException erro){
System.out.println("Arquivo nao encontrado!");
}catch(Exception erro){
System.out.println("Erro de leitura!");
}
}
public static String ler(int primeiro, int ultimo){
String dados = "";
char[] destino = new char[ultimo - primeiro];
memoria.getChars (primeiro, ultimo, destino, 0);
for (int i =0; i < destino.length;i++){
146
dados += destino[i];
}
return dados;
}

public static void gravar(){
try{
BufferedWriter saida;
saida= new BufferedWriter(new FileWriter("cliente.txt",true));
saida.write(memoria.toString());
saida.flush();
saida.close();
}catch(Exception e){
System.out.println("Erro de gravacao!");
}

}
}

Nesse exemplo, fazemos a busca do código do cliente como no exemplo anterior. Obtemos,
assim, o início do registro a ser excluído. Obtemos o código pelo método ler (linha 21), para exibi-lo
no pedido de confirmação ao usuário (linha 22). Se a resposta for igual a “S” (desprezando-se
maiúsculas e minúsculas – linha 25), procede-se à exclusão do registro no contêiner de memória. O
método gravar efetiva a transferência dos dados para o arquivo.


Exemplos diversos - utilizando as classes AWT, swing e event

a) O exemplo abaixo demonstra o código necessário para leitura e gravação de um arquivo texto
chamado arq.txt.


import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;

class Exemplo1Arquivos extends JFrame implements ActionListener{
JLabel L1;
JButton B1,B2,B3;
TextArea TA1;
public static void main(String args[]){
JFrame Janela = new Exemplo1Arquivos();
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
Janela.addWindowListener(x);
Janela.show();
}
Exemplo1Arquivos(){
147
setTitle("Manipulação de arquivos texto");
setSize(500,250);
getContentPane().setBackground(new Color(150,150,150));
getContentPane().setLayout(new FlowLayout());
L1 = new JLabel("Texto a ser gravado");
L1.setForeground(Color.black);
B1 = new JButton("Gravar");
B2 = new JButton("Ler");
B3 = new JButton("Limpar");
B1.addActionListener(this);
B2.addActionListener(this);
B3.addActionListener(this);
TA1 = new TextArea(8,60);
getContentPane().add(L1);
getContentPane().add(TA1);
getContentPane().add(B1);
getContentPane().add(B2);
getContentPane().add(B3);
}

public void actionPerformed(ActionEvent e){
String nome_do_arquivo = "c:/arq.txt";
if(e.getSource() == B3) //limpar
TA1.setText("");
if(e.getSource() == B1){ //gravar
try{
String S = TA1.getText();
byte b[] = S.getBytes();
FileOutputStream out = new
FileOutputStream(nome_do_arquivo);
out.write(b);
out.close();
}catch(java.io.IOException exc){
System.out.println("Erro ao gravar arquivo!");
}
}
if(e.getSource() == B2) { //ler
try{
FileInputStream in = new
FileInputStream(nome_do_arquivo);
byte bt[] = new byte[10240];
in.read(bt);
String S = new String(bt);
TA1.setText(S);
in.close();
}catch(java.io.IOException exc){
System.out.println("Erro ao ler arquivo!");
}
}
}
}


b) O exemplo abaixo apresenta uma forma mais prática de manipular arquivos texto, inserindo uma
caixa de diálogo a partir da classe FileDialog, uma pacote AWT. Quando o usuário pressiona o botão
gravar ou abrir, aparece uma caixa de diálogo semelhante à utilizada pelo windows, por exemplo, no
bloco de notas. Com isso, torna-se possível realizar a escolha do arquivo que será lido ou gravado
pela aplicação. O exemplo ainda outras duas classes (FileWriter e FileReader) que podem ser
usadas para a manipulação de arquivos texto. O código do exemplo é apresentado abaixo:

148



import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;

class Exemplo2Arquivos extends JFrame implements ActionListener{
JLabel L1,L2;
JButton B1,B2,B3;
TextArea TA1;
JTextField T1;
JPanel P1;
FileDialog Fabrir, Fsalvar;
public static void main(String args[]){
JFrame Janela = new Exemplo2Arquivos();
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
Janela.addWindowListener(x);
Janela.show();
}
Exemplo2Arquivos(){
setTitle("Manipulação de arquivos texto");
setSize(500,300);
getContentPane().setBackground(new Color(150,150,150));
getContentPane().setLayout(new FlowLayout());
L1 = new JLabel("Texto a ser editado");
L1.setForeground(Color.black);
L2 = new JLabel("Status");
L2.setForeground(Color.black);
B1 = new JButton("Gravar");
B1.addActionListener(this);
B2 = new JButton("Abrir");
B2.addActionListener(this);
B3 = new JButton("Limpar");
B3.addActionListener(this);
T1 = new JTextField(35);
T1.setForeground(Color.red);
T1.setEditable(false);
P1 = new JPanel();
P1.setLayout(new FlowLayout());
P1.add(L2);
P1.add(T1);
TA1 = new TextArea(8,60);
Fabrir = new FileDialog(this, "Abrir arquivo", FileDialog.LOAD);
Fsalvar = new FileDialog(this, "Salvar arquivo", FileDialog.SAVE);
149
getContentPane().add(L1);
getContentPane().add(TA1);
getContentPane().add(B1);
getContentPane().add(B2);
getContentPane().add(B3);
getContentPane().add(P1);
}

public void actionPerformed(ActionEvent e){
String nome_do_arquivo = "c:/arq.txt";
if(e.getSource() == B3){ //limpar
TA1.setText("");
T1.setText("");
}
if(e.getSource() == B1){ //gravar
try{
Fsalvar.show();
if (Fsalvar.getFile() ==null) return;
nome_do_arquivo = Fsalvar.getDirectory() +
Fsalvar.getFile();
FileWriter out = new FileWriter(nome_do_arquivo);
out.write(TA1.getText());
out.close();
T1.setText("Arquivo gravado com sucesso!");
}catch(java.io.IOException exc){
System.out.println("Erro ao gravar arquivo!");
}
}
if(e.getSource() == B2) { //ler
try{
Fabrir.show();
if (Fabrir.getFile() ==null) return;
nome_do_arquivo = Fabrir.getDirectory() +
Fabrir.getFile();
FileReader in = new FileReader(nome_do_arquivo);
String S="";
int i = in.read();
while(i!= -1){
S = S + (char)i;
i = in.read();
}
TA1.setText(S);
in.close();
T1.setText("Arquivo aberto com sucesso!");
}catch(java.io.IOException exc){
System.out.println("Erro ao abrir arquivo!");
}
}
}
}

ci) O próximo exemplo mostra a leitura e gravação de outros formatos de arquivo (inteiro)..

Métodos para leitura de tipos
primitivos
Métodos para a gravação de
tipos primitivos
readBoolean() writeBoolean()
readDouble() writeDouble()
readFloat() writeFloat()
readInt() writeInt()
readLong() writeLong()
readShort writeShort()



150












import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;

class Exemplo3Arquivos extends JFrame implements ActionListener{
JLabel L1,L2;
JTextField T1, T2, T3;
JButton B1,B2,B3;

public static void main(String args[]){
JFrame Janela = new Exemplo3Arquivos();
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
Janela.addWindowListener(x);
Janela.show();
}
Exemplo3Arquivos(){
setTitle("Gravação de números inteiros");
setSize(280,150);
getContentPane().setBackground(new Color(220,220,220));
L1 = new JLabel("Numero incial : ");
L1.setForeground(Color.black);
L2 = new JLabel("Numero final : ");
L2.setForeground(Color.black);
B1 = new JButton("Gravar");
B1.addActionListener(this);
B2 = new JButton("Limpar");
B2.addActionListener(this);
B3 = new JButton("Somar");
B3.addActionListener(this);
T1 = new JTextField();
T2 = new JTextField();
T3 = new JTextField();
getContentPane().setLayout(new GridLayout(4,2));
getContentPane().add(L1);
getContentPane().add(T1);
getContentPane().add(L2);
getContentPane().add(T2);
getContentPane().add(B1);
getContentPane().add(B2);
getContentPane().add(B3);
getContentPane().add(T3);
}

public void actionPerformed(ActionEvent e){
if(e.getSource() == B2){
T1.setText("");
T2.setText("");
return;
}
if(e.getSource() == B1){
151
try{
int N1 = Integer.parseInt(T1.getText());
int N2 = Integer.parseInt(T2.getText());

String S ="";
FileOutputStream arq = new
FileOutputStream("c:/arq.dat");
BufferedOutputStream buf = new BufferedOutputStream(arq);
DataOutputStream dado = new DataOutputStream(buf);
for(int i = N1; i < N2; i++){
dado.writeInt(i);
}
dado.close();
JOptionPane.showMessageDialog(null, "Arquivo gerado com
sucesso!", "Gravação de arquivo", JOptionPane.INFORMATION_MESSAGE);

}catch(java.io.IOException exc){
JOptionPane.showMessageDialog(null, "Erro ao gravar
arquivo!", "Erro!!", JOptionPane.ERROR_MESSAGE);
}
catch(NumberFormatException exc){
JOptionPane.showMessageDialog(null, "Digite apenas
valores numéricos!", "Erro!!", JOptionPane.ERROR_MESSAGE);
}
}
if(e.getSource() == B3) {
int total =0;
try{
FileInputStream arq = new FileInputStream("c:/arq.dat");
BufferedInputStream buf = new BufferedInputStream(arq);
DataInputStream dado = new DataInputStream(buf);
while(true){
int i = dado.readInt(); //ao terminar gera a
excecao EOF
total = total + i;
}
}catch(java.io.EOFException exc){
T3.setText(""+total);
}
catch(java.io.IOException exc){
JOptionPane.showMessageDialog(null, "Erro ao ler
arquivo", "Erro!!", JOptionPane.ERROR_MESSAGE);
}
}
}
}

152
Exercícios de Fixação - arquivos

v) Dados dois arquivos concebidos seqüencialmente, possuindo as informações descritas nas
fichas esquematizadas, desenvolva um programa que realize uma união deste. Essa
união implica criar um terceiro arquivo no qual constem apenas informações das pessoas
que faziam parte de ambos os arquivos seqüenciais; informações que não possuírem
correspondência não deverão existir no terceiro arquivo.


Nome:

Endereço:

Telefone:




Nome:

Endereço:

Bairro: Cidade: Estado:

CEP: Data nasc:




w) A partir da estrutura do registro construa um programa para administrar os problemas
cotidianos de um clube:

Arquivo de associados: randômico
Chave: código


Nº sócio:

Nome:

Endereço:

Bairro: Cidade: Estado:

Nº dependentes: Data de associação:



• Arquivo de mensalidades: seqüencial



Nº sócio:

Data vencimento: Valor:

Data de pagamento:




153
i) Calcular o número total de possíveis freqüentadores do clube (titulares + dependentes).
j) Apresentar a relação dos associados que aniversariam em determinado mês fornecido.
k) O programa deverá ser capaz de fazer inclusões, alterações e exclusões no arquivo de
associados.
l) Criar uma rotina que modifique a mensalidade para cada sócio, na data e valor
fornecidos.
m) Apresentar a relação dos associados inadimplentes, junto com o respectivo valor total da
dívida, mostrando ao final o valor totalizado de todas as dívidas dos associados.

x) Com o modelo dos registros a seguir, construa um programa para administração de contas
correntes em um banco.

9. Arquivo de correntistas: randômico
10. Chave: conta corrente



Conta corrente:

Correntista:

Data abertura:

Agência:


11. Arquivo de agências: randômico
12. Chave: número agência



Nº agência:

Nome agência:



13. Arquivo de lançamento: seqüencial


Conta corrente:

Data: Valor:

Docto: Histórico:



y) Exibir relatório com a relação com o nome e a quantidade de correntistas de cada
agência.
z) Exibir relatório com um ranking das dez agências com maior montante de saldo.
aa) Calcular o saldo de dado correntista em uma data fornecida.
bb) Exibir um relatório para um período (data inicial e data final) e conta corrente
fornecida. O extrato deve apresentar o saldo anterior e, para cada
lançamento do período, deve apresentar a data, histórico, número do
documento e valor. Ao final deve apresentar o saldo remanescente.

cc) Dados dois arquivos concebidos randomicamente e um, seqüencialmente, descritos através
do diagrama representativo de seus respectivos registros, elabore um programa que tem
por objetivo suprir as necessidades de uma vídeo-locadora:

154
• Arquivo de clientes: randômico
• Chave: código


Código: Telefone:

Nome:

Endereço:

RG: CPF:



• Arquivo de fitas de vídeo: randômico
• Chave: código da fita


Código: Oscar S/N:

Título:

Assunto:

Data de compra: / / Preço:



• Arquivo de movimento: seqüencial



Código fita:

Código cliente:

Qtde. dias fora: Preço:




dd) Consultar quais nomes e assuntos dos filmes um cliente, fornecido, já locou.
ee) Consultar quais clientes (com nome e telefone) locaram determinada fita.
ff) Exibir relatório:
• De gastos de cada cliente;
• Da relação das fitas que cada cliente locou mais de uma vez, com suas
respectivas quantidades;
• De fita por assunto;
• De filmes premiadas com um Oscar.
gg) Consultar quais filmes já premiados com o Oscar um determinado cliente já locou.
hh) Exibir relatório com todas as fitas já locadas, e o total de tempo respectivo em que
cada uma foi locada.
ii) Exibir relatório com as dez fitas mais locadas.
jj) Exibir relatório com a rentabilidade acumulada das duas fitas que mais e das duas
que menos foram locadas.
kk) Exibir relatório de quais fitas que já se pagaram.

• Para os exercícios abaixo, escreva o pseudocódigo e codifique o programa em Java.

155
a) Elabore um cadastro que armazene os dados dos atletas de um clube. Deverão ser armazenados:
nome, idade, altura, sexo, peso e modalidade esportiva. O programa deverá permitir a manipulação
dos dados armazenados. Utilize o método seqüencial.

b) Elabore um programa que possibilite o armazenamento dos dados dos funcionários de uma
empresa ára que seja gerada a folha de pagamento. Deverão ser armazenados: nome do funcionário,
código funcionário, data de admissão, salário bruto, n[umero de dependentes e cargo. O programa
deverá permitir a manipulação das informações e possuir uma opção para calcular o salário líquido de
cada funcionário. Utilize o método randômico.

• Elabore um controle acadêmico que permita:

• o cadastro dos dados acadêmicos que permita;
• o cadastro dos dados pessoais dos alunos;
• o cadastro das notas associadas à grade do aluno;
• a manipulação dos dados com controle de senha;

Crie um menu de opções e utilize todos os recursos aprendidos até agora. Utilize o método
randômico. O programa deverá verificar se o aluno foi aprovado ou reprovado nas disciplinas,
levando -se em consideração que a média de aprovação é de 7.0 sem exame e de 5.0 com exame.

• Elabore um controle de estoque que permita:

3. cadastrar novos produtos;
4. manipular as informações cadastradas;
5. acompanhar a quantidade de produtos disponíveis;
6. consultar o nome do produto, a quantidade disponível e o preço;

Faça um menu de opções e utilize todos os recursos aprendidos. Utilize o método sequencial.

































156

Programação Orientada a Objetos

Conceitos Preliminares

Introdução

termo orientação a objetos pressupõe uma organização de software em termos de coleção de
objetos discretos incorporando estrutura e comportamento próprios. Esta abordagem de
organização é essencialmente diferente do desenvolvimento tradicional de software, onde
estruturas de dados e rotinas são desenvolvidas de forma apenas fracamente acopladas.
Neste capítulo, as primeiras noções de orientação a objetos serão introduzidas. Esta breve
visão geral do paradigma permitirá entender melhor os conceitos associados à programação
orientada a objetos e, em particular, às construções da linguagem Java
TM
.

O processo de Abstração

Abstração consiste de focalizar nos aspectos essenciais inerentes a uma entidade e ignorar
propriedades “acidentais”. Em termos de desenvolvimento de sistemas, isto significa concentrar-se no
que um objeto é e faz antes de se decidir como ele será implementado. O uso de abstração preserva
a liberdade para tomar decisões de desenvolvimento ou de implementação apenas quando há um
melhor entendimento do problema a ser resolvido.
Muitas linguagens de programação modernas suportam o conceito de abstração de dados;
porém, o uso de abstração juntamente com polimorfismo e herança, como suportado em orientação a
objetos, é um mecanismo muito mais poderoso.
O uso apropriado de abstração permite que um mesmo modelo conceitual (orientação a
objetos) seja utilizado para todas as fases de desenvolvimento de um sistema, desde sua análise até
sua documentação.

Operações de abstração

Um programa de computador consiste na representação do modelo de resolução de um
problema.
As operações de abstração mostram como o ser humano mentaliza, organiza e modela o
mundo ao seu redor. Ao pensarmos o mundo real, as seguintes operações básicas podem ser
aplicadas:

7. Classificação/instanciação
8. Generalização/especialização
9. Agregação/decomposição
10. Associação

ClassificaçãoJInstanciação

Cada entidade tem determinadas características que a identificam.

Uma categoria define o conjunto de características que devem ser apresentadas por um
objeto, para que o mesmo possa ser classificado como pertencente a mesma. Assim, categoria é o
mesmo que classe. Concluímos então que cada objeto tem sua própria existência e características, e
todos os objetos que apresentam as mesmas características são definidos como pertencentes a uma
mesma classe.
Quando, em um grupo de objetos, identificamos um conjunto de características que são
comuns a todos, e a partir desta identificação, definimos a classe a qual pertencem todos estes
objetos, estamos fazendo uma operação de classificação. Por outro lado, quando construímos um
objeto contendo todas as características de determinada classe, estamos fazendo uma operação de
instanciação. A operação de instanciação ocorre sempre que criamos uma entidade de determinada
classe.
O
157
Uma classe define o conjunto de características dos objetos pertencentes a ela, isto é, especifica que
ações podem ser executadas pelos objetos, como estes objetos são compostos, quais
relacionamentos decorrentes desta composição, etc.
O processo de identificação da pertinência de um objeto a uma determinada classe pode ser
caracterizado, se ocorrer uma relação do tipo “é um” entre o objeto e a classe.




















Classificação. Operação que tem por objetivo, através da análise das características de um
objeto, definir que classe o mesmo pertence.

Instanciação. Operação que, dada uma determinada classe, define (ou cria) um objeto
pertencente a esta classe.


GeneralizaçãoJEspecialização

Sempre que, a partir de uma classe mais genérica, se definir uma classe mais especializada,
está se fazendo uma operação de Especialização. A classe mais especializada mantém (herda) todas
as características da classe mais geral e, adicionalmente, define características específicas.
De maneira inversa, podemos a partir de um grupo de classes, identificar características que
são comuns a todas e definir com estas características comuns, uma nova classe, a qual será mais
geral. A esta operação denomina-se Generalização.
A identificação da existência de uma generalização/especialização fica caracterizada, se
ocorrer a relação “é um tipo de” entre a classe mais especializada e a mais geral.

Generalização. Operação de análise de um conjunto de classes que identifica características
comuns a todas, tendo-se por objetivo a definição de uma classe mais genérica, a qual especificará
estas características comuns.

AUTOMÓVEL

(tem motor; porta-malas; placa;
n.chassis; ano; modelo;
proprietário; formato; monobloco;
etc)

Classe
(categoria)
Vectra do
José
Fusca da
Maria
Objeto
(entidade)
Instanciação Classificação
158
Especialização. Operação em que a partir de uma classe, identifica-se uma ou mais subclasses,
cada uma especificando características adicionais, em relação à classe mais geral.




Para representarmos a operação de generalização/especialização, usamos uma linha
contínua ligando a classe mais geral à classe mais especializada, e com uma seta apontando para a
classe mais geral.


















AgregaçãoJDecomposição

Especialização
Generalização
VEÍCULO AUTOMOTOR

(tem motor; porta-malas; placa;
n.chassis; ano; modelo;
proprietário; formato; monobloco;
etc)

(movimenta-se; pára; etc.)
AUTOMÓVEL

porta-malas; formato
monobloco.)


CAMINHÃO

(carroceria; n. de eixos; carga
máxima)


Classe mais geral



Classe mais específica



159
Um objeto constitui-se em “alguma coisa” que apresenta determinadas características, as
quais estão definidas em sua classe. Estas características podem ser divididas em dois grupos:
características de composição e características de ação.
As características de ação são aquelas que dizem respeito aos serviços que o objeto pode
executar.
As características de composição dizem respeito a constituição do objeto.
Um objeto pode ser composto por outros objetos. Quando unimos um conjunto de objetos,
com o objetivo de formamos um novo objeto, estamos realizando uma operação de agregação. Se,
analisando um objeto, isolamos cada um de seus componentes, estamos fazendo uma
decomposição.
O diagrama que expressa as operações de agregação/decomposição também pode ser
chamado de Diagrama Todo/Parte. A operação de agregação é caracterizada pela existência da
relação “é composto por” ou “é um agregado de”.
Para mais facilmente visualizarmos uma operação de decomposição, pode-se procurar pela
existência da relação “é parte de”.

160

Decomposição


Agregação






































Para representar o processo de agregação/decomposição usamos uma linha contínua
juntamente com um losango unindo as duas classes envolvidas. O losango deve ser colocado junto à
classe relativa à entidade que representa o todo (classe agregadora).



Placa

(cidade; estado; código
alfabético; código numérico)


Motor

(potência; cilindrada;
combustível; etc...)

(acionar; desligar; ...)






Vectra do Mauro
Placa do
Vectra do
Mauro
Porta-malas
do Vectra do
Mauro
Motor do
Vectra do
Mauro
Automóvel

(tem porta-malas; tamanho
pequeno; formato monobloco;
etc...)

Veículo automotor

(tem motor;placa;
ano;n.chassis; modelo;
proprietário; etc...)

(movimenta-se; pára; etc...)
Porta-malas

(capacidade; ...)


Classe agregadora Classe agregada
161

Associação

Uma associação consiste na descrição genérica de uma ou mais ligações entre as entidades.
Em uma associação, as entidades que apresentam ligação existem independentemente uma da
outra. Veja que diferentemente de uma associação, quando fazemos uma operação de agregação
estamos modelando entidades que são compostas por outras entidades. A agregação/decomposição
implica em acoplamento forte entre as entidades envolvidas. A existência de agregação fica
caracterizada, quando uma entidade é parte integrante de outra entidade, não fazendo sentido a
existência de uma, sem a existência da outra. Já na operação de associação, isto não acontece, isto
é, as entidades envolvidas apresentam independentes.
Assim, se para realizar determinada tarefa, uma entidade necessitar de outra entidade, e
ambas entidades apresentarem existências independentes, ou seja, uma não é parte integrante da
outra, então podemos definir a existência de uma associação entre suas respectivas classes.
























Exercícios de Fixação - Conceitos básicos de OO

1. O que você entende por resolver um problema?
2. Defina abstraçao
3. Fale sobre a relatividade do processo de abstraçao. Dê exemplos.
+. O que é uma entidade ou objeto?
5. O que é uma classe?
6. Quais as operaçoes de abstraçao?
7. Quais as diferenças entre agregaçao e associaçao?
8. construa um diagrama mostrando as operaçoes de abstraçao realizadas para cada
um dos dominios a seguir:
- imóveis;
- estudantes;
- computadores.
Professor Aluno
Associação
Professor
José
Aluno
Joaquim
162

O Modelo de Objetos

Conceitos Fundamentais

O conceito de orientação a objetos é fundamentado nessa estrutura, pois possui quatro pilares
mestres, que são: classe, objeto, atributos e métodos, os quais serão rapidamente expostos em
seguida, juntamente com conceitos que norteiam seu uso.

Classes e Objetos

A resolução de um problema passa pela análise de uma determinada situação real, tendo-se
por objetivo a construção de um modelo que represente esta situação real. Este modelo deverá,
considerar os objetos (entidades) que integram o problema. Pode ser considerado como objeto,
qualquer “coisa” que tenha algum significado dentro do contexto do problema, seja ela concreta ou
abstrata.

Classe é o conjunto de objetos que se define pelo fato de tais objetos, e só eles, terem uma
ou mais características em comum.

Pode-se observar que um objeto pode ser qualquer coisa que apresente alguma utilidade ou
sirva a algum propósito. Cada objeto consiste em uma entidade com identidade própria. Assim,
mesmo que a partir de uma observação simples se diga que dois objetos são iguais, tem-se dois
objetos distintos. Se analisarmos dois exemplares deste texto, por exemplo, veremos que se
constituem em dois objetos distintos, apesar de terem a mesma quantidade de páginas, mesmo
conteúdo, etc.

Objeto é uma ocorrência específica de uma classe, ou seja, uma instância de uma classe ou
um elemento específico do mundo real.

Em termos de programação podemos definir um objeto como sendo a abstração de uma
entidade do mundo real, que apresenta sua própria existência, identificação, características de
composição e que tem alguma utilidade, isto é, pode executar determinados serviços quando
solicitado.

Atributo

É o conjunto de características específicas de um objeto. Em sua obra (AMBLER, 1997),
define o atributo comparando-o a um elemento de dados definido em um registro.
O conteúdo de um atributo pode ser público ou privado. Quando privado, ocorre o efeito de
ocultamento de informações de um atributo de uma determinada classe ou objeto, o qual não será
visualizado ou utilizado na forma de acesso público.

Método

O conceito de método está associado à forma como um determinado atributo será alterado,
ou seja, método é a característica que possibilita alterar a funcionalidade de um atributo. P conceito
de método num nível mais amplo possibilita efetuar op controle lógico que refletirá uma determinada
ação (designar um comportamento) sobre o objeto e, por conseguinte, a sua classe também, ou
melhor, sua operação.
Em sua obra (AMBLER, 1997), afirma que um método pode ser visto como uma função
(funcionalidade) de um objeto, pois é através dos métodos que se torna possível modificar os
atributos de um objeto, ou seja, um método é algo que estabelece o que realmente um objeto faz.





163
Termos empregados na POO

É de fundamental importância conhecer não só os termos empregados, mas saber fazer a
devida distinção entre eles. A tabela seguinte apresenta um pequeno resumo dos termos utilizados
na definição dos quatro pilares indicados. A referida tabela possui o termo, descrição rápida de seu
significado e um possível exemplo de sua aplicação, de acordo com o exposto em (AMBLER, 1997 e
FURLAN,1998).


TEPhD


0ESCPIÇÅD


EXEhPLD

Abstração 0efInIção da Interface de uma classe e de
seus elementos.
A classe mamiferos possuI como
elementos o conjunto de objetos de
várIas espécIes, classIfIcadas segundo sua
familIa.
Acoplamento |edIda para avalIar o quanto duas ou maIs
classes se encontram conectadas.
D objeto ser humano e o objeto cavalo
possuem como pontos de conexão a
capacIdade de respIrarem e andarem.
Agregação CapacIdade de representar um
relacIonamento "faz parte de".
D objeto cavalo para o objeto humano
(num cenárIo rural) faz parte de sua vIda
e muItas vezes de sua subsIstëncIa.
AtrIbuto CaracteristIcas especifIcas de uma classe ou
objeto.
D objeto ser humano possuI nome, sexo,
data de nascImento.
Classe Conjunto de objetos que possuem uma ou
maIs caracteristIcas comuns, podendo ser
abstratas ou concretas.
Dp ser humano pertence à classe
bIologIca mamiferos.
Coesão CapacIdade de medIr o quanto de uma
determInada classe ou método fazem
sentIdo.
D ser humano possuI como atrIbuto vocal
a capacIdade de falar, enquanto um
objeto cavalo não.
Colaboração CapacIdade de uma determInada classe
trabalhar em conjunto com outra classe a
fIm de desempenharem suas funções em
conjunto.
A classe mamiferos vIve em função da
classe natureza, formando um so
ecosIstema.
Encapsulamento 0efInIção de como Implementar atrIbutos e
métodos de uma classe.
Efetuar a operação do cálculo da Idade a
partIr do atrIbuto data de nascImento
que é herdado de uma classe paI.

TEPhD


0ESCPIÇÅD


EXEhPLD

EspecIfIcação CapacIdade de acrescentar ou modIfIcar
atrIbutos e métodos herdados por uma
classe fIlho a partIr de sua classe paI.
A classe paI possuI como atrIbuto
profIssão o método de exercer medIcIna.
No entanto, a classe fIlho como atrIbuto
profIssão o método engenharIa.
Estado SItuação do comportamento de um
determInado objeto em um determInado
momento.
D objeto ser humano encontra·se em
hora de almoço.
Evento CaracteristIcas de uma ocorrëncIa de nivel
sIgnIfIcatIvo do mundo real que deve ser
tratada.
D objeto ser humano possuI como método
de ação trabalhar apos o almoço.
CeneralIzação CaracteristIca de compartIlhamento por
classes de atrIbutos ou métodos comuns.
A classe fIlho e a classe paI possuem
como atrIbuto profIssão a mesma
atIvIdade economIca.
Herança CapacIdade de uma classe fIlho (subclasse)
herdar um ou maIs atrIbutos e métodos de
uma ou maIs classes (classe paI).
D objeto fIlho herda do objeto paI a cor
azul e do objeto mãe cabelo lIso.
ÌnstâncIa
de classe
D mesmo que objeto, que é uma ocorrëncIa
especifIca de uma determInada classe.
D objeto ser humano é uma InstâncIa da
classe mamiferos.
|ensagem CapacIdade de comunIcação dIrecIonal
entre objetos no sentIdo de Invocar certa
operação.
Ìnformar o atrIbuto do objeto ser humano
que possua o atrIbuto nome x.
|étodo É a caracteristIca que possIbIlIta alterar a
funcIonalIdade de um determInado atrIbuto
de um objeto.
D objeto ser humano possuI como
atrIbuto profIssão a função vendedor. Ao
ser promovIdo para a função gerente, ele
muda a funcIonalIdade de seu atrIbuto
profIssão.
164
Dbjeto Fepresentação de um elemento do mundo
real, InstâncIa de uma classe, que pode ser
persIstente ou transItorIa.
Ser humano, cavalo, baleIa e golfInho dão
uma InstâncIa da classe mamiferos.
Dcultamento
de Informações
CapacIdade de restrIngIr o acesso externo
dos atrIbutos de um determInado objeto.
D objeto ser humano possuI os atrIbutos
de profIssão e escolarIdade
desconhecIdos.
Dperações LogIca de operação contIda em uma
determInada classe com o objetIvo
desIgnar·lhe um determInado
comportamento.
Efetuar cálculo da Idade de um IndIviduo,
a parIr do atrIbuto data de nascImento de
um objeto ser humano pertencente à
classe mamiferos.
PolImorfIsmo CapacIdade de InteragIr atrIbutos de um
objeto sem a necessIdade de conhecer seu
tIpo. CapacIdade que um objeto possuI de
mudar sua forma para outra forma.
D objeto ser humano assume dIferentes
fases de desenvolvImento ao longo de sua
vIda: InfantIl, pré·adolescente,
adolescente, adulto e ancIão.










165
Java e o modelo de objetos

ara construir estruturas de extrema complexidade a natureza criou células, tecidos, órgãos,
sistemas e organismos. Em uma maior escala estes organismos interagem com outros
organismos criando populações e ecologias. A compartimentalização e gerência de
complexidade obtida através da modularização dos sistemas biológicos (células, tecidos, órgãos,
organismos, etc) torna possível o elevado grau de equilíbrio presente na infinidade de sistemas
biológicos formados por milhares de indivíduos.
De forma similar e em menor escala o software é um artefato extremamente complexo. São
necessários diversos níveis de organização para que qualquer software não trivial possa funcionar
adequadamente. Estas técnicas de organização de software são resultados de 50 anos de evolução
da computação. Se comparada com os organismos vivos, poderíamos dizer que a Engenharia de
Software ainda está no Pré-Cambriano.
O modelo de objetos é uma metáfora de desenvolvimento de software baseada na construção
de elementos computacionais que mimetizam objetos do mundo real.
As diversas realizações do modelo de objetos, presentes nas dezenas de métodos e
metodologias orientadas a objeto que são difundidas nos ambientes de programação são resultado
da contribuição de muitas pessoas durante diversos anos.
Tudo começou com o Modelo Computacional de Von Neumann.
O modelo de Von Neumann, datado dos anos 40, ainda amplamente utilizado para mostrar
conceitos de programação de computador.













Os principais pontos a destacar no modelo são:

ódigo e dados compartilham a memória de uma forma homogênea.

nstruções podem ser vistas como dados e vice-versa.

ão existe a noção clara de tipo de dados.

ão se falava em Engenharia de Software.


Muitos anos depois, a grande quantidade de erros cometidos durante o planejamento e
codificação dos programas, que começavam a crescer de tamanho, provocou o surgimento de várias
propostas de organização de gerência e desenvolvimento de software. A nível de programação o
movimento de maior sucesso foi a programação estruturada.








P

CÓDIGO

DADOS
MEMÓRIA UNIDADE CONTROLE
PROCESSADOR
166
Programação Estruturada

Grandes disparidades de custos, prazos e qualidade com relação ao planejamento e
implementação de software nos anos 60 e 70 causaram a adoção do termo Engenharia de
Software.
A Programação Estruturada foi a primeira resposta bem sucedidad à Engenharia de Software
no escopo de programação. Embora hoje pareça simplista a aplicação dos conceitos de
SEQÜÊNCIA, DESVIO E LAÇO, representou um grande avanço para a organização da programação
em pequena escala.










SEQÜÊNCIA DESVIO LAÇO


A programação estruturada:

mpôs ordem ao código “espaghetti”, reinante na época, facilmente criado em
programas escritos em COBOL e FORTRAN, que não tinham mecanismos de
estruturação (modularização) bem definidos.

ão enfatiza a estruturação dos dados.


Depois de solucionado o problema do código “espaghetti” percebeu-se que o código é a parte
de um programa mais sujeita a variações. Começo-se a avaliar quais eram os elementos que sofriam
maior variação quando da mudança dos requisitos do software.
Software é um artefato bastante flexível, e por isto mesmo sujeito a constante modificações.
Todo software é solução para um problema específico, e sua realização se dá pela construção de
trechos de código e estruturas de dados. A figura abaixo dá uma idéia geral do impacto causado no
código e nos dados de um programa, quando se modificam os requisitos de um sistema em geral.



Percebeu-se que pequenas variações nos requisitos do sistema implicam em grandes
variações no código, enquanto que esta variação de requisitos produz menos impacto nos dados
deste mesmo programa.
A Programação Estruturada é uma metodologia baseada principalmente na estruturação do
código. Por ser baseada na parte mais sujeita a variações. A programação estruturada não confere
alto grau de estabilidade ao software. Esta conclusão levou à criação de metodologias de
PEÇUISITDS PEÇUISITDS
CD0ICD
0A0DS
167
desenvolvimento de programas baseadas na modelagem dos dados. O mais bem sucedido foi o
Modelo Entidade-Relacionamento.
O Modelo Entidade-Relacionamento foi proposto por Peter Chen, em 1970. É uma notação
para descrição e desenvolvimento de sistema de informação baseada na modelagem sem6antica de
dados. Obteve grande sucesso principalmente junto à comunidade de desenvolvedores de bases de
dados.
A figura abaixo mostra parte de um pequeno modelo de um sistema de controle bancário,
descrito utilizando-se o MER.


O Modelo E-R, principalmente na sua forma estendida (chamada de Modelo E-R Estendido).
Que permite modelar herança, entre outras coisas, é um dos precursores mais próximos do modelo
de objetos, sob o ponto de vista de ferramenta para modelagem de sistemas.

A evolução das técnicas de programação foi acompanhada, em paralelo, pelo
desenvolvimento de novas linguagens e estruturas sintáticas/semânticas que facilitam a
representação destes conceitos no código. Examinaremos como se deu esta evolução das
linguagens de programação.
A evolução dos conceitos e modelos de programação teve efeito direto na re-estruturação das
linguagens de programação. Isto se reflete basicamente na distribuição topológica dos dados e
códigos na memória do computador. A figura abaixo mostra como se deu a evolução desta
estruturação na várias gerações de linguagem de programação no tempo.





















BANCO
CLIENTE CONTA
ATENDE
GERENCIA
MOVIMENTA
1ª/2ª GERAÇÃO DE LINGUAGENS
SUBPROGRAMAS
DADOS
168














Módulos










2ª/3ª GERAÇÃO DE LINGUAGENS
FINAL DA 3ª GERAÇÃO DE
LINGUAGENS
PEQUENAS/MÉDIAS APLICAÇÕES
ORIENTADAS A OBJETO
CD0ICD
0A0DS
169


Pode-se perceber que a tendência evolutiva das linguagens tem sido aglutinar código ao
redor de pequenas regiões de dados na memória dos computadores. Este é o princípio básico de
implementação das linguagens orientadas a objetos.

Os principais elementos da estruturação topológica das linguagens orientadas a objetos
refletem um pequeno conjunto de definições, as quais formam o núcleo do modelo de Objetos.


GRANDES APLICAÇÕES
ORIENTADAS A OBJETO
170
O Modelo de Objetos

Originalmente concebido para construir aplicações de simulação utilizando a linguagem
Simula (1967), o Modelo de Objetos representa o mais destacado avanço da tecnologia de
programação e desenvolvimento de software da atualidade. Hoje, o modelo não é o único e existem
efetivamente milhares de pessoas trabalhando no seu uso e aperfeiçoamento. São muitos, e algumas
vezes, mal-interpretados, os conceitos e terminologias adotadas nas diversas variações do modelo.
Felizmente é possível começar a utilizar o modelo de objetos com um pequeno subconjunto
destes elementos. Estes elementos serão apresentados juntamente com os comandos e expressões
de Java que os representam. Eles são:
• Objetos, métodos e variáveis
• Agregação e mensagens
• Classes e Instâncias
• Herança
• Sobrecarga de operadores e Polimorfismo


Objetos, métodos e variáveis

Um OBJETO é um pacote de software contendo dados e procedimentos (código)
relacionados. Os procedimentos são chamados MÉTODOS. Os dados dos objetos são chamados
VARIÁVEIS ou COMPONENTES DO ESTADO.


Posteriormente veremos que em Java a interface de um objeto é o conjunto dos seus
métodos e dados que são declarados public e/ou protected. Quando a declaração de métodos e/ou
variáveis de um objeto for precedida pela cláusula private nenhum outro objeto, além do seu "dono",
tem acesso a estes componentes.












Agregação

As variáveis de um objeto são também objetos. Deste modo, o estado de um objeto é
formado por outros objetos. Objetos podem ser simples, como por exemplo uma String, ou
complexos, por exemplo um Banco. A idéia de que o estado de um objeto é composto por outros
objetos é bastante utilizada no mundo real e é chamada (no modelo de objetos) de AGREGAÇÃO.



Dbjeto
hétodos
varIáveIs
CIIente
171





























Mensagens

Objetos recebem mensagens de outros objetos através de sua interface. Quando um objeto x
invoca um método sobre um outro objeto y, dizemos que ocorre o envio de uma mensagem, de x
para y. Uma mensagem é composta pelo nome do método invocado sobre o objeto, do objeto que
receberá a mensagem, e de um conjunto opcional de parâmetros. Na figura abaixo tempos uma
representação de um objeto cliente enviando uma mensagem para um objeto conta bancária. O nome
da mensagem é debite, e tem dois parâmetros: R$ 100 e 7/5/95.






Em Java este envio de mensagem poderia corresponder ao trecho de código abaixo.
class Cliente {
...
public void envieMensagem() {
Nome, cpf,
contas
Conta
bancárIa
SaIdo ant., saIdo
atuaI, transações
Conta
bancárIa
SaIdo ant., saIdo
atuaI, transações
0ata,
vaIor
Transação
0ata,
vaIor
Transação
0ata,
vaIor
Transação
0ata,
vaIor
Transação
0ata,
vaIor
Transação
CIIente
Conta
ßancárIa
0ebIte(P$ 100, 7l5lº5)
0ebIte
172
...
contaBancaria.debite(100, new Date(5, 7, 1996));
...
}
...
}
Classes e instâncias

Para tratar da criação e atualização de várias ocorrências de um mesmo tipo objeto se faz útil
a noção de CLASSE de objetos. Classes são "moldes" que definem os métodos e as variáveis a
serem incluídas em um tipo particular de objeto. A classe é responsável pela criação dos objetos.
Podemos estabelecer uma analogia de processos com objetos e programas com classes. Uma classe
é um "molde" a partir do qual criamos objetos, do mesmo modo que podemos ver várias ocorrências
de um mesmo tipo de processo criadas a partir de um único programa. Os objetos que pertencem a
uma classe são chamados de INSTÂNCIAS desta classe e contêm valores particulares para as suas
variáveis. As variáveis de um objeto são chamadas, à la Smalltalk, de VARIÁVEIS DE INSTÂNCIA.
Abaixo temos esqueletos de código em Java que definem as classes: Cliente, ContaBancaria e
Transacao, as quais servem para criar os objetos representados na figura anterior.

class Cliente {
public String nome;
public int cpf;
private ContaBancaria[] contas;
...
}

class ContaBancaria {
private int saldoAnterior;
private int saldoAtual;
Transacao[] transacoes;
...
}

class Transacao {
public int valor;
public Date data;
...
}



Herança

Herança é um mecanismo através do qual uma classe de objetos pode ser definida como
caso especial de uma classe mais geral. Casos especiais de uma classe são chamados de
SUBCLASSES. A classe mais geral é chamada de SUPERCLASSE. Refinando nossa aplicação de
Controle Bancário, poderemos definir tipos mais específicos de contas bancárias: conta corrente e
conta de poupança.





SaIdo ant., saIdo
atuaI, transações
Conta
bancárIa
herança
herança
173








Abaixo temos esqueletos de código em Java que descrevem como se faz essa estensão de
classes.
class ContaCorrente extends ContaBancaria {
...
}

class Poupanca extends ContaBancaria {
}
O fato das classes ContaCorrente e Poupanca herdarem de ContaBancaria implica em dizer
que TODOS os componentes não privados (isto é, todas as variáveis e métodos que não são
precedidos pela cláusula private na sua declaração) definidos na classe ContaBancaria estão
automaticamente definidos para as classes ContaCorrente e Poupanca.


Sobrecarga de Operadores e Polimorfismo

Polimorfismo é uma técnica sofisticada de construção de programas, que permite que objetos
sejam tratados de forma homogênea e segura, simplificando a construção de código. Sobrecarga é
bastante similar a polimorfismo, embora mais simples de compreender. Vejamos o exemplo que se
segue. Suponha novamente o Controle de Contas Bancárias. Refinando mais ainda nossa aplicação
definamos dois tipos especiais de transacão: transação de débito e transação de crédito. Em ambos
os tipos de transação, inclusive na superclasse Transacao, está definido o método processe(int).
processe recebe como parâmetro um inteiro e devolve outro valor inteiro, correspondendo ao valor
que recebeu, adicionado ou subtraido do valor da transação, conforme seja seu tipo (trasação de
débito ou de crédito). Os esqueletos de código abaixo mostram trechos da implementação do método
nas duas subclasses (mostramos também pedaços da declaração da classe transação, onde temos
declarada a variável valor.

abstract class Transacao {
int valor;
...
public abstract int processe(int valorAnterior);
}

class TransacaoCredito extends Transacao {
...
public int processe(int valorAnterior) {
return valorAnterior + valor;
}
}
Conta
corrente
Poupança
Conta
EspecIaI
Juros acumuIados,
taxa juros
LImIte,
taxa juros
herança
174

class TransacaoDebito extends Transacao {
...
public int processe(int valorAnterior) {
return valorAnterior - valor;
}
}
A sobrecarga de operadores pode ser observada na implementação do método atualizeSaldo,
presente na classe ContaBancária. A computação do novo saldo atual da conta é obtida somando-se
ou subtraindo-se do saldo anterior os valores das transacoes recebidas, conforme sejam de crédito
ou débito, respectivamente.
Como cada subclasse de transação tem uma implementação distinta para o método
processe, a implementação do método atualizeSaldo pode ser mais simples. Observe o trecho de
código abaixo:
class ContaBancaria {
private int saldoAnterior;
private int saldoAtual;
Transacao[] transacoes;
...
public void atualizeSaldo() {
int saldoCorrente = saldoAnterior;
for (int i = 0; i < transacoes.length; i++) {
saldoCorrente = transacoes[i].processe(saldoCorrente);
}
saldoAtual = saldoCorrente;
}
...
}
Embora possa parecer à primeira vista que a sobrecarga complicou a compreensão do
código, o uso rotineiro e organizado da sobrecarga e do polimorfismo é um dos maiores
investimentos na redução de tamanho dos programas orientados a objetos.
O conceito de polimorfismo é ligeiramente mais sofisticado que sobrecarga e será esclarecido
mais adiante.
175

Introdução às classes

lasse é a construção lógica que define o formato e a natureza de um objeto e, por isso a
linguagem Java é definida sobre esta construção. Qualquer implementação feita tem que estar
encapsulada em uma classe.
Uma classe define um novo tipo de dados. Uma vez definida, a classe pode ser utilizada para
criar objetos do novo tipo de dados. Assim, uma classe pode ser vista como sendo um modelo para
objetos e um objeto como sendo uma instância de uma classe.

Definição de uma Classe em Java

Ao definir uma classe é declarada sua natureza e sua forma. Isto é feito especificando os
dados e o código que manipula estes dados. O código de uma classe define a interface para os seus
dados.
A declaração de uma classe em Java utiliza a palavra-chave class. O formato geral para se
definir uma classe é
class nome_da_classe {
tipo variável_de_instância1;
tipo variável_de_instancia2;
.
.
.
tipo variável_de_instânciaN;

tipo nome_do_metodo1 (lista — de — parâmetros){
//corpo_do_método
}
tipo nome_do_metodo2 (lista — de — parâmetros){
//corpo_do_método
}
.
.
.
tipo nome_do_metodoN (lista — de — parâmetros){
//corpo_do_método
}
}
Os dados ou variáveis definidas dentro de uma classe são chamadas de variáveis de
instância. O código de uma classe fica encapsulado cm métodos. Os métodos e variáveis definidas
em uma classe são chamados de membros da classe. Na maioria das vezes, as variáveis de
instâncias são acessadas e manipuladas através de métodos. Desta maneira, são os métodos que
definem como os dados serão utilizados.

Criando a Classe Caixa
Neste primeiro exemplo, será definida uma classe para representar uma caixa. A classe
Caixa define três variáveis de instância: largura, altura e profundidade. Neste ponto ainda não será
definido nenhum método para a classe Caixa.

class Caixa{
double largura;
double altura;
double profundidade;
}

Agora novos objetos do tipo Caixa podem ser criados a partir desta definição. A simples
declaração de um objeto não é o suficiente para que este seja criado e possa ser acessado. Para
C
176
criar um objeto é necessário que seja utilizado o operador new e o construtor da classe que aloca a
memória necessária para o objeto. Portanto a criação de um objeto deve ser feitai da seguinte forma:

Caixa minhaCaixa; // cria apenas uma referencia para o objeto
minhaCaixa = new Caixa(); // cria efetivamente o objeto

Para acessar uma variável de instância de uma classe basta utilizar o operador ponto(.) entre
o nome do objeto e a variável de instância desejada. A seguir é mostrado um exemplo completo de
um programa que utiliza a classe Caixa definida:

/* exemplo de um programa que usa a classe Caixa
salve em um arquivo chamada CaixaDemo.java */

class Caixa {
double largura;
double altura;
double profundidade;
}

// esta classe utiliza um objeto da classe Caixa
class CaixaDemo {
public static void main(String args[]) {
Caixa minhaCaixa;
double volume;

// cria o objeto minhaCaixa
minhaCaixa = new Caixa();

//atribui valores as variáveis de instância minhaCaixa.largura
= 12;
minhaCaixa.altura = 15;
minhaCaixa.profundidade = 23;

// calcula o volume de minhaCaixa
volume = minhaCaixa.largura * minhaCaixa.altura *
minhaCaixa.profundidade;

System.out.println("0 volume e " + volume);
}
}

O arquivo que contém este programa deverá ser salvo com o nome de CaixaDemo.Java,
pois a classe que contém o método main() é a classe chamada CaixaDemo.
Ao compilar serão gerados os arquivos Caixa.class e CaixaDemo.class. Para compilar o
exemplo, digite:
javac CaixaDemo.java
Para executar o programa é necessário chamar o interpretador Java da seguinte
java CaixaDemo

A saída do programa será
O volume e 4140.0

Introdução aos métodos
Conforme mencionado anteriormente, as classes consistem basicamente de variáveis de
instância e de métodos. Os métodos necessitam uma maior atenção pois em Java eles possuem
bastante flexibilidade e podem ser complexos. O formato geral de um método é:

tipo nome_do_metodo(lista_de_parâmetros) {
177
//corpo_do_método
}

O tipo de dados retornado pelo método é especificado por tipo. Este pode ser qualquer tipo
incluindo classes criadas pelo programador. Caso o método não retorne nenhum valor, é necessário
explicitar esta condição utilizando o tipo void. O nome do método é especificado por
nome_do_método. A lista de parâmetros especificada por lista_de_parametros é formada por pares
de "tipo" e "identificador" separados por vírgula. Caso não haja parâmetros, a lista de parâmetros
deve ficar vazia.
Caso o tipo de retorno do método seja diferente de void é necessário que seja utilizado o
operador return para retornar um valor para a rotina que chamou o método. Isto é feito da seguinte
forma:

return valor;

Onde valor define o valor a ser retornado pelo método.


Incluindo um Método na Classe Caixa

Embora possa ser definido uma classe apenas com dados, normalmente isto não ocorre. Na
maioria das vezes é desejável que sejam definidos os métodos que manipulam ou acessam os
dados. Isto permite que o implementador esconda as estruturas de dados e suas manipulações atrás
das abstrações dos métodos. Um método também é acessado utilizando um ponto separando o
nome do objeto do nome do método.
No exemplo anterior, o volume da caixa foi calculado pela classe chamada CaixaDemo.
Entretanto, como o volume de uma caixa depende somente de suas dimensões, faz mais sentido que
este cálculo seja feito pela própria classe Caixa. No exemplo abaixo é definido um método para
calcular o volume da caixa:

/* exemplo inclui um método para o calculo do volume
dentro da classe Caixa.
salve em um arquivo chamada CaixaDemo2.java */

class Caixa {
double largura;
double altura;
double profundidade;

// calcula e exibe o volume do Caixa
void volume() {
double volume;
volume = largura * altura * profundidade;
System.out.println(“0 volume e " + volume);
}

// esta classe utiliza um objeto da classe Caixa
class CaixaDemo2 {
public static void main(String args[]) {
Caixa minhaCaixa;

// cria o objeto minhaCaixa
minhaCaixa = new Caixa();

// atribui valores as variáveis de instância
minhaCaixa.largura = 12;
minhaCaixa.altura = 15;
minhaCaixa.profundidade = 23;

//calcula o volume de minhaCaixa
minhaCaixa.volume();
}
}
178

A saída deste programa é exatamente igual à do programa anterior.

Retornando um Valor

Suponha agora que em uma parte do programa deseja-se calcular o valor do volume sem
imprimi-lo. Neste caso, embora o volume tenha sido calculado dentro da classe Caixa, a melhor
maneira seria que o método retornasse o valor do cálculo ao invés de simplemente imprimi-lo. O
próximo exemplo, o método volume() retorna o valor do cálculo feito ao invés de imprimí-lo.

/* exemplo inclui um método para o calculo do volume
dentro da classe Caixa.
salve em um arquivo chamada CaixaDemo3.java */

class Caixa {
double largura;
double altura;
double profundidade;

// calcula o volume do Caixa
double volume(){
double volume;
volume = largura * altura * profundidade;
return volume;
}
}
//esta classe utiliza um objeto da classe Caixa
class CaixaDemo3 {
public static void main(String args[]) {
Caixa minhaCaixa;
double volume;

//cria o objeto minhaCaixa
minhaCaixa = new Caixa();
//atribui valores as variáveis de instância
minhaCaixa.largura = 12;
minhaCaixa.altura = 15;
ninhaCaixa.profundidade = 23;

//calcula o volume de minhaCaixa
volume = minhaCaixa.volume();

//imprime o volume na tela
System.out.println(“0 volume e " + volume);
}
}


Incluindo um Método com Parâmetros à Classe Caixa

A maioria dos métodos necessita que sejam passados alguns parâmetros. Nos exemplos
anteriores as variáveis de instância largura, altura e profundidade foram acessadas diretamente.
Contudo, em um programa orientado a objetos bem projetado, as variáveis de instância somente
devem ser acossadas por intermédio de métodos. Isto previne que as variáveis sejam manipuladas
de maneira incorreta. O exemplo abaixo apresenta uma melhor implementação da classe Caixa,
utilizando o método defineDimensoes para atribuir os valores das dimensões da caixa:

/* exemplo inclui um método para o calculo do volume dentro da classe Caixa.
salve em um arquivo chamada CaixaDemo4.java */

class Caixa {
double largura;
double altura;
double profundidade;

// calcula o volume da caixa
179
double volume() {
double volume;
volume = largura * altura * profundidade;
return volume;
}

// define as dimensões da caixa
void defineDimensoes(double l, double a, double p){
largura = l;
altura = a;
profundidade = p;
}
}

// esta classe utiliza um objeto da classe Caixa
class CaixaDemo4 {
public static void main(String args[]) {
Caixa minhaCaixa;
double volume;

// cria o objeto minhaCaixa
minhaCaixa = new Caixa();

//atribui valores as variáveis de instância
minhaCaixa.defineDimensoes(12, 15, 23);

//calcula o volume de minhaCaixa
volume = minhaCaixa.volume();

//imprime o volume na tela
System.out.println("0 volume e " + volume);
}
}

Construtores

O construtor é responsável por iniciar o objeto imediatamente após a sua criação. Uma vez
definido o construtor, ele é chamado automaticamente após a criação do objeto antes que o operador
new termine de executar. O construtor é um método especial quenão possui nenhum tipo de retorno,
nem mesmo void. Isto ocorre porque o retorno implícito de um construtor é o objeto criado. Por
convenção, em Java, o construtor tem sempre o mesmo nome da sua classe. Ainda no exemplo da
classe Caixa, podemos utilizar o construtor para iniciar as dimensões da caixa e, utilizar o método
defineDimensoes para modificá-las em tempo de execução conforme a listagem abaixo:

/* salve em um arquivo chamada CaixaDemo5.java
*/
class Caixa {
double largura;
double altura;
double profundidade;

// definição do construtor
Caixa(double l, double a, double p) {
defineDimensoes(l, a, p);
}

// calcula o volume da caixa
double volume() {
double volume;
volume = largura * altura * profundidade;
return volume;
}

// define as dimensões da caixa
void defineDimensoes(double l, double a, double p) {
largura = l;
altura = a;
180
profundidade = p;
}

// esta classe utiliza um objeto da classe Caixa
class CaixaDemo5 {
public static void main(String args[]) {
Caixa minhaCaixa;
double volume;

// cria o objeto minhaCaixa
minhaCaixa = new Caixa(12, 15, 23);

// calcula o volume de minhaCaixa
volume = minhaCaixa.volume();

//imprime o volume na tela
System.out.println('0 volume e " + volume);

// atribui novos valores as variáveis de instância
minhaCaixa.defineDimensoes(20, 11, 7);

//recalcula o volume de minhaCaixa
volume = minhaCaixa.volume();

//imprime o volume na tela
System.out.println("0 volume e " + volume);
}
}

A saída do programa é:

O volume e 4140.0
O volume e 1540.0

Note que neste exemplo o construtor utilizou o método defineDimensoes para iniciar as
variáveis de instância. Os métodos sempre podem ser utilizados dentro de qualquer outro método da
classe.

Garbage Collection

Conforme observado, os objetos são alocados dinamicamente através do operador new.
Programadores C++, utilizam o operador delete para liberar a memória alocada por um objeto para
que possa ser realocada posteriormente. Em Java, não é necessário que os programadores liberem
a memória alocada por um objeto. Este processo é feito de forma transparente e automática pela
JVM e, recebe o nome de Garbage Collection. Em Java, quando não houver nenhuma referência a
um objeto, a memória alocada para ele pode ser liberada e realocada. O processo de Garbage
Collection ocorre de forma esporádica (ou nunca, caso não haja necessidade) durante a execução de
um programa.

O Método finalize{)

Algumas vezes um objeto precisa executar alguma ação antes de ser destruído. Por exemplo,
se um objeto estiver trabalhando com algum recurso não-Java como um arquivo, o programador deve
assegurar-se de liberá-lo antes de que o objeto seja destruído.
Para estas situações específicas, Java oferece um mecanismo chamado de finalização.
Assim, o programador pode especificar ações que ocorrerão quando o objeto é liberado pelo sistema
de Garbage Collection. Um método finalizador de uma classe deve ser definido da seguinte maneira:
protected void finalize() {
// código_de_finalização
181
}

A palavra-chave protected previne que o método finalize() tenha seu código definido fora da
classe. Este e outros especificadores de acesso serão melhor comentados posteriormente.

Mais Detalhes Sobre Classes e Métodos

Este capítulo apresenta mais detalhes relacionados com as classes e métodos incluindo
sobrecarga de métodos, controle de acesso e as palavras-chaves static e final.

Sobrecarga de Métodos

Em Java uma classe pode ter mais de um método com o mesmo nome e implementações
diferentes desde que as listas de parâmetros sejam diferentes. Quando isto ocorri ocorreu uma
sobrecarga de métodos. Sobrecarga de métodos é uma das maneiras que Java implementa o
polimorfismo. A seguir é mostrado um exemplo de sobrecarga de métodos:

// demonstração de sobrecarga de métodos
class SobrecargaDemo {

void teste() {
System.out.println("Teste sem parâmetros");
}

// sobrecarga com l parâmetro inteiro
void teste(int a){
System.out.println("a - " + a);
}

// sobrecarga com 2 parâmetros inteiros
void teste(int a, int b){
System.out.println("a = " + a + " e b - " + b);
}

// sobrecarga com l parâmetro e retorno doublé
double teste(double a) {
System.out.println("Double a - " + a);
return a*a/2;
}
}

class Sobrecarga {
public static void main(String args[]) {
SobrecargaDemo sd = new SobrecargaDemo();
double resultado;
// chama as diferentes versões de teste()
sd.teste();
sd.teste(5);
sd.teste(2,7);
resultado = sd.teste(12.37);
System.out.println("Resultado de sd.teste(12.37) = “ + resultado);
}
}

A saída do programa é
Teste sem parâmetros
a = 5
a = 2 e b = 7
Double a = 12.37
Resultado de sd.teste(12.37) = 76.50845
182

Sobrecarga de Construtores

Além de sobrecarregar os métodos comuns, os construtores também podem ser
sobrecarregados oferecendo diferentes formas de se iniciar um objeto. Voltando para o último
exemplo da caixa, agora o seu construtor será sobrecarregado conforme o exemplo abaixo:

class Caixa {
double largura;
double altura;
double profundidade;

// definição do construtor
Caixa(double l, double a, double p) {
defineDimensoes(l, a, p);
}

// sobrecarga do construtor sem parâmetros
Caixa() {
defineDimensoes(0, O, 0);
}

// sobrecarga do construtor quando todas
// as dimensões da caixa são iguais
Caixa(double l) {
DefineDimensoes(l, l, l);
}

// calcula o volume da caixa
double volume() { double volume;
volume = largura * altura * profundidade;
return volume;
}

// define as dimensões da caixa
void defineDimensoes(double l, double a, double p) {
largura = l;
altura = a;
profundidade = p;
}

// esta classe utiliza um objeto da classe Caixa
class CaixaSobrecarga {
public static void main(String args[]) {
Caixa caixa1 = new Caixa();
Caixa caixa2 = new Caixa(13);
Caixa caixa3 = new Caixa(5,10, 31);
double volume;

// calcula e imprime o volume da caixa1 na tela
volume = caixa1.volume();
System.out.println(“0 volume da caixa1 e " + volume);

// calcula e imprime o volume da caixa2 na tela
volume = caixa2.volume();
System.out.println("0 volume da caixa2 e " + volume);

// calcula e imprime o volume da caixa3 na tela
volume = caixa3.volume();
System.out.println("0 volume da caixa3 e " + volume);
}
}



A saída do programa é
183

O volume da caixa1 e 0.0
O volume da caixa2 e 2197.0
O volume da caixa3 e 1550.0


A Palavra-Chave static

Normalmente, um membro de uma classe (método ou variável de instância) somente pode
ser acessado através de um objeto da classe. Entretanto, é possível a definição de um membro uma
classe que pode ser acessado diretamente antes que qualquer objeto da classe seja criado e sem
referenciar qualquer objeto. Para definir um membro com esta característica basta usar a palavra-
chave static em sua declaração. O exemplo mais comum do uso do static é o método main. O
método main é declarado como static porque é necessário chama-lo antes mesmo de qualquer
objeto ser criado.
Variáveis de instância declaradas como static são, essencialmente, variáveis globais.
Quando objetos de sua classe são declarados nenhuma cópia da variável static é feita. Na realidade,
todas as instâncias da classe compartilham a mesma variável static.


A Palavra-Chave final

Para evitar que uma variável seja modificada a palavra-chave final pode ser utilizada. Isto
significa que é necessário iniciar uma variável final em sua declaração. Uma variável do tipo final
pode ser considerada como uma constante em C/C++ declarada como const. Por exemplo:

final int ARQ_NOVO = 1;
final int ARQ_SALVAR = 2;
final int ARQ_FECHAR = 3;
final int ARQ_APAGAR = 4;

A partir deste ponto as outras partes do programa podem utilizar ARQ_NOVO,
ARQ_SALVAR, ARQ_FECHAR e ARQ_APAGAR como constantes sem se preocupar se os seus
valores vão ser alterados.
Herança

A herança é um dos conceitos fundamentais da programação orientação a objetos pois
permite uma classificação hierárquica. O programador pode definir uma classe contendo
características comuns a um conjunto de items relacionados. Esta classe pode então ser herdada por
outras classes mais específicas, cada uma delas acrescentando novas características únicas.

Fundamentos de Herança

Para se herdar uma classe é necessário simplesmente incorporar a definição de uma classe
dentro de outra através da palavra-chave extends. O formato geral de declaração de uma subclasse
que herda uma superclasse é:

class nome_da_subclasse extends nome_da_superclasse {
//corpo_da_classe
}

Em Java somente herança simples é suportada, ou seja, uma subclasse só ser herdada de
uma única superclasse. Em outras linguagens como C++ é possível ter uma subclasse herdada de
mais de uma superclasse (a este tipo de herança dá-se o nome de herança múltipla):

184
Exemplo de Herança

Para ilustrar o conceito de herança, considere o exemplo da Caixa dado anteriormente, uma
nova classe será criada herdando as propriedades de Caixa e acrescentando um novo componente
chamado de peso. Assim a nova classe (exemplo abaixo) possui largura, altura, profundidade e peso.

class Caixa {
double largura;
double altura;
double profundidade;

// definição do construtor
Caixa(double l, double a, double p) {
DefineDimensoes(l, a, p);
}

// sobrecarga do construtor sem parâmetros
Caixa () {
defineDimensoes(0, O, 0);
}

// sobrecarga do construtor quando todas
// as dimensões da caixa são iguais
Caixa(double l) {
DefineDimensoes(l, l, l);

}

// calcula o volume da caixa
double volume() {
double volume;
volume = largura * altura * profundidade;
return volume;
}

// define as dimensões da caixa
void defineDimensoes(double l, double a, double p) {
largura = l;
altura = a;
profundidade = p;
}

// esta classe utiliza um objeto da classe Caixa
class CaixaPeso extends Caixa {
double peso;

// construtor da classe
CaixaPeso(double lar, double alt, double pro, double pes) {
defineDimensoes(lar, alt, pro);
peso = pes;
}
}

class CaixaPesoDemo {
public static void main(String args[]) {
CaixaPeso.caixal = new CaixaPeso(5,10, 31, 22.5);
CaixaPeso.caixa2 = new CaixaPeso(3,12, 15, 6.64);
System.out.println("0 volume da caixa1 e " +
caixa1.volume());
System.out.println("O peso da caixa1 e " + caixa1.peso);

System.out.println("0 volume da caixa2 e " +
caixa2.volume()); System.out.println("O peso da caixa2 e
" + caixa2.peso);
}
}

185
A saída do programa é
O volume da caixa1 e 1550.0 O peso da caixa1 e 22.5
O volume da caixa2 e 540.0 O peso da caixa2 e 6.64


Sobreposição de Métodos

Ao utilizar a herança, quando um método da subclasse possui um nome igual a um da
superclasse, diz-se que o método da subclasse sobrepõe o método da superclasse. Quando um
método sobreposto é chamado, será sempre utilizada a versão do método definido na subclasse. A
versão do método da superclasse será escondida.
A sobreposição de métodos permite que Java suporte polimorfismo em tempo de execução.
O polimorfismo é essencial em programação orientada a objetos por uma razão: permite que
uma classe geral especifique métodos que serão comuns a todos os seus descendentes, permitindo
que as subclasses definam uma implementação específica de alguns ou todos os métodos da
superclasse.


Aplicando a Sobreposição de Métodos

Neste exemplo, será criada uma superclasse Figura2D que modela várias figuras
bidimensionais. Esta classe define um método área() que calcula a área de um ob exemplo apresenta
duas subclasses: Retângulo e Triângulo. Cada uma das subclasses sobrepõe o método área() de
forma a retornar o valor correto.

class Figura2D {
double base;
double altura;

Figura2D(double b, double a) {
base = b;
altura = a;
}

double area() {
System.out.println("A área para Figura2D e indefinida.");
return 0;
}
}

class Retangulo extends Figura2D {
Retangulo(double b, double a) {
super (b, a); // invoca o construtor da superdasse
}

double area(){
System.out.println("Calculando área do retangulo.");
Return base* altura;
}
}

class Triangulo extends Figura2D {
Triangulo(double b, double a) {
super (b, a); // invoca o construtor da superdasse
}

double area() {
System.out.println("Calculando área do triângulo.");
return base * altura / 2;
}
}

class CalculoArea {
public static void main(String args[]) {
186
Figura2D f = new Figura2D(5, 4);
Retangulo r = new Retangulo(2, 6);
Triangulo t = new Triangulo(3, 9);

System.out.println("Area e " + f.area());
System.out.println("Area e " + r.are());
System.out.println ("Area e " -r i.area());
}
}
A saída do programa é
A área para Figura2D e indefinida.
Área e 0.0
Calculando área do retângulo.
Área e 12.0
Calculando área do triângulo
Área e 13.5

Neste exemplo também foi utilizado a palavra super para chamar o construtor da
superclasse. Isto é equivalente à utilização da palavra-chave inherited em Delphi.

Classes Abstratas

Em alguns casos, deseja-se definir uma classe que declara a estrutura geral de um conjunto
de objetos sem prover uma implementação de todos os métodos. Os métodos não implementados
são chamados de métodos abstratos e as classes que possuem este tipo de método são chamadas
de classes abstratas. Para criar um método abstrato (sem implementação) a superclasse deve
declará-lo com a palavra-chave abstract. Obrigatoriamente, a classe que possui um método abstrato
deve também ser declarada com a palavra-chave abstract. Assim, o formato geral de uma classe
abstrata é:

abstract class nome_da_classe {
// corpo_da_classe
.
.
.
abstract tipo nome_do_método_abstrato(lista_de_parâmetros) {
// corpo_do_método
}
.
.
.
// corpo_da_classe
}
No exemplo anterior, a classe Figura2D possuía o método area() indefinido que era
implementado em suas subclasses Retangulo e Triângulo. Uma alternativa à implementação anterior
seria a definição de Figura2D como uma classe abstrata cujo método area() seria abstrato. Esta
alternativa é implementada abaixo:

abstract class Figura2D {
double base;
double altura;
Figura2D(double b, double a) {
base = b;
altura = a;
}
abstract double area();
}

class Retangulo extends Figura2D {
187
Retangulo(double b, double a) {
super(b,a); // invoca o construtor da superciasse
}

double area() {
System.out.printIn("Calculando área do retangulo.");
return base * altura;
}

class Triangulo extends Figura2D {
Triangulo(double b, double a) {
super(b,a); // invoca o construtor da superclasse
}
i
double area(){
System.out.println("Calculando área do triângulo.”);
return base * altura / 2;
}
}

class CalculoArea2 {
public static void main(String args[]) {
Figura2D r = new Retangulo(2, 6);
Figura2D t = new Triângulo(3, 9);

System.out.println("Area e " + r.area());
System.out .println("Area e " +
t.area());
}
}

Note que se neste caso não é possível criar um objeto da classe Figura2D e utilizar o método
area() pois isto geraria um erro de compilação já que este método não está definido para a classe
Figura2D.

Pacotes e Interfaces

Pacotes

Nos exemplos anteriores o nome de cada classe exemplo foi obtido do mesmo espaço de
nomes. Isto significa que cada classe tinha que ter um nome único para evitar conflito de nomes. Java
permite que o espaço de nomes seja dividido em blocos menores. Este mecanismo recebe o nome
de pacote (packages). De forma simples, um pacote pode ser definido como um conjunto de classes
que, dependendo do nível de acesso, podem ser acessadas somente pelas classes internas do
pacote ou pelas classes de outros pacotes.

Criando um Pacote

Para definir um pacote basta incluir o comando package no inicio do arquivo fonte. Todas as
classes declaradas dentro deste arquivo farão parte do mesmo pacote. O pacote define um espaço
de nomes, caso seja omitido, o espaço de nomes padrão será utilizado. O formato geral de pacotes é:
package nome_do_pacote;

Java utiliza os diretórios do sistema de arquivos para gerenciar os pacotes. Por exemplo, o
arquivo .class de qualquer classe declarada como parte de um pacote MeuPacote tem que estar
dentro de um diretório chamado MeuPacote. Como Java é case sensitive (diferencia letras
minúsculas de maiúsculas), o nome do diretório deve ser exatamente igual ao nome do pacote.
Pode-se criar uma hierarquia de pacotes. Para isso, basta separar cada pacote por um ponto
(.). O formato geral para pacotes multi-níveis é:
package pacote1.[pacote2.[pacote3]];
188
Onde os elementos entre [ e ] são utilizados caso existam. Lembre-se que a hierarquia de
pacotes deve se refletir no sistema de arquivos. Assim, um pacote declarado como
package java.awt.image;
precisa ser armazenado no diretório java/awt/image, java\awt\image ou java: awt: image em um
sistema de arquivos UNIX, Windows ou Macintosh, respectivamente. É necessário atenção na hora
de escolher o nome de um pacote pois para renomeá-lo, é necessário alternar o seu nome em todos
os seus arquivos e o nome do diretório onde o pacote está armazenado.


A Variável de Ambiente CLASSPATH

As classes Java organizadas em pacotes são mapeadas em diretórios. Contudo,
difererentemente do sistema de arquivos, sempre é necessário especificar todo o pacote e, nunca
parte dele. Por exemplo, o pacote para a classe java.awt.Button é sempre especificado como
java.awt.
Suponha que se queira que o interpretador Java execute a aplicação contida na classe
chamada Teste.class no pacote util.meupacote. Se o caminho para este diretório for
C:\java\MinhasClasses\util\meupacote, é necessário incluir na variável de ambiente CLASSPATH o
diretório C:\java\MinhasClasses.
Assim, para executar a aplicação Teste é necessário executar:
java -classpath C:\java\MinhasClasses útil.meupacote.Teste
ou
set CLASSPATH="%CLASSPATH%;C:\java\MinhasClasses;.”
java util.meupacote.Teste

Quando a aplicação executar, a JVM utiliza a variável de ambiente CLASSPATH para
encontrar as outras classes definidas no pacote util.meupacote que forem utilizadas pela classe
Teste.
Note que todo o nome do pacote é especificado no comando. Não é possível, por exemplo,
incluir no CLASSPATH o diretório C:\java\MinhasClasses\util\meupacote e usar o comando "java
Teste".

Controle de Acesso

Para o controle de acesso de dados ou métodos membros de uma classe, Java possui 3
modificadores ou especificadores de acesso: private, protected e public. No total, Java 4 níveis de
acesso:
1. Padrão - nenhum modificador é especificado. Neste nível, um membro da classe é visível para
qualquer classe e subclasse do pacote.
2. Privado - o modificador private é utilizado. Neste nível, um membro da classe pode ser
acessado somente pelos membros da mesma classe.
3. Protegido - utiliza o modificador protected. Neste nível, um membro da classe pode ser visto
por subclasses de qualquer pacote e qualquer classe do mesmo pacote
4. Público - utiliza o modificador public. Neste nível, um membro da classe pode ser visto por
qualquer classe ou subclasse de qualquer pacote.

µrìvate Náo dejìnìdo µrotected µublìc
|esma classe

189
µrìvate Náo dejìnìdo µrotected µublìc
Subclasse do mesmo
pacote


Não·subclasse do
mesmo pacote


Subclasse de outro
pacote


Não subclasse de
outro pacote



Importando um Pacote

Para utilizar as classes definidas em um pacote é necessário importar todas as classes de um
pacote ou somente as classes desejadas. Para isso é necessário utilizar a palavra import. O import
é equivalente ao uses do Object Pascal e ao include do C++.O uso do import deve ser feito
imediatamente após a definição do pacote (caso exista). O geral para o import é:
import pacote1.[pacote2].(nome_da_classe|*);
Onde os elementos entre [ e ] são utilizados caso existam. Caso seja utilizado o nome da
classe, então somente será importada aquela classe do pacote. Caso seja utilizado o *, todas as
classes do pacote serão importadas. A seguir é mostrado um código que importa a classe Date do
pacote java.util e todas as classes do pacote java.io.
import java.util.Date;
import java.io.*;

Interfaces

Interface é um tipo de dados especial que especifica o que uma classe deve fazer mas não
especifica como fazer. As interfaces são muito semelhantes às classes, contudo, são desprovidas de
variáveis de instância e, seus métodos são declarados sem implementação. Na prática, isto significa
que podem ser definidas interfaces sem fazer qualquer suposição a respeito de sua implementação.
Uma vez definida uma interface, qualquer classe pode implementá-la e uma classe pode implementar
quantas interfaces quiser. As interfaces são utilizadas para que classes não relacionadas possam
implementar métodos com a mesma interface. O geral de uma interface é:

acesso interface nome_da_interface{
tipo nome_da_constante1 = valor;
tipo nome_da_constante2 = valor;
.
.
.
tipo nome_da_constanteN = valor;

tipo nome_do_método1(lista_de_parametros){
//corpo_do_metodo;
}
tipo nome_do_método2(lista_de_parametros){
//corpo_do_metodo;
}
.
.
.
tipo nome_do_métodoN(lista_de_parametros){
190
//corpo_do_metodo;
}
}

O acesso pode ser public ou default (sem especificador de acesso). Se nenhum
especificador de acesso for utilizado então a interface pode ser acessada somente pelas classes do
seu pacote. As constantes declaradas dentro da interface têm que ser iniciadas e não poderão ser
modificadas por classes que implementam a interface. Abaixo é mostrado um exemplo de interface
que especifica um método chamado imprimeMensagem() que tem como parâmetro o código da
mensagem.
interface Mensagem {
void imprimeMensagem(int codigo);
}

Esta interface pode ser implementada por uma classe que imprime o valor na tela com um
simples System.out.println, pode ser implementada por outra classe que imprime em um Applet ou
em uma aplicação que exibe uma caixa de diálogo.

Tratamento de Exceção

Fundamentos do Tratamento de Exceção

Uma exceção é uma condição anormal que ocorre durante a execução de uma seqüência de
código. Ou seja, uma exceção é um erro em tempo de execução. Em linguagens como Object Pascal
e C++ o tratamento de exceção é opcional, ou seja, o programador decide se faz ou não. Em Java o
tratamento de exceção é obrigatório, sempre que houver um método que possa gerar uma exceção, a
classe que utilizar este método será obrigada a tratar de alguma forma a possível exceção. Caso
contrário ocorrerá um erro de compilação.
Em Java o tratamento de exceção é feito através de cinco palavras-chaves: try, catch throw,
throws e finally. O trecho de código a ser monitorado fica contido em um bloco try. Caso a exceção
ocorra, ela será executada no bloco de código contido em catch. Para gerar manualmente uma
exceção é utilizada a palavra-chave throw. Qualquer exceção que possa ser gerada por um método
deve ser especificada por uma cláusula throws. Qualquer código que precise ser executado antes de
sair de um método onde ocorreu uma exceção deve estar em um bloco finally. O formato geral de
um bloco de tratamento de exceção é:

try {
// Bloco de código monitorado
{
catch(ExcecaoTipol exObj) {
// Tratamento_da_exceção_tipol
}
catch(ExcecaoTipo2 exObj) {
// Tratamento_da_exceção_tipo2
}
catch(ExcecaoTipoN exObj) {
// Tratamento_da_exceção_tipoN
} finally {
// código_executado_antes_de_sair_do_bloco
}

ExcecaoTipo especifica o tipo da exceção que ocorreu.



191
Tipos de Exceção

Todas as exceções são subclasses derivadas da classe Throwable. Assim, Throwable está
no topo da hierarquia de classe das exceções. Imediatamente abaixo de Throwable estão duas
subclasses que dividem as exceções em duas ramificações distintas. A primeira ramificação é
originada na classe Exception. Esta classe é utilizada para definir condições excepcionais que os
programas devem tratar. As exceções criadas pêlos usuários devem utilizar a classe Exception.
A outra ramificação é originada na classe Error, que define as exceções que, sob condições
normais, não espera-se que sejam identificadas pelo programa. As exceções deste ramo são
utilizadas pela JVM para indicar erros relacionados ao ambiente de execução.

try-catch

Embora o tratador padrão de exceções do ambiente de execução Java monitore algumas
exceções e ofereça informações úteis para depuração, muitas vezes o usuário prefere tratar estas
exceções. Isto permite que o usuário corrija erros e evite que o seu programa seja finalizado. O
exemplo abaixo oferece o tratamento caso ocorra um erro de divisão por zero. Isto é feito
monitorando a exceção ArithmeticException.

class ExcecaoDemo {
public static void main(String args[]) {
int i, a;
for(i = 5; i >= 0; i--) {
try{ // monitora um bloco de código
System.out.println("Dividindo 35 por " + i +
"...”);
a = 35 / i;
System.out.println("35 / " + i + " = " + a);
} catch (ArithmeticException e) {
// verifica divisão por zero
System.out.println("Erro: Divisão por zero");
}
}
}
}

A saída do programa é
Dividindo 35 por 5... 35 / 5 °7
Dividindo 35 por 4... 35 / 4 = 8
Dividindo 35 por 3... 35 / 3 » 11
Dividindo 35 por 2... 35 / 2 = 17
Dividindo 35 por l... 35/1-35
Dividindo 35 por O... Erro: Divisão por zero

throw

Na seção anterior foi mostrado como tratar uma exceção gerada pelo ambiente de execução
Java. Entretanto, é possível que o programador usuário gere explicitamente uma exceção através da
palavra-chave throw. O formato geral é:
throw instancia_de_uma_exceção,
A instância da exceção a ser gerada deve ser necessariamente um objeto da classe
Throwable ou de uma subclasse de Throwable. A partir do ponto onde é utilizado o throw, o fluxo
de execução é interrompido e nenhuma outra operação subsequente é executada. O bloco try mais
próximo é inspecionado para verificar se o bloco catch identifica a exceção gerada. Caso a exceção
seja identificada, a execução do programa passa para o bloco catch. Se a exceção não for
identificada por nenhum bloco try-catch, então o tratador padrão de exceções é acionado
192
interrompendo a execução do programa e imprimindo a pilha de rastreamento. A seguir é mostrado
um exemplo de utilização de throw:
class ThrowDemo {
static void demoThrowQ {
try {
// gera uma exceção throw
new NullPointerException("DEMO");
}catch (NulIPointerException e) {
System.out.println("Identifiçada dentro de demoThrow”);
// gera novamente a mesma exceção
throw e;
}
}

public static void main(String args[]) {
try {
demoThrow();
}catch (NullPointerException e) {
System.out.println("Identifiçada novamente:" + e);
}
}
}

A saída do programa é
Identificada dentro de demoThrow
Identificada novamente: java.lang.NullPointerException: DEMO


throws

Quando um método "A" pode gerar uma exceção que ele não trata, é necessário especificar o
seu erro de maneira que outros métodos que chamem o método "A" previnam-se contra esta
exceção. Isto é feito através da inclusão da cláusula throws na declaração do método. A cláusula
throws lista os tipos de exceções que um método pode gerar. A inclusão desta cláusula força que os
usuários deste método tratem as possíveis exceções. O formato geral é:
tipo nome_do-metodo(lista_de_parâmetros) throws lista_de_exceções {
// corpo_do_método
}
A seguir é mostrado um exemplo de utilização de throws:
class ThrowsDemo {
static void demoThrows() throws IllegalAccessException {
System.out.println("Identificada dentro de demoThrows");
// gera a exceção
throw new IllegalAccessException("DEMO");
}

public static void main(String args[]) {
try {
demoThrows();
} catch (IllegalAccessException e) {
System.out.println("Identificada novamente: " + e);
}
}
}
A saída do programa é
Identificada dentro de demoThrows
193
Identificada novamente: java.lang.IllegalAccessException: DEMO

finally

Quando ocorre uma exceção o fluxo de execução do método é alterada abruptamente. Muitas
vezes dependendo de como o método é codificado, é possível que o método retorne de forma
prematura. Para evitar isto pode ser adicionado um bloco finally ao try-catch. O bloco finally será
executado sempre, ocorrendo ou não uma exceção. A seguir é mostrado um exemplo de utilização do
bloco finally:

class FinallyDemo {
static void metodoA() {
try {
System.out.println("dentro do metodoA");
throw new RuntimeException("DEMO");
} finally {
System.out.println("dentro finally do metodoA");
}
}

static void metodoB() {
try {
System.out.println("dentro do metodoB");
return;
} finally {
System.out.println("dentro finally do metodoB");
}
}

static void metodoC() {
try {
System.out.println("dentro do metodoC");
} finally {
System.out.println("dentro finally do metodoC");
}
}

public static void main(String args[]) {
try {
metodoA();
} catch (Exception e) {
System.out.println("Excecao identificada");
}
metodoB();
metodoC();
}
}

A saída do programa é
dentro do metodoA
dentro finally do metodoA
Exceção identificada
dentro do metodoB
dentro finally do metodoB
dentro do metodoC
dentro finally do metodoC

Note que o bloco finally é sempre executado mesmo sendo gerada uma exceção como no
metodoA(), solicitando um retorno prematuro como no metodoB() ou quando nenhuma exceção é
identificada como no metodoC().

194

Exceções Padrões em Java

Nesta seção serão apresentadas as exceções definidas no pacote java.lang que é portado
automaticamente em todo programa Java. Para as classes da ramificação RuntimeException. O
compilador não verifica se são tratadas por algum método. Por outro lado, para as classes da
ramificação Exception o compilador verifica se elas são tratadas em algum método do programa.
Muitas outras exceções são definidas em outras bibliotecas.

Exceçáo 0escrìçáo
ArìthmetìcExceptìon Erro arItmétIco como dIvIsão por zero
ArrcylndexDutD]8oundsExceptìon ÌndIce do crrcy fora do lImIte
ArrcyStoreExceptìon AtrIbuIção de elemento de tIpo Incompativel
ClcssCcstExceptìon Ccst InválIdo
llleyclAryumentExceptìon Argumento InválIdo Invocando um método
llleyclMonìtorStcteExceptìon Dperação de monItoramento InválIdo
llleyclStcteExceptìon AmbIente ou aplIcação em estado Incorreto
llleyclThrecdStcteExceptìon Dperação requIsItada Incompativel com estado atual
lndexDutD]8oundsExceptìon Algum tIpo de indIce fora do lImIte
NeyctìveArrcySìzeExceptìon Arrcy crIado com tamanho negatIvo
NullPoìnterExceptìon Uso InválIdo de referëncIa nula
NumberFomctExceptìon Conversão InválIda de Strìny para numero
SecurìtyExceptìon TentatIva de vIolação de segurança
StrìnylndexDutD]8ounds ÌndIce de Strìny fora de lImIte
0nsupportedDperctìonExceptìon Uma operação não suportada foI encontrada
Subclasses de RuntimeException nao checadas pelo compilador.


Exceçáo 0escrìçáo
ClcssNotFoundExceptìon Classe não encontrada
CloneNotSupportedExceptìon TentatIva de clonar um objeto que não Implementa
a Interface Clonable
llleyclAcessExceptìon Acesso negado a uma classe
lnstcncìctìonExceptìon TentatIva de crIar um objeto de uma classe abstrata
ou Interface.
lnterruptedExceptìon Uma Threcd foI InterrompIda por outra
NoSuchFìeldExceptìon Um campo requIsItado não exIste
NoSuchMethodExceptìon Um método requIsItado não exIste
Subclasses de Exception checadas pelo compilador.


Criando uma Exceção

Embora as exceções padrões de Java tratem a maioria dos erros comuns, o usuário pode
querer definir novas exceções para outros erros. Para isso basta criar uma subclasse de Exception.
Abaixo é mostrado um exemplo de criação de uma exceção:


class MinhaExcecao extends Exception {
private int código;

195
MinhaExcecao(int cod) {
código = cod;
}

public String toString() {
return "MinhaExcecao, código " + código;
}
}

class MinhaExcecaoDemo {
static void registra(int a) throws
MinhaExcecao {
System.out.println("registrando código = " + a);
if(a > 10) throw new MinhaExcecao(a);
SyStem.out.printLn(“código = " + a + " registrado");
}

public static void main(String args[]) {
try {
registra(5);
registra(29);
} catch (MinhaExcecao e) {
System.out.println("Exceção identificada: “ + e);
}
}
}

saída do programa é
registrando código - 5
código = 5 registrado
registrando código = 29
Exceção identificada: MinhaExcecao, código
=
29


EntradaJSaída

Streams

Os programas Java trabalham com Entrada/Saída (E/S) através de streams. Uma stream é
uma abstração que produz ou consome informação. Uma stream é ligada a um dispositivo físico
através do sistema de E/S. Todas as streams apresentam comportamento igual mesmo que os
dispositivos a elas ligado forem diferentes. Assim, as mesmas classes e métodos de E/S podem ser
utilizadas para diferentes tipos de dispositivos. Isto significa que uma Stream de entrada pode
abstrair muitos tipos diferentes de entradas como arquivos, teclado ou conexões de rede. Da mesma
forma, uma stream de saída pode referir-se ao terminal, a um arquivo ou a uma conexão de rede.


Streams de Bytes e de Caracteres
Java define dois tipos de streams: streams de bytes e streams de caracteres. As streams
de bytes oferecem meios para tratar a entrada e saída de bytes. Uma stream de bytes pode ser
utilizada, por exemplo, para ler ou escrever dados binários. Streams de caracteres oferecem meios
para tratar a entrada e saída de caracteres. As streams de caracteres utilizam a codificação Unicode.
Classes de Streams de Bytes

As streams de bytes estão divididas em dois ramos hierárquicos. O primeiro tem início na
classe abstrata InputStream. Todas as subclasses deste ramo correspondem a streams de bytes de
entrada utilizadas para a leitura de bytes de diversos dispositivos. O segundo ramo da hierarquia é
originado na classe abstrata OutputStream. As subclasses deste ramo permitem a escrita de bytes
196
em diversos dispositivos. A tabela abaixo mostra quais são as classes que trabalham com streams de
bytes.

Classes de Streams de Caracteres

As streams de caracteres também estão divididas em dois ramos hierárquicos. O primeiro
ramo tem início na classe abstrata Reader. Todas as subclasses deste ramo correspondem a
streams de bytes de entrada utilizadas para a leitura de caracteres de diversos dispositivos. O
segundo ramo da hierarquia é originado na classe abstrata Writer. As subclasses deste ramo
permitem a escrita de diversos disposivos.

Classe Stream 0escrìçáo
8ufferedÌnputStream Strecm de entrada bu]]erìzcdc
8ufferedDutputStream Strecm de saida bu]]erìzcdc
8yteArrayÌnputStream Strecm de entrad que lë de um array de bytes
8yteArrayDutputStream Strecm de saida que escreve em um array de byte
0ataÌnputStream Strecm de entrada para leItura de tIpos de dados Java Padrão
0ctcDutputStrecm Strecm de saida para escrIta em tIpos de dados Java Padrão
FìlelnputStrecm Strecm de entrada para leItura de arquIvos
FìleDutputStrecm Strecm de saida para escrIta em arquIvos
FìlterlnputStrecm Strecm de entrada que Implementa lnputStrecm
FìlterDutputStrecm Strecm de saida que Implementa DutputStrecm
lnputStrecm Strecm de entrada (classe abstrata)
DutputStrecm Strecm de saida (classe abstrata)
PìpedlnputStrecm Strecm de entrada pìpe
PìpedDutputStrecm Strecm de saida pìpe
PrìntStrecm Strecm de saida que possuI µrìnt e µrìntln
PushbccklnputStrecm Strecm de entrada que permIte devolver um byte lIdo
RcndomAccessFìle Suporta escrIta e leItura de arquIvos
SequencelnputStrecm Strecm de entrada que combIna uma ou maIs strecms de entrada
Classes de Streams de bytes.

Streams Predefinidas

A stream de saída padrão é System.out. Por padrão, esta stream está ligada ao terminal
(console). A stream de entrada padrão é System.in. Por padrão, esta stream também está ligada ao
teclado. Stream de erro padrão é System.err. Por padrão, esta stream também está ligada ao
terminal (console) mas pode ser redirecionada para qualquer dispositivo de E/S compatível.
System.in é um objeto do tipo InputStream. System.out e System.err são objetos do tipo
PrintStream. Estas são streams de bytes, contudo, são tipicamente utilizadas para ler caracteres do
teclado e escrever caracteres para o terminal.

Lendo Dados do Teclado

Em Java não existe um método generalizado para leitura de teclado como o scanf do C ou o
read do Pascal. Na realidade os caracteres do teclado são lidos através da stream System.in. Para
se obter uma stream de caracteres é necessário empacotar o System.in em um objeto
BufferedReader. Para criar um objeto BufferedReader o formato do construtor padrão é:

197
BufferedReader(Reader ReaderDeEntrada)

ReaderDeEntrada é ligado à instância de BufferedReader que está sendo criado. Reader é
uma classe abstrata. Uma das suas subclasses concretas é InputStreamReader que converte bytes
em caracteres. Para criar um objeto InputStreamReader pode-se usar o construtor:

InputStreamReader(InputStream StreamDeEntrada)

Neste caso, pode-se utilizar System.in como StreamDeEntrada para o construto do
InputStreamReader. Assim, para conectar um BufferedReader ao teclado é necessário incluir a
seguinte linha de código:
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)

Após a execução desta linha, br estará conectado ao teclado através do System.in.

A tabela abaixo mostra quais são as classes que trabalham com streams de caracteres.

Classe Stream 0escrìçáo
8u]]eredRecder
Stream do caracteres de entrada bufferizada
8u]]eredWrìter Stream de caracteres de saida bufferizada
ChcrArrcyRecder
Stream de entrada que lê de um array de caracteres
ChcrArrcyWrìter
Stream de saida que escreve em um array de caracteres
FìleRecder Stream de entrada para leitura de arquivos
FìleWrìter
Stream de saida para escrita em arquivos
FìlterRecder
Stream de entrada que implementa Reader
FìlterWrìter Stream de saida que implementa Writer
lnputStrecmRecder
Stream de entrada que traduz bytes em caracteres
DutputStrecmWrìter Stream de saida que traduz bytes em caracteres
LìneNumberRecder Stream de entrada que conta e lê linhas
Recder
Stream de caracteres de entrada (classe abstrata)
Wrìter
Stream de caracteres de saida (classe abstrata)
PìpedRecder Stream de caracteres de entrada pipe
PìpedWrìter
Stream de caracteres de saida pipe
PrìntWrìter
Stream de caracteres de saida que possui print e println
Push8cckRecder Stream de caracteres de entrada que permite
devolver um byte lido
StrìnyRecder Stream de caracteres de entrada que lê de uma string
StrìnyWrìter Stream de caracteres de saida que escreve em uma String
Classes de streams de caracteres.

Leitura de Caracteres do Teclado

Para ler um caractere do teclado basta utilizar o método read(). Observe que o método pode
gerar uma exceção lOException. Abaixo é mostrado um exemplo que lê do teclado:

import java.io.*;

class LeCaracterTeclado {
public static void main(String args[]) throws lOException {
char c;
198
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in)\

System.out.println("Digite um caracter qualquer ou 's' para sair”);
do {
c = (char) br.read();
System.out.println(c);
} while (c != 's');
}
}

Observe que o comportamento deste programa é um pouco diferente do esperado. Isto
ocorre porque System.in não repassa para o programa nenhum caractere até que seja pressionada
a tecla ENTER.

Leitura de Strings do Teclado

Para ler uma string do teclado basta utilizar o método readLine(). Observe que o método
readLine também pode gerar uma exceção lOException. Abaixo é mostrado um exemplo que lê uma
string do teclado:

import java.io.*; |
class LeStringTeclado {
public static void main(String args[]) throws lOException {
String s;
BufferedReader br = newBufferedReader(new InputStreamReader

(System.in));

System.out.println("Entre com texto e pressione ENTER");
System.out.println("Digite 'sair' para finalizar.");
do {
s = br.readLine();
System.out.println(s);
} while (!s.equals("sair"));
}
}


Escrevendo no Terminal

A escrita no terminal pode ser facilmente desempenhada através dos método println() do
System.out, conforme consta nos exemplos exibidos até o momento. Estes métodos são definidos
pela classe PrintStream (que é o tipo de objeto referenciado por System.out.


Leitura e Escrita de Arquivos

Diversas classes e métodos para leitura e escrita de arquivos são definidas em Java. Estas
classes fazem parte do pacote java.io. Em Java todos os arquivos são tratados como arquivos
binários. Contudo, podem ser utilizadas streams de caracteres para escrita e leitura de arquivos.
Duas das classes mais comuns para manipulação de arquivos são FileinputStream e
FileOutputStream que criam streams de bytes conectadas a arquivos. Para abrir um arquivo basta
criar um objeto de uma destas classes especificando o nome do arquivo como parâmetro do
construtor. Os construtores utilizados nos exemplos desta seção são:

FileInputStream(String nomeDoArquivo) throws FileNotFoundException
FileOutputStream(String nomeDoArquivo) throws FileNotFoundException

O parâmetro nomeDoArquivo especifica o arquivo a ser aberto. Se ao criar uma stream de
entrada, se o arquivo não puder ser encontrado ou não existir, a exceção FileNotFoundException é
199
gerada. No caso da stream de saída, caso o arquivo especificado não puder ser criado, a exceção
FileNotFoundException é gerada. Quando o stream de saída é criado, qualquer arquivo com o
mesmo nome será destruído.
Quando todas as operações de leitura ou escrita tiverem sido concluídas, é necessário fechar
o arquivo através do método close() definido em ambas as classes FilelnputStream e
FileOutputStream. O método close() pode gerar a exceção IOException.
Para ler bytes de um arquivo pode-se utilizar o método read() da classe FileInputStream. O
método read() pode gerar a exceção IOException. Sempre que chamado, o método read() lê um
byte e retorna o valor deste byte como um valor inteiro. Ao chegar ao fim do arquivo, o método read()
retorna -1. O exemplo a seguir lê um arquivo chamado TESTE.TXT e imprime na tela o seu conteúdo:

import java.io.*;
class ExibeArquivo {
public static void main(String args[]) throws IOException {
int i;
FileInputStream fis;

try {
fis = new FileInputStream(args[0]);
} catch (FileNotFoundException e) {
System.out.println("Arquivo não encontrado.");
return;
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Uso: ExibeArquivo nomeArquivo");
return;
}
// lê os caracteres e imprime na tela
do {
i = fis.read();
if(i != -1) System.out.print((char) i);
} while (i != -1);

fis.close();
}
}

Para escrever em um arquivo pode ser utilizado o método write() provido pela classe
FileOutputStream. Para este método é necessário passar o valor do byte a ser escrito no arquivo.
Este parâmetro é do tipo inteiro, contudo, somente o byte menos significativo é escrito no arquivo. O
método write() pode gerar a exceção lOException. No exemplo abaixo write() é utilizado para copiar
um arquivo:

import java.io.*;
class CopiaArquivo {.
public static void main(String args[]) throws lOException {
int i;
FileInputStream fis;
FileOuputStream fos;
try {
try {
fis = new FileInputStream(args[0]);
} catch (FileNotFoundException e) {
System.out.println("Arquivo origem não encontrado.”);
return;
}
try{
fos = new FileOutputStream(args[1]);
} catch (FileNotFoundException e) {
System.out.println("Erro criando arquivo destino.");
return;
}
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Uso: CopiaArquivo origem destino");
return;
}
200
// copia arquivo
try {
do {
i = fis.read();
if(i != -1) fos.write(i);
} while (i != -1);
} catch (lOException) {
System.out.println("Erro");
}
fis.close();
fos.close();
}
}



201
Applets

Introdução aos Applets

odos os exemplos anteriores são aplicativos de terminal (interface de texto). Contudo, tem
outros tipos de aplicações Java como os Applets. Um applet é uma pequena aplicação que
pode ser acessada de um servidor de Web, transferida pela Internet, automaticamente instalada
e executada como parte de um documento HTML. Neste capítulo serão apresentados os
fundamentos relacionados com a criação de um applet. Como será constatado ao longo deste
capítulo, os Applets são estruturados de maneira diferente dos aplicativos. Abaixo é apresentado o
exemplo mais básico de um applet:

import java.awt.*;
import java.applet.*;
public class PrimeiroApplet extends Applet{
public void paint(Graphics g) {
g.drawString("Primeiro exemplo de applet.", 20, 20);
}
}


Este applet importa dois pacotes, o primeiro é o java.awt (Abstract Window Toolkit - AWT). Os
Applets interagem com o usuário através do AWT e não através do terminal como nos exemplos
anteriores. O AWT oferece suporte a interface gráfica baseada em janelas. O AWT é bastante
extenso e, maiores detalhes sobre as suas classes devem ser obtidos nos arquivos de ajuda de Java.
O segundo pacote é o java.Applets que contém a classe Applet. Todos os Applets devem ser
subclasses de Applet.
Como o applet será acessado por um outro programa é necessário declará-lo como public. O
método paint() é definido pelo AWT e deve ser sobreposto pelo applet. Este método é chamado
sempre que o applet precisar ser redesenhado. Isto ocorre em situações como quando o applet é
minimizado e restaurado ou quando ele é coberto e descoberto por outra janela. O paint() também é
chamado quando o applet é iniciado. O parâmetro do método paint() é um objeto da classe Graphics
que representa a área onde o applet é exibido. O drawString() da classe Graphics recebe como
parâmetros a mensagem que será escrita na área do applet e a posição x e y onde ela será
posicionada. A posição (0, 0) corresponde ao ponto do topo esquerdo do applet.
Observe que um applet não possui um método main() pois ele é executado imediatamente
após ser carregado em um visualizador de applet ou em um navegador. Um applet é compilado da
mesma forma que os aplicativos terminais. Contudo, para executá-lo o processo é diferente. Existem
duas maneira de se executar um applet: '
• Utilizando um navegador Web compatível com Java como o Netscape ou versões do Internet
Explorer.
• Utilizando um visualizador de applet como o utilitário appletviewer provido com o Java. Neste
caso o applet é executado em uma janela. Normalmente esta é a maneira mais rápida de se
testar um applet.
Para executar um applet é necessário escrever um pequeno arquivo HTML contendo uma tag
APPLET indicando o nome do applet e suas dimensões (largura e altura ocupadas na tela). Abaixo é
mostrado um possível arquivo HTML:

<html>
<head>
<title> Primeiro Applet </title>
</head>
<body>
<applet code = "PrimeiroApplet" width = 3OO height = 200>
</applet>
</body>
</html>

Salve o arquivo como TesteApplet.html. Para executar o applet em um navegador basta
carregar o arquivo TesteApplet.html. Para executar no appletviewer basta executar:

T
202
appletviewer TesteApplet.html

De forma alternativa, para utilizar o appletviewer a tag APPLET pode ser incluída no código
do applet como comentário do código fonte do applet, conforme a listagem abaixo:

import java.awt.*;
import java.applet.*;
/*
<applet code = "PrimeiroApplet" width=300 height=200> </applet>
•/
public class PrimeiroApplet extends Applet {
public void paint(Graphics g) {
g.drawString("Primeiro exemplo de applet.", 20, 20);
}
}


Desta forma, basta compilar o código e executar o appletviewer passando o nome do
arquivo fonte (.java) do applet ao invés do arquivo HTML.


Esqueleto Básico de um Applet

Quase todos os Applets sobrepõem um conjunto de métodos que oferecem o mecanismo
báscio para que o navegador ou o visualizador de applet controle a sua execução. Quatro destes
métodos são definidos pela classe Applet: init(), start(), stop() e destrroy(). Outro método, paint(), é
definido pela classe Component da biblioteca AWT. Uma implementação padrão é oferecida, assim
não é necessário sobrepor os métodos que não serão utilizados. O esqueleto básico de um applet é
mostrado abaixo.


// Um esqueleto para Applets
import java.awt.*;
import java.applet.*;
/*
<applet code="EsqueletoApplet" width=300 height=200>
</applet>
*/
public class EsqueletoApplet extends Applet{
// Primeiro método chamado
public void init() {
// inicializacao do applet
}

// Chamado apôs init() e sempre que o applet e reiniciado
public void start() {
// inicia ou reinicia a execução
}

// Chamado quando o applet e suspenso
public void stop() {
// suspende a execução
}

// Chamado quando o applet e finalizado
// este e o ultimo método executado
public void destroy() {
// executa o código de finalização do applet
}

// Chamado quando o applet precisa ser redesenhado
public void paint(Graphics g) {
// código de desenho do applet
}
}
Embora este esqueleto não faça nada, ele pode ser compilado e executado.
203
Quando executado, ele gera uma janela limpa.


Iniciação e Finalização de um Applet

É importante observar a ordem em que cada um dos métodos apresentados no esqueleto são
chamados. Quando o applet é iniciado, o AWT chama em seqüência os seguintes métodos:

1. init()
2. start()
3. paint()

Quando o applet é finalizado a seguinte seqüência de métodos é chamada:
1. stop()
2. destroy()

init() - Este é o primeiro método a ser chamado. Nele devem ser iniciadas todas as vai método é
chamado uma única vez durante a execução do applet.
start() - O método start() é chamado imediatamente após o init() e sempre que for reiniciada a
execução do applet após ter sido suspensa. Este método é chamado sempre que o documento HTML
é exibido na tela.
paint() - Este método é chamado sempre que o applet precisa ser redesenhado. Isto pode varias
razões. Por exemplo, quando a janela do applet é coberta e descoberta por outra janela. Ou quando a
janela do applet é minimizada e restaurada. O método recebe um parâmetro Graphics que descreve
o ambiente gráfico onde o applet está sendo executado.
stop() - O método stop() é chamado quando o navegador Web deixa o documento HTML contendo
o applet (quando ele carrega outra página, por exemplo). Quando stop() é chamado, provavelmente
o applet está sendo executado. O método stop() é utilizado para suspender Threads que não
precisam ser executadas enquanto o applet não é visível. Elas podem ser reiniciadas através do
método start() caso o usuário volte para a página.
destroy() - O método destroy() é chamado quando o ambiente de execução determina que o applet
será removido completamente da memória. Neste momento todos os recursos utilizados pelo applet
devem ser liberados. O método stop() sempre é chamado antes do método destroy().

Cores do Applet

Para configurar a cor de fundo da janela de um applet, é necessário utilizar o método
setBackground(). Para configurar a cor de desenho é necessário utilizar o método
setForeground(). Estes métodos são definidos pela classe Component e apresentam seguinte
forma:
void setBackground(Color novaCor)
void setForeground(Color novaCor)

Onde novaCor define a cor que será configurada. A classe Cor define as seguintes constantes para
especificar uma cor:
Color.black Color.magenta
Color.blue Color.orange
Color.cyan Color.pink
Color.darkGray Color.red
Color.gray Color.white
Color.green Color.yellow
Color.lightGray

Abaixo é mostrado um exemplo que modifica a cor de desenho e a cor do fundo. A
visualização dele é mostrada na figura abaixo:

import java.awt.*;
import java.applet.*;
/*
<applet code =- “CorApplet" width=300 height= 200>
</applet>
*/
204
public class CorApplet extends Applet {
String msg;

// configura as cores
public void init() {
setBackground(Color.blue);
setForeground(Color.magenta);
msg = "Dentro do init() -- ";
}

public void start() {
msg += "Dentro do start() -— ";
}

public void paint(Graphics g) {
msg += "Dentro do paint().";
// desenha a string
g.drawString(msg,5,90);
}
}

Desenhando Formas Geométricas

Para desenhar figuras geométricas é necessário utilizar os métodos de desenho contidos na
classe Graphics através do parâmetro "g" passado para o método paint() do applet. Abaixo são
mostrados alguns métodos oferecidos para desenhar formas geométricas na janela do applet:


void drawLinc(int x1, int y1, int x2, int y2)
void draw0val(int x, int y, int width, int height)
void drawRect(int x, int y, int width, int height)


Abaixo é mostrado um applet que utiliza estes métodos:

import java.awt.*;
import java.applet.*;
/*
<applet code="DesenhoApplet" width=300 height=150>
</applet>
*/
public class DesenhoApplet extends Applet {
// configura as cores
public void init() {
setBackground(Color.lightGray); ;
setForeground(Color.black);
}

public void paint(Graphics g) {
// define cor e desenha uma linha
g.draw3tring("linha",125,18);
g.drawLine(5,20,295,20);

// define cor e desenha uma elipse
g.draw3tring("elipse",20,38);
g.drawOval(10,42,50,80);

// define cor e desenha um retangulo
g.drawString("retangulo",100,38);
g.drawRect(100,42,50,80);

// define cor e desenha um arco
g.drawString("arco",215,38);
g.drawArc(200,42,50,80,O,120);
}
)
205
ANEXO A:

Conceitos sobre a linguagem Java

Um Breve histórico

alvez a contribuição mais importante da revolução dos microprocessadores até esta data seja o
fato de ela ter possibilitado o desenvolvimento de computadores pessoais, que agora chegam a
centenas de milhões em todo o mundo. Os computadores pessoais tiveram um profundo
impacto sobre as pessoas e a maneira como as organizações conduzem e gerenciam seus negócios.
Muitas pessoas acreditam que a próxima área importante em que os microprocessadores
terão um impacto profundo serão os dispositivos inteligentes destinados ao consumidor final.
Reconhecendo isso, a Sun Microsystems financiou uma pesquisa corporativa interna com o codinome
Green em 1991. O projeto resultou no desenvolvimento de uma linguagem baseada em C e C++ que
seu criador, James Gosling, chamou de Oak(carvalho) em homenagem a uma árvore que dava para
a janela do seu escritório na Sun. Descobriu-se mais tarde que já havia uma linguagem de
computador chamada Oak. Quando uma equipe da Sun visitou uma cafeteria local, o nome Java
(cidade de origem de um tipo de café importado) foi sugerido e pegou.
Mas o projeto Green atravessava algumas dificuldades. O mercado para dispositivos
eletrônicos inteligentes destinados ao consumidor final não estava se desenvolvendo tão rapidamente
como a Sun tinha previsto. Pior ainda, um contrato importante pelo qual a Sun competia fora
concedido a outra empresa. Então, o projeto estava em risco de cancelamento. Por pura sorte, a
World Wide Web explodiu em popularidade em 1993 e as pessoas da Sun viram o imediato potencial
de utilizar Java para criar páginas da Web com o chamado conteúdo dinâmico. Isso deu nova vida ao
projeto.
Em maio de 1995, a Sun anunciou Java formalmente em uma conferência importante.
Normalmente, um evento como esse não teria gerado muita atenção. Entretanto, Java gerou
interesse imediato na comunidade comercial por causa do fenomenal interesse pela World Wide
Web. Java é agora utilizada para criar páginas Web com conteúdo interativo e dinâmico, para
desenvolver aplicativos corporativos de grande porte, para aprimorar a funcionalidade de servidores
da World Wide Web (os computadores que fornecem o conteúdo que vemos em nossos
navegadores da Web), fornecem aplicativos para dispositivos destinados ao consumidor final(como
telefones celulares, pagers e assistentes pessoais) e para muitas outras finalidades.

Princípios básicos de um ambiente Java clássico

Plataforma Java

Diversas plataformas estão disponíveis no mercado tais como Microsoft Windows, Macintosh,
OS/2 UNIX
R
e NetWare
R
. Um arquivo binário de uma aplicação que executa em uma plataforma não
pode ser executado em outra sem que o código seja recompilado. Isto ocorre porque o arquivo
binário é específico para uma determinada máquina e sistema operacional.
A plataforma Java é uma plataforma de software projetada para a transferência e execução
dinâmica, segura e interativa de applets e aplicativos de redes. A plataforma Java situa-se sobre as
demais plataformas de hardware/software compilando e executando bytecodes, que não são
orientados a uma arquitetura específica, mas são instruções de uma máquina virtual. Um programa
escrito em Java e compilado em um arquivo bytecode pode ser executado em qualquer máquina e
qualquer sistema operacional que possua a plataforma Java disponível. Esta portabilidade é possível
porque o núcleo da plataforma Java é a Máquina Virtual java (JVM – Java Virtual Machine).
Cada plataforma possui sua própria implementação da JVM, por outro lado, a especificação
da JVM é única. Por isso, a plataforma Java pode oferecer uma interface de programação
padronizada e uniforme para applets e aplicativos em qualquer hardware. Portanto, a plataforma Java
é ideal para a Internet, onde um programa deve poder ser executado em qualquer computador.

Benefícios da plataforma Java

T
206
A plataforma Java traz alguns benefícios para usuários finais, desenvolvedores e para a
equipe de suporte.

• Benefícios para usuários finais. Atualmente, a plataforma Java oferece um conteúdo interativo
na World Wide Web, com acesso do tipo just-in-time ao software. Aplicativos são disponibilizados
em todos os sistemas operacionais.
• Benefícios para desenvolvedores. A linguagem Java é orientada a objetos. Os desenvolvedores
não precisam portar seus aplicativos para os diversos sistemas operacionais disponíveis no
mercado, reduzindo com isso, o custo de desenvolvimento. A independência de plataforma por si
só já configura motivo suficiente para a adoção de Java como linguagem de programação.
• Benefícios administrativos e de suporte. O controle de versões e as atualizações são
simplificados pois as aplicações Java podem ser mantidas em um repositório central e serem
disponibilizadas para usuários individuais. Em ambientes com múltiplas plataformas de múltiplos
fornecedores, o número de plataformas que receberem suporte é reduzido para um. Com a
adoção de redes de computadores, o gerenciamento dos dados pode permanecer centralizado
enquanto o processamento é feito localmente.

Em resumo Java possui os seguintes características:
• Orientação a objetos
• Portabilidade
• Multitheading
• Suporte à comunicação
• Acesso remoto a banco de dados


Linguagem Java

A linguagem Java é o meio utilizado pelos desenvolvedores para escreverem código fonte.
Applets e aplicativos escritos na linguagem Java são compilados para um arquivo executável na
plataforma Java. A linguagem Java é orientada a objetos, tipada, multitheaded, dinamicamente
“linkada” e possui um mecanismo automático de garbage collection. Sua sintaxe é baseada em C e
C++, de maneira que os programadores familiarizados com estas linguagens podem se adaptar
facilmente.
A linguagem Java oferece aos desenvolvedores a capacidade de fazer três tipos de
programação em uma única linguagem. Assim como a linguagem de programação simbólica
smalltalk, Java é orientada a objetos, é dinamicamente “linkada” e possui uma hierarquia de classe
com herança simples. Para programação numérica, Java possui seus tipos de dados independentes
de plataforma, limites de arrays e uma aritmética IEEE bem definida. Estas capacidades permitem
uma boa base para a escrita de algoritmos numéricos que produzem resultados repetitivos. Para
programação de sistemas, as expressões, as instruções e os operadores da linguagem Java são, na
maioria das vezes, os mesmos da linguagem C.

Plataforma Java básica

A plataforma Java básica é a plataforma mínima que os desenvolvedores podem assumir de
modo seguro que está presente para se executar applets e aplicativos Java. Esta plataforma se aplica
a redes de computadores, computadores pessoais e estações de trabalho. Esta plataforma contém a
mesma JVBM mencionada anteriormente, mas possui uma API mínima conhecida como API básica
Java. Os desenvolvedores podem escrever programas com esta API mínima sem se preocuparem
com bibliotecas de classes adicionais.


Applets e aplicativos

A plataforma Java permite a criação de dois tipos de programas distintos:

• applets – são programas que necessitam de um navegador para serem executados. A tag line
<applet> é inserida em uma página HTML com o nome do programa a ser executado. Ao ser
acossada, pela Internet ou uma intranet corporativa, o automaticamente transferido do servidor e é
executado na máquina cliente.
207
• Aplicativos - são programas que não necessitam um navegador para serem ex< e não são
transferidos automaticamente como os applets. Ao ser chamado, o a é executado da mesma
forma que os programas escritos em outra linguagem.

JavaOS

Java OS é um sistema operacional que implementa a Plataforma Java Básica para executar
applets e aplicativos. O JavaOS é projetado para redes de computadores e dispositivos para redes de
computadores, tais como impressoras, copiadoras e controladores industriais. Estes dispositivos
podem ser ligados instantaneamente e dispensam administração de sistemas e, quando em uma
rede, podem ser automaticamente atualizados.

Por Dentro da Plataforma Java

A Plataforma Java pode ser dividida em duas partes, a Máquina Virtual Java (JVM - Java
Virtual Machine) e a API Java, conforme mostra a figura abaixo.

Aplicativos e applets
API Básica Java AP! estendida Java padrao
Classes Java Básica Classes Java de Extensao padrao
Máquina Virtual Java {JVM)
Interface de Portabilidade
Adaptador Adaptador Adaptador JavaOS
Navegador
Sistema
Operacional
Sistema
Operacional
Sistema
Operacional
Hardware

Hardware

Hardware

Hardware


A JVM funciona como um computador virtual que pode ser implementado em software ou
hardware. Trata-se de uma máquina abstrata projetada para ser implementada sobre os
processadores existentes. A interface de portabilidade e os adaptadores permitem que a JVM seja
facilmente portada para um novo sistema operacional sem a necessidade de ser completamente re-
escrita.
A API Java constitui a interface padrão para applets e aplicativos independente do sistema
operacional. A API Java define as funcionalidades essenciais para o desenvolvimento de aplicativos.
A API Básica Java provê a linguagem básica e os serviços de I/O, rede, GUI e applets. A API
Estendida Padrão Java estende as funcionalidades de Java além da API básica.
Na Figura acima, a Plataforma Java Básica é mostrada em preto, incluindo os blocos dos de
Adaptador. A API Java inclui tanto a API Básica quanto a API Estendida As classes constituem a
implementação das APIs. A JVM está no núcleo da plataforma. A interface de portabilidade fica entre
a JVM e o sistema operacional ou navegador. Esta interface de portabilidade possui uma parte
independente de plataforma (em preto) e uma parte dependente da plataforma (Adaptador). O
sistema operacional e o JavaOS são os elementos que efetivamente implementam as funcionalidades
de janela, arquivo e rede. Máquinas diferentes podem ser conectadas através de uma rede conforme
mostrado na figura acima. A API Java é aberta e extensível.

208
Máquina Virtual Java {JVM - Java Virtual Machine)

A JVM é a chave para a independência de sistema operacional e hardware. Na realidade a
JVM encapsula e esconde as particularidades do sistema operacional e do hardware oferecendo uma
interface única de execução de código. A JVM define um formato binário de arquivo (.class)
independente de plataforma. Este formato inclui as instruções de um computador virtual na forma de
bytecodes.

API Básica Java

Utilizando as APIs disponíveis na Plataforma Java, os desenvolvedores têm a garantiade que
suas aplicações funcionarão em qualquer JVM. Atualmente, a API Básica Java é definida como API
de Applet Java. Ao longo do tempo, conforme o amadurecimento da plataforma, esta API básica
poderá crescer, ao passo que algumas classes da API Estendida Padrão migrarem para a API
Básica.

API Estendidad Padrão

A API Estendida Padrão Java define um conjunto de extensões padrões, pois geram uma API
publicada, uniforme e aberta, que pode ser implementada por qualquer pessoa. Uma vez definidas,
elas podem ser incrementadas mantendo compatibilidade com as versões anteriores. Ao longo do
tempo, novas extensões podem ser adicionadas e algumas delas podem migrar para a API Básica
Java.

Compilador e Ambiente de Execução Java
Um Ambiente de Desenvolvimento Java inclui o ambiente de compilação e o a execução,
como na figura abaixo. A Plataforma Java é representada pelo ambiente de execução. O
desenvolvedor escreve o código fonte Java (arquivo .java) e o compila em bytecodes (arquivo .class).
Estes bytecodes são instruções para a JVM. Para se criar um applet, o desenvolvedor armazena os
bytecodes em um servidor HTTP e adiciona, em uma página html, a tag line < applet code = filename
> que nomeia o ponto de entrada do arquivo de bytecode.
Quando o usuário visita esta página, a tag line < applet > faz com que os arquivos bytecode
sejam transferidos pela rede do servidor para o navegador do usuário na Plataforma Java. No passo
seguinte, os bytecodes são carregados na memória e então são verificados os aspectos de
segurança antes de serem carregados na JVM.
Uma vez carregados na JVM, os bytecodes são interpretados pelo interpretador, e
normalmente são transformados em código de máquina pelo gerador de código JIT (Just-In_Time)
também conhecido como compilador JIT. O interpretador e o compilador JIT operam no contexto do
sistema de execução (Threads, memória e outros recursos do sistema). Qualquer classe da biblioteca
de classes Java (API) são dinamicamente carregados conforme a necessidade do applet.
















209



Anexo B
Resumo dos conceitos abordados sobre a Linguagem Java.

Java é uma linguagem de programação orientada a objetos desenvolvida pela Sun
Microsystems para ser portável entre diferentes plataformas.

Algumas Características

• É orientada a objetos.
• É portável, isto é, seus programas podem ser utilizados em diferentes plataformas.
• Seu código de programação é interpretado, o que garante maior velocidade de desenvolvimento e
portabilidade.
• Permite que o programa execute mais de um Thread (linha de execução).

A linguagem de programação Java possui um ambiente de desenvolvimento e um ambiente
de aplicativos. Ela resulta da busca de uma linguagem com as características do C++ aliadas à
segurança do Smalltalk.

Recursos

O JVM – Java Virtual Machine – cria uma máquina imaginária, implementada por meio da
emulação de um software executado em uma máquina real. O código do JVM está armazenado em
um arquivo .class.
O JVM fornece as especificações da plataforma de hardware, o que permite a independência
de plataforma, uma vez que o programa é compilado em uma máquina imaginária. Essas
especificações consistem em instruções e registro de linguagem de máquina, tamanho de cache,
velocidade do processador etc.

Coleta de Lixo

A garbage collection varre as memórias cujo ponteiro possui número de referência 0. Ocorre
automaticamente durante o tempo de vida de um programa.

Ambiente Java de Compilação

COMPILAÇÃO TEMPO DE EXECUÇÃO




















CodIgo fonte
arquIvo .java
Classe
arquIvo.class
Carregamento
da classe
7erIfIcação
do bytecode
Interpretação
JÌT - Code
Cenerator
Tempo de
execução
Hardware
O código é executado
Gerador de código „just-in-
time“
210
Figura 1 - ambiente Java de compilação


Durante o Processo de Compilação

Os arquivos são compilados à medida que são convertidos para bytecodes. Em tempo de
execução, os bytecodes são carregados, verificados e executados. Durante a execução, são feitas as
chamadas ao hardware subjacente.
O carregamento de classe é responsável pela carga de todas as classes necessárias à
execução do programa.
O interpretador verifica se foi gerado algum código ilegal, com a finalidade de verificar se o
bytecode adere às especificações JVM e não viola a integridade e a segurança do sistema.
Na geração de código, os bytecodes são compilados no código de máquina nativo antes da
execução, isto é, o código é interpretado para a plataforma em questão.
Para desenvolver programas, será necessário utilizar o Java Development Kit (JDK), um
ambiente de desenvolvimento que, além das ferramentas de desenvolvimento, contém todos os
elementos da plataforma Java. É possível adquirir o JDK gratuitamente no site da Sun:
www.sun.com.br

Arquivos do JDK

Quando se instala o JDK, é criada a seguinte estrutura de diretório:

0ìretòrìo conteúdo
.hotjava ConfIguração de cppletvìewer para uso do J0K
bIn ArquIvos bInárIos (executáveIs e bIblIotecas) do J0K.
demo Exemplos de aplIcações e cpplets.
docs 0ocumentação da APÌ.
Include ArquIvos utIlIzados para Integração com o codIgo natIvo.
lIb Classes da APÌ.
src CodIgo fonte das classes. Somente será crIado se for especIfIcado
como opção na Instalação do J0K. Ds arquIvos desse dIretorIo podem
ser utIlIzados para depuração.

Algumas Definições

Modificadores – têm a função de modificar a atribuição de classes, métodos e variáveis-
membro. São utilizados como prefixos.
Construtores – são utilizados para inicializaram objeto após a sua criação.
Um construtor tem o mesmo nome da classe em que reside e não tem tipo de retorno, pois o tipo de
retorno é implícito e é do mesmo tipo da classe em que reside.
Métodos – são os conjuntos de instruções executáveis de uma classe.
Código fonte – são os arquivos que contem as instruções escritas na linguagem de
programação escolhida, no caso, Java. O código fonte pode ser escrito em um editor de textos como
o Edit do DOS ou o Notepad do Windows. Os arquivos devem ser salvos com um nome (que deve
ser idêntico ao nome da classe), com um ponto (.) e com a extensão, que deve ser java. Por
exemplo: teste.java,média.java,cadastro.java etc.

1. //Exemplo de programa em Java
2. public class Ola{
3. public static void main(String args[]){
4. System.out.println(“Ola para todos!”);
5. }
6. }

Entendendo as Instruções do Código Fonte:

1. // inicia um comentário, utilizado para incluir explicações no meio do código.
211
2. A palavra public é um especificador de acesso que permite ao programador controlar a
visibilidade de uma classe ou método. class Ola é a identificação do nome da classe.
3. static void main – o main é o principal método. O Java procura esse método para
interpretar uma classe. O void é um modificador utilizado quando não é necessário retorno. O
main é declarado como static,pois não é preciso fazer referência a uma distância, uma vez
que ele é chamado pelo interpretador antes que quaisquer instância sejam criadas, isto é, o
main não irá requerer a chamada de uma instância dessa classe. O String args [] determina a
criação de um vetor chamado args, com elementos do tipo String utilizados para a entrada
de parâmetros.
5. System – nome da classe; out – nome do objeto da classe System, responsável pela saída;
println – método utilizado para exibir mensagens na tela do computador.
6. Os blocos de programa são delimitados por chaves. Esses blocos devem ser abertos { e
fechados }.

Nota: Esse arquivo deve ser gravado com o nome Ola.java, pois deve levar o mesmo nome da
classe.

Compilador Javac

O código fonte contém instruções de alto nível, isto é, instruções em uma linguagem que o
homem é capaz de compreender, mas a máquina não. Por isso, o código fonte precisa ser compilado.
O arquivo responsável pelo processo de compilação em Java é o Java compiler, chamado javac.
O javac gera, a partir do código fonte, um arquivo de bytecodes. Esse arquivo terá o mesmo
nome do arquivo fonte, mas com a extensão .class. Por exemplo: teste.class,
media.class, cadastro.class etc.

Código fonte Bytecode




Figura 2 – Diagrama de representação do processo de compilação

Para compilar um arquivo, basta digitar javac e o nome do arquivo. Por exemplo, no prompt
do DOS, conforme o modelo:

c:\> javac Ola.java

Exitem algumas opções que podem ser utilizadas para compilar o programa. Para isso,
utiliza-se a sintaxe javac [opções] arquivo [arquivo...]. Essas opções são relacionadas a
seguir:

javac [opções] arquivo [arquivos...]


Opções:

-classpath path[;...] - localização das classes das classes já devidas. Sobrepõe a variável de
ambiente CLASSPATH.

-d dir – especifica o diretório raiz onde as classes compiladas serão armazenadas.

-deprecation – ativa as mensagens de advertência que indicam os membros ou as classes
que estão em desuso.

-g - cria tabelas de debugging que serão usados pelo debugger. Contém informações como
variáveis locais e números de linha. A ação default do compilador é somente gerar números de
linhas. A opção -g:nodebug suprime a geração dos números de linha.

-nowarn – desativa as mensagens de advertência que informam problemas potenciais com o
código fonte.


medIa.java

java.class

CodIgo de
máquIna

javac

Interpretação
212
-depend – efetua a compilação de todos os arquivos que dependem do código fonte que está
sendo compilado. Sem essa opção, são compilados apenas os arquivos cujas classes são invocadas
no arquivo que está sendo compilado.

-O – otimiza o código compilado para gerar programas mais rápidos. Na versão 1.1. inclui o
código de todos os métodos, em vez de simplesmente invocá-los (call); aumenta o tamanho dos
arquivos compilados

-J opção – passa a string opção como argumento para o interpretador que irá executar esse
código. A string opção não pode conter espaços em branco. O argumento -J pode ser usado
múltiplas vezes

Exemplo:

javac – classpath .;c:\classes Ola.java
javac Ola.java Teste.java

Para Interpretar o Programa

Para executar (utilizar) o programa, basta digitar, no prompt do DOS, a palavra java seguida
do nome do programa. Por Exemplo:

c:\> java Ola

Palavras Reservadas

Anteriormente foi abordado o assunto identificadores (nomes) de variáveis, sobre o qual foi
dito que não se devem utilizar palavras reservadas à linguagem de programação. A seguir são
apresentadas as palavras reservadas à linguagem Java.

abstract default goto null synchronized
boolean do if package this
break double implements private throw
byte else import protected throws
case extends instanceof public transient
catch false int return true
char final interface short try
class finally long static void
const float native super volatile
continue for new switch while

Essas palavras não podem ser usadas como nomes de variáveis, métodos, interfaces ou
classes.

Variáveis

A declaração de variáveis em Java pode ser feita em qualquer parte do programa, e a
variável pode ser declarada e inicializada. Para relembrar os tipos de dados em Java, consulte o
Capítulo 3.
Exemplos:

byte idade;
short a1;
int i = 100;
long 1 = 5000;/* L:identificador long */
float v1,v2=4.578f; /* f.identificador float */
double d= 5,02e19; /* notação científica */
char h = 'h';
boolean resposta = true;
/* String são objetos, mas podem ser inicializados como tipos
primitivos */
213
String cadeia = “String em Java não é tipo primitivo”;

As variáveis podem ser declaradas dentro de uma classe. São as chamadas variáveis-
membro, que podem ser acessadas por qualquer conjunto de instruções da classe. Já as variáveis
declaradas dentro de um dos métodos da classe são chamadas de variáveis locais.

Modificadores de Variáveis

public – a variável é visível por todos.
private – a variável só é visível pela classe.
protected – a variável só é visível para a classe onde foi criada e para suas herdeiras.
private protected – a variável é visível somente para as subclasses.
static - a variável será chamada pelo nome da classe e não por um objeto dela.
final – a variável não pode ter seu valor alterado, pois é uma constante.

Comentários

Às vezes torna-se importante a escrita de textos no meio do código do programa para explicar
algo. Isso é denominado comentário e é um recurso muito utilizado para documentar partes do
código. Em Java, os comentários podem ser feitos de três maneiras:

// - para uma linha de comentários, por exemplo:// comentário
/* - para um trecho de comentários. O trecho deve ser delimitado, por exemplo: /*
trecho */
/** - para documentação. O trecho deve ser delimitados, por exemplo: /** trecho */

Modificadores de classes

public – pode ser instanciada e utilizada livremente, mesmo da classe interna.
protected – pode ser utilizada apenas no mesmo package ou em subclasses da classe
externa.
private – pode ser utilizada apenas na classe externa.
abstract – não pode ser instanciada. Esse modificador é utilizado para definir apenas
superclasses genéricas.
final – não permite definição de subclasses.

Modificadores de métodos e variáveis_membro

public – pode ser chamado livremente e as variáveis-membro podem ser utilizadas
livremente.
protected – os métodos e as variáveis-membro podem ser chamadas apenas no mesmo
package e em subclasses; as variáveis-membro seguem o mesmo padrão.
private – os métodos e as variáveis-membro podem ser chamados apenas na classe.
abstract – não podem ser definidos nem métodos nem variáveis-membro.
final – os métodos não podem ser subescritos; é utilizado para declarar constantes.
static – tanto os métodos como as variáveis-membro podem ser invocados a partir do
nome da classe.
native – é utilizado para a definição de métodos em código nativo. Não se aplica a
variáveis-membro.
transient – não se utiliza em métodos e não há persistência em variáveis-membro.
synchronized – para métodos, não permite acesso simultâneo e programas multithread.
Não se aplica a variáveis-membro.
volatile – não é aplicável à definição de métodos e em variáveis-membro não permite
cache.


Exceções

214

Throwable

ExceptIon

Error
O tratamento de exceções é realizado por um método que o Java possui para detecção de
erros. O tratamento de exceções é também conhecido como tratamento de erros, pois os erros são
capturados por esse recurso, que gera um alerta para o usuário.
As exceções ou erros são derivados da superclasse Throwable, conforme pode se observado
a Figura 3.














ÌlegalAccessExceptIon LInkageError
ÌnstantIatIonExceptIon Thread0eath
CloneNotSupportedExceptIon 7Irtual|achIneError
ÌnterruptedExceptIon AWTError
NoSuch|ethodExceptIon
ClassNotFoundExceptIon
AWTExceptIon
FuntImeExceptIon
ÌDExceptIon


RuntìmeExceµtìon l0Exceµtìon LìnkayeError VìrtualMachìneError
EmptyStockExceptIon EDFExceptIon ClassCIrcularItyError ÌnternalError
NoSuchElementExceptIon FIleNotFoundExceptIon ClassFormatError DutDf|emoryError
ArIthmetIcExceptIon ÌnterrupterÌDExceptIon ÌncompatIbleClassChangeError StackDverflowError
ArrayStoreExceptIon UTF0ataFormatExceptIon NoClass0efFoundError UnknownError
ClassCastExceptIon |alformedUFLExceptIon UnsatIsfIeldLInkError
ÌllegalArgumentExceptIon ProtocolExceptIon 7erIfyError
Ìllegal|onItorStartExceptIon SocketExceptIon
ÌndexDutDf8oundsExceptIon UnknownHostExceptIon
NullPoInterExceptIon UnknownServIceExceptIon
NegatIveArraySIzeExceptIon
SecurItyExceptIon

ArrayÌndexDutDf8oundExceptIon Abstract|ethodError
StrIngÌndexDutDf8oundsExceptIon ÌlegalAccessError
ÌnstantIatIonError
ÌlegalThread8oundsExceptIon NoSuchError
NumberFormatExceptIon NoSuch|ethodError





215

Descrição de algumas classes

Exception – são exceções genéricas que podem ser tratadas.
Error – são erros graves que normalmente não podem ser tratados.
RunTimeException – são as exceções geradas por erros de programação.
NullPointerException – é uma exceção associada à tentativa de acesso a propriedades
ou métodos de referências com valor null.
ArithmeticException – é uma exceção associada à tentativa de utilização incorreta de
operadores aritméticos como, por exemplo, a divisão por zero.
IndexOutOfBoundsException – é uma exceção associada a índices de vetores ou strings.
ArrayStoreException – é uma exceção gerada pela tentativa de atribuir a um elemento
de um array um objeto incompatível com o tipo declarado do array.

A captura das exceções deve ser feita da seguinte forma:

try {
//código que PODE gerar uma exceção
} catch(Exception e){// captura da exceção
//código executado no tratamento da exceção
}


Sendo que o código que pode gerar um exceção deve ser descrito no bloco try. Essas
exceções, por sua vez, são capturadas no bloco catch (), que deve especificar os argumentos
(exceções a serem tratadas).

Passagem da exceção pelo método:

void metodo1() throws IOException {
// código que pode gerar uma exceção IOException
}

Lançamento de exceção:

void metodo2() throws IOException {
// testa condição de exceção
if(excep) then throw(new IOException());
}

Classes mais utilizadas

1. String

A classe String provê objetos que são mais seguros e simples de utilizar do que os arrays
de caracteres. Os objetos String são constantes e não podem ser alterados.
Os objetos da classe String podem ser inicializados por atribuição direta, isto é, quando se
declara um objeto, já se atribui um valor a ele. Por exemplo:
String nome = “Rafael”;

A concatenação de strings é feita utilizando o operador +. Por exemplo:
nome + “Rissetti”; //o resultado será “Rafael Rissetti” e ficará
armazenado na variável nome.



Construtores

new String (char[] c) – constrói uma String a partir de um array de caracteres.
new String (String s) – constrói uma String a partir de uma outra String.
216
new String (StringBuffer sb) – constrói uma String a partir de um
Stringbuffer.


Principais métodos

public char charAt (int indice) – retorna o caracter na posição dada por indice.
public int campareTo (String var) – compara uma string com parâmetro String
var e retorna zero se ambas forem iguais, um número negativo se a String for menor e um
número positivo se for maior.
public static String CopyValueOf (char []) - retorna uma String com o
conteúdo do array de caracteres var.
public boolean equals (object o ) - verifica se o é uma string com a mesma
seqüência de caracteres.
Public boolean equalsIgnoreCase (String var) – compara uma string com a
String var. As diferenças entre maiúsculas e minúsculas são ignoradas.
Public int length () - retorna o comprimento da string.
Public int indexOf (int var) – retorna o índice da primeira ocorrência do caracter
var.
public int indexOf (int var, int início) - retorna a índice da primeira
ocorrência do caracter var a partir de ínicio.
public char [] toCharArray () - retorna um array com os caracteres da string.
Public String toLowerCase () - retorna uma cópia da string com todas as letras
convertidas para minúsculas.
public String toUpperCase () - retorna uma cópia da string com todas as letras
convertidas para maiúsculas.
public String trim () - elimina os espaços em branco no início e no fim da string.

Exemplos:
String nome = “Rafael”;
if (nome.equals(“rafael”.toUpperCase()))...
char [] teste = nome.toCharArray();

2. Classe que representa datas - java.util.date

A classe java.util.Date representa datas.

Construtores

new Date() - cria uma data que representa o momento de sua criação.
new Date(long tempo) - cria uma data com o tempo em milessegundos após 1ºde janeiro
de 1970.


Principais métodos

public long getTime() - retorna os milessegundos da data.
public void setTime (long temp) – especifica a data com o tempo em
milessegundos.
public boolean before(Date data) - retorna true se data é anterior a data.
public boolean after(Date data) - retorna true se data é posterior a data.
public int compareTo(Date data) - retorna 0 se a data é igual a data,um número
negativo se é anterior e um positivo se é posterior.

Exemplos:
Date data1 = new Date();
Date data2 = new Date();
System.out.println(“Resposta: “+ data1.after(data2));


217
3. Classes de Entrada e Saída

java.io.BufferedReader – filtro que age sobre um Reader, adicionando um buffer e
otimizando o acesso aos dados.

Construtores

new BufferedReader(Reader rd) - constrói um BufferedReader a partir de um
Reader rd, com buffer de tamanho default.

Principais métodos

public int read() throws IOException – lê um caractere da entrada-padrão.
public int read(char[]c,int início, int quant)throws IOException – lê
uma seqüência quant de caracteres e a coloca no array c a partir da posição dada por início.
Retorna o número de caracteres lidos (-1 se não houver caracteres para ler).
public String readLine()throws IOException – lê uma linha de caracteres.
public void close()throws IOException – fecha o Reader.

Exemplos:
BufferedReader arq;
arq = new BufferedReader(new FileReader(“arquivo”));
String linha;
try {
linha = arq.readLine();
} catch(IOException e){}


java.io.BufferedWriter – filtro que age sobre um Writer, adicionando um buffer e
otimizando o acesso aos lados.

Construtores

new BufferedWriter(Writer wr) - constrói um BufferedWriter a partir de um
Writer wr,com buffer de tamanho default.

Principais Métodos

public void Write()throws IOException – escreve um caracter na saída.
public void writer(char[]c,int início, int quant)throws IOException –
escreve quant,caracteres no array c a partir da posição dada por inicio.
public void newLine()throws IOException – inicia uma nova linha.
public void flush()throws IOException – descarrega a saída, forçando a escrita de
caracteres que eventualmente estejam no buffer.
public void close()throws IOException – fecha o Writer.

Exemplo:

BufferedWriter saída;
saída = new BufferedWriter (new FileWriter(“arquivo”);
String linha = “linha do texto”;
try {

saida.write(linha,0,s.lengt());
saida.newLine();
} catch (IOException e){}


218
java.io.RandomAccessFile - é um stream de entrada e saída específico para arquivos,
cujo acesso não precisa ser seqüêncial. Permite especificar se o modo de acesso será somente para
leitura ou para escrita e leitura.

Construtores

public RandomAccessFile(String arq,String modo) throws IOException –
cria um objeto para acesso a arquivo e o associa ao arquivo especificado em arq;modo especifica o
modo de acesso que pode ser: r(somente para leitura) ou rw(leitura e escrita).
public RandomAccessFile(String arq,String modo) throws IOException –
cria um objeto para acesso a arquivo e o associa ao arquivo especificado por arq;modo especifica o
modo de acesso que pode ser: r (somente para leitura) ou rw (leitura e escrita).

Principais métodos

public int read() throws IOException – lê um byte do arquivo.
public int read(byte[]x) throws IOException – lê um array de bytes do arquivo,
se houver informações e retorna o número total de bytes lidos, se não retorna -1.
public int read(byte[]x,int início,int qtd) throws IOException – lê uma
seqüência de qtd bytes e a coloca no array x a partir da posição dada por início.Retorna o
número de bytes lidos ou então -1.
public int readLine() throws IOException – lê uma linha de caracteres do arquivo.
public int skipBytes(long x) throws IOException – descarta x bytes da
entrada e retorna número de bytes que foram descartados.
public void seek(long x) throws IOException – posiciona o cursor de
leitura/escrita na posição x do arquivo (em bytes).
public long getFilePointer() throws IOException – retorna a posição corrente
do cursor, em bytes.
public long skipBytes(long x) throws IOException – descarta x bytes da
entrada.
public long length() throws IOException – retorna o tamanho do arquivo em
bytes.
public void setlength(long x) throws IOException – especifica o tamanho do
arquivo em bytes.
public void write()throws IOException – escreve um byte no arquivo.
public void write(byte []b)throws IOException – escreve um array de bytes no
arquivo.
public void write(byte[]x,int início,int qtd) throws IOException –
escreve a quantidade de bytes determinados por qtd bytes do array x a a partir da posição
determinada por início no arquivo.
public void close()throws IOException – fecha o arquivo.


4. File

A classe java.io.file representa um arquivo ou um diretório.

Construtores

new File(String path) - cria um objeto File que representa um arquivo na patch
especificado.
new File(String dir,String nome) - cria um o objeto File que representa um arquivo
no diretório dir com o nome especificado.
public File(File dir,String nome) - cria um objeto File que representa um arquivo
no diretório dir com o nome especificado.

Principais métodos

public boolean canRead() - verifica se o arquivo pode ser lido.
219
public boolean canWrite() - verifica se o arquivo pode ser escrito.
public int compareTo(File x) – compara o path com o de outro arquivo
determinado por x e retorna 0 se ambos forem iguais.
public void delete() - apaga o arquivo associado a esse objeto.
public boolean exists() - verifica a existência do arquivo ou diretório.
public Starting getName() - retorna o nome do arquivo ou diretório.
public String getPath() - retorna o path do objeto.
public boolean isDirectory() - verifica se o objeto representa um diretório.
public boolean isFile() - verifica se o objeto representa um arquivo.
public long length() - retorna o tamanho do arquivo.
public String[] list() - retorna a lista de arquivos se o objeto representar um
diretório.
public void mkdir() - cria um diretório.
public void renameTo(File x) – renomeia um arquivo ou diretório de acordo com o
nome determinado por x.

220
Anexo C

Classes do pacote Swing

Introdução

Este capítulo aborda a utiliza
ção de classes já disponíveis no Java, apropriadas para a criação de aplicações gráficas, conhecidas
inicialmente como pacote AWT – Abstract Window Toolkit. Entretanto, como tudo tem sua evolução, o
pacote AWT foi substituído pelo swing pertencente à biblioteca JFC (Java Foundation Classes),
portanto o swing é uma extensão das classes AWT, sendo parte integrante do Java 2. por este motivo
este capítulo dará enfoque às classes do swing que possuem diversas vantagens e muitos
aprimoramentos em relação às classes da AWT – melhor aparência, melhor tratamento de eventos,
recursos estendidos entre outros.
A diferença básica entre as classes do swing em relação às do pacote AWT está na presença
da letra J antes do início do nome da classe. Por exemplo: para inserir um botão do pacote AWT , é
usada a classe Button, já para usar um botão do pacote swing é usada a classe JButton. O mesmo
vale para todas as classes do swing, pois todas iniciam com J.
As aplicações gráficas são aquelas que possibilitam a criação de uma GUI (Graphical User
Interface – Interface Gráfica do Usuário). Ao desenvolver uma aplicação dotada de uma GUI, é
necessário definir quais componentes serão utilizados e qual a disposição que eles terão na janela. O
swing possui inúmeras classes que podem ser utilizadas na construção da GUI. Nesse ponto, a
linguagem começa a ficar mais interessante, pois é abandonada a tela monótona do shell (DOS ou
LINUX), partindo para janelas gráficas. Ao projetar uma aplicação gráfica, é necessário definir todos
os componentes que serão utilizados, quais seus objetivos e sua posição na janela.
Neste capítulo serão abordados os componentes mais utilizados na criação de janelas. Um
componente da GUI é um objeto visual (criado a partir de classes Java) que possibilita ao usuário
realizar a interação com a aplicação por meio do mouse e do teclado. Os componentes mais comuns
são: etiquetas, botões, caixas de texto, barras de rolagem, menus, objetos de múltipla escolha, entre
outros. Conforme será apresentado, cada um dos componentes possui propriedades que podem ser
alteradas em tempo de desenvolvimento ou execução (cor, tamanho, fonte, etc), assim como em
outras linguagens de programação. Todas as classes do swing são extensões do pacote AWT que,
por sua vez, são extensões da classe java.lang.Object, a superclasse de todas as classes do Java.

Todas as classes que serão elaboradas neste capítulo necessitam de diversas classes
externas, tanto do pacote swing como do AWT. Por este motivo todos os exemplos apresentados
terão três linhas com a diretiva import apontando para as classes externas, conforme as declarações
seguintes:

n) import java.awt.*; - permite a utilização de diversas classes do pacote AWT, além de possuir
uma série de constantes numéricas.
o) Import java.awt.event.*; - usado para o processamento dos eventos que ocorrerão na janela, tais
como: click do mouse, ENTER do campo texto, etc.
p) Import javax.swing.*; - permite a utilização de diversas classes do pacote swing.


Criação de Frames

Frame é o componente do pacote AWT responsável pela criação de janelas parecidas com as
encontrada em aplicativos do ambiente Windows. O componente frame gera uma janela com barra de
título, bordas e pode ter outros componentes em seu interior. Imagine o componente frame como uma
folha de projetos em que são inseridos diversos objetos. Em conjunto com esses objetos, o
componente frame gera uma visualização gráfica de um determinado aplicativo.
O exemplo1 demonstra a criação de uma janela por intermédio da classe JFrame do pacote
swing.


import java.awt.*;
import java.awt.event.*;
221
import javax.swing.*;

class ExIntGrafica1 extends JFrame{
ExIntGrafica1(){ //construtor
setTitle("Exemplo sobre interface gráfica"); //titulo da janela
setSize(400,50); //dimensoes da janela (largura e comprimento)
setLocation(150,150); //canto esquerdo e topo da tela
setResizable(false); //a janela não pode ser redimensionada
getContentPane().setBackground(Color.gray); // cor de fundo da
janela
}
public static void main(String args[]) {
JFrame janela = new ExIntGrafica1(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a jenala na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}
}

Os aspectos mais importantes do exemplo1 são:

linha 4: class ExIntGrafica1 extends Jframe{ - toda aplicação gráfica necessita utilizar as
funcionalidades da classe JFrame, responsável por controlar a exibição da janela. A palavra
extends (lembre-se do conceito de herança) informa que a classe ExIntGrafica1 irá utilizar todos
os recursos da classe JFrame. Resumindo: a classe ExIntGrafica1 herdará todas as
características da classe JFrame e terá outras características próprias, definidas pelo seu método
construtor, no caso o método ExIntGrafica1 (mesmo nome da classe).
Linha 6: ExIntGrafica1() - é o construtor da classe que mantém uma série de informações a
respeito da janela a ser criada, tais como: o título da janela, suas dimensões, sua localização na
tela, a cor de fundo, entre outras. Em todas as aplicações com janelas, o método construtor define
as características que a janela terá ao ser exibida.
Linha 17: JFrame janela = new ExIntGrafica1() - é declarado um objeto com o nome janela,
contendo as características da classe ExIntGrafica1 e sua inicialização é realizada.
Linha 18: janela.show() - a janela é apresentada na tela do método show().
Linhas 20 a 27 – são as instruções responsáveis pelo fechamento da janela. Se esses comandos
não fosse colocados, a janela do DOS/LINUX não poderia ser fechada pelo simples pressionar do
botão fechar. A janela da aplicação Java é encerrada, entretanto a janela do DOS fica “travada”.


A tabela 1 mostra um resumo dos métodos mais utilizados da classe JFrame:

Método Função
JFrame()
Cria uma janela vazia
getTitle() Obtém o título da janela
isResizable() Verifica se a janela é ou não dimensionável
setResizable(boolean) Especifica se a janela é ou não dimensionável
setTitle(String) Especifica o título da janela
Tabela 1 – resumo dos métodos da classe JFrame


Inclusão de textos e imagens na janela

Para a inclusão de textos nos frames, é necessário a utilização da classe JLabel. É possível
controlar várias propriedades do texto a ser utilizado, tais como: alinhamento, tipo de letra, tamanho,
cor, etc. A declaração de um objeto JLabel no programa observa a seguinte sintaxe:

222
JLabel <nome do label> = new JLabel (“texto do label”, Jlabel.<alinhamento>)

Para inclusão de imagens na janela, pode ser usada a classe ImageIcon por meio da seguinte
sintaxe:
ImageIcon <nome do ícone> = new ImageIcon(“caminho e nome da imagem a ser inserida”). Ao
inserir o caminho do arquivo, deve ser utilizada a barra normal (/). a barra invertida (\) é
considerada caractere reservado para a quebra de linha. Depois de criado o objeto que armazena
a imagem, ele deve ser inserido na janela por meio do JLabel, da mesma forma que um texto é
inserido. Desse modo, o modo JLabel pode ser usado para inserir um texto, uma imagem, ou
ainda os dois ao mesmo tempo, separados por vírgula.

O exemplo2 demonstra a utilização da classe JLabel para incluir textos e figuras em uma
janela:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class ExIntGrafica2 extends JFrame{
JLabel L1, L2, L3, L4;
ImageIcon icone = new ImageIcon("c:/Windows/Cloud.gif");

ExIntGrafica2(){ //construtor
setTitle("Inserindo Labels e Imagens na janela"); //titulo da janela
setSize(400,150); //dimensoes da janela (largura e comprimento)
setLocation(50,50); //canto esquerdo e topo da tela
getContentPane().setBackground(new Color(220,220,220)); // cor de
fundo da janela
L1 = new JLabel(" Aprendendo",JLabel.LEFT);
L1.setForeground(Color.red);
L2 = new JLabel(icone);
L3 = new JLabel("Inserir ",JLabel.RIGHT);
L3.setForeground(Color.blue);
L4 = new JLabel("Labels e imagens",icone,JLabel.CENTER);
L4.setForeground(Color.black);
getContentPane().setLayout(new GridLayout(4,1));
getContentPane().add(L1);
getContentPane().add(L2);
getContentPane().add(L3);
getContentPane().add(L4);
}
public static void main(String args[]) {
JFrame janela = new ExIntGrafica2(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a jenala na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}
}

Os aspectos mais iomportantes do exemplo2 são:

• Linha 6: contém a declaração dos objetos da classe JLabel, utilizados para armazenar e
manipular o texto. Eles são alinhados durante o procedimento da inicialização por meio de
constantes inteiras predefinidas pela linguagem (JLabel.LEFT que equivale a zero,
JLabel.CENTER que equivale a um e JLabel.RIGHT que equivale a dois). Quando o alinhamento
não for especificado, o default á à esquerda.
• Linha 7: contém a declaração de um ícone que será usado em conjunto com um label. O objeto
ícone está sendo declarado e inicializado com o endereço em que a imagem se localiza a partir do
disco C da máquina.
• Linha 13: define a cor de fundo da janela utilizando setBackground(new Color(220,220,220)).
Os números que aparecem dentro dos parênteses se referem ao padrão RGB (Red-Gree-Blue) e
223
definem as tonalidades das cores vermelha, verde e azul. Os números para a tonalidade podem
variar de 0 (mínimo) a 255 (máximo) e sua mistura irá formar uma cor específica.
• Linha 15: define a cor da fonte do objeto L1. Observe a formação: L1.setForeground(Color.red).
Da esquerda para a direita essa declaração pode ser interpretada assim: para o objeto L1 utilize a
cor de fonte (setForeground) vermelha (Color.red).
• Linha 16: contém a inicialização do label L2 com o objeto ícone. Observe que da mesma forma
que ocorre com o texto, um objeto Label pode ser inicializado com uma imagem. Dessa forma o
label L2 terá uma imagem atrelada a ele, e não um texto.
• Linha 19: contém a inicialização do label L4 como um texto e uma imagem. Esta é outra variação
de um objeto label: ele pode ser inicializado com um texto, uma imagem ou ambos.
• Linha 20: realiza a formatação do texto do label L4, definindo que será utilizada a fonte serif, em
negrito e com tamanho 20. Font.BOLD também é uma constante da linguagem Java.
• Linha 22: getContentPane().setLayout(new GridLayout(4,1)) – todos os componentes
visualizados nas janelas de aplicações gráficas, tais como: Labels, botões, caixas de texto, etc.,
necesitam ser inseridos em locais predefinidos da janela, conhecidos por células. Para dividir uma
janela em células, é necessária a utilização de um gerenciador de layout, ou seja, um método que
controla a maneira como os componentes serão dispostos na janela. Esta é uma função de
setLayout(), ou seja, é utilizado para definir como o frame será dividido. Nesse exemplo,
setLayout() define que o frame está composto por uma grade de quatro linhas e uma coluna (4,1)
em que os componentes serão inseridos. A representação da divisão do frame pode ser
interpretada da maneira seguinte:

Célula 1
Célula 2
Célula 3
Célula 4

Neste caso a janela foi dividida em quatro células, em que os componentes podem ser
inseridos. Caso não fosse definido o tipo de layout a ser usado na janela, o frame seria considerado
como contendo uma só célula. Existem diversos tipos de gerenciadores de layout em Java, os quais
demonstrados à medida que forem usados nos exemplos.

• Linhas 22 a 26: contém o método add() utilizado para adicionar componentes ao frame. Os
componentes são inseridos no frame à medida que aparecem no programa. A ordem com que os
componentes são inseridos é muito importante para sua correta disposição na janela. Ao usar o
add(), os componentes são inseridos linha a linha (sempre de cima para baixo). Neste exemplo a
grade possui apenas uma coluna; caso existissem mais colunas, o preenchimento seria realizado
da seguinte forma: linha1_coluna1, linha1_coluna2, linha2_coluna1, linha2_coluna2 e assim
sucessivamente. Sendo assim, o preenchimento da janela é dado sempre de cima para baixo
(linhas) e da esquerda para a direita (colunas).

O exemplo2 ainda não possui nenhuma funcionalidade, apenas serve para demonstrar a
inclusão de texto e imagem na janela.


A tabela 2 mostra um resumo dos métodos mais utilizados da classe JLabel:


Método Função
JLabel() Cria um label sem texto
JLabel(String) Cria um label com o texto dado
JLabel(String,int) Cria um label com o texto e o alinhamento dados
JLabel(String,image) Cria um labelI com o texto e imagem dados
JLabel(String,image,int) Cria um label com o texto, imagem e alinhamento
dados
getText() Obtém o texto do label
224
Método Função
setText() Especifica o texto do label
Tabela 2 – resumo dos métodos da classe JLabel


Inclusão de botões nas janelas

Para inclusão de botões nos frames, é utilizada a classe JButton. Da mesma forma que no
JLabel, muitas propriedades podem ser manipuladas em Jbutton. Observe o exemplo3 que mostra o
uso dessa classe:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class ExIntGrafica3 extends JFrame implements ActionListener{
JButton b1,b2;
ImageIcon icone = new ImageIcon("c:/Windows/Cloud.gif");

ExIntGrafica3(){ //construtor
setTitle("Inserindo botons na janela"); //titulo da janela
setSize(350,100); //dimensoes da janela (largura e comprimento)
setLocation(50,50); //canto esquerdo e topo da tela
getContentPane().setBackground(new Color(180,180,180)); // cor de
fundo da janela
b1 = new JButton("Busca", icone);
b1.setHorizontalTextPosition(AbstractButton.LEFT);
b1.setBackground(new Color(100,180,180));
b1.setForeground(Color.black);
b1.setFont(new Font ("ScriptS",Font.BOLD,20));
b1.setEnabled(true);
b1.addActionListener(this);
b1.setToolTipText("Pressione aqui para fazer uma busca");
b1.setMnemonic(KeyEvent.VK_B);
b2 = new JButton("Cancelar");
b2.addActionListener(this);
b2.setMnemonic(KeyEvent.VK_C);
b2.setToolTipText("Pressione aqui para cancelar");
getContentPane().setLayout(new FlowLayout());
getContentPane().add(b1);
getContentPane().add(b2);
}

public void actionPerformed(ActionEvent e){
//metodo implementado pelo ActionListener
if (e.getSource() == b1){
System.out.println("Botao 1 pressionado");
}
if(e.getSource() == b2){
System.out.println("Botao 2 pressionado");
}
}
public static void main(String args[]) {
JFrame janela = new ExIntGrafica3(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a jenala na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}
}


Os aspectos mais importantes do exemplo3 são:
225

• Linha 5: (implements ActionListener) – em qualquer aplicação em que asações do
usuáriodevem ser interpretadas quando eles interagem com a janela (clicar num botão, por
exemplo), é necessária a implementação de uma interface. Neste exemplo foi utilizada a interface
ActionListener. Como será visto mais adiantem outras interfaces podem ser utilizadas. Quando
uma implementação de interface é utilizada, torna-se obrigatório inserir na aplicação um ou vários
métodos que que realizarão o processamento dos eventos. Ao contrário das linguagens de
programação visuais (como Delphi, Visual Basic entre outras), não existe um método separado
para cada evento gerado em uma janela. Em Java, existe a presença de apenas alguns métodos,
comuns a todos os componentes, e actionPerformed é um deles. Devido ao fato de não existir
um método para cada evento dos componentes de uma janela, dentro do método
actionPerformed é necessário verificar qual dos componentes é responsável pela geração do
evento. Em outras palavras, é necessário reconhecer em qual componente o usuário clicou, ou
deu ENTER e assim por diante. As linhas 29 a 39 executam a tarefa de reconhecer qualdos
botões foi pressionado.
• Linha 15: da mesma forma que u label, um objeto do tipo botão pode ser incializado de três
maneiras: somente com um texto 9 o título do botão), com uma imagem ou com ambos. Esta linha
inicializa o botão com um texto e uma imagem, definida na linha 8.
• Linha 16:define a posição do texto em relação à imagem inserida no botão pelo método
setHorizontalTextPosition. Essa propriedade deve ser definida quando o botão possuir imagem
e texto ao mesmo tempo. O default é o texto aparecer ao lado direito da imagem. Isso pode ser
modificado por meio da constante LEFT que fará o texto aparecer ao lado esquerdo da imagem.
De maneira semelhante pode ser definido o alinhamento vertival do texto pelo método
setVerticalTextPosition, usando as constantes (TOP topo) ou BOTTOM (abaixo).
• Linha 17:define a cor do fundo do botão por meio do método setBackground da mesma forma
que um label ou qualquer outro objeto utilizado em uma janela.
• Linha 18:define a cor do título do botão (cor do texto) por meio do método setForeground da
mesma forma que um label ou qualquer outro objeto utilizado em uma janela.
• Linha 19: define a fonte do título do botão pelo método setFont. Neste exemplo a fonte definida é
do tipo AcriptS, em egrito (Font.BOLD) e de tamanho 20.
• Linha 20: define que o botão está habilitado (true) pelo método setEnabed. Essa condição é
default, uma vez que todos os botões ao serem inicializados já estão habilitados. Sendo assim, ela
não necessitaria ter sido definida. Para definir que um botão fique desativado, basta colocar false
dentro dos parênteses.
• Linha 21: registra o botão B1 para que o evento seja gerado por ele. Todo objeto inserido em um
frame deve ser registrado para que os eventos gerados pro ele sejam reconhecidos. Se um objeto
não for registrado, ele não terá nenhuma ação; ficará apenas como uma imagem estática. Dessa
forma é necessário registrar os objetos e essa é a função do método addActionListener(this).
Assim com o botão B1, todo botão deve ser adicionado ao processador de eventos. Se esse
método não for invocado, o botão não poderá realizar nenhuma função e será um botão
inoperante. Em outras palavras, todo botão que recebe um clique para realizar alguma função
necessita invocar o método addActionListener, de forma que o método actionPerformed (linha
33) possa reconhecê-lo.
• Linhas 16 e 17:os métodos setBackground e setForeground são, respectivamente, usados para
trocar a cor do fundo e a cor do texto de um botão.
• Linha 22:adidiona uma mensagem ao botão por meio do método setToolTipText. Quando o
ponteiro do mouse parar sobre o botão, essa mensagem será mostrada. Esse método pode ser
usado também em outros tipos de botão (CheckBox, Radio, etc.).
• Linha 23:adiciona uma letra sublinhada ao título do botão pelo método setMnemonic.
Pressionando a tecla ALT em conjunto com a tecla B, o botão é acionado, como se o mouse
tivesse clicado sobre ele. Esse método também pode ser usado em outros tipos de botão ou
menus.
• Linhas 24 e 25: inicializam o botão B2.
• Linha 28: define o gerenciador de layout utilizado na janela como sendo do tipo seqüência de
fluxo: setLayout(new FlowLayout(). FlowLayout é outro tipo de gerenciador de layout utilizado
para controlar o layout dos componentes inseridos na janela. É o mais simples dos gerenciadores
de layout, pois os componentes são arranjados da esquerda para a direita na ordem em que são
adicionados ao frame. Se não houver mais espaço na linha formada pelos componentes
adicionados, é criada outra linha abaixo desta, seguindo o mesmo critério de formação. O
gerenciador FlowLayout() possibilita que os componentes sejam distribuídos em linhas, como os
editores de texto fazem com as palavras de um parágrafo, isto é, preenchem a linha até que haja
226
espaço; ao terminar o espaço, muda para a linha abaixo. As linhas 29 e 30 adicionam os botões à
janela, primeiro o B1 e depois o B2.
• Linha 33: contém o método que recebe todas as ações disparadas na janela, ou seja, todos os
eventos gerados a partir da interação do usuário com a aplicação. Esse método deve ser
declarado como: public void actionPerformed(ActionEvent e), o qual é responsável por
reconhecer todas as ações do usuário sobre a janela. Sua utilização é obrigatória quando o frame
implementa a interface ActionListener, definida na linha 5. a letra e é declarada como um objeto
da classe ActionEvent e receberá todos os chamados aos eventos da janela. Todos os eventos
gerados serão tratados por esse método actionPerformed e o objeto ActionEvent será
responsável por definir qual objeto gerou esse evento.
• Linha 35: contém a declaração if (e.getSource() == B1) que quer dizer: se o objeto-fonte do
evento (e.getSource()), isto é, se o objeto que gerou o evento for o botão B1. Dessa forma é
reconhecido o objeto ActionEvent, no caso, o objeto e. Caso essa comparação seja verdadeira,
será impressa uma mensagem indicando que o botão 1 foi pressionado (linha 37). os mesmos
procedimentos ocorrem por meio das linhas 39 a 42 para o botão B2.


A tabela 3 mostra um resumos dos métodos mais utilizados da classe JButton:


Método Função
Button() Cria um botão sem texto
Button(String) Cria um botão com texto dado
Button(String, image) Cria um botão com texto e imagem dados
getLabel() Obtém o texto do botão
setLabel(String) Especifica o texto do botão
setEnabled(boolean) Define se o botão está habilitado (true) ou
desabilitado (false)
setHorizontalTextPosition() Define o tipo de alinhamento horizontal do texto
em relação a uma imagem. Pode assumir LEFT
(esquerda) ou RIGHT (direita)
setMnemonic Define uma letra que será usada como
acionadora do evento click, em conjunto com a
tecla ALT.
setToolTipText Possibilita atrelar uma mensagem ao botão.
Quando o ponteiro do mouse estaciona sobre o
botão, a mensagem é apresentada.
setVerticalTextPosition() Define o tipo de alinhamento vertical do texto em
relação a uma imagem. Pode assumir TOP (topo)
ou BOTTOM (abaixo)
Tabela 3 – resumo dos métodos da classe JButton


Inclusão de caixas de texto

Para inclusão de caixas de texto nos frames, é utilizada a classe JtextField que também
possui várias propriedades que podem ser modificadas. O exemplo4 demonstra o uso desta classe
para simular uma simples calculadora em que o usuário digita dois números em dois JtextFields e
clica em um dos quatro botões existentes no frame (+, -, *, /) para realizar um cálculo. Este exemplo
agrupa as classes JFrame, JLabel e JButton, estudadas até aqui.


import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class ExIntGrafica4 extends JFrame implements ActionListener{
JLabel L1, L2, L3;
227
JButton B1,B2,B3,B4,B5;
JTextField T1, T2, T3;

public static void main(String args[]){
JFrame janela = new ExIntGrafica4();
janela.show();
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica4(){
setTitle("Calculadora");
setSize(350,90);
setLocation(50,50);
getContentPane().setBackground(new Color(150,150,150)); // cor de
fundo da janela
getContentPane().setLayout(new GridLayout(3,4)); // 3 linhas e 4
colunas
L1 = new JLabel("Num.1");
L1.setForeground(Color.black);
L1.setFont(new Font("",Font.BOLD,14));
L2 = new JLabel("Num.2");
L2.setForeground(Color.black);
L2.setFont(new Font("",Font.BOLD,14));
L3 = new JLabel("Total");
L3.setFont(new Font("",Font.BOLD,14));
B1 = new JButton("+");
B1.addActionListener(this);
B2 = new JButton("-");
B2.addActionListener(this);
B3 = new JButton("x");
B3.addActionListener(this);
B4 = new JButton("/");
B4.addActionListener(this);
B5 = new JButton("Limpar");
B5.addActionListener(this);
B5.setBackground(Color.black);
B5.setForeground(Color.white);
T1 = new JTextField();
T2 = new JTextField();
T3 = new JTextField();
T3.setEditable(false); //define que o textField como seomente
leitura
getContentPane().add(L1);
getContentPane().add(T1);
getContentPane().add(B1);
getContentPane().add(B2);
getContentPane().add(L2);
getContentPane().add(T2);
getContentPane().add(B3);
getContentPane().add(B4);
getContentPane().add(L3);
getContentPane().add(T3);
getContentPane().add(B5);
}

public void actionPerformed(ActionEvent e){
if(e.getSource() == B5){
T1.setText("");
T2.setText("");
T3.setText("");
return;
}
float N1=0,N2=0,result = 0;
228
try{
N1 = Float.parseFloat(T1.getText());
N2 = Float.parseFloat(T2.getText());
}catch(NumberFormatException erro){
T3.setText("Erro!");
return;
}
if (e.getSource() == B1){ //botao somar
result = N1 + N2;
}
if (e.getSource() == B2){ //botao subtrair
result = N1 - N2;
}
if (e.getSource() == B3){ //botao multiplicar
result = N1 * N2;
}
if (e.getSource() == B4){ //botao dividir
result = N1 / N2;
}
T3.setText(""+result);
}

}

Os aspectos mais importantes do exemplo 4 são:

ll) Observe que o método main sempre foi inserido por último nos exemplos anteriores, dessa vez
aparece antes do método construtor. Isso não representa nenhum problema, pois a ordem tanto
faz, uma vez que os métodos são separados uns dos outros pelas chaves de abertura e
encerramento. A posição em que os métodos são declarados na classe tanto faz,
mm) linha 9: declara as três caixas de texto usadas na aplicação (T1, T2, T3)
nn) As linhas 36 a 40 inicializam e registram os cinco botões utilizados na aplicação.
oo) Linha 42: inicializa as caixas de texto em branco, isto é, as caixas de texto aparecem sem
nenhum texto. A caixa de texto pode ser inicializada com um texto default se necessário, por
exemplo: T1 = new JTextField(“Linguagem Java”). A dimensão da caixa de texto pode ser
controlada com a utilização de um número inteiro dentro dos parênteses, por exemplo T1 = new
JTextField(25). Entretanto, isso é válido somente quando o gerenciador de layout utilizado no
frame for FlawLayout, pois ao utilizar GridLayout a caixa de texto assume o tamanho da célula,
independentemente do tamanho utilizado.
pp) Linha 43: T3.setEditable(false) – esse recurso é utilizado para que a caixa de texto, no caso
T3, não possa ser alterada pelo usuário. É uma forma de fazer coma que a caixa de texto seja
somente leitura.
qq) Linhas 44 e 49: adicionam todos os objetos à janela, exatamente na ordem em que
aparecem.
rr) Linhas 52 a 79: possuem o método actionPerformed que é utilizado para manipular todas as
ações da aplicação. Conforme já citado, esse método recebe um ActionEvent usado para
verificar e reconhecer qual foi o objeto que disparou o evento.
ss) Linha 54: se foi pressionado o botão limpar (if e.getSource() == B5), então todas as caixas de
texto são limpas (setText(“”)). A instrução return 57 encerra o método actionPerformed, isto é,
nenhuma instrução abaixo no código será executada.
tt) Linhas 60 a 64: realizam a conversão dos valores digitados em valores numéricos, uma vez que o
conteúdo de um objeto JTextField é um texto e não pode ser usado diretamente para a realização
de cálculos matemáticos. Caso haja algum erro de conversão, no caso do usuário não ter digitado
um valor numérico, uma mensagem de erro irá aparecer no campo T3 (linha 67).
uu) para cada operação disponível na calculadora existe e.getSource com a função de
reconhecer o evento gerado.
vv) Linha 78: T3.setText(“”+result) – a variável result é utilizada para armazenar o resultado da
operação escolhida pelo usuário, porém trata-se de uma variável numérica que não pode ser
inserida diretamente em uma caixa de texto. Esta linha demonstra como é simples a conversão de
número em texto por meio de “” + result, ou seja, o resultado da operação é concatenado com
um texto vazio. Quando um número é concatenado com um texto, o resultado final transforma-se
em texto.
ww) Ressalta-se que toda vez que for necessário ler o conteúdo de um campo texto, utiliza-se o
método getText() e toda a vez que for necessário armazenar algo no campo texto, usa-se o
229
método setText().



A tabela 4 mostra um resumo dos métodos mais utilizados da classe JTextField:


Método Função
JTextField() Cria uma caixa de texto vazia
JTextField(String) Cria uma caixa de texto com a String dada
JtextField(String, int) Cria uma caixa de texto com a String e a
quantidade de colunas especificada
JTextField(int) Cria uma caixa de texto com a quantidade de
colunas especificada
getText() Obtém o texto do objeto
getSelectedText() Obtém o texto selecionado no objeto
IsEditable() Verifica se o componente é editável ou não
selectAll() Seleciona todo o texto
setEditable(boolean) Especifica se o componente é editável ou não
setText() Especifica o testo a ser contido no componente.
Tabela 4 – resumo dos métodos da classe JTextField


Inclusão de caixas de senha

Para inclusão de caixas de senha nos frames, é utilizada a classe JpasswordField.O
funcionamento da classe JpasswordField é praticamente o mesmo da classe JTextField. A
diferença é que o caracter digitado é substituído por outro caractere para esconder a senha digitada.
O caractere default que aparece no momento da digitação é o “*”, entretanto qualquer caractere pode
ser definido pelo método setEchoChar().
O exemplo 5 traz um aplicativo que reconhece e aceita a digitação de uma senha e quando o
usuário pressiona a tecla ENTER sobre o JPasswordField, sem a necessidade do uso de botões.
Assim como é possível registrar um botão para gerar um evento, também é possível registra um
campo texto ou um campo de senha. Este aplicativo simula uma tela de entrada em algum sistema,
em que o usuário digita uma senha. A aplicação imprimirá uma mensagem que mostra se a senha foi
ou não aceita. O exemplo compara a palavra digitada com a palavra JAVA para verificar a validade
da senha.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class ExIntGrafica5 extends JFrame implements ActionListener{
JLabel L1, L2;
JTextField T1;
JPasswordField P1;

public static void main(String args[]){
JFrame janela = new ExIntGrafica5();
janela.show();
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica5(){
230
setTitle("Verifica Senha");
setSize(350,65);
getContentPane().setBackground(new Color(150,150,150)); // cor de
fundo da janela
getContentPane().setLayout(new GridLayout(2,2)); // 3 linhas e 4
colunas
L1 = new JLabel("Digite a SENHA:");
L2 = new JLabel("Validação:");
L1.setForeground(Color.black);
L2.setForeground(Color.black);
L1.setFont(new Font("",Font.BOLD,14));
L2.setFont(new Font("",Font.BOLD,14));
T1 = new JTextField();
T1.setForeground(Color.red);
P1 = new JPasswordField();
P1.setEchoChar('*');
P1.addActionListener(this); //registra P1
getContentPane().add(L1);
getContentPane().add(P1);
getContentPane().add(L2);
getContentPane().add(T1);
}

public void actionPerformed(ActionEvent e){
try{
if(P1.getText().equals("JAVA"))
T1.setText("Senha válida");
else
T1.setText("Senha inválida");
}catch(Exception erro){}
}

}

Os aspectos mais importantes do exemplo 5 são:

11. Linha 9: declara P1 como sendo um objeto da classe JPasswordField.
12. Linha 37: inicializa o objeto JPasswordField com o conteúdo vazio, exatamente como feito com
um objeto do tipo JTextField.
13. Linha 38: define o caractere que substituirá o caractere digitado. Se essa linha não for declarada,
o caractere “*” será usado.
14. Linha 39: registra o objeto P1 para gerar um evento, da mesma forma que um botão é registrado.
Esse evento será gerado quando o usuário pressionar ENTER quando o foco estiver sobre o
objeto P1.
15. Linha 46: realiza a comparação do texto digitado com a senha “JAVA”. Caso o texto digitado e a
senha sejam iguais, o campo T1 receberá a mensagem “Senha válida” (linha 47); caso contrário,
T1 receberá “Senha inválida” (linha 49). Observe que no método actionPerformed não existe a
necessidade de verificar qual foi o objeto gerador do evento, uma vez que apenas o objeto P1 foi
registrado na aplicação, ou seja, apenas o objeto P1 poderá gerar eventos e, conseqüentemente,
invocar o método actionPerformed.



Formatação de caixas de texto

Em muitos casos torna-se necessário realizar a formatação das caixas de texto,
principalmente quando valores numéricos são inseridos. Para realizar a formatação, podem ser
utilizadas diversas classes da linguagem Java. Este item apresenta um exemplo bem simples de
formatação de um número inteiro e de um número de ponto flutuante (double). Observe o exemplo 6.

231
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.text.NumberFormat;

class ExIntGrafica6 extends JFrame implements ActionListener{
JTextField T1,T2;
double valor1 = 1000.54;
int valor2 = 100;
NumberFormat df1, df2;

public static void main(String args[]){
JFrame janela = new ExIntGrafica6();
janela.show();
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica6(){
setTitle("Formatando números");
setSize(350,65);
getContentPane().setBackground(new Color(150,150,150)); // cor de
fundo da janela
getContentPane().setLayout(new GridLayout(1,2)); // 3 linhas e 4
colunas
df1 = NumberFormat.getNumberInstance();
df1.setMinimumFractionDigits(4);
df2 = NumberFormat.getNumberInstance();
df2.setMinimumFractionDigits(4);
T1 = new JTextField();
T2 = new JTextField();
T1.setText(""+df1.format(valor1));
T2.setText(""+df2.format(valor2));
getContentPane().add(T1);
getContentPane().add(T2);
}

public void actionPerformed(ActionEvent e)
{}
}

Os aspectos mais importantes do exemplo 6 são:

14. Linha 4: para realizar a formatação de números, deve ser importada a classe NumberFormat
(existem outras como DecimalFormat) da classe Text.
15. Linha 10: declara dois objetos df1 e df2 que serão instâncias da classe NumberFormat. Esses
objetos receberão algumas configurações usadas na formatação de números.
16. Linhas 32 e 34: inicializam os objetos df1 e df2 coma instãncia default da máquina do usuário,
definida pelo sistema operacional.
17. Linhas 33 e 35: definem a quantidade de casas que será usada na formatação do número.
18. Linhas 38 e 39: formatam o número de acordo com o formato definido nas 33 e 35 pelo método
format.
19. Linha 43: apesar de este exemplo não gerar evento, deve ser declarado o método
actionPerformed, pois a classe ExIntGrafica6 está implementando a interface actionListener.
Se Implements ActionListener for retirada da linha 5, o método actionPerformed também pode
ser retirado (linhas 43 e 44).


232

Inclusão de listas de seleção

As listas de seleção são objetos que possibilitam a escolha de um ou vários valores
armazenados em uma lista de opções. Essa lista é manipulada a partir da classe JList. Para
utilização e melhor desempenho das lista de seleção, torna-se necessário realizar alguns
procedimentos, conforme a listagem seguinte:

16) Declarar um objeto para instanciar a classe JList
17) Declarar um objeto que conterá a lista das opções e adicionar a eles todas as opções.
18) Inicializar o objeto do item 1 com o objeto do item 2.
19) Criar um painel de rolagem.
20) Adicionar o objeto do item 1 ao painel de rolagem.

O exemplo7 demonstra como criar uma lista seguindo os procedimentos anteriores. Neste
exemplo são usados os principais métodos envolvidos coma manipulação de listas de seleção. O
usuário pode adicionar itens à lista (digitando na caixa de texto e pressionando ENTER), remover
itens, verificar o índice selecionado e verificar a quantidade de itens existentes na lista.


import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

class ExIntGrafica7 extends JFrame implements ListSelectionListener,
ActionListener{
JLabel L1;
JList lista;
JTextField T1;
JButton bquant, bindice,bclear;
DefaultListModel listModel;

public static void main(String args[]) {
JFrame janela = new ExIntGrafica7(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a janela na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica7(){ //construtor
setLocation(300,100); //canto esquerdo e topo da tela
setTitle("Uso do JListBox"); //titulo da janela
setSize(200,250); //dimensoes da janela (largura e comprimento)

T1 = new JTextField();
T1.addActionListener(this);
L1 = new JLabel("Sem selecao");
L1.setForeground(Color.black);
bquant = new JButton("Quantidade de itens");
bquant.addActionListener(this);
bindice = new JButton("Indice selecionado");
bindice.addActionListener(this);
bclear = new JButton("Remove item");
bclear.addActionListener(this);
listModel = new DefaultListModel();
listModel.addElement("banana");
listModel.addElement("pera");
listModel.addElement("maca");
listModel.addElement("uva");
lista = new JList(listModel);
233
lista.addListSelectionListener(this); //registra a lista
JScrollPane painel = new JScrollPane(lista);
getContentPane().setLayout(new GridLayout(6,1));
getContentPane().add(L1);
getContentPane().add(T1);
getContentPane().add(painel);
getContentPane().add(bquant);
getContentPane().add(bindice);
getContentPane().add(bclear);
}
public void actionPerformed(ActionEvent e){
//metodo implementado pelo ActionListener
if (e.getSource() == T1){
listModel.addElement(T1.getText()); //adiciona itens a lista
T1.setText("");
}
if(e.getSource() == bquant){
T1.setText("Quantidade: "+listModel.getSize());
}
if(e.getSource() == bindice){
T1.setText("Indice selecionado: "+lista.getSelectedIndex());
}
if(e.getSource() == bclear){
int index = lista.getSelectedIndex();
L1.setText("Removido: "+lista.getSelectedValue());
listModel.remove(index);
}
}
public void valueChanged(ListSelectionEvent e){
L1.setText("Selecionado: "+lista.getSelectedValue());
}
}


Os aspectos mais importantes do exemplo7 são:

• Linha 4: importa o pacote javax.swing.event para a manipulação dos eventos do JList. Cada vez
que o usuário escolhe um item da lista é gerado um evento que será tratado pelo método
valueChanged (linha 80).
• Linha 7: contém a implementação de duas interfaces: ActionListener e ListSelectionListener
(para tratamento dos eventos do JList). A implementação da interface ListSelectionListener se
faz necessária para que as opções do JList possam ser reconhecidas à medida que o usuário
realiza a escolha, da mesma forma que foi implementada a interface ActionListener para o
componente JButton. Quando a interface ListSelectionListener é utilizada, torna-se obrigatória a
declaração do método valueChanged.
• Linha 11: Declara lista como sendo um objeto da classe JList.
• Linha 13: declara listModel como sendo sendo um objeto da classe DeafultListModel – os itens
de um JList devem ser armazenados inicialmente em um objeto do tipo DefaultListModel para
depois serem inseridos na lista, portanto esse objeto irá conter todas as opções da lista. Observe
as linhas 44 a 49: o objeto listModel é inicializado, as opções são adicionadas e ele é adicionado
ao objeto JList.
• Linha 50: lista.addListSelectionListener(this) – para que a opção escolhida seja reconhecida no
momento da ação do usuário, o método addListSelectionListener deve ser invocado, registrando
o objeto da mesma forma que é feito com um botão. Desta forma é possível que o programa
realize uma ação no momento que a opção for escolhida.
• Linha 51: JscroolPane painel = new JscroolPane(lista) – declara e inicializa um objeto
chamado painel coma lista criada a partir da classe JList. Esse objeto painel é do tipo painel de
rolagem, criado a partir da classe JScroolPane. A lista deve ser adicionada a um painel de
rolagem para que seja possível navegar pelas opções existentes.
• Linha 65: contém o método addElement responsável por inserir um elemento (opção) na lista.
Observe que os elementos adicionados são inseridos no objeto listModel e não no objeto lista. No
caso, está sendo inserido na lista o texto contido no campo T1:
listModel.addElement(T1.getText()).
• Linha 69: verifica a quantidade de elementos existente na lista pelo método getSize():
T1.setText(“Quantidade: ”+listModel.getSize()). Esse método retornará um número inteiro
234
correspondente à quantidade de elementos que será inserida no campo T1.
• Linha 71: verifica qual dos elementos da lista está selecionado pelo método getSelectedIndex():
T1.setText(“Indice selecionado” + lista.getSelectedIndex()). Esse método retornará um número
inteiro correspondente ao elemento selecionado, em que o primeiro elemento terá índice 0, o
segundo índice 1 e assim sucessivamente. Esse método torna-se importante no sentido de
reconhecer qual das opções o usuário escolheu. Por exemplo: suponha que numa lista existam as
opções dinheiro, cheque, cartão. Dependendo da escolha feita pelo usuário, é possível realizar
procedimentos diferentes no programa, como, por exemplo, dar um desconto caso o pagamento
escolhido seja em dinheiro.
• Linha 75: contém o método getSelectedValue() que retorna o texto do elemento selecionado na
lista. Enquanto o método getSelectedIndex() retorna um número inteiro referente ai índice
selecionado, o método getSelectedValue() retorna o texto referente à opção escolhida. Nesta
linha o label L1 irá receber o texto referente ao item selecionado na lista que será removido.
• Linha 76: contém o método remove() responsável por remover um elemento da lista de acordo
com o índice fornecido dentro dos parênteses. Em outras palavras, se for necessário remover o
primeiro item da lista, deve-se utilizar lista.remove(0). Uma vez que o primeiro item da lista inicia
em zero. Nesta linha o item selecionado, armazenado por meio da linha 74, será removido.
• Linha 80: public void valueChanged(ListSelectionEvent e) – contém a declaração do método
que é executado no momento em que o usuário escolhe uma das opções da lista com o clicar do
mouse, ou com o mover das setas direcionais, ou seja, toda vez que o elemento selecionado for
mudado. Neste exemplo, apenas o objeto lista irá gerar esse evento, sendo desnecessário
verificar qual objeto foi o responsável pela execução do método, entretanto, caso existissem
outros objetos que gerassem esse evento, a verificação da fonte da geração seria necessária ,
algo do tipo: if(e.getSource == lista1). Ou seja, deveria ser realizado um procedimento
semelhante ao inserido no método actionPerformed quando diversos botões são usados


A tabela 5 mostra um resumo dos métodos mais utilizados da classe JList:


Método Função
JList() Cria uma caixa de seleção
getSelectValue() Obtém o texto do item slecionado
getSelectedIndex() Obtém o índice do texto selecionado
setSelectedIndex() Seleciona o índice especificado
setSelectedInterval(int,int) Seleciona diversos índices dentro do intervalo
especificado
isSelectionEmpty() Verifica se existe algum item selecionado na lista,
retornando verdadeiro ou falso.
IsSelectedIndex(int) Verifica se o índice está selecionado, retornando
verdadeiro ou falso
Tabela 5 – resumo dos métodos da classe JList

A tabela 6 mostra um resumo dos métodos mais utilizados da classe DefaultListModel():


Método Função
addElement(String) Adiciona o texto como um novo item da lista
getSize() Obtém a quantidade total de itens da lista
remove(int) Remove o item do índice especificado
235
Tabela 6 – resumo dos métodos da classe DefaultListModel.

Outra possibilidade das lista é a múltipla seleção, ou seja, m,ais de uma opção pode ser
escolhida ao mesmo tempo. Existem duas formas de seleção: a contínua. Em que diversos itens
podem ser selecionados em seqüência (uso da tecla SHIFT), e a alternada, na qual os itens podem
ser selecionados alternadamente (uso da tecla CTRL). Para tornar essa característica possível, deve
ser utilizado o método setSelectionMode(modo_de_seleção), em que modo de seleção pode ser 1
(seleção em seqüência) ou 2 (seleção alternada). Se você desejar mudar o exemplo 7 para que
possa selecionar diversos itens ao mesmo tempo, acrescente a linha lista.setSelectionMode(1); logo
após a linha 50. ressalta-se que ao trabalhar com múltipla seleção, diversos índices podem estar
selecionados ao mesmo tempo, o que impõe a utilização do método setSelectedIndex([]) que retorna
um array de índices selecionados.

Inclusão de caixas de seleção

As caixas de seleção são criadas a partir da classe JcomboBox e permitem que o usuário
selecione apenas um item de sua lista, ao contrário da JList, em que mais de um item pode ser
selecionado. O componente JcomboBox funciona praticamente da mesma forma que o JList, porém
há diferenças entre os métodos para manipulação de suas propriedades.
Observe o exemplo 9.8 que demonstra como utilizar vários métodos para manipulação do
LcomboBox.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

class ExIntGrafica8 extends JFrame implements ActionListener, ItemListener{
JLabel L1;
JTextField T1, T2, T3;
JComboBox combo;
JButton B1,B2,B3,B4,B5,B6,B7,B8;

public static void main(String args[]) {
JFrame janela = new ExIntGrafica8(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a janela na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica8(){ //construtor
setTitle("Uso do JComboBox"); //titulo da janela
setSize(400,170); //dimensoes da janela (largura e comprimento)

getContentPane().setBackground(new Color(190,190,190));
L1 = new JLabel("Conteudo");
L1.setForeground(Color.blue);
L1.setFont(new Font("Arial",Font.BOLD, 15));
B1 = new JButton("Mostra o texto");
B1.addActionListener(this);
B2 = new JButton("Mostra Indice");
B2.addActionListener(this);
B3 = new JButton("Adiciona item");
B3.addActionListener(this);
B4 = new JButton("Remove item");
B4.addActionListener(this);
B5 = new JButton("Remove todos os itens");
B5.addActionListener(this);
B6 = new JButton("Quantidade de itens");
B6.addActionListener(this);
T1 = new JTextField();
236
T2 = new JTextField();
String[] cores = {"Branco","Vermelho","Azul","Verde"};
combo = new JComboBox(cores);
combo.addItemListener(this);
getContentPane().setLayout(new GridLayout(5,2));
getContentPane().add(L1);
getContentPane().add(combo);
getContentPane().add(B1);
getContentPane().add(B4);
getContentPane().add(B2);
getContentPane().add(B5);
getContentPane().add(B3);
getContentPane().add(T1);
getContentPane().add(B6);
getContentPane().add(T2);
}
public void actionPerformed(ActionEvent e){
if (e.getSource() == B1){
L1.setText("Texto" + combo.getSelectedItem());
}
if(e.getSource() == B2){
L1.setText("Indice" + combo.getSelectedIndex());
}
if(e.getSource() == B3){
if(T1.getText().length() != 0){
combo.addItem(T1.getText());
}
}
if(e.getSource() == B4){
combo.removeItemAt(combo.getSelectedIndex());
}
if(e.getSource() == B5){
combo.removeAllItems();
}
if(e.getSource() == B6){
T2.setText("" +combo.getItemCount());
}
}

public void itemStateChanged(ItemEvent e){
T1.setText("" +combo.getSelectedItem());
}
}

OS aspectos mais importantes do exemplo 9.8 são:

14) Linha 5: implementa a interface ItemListener responsável por reconhecer quando ocorre a
mudança da opção selecionada no componente combo.
15) Linha 9: declara combo como sendo um objeto da classe JcomboBox.
16) Linha 41: String [] cores = {“Branco”, “Vermelho”,”Azul”,”Verde”} : contém a declaração
de um array de strings chamada cores que será adicionado ao JComboBox. Esse Array deve ser
formado por todos os elementos (opções) que o combo terá, separados por vírgula.
17) Linha 42: combo = new JComboBox(cores): realiza a inicialização do objeto combo. Sua
lista conterá as strings armazenadas no array cores.
18) Linha 43: registra o objeto combo para que a mudanças de seleção sejam reconhecidas e
tratadas pelo método itemStateChanged. O evento será gerado quando o usuário escolher uma
das opções do combo, seja com mouse ou com o teclado.
19) Linha 55: contém um método getSelectdItem() utilizado para retornar o conteúdo do texto
selecionado, isto é, retorna o texto da opção selecionado pelo usuário.
20) Linha 57: contém o método getSelectdIndex() utilizado para retornar um valor inteiro
contendo o índice da opção selecionada. Se estiver selecionada a opção 1, o método retorna o
número 0 (zero), se a opção 2 estiver selecionada, o método retorna o número 1 (um) e assim
sucessivamente.
21) Linha 61: contém o método addItem() usado para adicionar um item à lista do objeto combo,
no caso está sendo adicionado o conteúdo do campo texto T1.
22) Linha 65: contém o método removeItemAt() utilizado para remover um item da lista a partir
237
de um índice especificado. Utilizando em conjunto com o método getSelectdItem() , o item a ser
excluído será aquele que estiver selecionado na lista.
23) Linha 67: contém o método removeAllItems() utilizado para limpar o conteúdo de um
JcomboBox, ou seja, remover todos os seus itens de uma só vez.
24) Linha 69: contém o método getItemCount() utilizado para retornar a quantidade de
elementos existentes no objeto combo.
25) Linha 71: contém o método itemStateChangel que é executado toda vez que o usuário
seleciona uma das opções do componentes JcomboBox. Dessa forma, cada vez que uma opção
for selecionada, o conteúdo texto dessa opção aparecerá no campo texto T1, de acordo com a
linha 73.






Método Função
jComboBox (String) Cria uma caixa de seleção JcomboBox com um
array do tipo string.
addItem (String) Adiciona o texto como um novo item
getSelectedItem() Obtém o texto do Item selecionado
getItemCount() Obtém a quantidade total de itens
getSelectedIndex() Obtém o índice do item selecionado
removeItemAT(int) Remove o item com o indice especificado
removeAllitens(0 Remove todos os itens da lista.
Tabela 7 – resumo dos métodos da classe JComboBox






Inclusão de caixas de opção

As caixas de opção são criadas a partir da classe JcheckBox e permitem representar uma
opção que está ativada (true) ou desativada (false). As caixas de opção são utilizadas para exibir
várias opções dentre as quais o usuário pode optar por selecionar nenhuma, uma ou várias delas.
Como exemplo prático de utilização, suponha um site de uma livraria em que o usuário aponta todos
os gêneros de livro de seu interesse. O exemplo 9.9 demonstra a funcionalidade do JcheckBox
controlando a formatação de um determinado texto, de acordo com a escolha do usuário.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class ExIntGrafica9 extends JFrame implements ItemListener{
JLabel L1;
JCheckBox C1,C2;
static int negrito = 0,italico = 0;

public static void main(String args[]){
JFrame janela = new ExIntGrafica9();
janela.show();
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
238
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica9(){
getContentPane().setBackground(new Color(180,180,180));
setTitle("Uso do CheckBox");
setSize(300,70);
getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER));
L1 = new JLabel("Java");
L1.setFont(new Font("",Font.PLAIN,20));
L1.setForeground(Color.black);
C1 = new JCheckBox("Negrito");
C1.setBackground(new Color(180,180,180));
C1.addItemListener(this);
C2 = new JCheckBox("Italico");
C2.setBackground(new Color(180,180,180));
C2.addItemListener(this);
getContentPane().add(L1);
getContentPane().add(C1);
getContentPane().add(C2);
}

public void itemStateChanged(ItemEvent e){
if(e.getSource() == C1){
if (e.getStateChange() == ItemEvent.SELECTED){
negrito = Font.BOLD;
}else
negrito = Font.PLAIN;
}
if (e.getSource() == C2){
if (e.getStateChange() == ItemEvent.SELECTED){
italico = Font.ITALIC;
}else
italico = Font.PLAIN;
}
L1.setFont(new Font("Arial", negrito + italico,20));
}
}


O exemplo 9 apresenta uma janela que contém um Label e duas opções para o usuário
selecionar: negrito ou itálico. Conforme o usuário escolhe as opções, a fonte do Label é alterada para:
negrito, negrito + itálico ou normal, de acordo com a combinação escolhida. Os aspectos mais
importantes desse exemplo são:

• Linha 7: JCheckBox C1,C2 – realiza a declaração de C1 e C2 como sendo objetos da classe
JCheckBox.
• Linha 32: C1 = new JCheckBox(“negrito”) - realiza a inicialização do objeto C1, definindo o texto
que aparece na opção, isto é, será criado um botão de opção contendo o título negrito. Esta é a
forma mais simples de inicialização, pois é possível definir também se o objeto irá aparecer
selecionado ou não (true ou false). Quando nada é definido, o objeto não aparecerá selecionado.
Outra forma de inicialização é: C1 = new JcheckBox(“negrito”, true). Isso faria que C1 aparecesse
selecionado no momento da exibição na tela.
• Linha 34: C1.additemListener(this) – para que a seleção seja reconhecida pelo método
ItemStateChanged, é necessário invocar o método addItemListener da mesma forma que o
JcomboBox.
• Linha 42: itemStateChanged(ItemEvent e) – é o método que será executado quando o usuário
modificar a condição do objeto CheckBox, da mesma forma que foi descrito para o JcomboBox.
• Linha 44: if(e.getSource()==C1) – é utilizado para verificar se o objeto que gerou o evento foi o
C1.
• Linha 46: if(e.getStateChange()==ItemEvent.SELECTED) – este método é utilizado para
verificar se o componente JcheckBox está ou não checado. A propriedade SELECTED indica que
o objeto está checado e DESELECTED indica que o objeto não está checado.
239
• Linha 47, 49, 54 e 56: as constantes Font.PLAIN, font.BOLD e font.ITALIC são definidas
internamente na linguagem Java e possuem, respectivamente os valores inteiros 0 (zero), 1(um) e
2(dois). A combinação de seus valores gera tipos de fonte diferentes em setFont na linha 58.




A tabela 8 mostra um resumo dos métodos mais utilizados da classe JcheckBox.


Método Função
jCheckBox (String) Cria um checkbox com o texto especificado e com
a opção não selecionada.
jCheckBox (String, Boolean) Cria um checkbox com o texto e estado
especificado, com a seleção definida em Boolean
(true ou false)
getStateChange() Obtém o estado do checkbox, retornando
verdadeiro ou falso.
getSelected(Boolean) Especifica o estado do checkbox
Tabela 8 – Resumo dos métodos da classe JCheckBox



Inclusão de Painéis e Botões de Rádio

Os painéis são criados a partir da classe JPanel e podem ser utilizados quando vários tipos
de layout necessitam ser inseridos ser inseridos em uma janela. Cada painel pode assumir um layout
diferente.
Os botões de rádio são criados a partir da classe JRadioButton e, diferentemente dos
JCheckBox, permitem que apenas uma entre várias opções seja escolhido pelo usuário. Os botões
de rádio devem sempre ser agrupados em um ButtonGroup para cada conjunto de botões de rádio a
serem inseridos no frame. O exemplo 10 mostra o uso de painéis e de botões de rádio.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

class ExIntGrafica10 extends JFrame implements ItemListener{
JLabel L1,L2;
float N1 =0, result = 0;
JTextField T1,T2;
JPanel P1,P2;
JRadioButton radio1, radio2, radio3;
ButtonGroup radiogroup;

public static void main(String args[]) {
JFrame janela = new ExIntGrafica10(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a janela na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica10(){ //construtor
setTitle("Uso de botoes de radio"); //titulo da janela
setSize(340,120);
240
getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER));
L1 = new JLabel("Digite um valor");
L1.setForeground(Color.blue);
L2 = new JLabel("% do valor:");
L2.setForeground(Color.blue);
T1 = new JTextField(5);
T2 = new JTextField(5);
P1 = new JPanel();
P2 = new JPanel();
T2.setEditable(false);
radio1 = new JRadioButton("10% do valor");
radio1.addItemListener(this);
radio2 = new JRadioButton("20% do valor");
radio2.addItemListener(this);
radio3 = new JRadioButton("30% do valor");
radio3.addItemListener(this);
radio1.setMnemonic(KeyEvent.VK_1);
radio2.setMnemonic(KeyEvent.VK_2);
radio3.setMnemonic(KeyEvent.VK_3);
radiogroup = new ButtonGroup();
radiogroup.add(radio1);
radiogroup.add(radio2);
radiogroup.add(radio3);
P1.setLayout(new FlowLayout(FlowLayout.CENTER));
P1.setBackground(new Color(200,200,200));
P2.setLayout(new GridLayout(2,3));
P1.setBackground(new Color(200,200,200));
P1.add(L1);
P1.add(T1);
P2.add(radio1);
P2.add(radio2);
P2.add(radio3);
P2.add(L2);
P2.add(T2);
getContentPane().add(P1);
getContentPane().add(P2);
}
public void itemStateChanged(ItemEvent e){
if(T1.getText().length() == 0)
return;
try{
N1 = Float.parseFloat(T1.getText());
if(e.getSource() == radio1)
result = (N1*10)/100;
if(e.getSource() == radio2)
result = (N1*20)/100;
if(e.getSource() == radio3)
result = (N1*30)/100;
}catch(NumberFormatException erro){
T2.setText("Erro");
return;
}
T2.setText(""+result);
}
}

O exemplo 10 apresenta uma janela na qual o usuário digita um valor em uma caixa de texto
e escolhe uma opção em um botão de rádio. Cada botão realiza o cálculo da porcentagem sobre o
valor digitado e o coloca em uma outra caixa de texto.
Os aspectos mais importantes do exemplo 9.10 são:

• Linha 9: contém a declaração de dois painéis P1 e P2 que podem ser encarados da mesma forma
que as janelas (frames), pois compartilham as mesmas propriedades: cor do fundo, layout, objetos
que contém,etc. Depois de definidas as propriedades de um painel, ele é inserido na janela. Dessa
forma uma janela pode conter diversos painéis, cada um com o tipo diferente de formação e
layout.
• Linha 10: realiza a declaração de três objetos da classe JRadioButton (radio1, radio2, radio3).
241
• Linha 11: contém a declaração do objeto radiogroup referente à classe ButtonGroup que servirá
para agrupar e armazenar um conjunto de botôes de rádio do tipo JRadioButton.
• Linha 34: realiza a inicialização dos dois painéis.
• Linhas 36 a 38: realizam a inicialização dos botões de rádio com seus títulos correspondentes nos
parênteses. A inicialização também pode ser feita com mais um argumento informando se o botão
aparece marcado ou não, da mesma forma que o JCheckBox. A declaração ficaria assim: radio1
= new JRadioButton(“10% do valor”, true). Com essa inicialização, o botão apareceria marcado.
Outra possibilidade é inicializar um botão de rádio com um texto e uma imagem. Sendo assim, o
botão de rádio pode ser inicializado de diversas maneiras: com um texto, com uma imagem, com
um texto e uma imagem, além da definição de estar checado ou não. Estas linhas também
registram o evento dos botões de rádio.
• Linha 42: radiogroup = new ButtonGroup() - é a inicialização do objeto radiogroup para conter
os botões de rádio.
• Linha 43: adiciona cada um dos botões de rádio ao radiogroup. Dentre todos os botões inseridos,
apenas um deles pode ser escolhido pelo usuário.
• Linha 44: define o layout do painel P3, ou seja, um painel de fluxo com os objetos centralizados.
• Linha 45 e 47: definem a cor de fundo dos painéis P1 e P2.
• Linha 46: define o layout do painel P3, ou seja, um painel no formato grande contendo 2 linhas
por 3 colunas.
• Linhas 48 a 50: adicionam os objetos aos painéis correspondentes.
• Linha 51: adiciona os painéis à janela e todos os objetos atrelados a eles.




A tabela 9 mostrará um resumo dos métodos mais utilizados das classes JRadioButton e
JPanel.


Método Função
JRadioButton(String) Cria um botão de rádio com o texto especificado
JradioButton(String, boolean) Cria um botão de rádio com o texto especificado e
com a seleção definida (true ou false)
setSelected(boolean) Define se o botão está ou não selecionado (true
ou false)
ButtonGroup() Cria um grupo para botões de rádio
<nome_do_grupo>.add() Adiciona cada botão de rádio em um determinado
grupo
<nome_do_painel>.add() Adiciona objetos a um determinado painel
Tabela 9 – Resumo dos métodos da classe JRadioButton


Inclusão de caixas de mensagem

A inclusão de mensagens é realizada por meio da classe JOptionPane, especializada na
geração de caixas de diálogo, isto é, pequenas janelas que fazem uma pergunta, avisam o usuário ou
fornecem uma mensagem qualquer. Essas janelas representam um modo de comunicação com o
usuário, possibilitando fornecer uma simples informação ou obter respostas. A classe JOptionPane
oferece vários métodos para criação de caixas de diálogo de acordo com a necessidade. Uma
característica particular da classe JOptionPane é a não-necessidade de declaração de objetos para
a criação das caixas, que são criadas diretamente pelos métodos dessa classe.
Existem quatro tipos padrão de caixas de diálogo, cujos detalhes serão tratados
individualmente nas descrições seguintes:
• MessageDialog -caixa de diálogo que apresenta uma mensagem, possibilitando
acrescentar ícones de alerta ao usuário.
• ConfirmDialog – caixa de diálogo que além de emitir uma mensagem, possibilita ao
242
usuário responder a uma pergunta.
• InputDialog – caixa de diálogo que além de emitir uma mensagem, permite a entrada de
um texto.
• OptionDialog – caixa de diálogo que abrange os três tipos anteriores.


MessageDialog

A caixa de diálogo MessageDialog é utilizada para mostrar ao usuário alguma informação e
não retorna nenhum tipo de valor de resposta. Essas caixas de diálogo podem apresentar um ícone
referente ao tipo de mensagem (pergunta, informação, alerta, erro ou definido pelo usuário) ou não
apresentar nada, apenas a mensagem na tela sem ícone algum. Sua sintaxe é a seguinte:

JoptionPane.showMessageDialog(Component, <mensagem>, <título da
mensagem>, <tipo de mensagem>)

Em que:
• Component – refere-se a um objeto contêiner que permite definir a posição da tela em
que a caixa de mensagem irá aparecerá. Normalmente esse argumento é deixado como
null (default) para que a mensagem apareça centralizada na tela. Em nossos exemplos,
todas as mensagem utilizarão null nesse argumento.
• Mensagem – é a mensagem do tipo String que a caixa de diálogo informará ao usuário.
• Título da mensagem – é o texto que aparece na barra de título da janela caixa de diálogo.
• Tipo da mensagem – é o ícone que representa o tipo de mensagem que está sendo
informado ao usuário. Esse ícone é definido pelo usuário e pode ser até um gif animado,
dando maior beleza à aplicação. A tabela 10 apresenta as constantes da linguagem Java
para definição dos ícones a serem apresentados na tela.

Ícone Comando
QUESTION_MESSAGE
INFORMATION_MESSAGE

WARNING_MESAGE
ERROR_MESSAGE

INFORMATION_MESSAGE, <ícone>
vazio PLAIN_MESSAGE

O exemplo 11 utiliza caixas de diálogo para exibir na tela vários tipos de mensagem.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

class ExIntGrafica11 extends JFrame implements ActionListener{
ImageIcon icone = new ImageIcon("c:/windows/tips.gif"
);
JButton B1,B2,B3,B4,B5,B6;

public static void main(String args[]) {
JFrame janela = new ExIntGrafica11(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a janela na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
243
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica11(){ //construtor
setBackground(new Color (190,190,190));
setSize(350,100);
setTitle("Caixas de Mensagem"); //titulo da janela

getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER));
B1 = new JButton("Pergunta");
B1.addActionListener(this);
B2 = new JButton("Informação");
B2.addActionListener(this);
B3 = new JButton("Alerta");
B3.addActionListener(this);
B4 = new JButton("Erro");
B4.addActionListener(this);
B5 = new JButton("Definida pelo usuário");
B5.addActionListener(this);
B6 = new JButton("Somente mensagem");
B6.addActionListener(this);
getContentPane().add(B1);
getContentPane().add(B2);
getContentPane().add(B3);
getContentPane().add(B4);
getContentPane().add(B5);
getContentPane().add(B6);
}
public void actionPerformed (ActionEvent e){
if(e.getSource() == B1)
JOptionPane.showMessageDialog(null, "sera que estou aprendendo
Java?", "Pergunta", JOptionPane.QUESTION_MESSAGE);
if(e.getSource() == B2)
JOptionPane.showMessageDialog(null, "Esta é uma mensagem de
informacao!","Mensagem de Informação", JOptionPane.INFORMATION_MESSAGE);
if(e.getSource() == B3)
JOptionPane.showMessageDialog(null, "Cuidado!","Mensagem de
alerta", JOptionPane.WARNING_MESSAGE);
if(e.getSource() == B4)
JOptionPane.showMessageDialog(null, "Ocorreu algum
erro!","Mensagem de erro", JOptionPane.ERROR_MESSAGE);
if(e.getSource() == B5)
JOptionPane.showMessageDialog(null, "Utilizando um gif
animado!","Definido pelo usuário", JOptionPane.INFORMATION_MESSAGE,icone);
if(e.getSource() == B6)
JOptionPane.showMessageDialog(null, "Aprendendo a usar caixas de
mensagem","Somente mensagem", JOptionPane.PLAIN_MESSAGE);
}
}


O exemplo 11 apresenta uma janela com vários botões. Cada botão produz uma mensagem
diferente na tela, demonstrado as variações existentes para uma caixa de diálogo com o uso da
classe MessageDialog.
Os aspectos mais importantes deste exemplo são:

• Linha 44: contém o método showMessageDialog da classe JOptionPane. Este é o método
responsável por criar a caixa de mensagem de acordo com os parâmetros fornecidos dentro dos
parênteses. No caso desta linha, é fornecido o parâmetro QUESTION_MESSAGE, uma constante
da linguagem Java que contém um valor correspondente ao ícone de interrogação. Dessa forma a
mensagem exibida conterá um texto (“Será que estou aprendendo Java?”) e o ícone de
interrogação.
• Linhas 46,48,50,52 e 54: executam o mesmo procedimento da linha 44. modificando a constante
responsável pela inserção do ícone na caixa de mensagem.
244





ConfirmDialog

As caixas de diálogo de confirmação são pequenas janelas que possibilitam ao usuário
responder algum questionamento por meio dos botões Yes, No e Cancel. Essas janelas são
formadas pelo uso do método showConfirmDialog. Uma vez apresentada na tela,o usuário escolhe
uma das opções e, dependendo do botão clicado, é gerado um valor inteiro pertencente à classe
JOptionPane: YES_OPTION = 0, NO_OPTION = 1 e CANCEL_OPTION = 2, portanto esse valor é
para conhecer qual dos botões foi clicado pelo usuário.
Existem três tipos de caixas de diálogo de confirmação: as que apresentam os botões Yes e
NO (YES_NO_OPTION ou O), as que apresentam os botões Yes, No e Cancel
(YES_NO_CANCEL_OPTION ou 1) e as que apresentam os botões OK e Cancel
(OK_CANCEL_OPTION ou 2). A sintaxe da caixa de diálogo para confirmação é a seguinte:

int resposta = JoptionPane.showConfirmDialog(Component, <mensagem>,
<título da mensagem>, <botões presentes>, <tipo de mensagem>).

A única diferença entre essa sintaxe e a usada para a caixa de mensagem do item anterior se
refere ao parâmetro <botões presentes> no qual são inseridos os botões que aparecerão na caixa de
diálogo, conforme citado no parágrafo anterior.

O exemplo 12 demonstra o uso de três tipos de caixas de confirmação:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

class ExIntGrafica12 extends JFrame implements ActionListener{
JLabel L1;
JButton B1,B2,B3,B4,B5,B6;

public static void main(String args[]) {
JFrame janela = new ExIntGrafica12(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a janela na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica12(){ //construtor
setBackground(new Color (190,190,190));
setSize(400,100);
setTitle("Caixas de Confirmação"); //titulo da janela

getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER));
L1 = new JLabel("Resposta: ");
B1 = new JButton("sim e nao");
B1.addActionListener(this);
B2 = new JButton("Sim, Não e Cancelar");
B2.addActionListener(this);
245
B3 = new JButton("Ok e Cancelar");
B3.addActionListener(this);
getContentPane().add(B1);
getContentPane().add(B2);
getContentPane().add(B3);
getContentPane().add(L1);
}
public void actionPerformed (ActionEvent e){
int resp = 0;
if(e.getSource() == B1)
resp = JOptionPane.showConfirmDialog(null,"Erro ao acessar
arquivo. Tentar novamente?", "Erro de arquivo",JOptionPane.YES_NO_OPTION,
JOptionPane.ERROR_MESSAGE);
if(e.getSource() == B2)
resp = JOptionPane.showConfirmDialog(null,"Deseja salavar as
alterações?", "Salvar arquivo",JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.WARNING_MESSAGE);
if(e.getSource() == B3)
resp = JOptionPane.showConfirmDialog(null,"Deseja abrir o
arquivo?", "Abrir arquivo",JOptionPane.OK_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE);
switch(resp){
case 0: L1.setText("Pressionado o botão yes/Ok");break;
case 1: L1.setText("Pressionado o botão No");break;
case 2: L1.setText("Pressionado o botão Cancel");break;
}
}
}

Os aspectos mais importantes deste exemplo são:
7. Linha 39: int resp = 0 – a variável resp servirá para armazenar o valor inteiro correspondente à
resposta dada pelo usuário na caixa de confirmação.
8. Linha 41, 43 e 45: contem as constantes inteiras da classe JOptionPane que determinam os
botões visíveis na caixa de confirmação. Em vez de constantes, pode ser usado também o valor
correspondente a cada constante, conforme citado anteriormente.
9. Linha 46: switch(resp) – verifica a resposat coletada da caixa de confirmação. Esta variável
armazena um número inteiro que é utilizado para determinar qual foi o botão pressionado pelo
usuário na caixa de confirmação.



InputDialog

As caixas de diálogo de entrada são geradas a partir do método showInputDialog() e são
utilizadas para fazer uma pergunta ao usuário e solicitar a entrada de um texto. Esse texto será
armazenado em uma variável qualquer do tipo String. Essas caixas de diálogo são chamadas pelo
método showInputDialog(). A sintaxe usada na criação de caixas de diálogo de entrada é
praticamente a mesma usada nas caixas de mensagem, possuindo o formato seguinte:

Strind resp = JoptionPane.showInputDialog(null, <mensagem>, <título
da mensagem>, <tipo de mensagem>).

O exemplo 13 demonstra o uso da caixa de entrada para solicitar o nome do usuário e depois
apresentar uma mensagem de boas vindas.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
246

class ExIntGrafica13 extends JFrame implements ActionListener{
JLabel L1;
JButton B1;

public static void main(String args[]) {
JFrame janela = new ExIntGrafica13(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a janela na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica13(){ //construtor
setBackground(new Color (190,190,190));
setSize(230,100);
setTitle("Uso da caixas de entrada"); //titulo da janela

getContentPane().setLayout(new GridLayout(2,1));
L1 = new JLabel("",JLabel.CENTER);
L1.setForeground(Color.blue);
B1 = new JButton("Login");
B1.addActionListener(this);
B1.setToolTipText("Clique aqui para entrar no sistema");
B1.setMnemonic(KeyEvent.VK_L);
getContentPane().add(B1);
getContentPane().add(L1);
}
public void actionPerformed (ActionEvent e){
String resp = JOptionPane.showInputDialog(null,"Qual é o seu
nome?","Login no sistema",JOptionPane.QUESTION_MESSAGE);
if(!(resp == null|| resp.equals("")))
L1.setText("Seja bem vindo "+ resp + "!!");
else
L1.setText("");
}
}

Os aspectos mais importantes deste exemplo são:

cii) Linha 37: String resp = JoptionPane.showInputDialog – cria uma variável de nome resp que
armazenará o conteúdo digitado pelo usuário na caixa de diálogo de entrada. Caso o usuário não
digite nada e pressione Ok, a variável resp receberá vazio (“”); caso o usuário pressione o botão
Cancel, a variável resp receberá nulo (null).
ciii) Linha 39: if(!(resp == null || resp.equals(“”))) - ao aparecer a caixa de diálogo. É solicitado
que se digite algo na caixa de texto. Não será executada a linha após este comando caso a
resposta seja null (quando o usuário pressionar o botão Cancel) ou caso a resposta seja vazia
(quando o usuário não digitar nada na caixa de texto).
civ) Linha 41: L1.setText(“Seja bem vindo ”+resp +”!”) - exibe uma mensagem de boas-vindas
ao usuário de acordo com o nome que foi digitado na caixa de diálogo de entrada.

247


OptionDialog

As caixas de diálogo de opção são geradas a partir do método OptionDialog e são bem
complexas. Ela é capaz de combinar todos os recursos já vistos nas outras caixas de diálogo. Sua
sintaxe é:

int resposta = (null, <mensagem>, <título da mensagem>,<botões
presentes>, <tipo de mensagem>, <ícone>, <array de objetos>, <seleção
padrão>).

Em que:
8. botões presentes – um tipo de caixa que utiliza as variáveis YES_NO_OPTION,
YES_NO_CANCEL_OPTION ou OK_CANCEL_OPTION. Deve-se utilizar 0 (zero) caso outros
botões sejam utilizados no lugar destes
9. tipo de mensagem – uma das variáveis de pergunta, informação, alerta ou erro ou
definida pelo usuário.
10. Ícone – um objeto ImageIcon a ser apresentado no lugar de um dos ícones do argumento
anterior (<tipo de mensagem>). Se nenhum ícone for usado, deve-se colocar a palavra
null no lugar desse argumento.
11. Array de objetos – é um array de objetos que contém os componentes ou outros objetos
que representam as escolhas na caixa de diálogo, caso as opções YES_NO_OPTION,
YES_NO_CANCEL_OPTION ou OK_CANCEL_OPTION. não estejam sendo usadas.

O exemplo 14 demonstra o uso da caixa de diálogo de opção para fazer uma pergunta ao
usuário e aguardar ema entre três respostas disponíveis com o uso de três botões.

1mpo¡f ¸ava.aWf."¦
1mpo¡f ¸ava.aWf.evenf."¦
1mpo¡f ¸avax.sW1ng."¦
1mpo¡f ¸avax.sW1ng.evenf."¦

c1ass LxlnfG¡af1ca14 exfends JI¡ame 1mp1emenfs Acf1onL1sfene¡{
JLabe1 L1¦
J8uffon 81¦

pub11c sfaf1c vo1d ma1n{5f¡1ng a¡gs|]} {
JI¡ame ¸ane1a = neW LxlnfG¡af1ca14{}¦ //dec1a¡acao e 1n1c1a11zacao do
ob¸efo ¸ane1a
¸ane1a.shoW{}¦ //mosf¡a a ¸ane1a na fe1a
W1ndoWL1sfene¡ x = neW W1ndoWAdapfe¡{}{
pub11c vo1d W1ndoWC1os1ng{W1ndoWLvenf e}{
5ysfem.ex1f{0}¦
}

¸ane1a.addW1ndoWL1sfene¡{x}¦
}

LxlnfG¡af1ca14{}{ //consf¡ufo¡
sef8ackg¡ound{neW Co1o¡ {190,190,190}}¦
sef51ze{250,100}¦
sef11f1e{"ca1xas de enf¡ada"}¦ //f1fu1o da ¸ane1a

248
gefConfenfPane{}.sefLayouf{neW I1oWLayouf{I1oWLayouf.CLN1Lk}}¦
L1 = neW JLabe1{""}¦
L1.sefIo¡eg¡ound{Co1o¡.b1ue}¦
81 = neW J8uffon{"D1a1ogo de opção"}¦
81.addAcf1onL1sfene¡{fh1s}¦
gefConfenfPane{}.add{81}¦
gefConfenfPane{}.add{L1}¦
}
pub11c vo1d acf1onPe¡fo¡med {Acf1onLvenf e}{
5f¡1ng|] esco1ha = {"Lnf¡e 1 e 20 anos","Lnf¡e 21 e 40 anos","Ma1s de
40 anos"}¦
1nf ¡esp = JOpf1onPane.shoWOpf1onD1a1og{nu11,"qua1 sua
1dade?","ldade",0,JOpf1onPane.lNIOkMA1lON¸ML55AGL,nu11,esco1ha,esco1ha|0]}¦

5f¡1ng 1dade = {esco1ha|¡esp]}¦
L1.sef1exf{"1dade: "+1dade}¦
}
}

Os aspectos mais importantes deste exemplo são:

4. Linha 35: 5f¡1ng|] esco1ha = {"Lnf¡e 1 e 20 anos","Lnf¡e 21 e 40 anos","Ma1s de 40 5f¡1ng|] esco1ha = {"Lnf¡e 1 e 20 anos","Lnf¡e 21 e 40 anos","Ma1s de 40 5f¡1ng|] esco1ha = {"Lnf¡e 1 e 20 anos","Lnf¡e 21 e 40 anos","Ma1s de 40 5f¡1ng|] esco1ha = {"Lnf¡e 1 e 20 anos","Lnf¡e 21 e 40 anos","Ma1s de 40
anos"}¦ anos"}¦ anos"}¦ anos"}¦ - o array escolha é utilizado para definir i texto de três botões na caixa de diálogo, de
acordo com as Strings apresentadas.
5. Linha 36: contém a criação das caixas de diálogo de opção. O array escolha criará três botões
conforme a definição de seus nomes no array. O último argumento escolha[0] especifica que o
primeiro elemento do array deve ser a seleção padrão da caixa de diálogo, portanto o botão Entre
1 e 20 anos é o que ficará selecionado quando a caixa de diálogo for aberta. A variável resp
receberá o índice do botão clicado. Lembrando que o índice inicia-se no 0 (zero).
6. Linha 37: String idade = (escolha[resp]) – é criada uma variável idade do tipo String que
armazenará a resposta do usuário, dependendo do botão que foi clicado, cujo índice foi
armazenado na variável resp. Quando o usuário pressiona um dos botões da caixa de diálogo, é
gerado um número correspondente ao seu índice no array.







Inclusão de barras de rolagem

As barras de rolagem constituem-se em componentes que possibilitam o controle de um valor
numérico, dentro de uma faixa de valores, compreendido entre um valor mínimo e um máximo.
Existem três formas diferentes de mudar o valor da barra de rolagem:
ci) por meio das setas das extremidades – são utilizadas para incrementar ou decrementar
valores de pequena quantidade (de um em um por default).
cii) Por meio do intervalo no meio – utilizado para incrementar ou decrementar valores em
uma quantidade maior (de dez em dez por default).
ciii) Caixa no meio – sua posição é utilizada para mostrar onde o valor corrente está
localizado d entro do intervalo dos valores. Ao mover essa barra com o mouse, ocorre
uma mudança absoluta no valor com base na posição da caixa dentro da barra de
rolagem.
249

A sintaxe para criar uma barra de rolagem em Java é a seguinte:

JscrollBar(<orientação>,<valor inicial>,<intervalo do meio>,<valor
mínimo>,<valor máximo>).

Em que:
ii) orientação – é um valor inteiro que define se a barra de rolagem é horizontal (0) ou
vertical (1). A orientação pode ser definida também pelas constantes
JScrollBar.HORIZONTAL e JScrollBar.VERTICAL
iii) valor inicial – é o valor inicial da barra de rolagem que deve ser do tipo inteiro,
compreendido entre os valores máximo e mínimo da barra de rolagem.
iv) Intervalo do meio – é um valor do tipo inteiro que define o incremento ou decremento do
valor da barra de rolagem.
v) Valor mínimo – define o valor inteiro mínimo da barra de rolagem
vi) valor máximo – define o valor inteiro máximo da barra de rolagem.

O exemplo 15 demonstra o uso da barra de rolagem criando um pequeno conversor de
centímetros para polegadas:


import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.text.NumberFormat;

class ExIntGrafica15 extends JFrame implements AdjustmentListener{
JScrollBar SB1;
JLabel L1,L2;

public static void main(String args[]) {
JFrame janela = new ExIntGrafica15(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a janela na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica15(){ //construtor
setBackground(new Color (190,190,190));
setSize(250,100);
setTitle("Uso de barra de rolagem"); //titulo da janela

getContentPane().setLayout(new GridLayout(3,1));
SB1 = new JScrollBar(JScrollBar.HORIZONTAL,0,5,0,105);
SB1.addAdjustmentListener(this);
L1 = new JLabel(""+SB1.getValue(),JLabel.CENTER);
L1.setForeground(Color.black);
L2 = new JLabel("",JLabel.CENTER);
L2.setForeground(Color.black);
getContentPane().add(SB1);
getContentPane().add(L1);
getContentPane().add(L2);
}
public void adjustmentValueChanged(AdjustmentEvent e){
L1.setText(SB1.getValue()+" centímetros");
NumberFormat nf;

nf = NumberFormat.getNumberInstance();
nf.setMinimumFractionDigits(3);
double pol = SB1.getValue()/2.54;
250
L2.setText(nf.format(pol)+" Polegadas");
}
}


Os aspectos mais importantes do exemplo 15 são:

5. Linha 6: implementa a interface AdjustmentListener, utilizada para reconhecer a interação do
usuário com o objeto JScrollBar, ou seja, para reconhecer os eventos relacionados com o
JScrollBar da mesma forma que ActionListener é usado para reconhecer o clique do mouse.
6. Linha 8: declara SB1 como um objeto da classe JScrollBar.
7. Linha 30: SB1 = new JscrollBar(JScrollBar.HORIZONTAL,0,5,0,105) – inicializa o objeto SB1
como sendo uma barra de rolagem em que o primeiro argumento (JscrollBar.HORIZONTAL)
determina que será uma barra de rolagem do tipo horizontal. O segundo argumento (0) determina
que a posição inicial barra de rolagem será zero. O terceiro argumento (5) determina o valor para
incremento e decremento para o intervalo do meio, isto é, quando o usuário clicar na área da
barra. O quarto argumento (0) informa o valor mínimo da barra de rolagem. O quinto argumento
(105) informa o valor máximo da barra de rolagem, sendo que esse valor deve ser definido em
função do valor do intervalo do meio; na realidade o valor máximo da barra será 100 e não 105,
uma vez que o valor final deve ser acrescido com o valor do intervalo do meio. Sendo assim, a
barra de rolagem assumirá valores entre 0 e 100.
8. Linha 31: SB1.addAdjustmentListener(this) – registra a barra de rolagem SB1 para que o
evento seja gerado por ela.
9. Linha 32:SB1.getValue() - método utilizado para obter o valor inteiro da posição da barra de
rolagem. Note que o objeto L1 já é criado tendo como texto a posição inicial da barra de rolagem.
10. Linha 38: adjusmentValueChanged(AdjustmentEvent e) – método utilizado para receber as
ações geradas a partir da interação do usuário com o objeto JscrollBar(SB1).
11. Linha 44 a 46: definem um formato (três casas decimais) para a apresntação do valor em
polegadas, inserindo no objeto L2.



A tabela 11 mostra um resumo dos métodos mais utilizados da classe JScrollBar:

Método Função
JScrollBar(int,int,int, int,int) Cria uma barra de rolagem de acordo com os argumentos
definidos
getMaximum() Obtém o máximo valor da barra de rolagem
getMinimum() Obtém o mínimo valor da barra de rolagem
GetOrientation() Retorna o valor da orientação da barra de rolagem: 0 para
JScrollBar.HORIZONTAL e 1 para JScrollBar.VERTICAL
getValue() Obtém o valor inteiro corrente da barra de rolagem
getUnitIncrement() Obtém o valor do incremento por meio das setas das
extremidades
getBlockIncrement() Obtém o valor do incremento por intermédio do intervalo
do meio
setMaximum(int) Determina o valor máximo da barra de rolagem
setMinimum(int) Determina o valor mínimo da barra de rolagem
setOrientation(int) Determina o valor da orientação da barra de rolagem:
vertical ou horizontal
setValue(int) Determina o valor corrente da barra de rolagem
setUnitIncrement(int) Determina o valor do incremento por meio das setas das
extremidades
setBlockIncrement(int) Determina o valor do incremento por intermédio do
intervalo do meio.
Tabela 11 – Resumo dos métodos da classe JScrollBar.


Inclusão de áreas de texto
251

As áreas de texto geradas a partir da classe JTextArea são semelhantes às caixas de texto,
porém com maior funcionalidade, possibilitando realizar o tratamento de diversas linhas de texto. A
sintaxe para a utilização das áreas de texto é a seguinte:

JtextArea(<string>,<nº de linhas iniciais>,<dimensão>)

Em que:
di) string – um texto inicial qualquer que pode ser definido para o objeto no momento de sua
inicialização.
dii) nº de linhas inicias - Um valor inteiro que especifica o número de linhas que a área de
texto apresentará na tela, sem o uso de uma de uma barra de rolagem.
diii) dimensão – um valor inteiro que especifica a dimensão da área de texto em números
de caracteres, isto é, o número de caracteres que cabe em uma linha na área de texto.
Esta definição não apresenta muita importância, pois na realidade o número de caracteres
que uma linha pode conte está relacionado diretamente ao tipo de caractere usado. Por
exemplo, se o número de caracteres de uma linha for definido para 40, então caberão
exatamente 40 caracteres “W” , entretanto caberão 62 caracteres “A” e 156 caracteres
“I”.

O exemplo 16 demonstra algumas funcionalidades da área de texto.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.text.NumberFormat;

class ExIntGrafica16 extends JFrame implements ActionListener{
JTextArea TA1, TA2;
JTextField T1;
JButton B1,B2;

public static void main(String args[]) {
JFrame janela = new ExIntGrafica16(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a janela na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica16(){ //construtor
setSize(420,280);
setTitle("Uso do JTextArea"); //titulo da janela

getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER));
T1 = new JTextField(40);
T1.addActionListener(this);
B1 = new JButton("Copia tudo");
B1.addActionListener(this);
B2 = new JButton("Copia selecao");
B2.addActionListener(this);
TA1 = new JTextArea("Editor de texto:\n",5,40);
TA2 = new JTextArea(5,40);
JScrollPane painel1 = new JScrollPane(TA1);
JScrollPane painel2 = new JScrollPane(TA2);
getContentPane().add(painel1);
getContentPane().add(T1);
getContentPane().add(B1);
getContentPane().add(B2);
getContentPane().add(painel2);
}
252
public void actionPerformed(ActionEvent e){
if(e.getSource() == T1) { //ao pressionar ENTER no JTextField
TA1.append(T1.getText());
T1.setText("");
}
if (e.getSource() == B1) //copia conteudo de TA1 em TA2
TA2.setText(TA1.getText());
if(e.getSource() == B2) //copia selecao
TA2.setText(TA1.getSelectedText());
}
}

Os aspectos mais importantes do exemplo 16 são:

ii) Linha 34: TA1 = new JTexArea (“Editor de texto:\n”,5,40) – inicializa o objeto TA1 com uma
string mais o sinal de escape \n (serve para pular uma linha), o número de linhas (5) e o número
de colunas (40).
iii) Linha 35: TA2 = new JtexArea (5,40) – inicializa o objeto TA2 apenas com o números de linhas
e colunas para a área de texto.
iv) Linha 47: insere o texto armazenado no campo texto T1 para o final da área de texto TA1 por
meio do método append () da classe JTestArea. Dessa forma, toda vez que o usuário pressionar
a tecla ENTER sobre o campo T1, seu conteúdo texto será inserido no final de TA1.
v) Linha 51: o objeto TA2 obtém o texto armazenado no objeto TA1. Observe que o método para
obter (getText()) ou armazenar (setText()) um texto em um objeto do tipo JTestArea são os
mesmos de um objeto JTextField.
vi) Linha 53: TA2.setText(TA1.getSelectedText()) - o objeto TA2 obtém o texto selecionado do
objeto TA1.Isto é realizado pelo método getSelectedText().

A figura 16 apresenta o resultado obtido com a execução do exemplo 16.







A tabela 12 mostra um resumo dos métodos mais utilizados da classe JTextArea.

Método Função
JTextArea() Cria uma área de texto.
JTextArea(int, int) Cria uma área de texto de acordo com o número de linhas
e colunas especificadas.
JTextArea(String) Cria uma nova área de texto de acordo com o texto
especificado
JTextArea(String, int, int) Cria uma área de texto de acordo com o texto, o número de
linhas e o número de colunas especificados
getColumns() Obtém o comprimento ou colunas da área de texto em
caracteres.
253
Método Função
getRows() Obtém a largura ou linhas da área de texto em caracteres.
getSelectedTex() Obtém o texto selecionado na área de texto.
setColumns() Define o comprimento ou colunas da área de texto.
setRows() Define a largura ou linhas da área de texto.
insert(String, int) Insere a string especificada na posição indicada por uma
variável inteira.
replaceRange(String, int,int) Substitui o texto fornecido na variável string pelo texto
contido entre as posições definidas (início e fim).
setTex(), getText(), setEditable() Métodos da classe JtextComponent que Funcionam da
mesma forma em JTextField.


Inclusão de menus

Há dois tipos de menu utilizados em Java: as barras de menu que aparecem na parte
superior de quase todos os aplicativos de ambientes Windows e os menus Popup que aparecem
quando o usuário pressiona o botão direito do Mouse sobre algum objeto. Esses dois tipos de menus
serão mostrados separadamente nos itens seguintes.

Barra de menus

Antes de criar um menu, é necessário cria uma barra de menus para que ela possa conter o
conjunto de menus que aparece na parte superior da janela. Essa barra de menus é criada usando a
sintaxe seguinte:

JMenuBar <nome da barra de menus> = new JMenuBar();

Para definir essa barra de menus como sendo o menu padrão da janela, é utilizado o método
setJMenuBar() da seguinte maneira:

setJMenuBar(<nome da barra de menus>);

Com essas duas linhas de comando já é possível criar e definir a barra de menus, entretanto
é necessário criar também os menus que aparecerão na barra, pois apenas com as declarações
realizadas a janela conteria uma barra de menus, vazia. Para criar os menus é utilizada a classe
JMenu , conforme a sintaxe seguinte:

JMenu <> = new JMenu();

Para que o menu criado seja adicionado à barra de menus, deve-se utilizar o método add da
seguinte forma:

<nome da barra de menus>.add(<nome do menu>)

Com isso um menu é inserido na barra. Imagine, por exemplo, a inserção do menu Arquivo de
um aplicativo qualquer. Depois de criado o menu, é necessário adicionar a eles os itens que
compõem (para op menu Arquivo seriam: Novo, Salvar, SalvarComo...). Para inserir um item de
menu, é usada a seguinte sintaxe:

JMenuItem <nome do item> = JMenuItem()

Para adicionar o item ao menu, utiliza-se o método add:

<nome do menu>.add(<nome do item>)

De acordo com os parágrafos anteriores, pode-se notar que o processo de criação de menus
possui uma série de passos que devem ser seguidos. A figura 17 ilustra os itens necessários para a
criação de menus. Em resumo: cria-se uma barra de menus, adiciona-se a barra de menus à janela.

O exemplo 17 demonstra como inserir dois menus com seus itens correspondentes,
identificando qual item foi escolhido pelo usuário.
254

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExIntGrafica17 extends JFrame implements ActionListener{
JMenuBar M1;
JTextField T1;
JMenu menuCadastro, menuRelatorio;
JMenuItem micliente, mifornecedor, misair, mirlcliente, mirlfornecedor;

public static void main(String args[]) {
JFrame janela = new ExIntGrafica17(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a janela na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica17(){ //construtor
setTitle("Uso de Menus"); //titulo da janela

setSize(270,130);
setLocation(50,50);
getContentPane().setBackground(new Color(0,128,128));
T1 = new JTextField();
M1 = new JMenuBar(); //cria a barra de menus
menuCadastro = new JMenu("Cadastro"); //cria um menu
menuRelatorio = new JMenu("Relatorio");
micliente = new JMenuItem("Cliente"); //cria um item
micliente.addActionListener(this);
mifornecedor = new JMenuItem("Fornecedor");
mifornecedor.addActionListener(this);
misair = new JMenuItem("Sair");
misair.addActionListener(this);
menuCadastro.add(micliente); //adiciona um item ao menu
menuCadastro.add(mifornecedor);
menuCadastro.add(misair);
mirlcliente = new JMenuItem("Relação de Clientes");
mirlcliente.addActionListener(this);
mirlfornecedor = new JMenuItem("Relação de Fornecedores");
mirlfornecedor.addActionListener(this);
menuRelatorio.add(mirlcliente);
menuRelatorio.add(mirlfornecedor);
M1.add(menuCadastro); //adiciona o menu na barra de menus
M1.add(menuRelatorio);
setJMenuBar(M1); //define a barra de menus como padrao
getContentPane().add(T1);
}
public void actionPerformed(ActionEvent e){
if(e.getSource() == micliente)
T1.setText("Escolhido o item cliente");
if (e.getSource() == mifornecedor)
T1.setText("Ëscolhido o item fornecedor");
if(e.getSource() == mirlcliente)
T1.setText("Escolhido o item relação de clientes");
if(e.getSource() == mirlfornecedor)
T1.setText("Escolhido o item relação de fornecedores");
if(e.getSource() == misair)
System.exit(0);
}
}


255
Os aspectos mais importantes do exemplo 17 são:

6. Linhas 7,8 e 9: contêm as declarações dos objetos JMenuBar (Barra de menus), Jmenu(menu) e
JmenuItem(Item do menu) respectivamente.
7. Linha 31: M1 = new JmenuBar() - inicializa o objeto M1 como sendo uma barra de menus da
classe JMenuBar.
8. Linhas 32 e 33: inicializam os objetos menuCadastro e menuRelatório como menus da classe
JMenu.
9. Linhas 34, 36, 38, 43, e 45: inicializam um objeto como sendo um item de menu da classe
JMenuItem
10. Linhas 40, 41, 42, 47 e 48: adicionam itens aos menus menuCadastro e MenuRelatorio.
11. Linhas 35, 37, 39, 44 e 46: registram o evento ActionListener para cada um dos itens do menu.
12. Linhas 49 e 50: adicionam os menus à barra de menus M1.
13. Linha 51: setJMenuBar(M1) – define a barra de menus M1 como sendo o menu padrão da janela.
14. Linhas 54 a 66: contém o método actionPerformed que verifica qual dos itens do menu foi
escolhido, inserindo uma mensagem no campo texto T1.




O exemplo 18 apresenta um menu mais profissional, demonstrando a utilização de subitens,
ícones, barra divisória e teclas de atalho para acessa os itens do menu.


import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExIntGrafica18 extends JFrame implements ActionListener{
JMenuBar M1;
JMenu menuArquivo, menuSalvar;
JMenuItem miNovo, miAbrir, miSair, miSalvar, miSalvarC, miSalvarT;

public static void main(String args[]) {
JFrame janela = new ExIntGrafica18(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a janela na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica18(){ //construtor
setTitle("Uso de Menus"); //titulo da janela

setSize(250,150);
setLocation(50,50);
getContentPane().setBackground(new Color(0,128,128));
M1 = new JMenuBar(); //cria a barra de menus
menuArquivo = new JMenu("Arquivo"); //cria um menu
menuArquivo.setMnemonic(KeyEvent.VK_A);
menuArquivo.addActionListener(this);
menuSalvar = new JMenu("Salvar"); //cria um menu
miNovo = new JMenuItem("Novo",new ImageIcon("xxx.gif"));
miNovo.addActionListener(this);
256
miNovo.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N,
ActionEvent.ALT_MASK));
miNovo.setMnemonic(KeyEvent.VK_N);
miAbrir= new JMenuItem("Abrir",new ImageIcon("xxx.gif"));
miAbrir.addActionListener(this);
miAbrir.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A,
ActionEvent.ALT_MASK));
miAbrir.setMnemonic(KeyEvent.VK_B);
miSalvar= new JMenuItem("Salvar", new ImageIcon("xxx.gif"));
miSalvar.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,
ActionEvent.ALT_MASK));
miSalvar.addActionListener(this);
miSalvar.setMnemonic(KeyEvent.VK_S);
miSalvarC= new JMenuItem("Salvar Como");
miSalvarC.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C,
ActionEvent.ALT_MASK));
miSalvarC.addActionListener(this);
miSalvarC.setMnemonic(KeyEvent.VK_C);
miSalvarT= new JMenuItem("Salvar Tudo");
miSalvarT.addActionListener(this);
miSalvarT.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_T,
ActionEvent.ALT_MASK));
miSalvarT.setMnemonic(KeyEvent.VK_T);
miSair = new JMenuItem("Sair", new ImageIcon("xxx.gif"));
miSair.addActionListener(this);
miSair.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_X,
ActionEvent.ALT_MASK));
miSair.setMnemonic(KeyEvent.VK_X);
menuSalvar.add(miSalvar);
menuSalvar.add(miSalvarC);
menuSalvar.add(miSalvarT);
menuArquivo.add(miNovo);
menuArquivo.add(miAbrir);
menuArquivo.add(menuSalvar);
menuArquivo.addSeparator();
menuArquivo.add(miSair);
M1.add(menuArquivo); //adiciona o menu na barra de menus
setJMenuBar(M1); //define a barra de menus como padrao
}
public void actionPerformed(ActionEvent e){
if(e.getSource() == miNovo)
JOptionPane.showMessageDialog(null, "menu Novo", "Usando
menus",JOptionPane.INFORMATION_MESSAGE);
if (e.getSource() == miAbrir)
JOptionPane.showMessageDialog(null, "menu Abrir", "Usando
menus",JOptionPane.INFORMATION_MESSAGE);
if(e.getSource() == miSalvar)
JOptionPane.showMessageDialog(null, "Sub-menu Salvar", "Usando
menus",JOptionPane.INFORMATION_MESSAGE);
if(e.getSource() == miSalvarC)
JOptionPane.showMessageDialog(null, "Sub-menu Salvar Como",
"Usando menus",JOptionPane.INFORMATION_MESSAGE);
if(e.getSource() == miSalvarT)
JOptionPane.showMessageDialog(null, "Sub-menu Salvar Tudo",
"Usando menus",JOptionPane.INFORMATION_MESSAGE);
if(e.getSource() == miSair)
System.exit(0);
}
}


Os aspectos mais importante do exemplo 18 são:

• Linha 32: menuArquivo.setMnemonic(KeyEvent.VK_A) – cria um sublinhado embaixo da
letra especificada (no caso a letra “A”) para facilitar o acesso ao menu via teclado,
pressionando a tecla ALT mais a tecla sublinhada correspondente À declaração (no caso ALT
+ A).
257
• Linha 35: cria um item de menu com nome miNovo, contendo o texto “Novo” e uma imagem
criada no mesmo instante da inicialização por meio de new ImageIcon(“MenuNovo.gif”)
• Linha 37: miNovo.setAccelerator(KeyStroke.getKeyStroke (KeyEvent.VK_N,
ActionEvent.ALT_MASK)) – setAccelerator() é o método utilizado para criar um atalho para
o item de menu miNovo. Duas constantes, referentes a teclas, são passadas para esse
método: KeyEvent.VK_N, ActionEvent.ALT_MASK. Dessa forma esse item de menu será
acessado quando o usuário pressionar as teclas ALT+N.
• Linha 62: menuArquivo.addSeparator() – cria um separador no menu, isto é, um traço
vertical que será inserido logo após o menu menuSalvar (linha 61) e antes do menu miSair
(linha 62).





Menus popup

Os menus do tipo Popup, conhecidos também como menus suspensos, são construídos
praticamente da mesma forma que os menus de barra. Eles podem ser atrelados a qualquer objeto
da janela e são acionados por meio do botão direito do mouse. Com essa característica é possível
que uma mesma janela, dotada de diversos botões, invoque menus diferentes, dependendo do
posicionamento do mouse, isto é, dependendo do posicionamento do ponteiro do mouse sobre um ou
outro botão, menus diferentes podem ser chamados.
A principal diferença entre os menus suspensos e os menus de barra se refere à necessidade
de utilização de uma classe especial que permitirá que os diversos objetos da janela (como botões)
reconheçam o menu suspenso. Essa classe especial pode ser elaborada dentro da própria aplicação
e constitui-se na maneira mais simples de utilização dos menus suspensos.

O exemplo 19 demonstra a utilização de um menu suspenso que é reconhecido por um
botão:


import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExIntGrafica19 extends JFrame implements ActionListener{
JPopupMenu mpopup;
JMenuItem miCopiar, miColar, miSalvar;
JMenuBar M1;
JTextField T1;
JButton B1, B2;

public static void main(String args[]) {
JFrame janela = new ExIntGrafica19(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a janela na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica19(){ //construtor
258
setTitle("Uso de Menus Popup"); //titulo da janela

setSize(220,120);
setLocation(50,50);
getContentPane().setBackground(new Color(0,128,128));
getContentPane().setLayout(new GridLayout(3,1));
M1 = new JMenuBar(); //cria a barra de menus
T1 = new JTextField();
B1 = new JButton("Botao 1");
B2 = new JButton("Botao 2");
mpopup = new JPopupMenu();
MouseListener registra = new MostraPopup();
B1.addMouseListener(registra);
miCopiar = new JMenuItem("Copiar");
miCopiar.addActionListener(this);
miCopiar.setMnemonic(KeyEvent.VK_C);
miColar = new JMenuItem("Colar");
miColar.addActionListener(this);
miColar.setMnemonic(KeyEvent.VK_O);
miSalvar= new JMenuItem("Salvar", new ImageIcon("xxx.gif"));
miSalvar.addActionListener(this);
miSalvar.setMnemonic(KeyEvent.VK_S);
mpopup.add(miCopiar);
mpopup.add(miColar);
mpopup.add(miSalvar);
getContentPane().add(B1);
getContentPane().add(B2);
getContentPane().add(T1);
}
public void actionPerformed(ActionEvent e){
if(e.getSource() == miCopiar)
T1.setText("Copiar");
if (e.getSource() == miColar)
T1.setText("Colar");
if(e.getSource() == miSalvar)
T1.setText("Salvar");
}
class MostraPopup extends MouseAdapter{
public void mousePressed(MouseEvent e){
mpopup.show(e.getComponent(),e.getX(),e.getY());
}
}
}


Os aspectos mais importantes do exemplo 19 são:

• Linhas 7 e 37: declaram e inicializam mpopup como sendo um PopUpMenu por intermédio
da classe JPopouMenu.
• Linha 38: MouseListener registra = new MostraPopup(); - cria um evento chamado registro
a partir da classe MouseListener (uma classe que trata eventos do mouse) e o inicializa com
uma classe chamada MostraPopup. Esta é a classe especial citada anteriormente que será
usada para que o menu suspenso seja reconhecido pelos objetos da janela. Ela é definida
entre as linhas 62 e 68.
• Linha 39: B1.addMouseListener(registra); - registra o botão B1 como gerador do menu
suspenso, ou seja, quando o usuário pressionar o botão direito do mouse sobre o botão B1,
aparecerá o menu suspenso, invocando a classe MostraPopup. Observe que o botão B1 é o
único objeto da aplicação que registra o menu suspenso. O botão B2, por exemplo, não
possui ação relacionada ao menu.
• Linhas 62 a 68: definem a classe MostraPopup cuja função foi descrita anteriormente. Essa
estende a classe MouseAdapter, uma classe interna da linguagem Java que realiza o
tratamento de eventos do mouse. A linha 64 possui o método mousePressed que, como o
próprio nome indica, é executado quando o botão do mouse é pressionado, no caso o botão
direito. Na linha 66 é invocado o método show que se encarrega de pressionar o menu
suspenso na janela na posição definida pelas coordenadas X e Y do ponteiro do mouse.

259

Outros objetos podem ser inseridos em menus, aumentando s a complexidade. Por exemplo:
é possível inserir botões de rádio (JRdioButton) e caixas de marcação (JCeckBox). A forma de inseri-
los no menu é a a mesma, ou seja, pelo método ass (menu.add.objeto_selecionado)





Gerenciadores de Layout

A aparência e estética da aplicação são extremamente importantes, pois a interface do
usuário é o “cartão de visitas” da aplicação. Os objetos devem estar distribuídos em harmonia pela
janela, agrupados de tal forma que facilitem a compreensão e execução das tarefas por parte do
usuário, reduzindo a quantidade de movimentos necessária à operação da aplicação.
No decorrer dos exemplos deste capítulo, diversas vezes foram utilizados os gerenciadores
de layout de fluxo (FlowLayout) e de grade (GriLayout). Existem diversos detalhes envolvidos na
utilização desses gerenciadores e, além desses, existem outros tipos de gerenciadores. Este item
procura abordar de forma resumida os principais aspectos envolvidos no gerenciamento de Layout
das janelas por meio dos gerenciadores mais usados.
Uma interface de usuário é construída a partir de componentes chamados conteiners que
contém outros componentes. Os maiores exemplos de contêiners usados até aqui são os Frames
(JFrame) e os painéis (JPanel). Caso nenhum gerenciador de layout seja especificado na aplicação,
a linguagem Java considera que toda a extensão do contêiner é formada por apenas uma célula,
possibilitando assim, a inclusão de apenas um objeto.
Como o leitor observou nos exemplos anteriores deste capítulo, os componentes na são
inseridos na janela por meio de coordenadas X e Y. em vez disso, eles são inseridos de acordo com
a organização definida pelo gerenciador de layout da janela. Os principais gerenciadores de layout
disponíveis pelo gerenciador são: FlowLayout, GridLayout, BorderLayout e CardLayout. Este item
aborda os principais aspectos envolvendo esses gerenciadores.


FlowLayout

O FlowLayout se constitui no mais simples gerenciador de layout da linguagem Java. Nele os
componentes são dispostos da esquerda para a direita na ordem em que aparecem, isto é, na ordem
em que os componentes são adicionados à janela pelo método add. Quando não existe mais espaço
em uma linha é criada outra linha abaixo desta e este critério é usado em toda janela. A distribuição
dos objetos por meio do FlowLayout pode ser comparada à distribuição das palavras que um editor
de texto qualquer faz, isto é, ao terminar o espaço da linha, a palavra é colocada na linha abaixo.
Esse processo é feito automaticamente de acordo com o tamanho da janela.
A sintaxe utilizada para a definição do layout de fluxo é a seguinte:

getContentePane().setLayout(new FlowLayout([alinhamento,
espaçamento_horizontal, espaçamento_vertical|));

Em que;

• Alinhamento – refere-se ao alinhamento que os componentes assumirão no momento em que
forem inseridos no contêiner, podendo assumir os seguintes valores inteiros: 0 = esquerda, 1
= centralizado, 2 = direita. O alinhamento é opcional e quando não especificado, assume
valor 0.
• Espaçamento_horizontal – refere-se à distância que será dada entre os objetos inseridos na
260
mesma linha do contêiner. O espaçamento horizontal é opcional e quando não especificado é
considerado com 5 unidades.
• Espaçamento_vertical – se refere à distância que será dada entre as linhas do container
onde os objetos estão inseridos. O espaçamento vertical é opcional e quando não
especificado, é condiderado com cinco unidades.

Sendo assim, um layout pode ser criado definindo o espaçamento que os objetos terão entre
si na janela, da seguinte forma:

GetContentPane().setLayout(new FlowLayout(1,20,40));

Com esta declaração, será criado um layout de alinhamento centralizado, 20 unidades de
espaçamento horizontal e 40 unidades de espaçamento vertical.





A tabela 13 apresenta as variações possíveis para a definição do layout de um contêiner por
meio do FlowLayout:

Método Função
FlowLayout() Cria um layout padrão: alinhamento centralizado e
espaçamento entre objetos com cinco unidades.
FlowLayout(int) Cria um layout com o alinhamento fornecido e
espaçamentos entre objetos com cinco unidades.
FlowLayout(int,int,int) Cria um layout com o alinhamento, espaçamento horizontal
e espaçamento vertical fornecidos.


GridLayout

O GridLayout é um gerenciador que divide um contêiner num conjunto fr células espalhadas
numa grade retangular, de maneira que todas as células possuam a mesma dimensão. Com o
GridLayout uma janela pode ser dividida em linhas e colunas de acordo com os argumentos
especificados no momento de sua criação. Os componentes são dispostos na ordem em que
aparecem, sendo inseridos na grade da esquerda para a direita e de cima para baixo. Os
componentes adicionados à grade são expandidos de forma a ocuparem todo o espaço da célula em
que estão inseridos. Qualquer modificação no tamanho da janela (ou painel) refletirá
automaticamente no tamanho dos componentes adicionados a ela, ou seja, os componentes são
redimensionados em função da nova dimensão da janela.

A sintaxe utilizada para a definição de layout da forma de grade é a seguintes:

getContentePane().setLayout(new
FlowLayout([numero_de_linhas,numero_de_colunas, espaçamento_horizontal,
espaçamento_vertical|));

Em que:

• Número_de_linhas – refere-se à quantidade de linhas que a grade irá conter. Se não
especificado, assume valor 1.
• Número_de_colunas - refere-se à quantidade de colunas que a grade irá conter. Se não
especificado, assume valor 1.
• Espaçamento_horizontal e espaçamento_vertical – idem ao descrito para o gerenciador
FlowLayout. São parâmetros opcionais.

O espaçamento GridLayout é indicado quando os objetos a serem inseridos em um contêiner
necessitam estar dispostos em forma de linha e colunas, geralmente alinhados. Nem todas as
aplicações utilizam objetos alinhados e, na maioria das vezes, o gerenciador GridLayout sozinho não
261
é uma boa opção, de uma aplicação, geralmente é usada uma combinação de diversos
gerenciadores, utilizando painéis.
A tabela 14 apresenta as variações possíveis para a definição do layout de um contêiner por
meio do GridLayout:

Método Função
GridLayout() Cria um layout com uma linha e uma coluna.
GridLayout(int,int) Cria um layout com o número de linha e colunas
especificados.
GridLayout(int,int,int) Cria um layout com o número de linha e colunas
especificados.e com espaçamento horizontal e
espaçamento vertical fornecidos.


BorderLayout

O BorderLayout é um gerenciador que divide um conteiner em cinco regiões distintas: north
(região superior), south (região inferior), west (região à esquerda), east (região direita) e center
(região central). Diferentemente dos gerenciadores FlowLayout e GridLayout, a ordem com que os
componentes são inseridos é irrelevante, uma vez que o conteiner é dividido em regiões fixas. Em
cada região cabe apenas um componente, ou seja, como o conteiner é dividido em cinco regiões,
apenas cinco componentes podem ser inseridos nesse layout. Caso outro componentes seja inserido
em uma região já ocupada, o componente será sobreposto. Da mesma forma que o GridLayout, as
regiões do BorderLayout são redimensionadas de acordo com as dimensões da janela.
A divisão de uma janela em apenas cinco regiões parece uma desvantagem, porém cada
componente adicionado pode ser um painél que pode ter seus componentes próprios , gerenciados
por um layout próprio.

A sintaxe para definição do layout na forma de regiões é a seguinte:

getContentePane().setLayout(new BorderLayout([espaçamento_horizontal,
espaçamento_vertical]));

Em que:

• Espaçamento_horizontal e espaçamento_vertical – idem ao descrito para o gerenciador
FlowLayout e GridLayout. São parâmetros opcionais.

Para a utilização do BorderLAyout existe uma pequena diferença em relação aos
gerenciadores anteriores: é necessário informar no método add em qual região o objeto será inseirod.

GetContentPane().add(“North”,B1);
GetContentPane().add(“South”,B2);
GetContentPane().add(“West”,B3);
GetContentPane().add(“East”,B4);
GetContentPane().add(“Center”,B5);
Outro ponto a ser observado com o uso do BorderLayout é que as regiões não necessitam
ser preenchidas obrigatoriamente. É possível usar apenas as regiões desejadas. As regiões não
usadas serão consideradas pelo gerenciador como uma região única que pode receber um
componente qualquer. Observe a seguinte listagem:

GetContentPane().add(“North”,B1);
GetContentPane().add(“West”,B3);
GetContentPane().add(T1);

Este trecho utilliza apenas as regiões superior e esquerda; as outras regiões não são usadas.
Dessa forma o objeto T1 (um campo texto) irá ocupar o restante do espaço disponível no layout.

A tabela 15 apresenta as variações possíveis para a definição do layout de um conteiner por
meio do BorderLayout.

Método Função
262
Método Função
BorderLayout() Cria um layout sem espaçamento entre as regiões
BorderLayout(int,int) Cria um layout com espaçamento horizontal e vertical entre
as regiões.


CardLayout

O CardLayout se constitui num gerenciador mais aprimorado que pode agrupar diversos
conteiners na forma de cartões, mostrando um de cada vez, como um baralho ou como páginas de
um livro, ou seja, apenas um conteiner é visível de cada vez. Com esse gerenciador torna-se possível
a criação de pilhas de conteiners e qualquer um pode ser exibido de cada vez. Cada conteiner pode
possuir seu layout específico, permitindo que diversos gerenciadores de layout sejam usados em um
mesmo espaço da janela. Muitas aplicações apresentam esse tipo de agrupamento, em que diversos
formulários podem ser selecionados por meio de uma guia, geralmente na parte superior.

O exemplo 20 demostra o código completo para a manipulação de layout. Cada botão faz
aparecer um novo painel, dando a impressão de trocar a página da janela.


import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExIntGrafica20 extends JFrame implements ActionListener{
JPanel painelBotoes, painelCard, P1, P2, P3;
JButton B1,B2,B3,B4,B5,B6, btpainel1, btpainel2, btpainel3;
JLabel L1, L2, L3;
JTextField T1, T2;

public static void main(String args[]) {
JFrame janela = new ExIntGrafica20(); //declaracao e inicializacao do
objeto janela
janela.show(); //mostra a janela na tela
WindowListener x = new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
janela.addWindowListener(x);
}

ExIntGrafica20(){ //construtor
setTitle("Uso do Gerenciador de CardLayout"); //titulo da janela

setSize(280,170);
setLocation(50,50);
getContentPane().setBackground(new Color(0,128,128));
getContentPane().setLayout(new BorderLayout());
B1 = new JButton("Botao 1");
B2 = new JButton("Botao 2");
B3 = new JButton("Botao 3");
B4 = new JButton("Botao 4");
B5 = new JButton("Botao 5");
B6 = new JButton("Botao 6");
L1 = new JLabel("Esse é o painel 1", JLabel.CENTER);
L2 = new JLabel("Esse é o painel 2", JLabel.CENTER);
L3 = new JLabel("Esse é o painel 3", JLabel.CENTER);
T1 = new JTextField("Linguagem", 20);
T2 = new JTextField("Java", 10);
btpainel1 = new JButton("Painel 1");
btpainel1.addActionListener(this);
btpainel2 = new JButton("Painel 2");
btpainel2.addActionListener(this);
btpainel3 = new JButton("Painel 3");
btpainel3.addActionListener(this);
263
painelCard = new JPanel();
painelCard.setLayout(new CardLayout());
painelBotoes = new JPanel();
painelBotoes.setLayout(new GridLayout(1,3));
P1 = new JPanel();
P1.setLayout(new FlowLayout());
P1.add(L1);
P1.add(T1);
P1.add(T2);
P2 = new JPanel();
P2.setLayout(new GridLayout(4,1));
P2.add(L2);
P2.add(B1);
P2.add(B2);
P2.add(B3);
P3 = new JPanel();
P3.setLayout(new BorderLayout());
P3.add("North", B4);
P3.add("Center",L3);
P3.add("East",B5);
P3.add("South",B6);
painelBotoes.add(btpainel1);
painelBotoes.add(btpainel2);
painelBotoes.add(btpainel3);
painelCard.add(P1, "p1");
painelCard.add(P2, "p2");
painelCard.add(P3, "p3");
getContentPane().add("North",painelBotoes);
getContentPane().add("South",painelCard);
}
public void actionPerformed(ActionEvent e){
CardLayout c1 = (CardLayout) painelCard.getLayout();
if(e.getSource() == btpainel1) //se pressionado o botao painel 1
c1.show(painelCard, "p1"); //exiba o painel 1
if(e.getSource() == btpainel2) //se pressionado o botao painel 2
c1.show(painelCard, "p2"); //exiba o painel 2
if(e.getSource() == btpainel3) //se pressionado o botao painel 3
c1.show(painelCard, "p3"); //exiba o painel 3
}
}

Os aspectos mais impottante do exemplo 20 são:

• Linha 30: define o layout da janela como sendo do tipo BorderLayout, ou seja, dividirá a
janela em cinco regiões.
• Linhas 42 e 43: declarama e inicializam o objeto painelCard como sendo um painel de cartões
criado a partir da classe JPanel e gerenciado a partir de CardLayout.
• Linhas 44 e 45: declaram e inicializam o objeto painelBotoes como um painel no formato
grade, contendo uma linhapor três colunas. Esse painel obrigará os três botões usados na
aplicação para trocar os painéis da janela.
• Linhas 46 a 48: criam e definem o objeto P1 como um painel de fluxo, adicionando a ele o
label L1 e os TextFields T1 e T2.
• Linhas 49 a 51: criam e definem o objeto P2 como um painel de grade contendo quatro linhas
e uma coluna, adicionando a ele o label L2 e os botões B1, B2 e B3.
• Linhas 52 a 54: criam e definem o objeto P3 como um painel de regiões, adicionando a ele o
label L3 e os botões B4, B5 e B6.
• Linhas 55 a 57: adicionam três botões ao painelBotoes.
• Linhas 58 a 60: adicionam os painéis P1, P2 e P3 ao painelCard. Observe que cada painel é
associado uma string de identificação, o que possibilitará invocar a exibição do painel quando
necessário.
• Linhas 61 e 62: adicionam à janela da aplicação os painéis painelBotoes e o painelCard que
contém os três painéis P1, P2 e P3.
• Linha 67: declara e inicializa o objeto cl como sendo um painel da classe CardLayout que
contém o layout definido por painelCard. Esse objeto cl é usado para invocar os painéis
contidos no painelCard por meio do método show(), conforme apresentam as linhas 69, 71 e
264
73. Observe que o método show() contém como argumentos: o nome do painel que será
utilizado (painelCard) e o identificador do painel que será exbido (“p1”,”p2”,”p3”).



Conforme o leitor percebeu, utilizando o gerenciador de layout CardLayout é possível
apresentar diversos tipos de painel em uma só ajanela, sendo possível apresentar diversos tipos de
painéis em uma só janela, sendo possível à navegação entre eles pelos métodos da classe
CardLayout. Observe na tabela 16 os métodos usados para navegação entre os painéis: é possível
exibir i primeiro, o último, o próximo, o anterior ou exibir um painel diretamente por meio de seu nome,
conforme apresentado no exemplo 20. A ordem dos painéis depende da ordem em que foram
inseridos.

Método Função
CardLayout() Cria um layout sem espaçamento entre os painéis
CardLayout(int,int) Cria um layout com espaçamento horizontal e vertical entre
os painéis.
first(container) Exibe o primeiro componente (painel) adicionado ao
CardLayout.
last(container) Exibe o último componente (painel) adicionado ao
CardLayout.
previous(container) Exibe o componente anterior (painel) adicionado ao
CardLayout.
Next(container) Exibe o próximo componente (painel) adicionado ao
CardLayout.
show(container, “String”) Exibe o componente especificado pela string fornecida.








M M

#

F "
# #

M

#

!> !! !$

%
G =

N

O

"& "&

)8 +3 7 *2+ +/ 8 3 9 1 2(+
#

"& "&
N
P

O

$!

)8 +3 7 *2+ +/ 8 3 9 1 2(+
F % &
P

$! $!
%! & ' %" & %" &

J 5+ +, (-) / 9+ , ) *7, 5) .4
M #

%$ &
%% % %' % % %

+A . 4 -5+ *5)* K* / 4 +A . 4 ) / *5)* *+ 4 +4; 5 , ( *5)*4 - B8 4+ ) ) +A . ( * + * +4; 5 , ( *5)*4 - *K*9/ 4+ ) ) +A . ( * ))H 7 +
< ( "
P

% % % %
% %

% % % %
% '% ') % ' % ' % '> % '? % '?

F F F F F F F F
F < * & !
P

% '! %& %' %>
%!

%! %$ %% %
Q RQ %? %' > '+ $ %? > %? > %? > %? >

M

8 4/ 2- 9.9/ 3 + / +3 S 4 7 24K 7 + + ) )+T2- 4)// 29 *8+3 S ( 7 8+3 / +T ;) +3 S )- -/ *; 2- 75( 4 3 2 4-/ 3 47 2+
F !
#

%? > %! > %" > %% ?
%% ? ' +

%' ? %' ? %' ? %' ? % ? !" ! '$ + %? ? % !&

0)-R ., 4 B* B / U.4 56- - ) +/ ) D 4 ;) +3 *; 2) 4; 9 9+ ) 4 8 44 / .9/ + ) )9 A 7 4 4 4 + G)+ 2 *9+ - *7*+, ( *, *4 -5-K50)+; ) )+ -) ) 8 *4 / /
& ,

% !& % !& % !% % !' % !' % !
'$ # % !>

* 9 -+ 8 4 + + /, + + ) / 4 L 4E , (- *5+4* + + - *;+ , )D B 8 ) % && - 5) 1 98/ -1 6- -9 8 4 + + 7 9 5 ., + + ) / 1, 4 L )-9 9 -1 + * .*+ , 5 8 98/ -1 6- -75 +A . 4 8 4 + + 7 9 5 ., 1, *5)* V + ) / 4 L
P NO

% !> % !? % !?
% !?

% !! % !" % !"
% !$ % "& % "&

-

.

'' % "% % "' % " % " '

< G < G G G

% " % " % ">

(/ 9 -+ - *( 4 3 , 6- 8+ , 7 0) -/ - ) ., 4 2
*

% ">
% "? '# % "!

* 9 -1 +-) / , 5 7. + +/ ) , 50 9) * B8 ) D /. )

G

% "! % ""
% "" % "$ % "$

/

&

' 0 % $& % $% % $% % $% % $' % $ % $

W < G G Q G Q W
M M

% $ 1 2 '$ 0 % $>

. + , X) ), ++.*4 * 54 ) .4 ) *7)) ) .+ * 54 *, K / 4 ) ) )/, 9+ ) 1+, ++.*4 - )8 / * ) *7)) , 7 , . + ) 1+, .9 4 - )8 /* ) *; , 7 , . / +

% $> % $?
% $?

% $! % $"
% $" % $"

* *
#

' '& % '& '

9 / 3 ) / 8+3 , 1 ( 8 /+ - 9 / 2- ) 5 () 72 +T .
G

'&
'& '&

/

3

$ '& >

5 *B J .* )) /:/ 4 7 * 7 / 0 4 - , 1 + / . ++7 4/ / E- D/ 4 ) 5 50 9) B 8 4 9( 4 7 ) D 7 - ) . , 8 +-5+ ++ * 9* + + K* . B - /, * 50 9), L72- ++ 5(+ - ) 8 / . ) )13 B )
/

'& > '& > '& ! '& "
0 '& $ '& $ '& $ '& $ '% & '% & '% & '% % '% ' '% ' '% ' '% '% '% '% '% '% > '% >

Y
M

# # # # M P

Z

% '

.9 *; / 8 4 [ )*()) . , .4 UB 1/ +) + ) 1 ) *49+ ++ F ++ . , . 4 8 8 44 ) 9*, ) + + + ), . + 4 + E , / 8 )

'% > '% ? '% ! '% "

/

46 8 9 ; 57 6 : <
= 6>?:; @ 9 <
palavra lógica é originária do grego logos, que significa linguagem racional. De acordo com o dicionário Michaelis, lógica é a análise das formas e leis do pensamento, mas não se preocupa com a produção do pensamento, quer dizer, não se preocupa com o conteúdo do pensamento, mas sim com a forma deste, isto é, com a maneira pela qual um pensamento ou uma idéia são organizados e apresentados, possibilitando que cheguemos a uma conclusão por meio do encadeamento dos argumentos. Os argumentos podem ser dedutivos ou indutivos. Os argumentos indutivos são aqueles com que, a partir dos dados, se chega a uma resposta por meio de analogia, ou seja, pela comparação com algo conhecido, porém esse tipo de raciocínio não oferece certeza de que a resposta será de fato verdadeira. É necessário conhecer os fatos ou as situações para que se possa fazer a comparação. Já os argumentos dedutivos são aqueles cuja conclusão é obtida como conseqüência das premissas, isto é, por meio da análise das situações ou fatos, pode-se obter a resposta. Trabalha-se com a forma das sentenças, sem que haja necessidade do conhecimento prévio das situações ou fatos. Exemplos:

A

+ O

todo mamífero é um animal. todo cavalo é um mamífero. portanto, todo cavalo é um animal. Kaiton é um país do planeta Stix. Todos os Xipins são de Kaiton. Logo, todos os Xipins são Stixianos. Gerson é cientista. Todo cientista é estudioso. Logo, Gerson é estudioso.

b)

c)

A lógica é a “arte do bem pensar”, que é a “ciência das formas do pensamento”. Visto que a forma mais complexa do pensamento é o raciocínio, a lógica estuda a “a correção do raciocínio”. Podemos ainda dizer que a lógica tem em vista a “ordem da razão”.

A6 D 7 8 ?:; BC <9 <
Estudo das técnicas de formalização, dedução e análise que permitam verificar a validade de argumentos. A lógica também objetiva a criação de uma representação mais formal, que se contrapõe à linguagem natural, que é suscetível a argumentações informais.

= 6>?:; 8 E : < < F @ 9 < 6 4
Significa o uso correto das leis do pensamento, da “ordem da razão” e de processos de raciocínio e simbolização formais na programação de computadores, objetivando racionalidade e o desenvolvimento de técnicas que cooperem para a produção de soluções logicamente válidas e coerentes, que resolvam com qualidade os problemas que se deseja programar. O raciocínio é algo abstrato, intangível. Os seres humanos têm a capacidade de expressa-lo através da palavra falada ou escrita, que por sua vez se baseia em um determinado idioma, que segue uma série de padrões (gramática). Um mesmo raciocínio pode ser expresso em qualquer um dos inúmeros idiomas existentes, mas continuará representando o mesmo raciocínio, usando apenas outra convenção.

3

representar mais fielmente o raciocínio da lógica de programação. que pode ser concebida pela mente treinada e pode ser representada em qualquer uma das inúmeras linguagens de programação existentes. a solução de um problema. Quando elaboramos um algoritmo devemos especificar ações claras e precisas. faça Acionar interruptor. 4 . com vistas a alcançar. Colocar uma lâmpada nova. que pode ser descrito de diversas maneiras. Subir na escada. permite-nos abstrair de uma série de detalhes computacionais. dessa forma. 6 6 H < F 8 <: C 7 E 76 C4 6 ? Um algoritmo é uma linha de raciocínio. Assim podemos focalizar nossa atenção naquilo que é importante: a lógica da construção de algoritmos. então Pegar uma escada. que a partir de um estado inicial. Enquanto a quantidade de soquetes testados for menor que dez. Posicionar a escada embaixo da lâmpada. produzem um estado final previsível e bem definido. Exemplo: Algoritmo para trocar lâmpadas (considerando 10 lâmpadas) Descrição narrativa Ir até o interruptor. E CH <8 . Estas.Algo similar ocorre com a lógica de programação. descrição narrativa. como resultado final. ao mesmo tempo. garantindo que sempre que executado. = 6> <: C @ ? Um algoritmo pode ser definido como uma seqüência de passos que visam atingir um objetivo bem definido. Isto significa que o algoritmo fixa um padrão de comportamento a ser seguido. Uma vez concebida uma solução algorítmica para um problema. H G. Para escapar dessa “Torre de Babel” e. Retirar a lâmpada queimada. Colocar uma lâmpada nova. costumamos denominar esse processo de codificação. Se a lâmpada não acender. esta pode ser traduzida para qualquer linguagem de programação e ser agregada das funcionalidades disponíveis nos diversos ambientes. < 7C 4 8 <: C 7 F 6 ? Representar mais fielmente o raciocínio envolvido na lógica de programação e. são muito atreladas a uma grande diversidade de detalhes computacionais. Acionar o interruptor. produza o mesmo resultado. após um período de tempo finito. utilizamos os algoritmos. que pouco têm a ver com o raciocínio original. faça Retirar a lâmpada queimada. Buscar uma lâmpada nova. como por exemplo: pseudicódigo. por sua vez. fluxograma ou diagrama de Chapin. Ir até o interruptor do próximo soquete. sob as mesmas condições. uma norma de execução a ser trilhada. que podem ser acrescentados mais tarde. Enquanto a lâmpada não acender.

Se (lâmpada não acendeu) então Pegar uma escada. Colocar lâmpada nova. Fim enquanto.Diagrama Chapin ou N-S Ir para o primeiro soquete Soquetes testados < 10 Acionar o interruptor Lâmpada não acendeu? F V Pegar uma escada Colocar a escada embaixo do soquete Buscar uma lâmpada nova Acionar o interruptor Subir na escada Retirar a lâmpada queimada Colocar a lâmpada nova Lâmpada não acendeu? Retirar lâmpada queimada colocar lâmpada nova Ir para o próximo soquete Pseudocódigo ou portugol Inicio Declaração de variáveis. Ir para o próximo soquete. Fim enquanto. Subir na escada. 5 . Fim. Enquanto (lâmpada não acender) faça Retirar lâmpada queimada. Buscar lâmpada nova. Colocar a escada embaixo do soquete. Enquanto (soquetes testados) < 10 faça Acionar o interruptor. Colocar lâmpada nova. Fim se. Retirar a lâmpada queimada. Acionar interruptor.

Fluxograma ou Diagrama em blocos início Ir para o primeiro soquete Soquetes testados < 10 Acionar o interruptor Lâmpada não acendeu? Pegar uma escada Colocar a escada embaixo do soquete Buscar a lâmpada nova Acionar interruptor Subir na escada Retirar a lâmpada queimada colocar lâmpada nova Lâmpada não acendeu? Retirar a lâmpada queimada Colocar lâmpada nova Ir para próximo soquete fim 6 .

• processo. 7 8 I 4 6 J 6 <F 1. Com relação as aspecto de documentação. Descreva com suas palavras o que você entende por: • ação. • padrão de comportamento. O que você entende por aspecto estático e aspecto dinâmico de um algoritmo? Qual o conceito que relaciona estes dois aspectos? 4. 3. O que é um bom programa? 7. 2.. • evento.I . qual a vantagem de se utilizar uma pseudolinguagem para desenvolvimento de programas? 7 . Quais são as três estruturas básica de controle com as quais podemos desenvolver qualquer algoritmo? 5. Escreva um algoritmo para descrever como você faz para ir da sua casa até a Faculdade. O que é um programa? 6. • estado.

$% ! " " # & ' $% ()$*'+ ($*. utilizamos os tipos de dados primitivos (literal. Esses dados serão utilizados durante o processamento para a resolução do problema em questão. esses tipos seguem características de formato e espaço disponível nessa memória. Já na confecção de programas. ou seja. ? O s dados são na verdade. existem desdobramentos para esses tipos de dados a fim de adequá-los melhor ao propósito de cada linguagem e à resolução prática dos problemas. as variáveis também terão a função de armazenar dados temporariamente. Ao desenvolver um algoritmo. então. A partir daí. bancos de dados ou outros programas. Como os dados manipulados pelos computadores durante a execução dos programas são armazenados na memória. o valor do dado sofre alteração ou o dado é dependente da execução em um certo momento ou circunstância. uma vez que os algoritmos apenas representam a resolução dos problemas. inteiro. "< D ? 6 Um dado é classificado como variável quando tem a possibilidade de ser alterado em algum instante no decorrer do tempo. pois eles são capazes de manipular e armazenar um grande volume de dados com alta performance.%'+ 8 . Esses valores podem ser fornecidos pelo usuário do programa. Aproximando-nos da maneira pela qual o computador manipula as informações. escolhe-se o tipo adequado para a variável que representará esse valor. a partir de arquivos. para evitar problemas que podem ser ocasionados devido ao fornecimento de valores inadequados à operação que será realizada. mas na memória RAM do computador. vamos dividilas em quatro tipos primitivos. real e lógico). Na confecção de algoritmos. os dados devem ser classificados de acordo com o tipo do valor a ser armazenado na variável. voltemos nossa atenção para um conceito muito importante: informação. que serão os tipos básicos que usaremos na construção de algoritmos. Quando um algoritmo é transcrito para uma determinada linguagem de programação. isto é. podem ser originados a partir de processamentos (cálculos) ou. liberando o Homem para outras tarefas nas quais seu conhecimento é indispensável. Definir o tipo de dados mais adequado para ser armazenado em uma variável é uma questão de grande importância para garantir a resolução do problema. Para que haja integridade no resultado obtido. os valores que serão utilizados para a resolução de um problema. durante a execução do algoritmo em que é utilizado.+ (-* .%. Os dados são armazenados temporariamente em variáveis para que sejam processados de acordo com as especificações do algoritmo. Informação é a matéria-prima que faz com que seja necessária a existência dos computadores.+ # " ()-* . 7 7 A 6<: C 7 . E7E C 7 D Para entender os tipos primitivos. é necessário que se tenha conhecimento prévio do tipo de informação (dado) que será utilizado para resolver o problema proposto.H 6C 7 A 7 .

são utilizados em operações que necessitam de precisão fracionária. não existindo valores para este tipo de dado. em Java../56-'+ (6$ . 9 . seu valor é constante desde o início até o fim da execução do algoritmo ou da execução do programa.-. que representam números de precisão simples e dupla. podem assumir valores positivos e negativos. H < C7 7CH 6 Entendemos que um dado é constante quando não sofre nenhuma variação no decorrer do tempo. int e long. como a < b..5)-2'+ ! " ) (). os caracteres tem o tamanho de 16 bits variando de O a 65. tais como raiz quadrada. -* (* $/.6 7 Em Java o tipo de dados utilizado para armazenar um caractere é o char. uma constante é uma variável declarada com o modificar final Por exemplo: final float pi = 3. << C 6 . short.3 '2'+ (1 **.+ 0 ()* $/. /'. A variação dos valores que cada tipo de dado inteiro pode assumir é mostrada na tabela acima. O tipo char em Java é diferente do char no C/C++./5)-'+ ()$ .* 2-% '3/ .%/'+ %/ ()1 **. /'. char é um inteiro de 8 bits. ?< 7 6H Para valores lógicos. seno e cosseno. E78 < 78 *H 6 8 6 C ?C < C H6 Os números de ponto flutuante. Java não suporta tipos não sinalizados (inteiros somente positivos). assim como é constante para execuções diferentes no tempo. Todos os tipos inteiros são sinalizados. Grego e Árabe. como Latim. É uma união de doze conjuntos de caracteres.%/. Uma variável booleana pode assumir valor true (verdadeiro) ou false (falso). Em Java. Para isso os caracteres unicode necessitam de 16 bits para serem representados.1415f..56-2'+ 7 " 80 4 (2+ 4 " 0 ($+ 4 ' H6 7 C Java define quatro tipos inteiros: byte. Além disso. boolean é o tipo de dado requerido por condicionais que controlam estruturas de controle como if e for. A variação dos valores dos tipos de dados de ponto flutuante podem assumir é mostrado na tabela acima.536. Este tipo de dado é retornado por todos os operadores relacionais.* 2-% '3/ . também conhecidos como números reais. ou seja. O Unicode define um conjunto de caracteres internacional que representa todos os caracteres encontrados em todos os idiomas humanos.+ -* %/ ().-. Java possui o tipo boolean. respectivamente.3 '2. ou seja. Java utiliza o Unicode para representar seus caracteres. Em C/C++. Java define dois tipos de dados de ponto flutuante: float e double. O tamanho de um tipo inteiro não deve ser visto como a quantidade de memória para armazenar o dado e sim o comportamento apresentado pelo dado. Assim. O ambiente de execução Java pode utilizar qualquer tamanho de memória para armazenar o dado desde que o comportamento correto seja mantido.

.out. elas devem ser obrigatoriamente declaradas. // declara uma aproximação de PI char y = 'Y'. • Não utilizar caracteres especiais. 4 ++ .. O identificador é o nome da variável. // a variável x é iniciada com 'Y' H. a seguir é mostrado um trecho de código onde é calculado o comprimento da hipotenusa de um triângulo retângulo com os valores dos dois catetos: // demonstração de iniciação dinâmica class DinIni { public static void main(String args[]) { double cateto_oposto = 3. 4 K 7 8 / K 7 / 2 + D 4 8 H K <F 8 7 D 6 C .. os nomes para as variáveis são case-sensitive. / . short. System.1416. 7 4)R +/ ) . Já as variáveis do tipo boolean. dependendo do ponto do programa em que a variável é utilizada. A forma básica de uma declaração é a seguinte: tipo identificador [= valor]. entre outros. Por exemplo: soma_total é diferente de Soma_Total e também de Soma_total. isto é. como final. independentemente do ponto do programa.\ 5. Por exemplo. Entretanto. Atribui-se a todas as variáveis dos tipos: char. // hipotenusa é iniciado dinamicamente double hipotenusa = Math. for. isto é. O nome de uma variável deve ser único e deve estar de acordo com algumas regras. //inicia x com 22 double PI = 3. exceto os acima citados.0. ou seja. Para se declarar mais de uma variável do mesmo tipo basta utilizar uma vírgula como separador.sqrt(cateto_oposto*cateto_oposto + cateto_adjacente*cateto_adjacente).4 < < D 7 E <<? : < 6 ! D 6 < H : << Toda variável deve ser identificada.f.T. Os caracteres subseqüentes podem também ser algarismos.. Uma variável pode ser iniciada especificando-se um sinal de igualdade e um valor.0 / . O tipo é um dos tipos elementares de Java. identificador [= valor]. A seguir são mostrados alguns exemplos de declarações de variáveis: int a.< F 4 H G . < Embora os exemplos anteriores tenham exibido apenas variáveis sendo iniciadas com valores constantes. torna-se obrigatório sua inicialização com algum valor. byte. desde que seja antes de sua utilização no programa. int etc. float. deve receber um nome ou identificador.( * 5. símbolos (? / : # etc). tanto faz.g=2. Essa característica difere da maioria das linguagens de programação. long e double o valor 0 (zero) por default./ + -) 4-1/ + .. Quando as variáveis são declaradas. cateto_adjacente = 5. a menos que especificado de maneira contrária pelo programador. Em Java. um caractere 'sublinha' ou 'underline' (_) ou o símbolo cifrão ($). • As letras podem ser maiúsculas ou minúsculas. nomes com letras maiúsculas são diferenciados de nomes com letras minúsculas. Java permite que as variáveis sejam iniciadas dinamicamente. / * ./ + ++* 1 3 . como acentos. ou o nome de uma classe ou de um a interface.println("A hipotenusa é " + hipotenusa). c. utilizando expressões válidas no momento da declaração. *4 3 . ç. } 10 . // declaração de três inteiros a.) 8 44 B* B/ 1 . no meio ou no final. b.56. a linguagem Java atribui a elas valores-padrão. int long.0. seja no início. por default. atribui-se false. A linguagem Java exige que todas as variáveis tenham um tipo de dado definido antes de serem utilizadas no programa. mesmo com a linguagem possuindo esses valores padrão. • Não podem ser utilizadas palavras reservadas. b.c int d=1. • Nomes devem começar com uma letra. // declaração de mais quatro inteiros // iniciando d e g byte x = 22.e.

a variável hipotenusa é iniciada dinamicamente utilizando o Teorema de Pitágoras. /**Exemplo1: Essa classe demonstra a utilização de variáveis em uma classe em Java. para calcular a raiz quadrada. */ public class Exemplo1{ I E \ 6 ? double.println("x é " + x). sqrt().} As variáveis cateto_oposto e cateto_adjacente são iniciadas por constantes. de múltiplas linhas e de documentação. Um bloco define um escopo. O terceiro tipo é semelhante ao comentário de múltiplas linhas. entretanto tem o propósito de possibilitar a documentação do programa por meio de um utilitário (javadoc) fornecido pela Sun junto com o SDK. Para inserir comentários que envolvam várias linhas. Em Java existem dois tipos principais de escopo. Um escopo define que objetos são visível para outras partes do código do programa. O escopo define também o tempo de vida de uma variável. pois não são consideradas parte do código. Java permite que as variáveis sejam declaradas em qualquer bloco. devido ao seu modelo orientado a objeto. E 6 6 E 8 " 8 8 6 < 6 <"< D ? 6 Como dito anteriormente. Assim. ou ainda por uma outra pessoa que consulte o programa. Isto significa. tudo o que estiver entre dois sinais será considerado comentário. 7.20. Entretanto. estes tipos de escopo não se aplicam à Java. utiliza-se /* (barra asterisco) para demarcar o início e */ (asterisco barra) para o final. A seguir é mostrado um exemplo em Java mostrando estes conceitos: // Demonstra o escopo de blocos class Escopo{ public static void main(String args[]) { int x. um novo escopo é criado. O programa utiliza também o método embutido. 6C H 7 Os comentários são linhas adicionadas ao programa que servem para facilitar seu entendimento por parte do programador. sempre que um novo bloco é iniciado. } } Um aspecto importante a ser lembrado é que as variáveis são criadas apenas quando o seu escopo é iniciado e são destruídas tão logo seu escopo chega ao fim.y * 3. São declaradas as variáveis do tipo int e O exemplo também demonstra como imprimir o conteúdo das variáveis na tela. } // y não é acessível fora do bloco "if" // x ainda é acessível neste trecho System. ou seja.out. Essas linhas não afetam o programa em si. O Java aceita três tipos de comentários: de uma linha. que é um membro da classe Math. // acessível apenas neste bloco // x e y são acessíveis neste trecho x . o tempo de vida de uma variável dura enquanto seu escopo estiver ativo. Assim. Em linguagens procedurais existem dois tipos de escopo: global e local. // acessível por todo o código dentro do método m x = 10. que uma variável não guardará seu valor uma vez que tenha saído do seu escopo. Esse tipo de comentário inicia-se com /** e é encerrado com */. Contudo. um é definido por uma classe e o outro é definido por um método. 11 . if (x == 10) { // início de um novo escopo int y . Para inserir comentários de linha única utilizam-se // (duas barras) em qualquer local do programa e tudo o que estiver escrito depois deste sinal e na mesma linha será considerado um comentário.

y = 20.0 / < ++ 8 *5.out.println(dolar). /* As linhas seguintes enviam o conteúdo das variáveis para a tela */ System. São eles: 12 .println(y). 4 ) ] 9 / 751 4 ) 4+ ) 1 + " " " " " E < 6 6 8 7 Os operadores são utilizados para representar expressões de cálculo.println(x). 5. System. comparação. double dolar = 2.+ / 2 E < 6 < C > . valor = 3.out. Ex: nome = “fulano de tal”.out.( . Esse valor pode ser pré-definido (variante ou não) ou pode ser o resultado de um processamento.println(“Bem\nvindos\nao\nJava”). C\ ( * + -/ 4 . condição e atribuição. resultado = a + 5.92.1/ + ^ .9 . )7( . } } 9 9 9 : . E < 6 8 8 < A 4 6 C F São utilizados para expressar o armazenamento de um valor em uma variável. System.7 6 8 7 C São utilizados para realização dos diversos cálculos matemáticos.) 4 . } } /**Exemplo2: imprimindo múltiplas linhas de texto com uma única instrução */ public class Exemplo2{ public static void main (String args[]){ //o método main inicia a execução deo aplicativo java System. 8 / ++ 9 7 +* 1 3 . 7 < " " 8 ? @ <# <# = " " 8 " 8 " > # " 99 9B C " " A A " 8 5+ 4[ H 7 4 . aritméticos. relacionais e lógicos. Temos os seguintes tipos de operadores: de atribuição.public static void main (String args[]){ //declaração de variáveis do tipo inteiro int x = 10.out. .T* << ( * / / * .

! . O resultado dessa comparação é sempre um valor lógico (booleano) verdadeiro ou falso. A ) " " 6$ # 66 ! C 5 " $ 66 ( " +> 66 ( $ 5 " " +> )) ( " " $ + + " " + )) ( $ " $ $ ) + D A ) " " )$ # )) = D " # <# E F ! E F ! A *GH " 1 E ( F ( 5 " =8 <# G EE 5 " *- H # " # $+ ( " 4 4 1 H *> / ( * + C <# <# 6 ) 6 ) 6 ) ( + ( + E < 6 6< H 7 6 8 7 ?. < São utilizados para estabelecer uma relação de comparação entre valores ou expressões. ! = I I ! I @ 4 ( " 4 # + IJ ( 0 # 4 + 4 # 4 + KJ ( 0 # 4 + 4 4 = 0 IJ IJ = K K K @ ( = 0 KJ KJ 13 .

O resultado dessas expressões é sempre um valor lógico (booleano) verdadeiro ou falso. % &' % && ' R R S S ( )* + ( "& + R S R S % &' % && ' R S S S ( )* + .! . 0 LJ LJJ ! JJ 4 " ( # 4 0 D4 KI MJ MJ 4 ( 4 4 # E < 6 ?:. ! 5 NN ! " C J 3 NN MJ 1 ( ! 0 3 ! 4 4 PP C J 3 PP MJ 1 ( ! 0 3 ! 4 " 4 # # M M 4 I 3 ( @ O + 3 <Q 4 + 4 1 O + # 1 # < 6< 6 8 8 A ?LD < 6 A tabela verdade expressa o conjunto de possibilidades existentes para a combinação de variáveis ou expressões e operadores lógicos. Veja o exemplo abaixo: !! #$ #$ . 7 6 8 7 9 São utilizados para concatenar ou associar expressões que estabeleçam uma relação de comparação entre valores. "& + % &' ( )* + " % &' "% && ' S S R R % && ' !! ( "& + R R R S 14 .

* 6 6 M . de cima para baixo: (+ UV 66 )) 66 )) 6 ) M W ( " + E F H 6 ) T & <# 8 ) 8 ) ) ) = = : 0 <# 80 O " O <# = " <# D # =8 C <# <# % D D D @ " " " @ @ D D @ @ " " KK II III K KJ I IJ . C <# C <# <# C <# <# C <# " <# C <# # C <# 8 C <# 5 C <# A C <# A C <# C <# # " " @ 15 . Veja abaixo a precedência dos operadores: Os operadores são mostrados em ordem crescente de precedência.8 H 6 8 7 As linguagens de programação normalmente estabelecem uma ordem de avaliação considerando a precedência dos operadores quando mais de um operador é usado em uma expressão.<8 7 E < 6 . JJ MJ N G P NN PP X J 6J )J EJ FJ HJ NJ GJ PJ KKJ IIJ D D # D # 7 7 7 7 O 7 7 5 @ " " " @ % D @ " D 0 0 @ " @ " <# 0 # 0 D D D D D D D @ @ @ @ @ " " " " " " " @ @ " D @ " 4 A A 80 A A 80 5 80 A 80 .

System. Ex: Prefira SalBruto ou SalarioBruto ao invés de SB ou VAR1 Prefira TotAlunosAprovDireta ao invés de TotalAlunosAprovacaoDireta Destaque as palavras-chave das estruturas de controle e comandos com sublinhado.out.out.println(“-x = “ +(-x)). // várias operações com as variáveis System. incluindo.println(“y = “+ y). System. Seus algoritmos deverão ser lidos e entendidos por outras pessoas (e por você mesmo) de tal forma que possam ser corrigidos e receber manutenção. senão • . Vários comandos em uma linha causa ilegibilidade e dificulta a depuração.println(“Inteiro de x por y = “ +(int)(x/y)). principalmente: o descrição do que faz o algoritmo o autor o data de criação Escolha nomes de variáveis significativos. y = 3.out. Obs: Não se esqueça de atualizar os comentários. Ex: se media >= 7 então • . em caso de manutenção. todavia evite nomes muito longos. } } 6 < E <.. < F 8 A H <: C 7 : 7 < 4 6 7 ? • Use comentários com freqüência.println(“Resto de x por y = “ +(x%y)). fim-se Utilize espaços e linhas em branco para melhorar a legibilidade.. • Use comentários. Coloque apenas um comando por linha. no cabeçalho do algoritmo. System.println(“x/y = “ +(x/y)). Isto torna o algoritmo mais legível e facilita o entendimento da lógica empregada. temos: Parênteses mais internos Operadores aritméticos Operadores relacionais Operadores lógicos class Exemplo3{ public static void main (String args[]){ //declaração e inicialização de variáveis int x = 10. Use identação nos comandos de acordo com o nível que estejam.out. Utilize parênteses para aumentar a legibilidade e prevenir-se de erros.out.println(“x = “+ x). • • • • • • 16 . System... Pior do que um programa sem comentários.println(“x + 1 = “ +(++x)).out. alinhe comandos de mesmo nível e desloque comandos de nível inferior. System. ou seja.IIIJ C <# # " De maneira geral. também.out. é um programa com comentários errados. System.

: início comando 1. ao autor da especificação 2. a fim de formar a primeira impressão. releia o problema e faça anotações sobre os pontos principais. com todos os seus caminhos para verificar se o processamento está gerando os resultados esperados. Releia o problema quantas vezes for preciso para tentar entendê-lo. Verifique se o problema foi bem entendido. Extraia do problema todas as suas entradas. se preciso. mas com certeza no desenrolar do algoritmo. 8.Ex. Esta etapa pode parecer obscura no início. Teste cada passo do algoritmo. comando5. 17 . 9. sobre suas dúvidas. 7. Faça uma leitura de todo o problema até o final. Identifique qual é o processamento principal. se condicao1 então comando2. 4. 6. fim-se comando6. Crie valores de teste para submeter ao algoritmo. Verifique se será necessário algum valor intermediário que auxilie a transformação das entradas em saídas. Questione. 5. senão comando4. comando3. A seguir. checando as boas normas de criação. Reveja o algoritmo. Extraia do problema todas as suas saídas. 3. estes valores aparecerão naturalmente. fim > 8 E <8 76 D ? 6 C 8 <: C 7 C < 6 H D H 6 ? 1.

C <> B 5.A > 8 . Sabe-se que o uso incorreto da precedência de operadores ocasiona erros. B <= 5 c) A = 3 . b) determine o resultado das operações.e. em função dos valores dados. B < 5 h) A <> B .I . D <-.(A + B) – 10 * C h) X <-.A + B – 10 * C i) Y <-.e. B = 7 e) A < 5 .A mod D/5 f) Resultado <-. Verifique se as variáveis abaixo possuem nomes corretos e justifique as alternativas falsas: a) n#1 b) tempo c) n_1 d) $din e) n 1 f) K2K g) n1 h) U F i) 2nome j) dep k) nome2 l) val#r 3. avalie as expressões a seguir e: a) classifique a ordem em que as operações devem ser executadas. B <> 7 c) A <= 2 . B > A . B + C <> D 4.e. B = 7 b) A < 3 . Dadas as expressões a seguir.e.OU.e. Pensando nisso. A = 2 . B > 2 .5. C <> A g) A > B . B = 4 .e.não.A > 3 * 2 . Considere a seguinte atribuição de valores para as variáveis: A <-.-4. identificar o resultado verdadeiro ou falso que cada uma delas retornaria. B = C i) C > 2 . . A < B j) A > B .ou. B <--4 e C <-. a) A = 3 .A + B + C + D/4 e) Resultado <-. Complete a tabela-verdade a seguir: # 5 " 7 " # CJ/ KI 3 CJ/ KI 3 CJ/ KI 3 # CJ/ 18 . B >= 4 .ou. C = 8 d) A = 3 .B2 – 4 * A * C b) J <-.e.e. C > 2 f) B > A .ou. 7 8 K < F 6 J 6 I4 1.2 a) Delta <-. B >= 2 .“Hoje” <> “HOJE” c) Media <--(A + B + C+ D)/4 d) Media <-.ou. B = 7 d) . Considere os seguintes valores para as variáveis: A <-.8 a) A > 3 .nâo.3.ou. B <> 7 2. B + C > D j) Y <-.ou.ou.e.e. C = 8 b) A <> 2 .(A mod D)/5 g) X <-.e.e.ou. C <-. C = 8 e) A <> 8 .e. B <-. Supondo A = 2 e B = 7.8..

OU. B = 5 b) A <> 9 .6.ou.-1.OU.0 Nome <-.2. B <= 6 c) . Construa a tabela-verdade para as expressões: a) A >= 3 .v..não. L1 : lógico.2 C <-.3 X <-.ou. Determine o resultado das expressões a seguir: a) Nome = Rua b) X > Y . B <> 5 . C <= B c) (C – 3 * A) < (X + 2 * Z) d) ((Y/2) = X) . X + Y <= 20 .v.ou. C < 8 7.0 Z <-. A = 2 .C :inteiro.5 Y <-. Rua :literal.“Girassol” L1 <-.10.não. 19 . x. L1 <> . C = B .y. L1 f) .e.“Pedro” Rua <-. B >= 1 d) A > 3 .z : real.1 B <-.não. Nome. ((B * 2) >= (A + C)) e) .e.e.B.e. Dada a declaração de variáveis: A. e atribuindo-se a essas variáveis os valores: A <-.

. no momento em que ele é executado. 4 +/ ) S )8 +3 + B* B/ + D 4 S 7*-. S / 9/ +3 . 7 *2-. + -/ S/ .8 *55 . constantes. Os dados que entram em processamento sofrem transformações resultantes do processo e uma saída é produzida. . 0 7 7* 4. expressões lógicas. I E ) 6 ? \ 20 . isto é. deve existir uma perfeita relação lógica intrínseca ao modo pelo qual essas ações são executadas. Através das estruturas básicas de controle do fluxo de execução – sequenciação.7C C < 8 ./ 2. pois após encontrar um (. bem com comandos que traduzam esses conceitos de forma a representar o conjunto de ações. O exemplo a seguir. Quando um parâmetro é recebido por um programa. isto é. H ? 7 6 C 6 a criação de algoritmos utilizamos os conceitos de blocos lógicos. ? A estrutura seqüencial de um algoritmo corresponde ao fato de que o conjunto de ações primitivas será executado em uma seqüência linear de cima para baixo e da esquerda para a direita.. * 77< 6 8 E G 6 7 6 ! D < : 6 < C << Uma aplicação Java pode receber valores a partir da linha de comando. poderemos criar algoritmos para solucionar nossos problemas.). ao modo pelo qual é regido o fluxo de execução do algoritmo. Para que esse conjunto de ações se torne viável. . ENTRADA PROCESSAMENTO SAÍDA N 7C C < 6 N H < =6.8 . devemos saber construí-lo para prever qualquer intenção que o usuário tenha ao utilizar esse programa.._ S K . /7 . ele pode ser manipulado internamente e usado em um procedimento qualquer. relacionais e aritméticas. S . demonstra a utilização da passagem de parâmetros a um programa. Este exemplo apresenta na tela as palavras que o usuário digitar no momento da execução do programa por meio da linha de comando. repetição – e da combinação delas. que objetiva separar uma ação da outra e auxiliar a organização seqüencial das ações.) deveremos executar o próximo comando da seqüência. +3 % 2. Mostramos abaixo o modelo geral de um algoritmo: H.9 / . .-* ( 9 ) . Quando fazemos um programa. representando a solução de um problema.8 *5) K 7 E) . + -/ S -( ._ +3 '_ 22+3 _ K +3 9 2. atribuições. É importante ressaltar a seqüência de fatos que fundamentam a lógica computacional: a entrada de dados que serão processados para obter a saída. seleção. . 9)+ + -/ J S. na mesma ordem em que foram escritas. Convencionaremos que as ações serão seguidas por um ponto-e-vírgula (. variáveis. entrada e saída de dados.8 *5.

é possível converter tipos que a princípio são incompatíveis. embora sejam tipos compatíveis. Felizmente. Em programação é comum atribuir a uma variável de um tipo um valor de outro tipo. //imprima o 1º argumento na tela. System.7 Quanto um tipo de dados é atribuído a uma variável de outro tipo. Nestes casos. Essa característica gera um inconveniente no caso de ser necessária a utilização de valores de outro tipo. Por exemplo. < 8 E7 H 7C 6 . } } Ao executar o exemplo4. Para tanto. 21 . a conversão será feita automaticamente em Java. basta fazer uso do cast. não existe nenhuma convenção definida de double para byte. int i.println(args[1]). ela não atende todas as necessidades.out. uma conversão de int para byte não é automática pois. ou seja. eles serão considerados como caracteres. um short (16 bits) ou um byte (8 bits). pode-se utilizar o cast para fazer a conversão de forma explícita da seguinte forma: (tipo desejado) valor A seguir é mostrado um exemplo de casting e de conversão automática de tipos: class Conversao{ public static void main(String args[]) { byte b = 2. uma conversão automática de tipos é feita desde que estas duas condições sejam satisfeitas: • Os dois tipos são compatíveis. //imprima o 2º argumento na tela. Em diversos tipos de programas em Java. Sempre que os dois tipos forem compatíveis. Contudo nem todos os tipos são compatíveis e. Isto porque são todos compatíveis (tipos inteiros) e o long do que todos os outros.class Exemplo4{ public static void main (String args[]){ System. Por exemplo. portanto. nem todas as conversões são feitas automaticamente. H 67F 8 E 7 6 < H D 6 7C : Como vimos anteriormente. E C 67 <J D Embora a conversão automática de tipos seja de grande ajuda. • O tipo de destino é maior do que o tipo de origem. Por exemplo. é sempre possível atribuir a uma variável long um valor do tipo int. o usuário deve colocar o comando no seguinte formato: java Exemplo4 argumento1 argumento2 Exemplo: java Exemplo4 Aprendendo Java Os argumentos passados na linha de comando sempre se referem a “variáveis” do tipo String devido à sintaxe utilizada no método principal (main). mesmo que sejam passados números como parâmetros.out. um long (64 bits) sempre poderá receber um int (32 bits). Por exemplo.println(args[0]). H 675 7 D 6 C C< . necessitase realizar a conversão entre os diversos tipos primitivos existentes. que executa uma conversão de tipos de forma explícita. args é um vetor de String. Por esse motivo. todos os dados recebidos como argumentos em uma aplicação referem-se a valores do tipo String. o byte é menor do que o int.

// conversão forçada de double para int i = (int) d. } } 22 .println("i = " + i + " e b » " + b). conforme mostrado abaixo: I E $ 6 ? 3 class Exemplo5{ public static void main (String args[]){ double nota1.out. d = 2. media. media = (nota1+ nota2 + trabalho)/3. &JS &JD UV J 0&J 0&J 0&J 0&J Z 0 0 0 0 & + 0 " " " (+ 4( + 4( + 4( + 0( + .parseDouble(args[1])."). (+ S (+ D (+ & + + ' J $2 4 J $2 -3 J *3/ -3 & UV )( O exemplo 5 demonstra a criação de uma classe que recebe três valores da linha de comando (nota1. System.parseDouble(args[0]). System. trabalho = Double.println(“Media = “+ media). nota2 e trabalho) e calcula a média entre as notas.987.987 e i = 2 A linguagem Java possui uma série de classe que realizam essa tarefa de conversão. i = 2 e b = 2 Conversão de double para int.parseDouble(args[2]). //conversão automática de byte para int i = b."). } } Este programa sera a seguinte saída: Conversão de int para byte. existe a necessidade de o usuário entrar com três dados numéricos na linha de comando. System.out. trabalho. nota2 = Double.out. nota2.out.double d . nota1 = Double. utilizando para isso o conversor de tipo String para double.out. System.println("d = " + d + " e i = " + i).2.println("Conversão de double para int. Segue abaixo tabela mostrando essa tarefa: # J $2 J $2 4 0 0 0 0 J $2 3 J Y$2B J Y*2 3/B J Y*2 3/B J Y! B R 0 0 0 & + 0 & & 4 " 4 $ 4 % # & J (4 &J( &J( &J. System. Para que este exemplo seja executado com sucesso.println("Conversão de int para byte.

O bloco try sempre atua em conjunto com um ou vários blocos catch. dependendo do erro gerado na aplicação.println("Houve erro na entrada de dados"). dado = new DataInputStream(System. System.println("Houve erro na conversao.out. O asterisco presente em import java. A instrução import indica que um determinado pacote de classes deve ser carregado no momento da compilação.out. DataInputStream é uma classe que possibilita a entrada de dados via teclado. s = dado. isto é.io. trabalho=0.out. Neste exemplo está sendo chamado o pacote java.println("Entre com a nota 2"). System. é interessante verificar como é possível entrar com dados via teclado. nota2 = Float. trabalho = Float.parseFloat(s).io.out.< E <<6 C< <8 8 8 7 6 ?8 < H 8 6 < Apesar de uma aplicação provavelmente não necessitar receber dados pelo prompt durante a execução do programa. Uma alternativa é realizar a declaração da seguinte forma: import java.io que contém uma série de classes especializadas em entrada e saída de dados.in). • A linha 9 contém o bloco try (tente).DatInputStream. } catch(NumberFormatException e) { System.println("Entre com a nota 1").io. DataInputStream dado. } } } Uma breve explicação do exemplo: • A linha 1 contém uma diretiva de compilação.in).println("Media = "+ media).readLine(). System. digite apenas caracteres numericos"). try{ System. a execução do programa será desviada para um dos blocos catch. Isso é necessário quando uma classe precisa utilizar recursos já definidos em outras classes. dado = new DataInputStream(System. Neste exemplo poderá ocorrer um erro de entrada de dados pelo teclado (IOException) e um erro na conversão de String em float (NumberFormatException). media=0. s = dado. contém um apontamento para uma classe externa que será usada durante o processo de compilação.out. • A linha 8 declara um objeto chamado dado a partir da classe DataInputStream.readLine(). float nota1 =0. nota1 = Float. O exemplo 5 ilustra a resolução do problema apresentado no exemplo 4 utilizando entrada via teclado: I E + 6 ? 3 import java. No exemplo está sendo usada a classe DataInputStream que pertence ao pacote java. class Exemplo6{ public static void main(String args[]){ String s = " ".7 8 C.io. Entenda o pacote como um grupo de classes de mesmo tipo armazenadas em uma pasta qualquer. Um bloco constitui-se num trecho de código delimitado por abre e fecha chaves. O interpretador Java tentará executar o bloco try e se algum erro ocorrer.*. s = dado.println("Entre com a nota do trabalho").readLine(). } catch(IOException e) { System.parseFloat(s).* indica que devem ser carregadas todas as classes presentes no pacote java. pois existem meios mais eficientes de fazer isso.out.parseFloat(s). indicando que será utilizada apenas a classe DataInputStream. 23 .in). media = (nota1+ nota2+ trabalho)/3. nota2 =0.io. dado = new DataInputStream(System.

parseFloat.println. • A variável nome está sendo declarada para receber e armazenar na memória o valor escrito pelo usuário.lang. a execução do programa será desvida para a linha 33 que trata de erros de conversão de tipos.println(nome). • A variável nome recebe. " & \ A linguagem Java possui um pacote de classes padrão que é carregada toda vez que uma classe é compilada. Neste exemplo o programa pergunta qual é o nome do usuário e o escreve novamente na tela. ela é declarada como do tipo String. a linguagem requer um tratamento de entrada de dados para sua leitura correta. Embora isso seja desnecessário para a saída de dados. a variável s recebe o conteúdo do objeto dado (o que foi digitado pelo usuário).out.lang.System.*) da linguagem Java nesse programa.println("Qual o seu nome?"). por meio do método readLine(). Neste momento pode ocorrer um erro de conversão. Na linha 14.in).println("Houve erro durante a leitura"). o valor que o usuário escreveu. Como se deseja a entrada de um texto. novamente. caso o usuário tenha digitado um conteúdo diferente de número. 12 e 13 definem um bloco de tratamento de erros característico da linguagem Java. Caso ocorra algum erro. class Exemplo7{ public static void main(String args[]){ BufferedReader entrada.*.in)). } } } I E # 6 ? 3 Uma breve explicação do exemplo: • A cláusula import indica a utilização do pavote de entrada e saída de dados (java. import java. public static void main (String args[]) indica o bloco de instruções que serão executados quando o programa for requisitado pelo usuário. try{ System.io. Caso ocorra algum erro. o conteúdo da variável s é convertido em uma variável numérica do tipo float por meio de Float. seria necessária a seguinte declaração: import java. System. ela é mostrada na tela como saída de dados. Sempre que houver entrada de dados na linguagem Java. • As linhas 11. • class Exemplo6 indica o nome do programa e. um tratamento de erros similar será necessário. Na linha 13. a execução do programa será desviado para a linha 29 que trata de erros de entrada e saída de dados. • Após a leitura da variável.out. • Nas linhas 4 e 5 estão a declaração e a criação da variável entrada que será utilizada para a leitura do teclado. String nome.out.readLine(). nome = entrada. seria necessário declarar explicitamente a diretiva. Isso é necessário para garantir que a leitura seja armazenada na memóira com o formato de uma seqüência de caracteres (String) para que seu valor possa ser manipulado senmpre da mesma forma. uma vez que manipula troca de dados entre um periférico (teclado) e a memória. Essa maneira de chamar métodos é típica da orientação a objetos. 24 . A variável entrada é um objeto que permite a utilização desse método para leitura.io. A vantagem dessa sintace é que o programador pode utilizar apenas uma varipavel de entrada e depois convertê-la para os valores desejados quantas vezes forem necessárias. Trata-se do pacote java. mesmo para enviar qualquer informação na tela por meio de System. entrada = new BufferedReader (new InputStreamReader System.• • • Na linha 12 o objeto dado recebe o que foi digitado pelo usuário por meio de new DataInputStream(System. } catch(Exception e) { System. Caso esse pacote defaut não fosse carregado automaticamente.out. No caso da classe System. Esta linha pode gerar algum tipo de erro.

util.* (o asterisco indica todas as classes do pacote net). d) Construa um algoritmo que.parseDouble(args[3]). f) Faça um algoritmo que receba duas variáveis numéricas. • divisão do segundo pelo primeiro. • quociente inteiro da divisão do primeiro pelo segundo.n2. em que R é um dado fornecido pelo usuário.out. A utilização do * pode gerar uma certa confusão. • resto da divisão do segundo pelo primeiro. n4 = Double.media. b e c são fornecidos pelo usuário (considere que a equação possui duas raízes reais).parseDouble(args[1]). calcule e imprima: • soma dos dois números.* achando que os dois pacotes (util e net) serão incorporados ao programa. uma vez que ele deve ser usado apenas para identificar um grupo de classes e não um grupo de pacotes. 6 ?87 7 D 2 ? C 7 : ?4 6 6 ! D 3 57 << a) class CalcMedia { public static void main(String args[]){ double n1.parseDouble(args[0]). • Cada lata contém 5 litros. • subtração do segundo pelo primeiro. Não é possível utilizar java.println("A media anual e: "+media).n4. imprima a distância entre eles. n1 = Double. • divisão do primeiro pelo segundo. suponha que um programa utiliza os pacotes java. I E 7\ 6 ? a) Construa um algoritmo que calcule a média aritmética entre quatro notas semestrais quaisquer fornecidas por um aluno (usuário). c) Construa um algoritmo para calcular as raízes de uma equação do 2º grau (ax + bx + c). em que são fornecidos a altura e o raio desse cilindro. sendo que os valores de a. e) Faça um algoritmo para calcular o volume de uma esfera de raio R.n3. } } b) class tintas{ 25 .y1) e Q(x2. media = (n1+n2+n3+n4)/4. tendo como dados de entrada dois pontos quaisquer do plano P(x1. • Cada litro de tinta pinta 3 metros quadrados.parseDouble(args[2]). • multiplicação dos dois números. Por exemplo.A utilização do * não gera overhead (sobrecarga) no programa e normalmente é utilizado para reduzir o tamanho do código. • resto da divisão do primeiro pelo segundo. System.net. • subtração do primeiro pelo segundo.* (o asterisco indica todas as classes do pacote util) e java.y2). b) Construa um algoritmo que calcule a quantidade de latas de tinta necessárias e o custo para pintar tanques cilíndricos de combustível. n3 = Double. • quociente inteiro da divisão do segundo pelo primeiro. n2 = Double. Sabendo que: • A lata de tinta custa R$ 50.00.

println("A distancia entre os pontos e: "+distancia).y. custo = qtde_latas*50.3).out. System.pow(r.out. Area = 3.y1.println("O volume da esfera de raio "+r+" e: "+volume). System.2)).parseDouble(args[1]).distancia. h = Double. x = Double.println("A subtracao do primeiro pelo segundo e r = "+ (xy)). } } d) class DistPontos { public static void main(String args[]){ double x1.parseDouble(args[2]).parseDouble(args[0]).println("A multiplicacao do primeiro pelo segundo e r = " +x*y).pow(r.2) . } } e) class RaioEsfera { public static void main(String args[]){ double r.parseDouble(args[1]).pow((x2-x1).2)+2*3.parseDouble(args[1]). System.out.x1.4*a*c.volume.out. y1 = Double.println("As raizes sao: x1 = "+x1 +" e x2 = " + x2). System.parseDouble(args[0]).public static void main(String args[]){ double custo.14*Math.println("A quantidade de latas necessarias e: "+(int)(qtde_latas)). b = Double.pow((y2-y1).parseDouble(args[0]). System. x1 = Double.out. System.14*Math.h.out.Math. } } f) class Operacoes{ public static void main(String args[]){ double x.sqrt(delta))/2*a.out. System. x2 = Double. y = Double. distancia = Math.y2. x2= (-b .r. total_litros = Area/3.out. 26 .delta.out.Area. } } c) class Equacao { public static void main(String args[]){ double a.parseDouble(args[2]).parseDouble(args[3]).println("A subtracao do segundo pelo primeiro e r = " +(yx)).total_litros. r = Double. a = Double.qtde_latas.parseDouble(args[0]). y2 = Double.x2. x1= (-b + Math.b.println("A soma do primeiro com o segundo e r = "+ (x+y)). volume = (4/3)*3. System.parseDouble(args[1]). c = Double.sqrt(Math. qtde_latas = total_litros/5. delta = Math.x2. System.c.pow(b. r = Double.2)+ Math.println("O custo total da pintura e: "+(int)(custo)).parseDouble(args[0]).14*r*h.sqrt(delta))/2*a.

calcule e imprima a média aritmética entre essas notas. • losango. Calcule e imprima quantos salários mínimos ganha esse funcionário. • arredondamento do número. sabendo que o imposto equivale a 5% do salário. 17) sabe-se que o kilowatt de energia custa um quinto do salário mínimo. • círculo. 14) Calcular e exibir a área de um quadrado a partir do valor de sua diagonal que será digitado. qual será seu novo peso em gramas. calcue e imprima o valor do imposto de renda a ser pago. calcule e imprima: • o peso dessa pessoa em gramas.println("A +(int)(x/y)). 10) Faça um algoritmo que receba dois números. a ser pago por essa residência. em reais. calcule e imprima a subtração do primeiro número pelo segundo.out.out. System. 4) Faça um algoritmo que receba três notas de um aluno. • se essa pessoa engordar 5%.System. a partir de um desconto de 15%. calcule e imprima o novo salário sabendo-se que este sofreu um aumento de 25%. calcule e imprima: • a raiz quadrada desse número. System. • trapézio. 6) Faça um algoritmo que receba um valor de um depósito e o valor da taxa de juros. de cada kilowatt. 11) Faça um programa que receba um número inteiro. 16) Faça um algoritmo que receba o salário de um funcionário. calcule e imprima: • a parte inteira do número. 15) Faça um algoritmo que receba o salário de um funcionário.. Faça um algoritmo que receba o valor do salário mínimo e a quantidade de quilowatts gasta por uma residência. 2) Faça um algoritmo que receba dois números reais. • o novo valor a ser pago por essa residência. calcule e imprima a tabuada de multiplicação desse número.println("O " +(x%y)).out. calcule e imprima o seno e o cosseno desse ângulo. • esse número elevado ao quadrado.out. • o valor. 7) Faça um algoritmo que receba um número inteiro. um valor inteiro. 9) Faça um algoritmo que receba a medida de um ângulo em graus.println("A +(int)(y/x)). • retângulo. Calcule e imprima o valor do rendimento e o valor total depois do rendimento. • quadrado. 12) Faça um algoritmo que receba o valor do salário de um funcionário e o valor do salário mínimo. calcule e imprima a média ponderada dessas notas. ? 1) Faça um algoritmo que receba dois números inteiros e imprima a soma desses dois números. Calcule e imprima: • o valor. 7 8 I 4 O 7C C <76 N H < 6 J 6 <F =6. 27 . 18) Faça um algoritmo que receba o peso de uma pessoa.println("O " +(y%x)). • a parte fracionária do número. em reais. 8) Faça um algoritmo que receba um número real. calcule e imprima a divisão do primeiro número pelo segundo. 3) Faça um algoritmo que receba dois números inteiros. System. calcule e imprima um elevado ao outro. 13) Faça um algoritmo que calcule e imprima a área das seguintes figuras geométricas: • triângulo. 5) Faça um algoritmo que receba duas notas de um aluno e seus respectivos pesos. } } quociente do primeiro pelo segundo e r = " quociente do segundo pelo primeiro e r = " resto da divisao do primeiro pelo segundo e r = resto da divisao do segundo pelo primeiro e r = I .

o somatório 23) entre eles e o resto da divisão do somatório por cada um dos valores. O valor total deve ser apresentado no final da execução do programa. Calcule e imprima: • a idade dessa pessoa. Crie um programa que receba valores quaisquer e mostre a média entre eles.19) Faça um algoritmo que receba o ano de nascimento de uma pessoa e o ano atual. 28 . B fique com o valor de C e C fique com o valor de A. Crie um programa que receba a largura e o comprimento de um lote de terra e mostre a área 22) total existente. O programa deve calcular esses valores seguindo a fórmula total = quantidade1* valor1 + quantidade2 * valor2 + quantidade3 * valor3. 24) Uma determinada pessoa que trabalha com construção de piscinas precisa de um programa que calcule o valor das construções solicitadas pelos clientes. 20) Crie um programa que receba três nomes quaisquer por meio da linha de execução do programa. no seguinte formato: 21) quantidade1 valor1 quantidade2 valor2 quantidade3 valor3. Após as entradas. o outro nome (o segundo) será impresso na segunda linha. 26) Escreva um algoritmo para trocar os valores de três variáveis A. sabendo-se que os clientes sempre fornecem o comprimento. e os imprima na tela da seguinte maneira: o primeiro e o último nomes serão impressos na primeira linha um após o outro. B e C de modo que A fique com o valor de B. Leve em consideração que o valor da construção é cobrado por m3 de água que a piscina conterá e o preço é de R$ 45.00 por m3. • essa idade convertida em semanas. digitar um valor referente ao pagamento da somatória destes valores. a largura e a profundidade da piscina a ser construída. Faça um programa que receba a quantidade e o valor de três produtos. 25) Entrar via teclado com o valor de cinco produtos. Calcular e exibir o troco que deverá ser devolvido.

29 . fim. caso contrário (<condição> for falsa). são ou não satisfeitas. * ?D< P D 6 ! D << 7L. usamos uma seleção simples. delimitado por inicio e fim. que segue o seguinte modelo: se <condição> então C. representadas por expressões lógicas ou relacionais. C2. // seqüência de comandos .7C C < 8 766 F 7 6 ?4 Uma estrutura de seleção permite a escolha de um grupo de ações (bloco) a ser executado quando determinadas condições. Em Java esta estrutura possui as seguintes sintaxes: a) b) if (<condição>) C. Se <condição> for verdadeira. Cn) será executado. ./ +7 throw void const Palavras-chave em Java boolean char double finaly import native protected 4( * 1) throws volatile goto break class else float instanceof new public 4 /J `. . então. encerrando-se a seleção (fimse). conforme o seguinte modelo: se <condição> então inicio // inicio do bloco verdade C1. // comando único (ação primitiva) fimse. // comando único (ação primitiva) if (<condição>) { // inicio do bloco verdade C1. pode gerar um resultado falso ou verdadeiro. o “bloco verdade” (seqüência de comandos C1 . onde: <condição> é uma expressão lógica que. . Cn. A existência do bloco (demarcado por inicio e fim) é necessária devido à existência de um conjunto de ações primitivas sob a mesma cláusula então. . então basta escrevê-la. quando inspecionada. < 6 << abstract catch do final implements long private 4. //fim do bloco verdade fimse. nada é executado. Quando existir apenas uma ação após a cláusula. 7 transient while byte cotinue extends for int null return syncronized true case default false if interface package short this try Palavras-chave que são reservadas mas não são utilizadas por Java 66 F ?4 E6 ?7 Quando precisamos testar uma condição antes de executar uma ação. já quando precisamos colocar diversas ações é necessário usar um bloco.

parseDouble(args[3]). item obrigatório na linguagem Java. // seqüência de comandos . usamos a estrutura de seleção composta.n2. } } 66 F ?4 E 7C < Quando tivermos situações em que duas alternativas dependem de uma mesma condição. if (ma >= 6) System. n1 = Double.n4.n4). 30 .out. caso o aluno obtenha nota maior ou igual a seis. b) programa em Java class CalcMedia { public static void main(String args[]){ double n1.} C2. C2. n2 = Double. //ação primitiva fimse.parseDouble(args[0]). fimse.ma. I E \ Construa um algoritmo que calcule a média aritmética entre quatro notas semestrais 6 ? quaisquer fornecidas por um aluno (usuário). a) algoritmo em pseudocódigo inicio //declaração de variáveis n1.n2.n3. // seqüência de comandos . n4 = Double. fim.n3.n3.parseDouble(args[2]).parseDouble(args[1]). //entrada de dados ma := (n1+n2+n3+n4)/4. fim. Cn. o programa deverá emitir a mensagem “Aluno aprovado”. n3 = Double. //saída de dados se (ma >= 6) então escreva(“aluno aprovado”). //processamento escreva(ma). //fim do bloco verdade senão C.out. . Cn.println("Aluno aprovado"). uma das condições ser verdadeira e outra condição ser falsa. ma = (n1+n2+n3+n4)/4. . //fim do bloco verdade Observe que a condição deve sempre aparecer entre parênteses. O programa deve informar. leia(n1.ma:real.n4. Supondo que um conjunto de ações dependa da avaliação verdadeiro e uma única ação primitiva dependa da avaliação falso. System. usaremos uma estrutura de seleção semelhante ao seguinte modelo: se <condição> então inicio // inicio do bloco verdade C1.n2.println("A media anual e: "+media).

n1 = Double.println("Aluno aprovado!.n2. n2 = Double. caso contrário. Estude mais! "). a seleção agora é composta.out. if (ma >= 6) System. . // seqüência de comandos . C2. } //fim do bloco verdade else C. caso o aluno obtenha nota maior ou igual a seis. b) programa em Java class CalcMedia { public static void main(String args[]){ double n1. else System. //entrada de dados ma := (n1+n2+n3+n4)/4. Assim como a maioria das instruções Java. leia(n1. a) algoritmo em pseudocódigo inicio //declaração de variáveis n1.n3. o uso das chaves se faz desnecessário. I E \ Construa um algoritmo que calcule a média aritmética entre quatro notas semestrais 6 ? quaisquer fornecidas por um aluno (usuário).out.n3. tanto no if como no else. caso o resultado seja falso.n3. “Aluno reprovado”. porém.parseDouble(args[2]). o programa deverá emitir a mensagem “Aluno aprovado”. fim.n4. teremos a execução do comando C (ação primitiva) que segue a cláusula senão.println("A media anual e: "+media). O programa deve informar.n2.out. ma = (n1+n2+n3+n4)/4.Observamos que a existência do bloco verdade continua. sendo que este será executado caso <condição> (expressão lógica) seja verdadeiro. pois.parseDouble(args[0]). fimse.println("Aluno reprovado!.ma:real. Parabéns!").n4).n2. } } 31 . Em Java esta estrutura possui a seguinte sintaxe: if (<condição>) { // inicio do bloco verdade C1. Lembre-se de que as chaves são utilizadas quando se necessita que um bloco de instruções seja executado. //saída de dados se (ma >= 6) então escreva(“aluno aprovado”).ma.n4. Cn. n3 = Double.parseDouble(args[1]). senao escreva(“aluno reprovado”). //processamento escreva(ma).parseDouble(args[3]). System. n4 = Double. o conjunto if else deve ser utilizado em minúsculas e caso haja apenas uma instrução a ser executada.

C2. senão se <condição3> então inicio // bloco verdade2 C1. // seqüência de comandos . verificar se eles podem ser os comprimentos dos lados de 6 ? um triângulo e. sendo que.66 F ?4 H< 68 .C : H < ?4 H < 6 8 66 M 6 Podemos construir uma estrutura de seleção de diversas formas. //comando verdade fimse.8 < < Quando. tal formação ocorre quando uma determinada ação ou bloco deve ser executado se um grande conjunto de possibilidades ou combinações de situações for satisfeita. B e C. C2. isósceles ou escaleno. Cn. Informar se não compuserem nenhum triângulo. 8 < <. //bloco verdade1 fimse. se forem. Quando não conseguimos identificar um padrão lógico de construção em uma estrutura de seleção encadeada. dizemos que esta é uma estrutura de seleção encadeada heterogênea. agruparmos várias seleções. senão CF. fim. // seqüência de comandos . fim. . // comando verdade fimse. % ( ( " 1 3 I E \ Dados três valores A. verificar se compõem um triângulo equilátero. devido à necessidade de processamento. se <condição1> então se <condição2> então inicio // bloco verdade1 C1. 66 F 6 . fimse. Podemos resumir todas as variações possíveis da seleção encadeada do modelo anterior em uma tabela de decisão. . //bloco verdade2 senão se <condição4> então se <condição5> então CV. conforme a tabela abaixo: $ / 2 2 2 ( $ / 0 0 0 ) $ 0 / 2 2 * $ 0 0 / 2 + $ 0 0 / 0 . ao encadearmos várias seleções. formaremos uma seleção encadeada. Normalmente. Cn. a) algoritmo em pseudocódigo 32 . as diferentes possibilidades de construção tendem a um número elevado. fimse.

senão se ((a = b) ou (a = c) ou (b = c)) então escreva(“Triângulo isósceles”). Se Então se Vamos supor que. Outro fato importante é que o comando W sé será executado quando todas as condições forem ao mesmo tempo verdadeiras. } else System.parseInt(args[2]).c).println("Os lados nao formam um triangulo"). Após cada então existe outro se.b. leia(a.out. a = Integer. temos uma estrutura homogênea. se ((a < b + c) e (b < a + c) e (c < a + b)) então se (a = b) e (b = c) então escreva(“Triângulo equilátero”).b. seria equivalente a escrever. else if ((a == b) || (a == c) || (b == c)) System. um comando genérico W deva ser executado apenas quando forem satisfeitas as condições <condição1>. fimse. } } 66 F 6 .out. simplificadamente: 33 .parseInt(args[0]). fimse. c = Integer. Teríamos: • se <condição1> então se <condição2> então se <condição3> então se <condição4> então W.println("Triangulo isosceles"). fimse. senão escreva(“Estes valores não formam um triângulo”).parseInt(args[1]). fimse. b = Integer. fim.b.inicio a. senão escreva(“Triângulo escaleno”). fimse.out. 8 < <?4 H< 68 :H< M6 Chamamos de seleção encadeada homogênea a construção de diversas estruturas de seleção encadeada que seguem um determinado padrão lógico. e não existem senões.c:inteiro. em um dado algoritmo. Esta construção segue um padrão.println("Triangulo equilatero"). portanto. if ((a < b + c)&&(b < a + c) && (c < a + b)){ if ((a == b) && (b == c)) System. <condição3> e <condição4>. fimse. b) programa em Java class triangulo{ public static void main(String args[]){ int a.c. <condição2>.

fimse. fimse. simultaneamente: $ / • ( $ / ) $ / * $ / + % " 4 Se senão se Vamos supor que em determinado algoritmo uma variável X possa assumir apenas quatro valores. fimse. fimse. podemos transformá-la em um conjunto de seleções encadeadas. conforme o seguinte modelo: se (X = V1) então C1. não é igual a V1. sendo eles V1. V2. por exemplo. senão se (X = V4) então C4. /* 2 2 / 2 .. nem a V2.se <condição1> e <condição2> e <condição3> e <condição4> então W. Essa nova estrutura de seleção gera a tabela de decisão mostrada abaixo: 34 . a seguinte situação: se (X = V1) então C1. Para melhorar a performance dessa estrutura. senão se (X = V2) então C2. /( / 2 2 2 . se (X = V2) então C2.. fimse. pois as seleções não estão interligadas.. fimse. senão se (X = V3) então C3.. Teremos. Por isso todas as condições (X = Vn) serão avaliadas e ocorrerão testes desnecessários. V3. e que exista um comando diferente que será executado para cada valor armazenado em X. fimse. fimse. se (X = V4) então C4. comando pode ser executado. A tabela abaixo expressa nitidamente a necessidade de todas as condições serem verdadeiras. Não se trata de uma estrutura encadeada. isto é. fimse. V4. nem a V4). /) 2 / 2 2 . se (X = V3) então C3. A tabela de decisão para o exemplo é: . trata-se de uma situação excludente (se X é igual a V3. /+ 2 2 2 / % 1 3 5 6 Somente um e apenas um.

então. V4: C4. Para executarmos um comando que possui mais de um valor em que se verifica sua necessidade. fimse. senão se (X = V3) então C2. O modelo que expressa as possibilidades do exemplo anterior é o seguinte: escolha x caso caso caso caso . pode ser simplificado. Como esta situação é bastante freqüente na construção de algoritmos que dependem de alternativas. E. Se o conteúdo de X for igual a V2. o número médio de testes a serem executados foi reduzido. compondo uma estrutura típica que denominaremos se-senão-se. incluímos outra situação: caso contrário. utilizaremos uma estrutura específica para estes casos. . para executarmos um comando que se verifica com todos os outros valores. /+ 0 0 0 / % 1 3 5 6 Nessa estrutura. e para tal utilizaremos uma nova estrutura. V3: C3. serão executados apenas dois testes (X = V1) e (X = V2) e um comando (C2). a seleção de múltipla escolha. o comando Cn será executado. caso fimescolha. . senão C5. O exemplo genérico a seguir mostra uma estrutura de seleção encadeada homogênea sesenão-se: se (X = V1) então C1.. caso contrário. 35 . /) 0 / 2 2 . /* 0 0 / 2 . serão inspecionados os outros casos até ser encontrada uma igualdade ou terminarem os casos. a seleção de múltipla escolha. senão se (X = V4) então C3. agrupamos todos esses valores em um único caso. exceto os discriminados caso a caso. senão se (X = V5) então C4.. após cada senão existe outro comando se e depois do então existe uma ação qualquer (que não seja outra seleção). 66 F 8 QC ? 6 ?< ?4 6 ? E< 7. P Quando um conjunto de valores discretos precisa ser testado e ações diferentes são associadas a esses valores.. Vn:Cn Caso o conteúdo da variável X seja igual ao valor de Vn. /( / 2 2 2 . enquanto na estrutura anterior seriam inspecionados quatro condições. V1: C1. embora um único comando (C2) tenha sido executado. Essa construção segue um padrão.. estamos diante de uma seleção encadeada homogênea do tipo sesenão-se. senão se (X = V2) então C2. Por constituir um encadeamento homogêneo. V2: C2..

Realize também o controle dos possíveis erros que podem ocorrer durante a execução do programa. mostre na tela o novo valor do produto acrescida a porcentagem correspondente.' $2 *3 % 1 O ) 2. caso V5: C4. segundo a tabela seguinte: $0 $ / ' 1 $3 *2 -3 /2 Utilizando a estrutura switch-case. Siga a tabela de código a seguir: $0 $ * / 3 . fimse. Caso o código não seja nenhum dos especificados. fimescolha.fimse. caso contrário:C5. 4) Crie um programa para cálculo do salário líquido em que três valores devem ser informados pelo usuário na linha de comando: a quantidade de horas trabalhadas.V3: C2. que ao ser reescrita utilizando a estrutura de múltipla escolha fica da seguinte maneira: escolha x caso V1: C1. fimse. Construa um algoritmo que. I E 7\ 6 ? 1. Crie um programa que receba pelo teclado (use DataInputStream) o valor de um produto e um código de aumento. fimse. depois de 3) Faça um aplicativo que receba três números inteiros na linha de comando e mostre o maior dentre eles. o salário hora e o número de dependentes. O programa deve mostrar na tela as informações contidas no lado esquerdo da tabela seguinte. 2 [ E $# 6 (32E \ " + 36 . mostre o preço junto de sua procedência. tendo como dados de entrada o preço de um produto e seu código de origem. Os cálculos correspondentes aparecem no lado direito. o produto deve ser encarado como importado. caso V4: C3. caso V2.

produto do Oeste”). : ) . bonus). “ . caso 3: escreva(preco. caso 4: escreva(preco. “ . fimse. : J J $# KJ $222 E' 3F$22 I $222 E1F$22 KJ 322 I 322 KJ $222 E3F$22 I $222 E. “ . “ . caso 10: escreva(preco.origem). se(tempo >=5) então bonus = salario*0.produto do Sul”). tempo). ? C 7 6 ?87 : 7 D 1) inicio //declaração de variáveis preco:real.produto importado”). tempo:inteiro. J2 7 ) . caso 7.produto do Centro-Oeste”).in)).10. J 7 ) .6. J 7 @ . escolha origem caso 1: escreva(preco.25: escreva(preco. escreva(“O valor do bonus e: “.2 D .20. entrada = new BufferedReader (new InputStreamReader (System. fim. caso contrario: escreva(preco. class ExSelecao4{ public static void main(String args[]){ BufferedReader entrada. “ . fim. ?4 6 6 ! D 3 57 << % O import java.produto do Sudestel”). bonus :real. “ . 7 5) A empresa XKW Ltda. “ . Calcular e exibir o valor do bônus. 7 ) . origem:inteiro. “ . 37 .8. Concedeu um bônus de 20 por cento do valor do salário a todos os funcionários com tempo de trabalho na empresa igual ou superior a cinco anos e dez por cento aos demais.produto do Nordeste”).9: escreva(preco. : ) . 4) inicio //declaração de variáveis salario. leia(preco.io. senão bonus = salario*0. fimescolha.F$22 ).*.produto do Leste”). caso 5. leia(salario.produto do Norte”). : D . caso 2: escreva(preco.

preco = Double.println("Entre com o preço do produto:").break. System.println("R$ " +preco + " . switch(origem){ case 1:System. case 4:System.out. origem = Integer.io.out.out.println("R$ " +preco + " .readLine().readLine().out.out.parseInt(entrada. case 5: case 6: case 25:System.break.parseFloat(s). int origem.out.println("Houve erro durante a leitura").in).20))). int codigo. } } catch(Exception e) { System.break. default: System.println("O valor com o aumento e: "+(valor+(valor*0.break.produto do Leste"). System.println("O valor com o aumento e: "+(valor+(valor*0.out.println("Entre com o valor do produto:").double preco. 38 .out. try{ System. class ExSelecao1{ public static void main(String args[]){ String s = " ". DataInputStream dado.out.println("R$ " +preco + " .println("R$ " +preco +"Produto importado").out.out.println("R$ " +preco + " . codigo = Integer.in).break.println("O valor com o aumento e: "+(valor+(valor*0. case 7: case 8: case 9:System.out.break. valor = Float. float valor = 0.produto do Sul").println("Entre com o codigo de origem:").parseInt(s).println("Entre com o codigo do aumento:").*. } } } 'O import java. try{ System.println("R$ " +preco + " . case 4:System.parseDouble(entrada.break.break.out.produto do Norte"). case 2:System. s = dado. case 3:System.out.produto do Nordeste"). s = dado. case 10:System.readLine()).produto do Oeste").readLine()).35))).out. dado = new DataInputStream(System. dado = new DataInputStream(System.println("R$ " +preco + " . case 3:System.println("R$ " +preco + " .break.produto do Sudeste"). switch(codigo){ case 1:System.produto do CentroOeste").out.15))).break.

a = c.out. } } } O class ExSelecao2{ public static void main(String args[]){ int a.readLine()).parseDouble(entrada. default: System. b = c.println("Entre com o numero de dependentes:").parseInt(args[0]). INSS=0.println("Houve erro na entrada de dados").out.case 8:System.aux.out. a = b. digite apenas caracteres numericos"). SH.println("Entre com o valor da hora trabalhada:").parseInt(args[2]). if(a>b){ aux = a.io.Sal_Bruto.out.out.println("Entre com a quantidade de horas trabalhadas:"). a = Integer. ND.break.println(" "+a+ " " +b+ " "+c). System. IR=0.println("Houve erro na conversao.parseDouble(entrada. } catch(NumberFormatException e) { System.c. entrada = new BufferedReader (new InputStreamReader (System.40))).readLine()). System. HT = Double. } if(b>c){ aux = b. b = Integer. SH = Double. try{ System.parseDouble(entrada.out.out. c = aux. } System.readLine()). class ExSelecao3{ public static void main(String args[]){ BufferedReader entrada.in)). } } catch(IOException e) { System. double HT. c = Integer. } if(a>c){ aux = a. b = aux.*.parseInt(args[1]). c = aux. } } O import java. Sal_Liquido.out. //calculo do INSS if(Sal_Bruto <=1000) 39 . //calculo do salario bruto Sal_Bruto = HT * SH + (50*ND).println("Codigo invalido").println("O valor com o aumento e: "+(valor+(valor*0.b. ND = Double.

parseInt(entrada. calcule e imprima a média aritmética das notas e a mensagem de aprovado para média superior ou igual a 7.0. class ExSelecao4{ public static void main(String args[]){ BufferedReader entrada.out. 7 8 K < F O 7C C <8 766 F 6 J 6 I4 6 ?4 1) Faça um programa que receba quatro notas de um aluno. //Impressão do resultado System.out.parseFloat(entrada. float salario.io.readLine()).bonus. Escreva um programa que receba o salário de um funcionário e imprima o valor do salário reajustado ou uma mensagem caso o funcionário não tenha direito ao aumento. 2) Uma empresa decide dar um aumento de 30% aos funcionários cujo salário é inferiora 500 reais. else bonus = salario*0. try{ System. //Calculo do salario liquido Sal_Liquido = Sal_Bruto . salario = Float.readLine()). }catch(IOException e){ System.out.out.out. } } } O import java.INSS = Sal_Bruto*8.INSS . if(Sal_Bruto >1000) INSS = Sal_Bruto*9/100.in)).out. System. System.20f. } } } I . } catch(Exception e) { System. System. int tempo.. if(Sal_Bruto >1000) IR = Sal_Bruto*7/100.out.println("O salario bruto e de: " +Sal_Bruto). 40 .10f.out. //calculo do Imposto de Renda if(Sal_Bruto <=500) IR = 0. tempo = Integer.println("O Desconto de INSS foi de: " +INSS).println("Ocorreu erro durante a leitura").5/100.println("O valor do bonus e: "+ bonus).println("Houve erro durante a leitura").0 ou a mensagem de reprovado para média inferior a 7. System.println("O Desconto de IR foi de: " +IR). if((Sal_Bruto >500)&&(Sal_Bruto <=1000)) IR = Sal_Bruto*5/100. if(tempo >=5) bonus = salario*0.out.println("Entre com o salario:"). entrada = new BufferedReader(new InputStreamReader(System.println("O salario Liquido e de: " +Sal_Liquido).*. System.println("Quanto tempo esta na empresa?").IR.

a uma avaliação semestral e a um exame final.0 |__ 6. A tabela a seguir fornece os pesos das notas: Laboratório peso 2 Av. A senha é um conjunto de caracteres que são: 'ASDFG'.0 D < 5. 7) Faça um programa que receba a idade de um nadador e imprima a sua categoria seguindo as regras: categoria infantil A infantil B juvenil A juvenil B sênior idade 5 – 7 anos 8 – 10 anos 11 – 13 anos 14 – 17 anos maiores de 18 anos 8) No curso de Desenvolvimento de Software. calcule e imprima a média final e o conceito desse estudante.0 reprovado 5.7 * H) . A procedência obedece a seguinte tabela: Código Procedência 1 Sul 2 Norte 3 Leste 4 Oeste 5 ou 6 Nordeste 7. calcule e imprima o seu peso ideal. 5) Faça um programa que calcule e imprima o salário reajustado de um funcionário de acordo com a seguinte regra: • salários até 300.0 aprovado 41 .0 B 6. verifique se este número é par ou ímpar e imprima a mensagem. As notas variam de 0 a 10 e a nota final é média ponderada das 3 notas mencionadas.0 |__| 10.8 ou 9 Sudeste 10 até 20 Centro-Oeste 21 até 30 Nordeste 10) Faça um programa que receba um número. a nota final do estudante é calculada a partir de 3 notas atribuídas respectivamente a um trabalho de laboratório. reajuste de 50%.0 |__| 10.0 |__ 5. • salários maiores que 300. O programa deve imprimir mensagem de permissão ou negação de acesso.0 E 9) Faça um programa que receba o preço de um produto e o seu código de orígem e imprima a sua procedência.3) Faça um programa que verifique a validade de uma senha fornecida pelo usuário.0 |__ 7. 4) Faça um programa que receba a idade de uma pessoa e imprima mensagem de maioridade ou não. utilizando as seguintes fórmulas: • para homens: (72. 11) Faça um programa que receba dois números e imprima o menor dos dois. Semestral peso 3 Exame final peso 5 Faça um programa que receba as 3 notas do estudante. 6) Faça um programa que receba a altura e o sexo de uma pessoa.0 |__ 7.7. O conceito segue a tabela abaixo: média final conceito 8.58.0 |__ 8.0 A 7.0 C 5. reajuste de 30%.0 exame 7. 12) Faça um programa que receba três notas de um aluno. calcule e imprima a média aritmética entre essas três notas e uma mensagem que segue a tabela abaixo: Média Mensagem 0.1 * H) – 44. • para mulheres: (62.

Somente pessoas com pelo menos 18 anos e não mais de 70 anos podem adquirir apólices de seguros. / $ 78 ' 3 * % 1 % - Faça um programa que receba a idade e o grupo de risco (b.2 .13) Faça um programa que receba a idade de uma pessoa e classifique-a seguindo o critério a seguir: $ 2 $* *2 C * $$ $1 33 33 7 < ) 14) Faça um programa que receba o código correspondente ao cargo de um funcionário e imprima seu cargo e o percentual de aumento ao qual este funcionário tem direito seguindo a tabela: $0 $ * / 3 O ] D :# 5 $ 32 22H -3 22H *2 22H $2 22H 15) Faça um programa que mostre um menu com as seguintes opções: soma raiz quadrada finalizar O programa deve receber a opção desejada. Determine e imprima o quadrante em que se localiza este ângulo. Quanto às classes de ocupações foram definidos três grupos de risco. A tabela a seguir fornece as categorias em função da caixa de idade e do grupo de risco: 3 ( $ $' *3 /$ */ /2 . • • • 16) Uma companhia de seguros tem três categorias de seguros baseadas na idade e na ocupação do segurado. receber os dados necessários para a operação de cada opção. um número inteiro. Considere os quadrantes abaixo: Ângulo Quadrante 0 |__ 90 90 |__ 180 180 |__ 270 270 |__ 360 0 __ -90 1º quadrante 2º quadrante 3º quadrante 4º quadrante 1º quadrante 42 . m ou a) e determine e imprima o código do seguro. Na opção finalizar nada deve acontecer. realizar a operação e imprimir o resultado. 17) Faça um programa que receba a medida de um ângulo em graus.

O valor do prêmio é obtido pela consulta na tabela a seguir. o número de horas-falta em horas e o valor do prêmio. em que: H = (número de horas extras) – (2/3*(número de horas-falta)) 4 5 I */2 $'22 ^^P */22 $*22 ^^P $'22 %22 ^^P $*22 KJ %22 6 322 /22 -22 *22 $22 576 Faça um programa que receba o número de horas extras e o número de horas. • o cálculo do valor do imposto de renda retido na fonte segue a tabela abaixo: 2 8 # . 24) Escreva um programa que leia três valores inteiros e mostre-os em ordem crescente. • o salário do mês é igual ao número de horas trabalhadas vezes o valor da hora trabalhada. conte e imprima o número de vogais desta frase. Imprima o número de horas extras em horas. 19) Faça um programa que receba o valor do salário mínimo.Ângulo -90 |__ -180 -180 |__ -270 Quadrante 2º quadrante 3º quadrante -270 |__| -360 4º quadrante Para ângulos maiores que 360 graus. Utilize os códigos da tabela a seguir para ler qual a condição de pagamento escolhida e efetuar o cálculo adequado: $0 $ 43 . considerando o preço normal de etiqueta e a escolha da condição de pagamento. reduza ao intervalo de 0 a 360. 21) Faça um programa que receba uma frase. conte e imprima a quantidade de vezes em que aparece a palavra “aula”. baseada no número de horas extras e no número de horas que o funcionário faltou ao trabalho. • o salário bruto é igual ao salário do mês mais os valores dos dependentes mais os valores das horas extras.4 $2 22H *2 22H • • *22 " ' *22 322 322 o salário líquido é igual ao salário bruto menos IRRF. 23) Faça um programa que receba uma frase. • para cada hora extra trabalhada o cálculo do valor da hora trabalhada acrescida de 50%. 22) Faça um programa que receba uma frase. Calcule e imprima o salário a receber do funcionário seguindo as regras abaixo: • o valor da hora trabalhada é igual a 1/5 do salário mínimo. • para cada dependente acréscimo de 32 reais. a gratificação segue a próxima tabela: Salário líquido Gratificação Até 350 Superior a 350 100 reais 50 reais • o salário a receber do funcionário é igual ao salário líquido mais a gratificação. conte e imprima o número de palavras desta frase. 20) Faça um programa para resolver equações do 2º grau.falta em minutos de um funcionário. o número de horas trabalhadas. o número de dependentes do funcionário e a quantidade de horas extras trabalhadas. 18) Uma empresa decidiu dar uma gratificação de Natal aos seus funcionários. o número de horas. 25) Escreva um programa que calcule o que deve ser pago por um produto.

pinguim. crocodilo e cobra. então. águia.$0 $ * / 5 _ ` 5 * " $ @ # " < < @ @ ! $2H 3H ! $2H 26) Escreva um programa que leia o valor de dois números inteiros e a operação aritmética desejada: calcule. morcego. Exemplo: é mamífero? Sim é quadrúpede? Sim é carnívoro? Não é herbívoro? Sim então o animal escolhido foi o cavalo utilize as seguintes classificações: Carnívoro Leão Quadrúpede Herbívoro Mamíferos Bípede Frutíferos Voadores Aquáticos Morcego Baleia Tropical Não-voadoras Polar Aves Nadadoras De rapina Com casco Répteis Carnívoro Sem patas Pato Águia Tartaruga Crocodilo cobra Pinguim Avestruz Macaco Onívoro Cavalo Homem 44 . através de perguntas e respostas. a reposta adequada. macaco. pato. homem. cavalo. avestruz. Animais possíveis: leão. baleia. tartaruga. Utilize os símbolos da tabela a seguir para ler qual a operação aritmética escolhida: ' 6 ) E F " # <# <# <# 9 27) Construa um programa que seja capaz de concluir qual dentre os seguintes animais foi escolhido.

Para construir um laço finito. porém. necessariamente finito. portanto. Como visto anteriormente. podemos solucionar este problema escrevendo o algoritmo da seção anterior uma vez para cada aluno. A esses trechos de algoritmos que são repetidos damos o nome de laços de repetição. teríamos de escrevê-lo 50 vezes. ou seja. podemos proceder de dois modos: • • calcular média enquanto a quantidade de médias calculadas for menor ou igual a 50. O modelo genérico deste tipo de repetição é o seguinte: a) em pseudocódigo enquanto <condição> faça C1. no entanto. Verificar se dados três valores inteiros quaisquer os mesmo formam um triângulo. ECF Consiste em uma estrutura de controle de fluxo que permite repetir diversas vezes um mesmo trecho de algoritmo. escreva(quale). com que fluxo de execução repetisse certo trecho do algoritmo. teríamos de realizar um retrocesso – ao início dos comandos – para cada aluno. caso contrário. porém inviável. . 6 6 J 66 4 . Para realizar a repetição com teste no início. O que será impresso depois de executado o seguinte algoritmo: a) num = 20 b) num = -3 c) num = 0 leia(num) se num > 0 então quale = 'NUMERO POSITIVO' senão se num < 0 então quale = 'NUMERO NEGATIVO' senão quale = 'zero'. 45 .28. Ou seja. . o que nesta aplicação corresponderia a repetir o mesmo trecho 50 vezes. C2. calcular a média até que o número de médias calculadas atinja 50. C7C H H. fimenquanto. fim se. . 7C C < 8 6 6 4 7 6 ECF Imaginemos a situação problema de construir um algoritmo para calcular a média aritmética de 50 alunos de uma turma. 29. Trata-se de uma solução simples. utilizamos a estrutura enquanto. ter de escrevê-lo 50 vezes. Cn. que permite que um bloco ou uma ação primitiva seja repetida enquanto uma determinada <condição> for verdadeira. Efetuar a leitura de quatro número e apresentar os números que são divisíveis por 2 e 3. no caso dos 50 alunos. Outro modo de resolver essa questão seria utilizar a mesma seqüencia de comandos novamente. fim se. sem. fazendo. sempre verificando antes de cada execução se é “permitido” executar o mesmo trecho. informar que os lados não formam um triângulo. O número de repetições pode ser indeterminado. 30. Se formar informar o tipo. porém.

fim.acm.n3. Para isso precisamos contar as vezes em que foi realizado o cálculo.mat:real.n4). ma = (n1+n2+n3+n4)/4. o somatório das médias anuais de cada aluno. que seria a média aritmética das 50 médias anuais. MA). o que representa a característica principal desse modelo de repetição. //inicializacao do contador enquanto (con < 50) faça //teste da condição de parada //entrada de dados leia(n1.n2. Uma solução para o algoritmo que deve ler a nota de 50 alunos e calcular a média aritmética da turma seria: inicio //declaração de variáveis ma.parabéns”). con = con + 1. //contagem do nº de médias fornecidas fimenquanto. . restando apenas dividí-la pela quantidade de médias somadas (50). //calculo da media escreva(“Media anual = “. devemos estabelecer um modo de contagem. Se já da primeira vez o resultado é falso. utilizando uma expressão aritmética. conhecida conceitualmente como acumulador. con:inteiro. senão escreva(“Aluno reprovado! . e que cada iteração era incrementado em um.b) em Java while(<condicao>){ } Quando o resultado de <condição> for falso. Após o término da repetição. con:inteiro. //soma em ACM dos valores lidos em MA con = con + 1. con = 0.// inicializando o acumulador enquanto (con < 50) faça //teste da condição de parada leia(MA).ma:real. . 46 . Fazendo um laço que cada execução acumule em uma variável.estude mais”). Em primeiro lugar devemos pensar na condição. o qual é incrementado a cada repetição. portanto. fimse. se (MA >= 6) entao escreva(“Aluno aprovado! . os comandos não são executados nenhuma vez. No caso desse problema a condição seria que ele calcularia enquanto as quantidades de médias fossem inferiores ou iguais a 50. voltemos ao problema da média da turma de 50 alunos. o comando de repetição é abandonado. con = 0. Porém a estrutura enquanto não possui este recurso. //entrada de dados acm = acm + ma. + M49 + M50)/50 o que se torna inviável. //incrementar o contador em 1 fimenquanto. Para exemplificar. Podemos utilizar nessa situação as vantagens da estrutura de repetição. Devemos observar que contador CON foi inicializado com o valor 0 antes do laço. Em uma variação do algoritmo acima. poderíamos calcular a média geral da turma.n2.n3. teríamos a soma de todas as médias de acumulação. //inicializacao do contador acm = 0. inicio //declaração de variáveis n1. o que pode ser feito através de um contador representado por uma variável com um dado valor inicial.n4. como mostrado abaixo: (M1+M2+M3+M5+ .

//calculo da media anual da turma escreva(“Media anual da turma =”. fimse. a) pseudocódigo inicio //declaração de variáveis n. fim. portanto. //lê o primeiro número enquanto (n <> 0) faça //teste da condição de parada se ((n mod 2) == 0) então acm = acm + n. inicio //declaração de variáveis ma. mnp).// inicializando o acumulador leia(n). //soma em ACM dos valores lidos em MA leia(MA). //contagem dos nº pares fimse. pelo menos um mnp = acm/con. MAT = ACM/50. O valor de finalização será a entrada do número 0. MAT). o que faríamos para controlar o laço de repetição? Teríamos de encontrar outro critério de parada. que quando encontrado encerra o laço sem ter seu valor computado ao acumulador.con. Após a leitura da segunda média. con = 0. o que garante q não influência da leitura do finalizador -1 no cálculo da média da turma. leia(n). //calculo da media anual da turma escreva(“Media anual da turma =”. //inicializacao do contador acm = 0. //acumula em ACM a soma dos nº pares con = con + 1. usaremos como finalizador o valor -1. //inicializacao do contador acm = 0. Se não soubéssemos quantos eram os alunos. sempre defasado em uma unidade do número total de leituras. acm. Exemplo: Construa um algoritmo que calcule a média aritmética de um conjunto de números pares que forem fornecidos pelo usuário. 47 . mat:real. enquanto (MA <> -1) faça //teste da condição de parada acm = acm + ma. con:inteiro. fimenquanto. //contagem do nº de médias fornecidas fimenquanto.// inicializando o acumulador leia(MA). O algoritmo acima utiliza um pré-conhecimento da quantidade de alunos da turma da qual se desejava a média geral. MAT = ACM/CON. estando. Devemos observar que o contador CON inicia em 0 e que a leitura da primeira média anual MA acontece antes do laço de repetição. o contador incrementa em um. fim. o que pode ser feito utilizando um valor predefinido como finalizador de uma seqüencia de valores. con = 0. senão //nenhum par escreva(“Nenhum par foi fornecido!”).fim. MAT). //calcula a média dos nºs pares escreva(“Media : “. mnp : real. Para aplicar tal conceito ao algoritmo da média geral da turma. acm:inteiro. se (cont >0) então //houve nºs pares. con = con + 1.

que lê a média anual de 50 alunos e calcula a média geral da turma. o que representa a característica principal desse modelo de repetição. independente da validade da condição. . //contagem do nº de médias fornecidas até (con >= 50). tendo como dados de entrada tipos de vinho. pt.Cn) é executado pelo menos uma vez. Especifique a porcentagem de cada tipo sobre o total geral de vinhos. 48 . B para branco e R para rosê. //inicialização dos vários contadores conv = 0. que permite que um bloco ou ação primitiva seja repetido até que uma determinada condição seja verdadeira.66 4 . utilizamos a estrutura repita. ECF C7C H K < 6 6 H? Para realizar a repetição com teste no final. conv. sendo: T para tinto. O modelo genérico deste tipo de repetição é o seguinte: repita C1. //inicializacao do contador acm = 0..cb. b) programa em Java 2) Construa um algoritmo que permita fazer um levantamento do estoque de vinho de uma adega. e utilizando a estrutura de repetição com teste no final. .// inicializando o acumulador repita leia(MA). C2. //soma em ACM dos valores lidos em MA con = con + 1. con = 0.mat:real. utilize como finalizador F de fim.cr:inteiro.. ct. . Pela sintaxe da estrutura. //calculo da media anual da turma escreva(“Media anual da turma =”. ct = 0. 1) Reescreva o algoritmo das médias usando acumulador.pr:real. que o bloco (C1. teríamos: a) pseudocódigo inicio //declaração de variáveis ma. con:inteiro. a quantidade de vinhos é desconhecida. MAT).acm. I E 7\ 6 ? fim. até <condição>. Isto ocorre porque a inspeção da condição é feita após a execução do bloco. Cn. //entrada de dados acm = acm + ma. a) pseudocódigo inicio //declaração de variáveis tv: inteiro. //teste da condição de parada MAT = ACM/50.pb.

• é uma aplicação típica da seleção de múltipla escolha. se (conv > 0) então pt = (ct*100)/conv. C2. pr = (cr*100)/conv. . cr = 0. • vf é o valor final da variável v. ocorrem casos em que se torna difícil determinar o número de vezes em que o bloco será executado. ou seja. Sabemos que ele será executado enquanto uma condição for satisfeita – enquanto . o contador geral de vinhos foi dcrementado em um. cb = 0. • vi é o valor inicial da variável v. . pb). //teste da condição de parada conv = conv – 1. caso '3': cr = cr + 1. escreva(“Percentual de tintos =”. Exemplos: 49 . conv = conv + 1. CB e CR.fim. fimescolha. H ? 68 C 6 Nas estruturas de repetição vistas até agora. . //entrada de dados escolha tv caso '1': ct = ct + 1. escreva(“Percentual de brancos =”. pt).. até (tv = '4'). escreva(“Percentual de roses =”. ECF D < D ? 6. o valor até o qual ela vai chegar. foi necessário utilizar um contador para cada tipo de vinho. pb = (cb*100)/conv. pr). repita b) Programa em Java Observações: • além do contador geral de vinhos (CONV). senão escreva(“nenhum tipo de vinho foi fornecido”). Cn. fimse. ou até que uma condição seja satisfeita – repita. O modelo genérico para a estrutura de repetição para é o seguinte: para v:= vi até vf faça C1. caso '2': cb = cb + 1. A estrutura para repete a execução do bloco um número definido de vezes pois ela possui limites. 66 4 . para descontar o finalizador F. fimpara. leia(tv). • após o laço de repetição. Em que: • v é a variável de controle. CT. em que cada tipo de vinho corresponde a um caso.

b) programa em Java E < F 6 C66 < 4 H 7C C < 8 6 6 4 7 6 ECF Podemos estabelecer duas observações que relacionam a estrutura de repetição: • toda estrutura enquanto pode ser convertida para repita e vice-versa. • toda estrutura para pode ser convertida em enquanto. //soma em ACM dos valores lidos em MA fimpara. b) programa em Java 2) Elabore um algoritmo que efetue a soma de todos os números ímpares que são múltiplos de 3 e que se encontram no conjunto de números de 1 até 500. fim. MAT). 50 . a) pseudocódigo .enquanto inicio //declaração de variáveis n. acm = acm + ma. con:inteiro. resolvendo o problema com a repetição para. teríamos: a) pseudocódigo inicio //declaração de variáveis ma. si:inteiro. acm = 0.// inicializando o acumulador para con = 1 ate 50 faca //entrada de dados leia(MA).cont:inteiro.acm. si = 0. MAT = ACM/50. fim. mas nem toda estrutura enquanto pode ser convertida em para. fimse.1) voltemos ao cálculo da média aritmética de uma turma fixa de a 50 alunos. si). fimse. Exemplos: 1) Crie um algoritmo para que este imprima a tabuada de qualquer número.mat:real. fimpara. para i = 1 ate 500 faca se ( i mod 2 = 1) então se (i mod 3 = 0) então si = si + i. a) pseudocódigo inicio //declaração de variáveis i. //calculo da media anual da turma escreva(“Media anual da turma =”. OBS:o flag para as estruturas enquanto e repita é -1. escreva(“Soma =”.

M. leia(n). fimpara. int H.cont:inteiro. fim.A >=-10.B<50000000. .B. } System. for(A=0.S.A=A-2){ System. int A.// inicializando o acumulador repita escreva(cont. cont * n). for(A=10. t. fimenquanto. “ X “. leia(n). //declaração de variáveis n.println(A + " "). 2) Veja os exemplo abaixo: class ExRepeticao10{ public static void main(String args[]){ Thread t.println(). //declaração de variáveis n. “ = “.repita inicio leia(n).A++){ System. n. “ X “.println().A >=0. leia(n). cont = cont + 1. cont * n). } System.// inicializando o acumulador enquanto (cont <= 10) faça escreva(cont.cont:inteiro.println(). ate (n = -1). //cria um objeto t para o controle do tempo t = new Thread(). .out.B++). repita fim. fimenquanto. para cont = 1 ate 10 faca escreva(cont.out. for(B=0.println(A + " ").out.out. for(A=50. “ X “.A <=10.out. “ = “. n. enquanto (n <> -1) faça cont = 1.para inicio cont = 1.out.start().fim. } System.A=A-5){ System. cont = cont + 1. ate (cont > 10). leia(n). cont * n). //simula um relogio digital a) 51 . “ = “. n.println(A + " ").

try{ A = Integer.sleep(1000). } catch(InterruptedException E){ //interrupção do timer System.H <24.println("Nao foi fornecido um numero valido!").out. 2.M++)//controla os minutos for(S=0.out. Exibir a soma dos números positivos no intervalo de um a cem. tempo.out.S++) { //controla os segundos //exibe as horas na tela System.out.start().out.println(" "+A).System. } } } //não foi digitado inteiro I . while(A >0){ //inicio da estrutura while System.H++)//controla as horas for(M=0.println("Para encerrar pressione CTRL+C").println(H + " h: "+M+" m: "+S + " s ").M <60. tempo. //pula uma linha tempo.println("Algo interrompeu a contagem!").S <60. tempo. Exibir o produto dos números inteiros positivos no intervalo de um a cem.sleep(1000). Elaborar um programa que apresente no final o somatório dos valores pares existentes entre 1 e 500. 52 .out.println(" "+A). //fim da estrutura do-while System. try{ t.exit(0). }catch(ArrayIndexOutOfBoundsException E){ argumento System. 7 8 I 4 O 7C C <8 6 6 4 6 J 6 <F 6 ECF 1.out.out. tempo = new Thread(). }while(A >0). }catch(InterruptedException e){ } } } } b) class ExRepeticao11{ public static void main(String args[]){ Thread tempo.println().out. if(S==5) System.sleep(1000).println("Fim da 2ª contagem"). }//fim da estrutura while System. int A.parseInt(args[0]). A++.sleep(1000).. do {//inicio da estrutura do-while System. 3. //pausa de um segundo A--. for(H=0.out. } catch(NumberFormatException E){ //se o argumento for invalido System. System.println("Digite um argumento!").println("Fim da 1ª contagem").

A entrada de dados deve terminar quando for lido um número negativo. existem quatro candidatos. É considerado aprovado o aluno com nota final maior ou igual a 6. Fazer um programa que leia 20 idades de pessoas. Escreva um programa que leia um número não determinado de valores diferentes de zero e calcule a média aritmética dos valores lidos. deverá conter um valor negativo.25]. 13. Escreva a menor altura deste conjunto. 9. [51. A conversão de graus Farenheit para centígrados é obtida pela fórmula C = (5/9)*(F – 32). Fazer um programa que leia a nota final de 50 alunos e escreva: a) o total de reprovados. cujo conteúdo não será processado. Fazer um programa que calcule a porcentagem de ausência. Fazer um programa que leia um conjunto de alturas de pessoas. Mostrar o resultado final. Escreva a altura média das mulheres. É considerado aprovado o aluno com nota final maior ou igual a 6. Uma rainha requisitou os serviços de um monge e disse-lhes que pagaria qualquer preço. O último valor do conjunto de valores. Fazer um programa que leia a nota final de 50 alunos e escreva o total de aprovados. mostre a matrícula do aluno. Deseja-se fazer um levantamento a respeito da ausência de alunos à primeira prova de programação de computadores. 7. b) a nota média da turma. 19. e repita a operação até que a matrícula lida seja zero.20] e quantos estão fora do intervalo. e conte quantos deles estão no intervalo [10.b e c.100]. a média calculada e uma mensagem “aprovado” se a média for maior ou igual a 5 e “Reprovado” se a média dor menor que 5. 15. calcular e imprimir a média harmônica destes valores: média harmônica = 1 (1/a) + (1/b) + 1/c) 12. 6. [26. perguntou à rainha se o pagamento poderia ser feito com grãos de trigo dispostos em um tabuleiro de xadrez. considerando que o peso para a maior nota seja 4 e para as duas restantes. onde o segundo deverá ser maior que o primeiro. Os votos são informados atravé sde código. 18. Mostrar os resultados. Fazer um programa que leia um conjunto de idades de pessoas. Entrar com dois valores via teclado. 8. que não deve ser considerado. escrevendo estas informações. 16. c) a menor e maior nota da turma. Elaborar um programa para ler três valores distintos e exibir o maior deles. 20. calcule a média ponderada do aluno. Faça um programa para calcula o número de grãos que o monge esperava receber. 11. Escreva um programa que escreva todos o números ímpares entre 100 e 200. Calcule e escreva a idade média deste conjunto. Escrever um programa que leia a matrícula do aluno e suas três notas. O final do conjunto de valores é conhecido através do valor FIM. Construa um programa que. O final do conjunto de valores é conhecido através do valor zero. o dobro do quadro anterior. A rainha considerou o pagamento barato e pediu que o serviço fosse executado. Construir um programa que leia uma quantidade desconhecida de valores e conte quantos deles estão nos seguintes intervalos: [0. Escreva um programa que calcule e escreva uma tabela de graus centígrados em função de graus Farenheit que variam de 50 a 150 de 1 em 1. Cada valor deverá ser armazenado na variável X.5*cos|X/2|. Calcule e escreva a idade média deste grupo. a quantidade de valores negativos e o percentual dos valores negativos e positivos. O monge. dado um conjunto de valores inteiros e positivos. a quantidade de valores positivos. 5. Caso contrário solicitar novamente apenas o segundo valor. O final do conjunto de valores é conhecido através do valor -1. Escrever um programa que leia 50 valores.50]. É fornecido um conjunto de valores com as letras P ou A. Para cada valor lido calcule e escreva o valor de Y pela fórmula: Y = 2. Em uma eleição presidencial. 21. Dados três valores a. 17. Fazer um programa que leia um conjunto de valores. Construir um programa que some todos os números fornecidos pelo usuário até que o número lido seja iguala a zero e mostre a soma. Construir um programa que leia uma quantidade desconhecida de valores. 23. necessitando de alimentos. Fazer um programa que leia um conjunto de dados contendo o sexo e a altura de 50 pessoas. 25. determine qual é o menor e o maior valor do conjunto. 22. suas três notas. 10. O final do conjunto de valores é conhecido através do valor -1.4. 24.75] e [76. O final será o valor lido igual a zero. de tal forma que o primeiro quadro contivesse apenas um grão e os quadros subsequentes. Os dados utilizados para a escrutinagem obedecem a seguinte codificação: 53 . para caso o aluno estar presente ou ausente. sem se dar conta de que seria impossível efetuar o pagamento. 14. encontre o maior e o menor e mostre o resultado. 3.

• • •

1,2,3,4 = voto para os respectivos candidatos; 5 = voto nulo; 6 = voto em branco.

Elabore um programa que calcule e escreva: a) total de votos para cada candidato; b) total de votos nulos; c) total de votos em branco; d) percentual dos votos em branco e nulos sobre o total. Como finalizador do conjunto de votos, tem-se o valor 0. 26. Escreva um programa que imprima todas as possibilidades de que no lançamento de dois dados tenhamos o valor 7 como resultado da soma dos valores de cada dado. 27. Escreva um programa que imprima todos os números primos existentes entre N1 e N2, em que N1 e N2 são números naturais fornecidos pelo usuário. 28. Construa um programa que leia um conjunto de dados contendo altura e sexo (M para masculino e F para feminino) de 50 pessoas e, depois, calcule e escreva: • a maior e a menor altura do grupo; • a média de alturas das mulheres; • o número de homens e a diferença percentual entre estes e as mulheres. 29. Uma agência de publicidade quer prestar serviços somente para as maiores companhias – em número de funcionários – em cada uma das classificações: grande, média, pequena e microempresa. Para tal, consegue um conjunto de dados com o código, o número de funcionários e o porte da empresa. Construa um algoritmo que liste o código da empresa com maiores recursos humanos dentro de sua categoria. Utilize como finalizador o código da empresa igual a 0. 30. Calcule o imposto de renda de um grupo de 10 contribuintes, considerando que os dados de cada contribuinte, número do CPF, número de dependentes e renda mensal são valores fornecidos pelo usuário. Para cada contribuinte será feito um desconto de 5% do salário mínimo por dependente. Os valores da alíquota para cálculo do imposto são:
% C * 3 C * 3 , , . 3 22H $2 22H $3 22H *2 22H

Observe que deve ser fornecido o valor atual do salário mínimo para que o calcule os valores corretamente.

programa

31. Anacleto tem 1,50 metros e cresce 2 centímetros por ano, enquanto Felisberto tem 1,10 metros e cresce 3 centímetros por ano. Construa um algoritmo que calcule e imprima quantos anos serão necessários para que Felisberto seja maior que Anacleto. 32. Um cinema possui capacidade para 100 lugares e está sempre com ocupação total. Certo dia, cada espectador respondeu a um questionário, no qual constava: • sua idade; • sua opinião com relação ao filme, segundo as seguintes notas:
: C a ;. = = O D 5 75] A C7 7A . = b . =

Elabore um programa que, lendo estes dados, calcule e imprima: • a quantidade de respostas ótimo; • a diferença percentual entre respostas bom e regular;

54

• • •

a média de idade das pessoas que responderam ruim; a perdentagem de respostas péssimo e a maior idade que utilizou esta opção; a diferença de idade entre a maior idadeque respondeu ótimo e a maior idade que respondeu ruim.

33. Em um prédio há três elevadores denominados A, B e C. para otimizar o sistema de controle dos elevadores, foi realizado um levantamento no qual cada usuário respondia: • o elevador que utilizava com mais freqüência; • o período que utilizava o elevador, entre: • M = matutino; • V = vespertino; • N = noturno; Construa um algoritmo que calcule e imprima: • qual é o elevador mais frequentado e em período se concentra o maior fluxo; • qual o período mais usado de todos e a que elevador pertence; • qual a diferença percentual entre o mais usado dos horários e o menos usado; • qual a percentagem sobre o total de serviços prestados do elevador de média utilização. 34. Uma loja utiliza os seguintes códigos para as transações de cada dia: v – para compras à vista p – para compras a prazo É dada uma lista de transações contendo o valor de cada compra e o respectivo código de transação. Faça um programa que calcule e imprima: • valor total das compras à vista ; • valor total das compras a prazo; • valor total das compras efetuadas; • valor a receber pelas compras a prazo, isto é, primeira parcela, sabendo que estas serão pagas em três vezes. Sabe-se que são efetuadas 25 transações por dia. 35. Em um campeonato de futebol, cada time tem uma lista oficial de 23 jogadores. Cada time prepara uma lista contendo o peso e a idade de cada um dos seus jogadores. Os 40 times que participam do torneio enviam essas listas para o CPD da confederação. Faça um programa que apresente as seguintes informações: • o peso médio e a idade média de cada um dos times; • o peso médio e a idade de todos os participantes. C 7 66 E 7 ; I ? E6 6 C 6 ? H< 7

Ex1) fazer um programa que leia três valores inteiros, determine e imprima o menor deles: a) Algoritmo resolvido inicio //declaracao de variáveis a,b,c,menor:inteiro; escreva("Entre com o valor de A: ");leia(a); escreva("Entre com o valor de B: ");leia(b); escreva("Entre com o valor de C: ");leia(c); se( (a < c) e (a < c))entao menor = a; senao se (b < c) entao menor = b; senao menor = c; escreva("O menor valor e: "+menor);

fim.

b) Programa em Java
import java.io.*;

55

class ExemplosGerais1{ public static void main(String args[]){ int a,b,c,menor; BufferedReader entrada; entrada = new BufferedReader(new InputStreamReader(System.in)); try{ System.out.println("Entre com o valor de A: a = Integer.parseInt(entrada.readLine()); System.out.println("Entre com o valor de B: b = Integer.parseInt(entrada.readLine()); System.out.println("Entre com o valor de C: c = Integer.parseInt(entrada.readLine()); if( (a < c) && (a < c)) menor = a; else{ if (b < c) menor = b; else menor = c; "); "); ");

} System.out.println("O menor valor e: "+menor); }catch(Exception e){ System.out.println("Ocorreu um erro durante a leitura"); } } }

Ex2) Dados três valores distintos, fazer um programa que, após a leitura destes dados, coloque-os em ordem crescente. a) algoritmo em pseudocodigo inicio

//declaracao de variaveis a,b,c,aux:intueiro; escreva('Entre com o valor de A: ');leia(a); escreva('Entre com o valor de B: ');leia(b); escreva('Entre com o valor de C: ');leia(c); se ((a > b) ou (a > c)) entao se (b < c) entao aux = a; a= b; b= aux; senao aux = a; a= c; c= aux; se (b > c) entao aux = b; b= c; c= aux; escreva(a,' ',b,' ',c);

fim. b) programa em Java
import java.io.*; class ExemplosGerais2A{ public static void main(String args[]){ int a,b,c,aux;

56

BufferedReader entrada; entrada = new BufferedReader(new InputStreamReader(System.in)); try{ System.out.println("Entre com o valor de A: a = Integer.parseInt(entrada.readLine()); System.out.println("Entre com o valor de B: b = Integer.parseInt(entrada.readLine()); System.out.println("Entre com o valor de C: c = Integer.parseInt(entrada.readLine()); if ((a > b) || (a > c)){ if (b < c){ aux = a; a= b; b= aux; } else{ aux = a; a= c; c= aux; } if (b > c){ aux = b; b= c; c= aux; } } System.out.println("Os valores ordenados sao: "); "); ");

"+a+"

"+b+"

"+c);

}catch(Exception e){ System.out.println("Ocorreu um erro durante a leitura"); } } }

Ex3) Fazer um programa para determinar a soma dos números pares desde 100 até 200 inclusive. a) algoritmos em psudocodigo Solução 1: (enquanto) inicio soma, par:inteiros; soma = 0; par = 100; enquanto (par <= 200) faca soma = soma + par; par = par + 2; fimenquanto; escreva('A soma dos pares entre 100 e 200 (inclusive) e: ',soma); fim. Solução 2: (para) inicio soma, n:inteiro; soma = 0; para n= 50 ate 100 faca soma := soma + 2*n; escreva('A soma dos pares entre 100 e 200 (inclusive) e: ',soma); fim. Solução 3: (Repita)

57

inicio soma, par:inteiro; soma = 0; par = 100; repita soma := soma + par; par := par + 2; ate (par > 200); escreva('A soma dos pares entre 100 e 200 (inclusive) e: ',soma); fim. b) programa em Java (usando for)
class ExemplosGerais3{ public static void main(String args[]){ int soma=0, n; for(n=50;n<=100;n++) soma = soma + 2*n; System.out.println("A soma dos pares entre 100 e 200 (inclusive) e: } }

"+soma);

Ex4) Fazer um programa que calcule o fatorial de um número inteiro. a) algoritmo em pseudocodigo Solução: inicio fat, i, n: inteiro; fat = 1; escreva(´Entre com o valor de n: ´);leia(n); para i = 1 ate n faca fat = fat * i; escreva(´O fatorial de ´,n,´ e ´,fat);

fim

b) Programa em Java
import java.io.*; class ExFatorial{ public static void main(String args[]){ int fat,i,n; BufferedReader entrada; entrada = new BufferedReader(new InputStreamReader(System.in)); fat=1; try{ System.out.println("Entre com o valor de n: "); n = Integer.parseInt(entrada.readLine()); for(i=1;i<=n;i++){ fat *= i; } System.out.println("O fatorial de "+n+ " e: " +fat); }catch(Exception e){ System.out.println("Ocorreu algum erro na entrada!!!"); } } }

58

escreva('O montante e: '. a posição de seu investimento C (capital) inicial.println("Entre com o periodo: dado = new DataInputStream(System. escreva('Entre com o periodo: '). I – taxa de juros.out.parseDouble(s). int n. x = Integer. c = Double.in). String s = " ". taxa = taxa / 100. montante. n = 4 * x. trimestre. n = 4 * x. s = dado. 59 .leia(taxa). montante = montante * (1 + taxa). trimestre. taxa.readLine(). rendimento: real. dado = new DataInputStream(System. fim.in).readLine().montante). n – número de períodos decorridos (trimestres) a) algoritmo em pseudocódigo Solução: inicio c.montante após terem decorridos n trimestres.parseDouble(s). trimestralmente. DataInputStream dado. escreva('Entre com o capital: '). "). montante = c.Ex5) Uma pessoa aplicou seu capital a juros e deseja saber. "). b) Programa em Java import java.trimestre <= n. taxa. montante. Montante = c. OBS: ci) os valores de C.*.println("Entre com o capital: dado = new DataInputStream(System.leia(x). C – capital inicial investido. try{ System. Chamando de I a taxa de juros do trimestre. System.in). supondo-se que nenhuma retirada tenha sido feita.io. fimpara. I e X estão disponíveis em uma unidade de entrada. for (trimestre = 1.readLine(). taxa = taxa / 100. n. s = dado.println("Entre com a taxa: ").leia(c). x: inteiro. escrever uma tabela que dê para cada trimestre o rendimento auferido e o saldo acumulado durante um período de X anos.parseInt(s). class ExemplosGerais5{ public static void main(String args[]){ double c. escreva('O rendimento e: '. s = dado. taxa = Double.n++){ rendimento= taxa*montante.out. x. System.out. para trimestre = 1 ate n faca rendimento= taxa*montante. escreva('Entre com a taxa: '). cii) a fórmula para capitalização composta é dada por: Mn = C(1 + I)n Onde: Mn .rendimento). rendimento=0.

bois++){ System. escreva('Entre com o peso do boi: ').parseInt(entrada. try{ for (bois = 1.num:inteiro.println("Entre com o numero do boi: num=Integer.gordo. } System.readLine()). gordo = num. if(peso > maiorpeso){ maiorpeso = peso. maiorpeso=0. menorpeso = 100000. b) Programa em Java import java.num. escreva('O boi mais gordo e o '. fim. "). BufferedReader entrada. para bois = 1 ate 90 faca escreva('Entre com o numero do boi: '). entrada = new BufferedReader(new InputStreamReader(System. double peso.out.parseDouble(entrada. menorpeso=100000.leia(peso). peso = Double.*. System.leia(num). } } } Ex6) Num frigorífico existem 90 bois.out.montante = montante * (1 + taxa). magro=0.println("O montante e: "+montante).out. } 60 . System. Fazer um programa que escreva o número e o peso do boi mais gordo e do boi mais magro. peso.println("O rendimento e: "+rendimento). MaiorPeso.println("Entre com o peso do boi: "). }catch(Exception e){ System. fimse. maiorpeso = 0. se (peso < menorpeso) entao menorpeso := peso. class ExemplosGerais6{ public static void main(String args[]){ int bois. fimse. } if (peso < menorpeso){ menorpeso = peso.' e o seu peso e '. magro = num. gordo = num.out.menorpeso). magro := num.println("Ocorreu algum erro na entrada!"). gordo. MenorPeso: real. gordo=0.maiorpeso).magro.bois<=90.readLine()).out. magro. escreva('O boi mais magro e o '. Cada boi traz preso em seu pescoço um cartão contendo seu número de identificação e seu peso.in)).io. se (peso > maiorpeso) entao maiorpeso = peso. a) algoritmo em pseudocodigo Solução: inicio bois.' e o seu peso e '.

b) Programa em Java import java. sexo: caracter.maioridade). que não corresponde a ninguém. ii.leia(cabelos). pretos). maioridade = 0. castanhos. escreva('A percentual de individuos selecionados: '. escreva('Entre com o sexo do indiv¡duo: '). a) algoritmo em pseudocódigo Solução: inicio idade. TotalPessoas = 0. escreva('Entre com a idade do indiv¡duo: '). inclusive. maioridade. escreva('Entre com a cor dos cabelos do indiv¡duo: '). }catch(Exception e){ System.leia(olhos). escreva('Entre com a cor dos cabelos do indiv¡duo: '). fazer um programa que determine e escreva: a) a maior idade dos habitantes. escreva('Entre com a cor dos olhos do indiv¡duo: ').leia(cabelos). fim. castanhos. olhos.*. feminino).println("O boi mais magro e o "+magro+" e o seu peso e "+menorpeso).} System. pretos).out. totalpessoas := totalpessoas + 1. sexo (masculino.leia(sexo). fimse. cor dos cabelos (louros. Para cada habitante. escreva('Entre com o sexo do indiv¡duo: '). foi digitada uma linha com esses dados e a última linha. conterá o valor de igualdade igual a –1.io. b) a porcentagem de indivíduos do sexo feminino cuja idade está entre 18 e 35 anos. cabelos. cor dos olhos (azuis.println("O boi mais gordo e o "+gordo+" e o seu peso e "+maiorpeso). porcentagem: real. pessoas: inteiro. escreva('Entre com a cor dos olhos do indiv¡duo: '). escreva('A maior idade e: '. verdes.out. pessoas = 0. referentes a cada habitante.println("Houve algum erro na entrada"). iii.out. escreva('Entre com a idade do indiv¡duo: '). se (idade >= 18) e (idade <= 35) e (olhos = 'v') e (cabelos = 'L') e (sexo = 'F') entao pessoas := pessoas + 1. 61 . idade em anos. porcentagem := (pessoas * 100/totalpessoas). iv.porcentagem). } } } Ex7) Uma pesquisa sobre algumas características físicas da população de determinada região coletou os seguintes dados. System. totalpessoas. e que tenham olhos verdes e cabelos louros. fimenquanto.leia(idade). enquanto (idade <> -1) faca se (idade > maioridade) então maioridade := idade.leia(idade). para serem analisados: i. fimse.leia(olhos).leia(sexo).

cabelos = Integer. BufferedReader entrada.parseInt(entrada.out.parseInt(entrada.4= preto)").readLine()). conforme a utilização deste cômodo.println("Entre com a idade: ").println("Entre com a cor dos cabelos: (1 = louro.println("Entre com a cor dos olhos: azul.out.println("A maior idade e: "+maioridade). System. if((idade>=18)&& (idade <=35)&&(olhos 1)&&(sexo ==2)){ pessoas++.println("Houve algum erro na entrada!"). } porcentagem=(pessoas*100)/totalpessoas.pessoas=0.out.4= preto)").class ExPesquisa{ public static void main(String args[]){ int idade.parseInt(entrada.olhos. System.println("Entre com a cor dos cabelos: louro.readLine()).readLine()).3 = castanho.: ? $ .out. idade = Integer. } } } (1 = com o sexo: (1 = masculino. existem normas que dão o mínimo de potência de iluminação exigida por metro quadrado (m²).2 = castanho.2 = verde. System.parseInt(entrada.parseInt(entrada. }catch(Exception e){ System. try{ System.out. olhos = Integer. idade = Integer.readLine()). System.readLine()). sexo = Integer.parseInt(entrada. System. entrada = new BufferedReader(new InputStreamReader(System.println("Entre com a cor dos olhos: (1 = azul. } System. 3 = preto)").out.readLine()). totalpessoas=0.println("Entre com o sexo: (1 = masculino. System.maioridade=0. Seja o seguinte quadro tomado como exemplo: 9 : <% = > .readLine()).in)).2 = verde. cabelos = Integer.parseInt(entrada.parseInt(entrada.println("O percentual de selecionados "+porcentagem). System. while(idade != -1){ if(idade > maioridade) maioridade = idade.out.readLine()). olhos = Integer.2 = castanho.println("Entre com a idade: "). 3 = preto)"). totalpessoas++.% ??# @ $3 AB : C % 62 .2 = feminino)"). sexo = Integer.out.out. System.println("Entre feminino)").out. float porcentagem.3 = castanho. int cabelos.sexo.out.2 = ==2)&&(cabelos == (1 = e: Ex8) Para determinar o número de lâmpadas necessárias para cada cômodo de uma residência.

escreva('escritorio e banheiro = classe 3').Se o número calculado de lâmpadas for fracionário. escreva('Entre com o tipo do comodo: '). fazer um programa que: a) leia um número indeterminado de linhas contendo cada uma: a) cômodo de uma residência b) classe de iluminação deste cômodo c) as duas dimensões do cômodo b) calcule e escreva: b. b) a área do cômodo c) a potência de iluminação d) número de lâmpadas necessárias b. Solução: a) algoritmo em pseudocódigo inicio classe. 2. escreva('quarto e sala de TV = classe 1').1) para cada cômodo: a) o cômodo. cozinha e varanda = classe 2'). se (classe = 1) entao potencia = area * 15. enquanto (comodo != '*') faca area := comprimento * largura. que não entrará nos cálculos. escreva('Entre com t para sala de TV'). A última linha. escreva('Entre com q para quarto'). escreva('Entre com c para cozinha'). TotalLampadas = 0.leia(comprimento). senao se (classe = 2) entao 63 . 8. TotalPotencia = 0.3 -> 9. leia(comodo). considerar o menor inteiro que contenha esse número.. area.:8. TotalPotencia: real. escreva('Entre com v para varanda').2) para toda a residência: a) total de lâmpadas b) total de potência Observações: 1.7 -> 9.R O R 5 8 $ * * * - $3 $' $' $' *2 *2 Supondo que só serão utilizadas lâmpadas de 60W. potencia. escreva('Entre com o comprimento do comodo: '). escreva('Entre com a largura do comodo: '). largura. lampadas. comprimento. aux. escreva('Entre com e para escritorio'). escreva('Entre com a classe do comodo: '). Ex. escreva('sala. escreva('Entre com b para banheiro').leia(largura). leia(classe). escreva('Entre com s para sala'). TotalLampadas:inteiro. conterá no lugar do cômodo a palavra vazio. comodo: caracter.

aux := potencia/60 .out.println(). double aux. escreva('A quanrtidade de lampadas e: '. TotalLampadas := TotalLampadas + lampadas. totalPotencia:2:2). escreva('Entre com o comprimento do comodo: '). System.out. fimenquanto.out. BufferedReader entrada. comodo = Integer.println("sala.out.println("Entre com a largura do comodo: ").println("Entre com 5 para varanda"). escreva('A area do comodo e: '. escreva('Entre com a classe do comodo: ').println("Entre com 3 para sala de TV").readLine()).in)). classe = Integer.parseDouble(entrada.println("Entre com 2 para sala"). escreva('O comodo e: '. TotalLampadas=0. comprimento = Double. System.println("Entre com o comprimento do comodo: "). System.println("Entre com o tipo do comodo:").println("Entre com a classe do comodo: "). escreva('A potencia utilizada e: '. 64 .println("Entre com 4 para cozinha"). fimse.lampadas. System. while (comodo != -1){ area = comprimento * largura.println("quarto e sala de TV = classe 1").readLine()).out.parseInt(entrada.out. se (aux > 0) entao lampadas := lampadas + 1.parseDouble(entrada. escreva('Entre com a largura do comodo: '). escreva('Entre com o tipo do comodo: '). b) programa em Java import java.out. comodo).out. try{ System.println("Entre com 1 para quarto"). area:2:2). System.io. lampadas = trunc(potencia/60). largura = Double.println().println("Entre com 7 para banheiro").out. System. totalPotencia=0. System.out. TotalPotencia := TotalPotencia + Potencia. cozinha e varanda = classe 2"). totalLampadas). potencia. System. System. comprimento.leia(largura). System.out. System.*.parseInt(entrada.out.readLine()). System. escreva('O total de potencia para os comodos e: '.leia(comodo).println("Entre com 6 para escritorio").readLine()).comodo. class ExIluminacao{ public static void main(String args[]){ int classe.lampadas. fimse. lampadas). largura.out.println("escritorio e banheiro = classe 3"). System. potencia = area * 18 senao potencia = area * 20.leia(comprimento).out. else potencia = area * 20.fim.leia(classe). potencia:2:2). System.out. area. escreva('O total de lampadas para os comodos e: '. else if (classe == 2) potencia = area * 18. entrada = new BufferedReader(new InputStreamReader(System. if (classe == 1) potencia = area * 15. System. fimse.out.

maior1 =-1. A última linha. System. maior2 = -1. quanrtidade de lampadas e: "+ "+ System.ceil(potencia/60)).out.println().out.println(). enquanto (num > 0) faca escreva('o numero de inscricao e'.out. maior2:real.println("O total de lampadas para os comodos e: TotalLampadas). cont2 = 0.altura).cont2.println("Entre com a largura do comodo: ").''. classe = Integer. TotalLampadas = TotalLampadas + lampadas.out. System. System. System.parseDouble(entrada.out.out. escreva('Entre com o numero de inscricao: ').leia(altura).out.println("Entre com o comprimento do comodo: "). cont1 = 1. escreva('Entre coma altura da candidata: ').readLine()).leia(num). System.out.println("A potencia utilizada e: potencia).println("Entre com o tipo do comodo: "). senao 65 .readLine()). Para cada moça existe uma linha em uma unidade de entrada contendo seu número e sua altura. if (aux > 0) lampadas ++.lampadas = (int)(Math. maior1. System.parseInt(entrada.out. cont2 = cont1.readLine()).lampadas. cont1 = 0. aux = potencia/60 .println("Entre com a classe do comodo: "). maior1 = altura. }catch(Exception e){ System. num:inteiro. largura = Double.println("O comodo e: "+ comodo). que não corresponde a nenhuma moça.num. cont1.out..println("O total de potencia para os comodos e: totalPotencia).out. System.''.'e a altura e '. } System. comodo = Integer.println("Houve algum erro na entrada!").println("A area do comodo e: "+ area).out. 2) Calcule e escreva as duas maiores alturas e quantas moças as possuem. System. } } } "+ "+ Ex9) Fazer um programa que: 1) Leia e escreva o número e a altura das moças inscritas em um concurso de beleza.readLine()).parseInt(entrada.parseDouble(entrada.println("A lampadas). conterá o zero no lugar do número. totalPotencia = totalPotencia + potencia. se (altura > maior1) entao maior2 = maior1. System. a) algoritmo em pseudocódigo Solução: inicio altura.out. comprimento = Double. System.

senao se (altura == maior2) entao cont2 := cont2 + 1. n := n + 1. se (altura = maior1) entao cont1 = cont1 + 1 senao se (altura > maior2) entao maior2 = altura. senA = 0. 66 . fimenquanto.. radiano de décimo em décimo de radiano. o valor absoluto do erro cometido com a interrupção da série é inferior ao valor absoluto do primeiro termo abandonado. t: real. fimse. senao se (altura > maior2) entao maior2 = altura. usando a série: 3 5 SenA = A.0001. 3! 5! Com erro inferior a 0.senA:11:7. escreva('Entre com o numero de inscricao: '). cont2 = 1. fimse. Solução: a) algoritmo em pseudocódigo inicio n.A + A . fimse. valores inicial e final reais. t = a.leia(num). com A variando de 0 a 16. Observe-se que a estrutura para-ate-faca não permite variável de controle. escreva(maior1. fimse. e obtevese A. para i = 0 ate 16 faca a= i/10. escreva('Entre coma altura da candidata: '). senA. fim. cont2 = 1.0001) faca senA := senA + t. cont2). n = 0. cont1.n:3). enquanto (abs(t) >= 0. Para se contornar esta restrição. maior2. fimse. Em séries alternadas.leia(altura). escreva('A senA N').. Imprimir também o número de termos usados. a. b) programa em Java Ex10) Escrever um programa para fazer uma tabela de senA. fimpara. variando de 0 a 16.fim.i : inteiro. t := -t * a * a/(2 * n * (2 * n + 1)) fimenquanto. usou-se a variável inteira I. escreva(a:3:1.. dividindo-se cada I por 10.

.leia(turma). ate (turma = 'R').leia(aluno).Ex11) Para cada aluno da disciplina Programação de Computadores deste semestre. n. SomaDisc := 0. MelhorDisc := 0. deseja-se imprimir também o total de alunos aprovados. turma: caracter. enquanto (aluno != 0) faca n := n + 1. AprovDisc. escreva('Para sair entre com R').o número de alunos aprovados ( nota final> 60). AprovDisc := 0. MelhorDisc. fimse. nesta ordem) 2. virá uma linha com dados. se (melhor > melhorDisc) entao melhorDisc := melhor.media:6:2. fimse. . Número de matrícula 3. escreva('Entre com a nota do aluno: ').leia(aluno).. melhor = -1. para cada turma. NDisc = NDisc + n. aprov. que não correspondem a nenhum aluno.B. melhor. se (nota > melhor) entao melhor := nota.leia(nota). soma= 0. MediaDisc := SomaDisc/NDisc. escreva('Entre com o nome da turma: '). aluno: inteiro. escreva('Entre com o nome da turma: '). aprov = 0. ler estes dados e imprimir. escreva('Entre com a matricula do aluno: ').melhor:6:2).R. fimenquanto. será digitada uma linha com os seguintes dados: 1. NDisc := 0. AprovDisc = AprovDisc + Aprov. Após todas as turmas serem processadas. nota: real. soma = soma + nota. se (nota > 60) entao aprov = aprov + 1. através de um computador. SomaDisc. Nota final Após o último aluno de cada turma. escreva(AprovDisc:3. a média geral e a melhor nota na disciplina. contendo zero no lugar do número de matrícula.leia(nota). fim. MediaDisc. escreva('Entre com a nota do aluno: '). Deseja-se. a sua identificação. A identificação da turma (A. MediaDisc:6:2. escreva(aprov:3. a média das notas e a melhor nota. Solução: a) algoritmo em pseudocódigo inicio NDisc. repeat n= 0. media = soma/n. escreva('Entre com a matricula do aluno: '). media.leia(turma). 67 . soma. SomaDisc =SomaDisc + soma. MelhorDisc:6:2).neste semestre..

assim como o lucro total. 4) Um comerciante deseja fazer o levantamento do lucro das mercadorias que ele comercializa. calcule a porcentagem de ausência e escreva a identificação da turma e a porcentagem calculada.000 de habitantes com uma taxa anual de crescimento de 1. forneceu o sexo do entrevistado e sua resposta (sim ou não). Para cada turma. 9) Foi feita uma pesquisa para determinar o índice de mortalidade infantil em um certo período. mandou digitar uma linha para cada mercadoria com o nome.a porcentagem de pessoas do sexo masculino que responderam não./ 2 O 7C C < 8 . 7) Deseja-se fazer um levantamento a respeito da ausência de alunos à primeira prova de Programação de Computadores para cada uma das 14 turmas existentes. . ou B.Determine e escreva quantas mercadorias proporcionam: . 9 Fazer um programa que calcule e escreva uma tabela de centígrados em função de graus Fahrenheit.5%. aproximadamente .10% < lucro < 20% ..Lucro < 100% . de 200.a maior e a menor altura do grupo. que variam de 50 a 150 de 1 em 1. . Fazer um programa que: 68 . contém o valor da idade igual a zero.5 grama.. fazer um programa que determine o tempo necessário para que essa massa se torne menor do que 0. é fornecido um conjunto de valores.Lucro > 20% .O número de pessoas que responderam sim. sendo que os dois primeiros valores do conjunto correspondem à identificação da turma (A. . Para isto.Determine e escreva quantas turmas tiveram porcentagem de ausência superior a 5%. . mantidas essas taxas de crescimento.000.o número de pessoas que responderam não. preço de compra e preço de venda das mesmas. H ? 7 6 C 6 1) Fazer um programa que: . em gramas. e os demais valores deste conjunto contêm o número de matrícula do aluno e a letra A ou P para o caso de o aluno estar ausente ou presente. 5) Supondo que a população de um país A seja da ordem de 90.000 pessoas. ou C. . A última linha. minutos e segundos. fazer um programa que calcule e escreva: . Para isso. 2) Tem-se um conjunto d3e dados contendo a altura e o sexo (masculino e feminino) de 50 pessoas. fazer um programa que calcule e escreva o número de anos necessários para que a população do país A ultrapasse ou iguale a população do país B. Observação: o aluno deve adota um flag. Fazer um programa que: . 3) A conversão de graus Fahrenheit para centígrados é obtida por C = 5 ( F. 6) Um determinado material radioativo perde metade de sua massa a cada 50 segundos. 8) Uma certa firma fez uma pesquisa de mercado para saber se as pessoas gostaram ou não de um novo produto lançado o mercado. .a média de altura das mulheres. Fazer um programa que: . que não entrará nos cálculos. respectivamente.000.000 de habitantes comum à taxa anual de crescimento de 3% e que a população de um país B seja.32 ). Dada a massa inicial.Para cada turma. Escreva a massa inicial. . Sabendo-se que foram entrevistadas 2..a porcentagem de pessoas do sexo feminino que responderam sim. Fazer um programa que calcule e escreva: .Leia um número indeterminado de linhas contendo cada uma a idade de um indivíduo.Determine e escreva o valor total de compra e de venda de todas as mercadorias. a massa final e o tempo calculado em horas.) e ao número de alunos matriculados.o número de homens.Calcule e escreva a idade média deste grupo de indivíduos. Fazer um programa que: Compra e preço de venda das mesmas.

o número de matrícula. num determinado dia. a porcentagem de crianças que viveram 24 meses ou menos no período.3. industrial). c) Determine e imprima: i. Fazer um programa que : a) Leia um número indeterminado de dados. nada era anotado. iii. ii. Fazer um programa que: i. v. a porcentagem de alunos reprovados por infreqüência. 7. c) Escreva o número do canal e a sua respectiva porcentagem. cada uma. a porcentagem de crianças mortas no período. a porcentagem de crianças do sexo masculino mortas no período. um número indeterminado de linhas. o sexo de uma criança morta ( masculino. que não entrará nos cálculos. Para isso. 12) e o número de pessoas que o estavam assistindo naquela casa. b) leia. ii. a freqüência. para indicar fim de dados. ou seja esta casa não entrava na pesquisa. a nota final e o código (aprovado ou reprovado). sendo que o “FLAG” corresponde ao número do canal igual a zero. Fazer um programa que: a) Leia um conjunto de dados contendo o número de matrícula. Se a televisão estivesse desligada. O número do consumidor igual a zero deve ser usado como flag. o número de candidatos por vaga e a porcentagem de candidatos do sexo feminino ( escreva também o código correspondente do curso). é fornecido o seguinte conjunto de valores: a) o código do curso. Se a televisão estivesse desligada.a) leia inicialmente o número de crianças nascidas no período. c) É considerado aprovado o aluno que obtiver a nota final superior ou igual a 60 e que tiver comparecido a um mínimo de 40 aulas. b) número de vagas. a nota média da turma. d) código do tipo de consumidor (residencial. a maior e a menor nota da turma. c) quantidade de kWh consumidos durante o mês. b) calcule: 69 . ii. c) Escreva: a) para cada aluno. b) Calcule a porcentagem de audiência para cada emissora. contém no lugar do sexo a palavra “vazio”. ou seja esta casa não entrava na pesquisa. iii. A última linha. calcule e escreva para cada curso. e 5). calcule e escreva o total de candidatos. c) número de candidatos do sexo masculino. O último conjunto.4. contendo. Fazer um programa que: a) leia os dados descritos acima. b) A nota final é obtida pela média aritmética das notas dadas durante o curso. as três notas e a freqüência (número de aulas freqüentadas) de 100 alunos. b) o número do consumidor. a nota final de cada aluno. d) número de candidatos do sexo feminino. 12) O sistema de avaliação de uma determinada disciplina obedece aos seguintes critérios: a) Durante o semestre são dadas três notas. 11) Uma universidade deseja fazer um levantamento a respeito de seu concurso vestibular. comercial. b) Calcule: i. b) o que foi calculado no item b (2. determine o maior número de candidatos por vaga e escreva esse número juntamente com o código do curso correspondente (supor que não haja empate). contém o código do curso igual a zero. 5. 10) Foi feira uma pesquisa de audiência de canal de TV em várias casas de uma certa cidade. o total de alunos reprovados. iii. Para cada casa visitada. em seguida. após fornecidos os seguintes dados: a) preço do kWh consumido. Para cada curso. é fornecido o número do canal (4. 13) Deseja-se fazer uma pesquisa a respeito do consumo mensal de energia elétrica em uma determinada cidade. nada era anotado. feminino ) e o número de meses de vida da criança. iv.

70 e 80 km/hora. c) Utilize como flag o nº da conta igual a zero. e) experiência no serviço (sim ou não).00 e se o saldo de fim de dia for menor do que isso. o seu número e o saldo calculado. e as despesas montarão R$600. quantidade de transações e taxa de serviço. o total a pagar. O saldo mínimo exigido é R$30. b) o número de candidatos do sexo masculino. o maior consumo verificado. O último par contém estes dois valores iguais. o seu número e o total a pagar. d) sexo (masculino. Calcule: a) o número de candidatos do sexo feminino. v = velocidade. O último conjunto contém o número de inscrição do candidato igual a zero. é fornecido. 15) Os bancos atualizam diariamente as contas de seus clientes.c) d) e) f) g) h) para cada consumidor. com as seguintes velocidades: 20. 50. o total do consumo para cada um dos três tipos de consumidores. b) as linhas seguintes contêm o valor e o código da transação (depósito ou retirada). apenas quando este tempo for superior a 2 horas. 16) Uma empresa decidiu fazer um levantamento em relação aos candidatos que se apresentarem para preenchimento de vagas no seu quadro de funcionários. imprima o número da conta e a mensagem “NÃO HÁ FUNDOS”. Cada cidade tem seu marco quilométrico. 2) o que foi calculado nos itens b. a velocidade e o tempo decorrido entre as duas cidades. a média geral de consumo. Escreva: • o número de inscrição das mulheres pertencentes ao grupo descrito no item e. utilizando processamento eletrônico. v c) escreva os marcos quilométricos. 17) Uma companhia de teatro planeja dar uma série de espetáculos. 14) Tem-se uma estrada ligando várias cidades. e acima especificados. feminino). a R$15. d. c) idade. uma taxa de serviço é deduzida se a conta cai abaixo de uma certa quantia especificada. f) a menor idade entre mulheres que já têm experiência no serviço. serão vendidos 120 ingressos. isto significa insuficiência de fundos na conta). Supondo que você seja o programador encarregado desse levantamento. fazer um programa que: a) leia um conjunto de dados para cada candidato contendo: b) número de inscrição do candidato. o seguinte conjunto de dados: a) a primeira linha contém o número da conta. • o que foi calculado em cada item acima especificado. o menor consumo verificado. Escrever um programa que: a) calcule o saldo (crédito/débito) da conta a o fim do dia (se o resultado for negativo. Fazer um programa que: a) leia vários pares de dados. escreva: 1) para cada consumidor. onde t = tempo. e) número de mulheres que têm idade inferior a 35 anos e com experiência no serviço. o valor do saldo atual e do saldo mínimo diário. e = espaço. c) idade média dos homens que já têm experiência no serviço. uma taxa é debitada da conta. Numa conta de saldo mínimo. A direção calcula que. b) calcule os tempos decorridos para percorrer a distância entre estas duas cidades. Se não houver fundos. b) escreva para cada conta. sabendo-se que: t = e . Essa atualização envolve a análise dos depósitos e retiradas de cada conta. A uma 70 . 40. contendo cada par os valores dos marcos quilométricos. 30. para cada conta. em ordem crescente. de duas cidades. A fim de que esta atualização fosse feita utilizando computador.00. Suponha que uma conta particular comece o dia com um saldo de R$ 60.00 o ingresso. c. d) porcentagem dos homens com mais de 45 anos entre o total de homens.00. 60.

1) para cada equipe. fazendo-se variar este preço de R$15. o número de sua inscrição.00.4) + QUOCIENTE (S. calcule e escreva o número de inscrição de cada empregado. para cada comerciário. domingo corresponde a 0. e assim por diante. Os dias da semana são numerados de zero a seis.00 de R$3. 19) Numa certa loja de eletrodomésticos. segunda a 1. do limite de isenção de IRRF. Um dos programas necessários para a classificação das equipes concorrentes é o que emite uma listagem geral do desempenho das equipes. os preços dos televisores em cores e preto e branco e.Se o seu salário total (mínimo + comissões – INSS). o comerciário encarregado da seção de televisores recebe. mensalmente.1 ) + D + A + QUOCIENTE (A.3) a equipe vencedora.00 no preço dos ingressos espera-se que haja um aumento de 26 ingressos vendidos.2) um conjunto de linhas contendo cada uma o número de inscrição da equipe e os tempos (em minutos decimais) que as mesmas despenderam ao cumprir as três diferentes etapas. ainda.6 X M – 0.1) os pontos de cada equipe em cada uma das etapas.atribuir 100 pontos à etapa 3 < DELTA < 5 minutos – atribuir 80 pontos à etapa DELTA > 5 minutos – atribuir 80 – DELTA – 5 pontos à etapa. ele ainda terá um desconto de 15% sobre o que ultrapassar o limite de isenção retido na fonte. contém o número 9999 como número de inscrição. A . b. A última linha (flag). um salário mínimo mais comissão. o número de televisores a cores e o número de televisores preto e branco vendidos. março é o mês 1 e dezembro é o mês 10: D – representa o dia do mês.2) o total de pontos de cada equipe nas três etapas. que ele tem um desconto de 8% sobre seu salário bruto para o INSS.#/: . b) Calcular: b. seu salário bruto e seu salário líquido. Sabendo-se que existem 20 empregados nesta seção. os pontos obtidos em cada etapa e o total de pontos obtidos.representa o número formado pelos dois últimos algarismos do ano. O programa deverá: a) Ler: a.#? /#B : ? 0 $2 0 $2 0 *2 @ *2 ? $/H $-H $-H $*H " " " " < < < < " " " " 7: ??E #? Sabe-se ainda. c) Escrever: c.7) Onde: M – representa o número do mês. a . atribuindo pontos segundo determinadas normas. obedecendo ao quadro abaixo: : @ C = = = = B D # #. 1) uma linha contendo os tempos-padrão (em minutos decimais) para as três fases de competição. Fazer um programa que escreva uma tabela de valores do lucro esperado em função do preço do ingresso. Escreva.4) – 2 X S). seguindo o seguinte critério: Seja o valor absoluto da diferença entre o tempo-padrão (lido na primeira linha) e o tempo despendido pela equipe numa etapa: DELTA < 3 minutos . o número de inscrição.00 em R$3.diminuição de R$3.00 a R$3. 71 . 20) O dia da semana para uma data qualquer pode ser calculado pela seguinte fórmula: Dia da Semana = RESTO (( TRUNCA(2. Essa comissão é calculada em relação ao tipo e ao número de televisores vendidos por mês. for maior que o limite de isenção do imposto de renda. Janeiro e fevereiro são os meses 11 e 12 do ano precedente. o preço e o número de ingressos correspondentes. que não entrará nos cálculos. leia os valores do salário mínimo. 18) A comissão organizadora de um rallye automobilístico decidiu apurar os resultados da competição através de um processamento eletrônico. S – representa o número formado pelos dois primeiros algarismos do ano. 5 b. o lucro máximo esperado.

b) . PROBLEMAS ENVOLVENDO CÁLCULO DE SOMATÓRIOS 24) Fazer um programa que calcule e escreva o valor de S: S= 1 + 3 + 5 + 7 +. C – os que fazem mais de 35 peças por mês. que servirá de flag. Fazer um programa que leia os valores de X e Y e escreva.+ 250 50 49 48 1 26) Fazer um programa para calcular e escrever a seguinte soma: S= 37 X 38 + 36 X 37 + 35 X 36 +. ano e o dia da semana calculado. B – os que fazem de 31 a 35 peças por mês. mês. • a primeira data na linha é sempre a mais antiga • o ano está digitado com quatro dígitos..+ 1 X 2 72 . f) o número do operário ou operária de maior salário (não existe empate). 23) Fazer um programa para calcular o número de dias decorridos entre duas datas (considerar também a ocorrência de anos bissextos).+ 99 1 2 3 4 50 25) Fazer um programa que calcule e escreva a seguinte soma: 21 + 22 + 23 +.Fazer um programa que: a) leia um conjunto de 50 datas (doa. A linha de montagem standart comporta um máximo de 24 operários. Observação: A última linha. o número de operários na linha standart e na linha luxo. c) escreva. acima das 30 iniciais.. O mercado é capaz de absorver toda a produção e o fabricante deseja saber qual esquema de produção a adotar de modo a maximizar seu lucro diário. A fábrica possui 40 operários. o dia.. terá o número do operário igual a zero. c) o número total de peças fabricadas por mês. o número de rádios standart e luxo produzidos e o lucro.determine o dia da semana correspondente à data lida. A classe B recebe salário mínimo e mais 3% do salário mínimo por peça. ano). segundo o método especificado. sabendo-se que: • cada par de datas é lido numa linha. A linha de montagem comporta no máximo 32 operários. contendo cada uma: • o número do operário.. Fazer um programa que: a) leia várias linhas. e) a média de peças fabricadas pelas mulheres em cada classe.. ou se for divisível por 4 e não o for por 100.. 22) Uma determinada fábrica de rádios possui duas linhas de montagem distintas: standart e luxo. cada rádio luxo dá um lucro Y e gasta 2 homens-dia para sua confecção. • um ano será bissexto se for divisível por 400. para cada data lida. para esse esquema de lucro máximo. cada rádio standart dá um lucro X e gasta um homem-dia para sua confecção. • o número de peças fabricadas por mês. b) calcule e escreva: a) o salário de cada operário. b) o total da folha mensal de pagamento da fábrica. a última linha contém o número do dia negativo. A classe C recebe salário mínimo e mais 5% do salário mínimo por peça acima das 30 iniciais. • o sexo do operário. d) a média de peças fabricadas pelos homens de cada classe. 21) Numa fábrica trabalham homens e mulheres divididos em três classes: A – os que fazem até 30 peças por mês. A classe A recebe salário mínimo. mês.

475 + 470 ...0000001).0001.1 2 3 37 27) Fazer um programa que calcule e escreva o valor de S onde: S= 1 .10 1 4 9 16 25 36 100 28) Fazer um programa que calcule e escreva a soma dos 50 primeiros termos da seguinte série: 1.0001.. 31) Fazer um programa para calcular e escrever o valor do número usando a série: = 4 – 4 + 4 – 4 + 4 – 4 +. 73 .. adicionar apenas os termos cujo valor absoluto seja maior ou igual 0. de 0. 0! 1! 2! 3! 36) Elaborar um programa que: 1. 10 11 12 13 30) escrever um programa para gerar e escrever uma tabela com os valores do seno de um ângulo A radianos. inclusive.+ X 25 34) Fazer um programa que calcule e escreva a soma de S no seguinte somatório: S= 1 .....465 +. apresentada a seguir: sen A = A – A3 + A5 – A7 6 120 5..2 + 3 ..040 Condições: os valores dos ângulos A devem variar de 0. 3 5 7 9 11 Para obter a precisão desejada. 2.000 ...8 +. indique quantos termos foram usados..4 + 5 .+ 16. 1 2 3 4 29) Fazer um programa que calcule e escreva a soma dos 30 primeiros termos da série: 480 .X 1 2 25 24 com 51 termos.1 + 1 .3....1 + 1 . S= 1 . calcule e escreva o valor da série abaixo com precisão menor que um décimo de milionésimo (0. b) calcule e escreva o valor do seguinte somatório: S= X .1.1 em 0..384 225 196 169 144 1 35) Fazer um programa que calcule e escreva a soma dos 20 primeiros termos da série: 100 + 99 + 98 + 97 +.2 + 4 .0 a 6.991 +. 13 33 53 73 93 3 Sendo = S X 32 Fazer um programa para calcular e escrever o valor de 33) Fazer um programa que: a) leia o valor de X de uma unidade de entrada. 32) O valor aproximado de pode ser calculado usando-se a série .6 .997 + 994 . +X 3 23 -X 4 22 +. com precisão de 0. utilizando a série de Mac-Laurin Truncada.

Observação: o valor de x é fornecido como entrada.0001.. 1! 2! 3! De modo que o mesmo difira do valor calculado através da função Exp de. no máximo.x + x – x + x -.. 0.. 1! 2! 3! 37) Fazer um programa que calcule e escreva a soma dos 50 primeiros termos da série: 1! – 2! + 3! – 4! + 5! -... O programa deverá escrever o valor de x..S= 63 + 61 + 59 + 57 +... o valor dado pela função Exp e o número de termos utilizados da série.. • imprima o que foi calculado nos itens a e b.X6 +. 39) Fazer um programa para determinar e escrever o valor do seguinte somatório: S = X . 2 4 6 8 x 0 1 2 3 x 74 . o valor calculado através da série. 2! 4! 6! 8! • calcule a diferença entre o valor calculado no item a e o valor fornecido pela função Cós(X). 1 3 7 15 31 38) Fazer um programa que calcule o valor de e através da série: e = x + x + x + x +. O valor de x deve ser lido de uma unidade de entrada. 3! 5! 7! 40) Fazer um programa que: • calcule o valor do co-seno de x através de 20 termos da série seguinte: co-seno(x) = 1 .X2 + X4 ..

7 C < 68 C H 6 ! D .7 6 : << <6 C A s funções matemáticas permitem efetuar diversos tipos de cálculos matemáticos.PI – o valor de pi ( = 3. $ 4 " " 11 " !0 " " @ 4 " 0 4 <# " + : T ( (+ + (= (+E$22+> @ " <# = " Z (K IK " I+> ! (+ 4 (+ # " @ 4 <# = @ (K " I+> " " 4 " = (K $I K *I+> = (K $I K *I+> (+ " " 8 (+ " " = 4 (K " I+> " = (K " I+> 56 56 I E 7\ 6 ? 75 . A seguir são apresentadas as principais funções (ou métodos) da classe Math: " 56 C 4 <# c " C 4 <# " "56 C 4 <# (+ @ 56 C 4 <# 4 <# ? ) (+ @ @ @ " " .7182818284590452354). pois ela já faz parte do pacote java.E que se refere ao valor da base para logaritmos naturais (2.<nome da função ou método>(<argumentos ou lista de argumentos). A classe Math define duas constantes matemáticas. Não é necessário importar a classe Math em um programa para poder utilizar seus recursos. Math. 56 C @ 56 C 4 <# 4 22 " " @ @ 8 <# 4 <# 4 " " ! 0 4 " " (+ O @ " " @ " <# 2 ) 2 <# ) " " 11 ! @ 8 $2( 4 ! @ " " @ (+ . Para realizar esses cálculos. importado automaticamente pelo compilador de Java.lang.H5 7 46 H57 46 <6 C C< . são utilizados os métodos da classe Math que devem apresentar a seguinte sintaxe: Math.14159265358979323846) e Math.

25.5)).ceil(a)).out.C)). int A = 10.out. System.ceil(b)).9 e -4.out.C)).println("FUNCAO max()").println("Arredondando 5.println("O maior entre 10 e -5.25 e = " + Math.out.out. expoente = 2.out.out.out.println("25 elevado a 0. y = 30.out.println("FUNCAO ceil()").2 = " + Math. //função pow() System. System.out.8 = " + Math.out. System.println("Arredondando 5. System.2.out.println().D)).println("FUNCAO sqrt()"). System. b = 5.out.B)).5.println("A raiz quadrada de 900 e = " + Math. //função floor() System.max(A.println("Arredondando -5.min(A.random()*99). System.9 e = " + Math.D)). System.println().out.println("O maior entre 10 e 15 e = " + Math. } System.5 elevado a 2 e = " + Math. System.6 = " + Math.println().ceil(c)).out.println("5.println("O menor entre 10 e 15 e = " + Math. System.8 = " + Math.out.print(num+" "). B = 15.5 e = " + Math.max(A.println("O maior entre -5. System.println("FUNCAO min()").out. c= -5.out. System.6 = " + Math. System.floor(b)). System.println("Arredondando 5. System.max(C.x<=6.println("FUNCAO floor()").sqrt(x)). System.out. System. System.pow(base.println("O menor entre 10 e -5.out.floor(a)). //função sqrt() System.println("Arredondando 5. //função min() System.println().min(C. C= -5.floor(c)).println("A raiz quadrada de 30.qtd++){ for(int x = 1.pow(25. System.5 e = " + Math.println().D = -4.9 e = " + Math.sqrt(y)).min(A.println("O menor entre -5.B)).out. //função max() System.x++){ int num = (int) (Math.out. //função ceil() System.out. double x = 900..5 e = " + Math.out.println("5678 elevado a 0 e = " + Math.out. System.out. System.8.2 = " + Math. double base = 5. } } b) Função random() class ExemploRandom{ public static void main(String args[]){ for(int qtd = 1.a) funções matemáticas class ExemplosFuncMat{ public static void main(String args[]){ double a = 5.out. System.out.expoente)). qtd <= 5.pow(5678.0)).9 e -4.out.6. } } } 76 .println("FUNCAO pow()").out.println().println("Arredondando -5. System. System.5.9.

Essas strings podem ser manipuladas de várias formas.length(). Da mesma forma que as funções matemáticas.H5 7 8 CH 46 6 : Uma String corresponde à união de um conjunto de caracteres.out. String a = "ARROZ". ' $ $ 56 56 56 . Em Java. 4 4 (+ " " " 4 < % (+ " > # " 56 C 4 <# 4 @ T 0 (+ 4 @ ! O # " ! " <# K 0I " (K IK <# I+ " @ # ! " @ " < " < K 0I (+> 4 @ 4 2 (+ " ) 4 d " " K K K 0I 0I 0I I UK A "" Z O O (+ (+ <# " (+ " " " " T $ K 0I C (K I+> " 5 4 <# K 0I 0 (+> C 4 <# 8" 4 4 <# 0(K 4 IV+> 56 C 4 <# " < 4 # 4 I E 7\ 6 ? a) funções de String class ExemplosFunString{ public static void main(String args[]){ String A = "Aprendendo Java". acessa ou mudar caracteres individuais. As strings constituem-se uma cadeia de caracteres entre aspas. Por exemplo é possível verificar seu comprimento.println("Exempo da funcao length()"). System. as strings são instâncias da classe string. " <56 C 4 <# " < " < % 56 C 4 <# 5 0 = > . retirar um pedaço dela. String x = "banana nanica". . 77 .<função>(<argumento/s>). Estas funções acompanham a seguinte sintaxe: <nome da string>. b = "batata". Exemplo: S = “Linguagem Java”. String frase = " Cristo: o rei dos reis ". existem diversas funções (ou métodos se preferir) para manipulação de strings. int tamanho = A.

out.out. System.println().substring(2)).println().x<50000000. System.charAt(i)). System.replace('a'. System. System. System.println().out.out. System.out. } } //temporizador2 78 . System.trim() + "*"). } } b) Criação de Banners class ExemploBanners{ public static void main(String args[]){ String palavra = "".out.out.out.println("Sem espacos: "+ "*" + frase. System. System. System. for(int y=0.out.i++){ //varre os caracteres da palavra System.println("Trocar caracter 'a' por 'u': " + x.println(palavra.i++) System.toLowerCase()). System.println().println(A).length(). //a variavel palavra sera usaa no banner if (args.out.out.println("Mostra a palavra letra a letra").println("O tamanho da string e: "+ tamanho).println().println("Exemplo das funcoes toUpperCase() e toLowerCaser()").out.println("batata em maiuscula = "+b.out.println(A.println().'_')).println("Caracter = "+A. System.println("String: " + x).println("Trocar caracter 'n' por 'N': " + x.out. System.out. //a variavel palavra recebe a palavra digitada while(true) { //looping infinito for(int i =0. System.println("Para encerrar pressione CTRL+C").println("ARROZ em minuscula = "+a.substring(11.'u')).println("Exemplo da funcao substring()").println("Exemplo da funcao charAt()").println("do 3 caractere ate o fim = "+A.out.out.out.println("Exemplo das funcao trim()"). System.charAt(i)). //temporizador1 } System.replace(' '.println("String: " + A). System. System. for(int i = 11.out.println("Trocar caracter espaco por '_': " + x.println("do 1 caractere ate o 10 = "+A. System.out.15)).out.out.out.println("Com espacos: "+ "*" + frase + "*").replace('n'.charAt(5)).'N')). System.y++). System. System.out.println("Exemplo das funcao replace()"). System.out.length==1){ System.substring(0.out. for(int x=0.10)).System. palavra = args[0]. System.i<palavra. System.out.println("Entre com uma palavra qualquer").out.out.x++).i<=14.out.println("do 12 caractere ate o 15 = "+A.toLowerCase()). System.out. System.toUpperCase()).y<100000000. } } else System.out.println().println("SaLaDa em minuscula = "+"SaLaDa".out.

use a fórmula: c = pi*d/2 (em que c = comprimento. Crie um programa que simule a jogada de um dado (de seis lados) dez vezes e mostre o resultado na tela.. em que deve ser fornecida a quantidade de voltas que a roda da bicicleta deu e o diâmetro dessa roda em metros. Crie um aplicativo que receba uma frase qualquer e mostre-a de forma invertida. Faça um programa que calcule a distância percorrida. Exemplo: frase digitada: Java Ensino Didatico resultado esperado: ocitadiD onisnE avaJ 5.1416 e d = diâmetro da circunferência). Sabendo o comprimento da roda. desde que o raio do pneu da bicicleta seja conhecido. Crie um aplicativo que mostre o efeito apresentado no exemplo abaixo para uma determinada palavra. Com o uso desse aparelho é possível descobrir qual a distância percorrida em um percurso. 3. pi = 3. Crie um programa que clacule quantos metros cúbicos de água suporta uma determinada cx d'água em forma de cubo (todos os aldos são iguais). O usuário deve informar o valor do lado. Um ciclista criou um aparelho que marca quantas voltas a roda de sua bicicleta dá em um determinado percurso. Exemplo: palavra digitada: Java efeito: J Ja Jav Java Jav Ja J 79 . Para saber o comprimento da roda a partir do diâmetro fornecido. basta multiplicá-lo pelo número de voltas para descobrir a distância do percurso. e o 3 volume de água será calculado pela fórmula: volume = lado . Arredonde o resultado para seu próximo inteiro.I . Arredonde o resultado para seu inteiro anterior. 2. 7 8 K < F O KH 5 7 6 J 6 I4 46 <6 C C < 68 C H 7 .7 6 : 1. 4.

Cada posição contém exatamente um valor que pode ser manipulado individualmente. leia(v[5]). 6 Declaração E 7C7 H8 6 7 H 7 S6 6 < H < D C 7T <identificador>: vetor [li.J. Lf representa o limite final do vetor.9] de real. Exemplo a) algoritmo em pseudocódigo inicio A. poderemos manipulá-lo através de qualquer operação de entrada.G. também denominada índice. Índice Elemento Variável Valor 0 1º v[0] 58 1 2º v[1] 4 2 3º v[2] -5. Quando determinada estrutura de dados é composta por varáveis com o mesmo tipo primitivo.. da expressão aritmética ou da variável que estiver dentro dos colchetes.B. Esse índice determina a posição em que o elemento está inserido na estrutura."6 6 6 < R 7 C 7 C 6 "< D 7 .D.H. saída ou atribuição. e a posição por meio da constante. como um conjunto. Identificador é o nome dado ao vetor tipo representa qualquer tipo básico ou tipo anteriormente definido.7 2 2 3 3.F. 80 .7 3 4º v[3] 2 4 5º v[4] 3.2 5 6º v[5] 6 6 7º v[6] 9 7 8º v[7] 7 8 9º v[8] 0 9 10º v[9] -1 Manipulação O nome do vetor é denominado por meio do identificador que foi utilizado na definição de variáveis.I.C. Exemplo: Um vetor de 10 posições de reais poderia ter a seguinte definição e declaração: v: vetor[0.2 4 6 5 9 6 7 7 0 8 -1 9 As estruturas de dados são estritamente relacionadas com os algoritmos.E. utilizaremos a situação de construir um algoritmo que calcule a média aritmética geral de uma classe com dez alunos e imprimir a quantidade de notas acima da média calculada. Então. "< D 7 . Após isolar um único elemento de um vetor. escreva(v[5]). Exemplo: V[5] = 6. precisamos fornecer o nome do vetor (identificador) e o índice do elemento desejado. uma variável pode ser interpretada como um elemento e uma estrutura de dados. Em que: Li representa o limite inicial do vetor. 6 E 7C7 P < :H< M67 A ssim como na teoria dos conjuntos. temos um conjunto homogêneo de dados. para uma melhor percepção desses conceitos. 58 0 4 1 -5.lf] de tipo.. Para manipularmos um determinado valor (elemento) em um vetor.NotaAcima:inteiro.

NotaAcima=0. System. System.readLine()).println("Entre com a media do 1 a = Integer.E. fimse. media:real. System.parseInt(entrada.readLine()).c.parseInt(entrada. escreva(NotaAcima).readLine()). fimse.readLine()).e. aluno: ").out.println("Entre com a media do 3 c = Integer.b. aluno: ").out.parseInt(entrada. se(D >media) entao NotaAcima = NotaAcima+1. System.out.io.println("Entre com a media do 8 h = Integer.H. media = (A+B+C+D+E+F+G+H+I+J)/10. fimse.readLine()).println("Entre com a media do 9 i = Integer. aluno: ").out. leia(A. fimse.println("Entre com a media do 5 e = Integer.i.parseInt(entrada. fimse. aluno: ").parseInt(entrada.d.B. aluno: ").out.out. fimse.out. System.F. System.C. System. fimse.parseInt(entrada. se(G >media) entao NotaAcima = NotaAcima+1.J). se(C >media) entao NotaAcima = NotaAcima+1.j.G.readLine()). aluno: "). fimse. BufferedReader entrada.println("Entre com a media do 6 f = Integer. float media. fimse. se(H >media) entao NotaAcima = NotaAcima+1.parseInt(entrada.f.parseInt(entrada. se(F >media) entao NotaAcima = NotaAcima+1. System. aluno: "). fimse.readLine()).parseInt(entrada.in)). aluno: ").println("Entre com a media do 4 d = Integer.readLine()). se(B >media) entao NotaAcima = NotaAcima+1.println("Entre com a media do 7 g = Integer.*.g. class NotaAcimaM{ public static void main(String args[]){ int a. b) programa em Java import java. se(A >media) entao NotaAcima = NotaAcima+1.h.out. 81 . se(J >media) entao NotaAcima = NotaAcima+1. try{ System.fim.out.println("Entre com a media do 2 b = Integer. se(E >media) entao NotaAcima = NotaAcima+1. aluno: "). se(I >media) entao NotaAcima = NotaAcima+1. entrada = new BufferedReader(new InputStreamReader(System.readLine()).D.I.

x:inteiro. fimpara.. if(f > media) NotaAcima +=1.println("A quantidade de alunos com nota acima da media e: "+NotaAcima). }catch(Exception E){ System.readLine()). soma. if(d > media) NotaAcima +=1.out. //laço para acumular em soma os valores de vclasse para x=1 ate 10 faca soma = soma +vclasse[x]. Vejamos como ficaria o exemplo utilizando vetor: Exemplo: a) algoritmo em pseudocódigo inicio //declaração do vetor vclasse e das variaveis vclasse= vetor[1. if(j > media) NotaAcima +=1.println("Entre com a media do 10 aluno: "). if(b > media) NotaAcima +=1. if(g > media) NotaAcima +=1.out. //leitura do vetor vclasse para x=1 ate 10 faca leia(vclasse[x]).System. } } } O algoritmo mostrado acima torna-se impraticável para uma grande quantidade de notas.println("Houve erro na entrada de dados"). System. isto é.parseInt(entrada. if(i > media) NotaAcima +=1. if(a > media) NotaAcima +=1. if(c > media) NotaAcima +=1.10] de reais. NotaAcima = 0. j = Integer. if(e > media) NotaAcima +=1. media = (a+b+c+d+e+f+g+h+i+j)/10. um vetor armazenando cada nota em uma posição diferente do mesmo. //inicialização de variáveis soma =0. fimpara. media = soma/10. NotaAcima. //laço para veificar os valores de vclasse que estão acima da media 82 .out.media:real. Seria muito mais coerente se usássemos uma única variável que comportasse muitos dados. if(h > media) NotaAcima +=1.

*.i<=9.i++) soma +=classe[i].parseFloat(entrada. fim.i<=9. media. //soma dos valores for(i=0.v2[i]).para x=1 ate 10 faca se (vclasse[x] > media) entao NotaAcima = NotaAcima+1. float soma=0. 83 . for(i=0. fimpara. escreva(v3[i]). } System. BufferedReader entrada. class NotaAcimaM_Vet{ public static void main(String args[]){ float classe[] = new float[10].i++){ if (classe[i] > media) NotaAcima +=1.i<=9.println("Houve erro na entrada de dados!"). para i=1 ate 50 faca v3 = v1[i] + v2[i]. //numero de valores acima da media escreva(NotaAcima).out. some e imprima o resultado da soma. Solução: a) algoritmo em pseudocódigo inicio v1.io. }catch(Exception e){ System.v2.println("A quantidade de alunos com nota acima da media e: "+NotaAcima).in)). //calculo da media media = soma/10. try{ //entrada de dados System. } } } Exemplos: 1) Elabore um algoritmo que leia.v3:vetor[1.println("Entre com as notas dos alunos:").out..out.i++) classe[i] = Float.NotaAcima=0. fimse. fimpara. entre dois vetores inteiros de 50 posições. entrada = new BufferedReader(new InputStreamReader(System. for(i=0.readLine()). fimpara. para i=1 ate 50 faca leia(v1[i]. i:inteiro. //declaracao do array de 10 posicoes de inteiros int i.50] de inteiros. b) programa em Java import java.

} } } 2) Construa um algoritmo que preenha um vetor de 100 elementos inteiros. } //calculo da soma de v1 com v2 System. try{ //leitura do vetor v1 System. } //leitura do vetor v2 System..println("Entre com os valores para o vetor B:"). System. } }catch(Exception e){ System. for(i=0.*.100] de inteiros. colocando 1 na posição correspondente a um número par e 0 a um número ímpar. fimpara.in)).i<=49.out.println("Vetor resultante da soma de v1 com v2:").out.println("Entre com os valores para o vetor A:"). int i.readLine()).fim. int v2[] = new int[50]. fim.readLine()).println(" "+v3[i]). i:inteiro.i++){ v1[i] = Integer.i<=49. int v3[] = new int[50].i<=49.i++){ v2[i] = Integer. class SomaVet{ public static void main(String args[]){ BufferedReader entrada. senao a[i] = 0.out. fimse.io. para i=1 ate 100 faca se (i mod 2 == 0) então a[i] = 1.out. Solução: a) algoritmo em pseudocódigo inicio a:vetor[1. for(i=0.i++){ v3[i] = v1[i]+v2[i].out.parseInt(entrada. int v1[] = new int[50]. fimpara. entrada = new BufferedReader(new InputStreamReader(System.parseInt(entrada.println("Houve erro na entrada de dados!!!"). b) programa em Java import java. para i=1 ate 100 faca escreva(a[i]). for(i=0. b) programa em Java class PreencheVet{ public static void main(String args[]){ 84 .

*. for(i=0. try{ System.i<=4.out. 85 .i<=4. para i=1 ate 5 faca leia(a[i]). for(i=0. entrada = new BufferedReader(new InputStreamReader(System. int a[] = new int[5]. }catch(Exception e){ System.. soma=0.out.i<=9.println("Houve algum erro na entrada").i<=9. apresentar a soma de todos os elementos que sejam ímpares. escreva('A soma e: '.5] de inteiros.i++){ if((a[i] % 2) != 0) soma += a[i]. b) programa em Java import java. } } 3) Desenvolva um algoritmo que efetue a leitura de cinco elementos para um vetor A.i++) System. } for(i =0.i++) a[i] = Integer. soma). fimse.out. } System.print(" "+a[i]). fimpara.i:inteiro.i++){ if((i % 2) == 0) a[i] = 1.parseInt(entrada.println(). for(i =0. fim. No final. Solução: a) algoritmo em pseudocódigo inicio soma. } } } 4) Faça um algoritmo para calcular a média das temperaturas verificadas durante a semana a partir das médias diárias já obtidas.out. else a[i] = 0. fimpara.println("Entre com os valores do vetor A:"). a:vetor[1.println("A soma dos elementos impares e: "+soma). int i. class SomaImpar{ public static void main(String args[]){ BufferedReader entrada.in)).int a[] = new int[10].io. para i=1 ate 5 faca se ((a[i] mod 2) != 0) entao soma = soma + a[i].out.i. System.readLine()). int soma=0.

println("A media das temperaturas e: "+media).i<=6.j:inteiro. i. temp[5] = 22. temp[4] = 25. temp[5] = 22.0. temp[3] = 21.media. temp[0] = 19. b) programa em Java class MediaTemp{ public static void main(String args[]){ float soma=0. fim.7] de reais. temp[4] = 22. media = soma/7.0. temp[2] = 23. fimpara. temp[6] = 20. for(i=0. para i=1 ate 7 faca soma = soma + temp[i].0. i:inteiro.0.0.0. soma = 0. temp[2] = 21. } } 5) Faça um algoritmo para efetuar a ordenação dos elementos considerados no exemplo anterior. temp[6] = 20. System.0. media = soma/7.0. temp[6] = 24. Solução a) algoritmo em pseudocódigo inicio temp:vetor[1. soma.0. temp[7] = 24. media).0. exibindo o maior e o menor deles. int i. temp[1] = 19.0.media:real. temp[1] = 19.0..i++) soma += temp[i]. float temp[] = new float[7]. para i=1 ate 6 faca 86 . temp[1] = 23. temp[3] = 25. temp[2] = 23.0.7] de reais. temp[4] = 25.0.out. temp[3] = 21. temp[7] = 24. temp[5] = 20. escreva('A media de temperaturas da semana e:'..Solução: a) algoritmo em pseudocódigo inicio temp:vetor[1.

for(j=i+1.out. 87 . temp[5] = 20.out. i:inteiro.j. temp[6] = 24. temp[2] = 21.100] de inteiros.i<diasemana.min. temp[4] = 22. escreva('O menor valor e:'.i++){ min = i. x = temp[min].. Solução: a) algoritmo em pseudocódigo inicio numero:vetor[1. float temp[] = new float[diasemana]. fimse. fimse.i< diasemana -1. temp[1] = 23. para i=1 ate 100 faca se(numeros[i] == 30) entao escreva(i). float aux. para j = i+1 ate 7 faca se(temp[j] < temp[i]) entao min = j. temp[1]). temp[min] = temp[i]. escrever as posições em que estão armazenadas. temp[i] = x. fimpara. temp[3] = 25. int i.fim. escreva('O maior valor e:'. aux = temp[min].println("A temperatura minima da semana e: "+temp[0]). System. temp[7]). temp[0] = 19. fimpara. fimpara. Se existirem.println(). temp[min] = temp[i]. b) programa em Java class OrdenaVet{ public static void main(String args[]){ final int diasemana = 7. for(i=0. } } } System. fimpara.out. temp[i] = aux. System. } } 6) Fazer um programa que leia uma variável de 100 elementos numéricos e verificar se existem elementos iguais a 30. para i= 1 ate 100 faca leia(numeros[i]).println("A temperatura maxima da semana e: "+temp[6]).i++){ if(temp[j] < temp[min]){ min = j.

enquanto (LP[i] != 9999) faca i = i + 1.fim. $ * / 3 % . $32 9999 OC .. leia(LP[i]).j:inteiro.out. Existem disponíveis em uma unidade de entrada os números de matrícula dos alunos de “Lógica de Programação”(no máximo 150) e de “Organização de Computadores”(no máximo 220 alunos).151] de inteiros.i++) numeros[i] = Integer. $ * / 3 % . b) programa em Java import java. class Pesquisa{ public static void main(String args[]){ int numeros[] = new int[100].. LP .io. //leitura da matricula dos alunos que estao cursando LP i=1. Cada conjunto dos números de matrícula dos alunos de uma disciplina tem a matrícula fictícia 9999 no final. Fazer um programa que imprima o número de matrícula dos alunos que estão cursando estas disciplinas simultaneamente. leia(LP[i]).parseInt(entrada.out. OC:vetor[1.. entrada = new BufferedReader(new InputStreamReader(System.out. simultaneamente..println("Entre com os valores: "). int i.221] de inteiros. //leitura da matricula dos alunos que estao cursando OC 88 . fimenquanto.println("A posicao do elemento no vetor e:"+(i+1)).. try{ System. } }catch(Exception e){ System.i++){ if(numeros[i] == 30) System.in)). for(i=0.readLine()).i<=99. **2 9999 Solução: a) algoritmo em pseudocódigo inicio LP:vetor[1. } } } 7) A coordenação de Tecnologia em Desenvolvimento de Software do ICESAM deseja saber se existem alunos cursando.i<=99. for(i=0..*. as disciplinas “Lógica de Programação” e “Organização de Computadores”. BufferedReader entrada. i.println("Houve algum erro na entrada de dados").

OC[i] = Integer. LP[i] = Integer.out.out.readLine()).io. int i. i++.parseInt(entrada.readLine()).readLine()).println("Houve erro na entrada de dados!!"). i = i + 1. b) programa em Java import java. i=1.out.println("Alunos matriculados em simultaneamente:"). } //verificacao da matricula simultanea em LP e OC System. fimenquanto.in)). class VerifMatric{ public static void main(String args[]){ int LP[] = new int[151]. enquanto ((OC[j] != 9999) e (LP[i] != OC[j])) faca j = j + 1. fimenquanto. } //leitura da matricula dos alunos que estao cursando OC System. while(LP[i] != 9999){ j = 1.println("Entre com os numeros de matricula em OC:"). //verificacao da matricula simultanea em LP e OC i=1. leia(OC[i]). enquanto (LP[i] != 9999) faca j = i. OC[i] = Integer.parseInt(entrada.*. } }catch(Exception e){ System.out.readLine()). } LP e OC 89 . i=1. while(LP[i] != 9999){ i++. while((OC[j] != 9999) && (LP[i] != OC[j])) j++. BufferedReader entrada.i=1. fimse.parseInt(entrada. entrada = new BufferedReader(new InputStreamReader(System. while(OC[i] != 9999){ i++.out. i=1. if(LP[i] == OC[j]) System. enquanto (OC[i] != 9999) faca i = i + 1.println("Entre com os numeros de matricula em LP:"). fim. LP[i] = Integer. try{ //leitura da matricula dos alunos que estao cursando LP System. leia(OC[i]).println(LP[i]). fimenquanto.parseInt(entrada. int OC[] = new int[221].j. se (LP[i] = OC[j]) entao escreva(LP[i]).

.Nvoo. Caso contrário. fimenquanto. Além da leitura do número dos vôos e quantidade de lugares disponíveis. 'Voo '. se (apont != 0) entao se (LDisp[apont] > 0) entao escreva('Cliente: '. Nvoo. //verificação da existencia do voo enquanto(cliente != 9999) faca i = 1. 35 36 37 . e o número do vôo. se (Nvoo ==Voos[i]) entao apont =i. apont. leia(cliente. Ldisp[apont] = Ldisp[apont] – 1. imprimir o número da identidade do cliente.Nvoo). . 447 1 221 291 Solução: a) algoritmo em pseudocódigo inicio Voos.cliente. Para cada cliente.} } 8) Escrever um programa que faça reserva de passagens aéreas de uma companhia. Em caso afirmativo. apont = 0. i:inteiro.37] de inteiros. ' inexistente'). avisar ao cliente da inexistência de lugares. verificar se há disponibilidade no vôo desejado. enquanto ((i<=37) e (Nvoo != Voos[i])) faca i = i+1. ' numero do voo: '. . Indicando o fim dos pedidos de reserva.Nvoo). senao escreva('Cliente: '. atualizando o número de lugares disponíveis. constituídos do número da carteira de identidade do cliente e do número do vôo desejado. else 90 . . fimse. ler vários pedidos de reserva. para i = 1 ate 37 faca leia(Voos[i]. . cliente. . fimpara.LDisp:vetor[1. 90 16 15 Cliente NVoo 3 . . Estruturas de dados necessárias: 1 2 727 442 331 15 16 0 . Considerar fixo e igual a 37 o número de vôos da companhia. existe um passageiro cujo número da carteira de identidade é 9999. cliente.LDisp[i]).

fim.

escreva('Cliente: ',cliente, ' numero do voo: ',Nvoo, ' lotado'); fimse; fimse; leia(cliente,Nvoo); fimenquanto;

b) programa em Java
import java.io.*; class ReservaVoo{ public static void main(String args[]){ BufferedReader entrada; entrada = new BufferedReader(new InputStreamReader(System.in)); int Voos[] = new int[37] ,LDisp[] = new int[37]; int cliente,NVoo, apont, i; try{ for(i=0;i<=36;i++){ System.out.println("Entre com o voo e a quantidade lugares disponiveis neste voo:"); Voos[i] = Integer.parseInt(entrada.readLine()); LDisp[i] = Integer.parseInt(entrada.readLine()); } cliente = Integer.parseInt(entrada.readLine()); NVoo = Integer.parseInt(entrada.readLine());

de

//verificação da existencia do voo while((i <= 37)&&(NVoo != Voos[i])){ i=1; if(NVoo == Voos[i]){ apont = i; }else{ System.out.println("O cliente: "+cliente+ " voo "+NVoo+" inexistente"); apont = 0; } //verificação da existencia de lugar if (apont != 0){ System.out.println("O cliente: "+cliente+ " numero do voo "+NVoo); LDisp[apont] --; }else System.out.println("O cliente: "+cliente+ " numero do voo "+NVoo+ " lotado"); System.out.println("Entre com o voo e a quantidade de lugares disponiveis neste voo:"); cliente = Integer.parseInt(entrada.readLine()); NVoo = Integer.parseInt(entrada.readLine()); } }catch(Exception e){ System.out.println("Houve algum erro na entrada de dados"); } } }

9) Escrever um programa para corrigir provas de múltipla escolha. Cada prova tem 10 questões, cada questão valendo um ponto. O primeiro conjunto de dados a ser lido será o gabarito para a correção da prova. Os outros dados são os números dos alunos e suas respectivas respostas e o último número, do aluno fictício, será 9999. O programa deverá calcular e imprimir: a) para cada aluno, o seu número e sua nota. b) A porcentagem de aprovação, sabendo-se que a nota mínima de aprovação é 6. c) A nota que teve maior freqüência absoluta, ou seja, a nota que aparece maior número de vezes (supondo a inexistência de empates).

91

Estrutura de dados principal: Gabarito número nota

Respostas

Aprovados

Total

Freqüências

Maior

Porcentagem

Solução: a) algoritmo em pseudocódigo inicio gabarito,resposta:vetor[1..10] de caracter; frequencia:vetor[0..10] de inteiros; i, aprovados,maior, nota,notamaio,numero,total:inteiro; porcent:real; //atribuição dos valores iniciais necessários total = 0; para i=0 ate 10 faca frequencia[i] = 0; fimpara; escreva('Entre com o gabarito da prova'); para i=1 ate 10 faca leia(gabarito[i]); fimpara; leia(numero); enquanto(numero != 9999) faca para i=1 ate 10 faca leia(resposta[i]); fimpara; //correcao da prova nota = 0; para i=1 ate 10 faca se (gabarito[i] == resposta[i]) entao nota = nota + 1; fimse; fimpara; escreva('Numero ', numero, ' - nota: ', nota); total = total +1; //determinação da frequencia das notas frequencia[nota] = frequencia[nota] + 1; leia(numero); fimenquanto; //determinação da porcentagem de aprovaçao aprovados = 0; para i= 6 ate 10 faca aprovados = aprovados + frequencia[i]; fimpara; porcent = aprovados/total*100; //deteminacao da nota de maior frequencia maior =0; para i= 0 ate 10 faca se (frequencia[i] > maior) entao maior = frequencia[i];

92

fim.

notamaior = i; fimse; fimpara; escreva(' ',' porcentagem de alunos aprovados: ',porcent); escreva(' ',' Nota de maior frequencia: ',notamaior);

b) programa em Java
import java.io.*; class CorrecaoProva{ public static void main(String args[]){ String gabarito[] = new String[10], respostas[]= new String[10]; int frequencia[] = new int[11]; int i,aprovados=0, maior=0, nota=0, notamaior=0,numero, total=0; double porcent; BufferedReader entrada; entrada = new BufferedReader(new InputStreamReader(System.in)); try{ for(i=0; i<=10;i++) frequencia[i] = 0; System.out.println("Entre com o gabarito da prova:"); for(i=0;i<=9;i++) gabarito[i] = entrada.readLine(); System.out.println("Entre com o numero do aluno:"); numero = Integer.parseInt(entrada.readLine()); while (numero != 9999){ for(i=0;i<=9;i++) respostas[i] = entrada.readLine(); //correcao da prova for (i=0;i<=9;i++) if(gabarito[i] == respostas[i]) nota ++; System.out.println("Numero "+numero+ " - Nota: "+nota ); total++; //determinação da frequencia das notas frequencia[nota] ++; System.out.println("Entre com o numero do aluno:"); numero = Integer.parseInt(entrada.readLine()); } for (i=7;i<=9;i++) aprovados += frequencia[i]; porcent = aprovados/total*100; //Determinacao da nota de maior frequencia for(i=0;i<=10;i++) if (frequencia[i] > maior){ maior = frequencia[i]; notamaior = i; } System.out.println(" "+"Porcentagem de alunos aprovados: "+porcent); System.out.println(" "+"Nota de maior frequencia: "+notamaior); }catch(Exception e){ System.out.println("Houve algum erro na entrada!!"); } } }

10) Estão disponíveis num equipamento de entrada de dados informações sobre o estoque de mercadorias de uma loja. São dados os códigos das mercadorias e as respectivas quantidades existentes. A seguir, estão os pedidos dos clientes. Escrever um programa para a atualização do estoque, tal que:

93

a) b)

Sejam lidos os pedidos dos clientes, constituídos, cada um, do número do cliente, código da mercadoria e quantidade desejada; c) Seja verificado, para cada pedido, se ele pode ser integralmente atendido. Em caso negativo, imprimir o número do cliente e a mensagem “Estoque insuficiente”. d) Seja atualizado o estoque após cada operação; e) Seja listado o estoque final. Observação: considerar que, separando os dados do estoque inicial dos de pedidos, existe um dado código de mercadoria é 9999 e. encerrando os pedidos, há um cliente fictício, cujo número é 9999.

estoque inicial (máximo de 100 mercadorias).

seja lido e listado o

Solução: a) algoritmo em pseudocódigo inicio Estoque,codigo:vetor[1..101] de inteiros; cliente,i,mercadoria,n,quantidade:inteiro; i = 1; //leitura e escrita do estoque incial leia(codigo[i],Estoque[i]); enquanto (codigo[i] != 9999) faca escreva(codigo[i],estoque[i]); i = i+1; leia(codigo[i],Estoque[i]); fimenquanto; n = i – 1; leia(cliente,mercadoria,quantidade); enquanto (cliente != 9999) faca //verificacao da existencia da mercadoria i = 1; enquanto ((i!= n) e (mercadoria != codigo[i]) faca i = i+1; fimenquanto; se (mercadoria = codigo[i]) entao se (Estoque[i] >= quantidade) entao Estoque[i] = Estoque[i] – quantidade; senao escreva('cliente: ',cliente, ' - mercadoria: ',mercadoria, ' - não temos a mercadoria em estoque suficiente'); fimse; senao escreva('cliente: ',cliente, ' - mercadoria: ',mercadoria, ' - não existe a mercadoria pedida'); fimse; leia(cliente,mercadoria,quantidade); fimenquanto; //escrita do estoque final enquanto(codigo[i] != 9999) faca escreva(codigo[i], Estoque[i]); i = i+1; fimenquanto;

fim.

b) programa em Java

94

import java.io.*; class Controle_Estoque{ public static void main(String args[]){ int Estoque[] = new int[101], codigo[] = new int[101]; int i, cliente, n, mercadoria, quantidade; BufferedReader entrada; entrada = new BufferedReader(new InputStreamReader(System.in)); try{ i=1; //leitura e escrita do estoque inicial System.out.println("Entre com o codigo e a quantidade em estoque:"); codigo[i] = Integer.parseInt(entrada.readLine()); Estoque[i] = Integer.parseInt(entrada.readLine()); while (codigo[i] != 9999){ System.out.println("Codigo\tEstoque"); System.out.println(codigo[i]+"\t"+Estoque[i]); i++; System.out.println("Entre com o codigo e a quantidade em estoque:"); codigo[i] = Integer.parseInt(entrada.readLine()); Estoque[i] = Integer.parseInt(entrada.readLine()); } n=i-1; System.out.println("Entre com o codigo do cliente, o codigo da mercadoria e a quantidade:"); cliente = Integer.parseInt(entrada.readLine()); mercadoria = Integer.parseInt(entrada.readLine()); quantidade = Integer.parseInt(entrada.readLine()); while (cliente != 9999){ //verificacao da existencia da mercadoria i = 1; while((i != n)&&(mercadoria != codigo[i])) i++; if (mercadoria == codigo[i]){ if (Estoque[i] >= quantidade) Estoque[i] -= quantidade; else System.out.println("'Cliente: "+cliente + " - mercadoria: "+mercadoria+ " - nao temos a mercadoria em estoque suficiente"); }else{ System.out.println("'Cliente: "+cliente + " mercadoria: "+mercadoria+ " - nao temos a mercadoria pedida"); } System.out.println("Entre com o codigo do cliente, o codigo da mercadoria e a quantidade:"); cliente = Integer.parseInt(entrada.readLine()); mercadoria = Integer.parseInt(entrada.readLine()); quantidade = Integer.parseInt(entrada.readLine()); } //escrita do estoque final i = 1; while(codigo[i] != 9999){ System.out.println("Codigo\tEstoque"); System.out.println(codigo[i]+"\t"+Estoque[i]); i++; } }catch(Exception e){ System.out.println("Houve algum erro na entrada"); } } }

11) Este exemplo demonstra a utilização de um array para armazenar um conjunto de argumentos do tipo inteiro, passado pelo usuário na linha de execução.

95

out.println("O somatorio dos numeros. System. de elementos do array: "+StringArray.i--) System.valueOf(CaracterArray)).println("Quant.println("Quant.println().'f'.println(N[i] + " "). //array de caracteres System. total = total + N[i].out.out. int N[] = new int[10]. System.println("A media entre eles .'b'. for(int i=0. //criando um array de Strings String StringArray[] = {"Aprendendo". System.length). for(i = args.println("Os numeros digitados na ordem inversa foram:").3)).length.length > 0){ try{ for(i=0.i++) //armazena os nomes do array nomes = nomes + StringArray[i] + " ".i++){ //armazena cada um dos elementos no array N[i] = Integer. System. } } else System. char CaracterArray[] = {'a'.println("Mostrando o array: "+nomes).i <StringArray.out.out. } } 96 .out.'g'}.out. //acumula o somatorio dos elementos } System.'d'. total=0.println("1 e 3 caracteres " + String.out.println("Os argumentos devem ser numerso do tipo inteiro").out. System.println("Mostrando o array: "+ String.i>=0. } } Solução: 12) Este exemplo demonstra a criação e inicialização simultanea de um array Solução: class Exemplo12Vetor{ public static void main(String args[]){ String nomes = "".parseInt(args[i]).out.length)).valueOf(CaracterArray."Java"}.println().println("Monstrando o ultimo elemento do array: "+StringArray[StringArray. System.length).out.out.'c'. }catch(NumberFormatException e){ System.i<args.out. "+ (total/args."a". de elementos: "+ CaracterArray. System. System. "+ total).length."Linguagem". System.out.length -1]).class Exemplo11Vetor{ public static void main(String args[]){ int i.0.'e'.out.length-1. System.println("Mostrando o 1 elemento do array: "+StringArray[0]).println("Digite pelo menos um numero!"). //declara um array N de 10 elementos do tipo int if(args.

.5.5] de inteiros. 2 Índices de linhas 2 $ * msala[1.0..5] de inteiros. A essas estruturas indexadas damos o nome de matrizes.1.5.3. mr = matriz[1. Li2 representa o limite inicial da segunda dimensão da matriz. Solução: a) algoritmo em pseudocódigo inicio ma = matriz[1. são elas: 1) fixar a linha e variar a coluna 2) fixar a coluna e varia a linha Exemplos: 1) Construa um algoritmo que efetue a leitura. Manipulação Para acessar um elemento em uma estrutura composta multidimensional – matriz – precisamos da linha e da coluna onde está armazenado o elemento. mb = matriz[1. 97 . i..1. Identificador é o nome dado a matriz.5. Exemplo: Um vetor de 10 posições de reais poderia ter a seguinte definição e declaração: msala: matriz[0.... nós o inserimos em um único laço de repetição. i = 1. Como em uma estrutura multidimensional possuímos mais de um índice.li2.5] de inteiros.3] de real. a soma e a impressão do resultado entre duas matrizes inteiras que comportem 25 elementos. tipo representa qualquer tipo básico ou tipo anteriormente definido.lf2] de tipo. em mesmo número do que o número de dimensões da matriz. Declaração <identificador>: matriz [li1. Para percorre uma matriz podemos utilizar duas técnicas que poderão ser utilizadas de acordo com a necessidade da solução. fazse necessária a utilização de mais laços de repetição. Lf1 representa o limite final da primeira dimensão da matriz. daremos ênfase as de duas dimensões.. Em particular.lf1. permitem a criação de vetores com mais de um índice.1.2] $ * Índices de coluna Para utilizar o vetor. Lf2 representa o limite final da segunda dimensão da matriz.. Em que: Li1 representa o limite inicial da primeira dimensão da matriz.. 6 E 7C7 < ?8 6 7 H 7 S < R 7T C H < C 6 As variáveis composta multidimensionais. como o próprio nome diz. fazendo com que haja variação em seu índice.."< D 7 .j:inteiro.

while (j <5){ ma[i][j] = Integer. i=0.j]. i++.j]. enquanto (i <= 5) faca j = 1. class ExemploMat1{ public static void main(String args[]){ int ma[][] = new int [5][5].fim.println("Entre com os valores para a matriz B:").readLine()). int i. fimenquanto.println("Entre com os valores para a matriz A:"). mr[i. while (j <5){ mb[i][j] = Integer. while (i <5){ mr[i][j] = ma[i][j] + mb [i][j].println("Matriz soma mr:"). i=0.j] = mb[i. entrada = new BufferedReader(new InputStreamReader(System. BufferedReader entrada.print(" "+mr[i][j]). while (j < 5){ i=0.out. int mr[][] = new int [5][5].mb[i.parseInt(entrada. while (i < 5){ j=0.j]). enquanto (j <= 5) faca i = 1. } i++. fimenquanto.j.out. i = i + 1. j++. try{ //preenchimento da matriz A System. System.io. } //preenchimento da matriz B System.j]).parseInt(entrada. fimenquanto. } //matriz resultante da soma de ma com mb System. enquanto (j <= 5) faca leia(ma[i. j = 1. while (i < 5){ j=0.*.out. j = j+1.out. } 98 . } i++. i = i+1. enquanto (i <= 5) faca escreva(mr[i.readLine()). j=0.j] = ma[i. j = j + 1. int mb[][] = new int [5][5].in)). fimenquanto. b) programa em Java import java. j++.

3.println("Ocorreu algum erro na entrada de dados").out. int i. fimpara.k:inteiro. } }catch(Exception e){ System. int mr[][] = new int [3][3].println().out. int mb[][] = new int [3][3]. } } } 2) Elabore um algoritmo que leia duas matrizes A e B di tipo (3x3) e calcule em uma matriz R sua multiplicação.j]).j.. fimpara.j]).j] + ma[i. b) programa em Java import java.System. fimpara. 99 . Solução: a) algoritmo em pseudocódigo inicio ma. para k = 1 ate 3 faca mr[i. fimpara. i.j]).j] = 0.1. fimpara. fimpara.j]. class ExemploMat2{ public static void main(String args[]){ int ma[][] = new int [3][3].mb. fimpara.. fimpara.*.k] * mb[k. //saída de dados – matriz R para i = 1 ate 3 faca para j = 1 ate 3 faca escreva(mr[i.mr:matriz[1. //multiplicação de A por B para i = 1 ate 3 faca para j = 1 ate 3 faca mr[i.k.io. //entrada de dados – matriz A para i = 1 ate 3 faca para j = 1 ate 3 faca leia(ma[i. fim. //entrada de dados – matriz B para i = 1 ate 3 faca para j = 1 ate 3 faca leia(mb[i. ou seja R = A * B.j. fimpara. j ++.j] = mr[i.3] de inteiros.

calcular e exibir a média geométrica dos valores de cada uma das linhas.j<3.println("MATRIZ B:").i++){ for(j=0.2] de inteiros. } } //Multiplicacao de A por B System. } } //entrada de dados .readLine()).println("Entre com o valor A["+i+". para j = 1 ate 2 faca leia(g[i. entrada = new BufferedReader(new InputStreamReader (System.i++){ for(j=0.out.print(" "+mr[i][j]). fimpara.out. } System.j++){ System.out.j].println().println("MATRIZ A:"). ‘ = ‘.i<3. for(k=0.parseInt(entrada. representa a raiz quadrada do resultado da multiplicação dos elementos da coluna 1 (x1) pelos elementos da coluna 2 (x2).k<3. i. prod:real. for(i =0.out.matriz A System. sqrt(prod)).1. for(i =0. mb[i][j] = Integer.j++){ mr[i][j] = 0. "+j+"]"). for(i =0..j<3. } }catch(Exception e){ System.readLine()). ma[i][j] = Integer. Solução: a) algoritmo em pseudocódigo inicio g:matriz[1.k++){ mr[i][j] += ma[i][k] * mb[k][j].println("A matriz produto R e: "). fimpara. try{ //entrada de dados .i++){ for(j=0. para i = 1 ate 6 faca prod = 1.i<3. "+j+"]"). i.BufferedReader entrada.in)).6.println("Ocorreu algum erro na entrada de dados").matriz B System.println("Entre com o valor B["+i+". } } } 3) Dada uma matriz de 6 linhas e 2 colunas de inteiros. A média geométrica é calculada pela seguinte expressão: sqrt(x1 * x2).j]).out.parseInt(entrada. prod = prod * g[i. fim.. escreva(‘linha ‘.out. 100 .out.j:inteiro.out.j<3.j++){ System.i<3. } System.

nAlunos] de reais..println("Ocorreu algum erro na entrada de dados").i++){ prod = 1.j]. BufferedReader entrada.nAlunos.j<2. prod *= g[i][j]. } }catch(Exception e){ System. "+j+"]"). 101 . I. Solução: a) algoritmo em pseudocódigo inicio const nProvas = 3.parseInt(entrada.i<6.println("Linha . Para j = 1 ate nProvas faca Soma = soma + NotaProva[i. for(j=0.. fimpara. nAlunos = 30. NotaProva : matriz{1.sqrt(prod)).1.in)). g[i][j] = Integer. Para i = 1 ate nAlunos faca Soma = 0.j:inteiro.out.nProvas] de reais.b) programa em Java import java.j++){ System.out. O procedimento abaixo descreve a média de cada estudante e a média da turma em cada prova.nProvas] de reais. } System..j].. class ExemploMat3{ public static void main(String args[]){ int g[][] = new int [6][2].j. e as colunas estão associadas às notas das três provas referentes àquele estudante. } } } 4) Média dos alunos de uma disciplina.io. double prod.println("Entre com os valores de G["+i+".out. Para i = 1 ate nProvas faca Soma = soma + NotaProva[i. Para j = 1 ate nProvas faca Soma = 0. MedProvas: vetor[1. MedProvas[j] = soma/nAlunos. MedAlunos[i] = soma/nProvas. Considere uma matriz de 30 linhas e 3 colunas. MedAlunos:vetor[1. Cada linha está associada a um aluno de uma determinada disciplina. fimpara. entrada = new BufferedReader(new InputStreamReader(System. int i.readLine()). Soma : real. try{ for (i=0.*." + 1 + ": "+Math.

parseFloat(entrada.out.out. for (int j =0.i++){ soma += NotaProva[i][j].println("A media do aluno ["+i+"] = "+MedAlunos[i]). } } } 5) Escrever um programa que leia uma matriz 4x4. MedAlunos[i] = soma/nprovas. também lida. e escreva a matriz resultante. } for (int i =0. Solução: 102 . float soma. float MedProvas[] = new float [nprovas]. MedProvas[j] = soma/nalunos.out.in)).*. para i = 1 ate nProvas faca escreva(MedProvas[i]). multiplique os elementos da diagonal principal por uma constante k. float NotaProva[][] = new float [nalunos][nprovas].j++){ soma = 0. NotaProva[i][j] = Float. entrada = new BufferedReader(new InputStreamReader(System.out.j++){ System. } }catch(Exception e){ System. float MedAlunos[] = new float [nalunos]. } } for (int i = 0.println("Ocorreu algum erro na entrada de dados!!!").i++){ System. j< nprovas.nota ["+j+"]"). BufferedReader entrada. fimpara.println("Entre com a nota do aluno["+i+"]. } } for (int j = 0.println("Media da prova ["+i+"] = "+MedProvas[i]). final int nalunos = 30. fim. soma += NotaProva[i][j]. i< nalunos. para i = 1 ate nAlunos faca escreva(MedAlunos[i]). for (int i =0. b) programa em Java import java.i++){ soma = 0. try{ for (int i = 0.readLine()). class ExemploMat4{ public static void main(String args[]){ final int nprovas = 3.i++){ System.i <nalunos.i <nprovas. fimpara. fimpara.fimpara. i< nalunos.j <nprovas.io.

calcular a soma de cada linha e a soma de todos os elementos.in)).println().i<4.parseInt(entrada..out. A[i][j] = Integer.out. int i.i] * k. System.j]). for(i =0. fimpara. } }catch(Exception e){ System. for(i=0.i++){ for(j =0. entrada = new BufferedReader(new InputStreamReader(System.j. } } System.println("A nova matriz A e: ").out.out. //saída de dados para i =1 ate 4 faca para j = 1 ate 4 faca escreva(A[i.j<4.println("Entre com os valores da matriz A:").i<4.println("Entre com o valor de k:").1.println("Ocorreu algum erro na saida!!").k:inteiro. I.a) algoritmo em pseudocódigo inicio A:matriz[1.readLine()). //leitura da matriz A e da constante k para i =1 ate 4 faca para j = 1 ate 4 faca leia(A[i.i++){ for(j =0.j.j++){ System.println("Entre com o elemento A["+i+".readLine()).k. b) programa em Java import java.j]). BufferedReader entrada. class ExemploMat5{ public static void main(String args[]){ int A[][] = new int[4][4]. fimpara. } System. fim.*.out. } } } 6) Dada uma tabela de 4x5 elementos. fimpara.out. k = Integer.out. //calculo do produto de K pela diagonal principal de A para i = 1 ate 4 faca a[i.parseInt(entrada. try{ System.."+j+"]").i<4.i++) A[i][i] = A[i][i] * k. fimpara.j++){ System.io.print(" "+A[i][j]). Solução: a) algoritmo em pseudocódigo 103 .i] = a[i.j<4.4] de inteiros. leia(k). for(i =0.4. fimpara.

out. } } } 104 .i++){ somalinha = 0.1. fimpara.parseInt(entrada. } System.out.total. ‘ : ‘.j<5. i.j.. int i.io. //leitura da matriz Ma para i =1 ate 4 faca para j = 1 ate 5 faca leia(Ma[i.readLine()). BufferedReader entrada.println("Entre com os valores da matriz Mat:").5] de inteiros. I.println("Ocorreu algum erro na saida!!"). entrada = new BufferedReader(new InputStreamReader(System.out. para j = 1 ate 5 faca somalinha = somalinha +Mat[i. for(i =0. for(j =0.somalinha.*. Total = 0.somalinha:inteiro.in)).i<4. }catch(Exception e){ System. total).j]).i<4. class ExemploMat6{ public static void main(String args[]){ int Mat[][] = new int[4][5]. fimpara.j<5.j++){ System.somalinha). Mat[i][j] = Integer..out. } } for(i =0. escreva(‘LINHA ‘. total = total + somalinha. try{ System. total +=somalinha.i++){ for(j =0.4."+j+"]"). fimpara.inicio Mat:matriz[1.println("O total da somatoria das linha e: "+total).j].out.j++){ somalinha += Mat[i][j].println("Linha "+i+": "+somalinha). b) programa em Java import java.total=0.j. fim. //soma dos elementos da linha para i =1 ate 4 faca somalinha = 0.println("Entre com o elemento Mat["+i+". //saída de dados escreva(‘Total: ‘. fimpara. } System.

2. fimpara. para j = 1 ate 12 faca CLA[j] = CLÃ[j] = CLM [i... //custo e lucro anuais dos motores I.j. //inserção do custo e do lucro de cada motor para i =1 ate 2 faca para j = 1 ate 2 faca leia(Valores[i.j] = 0. 25 O setor de controle de vendas tem uma tabela do custo e do lucro (em mil reais) obtidos com cada motor: Custo Lucro M1 10 3 M2 15 2 Fazer um algoritmo que.2] de inteiros. calcule o custo e o lucro em cada um dos meses e o custo e o lucros anuais.j]). . para k = 1 ate 2 faca CLM[i. e o número de motores foi registrado na tabela a seguir: Jan Fev Mar .j] + Producao[i..k] * Valores[k.1. fimpara.7) Uma certa fábrica produziu dois tipos de motores M1 e M2 nos meses de janeiro a Dezembro.j]).j]. fimpara. .2] de inteiros. //produção mensal e custo e lucro mensal Valores: matriz[1. //leitura da matriz producao para i =1 ate 12 faca para j = 1 ate 2 faca leia(Producao[i. a partir da produção mensal de motores M1 e M2 e seus respectivos custos e lucros. 18 M2 20 10 15 . //calculo do custo e do lucro anuais para i =1 ate 2 faca CLÃ[j] = 0. Dez M1 30 5 7 .CLM:matriz[1. fimpara.k:inteiro.j] = CLM[i. fimpara. . fimpara.12.. . .. //Calculo do custo e do lucro mensais para i =1 ate 12 faca para j = 1 ate 2 faca CLM[i.1. Solução: a) algoritmo em pseudocódigo inicio Producao.j]. . fimpara. //custo e lucro de cada motor CLÃ: vetor[1..2] de inteiros. fimpara. 105 .

i++){ CLA[j] += CLM[i][j].j. }catch(Exception e){ System.j++){ CLA[j] = 0. for(k=0.fim.readLine()).println("Custo e lucro mensais:").print(" "+CLM[i][j]). //saída de dados para i =1 ate 12 faca para j = 1 ate 2 faca escreva(CLM[i.in)).j++){ System.j<2. } System. } } for(i =0. } } System. } } 106 .k++){ CLM[i][j] += Producao[i][k] * Valores[k][j].j++){ CLM[i][j] = 0.k<2.j++){ System.i++){ for(j =0. fimpara.println().out. int CLM[][] = new int[12][2]."+j+"]").out.i<2. try{ System. class ExemploMat7{ public static void main(String args[]){ int Producao[][] = new int[12][2]. for(i =0.j<2.i<12. int i. } System.io.out.println("Entre com os valores da matriz Producao:"). ‘ Lucro anual: ‘.println("Entre com o custo e lucro de cada motor:"). entrada = new BufferedReader(new InputStreamReader(System.j<2. } } System. for(i =0. for(i =0.out.j]). escreva(‘Custo anual: ‘.i++){ for(j =0.readLine()). fimpara.out. } } } for(j =0.parseInt(entrada.k.i++){ for(j =0.i<12. BufferedReader entrada. fimpara.*.j<2.j++){ Valores[i][j] = Integer.i<12.println("Ocorreu algum erro na saida!!"). for(i =0. CLA[1].out.j<2. Producao[i][j] = Integer.i<12. b) programa em Java import java. int Valores[][] = new int[2][2].println("Custo anual: "+CLA[0]+"\nLucroAnul: "+CLA[1]).out.parseInt(entrada. CLA[2]).println("Entre com o elemento Producao["+i+". int CLA[] = new int[2].out.i++){ for(j =0.

informando o usuário. gerando um total de 15 notas. Sabendo que essa escola possui três classes com 5 alunos em cada classe. crie um programa que receba as notas de cada aluno de cada classe w no final apresente a média de cada classes e a média a escola em geral.} I . No final verifique se uma determinada pessoa foi cadastrada no array.. 4) Uma escola precisa de um programa que controle a média das notas dos alunos de cada classe e a média das notas de todos os alunos da escola. sendo que esses números deverão ser organizados da seguinte forma: primeiro os números pares em ordem crescente e depois os números ímpares em ordem decrescente. 7 8 I 4 O D C 6 6 < R 7 6 J 6 <F 6 7 C 6 1) Crie um aplicativo que leia 10 valores inteiros quaisquer e imprima na tela os que são maiores que a média dos valores coletados. 3) Faça um programa que colete 10 nomes de pessoas e os armazene em array. 107 . 2) Crie um aplicativo que colete uma indefinida quantidade de números pela linha de execução e no final mostre o menor o maior número fornecido. 5) Faça um programa que utilize um método para organizar uma quantidade qualquer de números inteiros fornecidos pelo usuário na linha de execução do programa.

Outra grande vantagem da decomposição é que permite focalizar a atenção em um problema pequeno de cada vez. quando decompomos um problema em subproblemas. Obedece às mesmas regras que os identificadores de classe. No caso de um método com tipo de retorno void. como classes e as variáveis. decompô-la também. É conveniente que adotemos. uma classe ou void. a quantidade de situações diferentes que um problema pode apresentar. que é sucessivamente dividido até resultar em problemas mais simples e específicos. h) <modificadores>: são elementos que caracterizam o método quanto ã visibilidade (escopo) e qualidade. Assim. } d) <nome_método>: é um identificador válido da linguagem. não importando sua ordem. possui variáveis. Pseudocódigo: procedimento nome_procedimento (lista de parâmetros) //declaração das variáveis locais ao procedimento //instruções do procedimento fimprocedimento. ou seja. 6 . g) return: palavra reservada que indica o valor que será devolvido para o programa. Para acompanhar essa abordagem. portanto não há retorno e é desnecessário utilizar return. A sintaxe dos argumentos é a de declaração de variáveis: tipo identificador. Esse tipo pode ser um tipo primitivo. no caso de não retornar valor (equivalente a um procedimento). objeto e variável. 8 6 C7 6 H Um procedimento também conhecido como sub-rotina.8 ? R4 < <F Um problema complexo pode ser simplificado quando dividido em vários subproblemas. Se alguma parte ainda permanecer complexa. Lembremos que complexidade é sinônimo de variedade. operações e até funções. return <nome_variável_retorno>. então. por conseqüência. Os métodos. o que ao final produzirá uma melhor compreensão do todo. Analisar a divisão obtida para garantir coerência. <instruções>. Analisar o resultado para garantir entendimento e coerência. e os vários parâmetros são separados por vírgulas. um critério para orientar o processo de decomposição: Dividir o problema em suas partes principais. E74 F A decomposição de um problema é fator determinante para a redução da complexidade. Java: <modificadores> <tipo_retorno> <nome_método> (<argumentos>){ <tipo_retorno> <nome_variável> = <valor_inicial>. f) <tipo_retorno>: indica o tipo do valor retornado pelos métodos. Esse processo de decomposição contínuo também é conhecido como Refinamentos Sucessivos. Um algoritmo de procedimento é criado da mesma que outro algoritmo qualquer: deve ser identificado. estamos invariavelmente dividindo também a complexidade e. Onde: 108 . * . sendo associada com a variável que armazena esse valor. simplificando a resolução. podem possuir mais de um modificador. e) <argumentos>: indica a lista de argumentos que serão passados como parâmetros para os método. é um conjunto de instruções que realiza determinada tarefa. serão apresentados conceitos e técnicas que permitem a divisão de um algoritmo em módulos ou subalgoritmos. porque se parte de um problema complexo e abrangente. nada é devolvido.

protected: pode ser utilizado apenas no mesmo pacote e em subclasses. Procedimento ModAdicao().parseInt(<String>). *7. Indica um método que é visível para qualquer um que enxergue a classe./ . a tarefa associada a ele é realizada pelo algoritmo principal. . transient. native. Pode ser invocado a partir do nome da classe.res:real. subtração. v1. Se não há modificador. o método pode ser chamado apenas no mesmo pacote. escreva (res).v2). * 5) . Equivale à declaração de constante. res = v1 + v2. fim_do_procedimento Inicio do algoritmo principal instruções do algoritmo principal fim do algoritmo principal Exemplos: • Elaborar um algoritmo que realize a operação aritmética escolhida pelo usuário. Algoritmo principal //declaração de variáveis utilizadas no algoritmo principal //Declaração do procedimento Procedimento nome_do_procedimento() S )8 ++ . Deverá ser criado um menu de opções para o usuário. como por exemplo: abstract. existem outros modificadores. multiplicação ou divisão. static: não necessita de objeto. Z(-) / 99 / .*7. /4 1C 4 -(-) / 99.+ B* B / . 2) . private: pode ser invocado apenas na classe. isto é. /5) .Os modificadores mais utilizados são: public: pode ser invocado livremente. inicio leia(v1. + + 4 74 5) . Além desses. Módulo principal (menu) Módulo principal (menu) Módulo principal (menu) Módulo principal (menu) Módulo principal (menu) Solução: a) algoritmo em pseudocódigo inicio opcao:inteiro. entre dois valores fornecidos por ele. /7 Z. 4 +/ ) 8 + + (-) / 9S 7 *7. Chamada de procedimentos A chamada de um procedimento é o momento em que o procedimento é acionado e seu código é executado. final: não pode ser sobrescrito. volatile e synchronized.*7. 109 . a saber: adição. Por exemplo: Integer.v2.

fim. default : System. System. inicio leia(v1.println("3 : Multiplicacao"). escreva (res). break. class Menu{ public static void main(String args[]){ BufferedReader entrada. int opcao = Integer. Procedimento ModAdicao().println("2 : Subtracao"). try{ System.out.fim.out. res = v1 / v2.v2. } }catch(Exception e){ System. casocontrario: escreva('sair do programa').println("Ocorreu algum erro na entrada de dados"). fim.readLine()).res:real.res:real.out. inicio leia(v1. inicio leia(v1. switch (opcao){ case 1 : modAdicao().v2).println("Fim do programa").out.res:real.v2. break. break.*.v2.in)). res = v1 * v2. case 2 : modSubtr(). fim. v1. } } //modulo de adicao 110 . escolha (opcao) caso 1: ModAdicao(). b) programa em Java import java. Procedimento ModMultip(). fim.io. fimescolha.out. System. System.out. //inicio do algoritmo principal leia(opcao). escreva (res). break. System. caso 2: ModSubtr(). res = v1 . entrada = new BufferedReader(new InputStreamReader(System. caso 3: ModMultip().out. Procedimento ModSubtr().v2.v2).parseInt(entrada.v2). escreva (res). case 3 : modMultip(). v1. v1.println("Qual a opcao desejada?").println("1 : Adicao"). case 4 : modDiv(). caso 4: ModDiv().println("4 : Divisao").

in)). float num1 = Float.parseFloat(entraSub. entraMult = new BufferedReader(new InputStreamReader(System. } } //modulo de Divisao static void modDiv(){ BufferedReader entraDiv. System.println("Qual e o primeiro numero?"). float num2 = Float. try{ System. float num2 = Float. float resultado = num1 + num2. float num1 = Float.println("Qual e o primeiro numero?").readLine()). }catch(Exception e){ System.out.readLine()).println("Soma = "+resultado).out. System.out. }catch(Exception e){ System.parseFloat(entraMult. System.parseFloat(entraDiv.readLine()).readLine()). try{ System.out. }catch(Exception e){ System. }catch(Exception e){ System.num2.readLine()).println("Soma = "+resultado).println("Qual e o segundo numero?").out.out.parseFloat(entraSub. entraDiv = new BufferedReader(new InputStreamReader(System. try{ System. float num2 = Float. } } //modulo de Multiplicacao static void modMultip(){ BufferedReader entraMult. System.in)). try{ System.parseFloat(entraSoma. float resultado = num1 / num2. entraSoma = new BufferedReader(new InputStreamReader(System.println("Qual e o segundo numero?").println("Ocorreu algum erro na entrada de dados").println("Qual e o segundo numero?").out. System. 111 .out.println("Qual e o primeiro numero?").println("Ocorreu algum erro na entrada de dados"). pois as funções retornam valores que são associados ao seu nome e para esses valores se faz necessária a declaração do tipo de dado a ser retornado.parseFloat(entraDiv. como se fossem variáveis.readLine()).println("Qual e o segundo numero?").static void modAdicao(){ BufferedReader entraSoma. System.in)).out.println("Soma = "+resultado). float num1 = Float. entraSub = new BufferedReader(new InputStreamReader(System.out.out. A diferença entre eles é que as funções podem ser utilizadas em expressões. System.out. System.parseFloat(entraSoma. float num1 = Float. float resultado = num1 * num2.out.out. float resultado = num1 .in)).readLine()). float num2 = Float.parseFloat(entraMult. } } //modulo de subtracao static void modSubtr(){ BufferedReader entraSub.out.readLine()). } } } H57 46 As funções são criadas e chamadas da mesma maneira que os procedimentos.println("Ocorreu algum erro na entrada de dados").println("Ocorreu algum erro na entrada de dados").println("Qual e o primeiro numero?").println("Soma = "+resultado).out.

U.8 / .4-+ O S 7 *2. fimpara. for(int i= 1. fimse. 4 0).println("Qual o numero? "). 112 . Para resolver este problema. try{ System.readLine()).io.( * 9) . fim.parseInt(entrada.função nome_da_função (lista de parâmetros):tipo_de_dado da função inicio fim. retornar(fatorial).*.i++){ fat *=i. Exemplos: 1) Ler um numero fornecido pelo usuário e calcular o fatorial..i<=numero. i.println("Ocorreu erro na entrada"). int num = Integer. inicio leia(n). } return fat. K93 N. senão para i = 1 ate n-1 faca fat = fat * i. entrada = new BufferedReader(new InputStreamReader(System. existe a possibilidade de serem declaradas variáveis globais. } } S )8 +3 . int fat = fatorial(num).4 ). 79) + 4 1 2. se (n == 0) então fatorial = 1. Solução: a) algoritmo em pseudocódigo função fatorial(n:inteiro):inteiro.fat:inteiro..out. }catch(Exception e){ System. + ) + 74 instruções da função 7.println("fatorial = "+fat).4 ). System.in)). class ExmploFunc1{ public static void main(String args[]){ BufferedReader entrada.0). E 8 D 6 < D 7 6 A utilização de variáveis locais pode ocasionar redundância na declaração de variáveis que se fazem necessárias em vários módulos.out. b) programa em Java import java. fatorial = fat.out.U. } } static int fatorial(int numero){ int fat = 1.

return res.io. * G 6 7 < C Parâmetros são variáveis ou valores que podem ser transferidos do algoritmo principal para um módulo que está sendo chamado.b:real) res:real.b:real) res:real.*. Exemplo: a) algoritmo em pseudocódigo inicio procedimento multiplica*a. escreva(res). Existem dois tipos de parâmetros: os formais e os reais. leia(num1. Já as variáveis locais podem ser utilizadas pelo algoritmo em que foram declaradas e nos algoritmos hierarquicamente inferiores. Parâmetros formais São declarados nos módulos como as variáveis. fim. O algoritmo que chama a função ou o procedimento informa os calores que substituirão esses parâmetros. res = a * b. inicio res = a * b.num2:real. Exemplo: a) algoritmo em pseudocódigo procedimento multiplica*a.num2). multiplicar(num1. b) programa em Java import Java. float b){ float res. inicio res = a * b. O algoritmo que chama a função ou o procedimento informa esses valores ou variáveis. escreva(res).As variáveis globais são declaradas no algoritmo principal e podem ser utilizadas por todos os algoritmos hierarquicamente inferiores. class Multiplicar{ 113 .num2). } Parâmetros reais Os parâmetros reais são os valores que substituem os parâmetros formais. Eles funcionam como comunicadores entre módulos. fim. num1. b) programa em Java static float multiplicar (float a. fim.

readLine()). assim.println(“Qual e o numero 1?”). Os parâmetros podem ser passados por valor ou por referência.out. } public static void imprime(){ //declaracao do metodo imprime System. String frase2 = "feliz porque sei". try{ System. Os argumentos devem ser fornecidos na mesma ordem dos parâmetros.println(“Qual e o numero 2?”). int num1 = Integer.println(“Ocorreu erro na entrada”).println(). ou principal – isto é. entrada = new BufferedReader(new InputStreamReader(System. os objetos (String.métodos EX1) O exemplo abaixo mostra a chamada de um método (imprime) que imprime na tela uma frase qualquer. int num2 = Integer. multiplicar(num1.parseInt(entrada. passagem de parâmetros é a substituição dos parâmetros formais pelos parâmetros reais. toda alteração feita nos parâmetros formais.parseInt(entrada. etc) e os arrays são sempre passados por referência. class ExemploMetodo1{ public static void main(String args[]){ imprime().out.out. preservando. } } EX2) Utiliza-se de um método para imprimir o conteúdo de uma variável qualquer. } } * 77< 6 8 E G 6 7 < : 6 < C A passagem de parâmetros ocorre por meio da correspondência argumento/parâmetro. 114 . o valor do parâmetro é real é copiado para parâmetro formal do módulo. O Java passa o valor da variável quando o método é chamado e quaisquer alterações feitas na variável tornam-se permanentes Passagem de parâmetros por referência Na passagem de parâmetros por referência.out. o valor original do parâmetro. o parâmetro é de entrada e saída. Nota: Na linguagem Java. Exemplos . funcionando da mesma forma como System.num2).out.in)). } } static float multiplicar (float a. } catch(Exception e){ System. class ExemploMetodo2{ public static void main(String args[]){ String frase1 = "Sou muito feliz". String frase3 = "que DEUS me ama!". Passagem de parâmetros por valor Na passagem de parâmetros por valor. float b){ float res. em que os argumentos são valores constantes ou variáveis informadas no módulo chamador. System.public static void main(String args[]){ BufferedReader entrada. return res.println(“Aprendendo a Linguagem Java”). reflete-se nos parâmetros reais: assim. res = a * b.readLine()). Data.

//retorna a soma dos argumentos passados } } 115 . //invoca o método e imprime uma linha em branco tela(frase2).println("Digite apenas caracteres numericos!"). } } EX3) O exemplo abaixo apresenta outra classe com dois métodos que não retornam valores (além do main) em que os métodos são executados em cascata. String frase2 = "feliz porque sei".out. } public static int soma(String num1.out. } public static void tela(String S){ //declaracao do metodo tela System. uma vez que o método main chamará tela que.y=0. tempo(1).parseInt(num1).length==2) System.out.limpaTela(). tela(""). System. tela(frase3). //invoca o metodo para imprimir na tela tela(frase2).println(S). String frase3 = "que DEUS me ama!". //caso houver erro encerra o programa } return(x+y). String num2){ int x=0. chamará tempo. y = Integer.println(S).println("Entre com dois valores inteiros!").start().i<=25. t. por sua vez.out.parseInt(num2). } public static void tempo(int segundos){ //declaracao do metodo tempo try{ Thread t.exit(0). //invoca o metodo para imprimir na tela tela(""). }catch(InterruptedException e){ } } } EX4) O exemplo abaixo demonstra a utilização de um método que recebe duas variáveis tipo String (args[0] e args[1]) e retorna a soma entre elas na forma de número tipo inteiro.out. }catch(NumberFormatException e){ System. class ExemploMetodo3{ public static void main(String args[]){ String frase1 = "Sou muito feliz".println("Resultado = "+ soma(args[0].i++) System. tela(frase3). class ExemploMetodo4{ public static void main(String args[]){ if (args. t = new Thread().println(). //invoca o metodo para limpar a tela tela(frase1).out. } public static void tela(String S){ //declaracao do metodo tela System.args[1])). try{ x = Integer.sleep(segundos*1000). t. tela(frase1). } public static void limpaTela(){ //declaracao do metodo limpaTela for (int i=1. else System.

M<60.out.EX5) O exemplo abaixo mostra a recursividade gerada para imprimir o fatorial dos números inteiros de 0 a 10.int y){ return x*y. } public static long fatorial(long num){ if(num <=1) return 1.limpaTela(). //metodo recursivo de fatorial } } EX6) O exemplo abaixo demonstra um método de mesmo nome sendo declarado três vezes. "+area(3. } public static double area(int x.S. System.S<60. ExemploMetodo2.2. Esses métodos podem ser chamados por outras classes quantas vezes for necessário...out. } } } EX8) Este exemplo traz uma classe chamada Diversos.println("Area de um quadrado . class ExemploMetodo5{ public static void main(String args[]){ for(long i=0. for(H=0.H++) for(M=0. "+area(3.int z){ return x*y*z..out.i++) System. ExemploMetodo3. } public static double area(int x. } } EX7) O exemplo abaixo mostra o uso de métodos de outras classes já desenvolvidas en exemplos anteriores para simular um relógio. } public static double area(int x){ return x*x.int y. ExemploMetodo2.M. class ExemploMetodo7{ public static void main(String args[]){ int H. "+area(3)).println("Area de um retangulo .5)).M++) for(S=0.println(i + "! = "+ fatorial(i)).H<24.out. a) Classe Diversos: 116 .i<=10. isto é.limpaTela().println("Area de um cubo .. class ExemploMetodo6{ public static void main(String args[]){ System. Com o recurso de reaproveitamento de código são criados os packages (pacotes) em Java que agrupam classes de mesma natureza.println("Para encerrar pressione CTRL+C "+H+" h:"+M+" m: "+S+"s").. else return num*fatorial(num-1). em que existem vários métodos específicos à entrada de dados via teclado e cálculos numéricos. System..tempo(1).out. utilizando o recurso de sobrecarga.2)).S++){ System.

float num2){ return (num1-num2).import java. n = -1. if(n < minimo || n > maximo) System. }catch(IOException e){ System.println("Erro na leitura do teclado!"). } public static float soma(float num1. } public static float sub(float num1. try{ while(true){ //loop infinito n = Float. int maximo){ int n =0. } public static String leString(){ String nome ="".println("Entrada fora da faixa permitida!"). //erro de tipo } return (n).out.out.*. //erro de tipo } return (n). float num2){ return (num1*num2). } public static int media(int num1.readLine()). } public static float divisao(float num1.readLine(). try{ while(true){ //loop infinito n = Integer. 117 .println("Digite apenas numeros!").out. class Diversos{ static BufferedReader entrada = new BufferedReader(new InputStreamReader(System. //encerra o loop infinito } }catch(IOException e){ System.println("Entrada fora da faixa permitida!"). float num2){ return (num1+num2).parseFloat(entrada. int num2. float maximo){ float n =0.readLine()).in)). float num2){ return (num1/num2).println("Erro nos dados!").println("Digite apenas numeros!"). } return (nome).parseInt(entrada.out. int num3){ return ((num1+num2+num3)/3). public static float leNumeroFloat(float minimo. } catch(NumberFormatException e){ System. //encerra o loop infinito } }catch(IOException e){ System. n = -1. } catch(NumberFormatException e){ System.io. try{ nome = entrada. else break.out. if(n < minimo || n > maximo) System. else break. } public static int leNumeroInt(int minimo.out.out. } public static float mult(float num1.println("Erro na leitura do teclado!").

Solução: a) algoritmo em pseudocódigo inicio procedimento troca(a. while(n ==-1) //le enquanto o usuario nao digitar um numero n = Diversos.leNumeroFloat(0. System.println("Entre com uma nota de prova"). a = b. l.m.out.out.} public static int quadrado(int num1){ return (num1*num1). b = aux.io.out. System. aux:real. 118 .b:real).leString()). fim.n). int i = -1.3. senao troca(l.5)).3. fimse.out.println("Nota digitada = "+n).println(Diversos.m. escreva(l. while(i ==-1) //le enquanto o usuario nao digitar um numero i = Diversos.n). } } Ex9) Dados três valores distintos. System.println("Entre com uma idade").out. class ExemploFunc9{ public static void main(String args[]){ BufferedReader entrada.m.leNumeroInt(0.5 = "+ Diversos.m).n). se (l > m) ou (l > n) entao se (m < n) entao troca(l. System.println("A media de 1.*.out.150). System.10). } } b) classe UsaDiversos class UsaDiversos{ public static void main(String args[]){ System. inicio aux = a. System.n).media(1.println("Entre com um nome").n:real. fimse.out. fimse. float n = -1. colocá-los em ordem crescente. se (m > n) entao troca(m. leia(l. fim. b) programa em Java import java.println("Idade digitada = "+i).

}catch(Exception e){ System. calcule e escreva o valor de sua diagonal. M e N:").out. Y2. as coordenadas lidas e a área determinada. else troca(L. em caso de contrário. System.parseFloat(entrada.parseFloat(entrada. float L = Float. if((L > M)||(L > N)){ if(M < N) troca(L. float b){ float aux.in)).println("Ocorreu algum erro na entrada de dados"). ara cada registro. se X for igual a algum dos elementos de M ou false.N).println("Os valores ordenados sao: " +L+".parseFloat(entrada. sendo fornecidas as coordenadas X1. dados pelas fórmulas: A p m = M!___ C (M – P) p m = M!___ P! (M – P)! 119 .readLine()). 11) Um valor X.entrada = new BufferedReader(new InputStreamReader(System. "+N). . System.out. Escrever um programa que leia um conjunto de 20 números inteiros.out. Ex12) escrever uma função que calcule a distancia entre dois pontos de um plano. float N = Float.N).readLine()). b = aux.print("L = "). System. } } Ex10) Escrever um programa que leia as medidas das arestas a. Y1. Imprimir. O último para terá o valor zero para M e P. M e P.out. float M = Float. c D L=A +B D = L2 + c 2 2 Ex11) Escrever uma função lógica que receba: 9) Uma variável composta unidimensional M. } System. aux = a. E devolva o valor true. } if(M > N){ troca(M.print("M = "). "+M+".leia vários pares de números inteiros positivos. 10) O número N de elementos de M. try{ System. EX13) Fazer um programa que: . X2.println("Entre com os valores de L.out.readLine()).print("N = ").calcule e imprima o número de arranjos e combinações de M elementos P a P. b e c de um paralelepípedo. a = b.M). Y3 e determine a área do triângulo formado por estes pontos.out. e X3. } } public static void troca(float a. seguido de outro conjunto de 10 números inteiros e determine quais destes 10 números são iguais a um dos 20 primeiros.

o quociente da divisão de X por Y será o próprio divisor Y. Y=4 b) se um número inteiro X possui um divisor Y igual a sua raiz quadrada. Programação de Computadores e Cálculo I. Fazer um programa que. no mínimo. o número de um empregado. Fazer um programa que: . para cada empregado.º período do Ciclo Básico do Instituto de Ciências Exatas da UFMG.calcule. Dois números são primos entre si quando só admitem como divisor comum a unidade. deverão ser lidos.leia um conjunto de linhas contendo. a hora do início (horas. determine e escreva todos os pares de números amigos em um intervalo [A. determinar (utilizando o procedimento da alínea c)quais alunos podem fazer exame especial em cada disciplina. Fazer um procedimento que transforme segundos em horas. a quantas aulas assistiu) por disciplina.imprima. cada uma. Dois números M e N são amigos se a soma dos divisores de M. inteiros maiores que zero. utilizando o procedimento anterior. Exemplo: X = 64 X/Y = 8.imprima. Antes de se elaborar um programa para este problema. utilizando os dois módulos anteriormente definidos.Se M < P. exceto ele próprio. minutos e segundos) e a hora do término (horas. minutos e segundos em segundos. Ex: 2h40min 10s 9610s. conter um procedimento que classifique os elementos de um conjunto de informações de duas grandezas diferentes em ordem crescente de uma delas. é igual a M. 11030 s 3h 3min 50s. minutos e segundos) de uma determinada tarefa. um divisor de X. um par de números inteiros. o seu número e a duração de sua tarefa em horas. cuja nota mínima de aprovação é 60. 40 pontos). 120 . é igual a N e a soma dos divisores de N. minutos e segundos. para cada empregado. além de sua freqüência (ou seja. Exemplo: X = 64 X/Y = 16>V64 e é também. os números primos entre si. o quociente da divisão de X por Y será maior que a raiz quadrada de X. Os valores de A e B (A<B). e será também. num mesmo dia. . Ex. excluindo N. conter um procedimento para calcular e percentagem dos alunos que já foram aprovados (sem exame especial) em uma disciplina. dado um número inteiro N. Ex15) Fazer um programa que calcule o máximo divisor comum entre dois números inteiros (método das divisões sucessivas ou “jogo da velha”). minutos e segundos. Fazer um programa que: . divisor de 64. Ex16) Fazer um procedimento que. excluindo M.B]. retorne a soma dos divisores deste número. . por definição A p m =0 eC p m =0 Ex14) Fazer uma função que transforme horas.leia 50 linhas contendo. . ler o número de matrícula de cada aluno e sua nota final em cada disciplina ( na mesma ordem citada na alínea a ). A última linha (flag) conterá o número do empregado negativo. a duração da tarefa que ele executou. 50 alunos) do !. utilizando o procedimento anterior. O programa deve: • • • • • • ler a freqüência mínima exigida como requisito parcial para a aprovação do aluno em Geometria Analítica. se o aluno é freqüente e obteve. algumas observações se fazem necessárias: a) se um número inteiro X possui um divisor Y menor que sua raiz quadrada.que é igual a V64 Y=8 Ex17) Escrever um programa que emita um relatório e forneça dados estatísticos a respeito de uma turma (no máximo. cada uma. conter um procedimento que verifique se um aluno tem direito de fazer exame especial numa disciplina (isto é. nesta ordem.

a saber:bovinos. m) Necessita-se calcular alguns dados correspondentes aos animais de uma fazenda. substituir por zero todos os valores repetidos (maiores que zero). h) a digitação dos valores no vetor. 8. k) Construa um algoritmo que verifique. 4. Escreva um algoritmo para: • preencher uma matriz A de ordem 3. • criar um menu para acessar os itens anteriores Construa um algoritmo que. com suas notas respectivas. 5.0*(f-32) Crie um aplicativo que faça a contagem regressiva de um número inteiro informado pelo usuário. sem utilizar a função mod. Construa um algoritmo para calcular a média de peso de cada espécie para os animais de sexo feminino e do sexo masculino. • ordenar os elementos da matriz A. o) Faça a leitura de mil números pelo processo de sorteio automático. 6. imprimir a média dos valores fornecidos. Para cálculo do volume deve ser 2 usada a fórmula: volume = (4. Crie um aplicativo que receba uma temperatura qualquer em Farenheit e apresente seu correspondente em Celsius por meio de um método. a partir de dados fornecidos pelo usuário. ovinos e caprinos. Crie um método chamado aleatório que sorteie uma determinada quantidade de números de acordo com um argumento. Controle o tempo com um método tempo() contido em outra classe. I . j) Elabore um algoritmo que escreva por extenso um número inteiro com até dez dígitos fornecido pelo usuário.100)).• • escrever.0)*pi*raio . Os animais pertencem a espécies diferentes. a percentagem de alunos já aprovados. • gerar uma matriz somente com os números múltiplos de 5. 7. O usuário deve informar também o espaço de tempo entre cada contagem (em segundos). utilizando o procedimento da alínea d e a percentagem dos que têm direito ao exame especial. Verifique: 1. Crie uma nova classe para esse método do tempo() ou aproveite do exemplo 3. imprimir o valor do somatório de seus itens. 2. se um número é divisível por outro. • gerar uma matriz somente com os números pares da matriz A. possiblite: 3. i) Faça um algoritmo que possibilite o arredondamento de um número real para um número inteiro seguindo os padrões científicos. Criar um menu para acessar os itens anteriores. para cada disciplina. utilizando o procedimento definido na alínea e. qual foi o número sorteado mais vezes. devem ser gerados quatro números aleatórios entre 1 e 100.0/3. 7 8 I 4 L 6 J 6 <F 8 ? R4 < <F OBS: todos os algoritmo devem ser resolvidos utilizando os conceitos de modularização • • • Crie um aplicativo que receba o raio de uma esfera (do tipo double) e chame o método volumeEsfera para calcular e exibir o volume da esfera na tela. Para o cálculo utilize a seguinte fórmula: Celsius = 5. substituir por zero todos os valores negativos. Ambos devem ser fornecidos pelo usuário. n) Dada uma data abreviada. Os números devem estar entre 0 e 100.. para cada disciplina. o número de matrícula dos alunos que têm condições legais de fazer o exame especial. l) Escreva um algoritmo que calcule o mdc de dois números fornecidos pelo usuário. a partir de um vetor de 100 inteiros. por exemplo: se o usuário informar os argumentos 4 e 100 (aleatório(4.0/9. • • g) Construa um algoritmo que verifique se um dado número é divisível por outro. 121 . escreva-a por extenso. calcular e escrever. em ordem crescente. qual foi o número sorteado menos vezes. O usuário deve informar a quantidade de números a ser gerada e a faixa de números válidos para o sorteio.

Escreva um algoritmo que calcule a somatória dos n primeiros números de um conjunto. • as dezenas apostadas. o CPF de número 23086025620 é validado pelos dígitos verificadores 20. qual foi o maior número. sua nota final. 11) verifique o conceito obtido. recebendo como parâmetro 4 (quatro) números inteiros. Escrever um programa capaz de : • ler um conjunto indeterminado de linhas. quatro ou cinco dezenas sorteadas e ao final. A última linha. conterá o número da aposta igual a zero.conceito F Fazer um procedimento que. para cada aluno. ou “INVÁLIDO”. contendo. 12) escreva. com a nota da prova final. uma para cada aposta. qual foi o menor número. utilizando o procedimento anterior. Por exemplo. a quadra (quatro dezenas sorteadas) e a quina (cinco dezenas sorteadas). inicialmente. o seu número a sua nota final e o seu conceito. 10) calcule. O valor de n deverá ser fornecido pelo usuário.conceito E De 0 a 39 . cada uma. Fazer um programa que: 9) leia um conjunto de 80 linhas contendo. dentre as provas mensais. Construa um algoritmo que identifique se um número é ou não primo.conceito D De 40 a 59 . 4. para cada aluno.conceito C De 60 a 69 . cada uma. o esquema de verificação é o seguinte: • 230860256 2308602562 função função dígito verificador igual a 2 dígito verificador igual a 0 122 . Construa um algoritmo que calcule o somatório dos n primeiros termos da série de Fibonnacci. a seguir. • quantidade de dezenas apostadas (no máximo. o número do aluno as quatro notas mensais e a nota da prova final. Escreva um algoritmo que calcule o número de horas de determinado período estabelecido por duas datas. denominados controle). Construa um algoritmo que calcule a somatória de todos os números primos contidos em um conjunto de n elementos. ler várias linhas. para cada pessoa. 10 ). OBS: Um n° de CPF é validado através de seus dois últimos dígitos (dígitos verificadores. conforme a situação do número de CPF. A avaliação de aproveitamento de uma certa disciplina é feita através de quatro provas mensais no valor de 20 pontos e uma prova final no valor de 40 pontos. O programa deverá ler. O conceito final é dado atendendo-se ao seguinte critério: De 90 a 100 – conceito A De 80 a 89 . a quanti8dade de apostadores que fizeram o terno (três dezenas sorteadas). O valor de n deverá ser fornecido pelo usuário. Fazer um programa para avaliar as apostas da LOTO. Neste programa deverá ser utilizado um procedimento que faça a avaliação do número de pontos de cada aposta. contendo: • número da aposta. o nome de uma pessoa e seu número de CPF (nº de inscrição no Cadastro de Pessoas Físicas) • imprimir.conceito B De 70 a 79 . devolva ao módulo que o chamou a soma dos 3 (três) maiores números dentre os 4 (quatro) números recebidos. as cinco dezenas sorteadas e. O programa deverá escrever o número de todas as apostas que tiverem três. • utiliza e função acima para calcular os dígitos verificadores. • Construir uma função que receba como parâmetro de entrada um número inteiro positivo e devolva um dígito verificador.p) q) r) s) t) u) 3. A nota final é obtida somando-se as três melhores notas. que não entrará nos cálculos. os seus dados de entrada mais a mensagem “VÁLIDO”.

000 linhas contendo. • verifique se as datas estão corretas (1< Mês < 12.Ano.0. entre estas duas datas. fazer um programa que: • leia os dados contidos em 30 linhas. Mês e Ano das duas datas. escrever a palavra lida e a sua tradução. conterá os valores 0. cada uma: • a letra I (indicando inglês) e uma palavra qualquer das 1. duas datas. • escreva este número e a mensagem “Resultado Diário”. e que sempre haverá um único número vencedor. Fazer um programa que: • leia um conjunto de linhas contendo. A última linha. terá a primeira letra diferente de I e P. determine o número que apareceu mais vezes. dados N números. Para cada uma destas linhas. Supor que os valores possíveis de cada número estão entre 1 e 6. cada uma. qual a diferença.000 em português.0. Se algumas das datas não estiver correta. • 2. dependendo do ano ser bissexto ou não. O mês de fevereiro pode ter 28 ou 29 dias. devolvendo a tradução da mesma.Mês. 123 . Sabendo-se que um jogo de dados ocorre 40 vezes por dia e que a cada dia é digitada uma linha contendo os 40 números que saíram.. • escreva este número e a mensagem “Resultado mensal do jogo”. Todo ano bissexto é divisível por 4. • escreva as datas lidas e a diferença entre elas. que será utilizada como flag. correspondentes a um mês de jogo.0.000 em inglês. cujo cabeçalho é dado por QuantosDias (Dia. leia um número indeterminado de linhas contendo. A última linha. se as datas estiverem corretas. Para calcular quantos dias tem no ano até uma data fornecida é preciso verificar o número de dias de cada mês. escreva”Data incorreta” e os valores de Dia. ou • a letra P (indicando português) e uma palavra qualquer das 1. inclusive.0. em dias. Fazer um procedimento. Em seguida. • N é um parâmetro de saída que conterá o número de dias do ano até a data fornecida.0. Mês e Ano são parâmetros de entrada. uma palavra em inglês e a sua tradução em português. • verifique também qual o número ganhador do mês.• Fazer um procedimento que. indicando o fim de dados. • verifique. a letra I ou P e a palavra que se deseja traduzir. dia de acordo com o mês e se ambas estão dentro do mesmo ano). cada uma. N) onde: • Dia. Escrever um programa que leia um conjunto de 1. A tradução da palavra lida deve ser feita através de um procedimento que recebe as listas de palavras em inglês e português.

arquivos. como por exemplo discos rígidos. por um grande período de tempo. Os algoritmos eram limitados conforme a capacidade finita das estruturas de dados utilizadas (registros e/ou vetores). a partir daqui. os arquivos mantidos por uma companhia telefônica a cerca de seus assinantes. Ex1: biblioteca Ficha catalográfica Código do livro: Título: Autor: Assunto: Editora: Ano: Conjunto de Fichas catalográficas Código do livro: Título: Autor: Assunto: Editora: Ano: 124 . Muito comum em nosso cotidiano. portanto. o arquivo tem como finalidade o armazenamento de grandes quantidades de informação. Estudaremos. Os registros. entre outros. 6 H4 8 < = D 7 K F 6 Um arquivo é um local reservado para se guardar informações escritas. como sabemos. Um arquivo é um conjunto de registros (ou seja. produtos e pacientes.= D7 H 84 C F Até então utilizamos variáveis simples para armazenar as informações necessárias à resolução de determinado problema. por exemplo. uma estrutura de dados) no qual cada registro não ocupa uma posição fixa dentro da estrutura. discos flexíveis e CD-ROM. são formados por unidades de informação denominados campos. não possuindo. ou as informações armazenadas na Receita Federal sobre os contribuintes. Estes problemas tinham uma limitação: quantidade de informações que poderia ser armazenada para resolve-los. O arquivo de computador é uma maneira de armazenar informações em meios magnéticos. Um bom exemplo são os arquivos de aço utilizados para armazenar fichas contendo dados de clientes. Esses dados podem ser utilizados diversas vezes pelos programas associados ao arquivo. tamanho preestabelecido. entre outros. como.

4. que tanto o leitor (que consulta o arquivo) quanto o funcionário (que manipula as informações) atuam de forma muito parecida. Percebemos também que os passos 1 e 4 são sempre idênticos em todos os casos. você procura a informação sobre a localização de certo livro através das fichas que registram o acervo. 3. você intenciona manipular (inserir. No caso de ser um leitor. 3. então. 6. 2. Exemplificando. enquanto o passo 2 está sempre relacionado a uma pesquisa. Mesmo as diferentes operações que o funcionário pode desempenhar (inserir. 125 . 2. modificar. 2. Muito embora ainda seja possível perceber algo de comum entre as atividades do passo 3 – todas estão relacionadas ao fluxo de informações -. 3. a diferença está apenas no sentido em que os dados trafegam. Eliminar ou modificar dados) também são muito similares.Item da ficha (campo) Arquivo de aço (arquivo) Ficha (registro) < E ?4 H <F Generalizando. 1. Acrescentar dados Abrir gaveta do arquivo Achar posição da inserção Guardar ficha nova Fechar gaveta do arquivo Eliminar dados Abrir gaveta do arquivo Achar a ficha procurada Retirar a ficha do arquivo Fechar gaveta do arquivo Podemos observar que os algoritmos apresentados são muito semelhantes. sugerir os seguintes algoritmos básicos: Consultar arquivo 1. Entretanto. independentemente de como foi concebido. ou seja. Abrir gaveta do arquivo Achar a ficha procurada Alterar os dados da ficha Fechar gaveta do arquivo 1. você poderia ter apenas dois tipos de atitudes diferentes: 5. 4. Concluímos que podemos consultar e/ou manipular alguma informação no arquivo. o passo 3 é o que parece diferenciar realmente cada uma delas. 4. 2. Abrir gaveta do arquivo Achar a ficha procurada Copiar informações da ficha Fechar gaveta do arquivo Modificar dados 1. diante de um arquivo de livros de uma biblioteca. 4. remover) alguma informação a respeito de algum livro. Como funcionário (da biblioteca). Podemos. 3. podemos admitir que todo arquivo possui maneiras semelhantes de ser manipulado. em alguns casos o fluxo é da pessoa para o arquivo e em outros é do arquivo para a pessoa.

para gravar um novo registro. < 8 <6 7 6 . R e Nome g i s Zé Mané t Maria Xiquinha r o Jurubeba Silva s campos Endereço Rua dos bosque. ocorre por meio de uma campo chave previamente definido. que devem ser legíveis para o usuário. Assim sendo. o usuário deve ler e entender o que deverá ser digitado nos espaços reservados para as informações. Desta forma. tais como: abertura. Para trabalhar com esta técnica. Desta forma.Independentemente do tipo de um arquivo. Os registros por sua vez. direta ou indexada. 77 Os arquivos criados em meios magnéticos podem ser acessados para leitura e/ou escrita na forma seqüencial. leitura e fechamento. Isto implica o fato de que os registros de um arquivo direto possuem um lugar (chave) previamente “reservado” para serem armazenados. Existem dois arquivos: o arquivo índice (arquivo direto) e o arquivo indexado (arquivo seqüencial). o acesso a um registro tanto para leitura quanto para escrita pode ser feito de modo instantâneo. passando este a ser o arquivo indexado. no registro do arquivo indexado. isto é. 126 . o local no qual serão digitadas ou selecionadas as informações. depois basta posicionar de forma direta na página (no caso de um livro) identificada no índice. Acesso direto. 13) Na interface também deve existir um espaço para que o usuário faça a entrada dos dados. por meio da chave. cada linha representa um registro. basta criar um arquivo direto que será o índice de consulta do arquivo seqüencial. E 7 8 <= D 7 6 Arquivo texto As informações de um arquivo texto são organizadas em registros. 247 Av. Cada campo recebe dados que são armazenados no arquivo por meio da associação da variável da interface com o campo do arquivo. Primeiro consulta-se o arquivo índice. Se o registro a ser lido for o último. até localizar a primeira posição vazia após o último registro. passa-se a possuir um vínculo entre um dos campos do registro e sua posição de armazenamento. isto é. Os acessos serão feitos como em um livro. O processo de leitura também ocorre de forma seqüencial. Leste-Oeste. um a após o outro. 15) No arquivo. por meio de um arquivo índice que possui a chave de busca para esse arquivo. como definidos a seguir: Acesso seqüencial. deve existir um campo para cada variável cuja informação deve ser armazenada. 14) No programa. ele tem a capacidade de executar algumas operações em comum. 10 Rua da Gruta. Acesso indexado. é necessário percorrer todo o arquivo a partir do primeiro registro. No arquivo. Conhecido também como randômico. são organizados em campos e nos campos é que são inseridas as informações. deve existir uma variável para cada informação que será digitada na interface. são representados os nomes dos campos. Ocorre quando se acessa de forma direta um arquivo seqüencial. Ocorre quando o processo de gravação e leitura é feito de forma contínua. Um registro é um conjunto de campos. o qual possui a chave de pesquisa. registro a registro. ou seja. um conjunto de informações sobre um determinado assunto. isto é. primeiro é necessário ler todos os registros que o antecedem. 1002 CEP Telefone 69025-952 251-8547 69025-852 542-8756 69054-584 236-8547 12) Na interface. no caso seria o número da página.

por exemplo. mencionando o tipo de arquivo que será utilizado. Nos algoritmos. esse deve ser aberto: Abrir(nome da variável de arquivo) Será disponibilizado o primeiro registro armazenado. Para que seja possível a manipulação do arquivo. ate EOF (agenda). como. utiliza-se uma estrutura de repetição que provoque o avanço pelos registros até o final do arquivo: repita avancar(agenda). endereco: caracter. tipo reg_agenda = registro nome:caracter. auxiliar. arq_agenda: arquivo sequencial de reg_agenda. fimregistro. As variáveis Auxiliar e Agenda são variáveis de registro e de arquivo. agenda:arq_agenda. arq_agenda: arquivo sequencial de reg_agenda. repita avancar(agenda).endereco. fechar(agenda). endereços e telefones. telefone:caracter. endereco: caracter. Esse identificador é associado ao arquivo que será formado pelos registros de reg_agenda. em uma fita cassete. para se chegar ao último registro.auxiliar). telefone:caracter.nome. armazenar(agenda. auxiliar. ate EOF (agenda). passando por todos os registros armazenados.telefone). abrir(agenda). Para acessar os próximos registros. fimregistro. declarar uma estrutura do tipo registro com todos os campos cujas informações pretende-se armazenar. utiliza-se a instrução: Avancar(nome da variável de arquivo) No caso de se desejar que o arquivo seja posicionado no último registro. deve-se. primeiramente. auxiliar:reg_agenda. leia (auxiliar. fim. 127 . Solução: a) algoritmo em pseudocódigo inicio tipo reg_agenda = registro nome:caracter. Nota: Por se tratar de um arquivo seqüencial. respectivamente. É necessário também declarar um identificador do tipo arquivo. percorre-se o arquivo todo.Exemplos – acesso seqüencial: ARQUIVO SEQUENCIAL – OPERAÇÃO DE INCLUSÃO • Construa um agenda que armazene nomes.

Declaração da variável do tipo registro. isto é. 128 . conforme citado no capítulo 4. end