Sebenta

3eoerla da 0|sc|p||ra de lrlroduao a Prograraao
@ Esco|a 3uper|or de Tecro|og|a de 3eluoa| 2001-2005 Pg|ra 1

|nd|ce de Hatr|as

1 - Corce|los 8s|cos de C|rc|as da Corpulaao.................................................................................................... 5
1.1 - Vol|vaao ............................................................................................................................................................ 5
1.2 - Reso|uao de Proo|eras .................................................................................................................................... 5
1.2.1 - Reso|uao de Proo|eras rur Corpulador ...............................................................................................
1.2.2 - Tcr|cas de 0escr|ao de A|gor|lros......................................................................................................... 8
1.2.3 - Cr|aao de A|gor|lros............................................................................................................................... 10
1.3 - 0o A|gor|lro ao Prograra................................................................................................................................ 10
1.3.1 - Represerlaao 0|g|la| da lrlorraao....................................................................................................... 10
1.3.2 - Corporerles de ur Corpulador ............................................................................................................ 11
1.1 - L|rguagers de Prograraao ............................................................................................................................ 13
1.1.1 - Traduao de L|rguagers de Prograraao............................................................................................... 13
1.5 - A L|rguager Java............................................................................................................................................. 11
1.5.1 - Corp||ar ur Prograra er Java............................................................................................................... 11
1. - Exercic|os Prl|cos ............................................................................................................................................ 15
2 - Forra||zaao........................................................................................................................................................ 1
2.1 - Vol|vaao .......................................................................................................................................................... 1
2.2 - 3|rlaxe............................................................................................................................................................... 1
0rarl|ca............................................................................................................................................................. 1
2.3 - 3errl|ca.......................................................................................................................................................... 1Z
Aro|gu|dade 3errl|ca....................................................................................................................................... 1Z
2.1 - Erros 3|rlcl|cos e Erros 3errl|cos ............................................................................................................... 1Z
2.5 - 0el|r|ao de 0rarl|cas (3|rlaxes) .................................................................................................................. 18
2. - Nolaao 8NF..................................................................................................................................................... 18
2.Z - 0|agraras 3|rlcl|cos....................................................................................................................................... 20
2.8 - Exercic|os Prl|cos ............................................................................................................................................ 22
3 - Corce|los 8s|cos de Prograraao .................................................................................................................... 2
3.1 - Eslrulura de ur Prograra ................................................................................................................................ 2
3.2 - lderl|l|cadores ................................................................................................................................................... 2
3.3 - Pa|avras Reservadas ........................................................................................................................................ 2Z
3.1 - 3iroo|os e va|ores ........................................................................................................................................... 2Z
3.5 - var|ve|s............................................................................................................................................................ 28
3. - 0ec|araao e lr|c|a||zaao................................................................................................................................. 28
3.Z - Corslarles ........................................................................................................................................................ 29
3.8 - T|pos de 0ados ................................................................................................................................................. 30
3.8.1 - lrle|ros....................................................................................................................................................... 31
3.8.2 - Rea|s ......................................................................................................................................................... 32
3.8.3 - Caracleres................................................................................................................................................. 33
3.8.1 - Lg|co........................................................................................................................................................ 31
3.8.5 - 0peradores Lg|cos.................................................................................................................................. 31
3.8. - 0peradores Re|ac|ora|s............................................................................................................................ 31
3.9 - lrslruoes.......................................................................................................................................................... 35
3.9.1 - Corerlr|os.............................................................................................................................................. 3
3.9.2 - Paragralaao / lrderlaao........................................................................................................................ 3
3.10 - ur prograra er Java.................................................................................................................................... 3Z
3.11 - Exercic|os Prl|cos .......................................................................................................................................... 38
1 - 3equerc|aao....................................................................................................................................................... 10
1.1 - lrslruao de Alr|ou|ao...................................................................................................................................... 10
1.1.1 - 0peradores de Alr|ou|ao ......................................................................................................................... 10
1.1.2 - 0peradores de lrcrererlo e 0ecrererlo................................................................................................ 11
1.2 - Expressoes........................................................................................................................................................ 11
1.2.1 - Corversoes de T|po .................................................................................................................................. 12

4.3 - C|asse Math e Random .......................................................................................................................... 13
1.3.1 - 8|o||oleca de C|asses................................................................................................................................ 11
1.3.2 - C|asse Math............................................................................................................................................ 11
1.3.3 - C|asse Random....................................................................................................................................... 11
1.1 - Erlrada e 3aida de 0ados ................................................................................................................................ 1
1.1.1 - 3aida de 0ados......................................................................................................................................... 1
1.1.2 - Erlrada de 0ados ..................................................................................................................................... 1Z
1.1.3 - C|asse Le ............................................................................................................................................... 1Z
1.1.1 - C|asse String....................................................................................................................................... 19
1.5 - Exercic|os Prl|cos ............................................................................................................................................ 50
5 - lrslruoes de Corlro|o ......................................................................................................................................... 52
5.1 - 3e|ecao............................................................................................................................................................ 52
5.1.1 - 3e|ecao 3|rp|es: if............................................................................................................................... 52
5.1.2 - 3e|ecao Er A|lerral|va: if-else....................................................................................................... 51
5.1.3 - 3e|ecao Vu|l|p|a: switch - case.................................................................................................. 59
5.2 - Repel|ao .......................................................................................................................................................... 2
5.2.1 - lrslruao de Repel|ao while............................................................................................................... 3
5.2.2 - lrslruao de Repel|ao do-while ....................................................................................................... 5
5.2.3 - lrslruao de Repel|ao for .................................................................................................................... Z
5.3 - Exercic|os Prl|cos ............................................................................................................................................ Z1
- 3uo-Prograras .................................................................................................................................................... Z9
.1 - Proced|rerlos................................................................................................................................................... 80
.2 - Furoes............................................................................................................................................................. 81
.3 - Parrelros........................................................................................................................................................ 82
.1 - Passager de Parrelros ................................................................................................................................. 81
.5 - v|s|o|||dade das var|ve|s.................................................................................................................................. 8
. - Exercic|os Prl|cos ............................................................................................................................................ 88
Z - C|asses e 0ojeclos............................................................................................................................................... 89
Z.1 - 0ojeclos ............................................................................................................................................................ 89
Z.2 - C|asses.............................................................................................................................................................. 90
Z.3 - Alr|oulos ............................................................................................................................................................ 90
Z.1 - Vlodos............................................................................................................................................................. 90
Z.5 - lrslarc|aao de C|asses.................................................................................................................................... 91
Z. - Relererc|ar 0ojeclos......................................................................................................................................... 91
Z.Z - Vlodos e Passager de Parrelros (rev|sao) ................................................................................................ 93
Z.8 - Corslrulores...................................................................................................................................................... 95
Z.9 - 0el|r|ao de Novas C|asses.............................................................................................................................. 9Z
Z.10 - var|ve|s de C|asse......................................................................................................................................... 98
Z.11 - var|ve|s de lrslrc|a ..................................................................................................................................... 99
Z.12 - 0 0perador de Aulo-Relererc|aao this .................................................................................................... 99
Z.13 - Exercic|os Prl|cos ........................................................................................................................................ 100
8 - Recurs|v|dade..................................................................................................................................................... 103
8.1 - 0el|r|oes........................................................................................................................................................ 103
8.2 - Exercic|os prl|cos .......................................................................................................................................... 105
9 - Taoe|as............................................................................................................................................................... 10
9.1 - Vol|vaao ........................................................................................................................................................ 10
9.2 - Taoe|a ur|d|rers|ora| .................................................................................................................................... 108
9.2.1 - var|ve|s 3|rp|es e do l|po laoe|a .......................................................................................................... 108
9.2.2 - Passos para ul|||zar ura laoe|a .............................................................................................................. 108
9.2.3 - Acesso a e|ererlos rao ex|slerles........................................................................................................ 112
9.3 - Passager de laoe|as coro parrelros de rlodos ..................................................................................... 112
9.1 - 1.1 - Taoe|a Vu|l|d|rers|ora| ......................................................................................................................... 113
9.5 - Taoe|as de 0ojeclos........................................................................................................................................ 111
9. - C|asse Vector............................................................................................................................................. 120

9..1 - lrlroduao ............................................................................................................................................... 120
9..2 - A|gurs rlodos da c|asse Vector...................................................................................................... 120
9.Z - Exercic|os Prl|cos .......................................................................................................................................... 122
10 - A|gor|lros de Procura/Pesqu|sa................................................................................................................... 125
10.1 - lrlroduao...................................................................................................................................................... 125
10.2 - Procura 3equerc|a| ....................................................................................................................................... 125
10.2.1 - 3|rp|es.................................................................................................................................................. 125
10.2.2 - Cor 3erl|re|a....................................................................................................................................... 12Z
10.3 - Procura 8|rr|a.............................................................................................................................................. 128
10.1 - Exercic|os prl|cos ........................................................................................................................................ 130
11 - A|gor|lros de 0rderaao.............................................................................................................................. 132
11.1 - lrlroduao...................................................................................................................................................... 132
11.2 - 8uoo|e3orl ..................................................................................................................................................... 133
11.3 - 3re||3orl ........................................................................................................................................................ 135
11.1 - 0rderaao por se|ecao ............................................................................................................................... 13Z
11.5 - A|gor|lro 0u|c|3orl....................................................................................................................................... 138
11. - Exercic|os prl|cos ........................................................................................................................................ 110
12 - Arexo l - C|asse Le.java............................................................................................................................... 111
13 - Arexo ll - 0|ossr|o...................................................................................................................................... 11Z
11 - Arexo lll - 8|o||ogral|a ................................................................................................................................... 119

Nota: Ao |orgo da |e|lura desle docurerlo, serpre que rao erlerder o s|gr|l|cado de delerr|rado lerro, por lavor
d|r|ja-se ao g|ossr|o que apreserlado er arexo para descoor|r ura possive| del|r|ao para o resro.
Caso rao esleja | del|r|da a pa|avra que procura, rao res|le er quesl|orar os co|egas ou prolessores para re|ror
l|car esc|arec|do.
Ao rol|l|car o prolessor eslar laror a corlr|ou|r para re|ror|as luluras ro docurerlo, po|s rovas pa|avras poderao
ser ad|c|oradas ao g|ossr|o que poss|ve|rerle esc|arecerao oulros co|egas cor duv|das sere|rarles a sua.

Esle docurerlo, para a|r de ler s|do e|aoorado pe|os prolessores j rerc|orados, corla cor a parl|c|paao dos
docerles da cade|ra de lP dos aros |ecl|vos de 2000/2001 al 2003/2001, v|slo lerer s|do ul|||zados os respecl|vos
acelalos coro relerrc|a para a|gurs dos corleudos aqu| ul|||zados.

1 - Conceitos Bsicos de Cincias da Computao
1.1 - Motivao
Nas soc|edades roderras lodos os seclores de acl|v|dade deperder d|recla ou |rd|reclarerle do apo|o dos
corpuladores.

0 lurc|orarerlo dos corpuladores deperde da corjurao do larouare, corporerles lis|cos, e do $olruare,
|rslruoes que os corpuladores dever execular. Pode d|zer-se que os prograras lorrecer correc|rerlos e
eslralg|as de reso|uao de proo|eras. A prograraao a 'arle de ara||sar ur proo|era e ercorlrar ura sequrc|a
de acoes (ur a|gor|lro) capaz de o reso|ver correclarerle.
1.2 - Resoluo de Problemas
0 oojecl|vo de ur prograrador, quardo escreve ur prograra, o de reso|ver ur ou ra|s proo|eras. Ass|r, o
passo lurdarerla| ra cr|aao de ur prograra a del|r|ao de ur a|gor|lro. Corlrar|arerle ao que se possa
persar, ra ra|or|a das vezes, a pr|rc|pa| d|l|cu|dade rao res|de ra s|rlaxe ou ra serrl|ca da ||rguager de
prograraao ul|||zada, ras s|r ra procura de so|uoes para o proo|era er causa.

ur a|gor|lro pode ser del|r|do coro ur corjurlo l|r|lo de |rslruoes oer del|r|das e rao aroiguas, que execuladas
por ura delerr|rada order reso|ver ur proo|era.

Para que se possa ercorlrar ura ooa so|uao para ur proo|era, recessr|o corear pe|a sua corpreersao. Er
segu|da, o proo|era deve ser ara||sado ro serl|do de procurar so|uoes para o resro. 0uardo se laz a ar||se de
ur proo|era |rporlarle cors|derar lrs corporerles:
eslado |r|c|a|, |slo qua|s os dados de erlrada do proo|era;
a lrarslorraao, que espec|l|ca os passos recessr|os para lrarslorrar o eslado |r|c|a| ro eslado l|ra|;
eslado l|ra|, ou seja, o que se prelerde ooler coro resu|lado.

Vu|los dos erros dos prograradores sao causa de ura del|c|erle corpreersao e ar||se do proo|era.
A reso|uao de proo|eras ura larela, para a qua| rao r rece|las rer lorru|as po|s cada proo|era ur caso
d|lererle, la| coro poder ser |rureras as so|uoes que o reso|ver. uras serao ra|s correclas ou lerao re|ror
deserperro que oulras, uras a|rda serao ra|s ou reros exausl|vas; caoe-ros a rs, coro prograradores, saoer
aver|guar qua| das so|uoes ercorlradas se adequa re|ror as recess|dades da larela que leros er raos.

Exemp|o:

varos supor que leros coro larela reso|ver o proo|era da corlecao de ur oo|o.
Ara||sardo ludo o que recessr|o para curpr|r cor essa larela e lerdo er corla os passos alrs rerc|orados,
qua|s sao os passos a segu|r?

Estado |n|c|a|: |rgred|erles
Transformao: processo de corlecao do oo|o (A|gor|lro)
1. Misturar ingredientes
1.1 8aler a rargar|ra e o aucar al ooler ur crere;
1.2 Ad|c|orar os ovos
1.3 Jurlar a lar|rra e o lerrerlo;
1.1 Co|ocar a rassa rura lorra
2. Cozinhar o bolo
2.1 Aquecer o lorro a lerperalura desejada

@ Esco|a 3uper|or de Tecro|og|a de 3eluoa| 2001-2005 Pg|ra
2.2 Co|ocar ro lorro e esperar que o oo|o esleja coz|do
Estado f|na|: ur oo|o

Al|ra| rao s ra prograraao de corpuladores que poderos ap||car a|gur rlodo ou l|po de rac|ocir|o para
reso|ver proo|erasl
Aqu| v|ros ap||cada a ur caso da v|da quol|d|ara exaclarerle a resra order de persarerlo que |reros segu|r
daqu| por d|arle ra |rp|ererlaao de prograras de corpuladores.
1.2.1 - Resoluo de Problemas num Computador
0uardo se corceoer a|gor|lros para serer lrarslorrados er prograras |rporlarle expr|r|-|os ul|||zardo acoes
que o corpulador seja capaz de execular:

Receoer e lorrecer |rlorraao
0uardar |rlorraao para posler|or ul|||zaao
0peraoes ar|lrl|cas
0peraoes |g|cas
Esco|rer erlre vr|as acoes (se|ecao)
Repel|r ur grupo de acoes (repel|ao)

ur a|gor|lro deve ver|l|car o segu|rle:

0escrever lodas as lrarslorraoes recessr|as para reso|ver o proo|era, lazerdo-o er lerros que
possar ser execulve|s pe|o corpulador
3er rao aroiguo (qua|quer pessoa que o execule oolr os resros resu|lados)
Para ur resro corjurlo de dados deve produz|r serpre os resros resu|lados (se cor os resros
|rgred|erles, ras resras quarl|dades l|vsseros oo|os d|lererles a|go de errado se l|rra passado,
correclo?)
Produzir resultados correctos, qualquer que seja o conjunto de dados legtimos utilizado.
Exemplos:

Exemplo 1: Elaborar um algoritmo que calcule a rea total das paredes de uma caixa de seco
rectangular a partir das suas dimenses.

Estado |n|c|a|: corpr|rerlo, |argura, a|lura
Transformao: Ca|cu|ar as reas da oase e |alera|s e ca|cu|ar a rea da ca|xa
Estado f|na|: rea da ca|xa

A|gor|tmo:

L corpr|rerlo
L |argura
L a|lura

Area_oase = corpr|rerlo |argura
Area_|alera|1 = corpr|rerlo a|lura
Area_|alera|2 = |argura a|lura
Area_ca|xa = 2 Area_oase 2 Area_|alera|1 2 Area_|alera|2

Escreve Area_ca|xa

Exerp|o 2: ura |oja verde l|ores, olerece aos l|or|slas |serao de |rposlo e descorlo (corpras < C50 - 2, C50 <
corpras < C250 - 5 e corpras > C250 - 10) os oulros corpradores rao lr descorlo e pagar ur |rposlo de

@ Esco|a 3uper|or de Tecro|og|a de 3eluoa| 2001-2005 Pg|ra Z
. 0eservo|va ur a|gor|lro para, aps a rea||zaao de ura corpra, delerr|rar, a parl|r da |rporlrc|a ca|cu|ada,
quarlo que cada c||erle ler elecl|varerle de pagar.

A|gor|tmo:

L despesa
L l|po_c||erle

3e l|po_c||erle puo||co erlao
lola|_a_pagar = despesa despesa 0,0
3erao
3e despesa < 50 erlao
descorlo = 0,02
3erao
3e despesa < 250 erlao descorlo = 0,05
3erao descorlo = 0,1
F|r_3e
Tola|_a_pagar = despesa - despesa descorlo
F|r_3e
Escreve lola|_a_pagar

Exerp|o 3: Ca|cu|ar a sora dos pr|re|ros 100 rureros |rle|ros pos|l|vos

A|gor|tmo:

A 3ora lorra-se 0
0 Nurero lorra-se 1
repel|r
A 3ora lorra-se 3oraNurero
0 Nurero lorra-se Nurero1
al que o Nurero seja ra|or do que 100

ou

3ora=0
Nurero=1
repel|r
3ora= 3oraNurero
Nurero=Nurero1
al que Nurero > 100

Exerp|o 1: E|aoorar ur a|gor|lro que ca|cu|e a rd|a de ur corjurlo de rureros |rle|ros que se saoe lerr|rar cor
ur rurero regal|vo

A|gor|tmo:

sora=0
rurs=0
Le va|or

Erquarlo (va|or >=0)
sora= sorava|or
rurs=rurs1
Le va|or

F|r_Erquarlo
3e rurs=0
Escreve 'Corjurlo vaz|o
3erao
red|a=sora/rurs
Escreve red|a
F|r_3e
1.2.2 - Tcnicas de Descrio de Algoritmos
0s a|gor|lros rao sao d|reclarerle execulve|s pe|o corpulador, a lorra coro sao descr|los ur pouco ||vre,
a|rda que deva ser sul|c|erlererle exacla para que rao raja qua|quer aro|gu|dade.

ura rare|ra de descrever a|gor|lros usardo pseudocd|go (corsu|lar os exercic|os arler|ores). 0 pseudocd|go
ur cd|go de escr|la er que se ul|||zar lerros corverc|ora|s para |rd|car as |rslruoes do prograra; esses
lerros sao gera|rerle ur r|slo de pa|avras da rossa ||rguager ralura| cor pa|avras e rolaoes lip|cas das
||rguagers de prograraao. A ul|||zaao de pseudocd|go perr|le ao prograrador expressar as suas |de|as ser ler
de se preocupar cor a s|rlaxe da ||rguager de prograraao. 0s a|gor|lros poder laror ser descr|los ul|||zardo
f|uxogramas. 0s l|uxograras sao d|agraras represerlal|vos do l|uxo de acoes de ur prograra, alravs de
siroo|os, que represerlar os d|lererles l|pos de acoes e seu ercadearerlo ra sequrc|a do prograra (ver l|gura
aoa|xo).

F|gura 1. Represerlaao grl|ca de ur a|gor|lro.

Processarerlo er gera|

Le|lura/Escr|la de 0ados

lrc|o/F|r de processarerlo

L|rra de l|uxo


0ec|sao cord|c|ora|

Esco|ra ru|l|p|a

3uoprograra

F|gura 2. Pr|rc|pa|s siroo|os ul||zados ros l|uxograras.

Aclua|rerle os l|uxograras rao sao elecl|varerle ru|lo ul|||zados. 0s l|uxograras la|vez possar ser ule|s para
ajudar a v|sua||zar re|ror delerr|radas eslruluras lip|cas de prograraao. Vas, para represerlar prograras de
rd|a e grarde exlersao, lorrar-se d|lice|s de corcrel|zar.

F|gura 3. Exerp|o de ur l|uxograra.

lric|o
lric|o
Ler va|or 1
Ler va|or 2
va|or 1 > va|or 2
Escrever
va|or 1 ra|or
3|r
va|or 1 < va|or 2
3|r
Nao
Escrever
va|or 2 ra|or
Escrever
va|ores |gua|s
Nao
F|r

Escrever 'lrlroduza do|s rureros
Ler va|or 1
Ler va|or 2
3e va|or1 > va|or 2 erlao
Escreve va|or1 ' ra|or
3erao
3e va|or1 < va|or 2 erlao
Escreve va|or2 ' ra|or
3erao
Escreve 'va|ores |gua|s
F|r_3e
F|r_3e
F|r

F|gura 1. Exerp|o da l|gura 3 escr|lo er pseudocd|go.

A ul|||zaao de pseudocd|go ler a varlager de poderros ul|||zar ur lexlo escr|lo dessa lorra coro oase para a
escr|la de ur prograra, rao aperas rura delerr|rada ||rguager de prograraao, ras er qua|quer oulra, ser ler
de se e|aoorar ur rovo a|gor|lro.

0ulra varlager da escr|la de a|gor|lros er pseudocd|go que esla lorra de aoordager presla-se a ura
aprox|raao sucess|va a versao l|ra| do prograra, ou seja, pode-se |r progred|rdo por lases, reverdo o
pseudocd|go e suosl|lu|rdo-o progress|varerle por lerros e s|ra|s prpr|os da ||rguager de prograraao.
1.2.3 - Criao de Algoritmos
A cr|aao de a|gor|lros lurdarerla| ro deservo|v|rerlo de prograras de corpulador. 0uardo se lrala de
prograras corp|exos, surger d|l|cu|dades ad|c|ora|s dev|das a quarl|dades de aspeclos que recessr|o
cors|derar ro rorerlo. A corp|ex|dade larlo pode ser gerada pe|a d|rersao, coro pe|a d|l|cu|dade do proo|era a
reso|ver.
ura lcr|ca ul|||zada a correc|da coro 'aoordager do lopo para a oase (aoordager Top-0oun), por parl|r de
ur proo|era gera| e procurar cregar aos dela|res. Nesla aoordager o proo|era corp|exo d|v|d|do er proo|eras
ra|s s|rp|es e procura-se so|uoes para esses proo|eras ra|s s|rp|es.
Ex|sle laror a aoordager corlrr|a, ape||dade de 3orrom-up que parle da oase para o lopo, ou seja, parl|rdo de
proo|eras pequeros, v|sua||zar a so|uao para a|go ra|s arp|o e ra|s gerr|co.
Pode al ul|||zar-se ur r|slo deslas duas aoordagers, desde que ro l|r cors|garos al|rg|r ura ooa so|uao para o
proo|era.
Er qua|quer ura de|as esl |rererle ur corce|lo que a oase de reso|uao de qua|quer proo|era: a d|v|sao er
e|ererlos de so|uao ra|s s|rp|es, que lraoa|rardo er corjurlo ros lazer cregar a so|uao que ros |rleressa.
lrdeperderlererle do serl|do er que procuraros a so|uao, eslaros serpre a ul|||zar ura lcr|ca que se crara
'0|v|oe ano 0onquer

, ou seja, d|v|d|r para corqu|slar. N|rgur garra ura corr|da s porque dec|de garrar, ler de
correr as elapas lodas ura por ura cor o oojecl|vo de ro l|r ler corsegu|do ura rd|a de lerpos |rler|or a dos
oulros corredoresl
1.3 - Do Algoritmo ao Programa
1.3.1 - Representao Digital da Informao
0s corpuladores arrazerar e processar loda a |rlorraao, ul|||zardo o s|slera de rureraao |nr|o. 0 s|slera
de rureraao o|rr|o ur s|slera de do|s eslados. A ur|dade os|ca desle s|slera o o|r, que pode assur|r
aperas do|s eslados d|sl|rlos, represerlados pe|os va|ores 0 e 1.
0oserveros a laoe|a segu|rle:

Num. 0ec|ma| 1 b|t 2 b|ts 3 b|ts


Coro poderos ver|l|car ra laoe|a N o|rs represerlar 2
N
|lers d|sl|rlos. 0uer-se cor |slo d|zer, cor 1 o|l
corsegu|ros represerlar 2
1
= 2 rureros, cor 2 o|ls corsegu|ros represerlar 2
2
= 1 rureros d|sl|rlos, cor 3 o|ls
represerlar-se 2
3
= 8 rureros, e ass|r sucess|varerle.
A corversao de rureros do s|slera o|rr|o para o s|slera dec|ra| laror s|rp|es, vejaros o segu|rle exerp|o:

111 = 1*2
2
+ 1*2
1
+ 1*2
0
= 7
101 = 1*2
2
+ 0*2
1
+ 1*2
0
= 5

0o s|slera dec|ra| para o s|slera o|rr|o, oasla lazer d|v|soes sucess|vas por do|s e aprove|lar o reslo da d|v|sao
|rle|ra:

7 / 2 = 3 e o resto da diviso 1

0s corpuladores arrazerar dados er sr|es de 8 o|rs, deror|rados o,res.
Corsoarle o rurero de o|ls ou de oyles poderos dar rores d|lererles as ur|dades (a sere|rara do que acorlece
ro s|slera rlr|co cor relros, decirelros, cerlirelros, elc.). vejaros a laoe|a segu|rle:

Un|dade 6onverso 8|mbo|o 8|
1 bit N/A b
1 byte 8 bit B
1 Kilobyte 1024 byte KB
1 Megabyte 1024 Kilobyte MB
1 Gigabyte 1024 Megabyte GB

Ex|sler oulros s|sleras de rureraao para a|r do dec|ra| e do o|rr|o, la|s coro o ocla| e o rexadec|ra|, por
exerp|o.
1.3.2 - Componentes de um Computador
ur corpulador ler ura parle lis|ca (narouare), corsl|luida pe|o ror|lor, lec|ado, ralo, rerr|a elc., e ura parle
rao lis|ca (solruare), corsl|luidas pe|os prograras.

0 0 00 000
1 1 01 001
2 10 010
3 11 011
1 100
5 101
110
Z 111
... ... ... ...


F|gura 5. Corporerles de ur corpulador.

0 corporerle ra|s |rporlarle do corpulador a ur|dade erlra| (CPu - 0enrra| Process|ng un|r). A lurao os|ca
do CPu ooler, |rlerprelar e execular |rslruoes, ura de cada vez. Esla ur|dade execula corl|ruarerle ur c|c|o
que cors|sle ros passos segu|rles:

Aqu|s|o (oolerao de ura |rslruao)
0escod|f|cao (delerr|raao do l|po de |rslruao)
Execuo (execuao da |rslruao).

0 CPu corsl|luido por:

F|gura . Corporerles da CPu.

0ulro e|ererlo lurdarerla| a rerr|a cerlra|, laror correc|da por RAV (Ranoom /ccess Vemor,). E ura
rea de arrazerarerlo de |rlorraao que apreserla as segu|rles caraclerisl|cas:
Perde o corleudo quardo se des||ga o corpulador - rerr|a vo|l||;
Pode ser |rag|rada coro sucessao de c|u|as (ver l|gura aoa|xo);
Cada c|u|a de rerr|a arrazera ur ur|co va|or;
0uardo se escreve ur rovo va|or rura c|u|a de rerr|a, perde-se o va|or que arler|orrerle | eslava;
ur|dade Corlro|e
0elerr|ra a prx|ra |rslruao a ser
execulada (corlro|a lodos os passos do
processarerlo)
ur|dade Ar|lrl|ca/Lg|ca
Eleclua c|cu|os (ad|ao, suolraao e oulras
operaoes ar|lrl|cas, oer coro a
corparaao de va|ores) e lora dec|soes
Reg|slos
Pequero rurero de reg|slos cor grarde
ve|oc|dade de acesso, para arrazerarerlo
de resu|lados lerporr|os
Per|lr|cos
0e Erlrada

ur|dade
Cerlra| de Processarerlo
(CPu)
Per|lr|cos
0e 3aida
Verr|a
Pr|rc|pa|
Verr|a
3ecurdr|a

A capac|dade da rerr|a expressa ro rurero de oyles que e|a corsegue arrazerar: k||oo,res (K8 -
1021 o,res), megao,res (V8 - 1021 K8 ou 1021000 o,res), g|gao,res (08 - 1021 V8 ou 1021000000
o,res)

3upordo que lirraros ura rerr|a RAV de 1V8 (1 Vegaoyle), e que cada c|u|a da rerr|a ler ura d|rersao
de 1K8 (1 K||ooyle), a sua represerlaao grl|ca poder|a ser a segu|rle (er que os rureros aoa|xo da laoe|a de
c|u|as represerlar os ird|ces que |derl|l|car cada c|u|a. C|u|a rurero 1, 2, ... 25, elc):

z a 12 x
0 1 2 3 ... 256 ... 512 ... 1024

F|gura Z. Represerlaao grl|ca da rerr|a cerlra| de ur corpulador (RAV)

Para a|r da CPu e da rerr|a cerlra|, ex|sler d|versos l|pos de d|spos|l|vos que perr|ler a corur|caao erlre o
corpulador e o ul|||zador, coro por exerp|o:

d|spos|l|vos de erlrada: lec|ado, ralo;
d|spos|l|vos de saida: ror|lor, |rpressora;
d|spos|l|vos de erlrada/saida: roder.

0 arrazerarerlo perrarerle da |rlorraao, corsegu|do er d|spos|l|vos de arrazerarerlo securdr|o:
Arrazr de dados ||gado a rerr|a pr|rc|pa|
Varlr o corleudo resro cor o corpulador des||gado - rerr|a rao vo|l|| - arrazerarerlo
perrarerle (laror se d|z pers|slerle) da |rlorraao

Esles d|spos|l|vos de arrazerarerlo securdr|o pers|slerle sao os 0|scos rig|dos, d|squeles, C0-Rors, 0v0s,
F|asr0r|ves, carloes de rerr|a usados ras rqu|ras lologrl|cas d|g|la|s, erlre oulros.
1.4 - Linguagens de Programao
Para que ur corpulador possa execular delerr|rada larela, recessr|o que |re seja lorrec|do ur prograra. 0s
prograras sao escr|los ul|||zardo ||rguagers de prograraao.

l d|versos rive|s de ||rguager de acordo cor as al|r|dades que apreserlar cor as ||rguagers ruraras:
L|nguagens Hqu|na: sao ul|||zadas para corardar d|reclarerle asa acoes do corpulador. As
|rslruoes sao corsl|luidas por 0s e 1s, e rar|pu|ar d|reclarerle erl|dades derlro do corpulador.
L|nguagens Assemb|y: sao ||rguagers cor caraclerisl|cas sere|rarles as das de rqu|ra, d|ler|rdo
aperas por usarer rores s|ro||cos er vez de sequrc|as de 0s e 1s.
L|nguagens de A|to N|ve|: sao ||rguagers ra|s prx|ras das ||rguagers ruraras e, por |sso, sao ra|s
lce|s de ul|||zar do que as oulras.
l ru|las ||rguagers que se poder |rc|u|r resla calegor|a: C, Pasca|, L|sp, Pro|og, C e Java.
1.4.1 - Traduo de Linguagens de Programao
ur prograra lorrec|do ao corpulador para que esle o possa execular. No erlarlo, os corpuladores s erlerder
||rguager rqu|ra, pe|o que recessr|o proceder a lraduao do prograra. Para elecluar essa lraduao ul|||zaros
comp||adores. 0s corp||adores sao prograras que lazer a lraduao do cd|go lorle (escr|lo rura ||rguager de
a|lo rive|) para cd|go execulve| (er ||rguager rqu|ra).

A pr|re|ra lurao dos corp||adores ver|l|car se o cd|go lorle que |re lorrec|do curpre as regras s|rlcl|cas da
||rguager er causa e ass|ra|ar os erros que everlua|rerle ex|slar, deror|rados por erros de comp||ao. Aos
erros que ocorrer durarle a execuao do prograra e que rao poder ser deleclados durarle a corp||aao d-se o
rore de erros de execuo.


ur prograra ser erros de corp||aao rao s|gr|l|ca recessar|arerle que lurc|ore coro era desejado. Pode ler
erros serrl|cos (ou seja, erros |g|cos, der|vados de ur rac|ocir|o errado que |evou a ura so|uao laror
|rcorrecla). Nesle caso, lereros de proceder a ura rev|sao do cd|go e rovos lesles para que os erros sejar
reso|v|dos.
1.5 - A Linguagem Java
JAvA ura ||rguager de prograraao or|erlada a oojeclos, deservo|v|da pe|a $un V|cros,srems. Esla ||rguager
resu|lou da |de|a de cr|ar ura ||rguager que pudesse ser execulada er qua|quer l|po de corpulador.
1.5.1 - Compilar um Programa em Java
ur dos oojecl|vos pr|rc|pa|s do deservo|v|rerlo do Java era a poss|o|||dade de ur prograra escr|lo resla ||rguager
ser execulado er qua|quer l|po de corpulador ser ler de ser a|lerado ou corp||ado rovarerle. No erlarlo, esle
oojecl|vo rao pode ser al|rg|do cor a ul|||zaao de corp||adores lrad|c|ora|s.

Esle proo|era l|ca reso|v|do cors|derardo ur corpulador v|rlua| que se |rag|ra capaz de execular ur cd|go
corsl|luido por |rslruoes s|rp|es. 0 comp||ador Java rao gera cd|go execulve| ra|s s|r o,recooe, ur cd|go
que |rdeperderle do corpulador er que seja execulado. Esse cd|go ler de ser |rlerprelado pe|a crarada
Hqu|na V|rtua| Java, que ur prograra er execuao ro corpulador e que resporsve| por execular prograras
Java.
Ex|sler versoes d|lererles desla Vqu|ra v|rlua| para d|lererles s|sleras operal|vos (w|rdoWs, ur|x, L|rux, 3o|ar|s,
Vac03, elc).

A l|gura segu|rle descreve o processo de cr|aao, corp||aao e execuao de ur prograra er Java.

Cd|go Forle Java
Corp||ador Java
Vqu|ra v|rlua| Java
(JvV, lrlerprelador Java)
8ylecode Java
Execuo
Traduo
0 'cd|go-lorle, quardo passa pe|o corp||ador,
lrarslorrado rur corjurlo de
o,res lorralados - des|grados de o,recooes.
Nesla lase rao se lrala a|rda de 'cd|go-rqu|ra,
ras s|r de ur cd|go |rlerrd|o.
0s o,rescooes rao poder ser execulados
d|reclarerle ros d|versos processadores.
3ao recessr|os |rlerpreladores, essa |rlerprelaao
le|la pe|a JvV (Java v|rrua| Vacn|ne).
Cd|go Forle Java
Corp||ador Java
Vqu|ra v|rlua| Java
(JvV, lrlerprelador Java)
8ylecode Java
Execuo
Traduo
0 'cd|go-lorle, quardo passa pe|o corp||ador,
lrarslorrado rur corjurlo de
o,res lorralados - des|grados de o,recooes.
Nesla lase rao se lrala a|rda de 'cd|go-rqu|ra,
ras s|r de ur cd|go |rlerrd|o.
0s o,rescooes rao poder ser execulados
d|reclarerle ros d|versos processadores.
3ao recessr|os |rlerpreladores, essa |rlerprelaao
le|la pe|a JvV (Java v|rrua| Vacn|ne).

F|gura 8. Processo de cr|aao, corp||aao e execuao de ur prograra er Java.

A ul|||zaao do cd|go |rlerrd|o ler a varlager de perr|l|r aos corpuladores cr|ar prograras que poder ser
execulados er qua|quer l|po de corpulador, ser que lerrar que se preocupar cor as suas espec|l|caoes. 0esde
que esse corpulador lerra a rqu|ra v|rlua| corresporderle |rsla|ada, qua|quer prograra Java poder ser |
execulado.


Para cr|ar prograras er Java recessr|o ler |rsla|ado ro corpulador, pe|o reros o Java $ranoaro Eo|r|on
$olruare 0eve|opmenr r|r (J23E 30K) |rsla|ado ro corpulador.
1.6 - Exerccios Prticos
Escreva ur a|gor|lro para reso|ver cada ur dos segu|rles proo|eras.

Exerc. 1: ver|l|car se ur rurero se ercorlra erlre 1 e 10.

Exerc. 2: 0ado ur va|or de lerperalura, er graus Ce|s|us, Farerre|l ou Ke|v|r, corverler esse va|or para as
reslarles ur|dades. (Nola: C = (F-32)5/9; K = C2Z3.15)

Exerc. 3: 3orar ur corjurlo de 100 rureros |rle|ros.

Exerc. 1: 0elerr|rar o resu|lado de ura expressao ralerl|ca que ul|||ze os operadores: e -

Exerc. 5: Ca|cu|ar o perirelro e a rea de ura l|gura georlr|ca, saoerdo que a l|gura s pode ser ur reclrgu|o
ou ura c|rcurlerrc|a.

Exerc. : Procurar ura rola de ur a|uro rura paula, alravs do seu rurero

Exerc. Z: 0escoor|r ur rurero erlre 0 e 1000, persado por ur co|ega. Aps ler acerlado |rlorrar o co|ega do
rurero de lerlal|vas elecluadas.

Exerc. 8: 0elerr|rar se o rurero pr|ro.

Exerc. 9: 0elerr|rar a d|lerera de d|as erlre duas dalas qua|squer.

2 - Formalizao
2.1 - Motivao
0uardo se esluda ura ||rguager lurdarerla| que se erlerda a lorra da ||rguager e o s|gr|l|cado assoc|ado a
lorra. Esles do|s aspeclos sao deror|rados, respecl|varerle, a s|rlaxe e a serrl|ca da ||rguager.

Ao esludar ura ||rguager de prograraao, esserc|a| que se corpreerda a sua s|rlaxe e a sua serrl|ca. A
s|rlaxe delerr|ra a lorra das |rslruoes a lorrecer ao corpulador, e a serrl|ca va| delerr|rar o que o corpulador
va| lazer ao execular cada ura das |rslruoes. Ass|r, ura ||rguager caracler|zada pe|a s|rlaxe (lorra da
||rguager) e pe|a serrl|ca (s|gr|l|cado assoc|ado a lorra).
2.2 - Sintaxe
A 3|rlaxe de ura ||rguager o corjurlo de regras que del|re as re|aoes v||das erlre corporerles da ||rguager,
la|s coro pa|avras e lrases. A s|rlaxe rada d|z er re|aao ao s|gr|l|cado da ||rguager. A s|rlaxe de ura ||rguager
ralura| a sua grarl|ca. Ara|ogarerle, er ||rguagers de prograraao, a s|rlaxe laror del|r|da alravs de
grarl|cas.
Gramtica
Cors|dereros ur exerp|o de ura lrase escr|la rura ||rguager ralura|. Er Porlugus ura lrase s|rp|es
corsl|luida por ur s|rlagra ror|ra| segu|do de ur s|rlagra veroa|.

'D Joo acenoeu o cacn|moo

Esla lrase ler coro s|rlagra ror|ra| 'D Joo e coro s|rlagra veroa| 'acenoeu o cacn|moo. Por sua vez, o
s|rlagra ror|ra| '0 Joao corsl|luido pe|o delerr|rarle '0 segu|do do rore 'Joao. 0 s|rlagra veroa|
'acerdeu o cacr|roo del|r|do coro serdo ur veroo 'acerdeu segu|do de ur s|rlagra ror|ra| 'o cacr|roo.

F|gura 9. Eslrulura da lrase.

3e rudarros a eslrulura da lrase para:

'D cacn|moo acenoeu o Joo

Frase
3|rlagra Nor|ra| 3|rlagra veroa|
0elerr|rarle Nore veroo 3|rlagra Nor|ra|
0elerr|rarle Nore
0 Joao acerdeu o cacr|roo

@ Esco|a 3uper|or de Tecro|og|a de 3eluoa| 2001-2005 Pg|ra 1Z
A lrase esl s|rlal|carerle correcla. No erlarlo, a lrase rao laz serl|do, |slo rao ler va|or serrl|co.

Cor esle exerp|o poderos ver|l|car que a s|rlaxe rao se preocupa cor o s|gr|l|cado assoc|ado as lrases, ras
aperas cor a del|r|ao da sua eslrulura
2.3 - Semntica
A serrl|ca de ura ||rguager del|re o s|gr|l|cado (va|or serrl|co) de cada lrase da ||rguager.

A serrl|ca de ura ||rguager de prograraao delerr|ra o resu|lado da execuao de ura |rslruao. ura das
lorras de descrever a serrl|ca de ura ||rguager de prograraao cors|sle er lorrecer ura descr|ao er
||rguager ralura| do seu s|gr|l|cado.
Ambiguidade Semntica
As grarl|cas para ||rguagers ralura|s sao |rererlererle aroiguas. ur proo|eras assoc|ado as grarl|cas
aroiguas que as d|lererles eslruluras da resra lrase eslao assoc|ados s|gr|l|cados d|lererles, e porlarlo, dada
ura lrase |so|ada, rao possive| delerr|rar ur|vocarerle o seu s|gr|l|cado.

Por exerp|o, cors|dereros a lrase:

'Eu v| o nomem no monre com um re|escop|o

Nas ||rguagers de prograraao a aro|gu|dade s|rlcl|ca rao pode ex|sl|r, coro acorlece cor as ||rguagers
ralura|s (lr grarl|cas aroiguas).

F|gura 10. Possive|s s|gr|l|cados da lrase 'Eu v| ur rorer ro rorle cor ur le|escp|o

Nas ||rguagers de prograraao, ao ara||sar ura |rslruao de ura ||rguager de prograraao, o corpulador deve
ser capaz de delerr|rar exaclarerle a eslrulura da |rslruao e, corsequerlererle, qua| o seu s|gr|l|cado. ura das
preocupaoes ra del|r|ao de ura ||rguager de prograraao a de ev|lar qua|quer l|po de aro|gu|dade.
2.4 - Erros Sintcticos e Erros Semnticos
0s erros de ur prograra poder ser de do|s l|pos:

Erros s|ntct|cos - As |rslruoes do prograra rao eslao de acordo cor as regras da grarl|ca da
||rguager de prograraao ul|||zada.
Esles erros sao deleclados pe|o corp||ador da ||rguager, porlarlo rar|leslar-se alravs dos crarados
erros de corp||aao.

Erros semnt|cos - 0r|g|rados pe|a execuao de ura sequrc|a de acoes que rao corresporde ao
verdade|ro props|lo do prograrador.

Esles erros sao ra|s d|lice|s de deleclar e corduzer, regra gera|, a erros de execuao.
Ex: escrever ro prograra (x1) er vez de (x-1)
2.5 - Definio de Gramticas (Sintaxes)
Coro j v|ros, ura grarl|ca ur corjurlo de regras(s|rlaxe) que del|re a eslrulura das lrases escr|las rura
delerr|rada ||rguager.
No rurdo da prograraao, ura grarl|ca del|re as regras s|rlcl|cas alravs das qua|s se pode escrever de lorra
correcla ur delerr|rado prograra usardo ura delerr|rada ||rguager de prograraao.

Para del|r|r ura grarl|ca recessr|o recorrer a qualro corce|los:

8|mbo|os Term|na|s - corjurlo de siroo|os que aparecer ras lrases da ||rguager.

8|mbo|os No Term|na|s - corjurlo de siroo|os que rao aparecer ras lrases de ura ||rguager, ras
que sao ul|||zados para descrever os vr|os corporerles das lrases da ||rguager (Ex. ra grarl|ca
porluguesa 's|rlagra ror|ra| )

8|mbo|o |n|c|a| - siroo|o rao lerr|ra| espec|a|, que represerla o e|ererlo pr|rc|pa| da ||rguager

Regras de Produo - descrever a eslrulura dos vr|os corporerles da ||rguager. Eslaoe|ecer a lorra
de gerar lodas as lrases da ||rguager a parl|r do siroo|o |r|c|a| (Ex. ra grarl|ca porluguesa: ura lrase
corsl|luida por ur s|rlagra ror|ra| segu|do de ur s|rlagra veroa|)

As grarl|cas poder ser descr|las ul|||zardo vr|as represerlaoes, la| coro a rolaao 8NF, d|agraras s|rlcl|cos,
erlre oulras.
2.6 - Notao BNF
A rolaao 8NF lo| |rverlada por Jonn 3ackus e Perer haur (8NF s|gr|l|ca '3ackus haur Form).
Esla rolaao serve para espec|l|car as regras s|rlcl|cas de ura grarl|ca lerdo er corla os qualro corce|los
rerc|orados ra secao arler|or.

Nura grarl|ca er rolaao 8NF, ul|||zaros a segu|rle represerlaao:

8|mbo|os Term|na|s - escrever-se d|reclarerle o siroo|o
8|mbo|os No Term|na|s e |n|c|a| - escrever-se erlre '< e '>
<siroo|o rao lerr|ra| ou |r|c|a|>
0 siroo|o [ (||do ou) represerla a|lerral|vas possive|s
0 siroo|o ::= s|gr|l|ca ' corposlo por
Regras de produo - apreserlar a esquerda do siroo|o ::= ur siroo|o rao lerr|ra| e a d|re|la ura
descr|ao da sua eslrulura
<siroo|o rao lerr|ra|> ::= eslrulura

Exemp|os:

Exerp|o 1: 0el|r|r a eslrulura de ura lrase er Porlugus

<F> ::= <SN><SV>
<SN> ::= <Det><N>
<SV> ::= <V><SN>


1. Uma frase (F) constituda por um sintagma nominal (SN) seguido
de um sintagma verbal (SV)
2. Um sintagma nominal (SN) definido por um determinante (Det)
seguido de um nome (N)
3. Um Sintagma verbal (SV) formado por um verbo (V) seguido de um
sintagma nominal (SN)

Exerp|o 2: 0el|r|r rureros o|rr|os usardo a rolaao 8NF, saoerdo que ur rurero o|rr|o corsl|luido por ura
sequrc|a de ur ou ra|s dig|los o|rr|os 0 ou 1.

<nmero binrio> ::= <digito binrio> |
<digito binrio><nmero binrio>
<digito binrio > ::= 0 | 1

A 1 regra de produao del|re ur rurero o|rr|o coro serdo ur dig|lo o|rr|o ou ur dig|lo o|rr|o segu|do de ur
rurero o|rr|o
A 2 regra de produao del|re ur dig|lo o|rr|o coro serdo ur 0 ou ur 1.

3iroo|o |r|c|a|: rurero o|rr|o
3iroo|os lerr|ra|s: 0 e 1
3iroo|os rao lerr|ra|s: rurero o|rr|o e dig|lo o|rr|o

Exerp|o 3: 0el|r|r rureros |rle|ros usardo a rolaao 8NF

<inteiro>::= <nmero > | + <nmero > | - <nmero >
<nmero> ::= <digito > | <digito > <nmero >
<digito> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
A 1 regra de produao del|re ur |rle|ro coro ur rurero ser s|ra|, ur rurero cor o s|ra| ou ur rurero cor o
s|ra| -.
A 2 regra de produao del|re ur rurero coro ur dig|lo ou ur dig|lo segu|do de ur rurero.
A 3 regra del|re o que ur dig|lo.

3iroo|o |r|c|a|: |rle|ro
3iroo|os lerr|ra|s: , -, 0, 1, 2, 3, 1, 5, , Z, 8, e 9
3iroo|os rao lerr|ra|s: |rle|ro, rurero e d|g|lo

Exerp|o 1: Escreva ura grarl|ca er rolaao 8NF para del|r|r o lerpo ul|||zado pe|os re|g|os d|g|la|s orde
aparecer roras : r|rulos : segurdos.

<Tempo> ::= <Horas> : <Minutos> : <Segundos>
<Horas> ::= 0 | 1 | 2 | 3 | 4 | 5 | 23
<Minutos> ::= 00 | 01 | 02 | 03 | 04 | 05 | 59
<Segundos>::= 00 | 01 | 02 | 03 | 04 | 05 | 59

Exerp|o 5: Cors|dere a segu|rle grarl|ca er rolaao 8NF.

<8> ::= b <>
<> ::= b <6> [ a <> [ b

<6> ::= a

3iroo|o |r|c|a|: 3
3iroo|os lerr|ra|s: a, o
3iroo|os rao lerr|ra|s: 3, 8 e C

a) A lrase baaab s|rlacl|carerle correcla?

1 Regra de produao o <8>
2 Regra de produao a <8>
2 Regra de produao o

3|r porque possive| escrever recorrerdo as 1 e 2 regras de produao.

o) A lrase aabb s|rlacl|carerle correcla?

Nao porque rao corea por o

c) A lrase bba s|rlacl|carerle correcla?

2 Regra de produao o <C>
3 Regra de produao a
3|r porque possive| escrever recorrerdo as 1 , 2 e 3 regras de produao
2.7 - Diagramas Sintcticos
ura |rlerprelaao v|sua| das regras de produao de ura grarl|ca er rolaao 8NF pode ser dada por ur d|agrara
s|rll|co.

8|mbo|os term|na|s: escrever-se d|reclarerle e aparecer ro carlo super|or esquerdo do d|agrara

8|mbo|o term|na|

8|mbo|os no term|na|s: derlro de ur reclrgu|o

3iroo|o Nao Terr|ra|

8|mbo|o 0ef|n|do: escr|lo ro carlo super|or esquerdo do d|agrara (|-se corposlo por).
3iroo|o 0el|r|do 3iroo|o 0el|r|do

0|sjuno: represerla-se por ura separaao de selas (|-se 'ou)
3iroo|o 0el|r|do 3iroo|o 0el|r|do

Regra de Produo: apreserla ro carlo super|or esquerdo o siroo|o por e|a del|r|do

Nmero |nr|o 0
1
Exemp|os:

Exerp|o 1: 0el|r|r a eslrulura de ura lrase er Porlugus

Exerp|o 2: 0el|r|r rureros o|rr|os usardo d|agraras s|rlcl|cos, saoerdo que ur rurero o|rr|o corsl|luido
por ura sequrc|a de ur ou ra|s dig|los o|rr|os 0 ou 1.

Ex|sler delerr|rados casos er que possive| s|rp||l|car os d|agraras rur d|agrara ur|co, s|rp||l|cado, s cor
siroo|os lerr|ra|s (d|agrara segu|rle).

Diagrama sintctico para a Frase (F):
Diagrama sintctico para o sintagma nominal (SN):
Diagrama sintctico para o sintagma verbal (SV):
SN SV
F
Det N
SN
V SN
SV
<F> :: <8N> <8V>
<8N> :: <0et> <N>
<8V> :: <V> <8N>
0et
0
A
8N
Joo
Har|a
6ach|mbo
L|vro
8V
Acendeu
Leu
Abr|u
0|g|to |nr|o Nmero |nr|o
0|g|to |nr|o Nmero |nr|o
0|g|to |nr|o 0
1

Exerp|o 3: 0el|r|r rureros |rle|ros usardo d|agraras s|rlcl|cos.

Exerp|o 1: Cors|dere a segu|rle grarl|ca er rolaao 8NF

<$> ..= o <3>
<3> ..= o <0> j a <3> j o
<0> ..= a

0|agrama s|nracr|co equ|va|enre.

Exerc. 1: 0ada a segu|rle grarl|ca er rolaao 8NF:

<Comp>::= <Bum> <Dum+> <Bum> | <Dum+> <Bum>
<Dum+>::= <Dum> <Dum+> | <Dum>
<Dum> ::= B | C | D
<Bum> ::= A | E

a) lderl|l|que o siroo|o |r|c|a| da grarl|ca, ass|r coro os siroo|os lerr|ra|s e rao lerr|ra|s.
o) 0|ga, jusl|l|cardo, qua|s das segu|rles lrases perlercer ou rao a ||rguager del|r|da pe|a grarl|ca:

1)EFA
2)AA
3)ACC
4)ABCDE
5)BBAAAAE
6)EDDCCE
0
1
2
3
1
5

Z
8
9

-
Nurero lrle|ro
8
b
a
b
b
a

7)BBCA

c) Apreserle ur d|agrara s|rlcl|co equ|va|erle


<S>::=<A> a
<A>::=a 
::=<A> a | b

a) lderl|l|que o siroo|o |r|c|a| da grarl|ca, ass|r coro os siroo|os lerr|ra|s e rao lerr|ra|s e del|ra er porlugus
correrle a lrase <3>.

1)aabaa
2)abc
3)abaa
4)aaaabaaaa
5)aaaba



<Blop>::= c <Gulp> s
<Gulp>::= a | b <Gulp> | x <Bat> y
<Bat> ::= x | y <Bat>


1)cas
2)cGulps
3)bay
4)cxxy
5)cxxayys


Exerc. 1: Escreva ura grarl|ca, larlo er rolaao 8NF coro ul|||zardo d|agraras s|rlcl|cos, para del|r|r ur preo
er euros.

Exerc. 5: Escreva ura grarl|ca, larlo er rolaao 8NF coro ul|||zardo d|agraras s|rlcl|cos, para del|r|r as
ralricu|as porluguesas de aulorve|s.

Exerc. : Escreva ura grarl|ca, larlo er rolaao 8NF coro ul|||zardo d|agraras s|rlcl|cos, que ace|la lrases da
segu|rle lorra: as lrases corear por o e acaoar er c. Erlre esles siroo|os pode raver qua|quer rurero de
voga|s. ura voga| ur e|ererlo do corjurlo: a, e, |, o, u.

Exerc. Z: 0ada a segu|rle grarl|ca er rolaao 8NF:



<Princ>::= a <Meio> a
<Meio> ::= b <Fim> b
<Fim> ::= c | c <Fim>

o) Escreva ura grarl|ca equ|va|erle ul|||zardo ur ur|co d|agrara s|rlcl|co.

Exerc. 8: Escreva ura grarl|ca, larlo er rolaao 8NF coro ul|||zardo d|agraras s|rlcl|cos, que del|ra lrases da
segu|rle lorra:
(1) as lrases corear por c;
(2) as lrases acaoar er r;
(3) erlre o c e o r poder ex|sl|r larlos a's e d's quarlos qu|serros, ras ler que ex|sl|r pe|o reros ur
de|es. 3ao exerp|os de lrases desla ||rguager: car, cadar, cdr, cdddddr.

Exerc. 9: Escreva ura grarl|ca, larlo er rolaao 8NF coro ul|||zardo d|agraras s|rlcl|cos, para del|r|r ur
rurero rea|, o qua| pode ser escr|lo quer er rolaao dec|ra| quer er rolaao c|erlil|ca. ur rea| er rolaao
dec|ra| pode ou rao ler s|ra|, e ler que ler porlo dec|ra|, o qua| rodeado por dig|los. Por exerp|o -1.0, 1.0 e 1.0
sao rea|s er rolaao dec|ra|. ur rea| er rolaao dec|ra| ler ura rarl|ssa, a qua| ur |rle|ro ou ur rea|,
segu|do por ur 'E e ur expoerle |rle|ro, o qua| pode ou rao ler s|ra|. Por exerp|o 1.2E-5; 2E1; -21.21E21 sao
rureros rea|s er rolaao c|erl|l|ca.

Exerc. 10: Escreva ura grarl|ca, larlo er rolaao 8NF coro ul|||zardo d|agraras s|rlcl|cos, para represerlar
ur rurero corp|exo da lorra:
<s> <A> <s> i
er que 'A e '8 sao rea|s ser s|ra|, 's ur s|ra| ' ou '-' e '| ur siroo|o lerr|ra|. Por exerp|o, 1.5-3.0| e 23|
sao rureros corp|exos.


<A>::= 1 ( ) 2 ( <C> ) 3 ( <C> ) | 1 ( ) 2 <C>
::= k=m | k<>m | k<=m | k>=m
<C>::= <D> + <D> | <D> - <D> | <D> * <D>
<D>::= e | f | g | h

o) Apreserle ur d|agrara s|rlcl|co equ|va|erle


<Seleco> ::= <confuso> | <confuso> ; else <Expresso> ;
<confuso> ::= if ( <Condio> ) <Expresso> ;
<Condio> ::= k == m | k != m | k <= m | k>=m | k<m | k>m
<Expresso>::= <Id> + <Id>|<Id> - <Id> | <Id> * <Id> | <Id> / <Id>
<Id> ::= e | f | g | h

a) lderl|l|que o siroo|o |r|c|a| da grarl|ca, ass|r coro os siroo|os lerr|ra|s e rao lerr|ra|s e del|ra a grarl|ca
er porlugus correrle.
o) Apreserle ur ur|co d|agrara s|rlcl|co equ|va|erle.



<Seleco> ::= Switch ( <Expresso> ) { <Lista> } ;
<Lista> ::= case valor : instruo | case valor : instruo <Lista>;
<Expresso>::= <Id> + <Id> | <Id> - <Id> | <Id> * <Id> | <Id> / <Id>
<Id>::= e | f | g | h

a) lderl|l|que o siroo|o |r|c|a| da grarl|ca, ass|r coro os siroo|os lerr|ra|s e rao lerr|ra|s e del|ra a grarl|ca
er porlugus correrle.
o) Apreserle ur ur|co d|agrara s|rlcl|co equ|va|erle.
Exerc. 11: 0ada a segu|rle grarl|ca er rolaao 8NF, er que o siroo|o |r|c|a| comp.:

<ins> ::= <ins1> | <ins1> ; <ins>
<comp> ::= begin <ins> end
<ins1> ::= <comp> | a | b | c

o) Reescreva-a ul|||zardo d|agraras s|rlcl|cos.
c) ver|l|que a va||dade das segu|rles lrases, de acordo cor a grarl|ca:
1)begin a;b; a end
2)begin c; end
3)begin end
4)begin a begin a; a; a; b end; c end
5)begin a end; begin b; c end
6) begin a begin b; c end

Exerc. 15: Escreva ura grarl|ca, ul|||zardo d|agraras s|rlcl|cos, para del|r|r rureros |rle|ros de corpr|rerlo
irpar (ex.: 1, 221, 55555, elc.) . Reescreva-a ul|||zardo rolaao 8NF.


3 - Conceitos Bsicos de Programao
3.1 - Estrutura de um Programa
0s prograras |rc|uer rorra|rerle lrs l|pos de corporerles:
0ec|araes - perr|ler reservar rerr|a para o arrazerarerlo da |rlorraao ervo|v|da;
|nstrues - |rd|car ao corpulador o que deve elecluar;
Comentrios so teis para os humanos, mas so ignorados pelo computador.

As ||rguagers de prograraao lr regras s|rlcl|cas que |rd|car coro cr|ar dec|araoes, |rslruoes e corerlr|os
de lorra correcla. A s|rlaxe do Java (a ||rguager ul|||zada coro suporle resla cade|ra para a aprerd|zager da
prograraao) la| coro a de oulras ||rguagers, |rc|u| |derl|l|cadores, pa|avras reservadas, siroo|os e va|ores.
3.2 - Identificadores
0s |dent|f|cadores sao rores alr|ouidos aos d|lererles e|ererlos de ur prograra (luroes, var|ve|s, corslarles e
oulras erl|dades que esle rar|pu|a). Ex|sler regras para a corslruao de |derl|l|cadores.
Er Java, essas regras sao as segu|rles:
0ever ser |r|c|ados por ura |elra, urderscore (_) ou c|lrao (S)
Poder ler oulros caracleres (|elras, dig|los, urderscore ou c|lrao)
Nao poder corler espaosl

Corlrar|arerle ao que acorlece roulras ||rguagers, o Java d|sl|rgue erlre ra|uscu|as e r|ruscu|as, ou seja:

A a
B b
public static void PUBLIC STATIC VOID

A|rda que as corveroes rao sejar oor|galr|as e o corp||ador rao ver|l|que se sao curpr|das, acorse|rve| a
sua ul|||zaao, po|s lac|||lar a corpreersao dos prograras por prograradores a e|as rao|luados. Taror para o
Java corur usar corveroes para os |derl|l|cadores a cr|ar quardo se deservo|ve ur prograra:

0s rores das C|asses (vereros ad|arle o que sao) corear por |elras ra|uscu|as (ex: Area)
0ua|quer oulro rore corea por |elras r|ruscu|as, por exerp|o o de ur rlodo (ex: main() vereros
laror ad|arle o que sao rlodos)
As pa|avras segu|rles a pr|re|ra, corear cor ra|uscu|a (ex: d|sc|p||ra0oCurso)
0s |derl|l|cadores dever suger|r o seu va|or serrl|co, |slo dever ler rores sugesl|vos de acordo cor o props|lo
a que se desl|rar.

NF para def|n|r |dent|f|cadores em Java

<identificador> ::= <letra> | <caracter><string>
<letra> ::= a | b | ....| z | A | B | ... | Z |
<caracter> ::= <letra> | _ | $
<string> ::= <caracter ou digito> |
<caracter ou digito><string>
<caracter ou digito> ::= <caracter> | <digito>
<digito> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9


Exemp|o

0ua|s dos segu|rles |derl|l|cadores sao v||dos er Java e qua|s rao sao?

1_x invlido, comea por dgito
X1 vlido
M&M invlido, carcter & ilegal
int invlido, uma palavra reservada
$dlar invlido, carcter acentuado no nome
limite Inf invlido, espao em branco
3.3 - Palavras Reservadas
0s |derl|l|cadores poder ser esco|r|dos pe|os prograradores (ex: rurero0oA|uro). No erlarlo, laror poderos
ul|||zar |derl|l|cadores prev|arerle del|r|dos ra ||rguager, des|grados por: Pa|avras Reservadas. As Pa|avras
Reservadas sao pa|avras ul|||zadas ra del|r|ao da ||rguager e que lr ur s|gr|l|cado prpr|o resse corlexlo. A sua
serrl|ca rao pode ser a|lerada pe|o prograrador.

F|gura 11. L|sla das pr|rc|pa|s pa|avras reservadas ex|slerles ra ||rguager Java
3.4 - Smbolos e Valores
0s 8|mbo|os del|r|dos er Java |rc|uer d|versos:
0peradores: , -, e =
3|ra|s de porluaao: {, , (, ) e ;
Ta| coro as pa|avras reservadas, os siroo|os lr ur s|gr|l|cado oer del|r|do e rao poder ser ul|||zados para oulro
l|r.

0s Va|ores sao dados exp|ic|los que poder ser rar|pu|ados pe|o prograra, |slo sao lodos os va|ores ace|les pe|a
||rguager.

Por exerp|o:

Nurero |rle|ros: 5 e -301
Nureros rea|s: 3.11159, -0.02 e 5.88l
0s caracleres: 'a', 'A' e '\r'
Cade|as de caracleres: '8or d|al
abstract boolean break byte
byvalue
case
cast
catch char class
const continue default do double
else extends false final finally
float for
future generic goto
if implements import
inner
instanceof
int interface long native new
null
operator outer
package private
protected public
rest
return short
static super switch synchronized this
Throw throws transient true try
var
void volatile while


3.5 - Variveis
ura var|ve| ura |oca||zaao er rerr|a ra qua| poderos guardar ur va|or de ur dado l|po. A cada var|ve|
eslao assoc|ados ur l|po e ur rore.

0 va|or de ura var|ve| pode var|ar durarle a execuao do prograra. No erlarlo, er cada rorerlo ura var|ve|
pode aperas corler ur va|or. Coro poderos ver|l|car ra l|gura segu|rle, o arrazerarerlo de ur rovo va|or rura
var|ve| deslr| o va|or arler|or dessa resra var|ve|.

F|gura 12. Represerlaao grl|ca do corce|lo de var|ve|
3.6 - Declarao e Inicializao
Para usar ura var|ve| recessr|o lazer a sua 0ec|arao prev|arerle, |slo a espec|l|caao do seu rore
(|derl|l|cador) e da gara de va|ores que pode corler (l|po de dados). A dec|araao lerr|rada cor ur porlo e
virgu|a (;). Esle o siroo|o que se usa er Java para |rd|car o l|ra| de qua|quer dec|araao ou |rslruao.

F|gura 13. Esquera represerlal|vo da dec|araao de var|ve|s

NF para representao da dec|arao de var|ve|s:

<declarao vars> ::= <modificadores> <tipo> <variaveis>; |
<tipo> <variaveis> ;
<variaveis> ::= <identificador> |
<identificador>, <variaveis>

A |n|c|a||zao cors|sle ra alr|ou|ao de ur va|or a ura var|ve| (ex: total = 0;).
1002
Clula de
Memria
int num = 145;
Num -> EM 1002
1002
Clula de
Memria
num = 210;
int total;
int count, temp, result;
H H | |t t| |p p| |a as s v va ar r| | v ve e| |s s p po od de em m s se er r c cr r| |a ad da as s n nu um ma a n n| |c ca a d de ec c| |a ar ra a o o
t t| |p po o d de e d da ad do o | |d de en nt t| |f f| |c ca ad do or r d da a v va ar r| | v ve e| |

Nao eslaros a la|ar de ur va|or qua|quer, ras s|r do va|or |n|c|a| da var|ve|.

NF para def|n|r o processo de |n|c|a||zao de var|ve|s:

<inicializao vars> ::= <identificador> = <expresso>;

Poderos, ro erlarlo, dec|arar e |r|c|a||zar ura var|ve| ra resra expressao.

Exemp|o:

int sum = 0;
int base = 32, max = 149;

NF para def|n|r o processo de dec|arao e |n|c|a||zao de var|ve|s:

<declarao com inicializao vars> ::= <modificadores> <tipo>
<identificador> = <expresso>;

E de rolar que a dec|araao de ura var|ve| aperas provoca a reserva de espao de rerr|a recessr|o e a sua
|derl|l|caao pe|o rore dec|arado. A var|ve| ler ur va|or |rdel|r|do. Na |r|c|a||zaao a var|ve| l|ca cor ur va|or
del|r|do (s agora pode ser ul|||zada).

0uardo ura var|ve| relererc|ada rur prograra, ul|||zado o va|or aclua| (ver cd|go aoa|xo).

int nomeDaVar; // declarao
nomeDaVar = 20; //inicializao
nomeDaVar = nomeDaVar + 50; // Referenciao
// qual o valor de nomeDaVar neste momento?
int x = 50;
x = x + nomeDaVar; // qual o valor de x neste momento?

3.7 - Constantes
ura Corslarle pode ser erlerd|da coro ur erdereo de rerr|a, la| coro ura var|ve|, ras ro qua| s pode ser
escr|lo ur va|or ura ur|ca vez. Ass|r, o va|or rarlr-se |ra|lerado durarle loda a execuao do prograra. A||s, se
lerlarros ao |orgo do prograra alr|ou|r ur va|or d|lererle a ura corslarle, suposlo ser ura v|o|aao da s|rlaxe
da prpr|a ||rguager, resu|lardo er erros de corp||aao.

Er Java, ul|||zada a pa|avra reservada final para |rd|car que delerr|rado |derl|l|cador represerla ura
corslarle.

Exemp|o:

final int MIN_TEMP = -10;


ura corslarle pode ser dec|arada coro:

final <tipo> <nome_var> ou
static final <tipo> <nome_var>

Exemp|os:

final double PREVISAO_VENDAS = 350000.0;
static final double PREVISAO_VENDAS = 350000.0;

Por corverao, as corslarles dever ser escr|las er |elras ra|uscu|as.

NF para a dec|arao de constantes:

<declarao constantes> ::= <constante> |
<constante>; <declarao constantes>
<constante> ::= final <modificadores> <tipo> <variaveis>

3ere|raras das corslarles cor as var|ve|s:
Tr ur |derl|l|cador
Tr ur va|or

0|lereras re|al|varerle as var|ve|s:
0 seu va|or rao pode ser a|lerado
3.8 - Tipos de Dados
Er Java leros do|s rive|s de l|pos de dados:

T|pos de 0ados Pr|m|t|vos: sao os ra|s s|rp|es, serdo ul|||zados para guardar rureros, caracleres e va|ores
ooo|earos. Arrazerar d|reclarerle os va|ores.
Refernc|as: sao oojeclos e arrays, guardar o erdereo do |oca| orde os dados se ercorlrar (vereros ra|s
ad|arle o s|gr|l|cado de cada ur).

Exemp|o:

int x = 10;
// int um tipo primitivo

String str= new String (Ola);
// String uma referncia



F|gura 11. Represerlaao grl|ca da possive| |oca||zaao er rerr|a das var|ve|s dec|aradas ros do|s exerp|os
arler|ores

ur l|po de dados del|r|do pe|a gama de va|ores que pode represerlar e pe|as operaes que soore e|es se
poder elecluar.
Por agora varo-ros locar aperas ros l|pos de dados pr|r|l|vos.
A ||rguager Java co|oca o|lo l|pos de dados pr|r|l|vos a rossa d|spos|ao:

0ualro represerlar |rle|ros: byte, short, int, long
0o|s represerlar rureros Rea|s: float, double
ur represerla caracleres: char
ur represerla va|ores Lg|cos : boolean
3.8.1 - Inteiros
Tipo
Inteiro
Tama-
nho

Menor Valor

Maior Valor
byte 1 byte
(8 bits)
128 127
short 2 bytes
(16 bits)
32,768 32,767
int 4 bytes
(32 bits)
2,147,483,648 2,147,483,647
long 8 bytes
(64 bits)
9,223,372,036,854,775,808 9,223,372,036,854,775,807

F|gura 15. 0|lererles l|pos de |rle|ros olerec|dos pe|a ||rguager Java. Nesla laoe|a poderos ver o espao ocupado
por ura var|ve| de cada ur desles l|pos, oer coro o ra|or e reror va|or que essa var|ve| pode ler

Coro exerp|os de va|ores lip|cos a guardar er var|ve|s de cada ur dos l|pos |rle|ro poder ser apreserlados:

byte: 40
short: -22 500
int: 1 500 000
long: 4 000 000 000

memria
Ola"
20A20
20A20
20B+0
10 x
str
20B+0

Er oa|xo leros o corjurlo de operaoes que poder ser elecluadas soore va|ores de l|po |rle|ro:

Operao Smbolo Exemplo Resultado
Adio
+ 26 + 10 36
Subtraco
- 26 - 1 25
Multiplicao
* 26 * 10 260
Diviso
/ 26 / 10 2
Mdulo
(resto)
% 26 % 10 6

F|gura 1. Corjurlo de operaoes que poder ser elecluadas soore va|ores do l|po |rle|ro

A precednc|a de operadores determ|na a ordem de execuo das operaes. Por exerp|o cors|dere-se a
|rslruao: System.out.println(30 + 10 / 2);

As |rlerprelaoes possive|s sao:

F|gura 1Z.
Grau de
Precedncia
Operao
Alto
()
Mdio
-, + (unrios)
*, /, %
Baixo
+, -

F|gura 18. lrlerprelaoes possive|s da order dos operadores e laoe|a cor as regras de precedrc|a correclas
3.8.2 - Reais
ur rurero rea| pode ser represerlado usardo a rolaao dec|ra|, ler ur porlo dec|ra| ou a rolaao exporerc|a|,
ler ur expoerle (E) Ex: 5.0, 12.31, 0.0, -15.8, 12. , 5.E2Z

Tipo Tamanho
float 4 bytes (32 bits)
double 8 bytes (64 bits)

F|gura 19. T|pos de dados rea|s ex|slerles er Java
correcto!
30 10
2
20
+
=
e
30
10
2
35 + =
errado!


Tipo Menor Valor Maior Valor
float 1.40129846432481707e-45 3.40282346638528860e+38
double 4.94065645841246544e-324 1.79769313486231570e+308

F|gura 20. Va|or e reror va|or represerlve|s pe|os d|lererles l|pos de dados rea|s do Java

0s rureros rea|s poder ser segu|dos das |elras f ou d |rd|cardo que se prelerde o seu arrazerarerlo coro
float ou coro double. A ausrc|a de |rd|caao |rp||ca que o rurero seja cors|derado coro double.

Operao Smbolo Exemplo
Resultado
Adio
+ 5.4 + 2.0 7.4
Subtraco
- 5.4 - 2.0 3.4
Multiplicao
* 5.4 * 2.0 10.8
Diviso
/ 5.4 / 2.0 2.7

F|gura 21. 0peraoes possive|s soore rea|s

Grau de
Precedncia
Operao
Alto
()
Mdio
-, + (unrios)
*, /
Baixo
+, -

F|gura 22. Precedrc|as dos operadores soore rureros rea|s
3.8.3 - Caracteres
0 arrazerarerlo de caracleres er Java corsegu|do pe|o l|po char. Na rea||dade, as var|ve|s do l|po char
arrazerar rureros que |derl|l|car os caracleres de acordo cor ur cd|go deror|rado uhl0D0E. Esle cd|go
ur sranoaro |rlerrac|ora| de represerlaao de caracleres que corlr siroo|os e caracleres dos a|laoelos oc|derla|s
e or|erla|s.

0s va|ores do l|po char sao de||r|lados por p||cas( ' ):

Exemp|os:

// 'a' 'X' '7' '$' ',' '\n'
// so valores do tipo char

char letra = 'a;

3.8.4 - Lgico
0 arrazerarerlo de va|ores |g|cos er Java corsegu|do pe|o l|po boolean, que, ev|derlererle, aperas pode
assur|r ur de do|s va|ores: verdade|ro, ou la|so.

As pa|avras reservadas true e false sao os ur|cos va|ores v||dos para ur l|po Lg|co

Exemp|o:

boolean terminado = false;

3.8.5 - Operadores Lgicos
As expressoes |g|cas poder ul|||zar os segu|rles operadores |g|cos:

! NOT
&& AND
|| OR

0perar soore operardos |g|cos e produzer resu|lados |g|cos.

0 N0T ur operador urr|o (ler aperas ur operardo), erquarlo que o AN0 e o 0R sao operadores o|rr|os (lr
do|s operardos)

a b a && b a || b a ! a
true
true
false
false
true
false
true
false
true
false
false
false
true
true
true
false
true
true
false
false
false
false
true
true
F|gura 23.
F|gura 21. Taoe|as de verdade dos operadores &&, jj e l
3.8.6 - Operadores Relacionais
Re|ac|orar duas expressoes de ur resro l|po de dados e relorrar ur va|or de l|po boolean:

Operador Designao
> Maior que
>= Maior ou igual a
< Menor que
<= Menor ou igual a
== Igual a
!= Diferente de


A l|gura aoa|xo ||uslra as operaoes possive|s para os vr|os l|pos de dados:

boolean
char
float,
double
byte, short,
int, long
+
-
*
/
%
>
>=
<
<=
==
!=
>
>=
<
<=
==
!=
>
>=
<
<=
==
!=
>
>=
<
<=
==
!=
+
-
*
/
+
!
||
&&
++
--
+
+
boolean
char
float,
double
byte, short,
int, long
+
-
*
/
%
>
>=
<
<=
==
!=
>
>=
<
<=
==
!=
>
>=
<
<=
==
!=
>
>=
<
<=
==
!=
+
-
*
/
+
!
||
&&
++
--
+
+

3.9 - Instrues
Coro j lo| reler|do arler|orrerle, sao as |rslruoes que |rd|car ao corpoulador o que esle deve lazer. As
|rslruoes poder ser de do|s l|pos:

Executve|s - or|g|rar a execuao de ura operaao
No executveis constituem directivas para a JVM

Exemp|os:

// executveis
System.out.println("Ol!");
aluno.inscricao();

// no executveis
public static void main(String[ ] args)
import desenhograficos.*;

0uarlo a sua corp|ex|dade, as |rslruoes poder ser:

|nstrues 8|mp|es - lerr|rarer er porlo e v|rgu|a (;)
|nstrues 6ompostas - o|oco de |rslruoes corsl|luido por vr|as |rslruoes s|rp|es e de||r|ladas por
' { .


Exemp|os:

// instruo simples

// instruo composta

{
System.out.println("Bom trabalho!");
}

NF para def|n|r as |nstrues:

<bloco de instrues> ::= { <instrues> }
<instrues> ::= <instruo>; | <instruo>;<instrues>

ur o|oco de |rslruoes pode ser |rlroduz|do er qua|quer |oca| orde ura |rslruao s|rp|es possa ser ul|||zada.
0 Corpulador |r|c|a a execuao do prograra pe|a pr|re|ra |rslruao do rlodo main(), da c|asse que l|ver s|do
e|e|la coro pr|rc|pa| (vereros ur pouco ra|s ad|arle o que o rlodo main e o que ura c|asse. Por agora,
oasla saoer que o main represerla o porlo de parl|da por orde o prograra corea a ser execulado).
As |rslruoes sao execuladas sequerc|a|rerle, ra order porque sao escr|las, da esquerda para a d|re|la, de c|ra
para oa|xo.
3.10 - Comentrios
0s corerlr|os de ur prograra docurerlar as |rslruoes ex|slerles. 0ever ser |rc|uidos de lorra exp||car o
props|lo do prograra e descrever passos do processarerlo. Nao |rl|uerc|ar o lurc|orarerlo do prograra po|s
sao |grorados pe|o corp||ador.

0s corerlr|os er Java lr do|s lorralos:

// formato utilizado para comentrios no final da linha

/* formato para comentrios que se
estendem por mais de uma
linha
*/
3.11 - Paragrafao / Indentao
Caracleres de espao, ||rras er orarco e laou|aao sao gerer|carerle des|grados por espaos er orarco. 0s
espaos er orarco sao ul|||zados para separar |derl|l|cadores e siroo|os ro prograra. Todos os espaos er orarco
ad|c|ora|s sao |grorados.

ur prograra Java pode ser lorralado de ru|l|p|as lorras. 0eve ser ul|||zada a paragralaao, para assegurar a
|eg|o|||dade dos prograras


Exemp|o de um programa Java com paragrafao

package meuteste;

public class OlaMundo {
public static void main(String[] args) {
System.out.println("Ol Mundo!");
}
}

Exemp|o de um programa Java sem paragrafao

package meuteste; public class OlaMundo { public static void
main(String[] args) { System.out.println("Ol Mundo!"); } }

0 Corp||ador |grora a paragralaao e os l|rs de ||rra.
3.12 - Um programa em Java
Cors|dere que se prelerde ur prograra que, dado o rore de ur a|uro, roslre ura rersager ao a|uro.
0 rore do a|uro lorrec|do pe|o ul|||zador, pe|o que o seu va|or rao correc|do ro rorerlo da escr|la do
prograra - prever ur re|o de arrazerar esse va|or.
Ped|r ao ul|||zador o rore e proceder a respecl|va |e|lura
A rersager dever ser roslrada alravs do ror|lor.

0 cd|go para o prograra prelerd|do poder|a ser o segu|rle:

public class PrimeiroPrograma {

public static void main (String args[]){

// Declarao de variveis
String nome;

// L o nome do aluno
System.out.println(Introduza o seu nome);
nome = Le.umaString();

// Mostra a mensagem
System.out.println(Ol+nome+bom trabalho para a
disciplina de Introduo Programao);
}
}

Para que o corpulador possa arrazerar va|ores recessr|o reservar espao de rerr|a. Para la| recessr|o
|rd|car o l|po de dados a arrazerar e rore que |r ser usado para o |derl|l|car - 0ec|arao de Var|ve|s
(String nome);

Ped|r ao ul|||zador para |rlroduz|r o rore:

3ysler.oul.pr|rl|r('lrlroduza o seu rore);


Le.umaString() ur suoprograra que |eva o prograra a parar e a esperar que o ul|||zador escreva o
rore usardo o lec|ado e o corl|rre cor a a lec|a 'Enrer. 0 va|or |rlroduz|do arrazerado ra var|ve| nome.

Voslrar ao ul|||zador a rersager:

System.out.println(Ol+nome+bom trabalho para a disciplina de
Introduo Programao);

Nesle caso rao se esl a rardar escrever aperas ura cade|a de caracleres (' ). 0uardo aparece o rore de ura
var|ve| ra |rslruao de escr|la, o s|slera resporde escreverdo o va|or correrle dessa var|ve| e rao o seu rore.

0evemos ad|c|onar comentr|os ao cd|go - lrases que se ul|||zar para lac|||lar a |e|lura do cd|go de ur
prograra por parle de quer l|ver que ul|||zar o rosso cd|go ou a|ler-|o por qua|quer rol|vo. Ner que seja para rs
prpr|os, quardo vo|larros a rexer ro cd|go de ur prograra que j rao ul|||zva-ros a seraras, reses e al
aros, ros possaros |erorar do que l|zeros e cor que oojecl|vos.

No exerp|o de prograra ac|ra os corerlr|os ad|c|orados lorar:

//Declarao de variveis
//Mostra a mensagem
Exerc. 1: 0e que l|pos de dados poder|ar ser as corslarles da laoe|a 1? Nole que a|gurs de|es poder ser de
d|lererles l|pos.

1 23E5 300 7E10 1E3
0 -255 23.4E300 32767 -32767
true false 8000000 -127 123

Exerc. 2: 0elerr|re qua|s dos segu|rles rureros sao v||dos. 3e ur rurero v||do, espec|l|que a que l|po de
dados pr|r|l|vo perlerce.

666
777.
888.0
6.66e2
483,500
1666667e -6

Exerc. 3: 0ec|are corslarles para cada ur dos |derl|l|cadores da laoe|a 1 ul|||zardo os correc|rerlos que j
adqu|r|u do Java:

conta 3
diferenca -2
fraccao 0.33333
cor Azul

Exerc. 1: 0|ga qua|s das segu|rles dec|araoes rao sao ace|les. Jusl|l|que.

a) CONSTANT PI = 3.14; o) CONST e = 2.718; c) CONST a = 3;
b = 4;

d) CONST a, b = 12; e) CONST a = 12; b = 12; l) CONST valor = 2
g) VAR y : INTEGER r) VAR x, y : CHAR; |) VAR x : BOLEAN;
j) VAR x = REAL; |) VAR x : CHAR; |) VAR a: CHAR;
VAR b : REAL;
r) VAR a : INTEGER; r) VAR a; b : INTEGER;
b : CHAR; c : INTEGER; c : REAL;


4 - Sequenciao
4.1 - Instruo de Atribuio
A |rslruao de alr|ou|ao perr|le arrazerar ur va|or rura var|ve|. Esle va|or pode ser lorrec|do d|reclarerle ou
resu|lar do c|cu|o de ura expressao.

NF para def|n|o da |nstruo de atr|bu|o:

<instruo de atribuio>::= <identificador>=<expresso>;

A expressao da d|re|la ca|cu|ada er pr|re|ro |ugar, serdo o resu|lado arrazerado ra var|ve| da esquerda. Nesle
corlexlo, o s|ra| = deve |er-se 'lora o va|or de.
3 pode ser alr|ouido ur va|or a ura var|ve| que seja cors|slerle cor o l|po de dados dec|arado para essa var|ve|.
A resra var|ve|, pode eslar ro |ado esquerdo e d|re|lo da |rslruao de alr|ou|ao. Cors|dere-se o exerp|o:

F|gura 25. Represerlaao esquerl|ca da alr|ou|ao de va|ores a ura var|ve|

Exemp|os:

int conta ;
conta = 25; corla 25
sum = conta; sur 25
conta = sum + 15; corla 10
conta = conta + 1; corla 11
4.1.1 - Operadores de Atribuio
Por vezes recessr|o elecluar ura operaao soore ura var|ve|, e er segu|da arrazerar-se o va|or ool|do ressa
resra var|ve|. 0s operadores de alr|ou|ao Java s|rp||l|car essas operaoes.
Por exerp|o, a |rslruao num += conta;
equ|va|erle a num = num + conta;
Pr|re|ro, ad|c|orada ura ur|dade
ao va|or or|g|ra| da var|ve| conta
0e segu|da o resu|lado arrazerado rovarerle er conta
(suosl|luirdo o va|or or|g|ra|)
corla = corla 1;
0 va|or arler|or da var|ve| total suosl|luido por 55
lola| = 55;


F|gura 2. 0|lererles represerlaoes para os operadores de alr|ou|ao
4.1.2 - Operadores de Incremento e Decremento
0s operadores de |rcrererlo e decrererlo sao operadores ar|lrl|cos e |rc|der soore ur operardo.

Pode-se usar a alr|ou|ao para |rcrererlo de ura var|ve|, por exerp|o:

conta = conta + 1;

0u usar o operador de |rcrererlo:

conta++; // Verso Sufixo
++conta; // Verso Prefixo

0|ferena entre o 8uf|xo e Pref|xo

8uf|xo: |rcrererla oepo|s de ca|cu|ar a expressao

int x = 0, y = 1;
x = y++; // y 2, x 1

Pref|xo: |rcrererla anres oe ca|cu|ar a expressao

int x = 0, y = 1;
x = ++y; // y 2, x 2
0 operador de decrererlo -- suolra| ur ao seu operardo:

count--;
--count;
4.2 - Expresses
ura expressao ura sequrc|a de operadores e de va|ores. As expressoes poder ser ca|cu|adas, oolerdo-se ur
rovo va|or.

0perador

=
-=
=
/=
=
Exerp|o

x = y
x -= y
x = y
x /= y
x = y
Equ|va|erle a

x = x y
x = x - y
x = x y
x = x / y
x = x y

Poderos ler:

Expresses Ar|tmt|cas - ervo|ver operadores ar|lrl|cos

5 * ( 2 + 3 ) + ( 7 3 ) / 2 Resultado: 27

As expressoes ar|lrl|cas sao ca|cu|adas |evardo er corla a pr|or|dade dos d|lererles operadores ervo|v|dos

Expresses Lg|cas - lr coro resu|lado ur va|or |g|co e sao corslruidas cor operadores re|ac|ora|s e
operadores |g|cos

Exemp|os:

Exerp|o1: 0elerr|re o va|or das segu|rles expressoes, |rd|cardo laror o l|po do va|or ool|do

Resu|tado
3-4*2+1 -1 |rl
2*(12%5)-(8-3)/2 2 |rl
2*12%5-8-3/2 -5 |rl
2.5+6%4*2.1 .Z douo|e
2((20/)(3(2-1.5))) (2.51-1.5) 1.0 douo|e

Exerp|o 2: 0elerr|re o resu|lado das segu|rles expressoes ou |rslruoes

Resu|tado
3+5/2) >= (1-4%2) lrue
x=3 == 4; x l|ca la|se
8-1 != 3 + 4 la|se
a < b || c < a lrue
(!a && b)|| (a || !b) lrue para a = lrue e o = la|se

4.2.1 - Converses de Tipo
0 l|po de resu|lado de ura expressao deperde do l|po dos seus operardos. 3e os operardos sao lodos do resro
l|po, o resu|lado ser laror desse l|po. 3e os operardos sao de vr|os l|pos - corversao.

As corversoes sao le|las auloral|carerle e de rodo a que rao raja perda de |rlorraao. Pe|o que rer lodas as
lrarslorraoes sao possive|s. Ex: ur va|or rea| rao pode ser corverl|do auloral|carerle para ur |rle|ro (perda da
parle dec|ra|); o corlrr|o possive| ser perda de |rlorraao.

E possive| corverler ur va|or para ur l|po que ocupe ra|s espao de rerr|a, ras o |rverso rao verdade|ro (a
reros que cors|garos lor-|o de a|gura lorra, coro vereros a segu|r).

Cade|a de corversao aulorl|ca

oyle > srorl > |rl > |org >l|oal > douo|e

A corversao cor perda de |rlorraao - Cast deve ser |rd|cada exp||c|larerle, caso corlrr|o deleclado ur erro
pe|o corp||ador.


Exemp|o

resultado_int = (int) (valor_double + valor_int)

Exemp|os:

Exerp|o1: Cors|dere-se o segu|rle cd|go

int var_int=10, resultado_int;
double var_double= 5.2, resulatdo_double;

resultado_double = var_int + var_double;

Nesle caso var_int corverl|do para double , a sora elecluada e o resu|lado double

resultado_int = var_int + var_double;

Terlar arrazerar ur resu|lado double rura var|ve| int rao possive| ser perda de |rlorraao (corp||ador
delecla erro).

resultado_int = (int) (var_int + var_double);

Exerp|o2: 0ua| o va|or de x ro l|ra| das segu|rles |rslruoes supordo que lorar le|las as dec|araoes e
|r|c|a||zaoes das var|ve|s:

double x, y=6.3, z=2.2;
resu|tado
x= y/z; -2.8636363636363633
x= (int)y/z; -2.727272727272727
x= y/(int)z; -3.15
x= (int) y /(int)z; -3.0
x = (int)(y/z); -2.0
4.3 - Classe Math e Random
Va|s ad|arle, la|areros dos l|pos de dados j rerc|orados coro relerrc|as, os qua|s sao del|r|dos por re|o de ur
corce|lo a que se deu o rore de 6|asse.
Esle corce|lo a|go corp|exo e deve ser v|slo pr|re|ro de ura lorra ra|s |so|ada, arles que se possa corpreerder
ludo o que esl ervo|v|do ra sua del|r|ao.
Porlarlo, por agora, varos persar rura c|asse coro ur corjurlo de luroes agrupadas segurdo ur corlexlo
corur. Essas luroes sao ro lurdo ul|||lr|os aos qua|s poderos recorrer ao |rp|ererlar os rossos prpr|os
prograras, por lorra a ra|s rap|darerle reso|ver proo|eras pequeros e corurs coro, por exerp|o, a geraao de
rureros a|ealreos, a ul|||zaao de d|versas luroes ralerl|cas, elc.
As prpr|as c|asses poder ser agrupadas derlro de ur resro corjurlo, cr|ardo as craradas o|o||olecas de c|asses
das qua|s varos la|ar agora ur pouco.

4.3.1 - Biblioteca de Classes
ura o|o||oleca de c|asses ura co|ecao de c|asses prev|arerle e|aooradas, que poder ser ul|||zadas ro
deservo|v|rerlo de prograras.

As c|asses, de acordo cor as suas l|ra||dades, poder ser orgar|zadas er pac|ages (pacoles):

Pac|ages 0ojecl|vo
java.lang 3uporle da ||rguager
java.util ul|||lr|os
java.applet Cr|aao de app|els para a Weo
etc.
4.3.2 - Classe Math
ura c|asse das c|asses prev|arerle e|aooradas a c|asse Math que |rc|u| ur vaslo rurero de suoprograras
que |rp|ererlar d|versas luroes ralerl|cas (ex: Math.sqrt() - ca|cu|a a raiz quadrada;
Math.sin() - ca|cu|a o sero de ur rgu|o; elc.)

A c|asse Math perlerce ao package java.lang , esle package |rporlado auloral|carerle ser
recess|dade de |rc|usao especil|ca ro prograra.

Para ul|||zar c|asses de oulros pacoles recessr|o |rporlar (import) exp||c|larerle a c|asse.

Exerp|o:
Ca|cu|ar a polrc|a de ur rurero e|evado a oulro.

public class Calculo {

int base=2, expoente=8;
int resultado;

resultado = Math.pow(base, expoente);

System.out.println(O resultado : +resultado);
}
}

4.3.3 - Classe Random
A c|asse Random parle do package java.util (lorrece rlodos para gerar rureros a|ealr|os). Coro
rao ura c|asse do pac|age java.lang recessr|o |rporlar exp||c|larerle:

|rporl java.ul||.Rardor;

0uardo recessr|o ul|||zar ura c|asse de ur package ras rao quereros usar a d|recl|va import, pode ser
ul|||zado o seu rore corp|elo.


A|gurs rlodos da c|asse Random

Vlodo 0escr|ao
Rardor() Cr|a gerador de rureros a|ealr|os
|rl rexl(|rl o|ls) 0era o rurero a|ealr|o segu|rle
|rl rexllrl() Relorra ur rurero |rle|ro a|ealr|o
|rl rexllrl(|rl r) Relorra ur rurero |rle|ro a|ealr|o de ur |rlerva|o de 0 a r
douo|e rexl0ouo|e() Relorra ur rurero rea| a|ealr|o, erlre 0.0 e 1.0


java.util.Random r = new java.util.Random();
int resultado = r.nextInt();

}
}

A desvarlager que o rore que leros a escrever se lorra deras|ado exlerso, pe|o que rer serpre corpersa
ul|||zar esla aoordager.
A oulra aoordager possive|, cors|sle er ul|||zar de lorra exp|ic|la a d|recl|va |rporl:

import java.util.Random;



Random r = new Random(); //agora j mais legvel...

int resultado = r.nextInt();

}
}

Para |rporlar lodas as c|asses de ur pac|age ul|||za-se o caracler espec|a| *

|rporl java.ul||.;


Exemp|o

3orar do|s rureros gerados a|ealor|arerle.


public class SomaAlet {
Random random = new Random();
int n1 = random.nextInt();
int n2 = random.nextInt();
int soma = n1 + n2;
System.out.println(A soma : +soma);
}
}

4.4 - Entrada e Sada de Dados
0s prograras sao cerlarerle ra|s ule|s e versle|s se rea||zarer operaoes de erlrada / saida de dados. 0u seja,
se ros perr|l|rer gerar |rleracl|v|dade cor o ul|||zador.

0peraoes de erlrada / saida de dados:
ul|||zador lorrece dados
Prograra corur|ca resu|lados
3aida ou escr|la de dados: ecra (ra|s corur)
Erlrada ou |e|lura de dados: le|la alravs do lec|ado
4.4.1 - Sada de Dados
A escr|la de rersagers ro ecra pode ser le|la ul|||zardo os suoprograras print ou println ex|slerles er
System.out (package System, c|asse out). 0ua|quer ur desles suoprograras perr|le escrever ro
ecra, d|ler|rdo aperas ro laclo de o println elecluar ura rudara de ||rra aps a escr|la o que rao acorlece
cor print .

Para se escrever ura rersager ro ecra os suoprograras print e println lr de receoer coro
parrelro a rersager a escrever, |slo deve aparecer erlre parrles|s. Por exerp|o: a |rslruao:

System.out.print (Ol a todos);

escreve ro ecra: Ol a todos

println versus print

System.out.println()


Cursor
Cursor
33
0 Pedro ler 33 aros
A sora dos do|s rureros 5
Voslra a rersager e er segu|da pos|c|ora o cursor ro |ric|o da ||rra segu|rle:

System.out.println(Primeira mensagem");
System.out.println(Segunda mensagem");
> Pr|re|ra rersager
> 3egurda rersager
>_

System.out.print()

Voslra a rersager e pos|c|ora o cursor |red|alarerle aps o va|or escr|lo:

3ysler.oul.pr|rl(Pr|re|ra rersager );
System.out.print("Segunda mensagem ");

Pr|re|ra rersager 3egurda rersager_

Exemp|os:

Exerp|o1: Escrever o va|or correrle de ura var|ve|

|rl |dade = 33;
System.out.println(idade);

Exerp|o 2: Escrever vr|os e|ererlos de ura s vez

int idade = 33;
System.out.println(O Pedro tem +idade+ anos);

Exerp|o 3: Expressoes ra ||sla de e|ererlos a escrever

int x = 3, y = 2;
System.out.println(A soma dos dois nmeros + (x + y));

4.4.2 - Entrada de Dados
A ||rguager Java d|spoe de ur suoprograra System.out.read() capaz de |er ur caracler a parl|r do
lec|ado. No erlarlo, para oulros dados de d|lic|| ul|||zaao, po|s se o dado a lorrecer ao ul|||zador lor corposlo por
ra|s do que ur caracler, por exerp|o, se lor ur rore ou ur rurero cor vr|os dig|los, esle suoprograra reve|a-se
de dil|c|| ul|||zaao, j que ler|a de ser crarado larlas vezes quarlos os caracleres que corsl|luer a |rlorraao a |er.
4.4.3 - Classe Le
Terdo er corla a d|l|cu|ade que ex|sle ra |e|lura de oulro l|po de dados, oplou-se por ul|||zar ur corjurlo de
suoprograras capazes de |er dados a parl|r da erlrada padrao. A |e|lura s lerr|rada quardo o ul|||zador press|ora
a lec|a 'Enrer, pe|o que os dados poder ser corsl|luidos por qua|quer rurero de caracleres. Esles suoprograras
ercorlrar-se agrupados ro l|cre|ro Le.java, que se ercorlra er arexo.


Ex|sle resse l|cre|ro ur suoprograra para cada l|po de dados:

T|po de va|or Crarada
int Le.umInt()
float Le.umFloat()
double Le.umDouble()
String Le.umaString()

A ul|||zaao de qua|quer ur desles suoprograras oaslarle s|rp|es.

double var_double = Le.umDouble();

Exemp|os:

Exerp|o1: Escrever ur prograra que corverla rgu|os ||dos er graus para rad|aros (|rler|ores a 30)

public class Angulo {

double angulo, angulo_rad;
System.out.print("Valor do ngulo = "); // L ngulo em graus
angulo = Le.umDouble();
angulo_rad = angulo * Math.PI / 180; // Converte para radianos
// Mostra ngulo em radianos
System.out.println ("ngulo em radianos = "+ angulo_rad);

}
}

Exerp|o 2: Escreva ur prograra para ca|cu|ar arola de ur a|uro, del|r|da da segu|rle lorra: 0 rd|a dos 2
lesles da d|sc|p||ra, 20 rd|a dos 3 re|rores lraoa|ros prl|cos e 20 lraoa|ro l|ra|.

public class Media {
double teste1, teste2, t_pratico1, t_pratico2,
t_pratico3,trab_final, nota;

// L notas dos testes, trabalhos e trabalho final
System.out.print("Nota do 1 teste = ");
teste1 = Le.umDouble();

System.out.print("Nota do 2 teste = ");
teste2 = Le.umDouble();

system.out.print("Nota do 1 melhor trabalho prtico = ");
t_pratico1 = Le.umDouble();

System.out.print("Nota do 2 melhor trabalho prtico = ");

System.out.print("Nota do 3 melhor trabalho prtico = ");


System.out.print("Nota do trabalho final = ");
trab_final = Le.umDouble();

nota = 0.6*((teste1+teste2)/2)+
0.2*((t_pratico1+t_pratico2+t_pratico3)/3)+
0.2*trab_final;

System.out.println ("Nota = "+nota); // Mostra nota
}
}
4.4.4 - Classe String
ura das c|asses predel|r|das ra ||rguager Java a c|asse String. E ura c|asse oaslarle ul|||zada e que serve
para rar|pu|ar cade|as de caracleres.

ura String serve para guardar va|ores corslarles, |slo ura vez que seja alr|ou|do ur va|or a ura String
esle rao pode ser a|lerado. Ass|r, qua|quer operaao soore ura 3tring devo|ve ura rova String (String
rod|l|cada)

String frase = Introduo Programao

A|gurs rlodos da c|asse String

Vlodo 0escr|ao
3lr|rg() Cr|a ur oojeclo do l|po 3lr|rg
char charAt(int index)
0evo|ve o caracler da pos|ao index da slr|rg
int compareTo(String anotherString) Corpara duas
slr|rgs
int indexOf(String str) 0elerr|ra a |oca||zaao da pr|re|ra ocorrrc|a de ura
cade|a de caracleres derlro de ura cade|a de
caracleres
String toUpperCase() Trarslorra er ra|uscu|as a cade|a de caracleres
int lenght() Relorra o corpr|rerlo da slr|rg

Nota: Para ra|s |rlorraoes soore os rlodos d|spor|o|||zados pe|a String corsu|lar a docurerlaao do Java.

Exemp|os:

String frase = Hoje quinta feira; Resu|tado
int tamanho = frase.lenght(); lararro=19
String palavra = frase.substring(0,4); pa|avra='loje
String novaPalavra = frase.toLowerCase(0,4); rovaPa|avra='roje
char c = palavra.charAt(2); c='j'
boolean b = novaPalavra.equals(Hoje); o=la|se
int indice = frase.indexOf(qui); |rd|ce=Z
String outraPalavra = frase.substring(indice,indice+7);
oulraPa|avra='qu|rla
String outra = outraPalavra.trim(); oulra='qu|rla

Exerc. 1: 0ua| a order de ava||aao das expressoes da laoe|a?

a + b + c + d + e

a / (b + c) - d % e

a + b * c - d / e

a / (b * (c + (d - e)))

Exerc. 2: lrd|que e corr|ja os erros s|rlcl|cos e serrl|cos do prograra da l|gura 1 e |derl|l|que-os de acordo cor o
seu carcler:

public class ImprimeTipos{
public static void main (String[] args) {
boolean b = false;
char c = r;
byte j = 127;
short k 32767;
int m = 1234567890
long n =9223372036854775870L; // L de long
float x = 3.14159265F; // F de float
double y = 3.141592653589793238;

Syste.out.println(b= + c);
System.outprintln(c= + c);
Systemout.println(j= + j);
System.out.println(k= + y);
System.out.println(bm= + b);
System.out.println(n= + n);
System.out.print(x= + x);
System.out.println(y= + y);
}
}
Figura 1

Exerc. 3:
Escreva ur prograra er Java que |r|c|a||ze ura var|ve| |rle|ra r cor o va|or 5811 e er segu|da recorra aos
operadores quoc|erle da d|v|sao |rle|ra e reslo da d|v|sao |rle|ra para exlra|r e |rpr|r|r cada ur dos dig|los de r. A
saida do prograra deve ser do l|po:
N = 5811
0s dig|los de r sao 5, 8, 1, e 1
Corse|ro: use r/1000 para exlra|r o d|g|lo dos r||rares de r, e r=1000 para rerover o d|g|lo dos r||rares de r.

Exerc. 1:
Ca|cu|e o va|or das expressoes da laoe|a, ass|ra|ardo os casos er que la| rao seja possive|.

23 + 34 < 123 (23+34<123) && (89.1*100>200)
89.1 * 100 > 200 (89.1*100>200) || (34.3 != 34)
78 / 2 == 50 (78/2==50) && (23+34<123)
67.23 * 200 <= 500 (67.23*200<=500) || (78/2==50)

900 200 >= 1000 (900200>=1000) && (67.23*200<=500)
34.3 != 34 (34.3!=34) || (78/2==50)

Exerc. 5:
Escreva ur prograra que ca|cu|e a rd|a de prec|p|laao de lrs reses, Aor||, Va|o e jurro. 0ec|are e |r|c|a||ze ura
var|ve| cor a prec|p|laao de cada rs, ca|cu|e a rd|a e escreva o resu|lado sooa a lorra:
Prec|p|laao er Aor||: 12.
Prec|p|laao er Va|o: 11.
Prec|p|laao er Jurro 8
Vd|a da prec|p|laao: 11.333333
Para a||rrar os va|ores rurr|cos use o caracler de laou|aao '\l' coro parle da slr|rg de caracleres ras |rslruoes
de saida. ver|l|que se o prograra apreserla os resu|lados correclos.

Exerc. :
Escreva ur prograra para reso|ver cada ura das segu|rles s|luaoes
a) Ler ur rurero |rle|ro, ru|l|p||c-|o por 2 e escrever o resu|lado.
o) Ler do|s rureros |rle|ros e escrever a sua sora, d|lerera e produlo.
c) Ler do|s rureros rea|s e escrever a sua sora, d|lerera e produlo.

Exerc. Z:
0s lraoa|radores de ura erpresa l|verar ur aurerlo de 3,1 cor ele|los relroacl|vos de reses. Ler o arl|go
sa|r|o rersa| dos lraoa|radores e escrever o va|or dos relroacl|vos e do sa|r|o rersa|.

Exerc. 8:
Ca|cu|ar o preo do a|uguer de ur video oaseado ro cuslo/d|a (corslarle ao |orgo de ur aro) e ro rurero de d|as
que o sc|o leve o video er seu poder.

Exerc. 9:
Escreva ur prograra para ca|cu|ar a rd|a de ur corjurlo de 10 rureros |rser|dos pe|o ul|||zador.

Exerc. 10:
Para ca|cu|ar o sero de ur va|or de dup|a prec|sao use os rlodos Math.sin(value) e
Math.cos(value). Nole que os va|ores do argurerlo sao er rad|aros e rao er graus.
a) Escreva ur prograra para ca|cu|ar o sero e o cosero de 0.53. Arrazere cada ur de|es rura var|ve| e er
segu|da ca|cu|e o quadrado da sua sora e arrazere-o rura lerce|ra var|ve|. Escreva o va|or das lrs var|ve|s
rura lorra sere|rarle a

3ysler.oul.pr|rl|r(s|re: s|rx cos|re: cosx sur: sur );

o) Exper|rerle cor oulros va|ores a|r de 0.523

Exerc. 11:
Ed|le o prograra do exercic|o arler|or ad|c|orardo-|re ura |rslruao que corverla graus er rad|aros e use-a para
alr|ou|r va|ores a x er graus e depo|s de corverl|dos er rad|aros us-|os coro argurerlo dos rlodos
Math.sin e Math.cos. 0 rlodo Math.PI d-|re ur va|or ru|lo prec|so do va|or de Pi.

5 - Instrues de Controlo

Al aqu|, lodos os exerp|os de cd|go que v|ros segu|ar ura eslrulura a que se d o rore de sequerc|a|. Nao
l|rrar rerrura |rslruao que de a|gura lorra l|zesse rudar o l|uxo de execuao da ap||caao. 0u seja, as
|rslruoes sao execuladas ura aps a oulra de acordo cor a order por que aparecer. Esla l||osol|a ||r|la er ru|lo
a ul|||dade dos prograras que se possar v|r a produz|r.
Reso|ver proo|eras ra|s corp|exos ex|ge ur ra|or poder de dec|sao soore a lorra coro o prograra execulado
(l|uxo de execuao), o que ros poss|o|||lado pe|as |rslruoes de corlro|o. 0 que eslas lrazer de rovo a
capac|dade de corlro|ar a execuao de ura ap||caao red|arle o eslaoe|ec|rerlo de cord|oes |g|cas.

Ex|sler esserc|a|rerle do|s l|pos de |rslruoes de corlro|o:

1. 8e|eco: perr|ler delerr|rar o car|rro a segu|r de acordo cor o va|or de ura expressao;
2. Repet|o: perr|ler corlro|ar o rurero de vezes que ur delerr|rado o|oco de |rslruoes execulado
(sao os crarados c|c|os).
5.1 - Seleco
Ao |rp|ererlar ap||caoes poderos ler que lorar dec|soes cor oase er va|ores de expressoes, dados lorrec|dos
pe|o ul|||zador, resu|lados ca|cu|ados, elc.
0esle l|po de recess|dades surg|rar as |rslruoes de se|ecao: para |rpr a execuao cord|c|ora| de |rslruoes.

A se|ecao de |rslruoes pode ser:

8|mp|es: Cor oase ra cord|ao a ava||ar execula ur o|oco de |rslruoes ou erlao rao execula;
Em a|ternat|va: Ter duas poss|o|||dades de o|ocos de |rslruoes a execular. Cor oase ra cord|ao, ou
execula ur ou execula oulro.
H|t|p|a: As poss|o|||dades sao vr|as e as cord|oes a ver|l|car laror, o o|oco a execular esco|r|do
cor oase ra cord|ao cuja ver|l|caao lerra s|do pos|l|va.

Er Java as |rslruoes de se|ecao sao as segu|rles:

if/else
switch - case

Cor eslas |rslruoes poderos corcrel|zar cada ur dos lrs l|pos de se|ecoes ac|ra rerc|orados.
5.1.1 - Seleco Simples: if
ur exerp|o de ura se|ecao s|rp|es represerlado por ur l|uxograra pode ser o segu|rle:

Cord
?
lrslruoes...
verdade
la|so

F|gura 2Z. F|uxograra de ura |rslruao de se|ecao s|rp|es

Corea por ser ava||ada ura cord|ao |g|ca. 3e o seu resu|lado der verdade|ro, erlao execulado ur delerr|rado
o|oco de |rslruoes. Caso corlrr|o, a execuao do prograra prossegue serdo esse o|oco |grorado.

Er Java, esle l|po de se|ecao corcrel|za-se recorrerdo a |rslruao if, cuja s|rlaxe a segu|rle:

0|agrama s|ntct|co:

F|gura 28. 0|agrara 3|rlcl|co da |rslruao de se|ecao if

NF para uma |nstruo de se|eco s|mp|es - if:

<instruo if> ::= if (<expresso-lgica>)
<instruo>;

6d|go exemp|o para uma |nstruo |f:

if (condio) {
instrues;
}

Exemp|o 1:

public class TesteIdade
{
public static void main(String args[])
{
int idade = 14;
// Verificar se um individuo tem
// idade para guiar
if (idade < 16)
System.out.println(Muito novo para guiar);
}
}

Exemp|o 2:

// Programa que gera um nmero aleatrio e reporta se
// o nmero gerado ou no negativo


public class NumNeg
{
if
instruo expresso ( )

{
int n = random.nextInt();
System.out.println(n = + n);

if (n < 0)
System.out.println(*** n < 0! ***);

System.out.println(Adeus.);
}

5.1.2 - Seleco Em Alternativa: if-else
Vu|las vezes |rleressa-ros que, quardo a cord|ao a ver|l|car seja la|sa, raja ur corjurlo a|lerral|vo de |rslruoes a
execular. E a |slo que se d o rore de se|ecao er a|lerral|va, que, er lerros de l|uxograra pode ser represerlada
da segu|rle lorra:

F|gura 29. F|uxograra de ura |rslruao cor se|ecao a|lerral|va

Recap|lu|ardo: 3e a cord|ao lor verdade|ra, execulado o corjurlo de |rslruoes A. 3e lor la|sa, execulado er
a|lerral|va o corjurlo de |rslruoes 8. 0 prograra segue depo|s cor as |rslruoes que l|ver para execular a segu|r.

Er lerros de s|rlaxe Java, esle l|po de se|ecao represerla-se da segu|rle lorra:

0|agrama s|ntct|co:

F|gura 30. 0|agrara s|rlcl|co da |rslruao de se|ecao if-else

Cord
?
A - lrslruoes...
verdade la|so
8 - lrslruoes...
if
instruo expresso
else
( )
instruo

NF da |nstruo de se|eco em a|ternat|va - |f|e|se:

<instruo if> ::= if (<expresso-lgica>)
<instruo>;
else
<instruo>;

6d|go exemp|o de uma |nstruo |f|e|se:

if (condio) { // as chavetas aparecem quando h mais que
// uma instruo a executar dentro do if ou
// do else. Passa a ser composto!
instrues;
}
else {
instrues;
}

Exemp|o 1:

public class TesteNota
{
{
int Nota = 14;

// Resultado da avaliao
if (nota < 10)
System.out.println(Nota negativa);
else
System.out.println(Nota positiva);
}
}

Exemp|o 2:

// Programa que gera dois nmeros aleatrios
// e reporta qual deles o menor.

public class Menor
{
{
int m = random.nextInt();
System.out.println("m = " + m);
int n = random.nextInt();
System.out.println("n = " + n);
if (m < n) // o que acontece se m=n?
System.out.println(O menor numero e " + m);

else
System.out.println("O menor numero e " + n);
}
}

As |rslruoes if poder ser represerladas er para|e|o ou ercadeadas, caso raja vr|as a|lerral|vas a esludar e a
represerlar.

Exemp|o 3:

// Determinar a ordem de grandeza
// dos trs nmeros (a, b, c) usando ifs encadeados.

// cdigo:
if (a < b)
if (b < c)
System.out.println("a < b < c");
else
if (a < c)
System.out.println("a < c < b");
else
System.out.println("c < a < b");
else
if (a < c)
System.out.println("b < a < c");
else
if (b < c)
System.out.println("b < c < a");
else
System.out.println("c < b < a");

a < o < c

a < c < o

c < a < o

o < a < c
o < c < a

c < o < a

s|r
rao
s|r
rao
(o < c) ?
(a < c) ?
s|r
rao
(a < c) ?
(o < c) ?
s|r
rao
(a < o) ?
s|r
rao

Exemp|o 4:

// Determinar a ordem da grandeza
// dos trs nmeros (a, b, c) usando ifs paralelos.

// cdigo:
if (a < b && b < c) System.out.println("a < b < c");
if (a < c && c < b) System.out.println("a < c < b");
if (b < a && a < c) System.out.println("b < a < c");
if (b < c && c < a) System.out.println("b < c < a");
if (c < a && a < b) System.out.println("c < a < b");
if (c < b && b < a) System.out.println("c < b < a");

Esserc|a|rerle, ao lorar a dec|sao de usar ifs de lorra ercadeada ou er para|e|o eslaros aperas a ler er
corla o laclo de cada cord|ao a ver|l|car deperder ou rao das arler|ores.

Er re|aao ao uso especil|co da a|lerral|va else, r ura rola |rporlarle a lazer. l casos er que o else pode,
er lerros serrl|cos, lorrar-se aroiguo, ou seja, ser susceplive| de |rlerprelaoes d|lererles rura resra
s|luaao.

Exemp|o 5:

if ( numeroAluno > 1200)
if (numeroAluno < 2000)
System.out.println("O aluno tem um numero entre 1201 e 1999");
else
System.out.println("O aluno tem um numero inferior ou igual a
1200");

A que if pertence o else?

0a lorra coro esl escr|lo o cd|go, parece ser dado a erlerder que o else represerla a a|lerral|va a cord|ao
numeroAluno > 1200....
Vas ra rea||dade o cd|go ler ur erro de |rderlaao e o else represerla ura a|lerral|va a cord|ao
numeroAluno < 2000.
a<o? o<c?
a<c? c<o?
o<c? c<a?
o<a? a<c?
c<a? a<o?
c<o? o<a?
a<o<c
a<c<o
o<a<c
o<c<a
c<a<o
c<o<a

Nao poder ex|sl|r aro|gu|dades quarlo ao car|rro a segu|r ra execuao de |rslruoes. 3e rao l|vesse s|do
esl|pu|ada a parl|da ura regra para o Java operar resles casos, o |rlerprelador rao saoer|a o que lazer quardo |re
surg|sse ur corjurlo de |rslruoes desle grero.
Er Java, a serrl|ca da |rslruao if/else d|la que ur else perlerce serpre ao if que lo| de|xado er aoerlo
er u|l|ro |ugar. 0u seja, ao u|l|ro if ser else.

Na s|luaao arler|or, para lorar a que o else esl|vesse assoc|ado ao pr|re|ro if, leriaros de usar de||r|ladores:

if ( numeroAluno > 1200) {
if (numeroAluno < 2000)
System.out.println("O aluno tem um numero entre 1201 e 1999");
}
else
System.out.println("O aluno tem um numero inferior ou igual a 1200");

Nesle caso, d|zeros que o segurdo if e a rersager que esle erv|a para o cara| de saida (caso a cord|ao seja
verdade|ra), lazer parle do o|oco de |rslruoes a execular quardo numeroAluno > 1200 ler o va|or true.
Torrro-|as rura |nstruo composta.

Nota: Pode raver ifs ser elses, ras o corlrr|o rao se ap||ca.

Exemp|o :

// Se tem menos que 70 pontos, visualizar Deve melhorar
// Se tem mais que 95 pontos, visualizar Trabalho
// excelente!
// Se tem entre 70 e 95, no visualizar mensagem
// O cdigo seguinte est certo ou errado?

import Le;

public class Pontos
{
{
int pontos = Le.umInt();

/* Sem as {} sabemos a que if pertence o
else? E esse o resultado desejado? */
if (pontos >= 70)
if (pontos > 95)
System.out.println(" Trabalho excelente!");
else
System.out.println(" Deve melhorar ");
}
}

Ap||cardo a regra de que ur else perlerce ao u|l|ro if de|xado er aoerlo, o else perlerce ao if orde se
ver|l|ca se pontos > 95l
Er lerros s|rlcl|cos ser|a ass|r que a rqu|ra v|rlua| Java |r|a |rlerprelar, po|s rao r rarger para aro|gu|dades.
A rqu|ra ler de saoer serpre qua| a prx|ra |rslruao a execular.
Er lerros serrl|cos, c|ararerle leriaros aqu| ur erro de |rlerprelaao do proo|era e os resu|lados rao ser|ar os
ped|dos pe|o erurc|ado.

5.1.3 - Seleco Mltipla: switch - case
Nos l|pos de |rslruoes de se|ecao descr|los arler|orrerle ver|l|cros que possive| ul|||zar d|lererles lorras da
|rslruao |l para se|ecc|orar a a|lerral|va que ra|s ros corvr.
No erlarlo, se a dec|sao a lorar l|ver que ser le|la cor oase rur va|or |rle|ro ou rura |elra ao |rvs de ur va|or
|g|co, erlao a eslrulura de se|ecao ru|l|p|a que varos apreserlar lorra-se ra|s el|caz.

Er lerros de l|uxograra pode ser represerlada da segu|rle lorra(corsu|lar ||vro FCA - Furdarerlos de
Prograraao er Java2 para ra|s dela|re):

F|gura 31. F|uxograra de ura |rslruao de se|ecao ru|l|p|a

Corea por ca|cu|ar o va|or da expressao exp que ler de ler ur resu|lado de l|po |rle|ro ou caracler. 0epo|s,
corpara o va|or da expressao corlra os va|ores v1 a vr. 3e lor |gua| ao de a|gur de|es, execula o o|oco de |rslruoes
corresporderle.
3e o va|or da expressao a execular rao lor |gua| a rerrur dos va|ores v1... vr, pode suceder ura de duas s|luaoes:
rao r ra|s rerrura a|lerral|va a cors|derar e porlarlo rerrur o|oco de |rslruoes a execular
r ura a|lerral|va prorla a ser execulada quardo ra|s rerrura serve e essa a esco|r|da (ro l|uxograra
esl represerlada pe|o va|or outro).

Er Java, a |rslruao que se usa para represerlar s|luaoes de se|ecao ru|l|p|a a |rslruao switch. A |rslruao
switch laror ura |rslruao de se|ecao que, cor oase ra ava||aao de ura var|ve| ou expressao de va|or
|rle|ro (ou caracler) esco|re, erlre vr|as a|lerral|vas possive|s, ura |rslruao ou corjurlo de |rslruoes a execular.

exp
l1 l2 lr |d
...
v1 v2 vr outro

Er lerros s|rlcl|cos leros:

0|agrama s|ntct|co:

F|gura 32. 0|agrara s|rlcl|co da |rslruao de se|ecao ru|l|p|a switch-case

NF para uma |nstruo de se|eco m|t|p|a - switch/case:

switch (<expresso>)
{
case <valor 1>:
<instruo 1>;
break;

case <valor n>: [case <valor m>:]
<instruo x>;
break;
default:
<instruo y>;
break;
}

A |rslruao break aps cada case serve para ev|lar que os prx|ros cases sejar execulados. 3e r ur case que
ler o resro va|or da expressao o seu o|oco de |rslruoes deve ser execulado e o break laz cor que a |rslruao
switch seja lerr|rada.
0 default o caso que deve ser execulado quardo ra|s rerrur serve (segurdo o l|uxograra a opao outro).
0s cases que rao sejar exp||c|larerle prograrados rur switch ser default sao |grorados. A ex|slrc|a do
default loca o prograrador ra recess|dade de processar cord|oes excepc|ora|s. l, ro erlarlo, s|luaoes er
que a ul|||zaao do default rao recessr|a.

Nota:

Esquecer ur break orde e|e deve ser usado, corduz a erros |g|cos ou serrl|cos.
Eroora a order dos cases e do default rao esleja esl|pu|ada a parl|da, cors|derada ooa prl|ca
co|ocar o default er u|l|ro |ugar.
switch (expresso)
case
constante
:
instruo brea
k
;
{
}
defaul
t

0 break aps a u|l|ra |rslruao case (ou default, se esla lor a u|l|ra), rao recessr|o. Vu|los
prograradores co|ocar-ro aperas por ura queslao de coerrc|a e s|relr|a para cor as arler|ores.

Exemp|o 1:

import Le;

public class Pontos
{
{
int pontos;
System.out.print (Digite um inteiro entre 1 e 100:> );
pontos = Le.umInt();

switch (pontos/10)
{
case 10:
case 9: System.out.println("A - Excelente!");
break; // por exemplo, se o break nao estivesse aqui
// e pontos/10 = 9, o bloco seguinte (do case 8)
// era executado na mesma, conduzindo a um erro!
case 8: System.out.println(B - Bom trabalho!");
break;
case 7: System.out.println("C - Pode fazer melhor!");
break;
case 6: System.out.println("D - Falamos depois da aula.");
break;
default: System.out.println("F Vai trabalhar!");
}
}
}

Exemp|o 2:

import Le;

public class TestaCaracter
{
{
char ch = Le.umChar();

switch (ch)
{
case 0: case 1: case 2: case 3: case 4:
case 5: case 6: case 7: case 8: case 9:
return (ch 0);

case a: case b: case c: case d: case e:
case f:
return (ch a) + 10;

case A: case B: case C: case D: case E:
case F:

return (ch A) + 10;

default:
System.out.print(Adeus.);
}
}
}
// No h breaks porque cada expresso tem um return que
// sai do bloco antes que se tente sequer avanar
// para o prximo!

If Versus Switch

0 if apropr|ado para lesles er expressoes que represerler va|ores |g|cos
0 switch laz se|ecoes cor oase expressoes cujos va|ores sejar |rle|ros
ul|||za-se o if quardo
o 0 rurero de a|lerral|vas pequero
o 0uereros |rpor ura order ra ava||aao da expressao
o A esco|ra oaseada er garas de va|ores (l|po x>1, ou y>100 && y>200... )
ul|||za-se o switch quardo
o 3e leslar expressoes cujos resu|lados sao va|ores de l|pos erurerve|s (|rle|ros, caracleres)
5.2 - Repetio
E lurdarerla| que ura ||rguager de prograraao d suporle a repel|ao de larelas, rao s por ura queslao de
el|c|rc|a ras laror de produl|v|dade.
3e r ura larela que deve ser execulada 500 vezes, rao varos escrever 500 vezes o resro o|oco de cd|go. Nao
s de|xa de ser produl|vo, carsal|vo e desrol|varle, ras a|rda por c|ra lorra o cd|go ra|s susceplive| a erros
que para serer corr|g|dos ros oor|gar a percorrer cada ur dos o|ocos de |rslruoes que prograrros
repel|darerle.
As |rslruoes que ros perr|ler reso|ver esle l|po de proo|eras de ura lorra ra|s el|caz sao as |rslruoes de
repel|ao, laror correc|das por c|c|os.

ur c|c|o ura sequrc|a de |rslruoes execulada de lorra repel|l|va e suje|la a ura cord|ao de lrr|ro. E
rorra|rerle corposlo por:
Corpo: corjurlo de |rslruoes a repel|r
ura cord|ao ou oulra eslrulura que corlro|a a execuao do corpo, espec|l|cardo de a|gura lorra a
quarl|dade de vezes que esle deve ser execulado (rurero de |leraoes).

0uardo ur c|c|o rao ler l|r, ou seja, repele as |rslruoes do corpo |rdel|r|darerle, d|z-se que se lrala de ur 6|c|o
|nf|n|to.
Esle l|po de s|luaoes aoso|ularerle |rdesejve| po|s se ur c|c|o rao lerr|ra o prograra rao avara e,
corsequerlererle, a sua execuao laror rao ler l|r rer produz|r resu|lados. Para a|r d|sso, correros o
r|sco de esgolar os recursos do corpulador rap|darerle se durarle esse c|c|o |rlerr|rve| rouver operaoes
ex|gerles er lerros de requ|s|los de rerr|a, por exerp|o.

Er Java ( e ra ra|or|a das ||rguagers de prograraao de a|lo rive|), r lrs l|pos de |rslruoes de repel|ao:

while
do-while
for

5.2.1 - Instruo de Repetio while
Esla |rslruao de repel|ao oase|a-se ra ava||aao de ura cord|ao |g|ca para delerr|rar a corl|ruaao (ou rao) da
execuao do corpo do c|c|o.

0e acordo cor o que ros roslra o l|uxograra segu|rle, o que veros que erquarlo a cord|ao l|ver o va|or
verdade|ro (true), o corpo corl|rua a ser execulado.

F|gura 33. F|uxograra de ura |rslruao de repel|ao while

Er lerros s|rlcl|cos leros:

0|agrama 8|ntct|co:

F|gura 31. 0|agrara s|rlcl|co da |rslruao de repel|ao while

NF de uma |nstruo while:

<instruo while> ::= while (<expresso>)
<instruo>;

6d|go exemp|o de uma |nstruo wh||e:

// as chavetas aparecem se houver mais do que uma instruo
// a executar no corpo do ciclo
while(condio){
instrues;
}

?
lrslruoes
v
F
while
expresso-lgica instruo
( )

Aps ura pequera ar||se dos d|agraras e s|rlaxes apreserlados ac|ra, r a|guras pequeras rolas a lazer:

A ava||aao da expressao ou cord|ao ler que ler oor|galor|arerle coro resu|lado ur va|or |g|co (true
ou false).
0 corpo do c|c|o pode ser ura |rslruao s|rp|es ou corposla. lslo , pode raver ura ou ra|s |rslruoes a
repel|r.
Essas |rslruoes sao repel|das erquarlo a cord|ao a ava||ar er cada passager lor verdade|ra.
3e a cord|ao a ver|l|car l|ver a parl|da o va|or la|se, o c|c|o rao cregar a ser execulado.
Para que o c|c|o rao se lorre |rl|r|lo, leros de gararl|r de a|gura lorra que a expressao ava||ada a cada
passager cregar a ler o va|or la|se. lsso corsegue-se lazerdo cor que ura das |rslruoes do corpo do
c|c|o se ercarregue de rudar o va|or da cord|ao ro rorerlo apropr|ado.

Exemp|o 1:

public class CicloWhile
{
{
int a=30, b=15, i=3;

while (i>0)
{
a-=10;
b-=5;
i--;
System.out.println(A + a + B + b);
}
}
} // qual o resultado produzido?

Exemp|o 2:

/* Programa que gera um nmero entre 1 e 100 verifica se o nmero
primo (primo um nmero maior que 2 e que divisvel somente por si
prprio e por 1) */

public class NumeroPrimo {
int d = 2;
int x = random.nextInt(100)+1;
boolean primo = (x > 1);

while (primo && d <= x)
primo = (x % d++ != 0);

if (primo)
System.out.println(x + " e primo.");
else
System.out.println(x + " no primo.");
}
}


Exemp|o 3:

public class CicloInfinito
{
{
int a=0, i=0;
do
{
++a;
++i;
System.out.println(A + a);
}
while (i > 0);
}
} // Este um exemplo a no seguir!
5.2.2 - Instruo de Repetio do-while
A |rslruao de repel|ao do-while sere|rarle a arler|or (while), ro serl|do er que execula o corpo do c|c|o
erquarlo a cord|ao a ava||ar lor verdade|ra.
0ever respe|lar-se as resras regras para ev|lar a geraao de c|c|os |rl|r|los, ou seja, r que gararl|r que ro corpo
do c|c|o ex|sle a|gura |rslruao que ro rorerlo cerlo ruda a o va|or da cord|ao por lorra a queorar o c|c|o.
Apesar de o rodo de lurc|orarerlo ser aparerlererle o resro, o do-while corporla-se de rare|ra
||ge|rarerle d|lererle: pr|re|ro execula o corpo do c|c|o e s depo|s ava||a o va|or da cord|ao de parager. lslo laz
cor que se gere ura ruarce que rarca loda a d|lerera:

Por ava||ar pr|re|ro a cord|ao, ur while pode rurca cregar a execular o corpo, se a cord|ao lor la|sa
|ogo a parl|da. 0|z-se que o while executa 0 ou ma|s vezes.
Por ava||ar a cord|ao ro l|r, ur do-while execula serpre o corpo pe|o reros ura vez. 0 do-
while executa 1 ou ma|s vezes.

Er lerros de l|uxograra, ur do-Wr||e pode represerlar-se da segu|rle lorra:

F|gura 35. F|uxograra da |rslruao de repel|ao do-while

?
lrslruoes
v
F

@ Esco|a 3uper|or de Tecro|og|a de 3eluoa| 2001-2005 Pg|ra

0|agrama 8|ntct|co:

F|gura 3. 0|agrara 3|rlcl|co da |rslruao de repel|ao do-while

NF para uma |nstruo do-while:

<instruo do-while> ::= do
<instruo>
while(<expresso>);

6d|go exemp|o para uma |nstruo do-while:

do { // as chavetas aparecem quando o corpo do ciclo tem
// mais do que uma instruo a executar!
instrues;
} while(condio);

Exemp|o 1:

public class CicloDoWhile
{
{
int a=0, i=0;

do
{
++a;
++i;
System.out.println(A + a);
}
while (i<3);
}
} // qual o resultado produzido?

Exemp|o 2:

// Programa que gera um nmero entre 1 e 100
// e verifica se o nmero primo.

public class Primo
{
do
expresso-lgica
instruo
( )
while

public static void main(String[] args)
{
boolean primo;
int d = 2;
int n = random.nextInt(100)+1;

do
primo = (n % d++ != 0);
while (primo && d < n);

if (primo)
System.out.println(n + " primo.");
else
System.out.println(n + " no primo.");
}
}

Recap|tu|ando:

A |rslruao de repel|ao while corea por ava||ar a expressao :
o 3e lor verdade|ra erlra ro c|c|o
o Execula |rslruao ou o|oco de |rslruoes |rlerras ao c|c|o
o A cada rova |leraao re-ava||a a expressao |g|ca
o 3e a expressao se lorrou la|sa o c|c|o lerr|ra
A |rslruao do-while:
o Execula o o|oco de |rslruoes |rlerras ao c|c|o
o Ava||a a expressao
o 3e lor verdade|ra corl|rua o c|c|o, serao lerr|ra
Corc|usao:
o A |rslruao do-while execula o o|oco de |rslruoes ura ou ra|s vezes
o A |rslruao while execula o o|oco de |rslruoes zero ou ra|s vezes
5.2.3 - Instruo de Repetio for
A |rslruao for oulra |rslruao de repel|ao ru|lo ul||, parl|cu|arrerle quardo se correce de arlerao a
quarl|dade de |leraoes recessr|as (ou seja, o rurero de vezes que se prelerde repel|r o corpo do c|c|o).
A execuao do corpo do c|c|o lor esl, regra gera|, deperderle da ava||aao do va|or de ura var|ve| de corlro|o.

0|agrama 8|ntct|co:

F|gura 3Z. 0|agrara s|rlcl|co da |rslruao de repel|ao for

for (
expresso
lgica
;
expresso
instruo
;
expresso
)

NF para a |nstruo de repet|o for:

<instruo for> ::= for(<inicializao>;<expressoC>;<incremento>)
<instruo>;

<inicializao> ::= <varCont> = <identificador> |
<varCont> = <valor>

<varCont> ::= <identificador>
<expressoC> ::= <expresso> <operador lgico> <expresso>
<incremento> ::= <identificador> <operador incremental> |
<identificador> ::= <identificador> = <instruo>

|r|c|a||zaao a expressao que |r|c|a||za o c|c|o alr|ou|rdo ur va|or |r|c|a| a var|ve| de corlro|o <varCorl>
expressaoC represerla o lesle que elecluado er cada c|c|o.
lrcrererlo a |rslruao que a|lera o va|or da var|ve| de corlro|o.

6d|go exemp|o para a |nstruo de repet|o for:

for(expresso1;expresso2;expresso3){
instrues
}
0 rodo de lurc|orarerlo o segu|rle:
1. Parle de expresso1.
2. Ava||a expresso2.
o 3e verdade|ra:
execula |rslruao
execula |rcrererlo delerr|rado por expresso3 para a var|ve| de corlro|o de
expresso1
regressa ao passo 2
o 3e la|sa:
Terr|ra o c|c|o

Er lerros de l|uxograra, ur for poder-se-|a represerlar da segu|rle lorra (segu|rdo ||lera|rerle a espec|l|caao
do c|c|o):

F|gura 38. F|uxograra da |rslruao de repel|ao for

Exp2?
lrslruoes
Ap||ca Exp3 a Exp1
v
F


Notas:

Nur c|c|o for, deveros ler er alerao que, a var|ve| de corlro|o, ao ser dec|arada ro caoea|ro do
c|c|o, s correc|da derlro do seu corpo. 3e lerlarros us-|a lora do c|c|o ooleros ur erro de s|rlaxe.
Para corsegu|r esse ele|lo deveros dec|ar-|a arles do caoea|ro do c|c|o (a |r|c|a||zaao pode, ou rao,
ser le|la resse caoeca|ro).
ur erro corur de prograraao cors|sle er usar v|rgu|as, ao |rvs de porlos e v|rgu|a, para separar as
expressoes do caoea|ro do for.
Norra|rerle gerar-se erros serrl|cos/|g|cos se co|ocarros ur ; |red|alarerle a segu|r ao } do
caoea|ro do for, |slo porque ass|r o c|c|o rao ler corpo e passa a execular ura sucessao de |rslruoes
vaz|as.

Exemp|o 1:

public class CicloFor
{
{
int a=0, b=0;
for (int i=0; i<3; i++)
{
a+=10;
b+=5;
System.out.println(A + a + B + b);
}
}
}

Exemp|o 2:

// Programa que gera aleatoriamente um nmero entre 1 e 100
// e verifica se o nmero primo.


public class Primo
{
{

int n = random.nextInt(100)+1;

for (int d = 2; d < n; d++)
if (n%d == 0) {
System.out.println(n + " no primo.");
return;
}

System.out.println(n + " primo.");
}
}


@ Esco|a 3uper|or de Tecro|og|a de 3eluoa| 2001-2005 Pg|ra Z0

Todas as 3 expressoes do caoea|ro do lor sao opc|ora|s:

3e or|l|rros a expresso2, o Java assure que a cord|ao de corl|ruaao do c|c|o true, gerardo
porlarlo ur c|c|o |rl|r|lo.
Poderos or|l|r a expresso1 se |r|c|a||zarros a var|ve| de corlro|o arles do c|c|o.
Poderos or|l|r a expresso3 se o prograra ca|cu|ar o |rcrererlo ou decrererlo cor |rslruoes
derlro do corpo do c|c|o.

6|c|os Encadeados

Ta| coro poderos ler |rslruoes de se|ecao ercadeadas, laror poderos ler c|c|os ercadeados, ou seja, ler
c|c|os derlro de c|c|os.
A regra d|la aperas que o c|c|o ra|s |rler|or o u|l|ro a ser execulado. 0esde que o exler|or reura as cord|oes para
prossegu|r, o |rler|or laror ler a sua crarce de rea||zar lraoa|ro.

Exemp|o 3:

public class CiclosEncadeados
{
{
final int SIZE = 5;
for (int x = 1; x <= SIZE; x++)
{
for (int y = 1; y <= SIZE; y++)
{
int z = x*y;
if (z < 10) System.out.print(" ");
System.out.print(" " + z);
}
System.out.println();
}
}
}

Nota:

Nao acorse|rve| ercadear ru|los c|c|os urs ros oulros. Torra ru|lo ra|s d|lic|| a rarulerao do cd|go e a
reso|uao de proo|eras, ou seja, aurerlaros loda a corp|ex|dade da so|uao.
ura rlr|ca razove| ser|a rurca ul|||zar ra|s do que lrs c|c|os ercadeados.

while versus do-while, versus for

Aps saoerros coro lurc|ora cada l|po de |rslruao de repel|ao res|de a|rda ura queslao por reso|ver: qua| de|as
deve ser usada er cada s|luaao?

ur c|c|o for, usa-se esserc|a|rerle quardo o rurero de repel|oes correc|do arles do |ric|o da sua execuao.
Er Java, o for l|exive| o sul|c|erle para que possa ser ul|||zado er s|luaoes orde o rurero de repel|oes seja
laror corlro|ado por ura cord|ao |g|ca e er que o rurero de repel|oes rao seja correc|do de arlerao. No
erlarlo, apesar de la| ser possive| e de produz|r ur cd|go ra|s corpaclo, por rorra laror ra|s d|lic|| de |er e
corpreerder caso lerraros de corr|g|r erros.


0uardo o rurero de repel|oes rao correc|do a parl|da, eslardo a execuao do o|oco de |rslruoes deperderle
aperas de ura cord|ao |g|ca, deveros erlao ul|||zar o while.

0everos usar ur c|c|o do-while er s|luaoes er que o o|oco de |rslruoes a repel|r, para a|r de eslar
deperderle da ava||aao de ura cord|ao |g|ca, deva ser execulado pe|o reros ura vez. A||s, esse o porlo que
rarca a d|lerera erlre ur do-while e os oulros do|s l|pos de |rslruoes de repel|ao.
Cor esla sr|e de proo|eras prelerde-se que o a|uro:
1. Correa a serrl|ca e s|rlaxe das d|lererles |rslruoes de corlro|o
2. Aprerda a usar as |rslruoes de corlro|o e dor|re a sua ul|||zaao ras ra|s var|adas lorras

Parte | - 0uestes ter|cas:

1. 0ue l|pos de |rslruoes de corlro|o correce?
2. Na sua op|r|ao, para que server as |rslruoes de corlro|o?
3. 0ua| o oojecl|vo da |rslruao |l? E do sW|lcr? 0ua|s as d|lereras erlre eslas duas |rslruoes de se|ecao?
Er que l|po de s|luaoes se deve usar ura ou a oulra? Jusl|l|que lodos os passos da resposla.
1. Ao ul|||zar o |l ler de ul|||zar serpre e oor|galor|arerle ur e|se? 3e rao lor o caso |rd|que a que s|luaoes se
ap||car a ul|||zaao do e|se.
5. E possive| ler |rslruoes |l ercadeadas ou para|e|as. verdade|ro ou la|so?
. Para que serve a ul|||zaao da |rslruao orea| ro cd|go de ur sW|lcr?
Z. 0 que represerla a opao de delau|l?
8. 0 que ur c|c|o? 0ua| a rol|vaao que ercorlra ra ul|||zaao de |rslruoes de repel|ao?
9. 0ua|s sao as |rslruoes de repel|ao que correce? 0ua|s as d|lereras erlre e|as? 0uardo acra que deve
ul|||zar cada ura? Jusl|l|que cada passo da resposla.
10. E possive| cod|l|car c|c|os ercadeados? 0ua|s sao as ||r|laoes que ercorlra resle l|po de so|uao?
11. 0 que sao c|c|os |rl|r|los?

Parte || - 6ond|c|ona|s e 6|c|os

Exerc. 1: Para os exercic|os segu|rles |rd|que o oulpul que espera coro resu|lado, lerdo er corla a dec|araao e
|r|c|a||zaao das segu|rles var|ve|s:

final int MAX = 25, LIMIT = 100;
int num1 = 12, num2 = 25, num3 = 87;

A||nea A
if (num3 >= LIMIT)
System.out.println ("ma");
System.out.println ("laranja");
System.out.println ("pera");
A||nea
if (num2 == MAX)
{
}
A||nea 6
if (LIMIT+num3 <= 150)
{

}
else
A||nea 0
if (num1 < MAX)
if (LIMIT >= num2)
A||nea E
if (LIMIT%num1 + 4 == num1 + (MAX-num2))
{
}
else
{
System.out.println ("banana");
}
A||nea F
if (num2 > 18)
if (num1 < 0)
else

A||nea C
if (num3 >= MAX)
{
if (MAX/num2 == 1)
if (LIMIT-num3 > num1+2)
else
{
System.out.println ("banana");
System.out.println ("kiwi");
}
}
else
if (num2*2 == MAX*2)
System.out.println ("uva");
A||nea h
if (LIMIT >= 4*num2)
if (MAX == 25)
else
else
System.out.println ("pera");.


Exerc. 2: Para os exercic|os segu|rles escreva segrerlos de cd|go que s|rvar para execular as acoes |rd|cadas:

A||nea A
lrpr|r|r 'lurral se a var|ve| sur lor d|v|sive| por courl

A||nea
lrpr|r|r 'Nur zero, 'Nur pos|l|vo, 'Nur regal|vo, corsoarle o va|or de rur.

A||nea 6
Alr|ou|r o va|or ra|s pequero de do|s |rle|ros a var|ve| sra||esl ul|||zardo:
1. ll-e|se
2. 0perador cord|c|ora|

A||nea 0
lrpr|r|r 'lgua| se do|s va|ores do l|po float guardados er va|1 e va|2 lorer exaclarerle |gua|s e
'Esserc|a|rerle |gua| se esses do|s va|ores esl|verer a ura d|slrc|a |rler|or ou |gua| a 0.0001 ur do oulro.
lrpr|r|r '0|lererle se rao lorer de lodo |gua|s ou sere|rarles.:

Exerc. 3: Nos segu|rles exercic|os |rd|car o oulpul que |r ser produz|do lerdo er corla o va|or de oase das
segu|rles var|ve|s:
final int MIN = 10, MAX = 20;
int num = 15;
A||nea A
while (num < MAX)
{
System.out.println (num);
num = num + 1;
}
A||nea
do
{
num = num + 1;
}
while (num <= MAX);
A||nea 6
for (int count1=1; count1 <= 5; count1++)
{
for (int count2=1; count2 <= 5; count2++)
System.out.print (count1*count2 + " ");
}
A||nea 0
while (num > MIN)
{
num = num - 1;
}
A||nea E
while (num < MAX)
{
if (num%2 == 0)
num++;
}

A||nea F
for (int value=7; value < 0; value--)
System.out.println (value);
A||nea C
do
{
num = num + 1;
if (num*2 > MAX+num)
}
while (num <= MAX);
A||nea h
for (int value=num; value <= MAX; value++)
if (value%4 != 0)
System.out.println(value);

Exerc. 1: Para os exercic|os segu|rles escreva segrerlos de cd|go que perr|lar execular as acoes rerc|oradas:

A||nea A
ver|l|car se o ul|||zador |rlroduz|u ur va|or par, ul|||zardo ur do-Wr||e.

A||nea
ver|l|car se o ul|||zador |rlroduz|u ur va|or pos|l|vo, ul|||zardo ur Wr||e.

A||nea 6
lrpr|r|r os rureros pares erlre 0 e 100.

A||nea 0
lrpr|r|r os rureros ru|l|p|os de 3 de 300 al 3.

Exerc. 5: 0ua|s das |rslruoes da laoe|a segu|rle sao equ|va|erles?

A
if (condio1)
if (condio2)
instruo
C
If (condio1 || condio2)
instruo
B
If (condio1)
Instruo1
else if (condio2)
instruo1
D
If (condio1 && condio2)
instruo

Parle lll - Pequeros Prograras

Exerc. : Ler ur rurero e |rd|car se o rurero par ou irpar.

Exerc. Z: Ler ur caracler e delerr|rar se esle corresporde a ur dig|lo.

Exerc. 8: Ler lrs rureros |rle|ros e delerr|rar qua| ra|or.

Exerc. 9: Escreva ur prograra para orderar do|s |rle|ros |rser|dos pe|o ul|||zador.

Exerc. 10: Escreva ur prograra para orderar lrs |rle|ros |rser|dos pe|o ul|||zador.

Exerc. 11: Escreva ur prograra para orderar qualro |rle|ros |rser|dos pe|o ul|||zador.


Exerc. 12: Faa ur prograra, que receoa ur delerr|rado rurero e |rlorre o ul|||zador se o resro d|v|sive| por
5.

Exerc. 13: Escreva ur prograra, er Java, que |e|a 2 rureros |rle|ros e |rlorre o ul|||zador se o pr|re|ro d|v|sive|
pe|o segurdo.

Exerc. 11: Escreva ur prograra er Java para ver|l|car se ur rurero |rle|ro d|v|sive| por 2, 3, 5, , 10, 15 ou 30.

Exerc. 15: Escreva ur prograra er Java que ace|le ur rurero rea| e o arredorde para o |rle|ro ra|s prx|ro.

Exerc. 1: Escreva ur prograra, que oolerra a|ealor|arerle ur rurero e |rlorre ao ul|||zador se o rurero
regal|vo.

Exerc. 1Z: Escreva ur prograra, CalcIRS que ace|le o orderado de ur lraoa|rador e devo|va o |rposlo a pagar
de acordo cor a laoe|a 2:

Ordenado Taxa
<100.000 5%
>= 100 000 e < 300 000 15%
> 300 000 25%
Tabela 2

Exerc. 18: 0oserve o cd|go da l|gura segu|rle e |rd|que, caso ex|slar, os erros ex|slerles:

switch(n)
{
case 1:
a=11;
b=22;
break;
case 2:
c=33;
break;
d=44;
}

Exerc. 19: Escreva ur prograra que apreserle ura ||sla de 5 ||vros d|lererles ao ul|||zador, ped|rdo-|re que
se|ecc|ore ur de|es. Para o ||vro se|ecc|orado, |rlorre o ul|||zador do preo do ||vro.

Exerc. 20: Cr|e ur prograra, que lerdo do|s rureros ool|dos a|ealor|arerle, prelerde-se |rpr|r|r o resu|lado da
operaao ralerl|ca erlre aroos, deperderdo do operador esco|r|do (, -, ,/).

Exerc. 21: Escreva ur prograra que receoa lrs va|ores rea|s, que corresporder a lrs |ados de ur lr|rgu|o e que
c|ass|l|que o lr|rgu|o coro equ||lero, |ssce|es ou esca|ero.

Exerc. 22: Escreva ur prograra que delerr|re os zeros de 1 equaao quadrl|ca. 0 seu prograra deve corlerp|ar
os casos er que o coel|c|erle do lerro quadrl|co zero e o caso das raizes serer corp|exas.

Exerc. 23: Faa ur prograra que | ura sequrc|a de rureros |rle|ros pos|l|vos e ca|cu|e a sua sora. A quarl|dade
de rureros descorrec|da a parl|da. A sequrc|a de erlrada s lerr|ra quardo lor |rlroduz|do ur rurero regal|vo.

Exerc. 21: Escreva ur prograra, er Java, que s|ru|e ur jogo. 0 jogo cors|sle ro segu|rle: 0 prograra oolr ur
rurero a|ealr|o do s|slera e erquarlo o ul|||zador rao acerlar o rurero er queslao, o jogo corl|rua.


Exerc. 25: Cr|e ur prograra que ca|cu|e a sora de r pr|re|ros rureros pos|l|vos, serdo o va|or de r lorrec|do pe|o
ul|||zador.

Exerc. 2: Faa ur prograra, que ca|cu|e a rd|a de 5 rureros a|ealr|os.

Exerc. 2Z: Cr|e ur prograra, que laa a sora dos pr|re|ros 50 rureros |rle|ros.

Exerc. 28: Escreva ur prograra que |rpr|ra a sora dos pr|re|ros 20 rureros irpares.

Exerc. 29: Escreva, ul|||zardo ur c|c|o 'lor, ur corjurlo de |rslruoes equ|va|erle a:

while (i<100)
System.out.println(i,ao quadrado igual a ,Math.sqr(i));

Exerc. 30: Escreva ur prograra que gere ur rurero |rle|ro a|ealr|o erlre 2 e 100 e ver|l|que se o resro ou rao
pr|ro. Recorde-se que ur rurero pr|ro se lor ra|or do que 2 e que seja ur|carerle d|v|sive| por 1 e por e|e
prpr|o.

Exerc. 31: Escreva ur prograra, er Java, que corprove a lrru|a da l|gura segu|rle :
6
) 1 2 ( ) 1 (
1
2
+ +
=
=
n n n
i
n
i

Para corprovar os resu|lados de aroos os lerros, gere ur rurero a|ealr|o para r erlre 0e 100.

Exerc. 32: 0oserve o cd|go da l|gura segu|rle e d|ga qua| o resu|lado do resro:

public class Exercicio
{
public static void main(String[ ] args){
int count =0;
for (int i=0; i<3; i++)
resume:
for (int j=0; j<4; j++)
for (int k=0; k<5; i++) {
++count;
if (i==1 && j==2 && k==3) break resume;
}
System.ou.println(\tcount= + count);
}
}

Exerc. 33: 0oserve o cd|go da l|gura segu|rle, ool|do a parl|r do arler|or cor a|guras rod|l|caoes. Nesle caso,
d|ga qua| o resu|lado apreserlado:

public class Exercicio {
public static void main(String[ ] args) {
int count =0;
for (int i=0; i<3; i++){
resume:
for (int j=0; j<4; j++)
for (int k=0; k<5; i++) {
++count;
if (I==1 && j==2 && k==3) break resume;
}


@ Esco|a 3uper|or de Tecro|og|a de 3eluoa| 2001-2005 Pg|ra ZZ
System.ou.println(\tcount= + count);
}
}
}

Exerc. 31: 0oserve o cd|go da l|gura segu|rle e |rd|que, caso ex|slar, os erros ex|slerles:

public class Exercicio {
public static void main(String [ ] args){
System.out.print(0);
int fib0 = 0;
int fib1 = 1;
int fib2 = 1;
while (fib2<1000);
{
fib0=fib1;
fib1=fib2;
fib2=fib0 + fib1;
System.out.print( , + fib1);
}
}

Exerc. 35: Escreva ur prograra er Java, que |rpr|ra ro crar a corlager de 1 a 10.

Exerc. 3: ur oarco verda roeda eslrarge|ra (0|ares, Frarcos, L|oras, elc.) e |eva ura cor|ssao de 2 do va|or
lrarsacc|orado ra|s 1 Euro. Escreva ur prograra para |rd|car qua| o va|or a pagar por ura cerla verda de roeda.
0 prograra receoe a quarl|a e l|po de roeda a adqu|r|r. As laxas de cro|o ex|sler ro prograra coro corslarles.

Exerc. 3Z: 3uporra que ur reslaurarle ler a segu|rle ererla:

Prego 1.50C
8alalas Fr|las 0.Z5C
3uro 0.55C
8o|o 0.85C

A||nea A
3o||c|le o rurero de doses de cada ur dos e|ererlos e |rd|que a laclura d|scr|r|rada.

A||nea
Nao possive| sal|slazer ped|dos ro va|or |rler|or a 2.5C.

A||nea 6
0s ped|dos de va|or super|or a 25C lr ur descorlo de 20.

Exerc. 38: ura cerla erpresa laor|ca rolores cor polrc|as corpreerd|das erlre 1 e 99cv. Ao processar
|rlorraao soore ur desles rolores, ur prograra usa ur de lrs proced|rerlos, de acordo cor a polrc|a do
rolor. Parl|rdo do pr|rcip|o que o prograra esl escr|lo er Java e de que a var|ve| |rle|ra Pol represerla a polrc|a
do rolor a ser laor|cado, escreva ura |rslruao |l que execule o proced|rerlo corresporderle de acordo cor a
laoe|a segu|rle:

Polrc|a do rolor Acao a execular
Pol < 1 Versager de erro
1 <= Pol < 5 Pw1

5 <= Pol < 20 Pw2
20<= Pol < 100 Pw3
Pol >= 100 Versager de erro

As cord|oes das |rslruoes |l rao dever ler corjuroes.

Exerc. 39: Escreva ur prograra er Java que corverla rolas quarl|lal|vas de 0 a 20 er rolas qua||lal|vas de rau a
exce|erle, ul|||zardo ura eslrulura de |l's ercadeados e que ver|l|que o ||r|le super|or das garas de cada ura das
rolas qua||lal|vas.

Cors|dere que:
0-1 : Vau
5-9 : Vediocre
10-13 : 3ul|c|erle
11-1Z : 8or
18-20 : Vu|lo 8or

Exerc. 10: Escreva ur prograra er Java para ca|cu|ar os juros e o rovo sa|do de ura corla oarcr|a, lerdo er
alerao que se o sa|do lor |rler|or a 1.000 a corla rao receoe juros e paga ura laxa ao oarco (ru|la). Caso a corla
al|rja ur sa|do regal|vo carce|ada. 0 prograra dever ler a ru|la represerlada por ura corslarle. 0ever |er o
sa|do arler|or, o rurero de reses ao l|r do qua| quereros ca|cu|ar o sa|do, e a laxa de juros arua|. Parla do
pr|rcip|o de que rao r rov|rerlos ra corla e de que os juros s sao ca|cu|ados ro l|r do rurero de reses
espec|l|cado.

6 - Sub-Programas
T|p|carerle, ur prograra corresporde a |rp|ererlaao de ura so|uao para ur delerr|rado proo|era. Vu|las
vezes, os proo|eras a reso|ver sao deras|ado corp|exos, pe|o que ros serl|ros oor|gados a parl|-|os er proo|eras
ra|s pequeros, por lorra a lac|||lar a descooerla da so|uao. Esles suo-proo|eras, para a|r de ra|s pequeros, lr
ura so|uao ra|s s|rp|es. A esla eslralg|a de reso|uao de proo|eras crara-se 'd|v|de ard corquer, ou seja,
d|v|d|r para corqu|slar: reso|ver os suo-proo|eras corduz-ros a so|uao g|ooa|.

Para cada suo-proo|era ex|sle ura |rp|ererlaao possive| soo a lorra de prograra, dai a des|graao de suo-
prograra:
Cr|aros secoes do prograra que execular larelas especil|cas, cor ur corjurlo de |rslruoes a curpr|r
ru|lo oer del|r|do
ura vez lraoa|rardo er corjurlo, eslas secoes (por vezes laror craradas de rol|ras), corlr|ouer
para a reso|uao do proo|era gera| e ra|s corp|exo.

Vantagens da Ut|||zao de 8ub-Programas

usardo suo-prograras ||r|laros a corp|ex|dade da so|uao g|ooa| a cusla da sua corjugaao.
Corlr|ouiros a|rda para a c|areza e |eg|o|||dade dos prograras po|s o cd|go que reso|ve cada larela esl separado.
lderl|l|car-se ra|s lac||rerle os dados recessr|os e os resu|lados produz|dos por cada larela.
Ev|la-se a ex|slrc|a de cd|go redurdarle (|.e. que rao laz la|la, repel|do), po|s reur|rdo o cd|go corur a larelas
d|lererles poderos re-aprove|l-|o er porlos d|sl|rlos do prograra.

6hamada de um 8ub-Programa

ur suo-prograra |derl|l|cado por ur rore que |re alr|ouido pe|o prograrador. E a esle rore que ur
prograrador se relere quardo prelerde ul|||zar o suo-prograra er queslao. 8asla dar a |rd|caao do rore de ur
suo-prograra segu|do de parrles|s curvos a aor|r e a lecrar (), para que o corjurlo de |rslruoes que o corpoer
sejar execuladas. vereros ra|s ad|arle que se o suo-prograra recess|lar de dados de erlrada para ser execulado
derlro desses parrles|s que la|s dados |rao surg|r ( o que se crara de passager de parrelros).

Exemp|o 1:

resultado = Math.pow(2,4);

Cor esla |rslruao eslaros a crarar o suo-prograra pow, ex|slerle ra c|asse Math da ||rguager Java. Esle suo-
prograra serve para ca|cu|ar a polrc|a de ur rurero x e|evado a oulro rurero y. Nesle caso ca|cu|ros o va|or de
2
1
(dardo coro parrelros os va|ores 2 (x) o va|or 1 (y) ), que resu|la er 1. E esle o va|or cor que a var|ve|
resu|lado |r l|car aps a crarada do suo-prograra.

Exemp|o 2:

numero = Math.random();

Nesle caso crarros o suo-prograra rardor, laror perlercerle a c|asse Valr. Esle suo-prograra gera ur
rurero a|ealr|o e, coro poderos ver|l|car, rao prec|sa de rerrur parrelro de erlrada para elecluar os c|cu|os a
que se propoe.


6r|ao de 8ub-Programas

ur suo-prograra corsl|luido por:

Caoea|ro: corjurlo de pa|avras reservadas (que vereros ra|s ad|arle qua|s sao e para que server),
rore do suo-prograra, ||sla de parrelros (que pode ser vaz|a) erlre parrles|s curvos.
lrslruoes: corjurlo de |rslruoes recessr|as ao curpr|rerlo dos oojecl|vos do suo-prograra.

0eve ser cr|ado ro ro|lo de ur prograra para que possa ser execulado e ser ul||.

Nota: E |rporlarle que arles do suo-prograra sejar co|ocados corerlr|os |rd|cal|vos do props|lo que esle serve.
0ever laror dar-se rores sugesl|vos aos suo-prograras, que |rd|quer de lorra c|ara para que que esles
server, la| coro ro caso das var|ve|s.

Exemp|o 3:

public class Programa
{

{
System.out.println("1 instruo executada pelo main");

imprimeMensagem() // chamada do sub-programa imprimeMensagem

System.out.println(3 instruo executada pelo main");
}

// imprimeMensagem : sub-programa que escreve a mensagem
// Ol Mundo! no cran
public static void imprimeMensagem()
{
System.out.println("Ol Mundo!");
}

}

ur suo-prograra pode (ou rao) ler que produz|r a|gur resu|lado para o exler|or (ou seja, para quer |re ped|u que
execulasse a larela a que esl desl|rado).
Corsoarle lerra ou rao que produz|r esses resu|lados, ur suo-prograra pode ser c|ass|l|cado da segu|rle lorra:

Proced|rerlo
Furao

0s proced|rerlos e luroes er Java crarar-se mtodos. l rlodos que apreserlar va|ores de relorro e oulros
que rao o lazer.
6.1 - Procedimentos
ur proced|rerlo ur suo-prograra que corlr ur corjurlo de |rslruoes a execular de lorra ur|lr|a e alr|ca
para curpr|r cor delerr|rada larela.
Para que a larela seja execulada, o proced|rerlo pode ou rao ler de receoer dados de erlrada. Execula as
|rslruoes que o corpoer ura a ura al al|rg|r o l|r. 0u lodas sao oer suced|das e a larela curpr|da ou, se
a|gura la|ra, o proced|rerlo la|ra e a larela rao se curpr|u. E |slo que s|gr|l|ca operaao alr|ca/ur|lr|a.
Cabealho do sub-programa
Instrues a executar

ur proced|rerlo rao relorra va|ores, o que er Java |derl|l|cado pe|a pa|avra void arles do rore do rlodo
(suo-prograra). 0 rlodo |rpr|reVersager do exerp|o 3 ac|ra derorslrado ur exerp|o s|rp|es de
proced|rerlo.
6.2 - Funes
ura lurao ur suo-prograra |drl|co a ur proced|rerlo, cor a d|lerera de que apreserla ur va|or coro
resu|lado da sua execuao.
E ur rlodo que ler va|or de relorro (rao void, ao corlrr|o do proced|rerlo).
A lorra de ura lurao apreserlar ur resu|lado recorrer a |rslruao return.

A |nstruo Return

Esla |rslruao |rlerrorpe a execuao do suo-prograra correrle e o l|uxo de execuao do prograra devo|v|do ao
l|r da |rslruao er que o suoprograra lo| crarado.

return <expresso>;

0 va|or da expressao o va|or de relorro do rlodo.

Er delerr|rados proced|rerlos (rlodos void), a |rslruao return pode aparecer de lorra exp|ic|la (ser
<expresso>), aperas para |rlerrorper a execuao do rlodo (aps ver|l|caao de ura dada cord|ao, por
exerp|o).

Exemp|o 1:

public class ExemploFuncao
{
{
double varA;
varA = 10.5;

System.out.println(2 instruo executada pelo mtodo main");
System.out.println(varA);

varA = funcao(); // invocacao do mtodo funcao

System.out.println(varA);
System.out.println("5 instruo executada pelo mtodo main");
}

// funcao: soma 2 numeros aleatorios e retorna o resultado da soma
static double funcao()
{
double valor1, valor2, resultado;
valor1 = Math.random();
valor2 = Math.random();

resultado = valor1 + valor2;

return resultado;
}
}


Nesle exerp|o, o prograra corea por alr|ou|r o va|or 10.5 a var|ve| varA de l|po double.
Er segu|da, |rpr|re ura rersager ro crar, segu|da do va|or da var|ve|.
Ao lazerros varA = funcao(); eslaros a crarar o rlodo que ler o rore funcao. Nesle rorerlo, o
corlro|o da execuao passa para esse suo-prograra. E|e l|ca erlao ercarregue de execular a sua larela, que resle
caso sorar do|s rureros a|ealr|os e apreserlar ro l|ra| o resu|lado da sora.
0erlro do rlodo lurao o que acorlece o segu|rle: gerado ur rurero a|ealr|o por re|o da crarada ao
rlodo random da c|asse Math e co|ocado o seu va|or derlro da var|ve| valor1. 0e segu|da, gerado rovo
rurero a|ealr|o da resra lorra e o seu va|or co|ocado derlro da var|ve| valor2. Por l|r, co|oca-se o
resu|lado da sora derlro da var|ve| resultado.
Para lerr|rar, a lurao ler de relorrar o resu|lado do c|cu|o elecluado, devo|verdo o corlro|o ao prograra
pr|rc|pa|. Para |sso recorre a |rslruao return. Ao lazer return resultado; a lurao lerr|ra,
apreserlardo o va|or da var|ve| resu|lado a quer a crarou, que resle caso lo| a lurao main (alravs de
varA=funcao() ). A corc|usao de lodos esles passos que o resu|lado do c|cu|o elecluado pe|o rlodo
funcao l|ca arrazerado derlro da var|ve| varA.
0 prograra prossegue erlao cor as reslarles |rslruoes que ler a execular, que cors|sler aperas er escrever o
rovo va|or da var|ve| varA ro crar e ura u|l|ra rersager ('5 |rslruao execulada pe|o rlodo ra|r).
6.3 - Parmetros
J lo| rerc|orado que, por vezes, para poder corcrel|zar delerr|rada larela, ur suo-prograra prec|sa de dados de
erlrada ( |rag|reros que a larela era preparar ur oo|o para ser coz|rrado... prec|saros dos |rgred|erlesl Far|rra,
ovos, aucar, elc. ).
A esses dados de erlrada crararos parrelros. 3ao var|ve|s que relererc|ar d|lererles l|pos de dados dos qua|s
o suo-prograra recess|la para |evar a caoo a sua larela.

Esles poder ser c|ass|l|cados da segu|rle lorra:

Parmetros Forma|s: Aque|es que sao dec|arados ro caoea|ro do suo-prograra (derlro dos parrles|s
curvos...) e que poder ser ul|||zados por e|e ro o|oco de |rslruoes que ler para execular.
Parmetros Actua|s: Taror crarados de parrelros corcrelos, sao os va|ores que os parrelros
lorra|s adqu|rer durarle a execuao do suo-prograra.

Exemp|o 1:

public class ProcedimentoComParametros
{
{
int pcA = 10, pcB = 20;


procComParams(pcA, pcB); // invocao do mtodo procComParams

}

// procComParams: recebe dois inteiros e imprime no cran a sua soma
// imprime tambm a soma de duas variveis
// locais (internas) ao procedimento
public static void procComParams( int pfA, int pfB) // PROCEDIMENTO
{
int varLocalC = 11, varLocalD = 12;


System.out.println (2 Instruo executada pelo metodoVoid_2");

System.out.println (pfA+pfB);
System.out.println (varLocalC+varLocalD);

System.out.println (5 Instruo executada pelo metodoVoid_2");
}
}

Nesle exerp|o, veros a ||sla de parrelros lorra|s dec|arada ro caoea|ro do rlodo, |derl|l|cada pe|os do|s
|rle|ros pfA e pfB.
No prograra pr|rc|pa| ver|l|caros que a var|ve| pcA corea por ler o va|or 10 e pcB o va|or 20. 0epo|s de
|rpr|r|r ura rersager, |rvocado o rlodo procComParams. Nessa a|lura sao dadas coro parrelro ao
rlodo as var|ve|s pcA e pcB. Esles sao os parrelros aclua|s ou corcrelos, porque represerlar os va|ores cor
os qua|s o rlodo va| lraoa|rar er lerpo de execuao para |evar a caoo a sua larela.
0s va|ores de pcA e pcB sao cop|ados, respecl|varerle, para derlro das var|ve|s pfA e pfB, por |sso, quardo
derlro do rlodo lazeros System.out.println (pfA+pfB); sa| 30, coro ser|a de esperar.

Exemp|o 2:

public class FuncaoComParams
{
{
int pcA = 1, pcB = 20, varC = 30;
System.out.println(varC);

varC = funComParams(pcA, pcB); // invocao do mtodo funComParams

System.out.println(varC);
}

public static int funComParams(int pfA, int pfB) // FUNO
{
return (pfA+pfB);
}
}

Esle exerp|o ru|lo sere|rarle ao arler|or, exceplo ro laclo de que agora leros ura lurao, cujos parrelros
lorra|s sao pfA e pfB. 0s parrelros aclua|s sao pcA e pcB, e a lurao apreserla coro resu|lado a co|ocar
derlro da var|ve| varC a sora dos parrelros aclua|s (ou seja, os va|ores de pfA e pfB er lerpo de
execuao).

Esserc|a|rerle r a reler que os parrelros lorra|s server para |rd|car qua|s sao os l|pos de dados de erlrada que
ur suo-prograra recess|la para poder curpr|r cor os seus oojecl|vos, ao passo que os parrelros aclua|s
represerlar va|ores corcrelos durarle a execuao do suo-prograra.
l ura re|aao d|recla erlre parrelros lorra|s e parrelros aclua|s, ro serl|do de que a cada parrelro lorra|
corresporde ur parrelro rea| (apesar de raver ||rguagers er que possive| espec|l|car parrelros opc|ora|s. Ta|
rao o caso do Java.). Ass|r serdo, o rurero de parrelros lorra|s e parrelros aclua|s para ur suo-prograra
ler de ser |gua| e os l|pos dos resros laror lr de corresporder. 0u seja, se delerr|rado rlodo espera ur
int segu|do de ur char, cors|derado ur erro s|rlcl|co se o prograrador ao crarar esse rlodo erv|ar

pr|re|ro ur char e depo|s ur int ou resro passar va|ores de oulro l|po qua|quer. 0s parrelros lr de eslar
pe|a order espec|l|cada e lr de ser do resro l|po.
6.4 - Passagem de Parmetros
Passar parrelros a ur suo-prograra s|gr|l|ca crarar esse suo-prograra dardo-|re coro erlrada os dados que de
que e|e recess|la.

Ex|sler do|s l|pos de passager de parrelros:
Por Va|or: o parrelro lorra| receoe ura cp|a do va|or do parrelro aclua|, serdo que |rlerrarerle
aperas corsegue rudar o va|or da cp|a e rao o or|g|ra|.
Por Refernc|a: o parrelro lorra| receoe ura relerrc|a para o va|or do parrelro aclua|. Logo,
|rlerrarerle corsegue rudar o va|or aporlado por essa relerrc|a, o que ler coro corsequrc|a a
rod|l|caao do va|or do parrelro aclua|.

Em Java, a passager de parrelros serpre le|la por va|or.

Exemp|o 1 (passagem de parmetros por va|or}:

public class ProcComParams // pegando num dos exemplos anteriores...
{
{
int pcA = 10, pcB = 20; // valores iniciais de pcA e pcB
// vo ser usados como parmetros actuais
// para o mtodo procComParams

procComParams(pcA, pcB); // invocacao do mtodo procComParams
// vamos ver o que se passa dentro do
// mtodo...

// depois de procComParams ter terminado e ter modificado
// o valor dos seus parmetros...

System.out.println(pcA = + pcA); // pcA manteve o valor 10!
System.out.println(pcB = + pcB); // pcB manteve o valor 20!
}

public static void procComParams(int pfA, int pfB) // PROCEDIMENTO
{
// pfA recebe uma cpia do valor de pcA
// pfB recebe uma cpia do valor de pcB

pfA = pfA + 2; // mudamos o valor de pfA
pfB = pfB * 3; // mudamos o valor de pfB

// imprimimos os dois valores
System.out.println (pfA = + pfA);
System.out.println (pfB = + pfB);
}
}

vejaros a|rda a represerlaao er rerr|a do suced|do...


20 10 20 10 20 10 20 10
AAAAAA AAAAAB AAAAAC AAAAAD AAAAAE AAAAAF AAAAB0 AAAAB1
20 10 20 10
// Antes da invocao de procComParams!
// Invocao de procComParams!
pcA pcB pfA pfB
pcA pcB
pfA pfB
pfA e pfB so
CPIAS de pcA e
pcB!
pfA e pfB so
CPIAS de pcA e
pcB!
60 12 20 10 60 12 20 10
pfA e pfB
mudaram de
valor mas pcA e
pcB No!
pfA e pfB
mudaram de
valor mas pcA e
pcB No!

F|gura 39. 0erorslraao do corce|lo de passager de parrelros por va|or

T|pos de dados er Java que rao sejar pr|r|l|vos sao oojeclos (dos qua|s la|areros ra|s ad|arle). As var|ve|s que
represerlar oojeclos sao ra rea||dade relerrc|as (aporladores) para zoras de rerr|a orde esles eslao
arrazerados.
Ao passar coro parrelro para ur suo-prograra ura var|ve| que represerla ur desles l|pos, eslaros a passar
ura cp|a da relerrc|a para o resro. lslo s|gr|l|ca que, se derlro do suo-prograra l|zerros a|gura operaao
soore essa var|ve|, eslaros ra rea||dade a a|lerar o oojeclo e quer crarou o suo-prograra v essa a|leraao. lslo
provoca ur corporlarerlo |drl|co ao da passager por relerrc|a.
Eroora s ra|s ad|arle possaros ver o que sao oojeclos e coro se corporlar, vejaros a derorslraao desle
corce|lo de relerrc|a:

Exemp|o 2 (passagem de parmetros por refernc|a}:

public class ProcComParams // com um exemplo semelhante
{
{
// Criamos uma varivel chamada exemplo, do tipo StringBuffer
// StringBuffer um tipo que representa cadeias de caracteres
// (um dos tais objectos..)
// exemplo uma referncia para a zona de memria onde o
// objecto StringBuffer criado e guardado
StringBuffer exemplo = new StringBuffer(Teste);

// damos essa referncia como parmetro ao mtodo e vamos ver o
// que se passa l dentro...
procComParams(exemplo); // invocacao do mtodo procComParams

System.out.println (exemplo);
}

public static void procComParams(StringBuffer s) // PROCEDIMENTO
{
// s do tipo StringBuffer e tem uma cpia do valor
// da varivel exemplo. Agora apontam ambas para a mesma

// zona de memria.

// ao modificarmos o valor do objecto apontado por s
// apagando o seu contedo (delete)
// e colocando contedo novo (append)
// estamos a fazer com que essa alterao seja vista no
// programa principal atravs da varivel exemplo
// dado que ambas esto associadas mesma zona de memria!

s.delete(0, s.length());
s.append(Isto FOI um teste passagem por referncia!);
}
}

Er lerros v|sua|s varos ver|l|car o que acorleceu:

Teste
passagem
por
referncia
Teste
passagem
por
referncia
// Antes da invocao de procComParams!
// Invocao de procComParams!
exemplo s
AAAAAA AAAAAA Teste
passagem
por
referncia
AAAAAA AAAAAA Teste
passagem
por
referncia
exemplo
s
AAAA
AAAAAA
Isto FOI um
teste
passagem
por
referncia
AAAA
AAAAAA
Isto FOI um
teste
passagem
por
referncia
s uma referncia
para o objecto
apontado por
exemplo
s uma referncia
para o objecto
apontado por
exemplo
Logo, quando s muda
de valor, exemplo
tambm sofre as
consequncias!
Logo, quando s muda
de valor, exemplo
tambm sofre as
consequncias!

F|gura 10. 0erorslraao do corce|lo de passager de parrelros por relerrc|a
6.5 - Visibilidade das Variveis
Arles de la|arros er v|s|o|||dade de var|ve|s varos re|erorar coro que ur prograra esl orgar|zado.
Regra gera|, seja er Java seja roulras ||rguagers, ura ap||caao |rlorrl|ca corsl|luida por ur prograra pr|rc|pa|
que ul|||za d|versos suo-prograras que o ajudar ro curpr|rerlo do seu oojecl|vo. (A la| aoordager do d|v|d|r para
corqu|slar, |erorar-se?)
Er Java, ura ap||caao corsl|luida por ura ou ra|s c|asses. ura (e s uma) dessas c|asses corlr ur rlodo
crarado main que o prograra pr|rc|pa|. Esle ul|||za erlao suo-prograras que poder ex|sl|r ra resra c|asse ou
roulras.

Ex|sler lrs regras |rporlarles ra eslruluraao de ur prograra (||vro FCA - Furdarerlos de Prograraao er
Java2):

ur prograra corlr:
o 0ec|araoes de var|ve|s;
o ur suo-prograra pr|rc|pa| crarado main();

o ur corjurlo de suo-prograras del|r|dos pe|o prograrador.
0s suo-prograras corlr:
o 0ec|araoes de var|ve|s;
o lrslruoes e|ererlares (alr|ou|ao, se|ecao, repel|ao, elc.);
o Craradas a oulros suo-prograras (pr-del|r|dos ou cr|ados pe|o prograrador).

0s dela|res de |rp|ererlaao de ur suo-prograra sao |rre|evarles, desde que se sa|oa para que que e|e serve,
que parrelros receoe e que l|po de resu|lado deve produz|r ( coro se losse ura ca|xa regral).

E desle corjurlo de regras e del|r|oes que surge o corce|lo de v|s|o|||dade de ura var|ve|. v|s|o|||dade de ura
var|ve| ura roao assoc|ada ao |oca| orde a var|ve| dec|arada ro prograra.

Poderos erlao c|ass|l|car as var|ve|s da segu|rle lorra:
Var|ve|s |oca|s
Var|ve|s g|oba|s

ura var|ve| dec|arada derlro de ur suo-prograra crarada de var|ve| |oca| a esse suo-prograra. ura var|ve|
|oca| cr|ada serpre que o suo-prograra acl|vado e deslruida quardo esle lerr|ra a sua execuao.
A|rda que raja oulro suo-prograra que corlerra ura var|ve| dec|arada cor o resro rore, eslaros a la|ar de
var|ve|s d|lererles, que ex|sler er espaos de rerr|a separados, por periodos de lerpo d|lererles e v|s|o|||dades
d|lererles, po|s ex|sler er suo-prograras d|sl|rlos.

ura var|ve| g|ooa| aque|a que dec|arada ro |ric|o do prograra e suos|sle al que o prograra lerr|re, serdo
v|sive| derlro de qua|quer suo-prograra que o corsl|lu|. Para a|r de serer v|sive|s derlro de qua|quer suo-
prograra que corsl|lu| a ap||caao, as var|ve|s g|ooa|s poder laror ser ul|||zadas por esses suo-prograras.
Nao ro erlarlo acorse|rado o uso aous|vo desle l|po de var|ve|s dadas as ||r|laoes que causar ra |eg|o|||dade
do cd|go e a lac|||dade cor que provocar o aparec|rerlo de erros d|lice|s de deleclar.
Para a|r d|sso rao corlr|ouer er rada para a reul|||zaao de cd|go po|s lorrar o cd|go deservo|v|do
deperderle do corlexlo de ul|||zaao.

Exemp|o 1:

class VisibilidadeVariaveis
{
private int valor1;

// varivel global
public static int valor2 = 10;

public static void mudaValor2(int v2) {
// novoValor uma varivel local ao mtodo
int novoValor = v2 + valor2;
valor2 = novoValor;
} ...

public static void main(String args[]) { // Resultado = 43!
System.out.println(Valor2 antes da chamada = + valor2);
mudaValor2(33);
System.out.println(Valor2 depois da chamada = + valor2);
}
}


0bject|vos da 8r|e:

1. Erlerda e sa|oa ap||car as rooes de proced|rerlo e lurao alravs da cr|aao de rlodos
2. 0or|re a serrl|ca da |rvocaao de rlodos
3. Corpreerda os corce|los de parrelro lorra| e aclua|
1. Erlerda as d|lereras erlre a passager de parrelros por va|or e por relerrc|a
5. Corpreerda a d|lerera erlre var|ve|s |oca|s e g|ooa|s

Parte | - 0uestes Ter|cas

1. 0ua|s sao as lases por que passa a ul|||zaao de ur rlodo?
2. 0ua| a d|lerera erlre ur proced|rerlo e ura lurao?
3. No Java ex|sler os corce|los de proced|rerlo e lurao de lorra exp|ic|la? 3e rao ex|sler, coro sao
represerlados? 0 exerp|os.
1. Para que serve a |rslruao relurr?
5. 0 que sao parrelros lorra|s e parrelros aclua|s? Jusl|l|que e d exerp|os.
. ura var|ve| |oca| ura var|ve| que correc|da e esl d|sporive| para ser ul|||zada por loda a ap||caao
e por lodos os oojeclos que a corpoer, verdade|ro ou la|so? Jusl|l|que a resposla que der.
Z. 0 que erlerde por ass|ralura de ur rlodo?
8. 0ue l|pos de passager de parrelros correce? 0ua|s as d|lereras erlre cada ura?
9. Er Java ex|sler lodos os l|pos de passager de parrelros que |rd|cou? Jusl|l|que e d exerp|os para
cada s|luaao rerc|orada.

Parte || - Ap||cao de 6once|tos Usando Pequenos Programas

Exerc. 1: ul|||zardo o rlodo de passager por va|or, cr|e ur prograra orde o ul|||zador |rlroduz do|s rs a|ealr|os e
cor o auxi||o de ur suoprograra relorre o ra|or de erlre os seus argurerlos.

Exerc 2: Escreva ur prograra que ul|||ze ur suoprograra(rlodo) para a lroca de va|ores de duas var|ve|s. Nola
que os va|ores deverao ser receo|dos do ul|||zador, ro prograra pr|rc|pa|. Eslas var|ve|s deverao ser do l|po 3lr|rg.

Exerc. 3: Cor o auxi||o de ur suoprograra(rlodo) orde se lroca corleudo de var|ve|s, laa ur prograra er Java
que ordera lrs 3lr|rgs a|laoel|carerle.

Exerc. 1: Terle elecluar o resro exercic|o ras agora cor |rle|ros, |slo , |rp|ererlar o rlodo de lroca e
posler|orrerle elecluar a orderaao de lrs rureros |rle|ros receo|dos do lec|ado.
0 a sua op|r|ao quarlo ao resu|lado esperado. E suposlo ser sere|rarle ao ool|do cor as 3lr|rgs? Jusl|l|que
porque que la| acorlece.


7 - Classes e Objectos
0s prograras er Java sao deservo|v|dos coro|rardo rovos rlodos e c|asses cor os j ex|slerles ra ||rguager
(a d|la APl Java - App||cal|or Prograrr|rg lrlerlace Java). A APl Java olerece ura sr|e de c|asses e rlodos para
execular desde c|cu|os ralerl|cos, rar|pu|aoes de cade|as de caracleres, rar|pu|aoes de caracleres,
operaoes de |rpul/oulpul, ver|l|caao de erros e ru|las oulras operaoes ule|s. 0lerece de ludo o que ur
prograrador possa prec|sar coro oase para deservo|ver as suas ap||caoes.
A ||rguager de prograraao Java d|z-se or|erlada aos oojeclos. Nur parad|gra de oojeclos, ao corlrr|o do que se
possa persar, rao se procura ura rova lorra de prograrar, ras s|r or|erlarro-ros para ura lorra de persar
aoslracla re|al|varerle a qua|quer proo|era, ul|||zardo para |sso corce|los do rurdo rea|.

A lilu|o de exerp|o: lodos rs leros preserle ra rossa rerle o que ur aulorve|. A del|r|ao desle corle|lo, er
or|erlaao aos oojeclos crara-se c|asse.
Todos rs saoeros a|rda que ur aulorve| ler qualro preus, ler porlas, oarcos para ros serlarros, ur rolor,
elc.ec. lslo sao as propr|edades(alr|oulos) de ur aulorve|, que a|gur del|r|u quardo cr|ou a c|asse.

Por oulro |ado, saoeros a|rda que, rodardo a crave, o rolor se ||ga; que carregardo ro ace|erador depo|s de
ergalada a rudara o aulorve| avara ra|s depressa. Esles sao a|gurs dos corporlarerlos que ur aulorve|
saoe deserperrar. Er lecro|og|a de oojeclos aos e|ererlos que del|rer corporlarerlo crararos rlodos.
Represerlar lurc|ora||dade.
Por l|r, resla-ros ler preserle que |rdeperderlererle da c|asse, c|rcu|ar pe|o rurdo ur ser rurero de |rslrc|as
da resra. Todos os d|as ver|l|caros que r |rersos aulorve|s, parados ou a c|rcu|ar, de jare|as aoerlas ou
lecradas, de cores e lorralos d|lererles, a ve|oc|dades d|lererles, pe|as ruas lora. Essas |rslrc|as lorar cr|adas
recorrerdo a ur rlodo espec|a| deror|rado corslrulor (resle caso, a ||rra de rorlager) e, quardo o seu lerpo
de v|da cregar ao l|r, serao deslruidas pe|o deslrulor (o cerlro de aoale, por exerp|o).

Terdo ura ur|ca c|asse poder cr|ar-se larlas |rslrc|as quarlas lorer prec|so que, lraoa|rardo er corjurlo,
corlr|ouer para a reso|uao de delerr|rado proo|era. A eslas |rslrc|as crararos oojeclos.

Programao 0r|entada aos 0bjectos

Esle l|po de prograraao cors|sle er cr|ar ap||caoes a parl|r de oojeclos.
0eserrar ur prograra passa por:
0el|r|r os oojeclos recessr|os
o 0ua|s as suas caraclerisl|cas
o 0ue lurc|ora||dades dever olerecer
0el|r|r a lorra coro os oojeclos corur|car erlre s| para al|rg|r os oojecl|vos a que o prograra se propoe
7.1 - Objectos
lrslrc|as de c|asses que ercapsu|ar dados e luroes.

Acluar coro lorrecedores de serv|os.
Tr:
o lderl|dade (del|r|da pe|a c|asse);
o Eslado (alr|oulos) - Cada ur correce e guarda os seus dados, ou seja os va|ores dos alr|oulos;
o Corporlarerlo - rlodos, laror del|r|dos pe|a c|asse. Todos os oojeclos da resra c|asse
saoer execular o resro corporlarerlo.
Co|aoora cor oulros oojeclos alravs da lroca de rersagers (|rvocaao de rlodos) para produz|r
resu|lados re|evarles para o dorir|o do proo|era


0s oojeclos sao rorra|rerle descr|los (alravs das c|asses) recorrerdo a rores, prorores, adjecl|vos ou
advro|os.
7.2 - Classes
0el|r|ao de ur corce|lo que lulurarerle ser |rslarc|ado.
0escreve ur corjurlo de oojeclos do resro l|po e cor a resra eslrulura |rlerra.
0escreve os alr|oulos (|rlorraao) e o corporlarerlo (rlodos) de ur oojeclo.
E |rslarc|ada para cr|ar oojeclos.

0el|r|r ura c|asse |rp||ca:
Espec|l|car os seus alr|oulos (var|ve|s)
Espec|l|car o corporlarerlo dos luluros oojeclos dessa c|asse (rlodos)
7.3 - Atributos
0el|rer caraclerisl|cas das luluras |rslrc|as de ura c|asse.
Tr ur rore ur|co derlro da resra c|asse, ras c|asses d|lererles poder ler alr|oulos cor o resro rore.
7.4 - Mtodos
0el|rer lurc|ora||dade das luluras |rslrc|as de ura c|asse.
3ao rorra|rerle descr|los recorrerdo a veroos, por |rd|carer a|gur l|po de acao.
Perr|ler rod|l|car ou |rlerrogar os oojeclos re|al|varerle ao seu eslado aclua|.

A ul|||zaao dos rlodos passa rorra|rerle por duas lases:
def|n|o (del|r|r o que e que ur rlodo saoe lazer ro ro|lo do oojeclo a que perlerce)
|nvocao (processo de erv|ar rersagers a ur oojeclo para que delerr|rado rlodo do seu
corporlarerlo seja execulado)

ur rlodo ler serpre ura ass|ralura, a qua| corsl|luida por:
l|po de relorro
rore
rurero e l|po de parrelros

0o|s rlodos lr a resra ass|ralura quardo esles e|ererlos sao |drl|cos er aroos. Nao possive| ra resra
c|asse a ex|slrc|a de rlodos cor a resra ass|ralura.

Nota:

Por corverao, er Java, os rores de c|asses corear por |elras ra|uscu|as (ex: NoreC|asse), ao passo que os
rores de oojeclos corear cor r|ruscu|as (ex: rore0ojeclo).
0s rores dos rlodos corear laror por r|ruscu|as (ex: roreVelodo).

0 lorralo gera| de ur rlodo o segu|rle:

// J vimos isto quando falmos de sub-programas!
tipoRetorno nomeMetodo(listaParametros) {
declaracoes;
instrues;
retorno (se for o caso);
}

7.5 - Instanciao de Classes
lrslarc|aao o processo de cr|ar |rslrc|as (oojeclos) de ura delerr|rada c|asse.
E ura operaao le|la soore a c|asse e rao soore os oojeclos (dado que os oojeclos j sao |rslrc|as rao laz serl|do
cr|ar |rslrc|as a parl|r de|es...).
Para cr|ar ura |rslrc|a de ura c|asse ul|||zaros o operador new, que quardo execulado a|oca a rerr|a
recessr|a para guardar o oojeclo er causa ra rerr|a.

8|ntaxe NF:

new <nome da classe> ();

ou

new <nome da classe> (<lista de parmetros actuais>);

Exemp|o 1:

Conta c = new Conta();
// A varivel c uma referncia a um objecto.
// A varivel, na verdade, serve como apontador para o
// endereo de memria que o objecto ir ocupar.
7.6 - Referenciar Objectos
Relererc|ar ur oojeclo cors|sle er ul|||z-|o para corcrel|zar delerr|rado oojecl|vo.
Pr|re|ro ur oojeclo ler de ser corslruido, ou seja ler de se a|ocar rerr|a para o guardar. Teros laror de |re
alr|ou|r ura relerrc|a (esles passos sao os que lorar le|los ro exerp|o 1).
Posler|orrerle, relererc|aros o oojeclo ul|||zardo a var|ve| que lo| cr|ada para o ele|lo e erv|ardo rersagers ao
oojeclo.
Essas rersagers, laror coro j rerc|orros, sao |rvocaoes dos rlodos que o oojeclo saoe execular, ou
seja, dos rlodos que lorar del|r|dos ra c|asse a que e|e perlerce.

Exemp|o 2:

System.out.println(OLA);

Ao escrever esla ||rra de cd|go eslaros a erv|ar ura rersager println cor o parrelro OLA ao oojeclo
System.out, ou seja, eslaros a |rvocar o rlodo println ro oojeclo System.out que o cara| de saida
que usaros para escrever lexlo ro crar.

Exemp|o 3:

contaDoBanco.recebeOrdenado (500.5);
Objecto
Mtodo
Parmetros:
dados fornecidos
ao mtodo
contaDoBanco.recebeOrdenado (500.5);
Objecto
Mtodo
Parmetros:
dados fornecidos
ao mtodo


Ao oojeclo contaDoBanco (parl|rdo do pressuposlo que perlerce a c|asse Conta j usada er exerp|os
arler|ores), eslaros a erv|ar ura rersager recebeOrdenado que ler coro parrelro o va|or 500.5. 0u
seja, eslaros a |rvocar o rlodo recebeOrdenado cor o parrelro 500.5 ro oojeclo contaDoBanco.
Vlodo esse que esl del|r|do ra c|asse Conta.

Exemp|o 4:

Conta c;
c = new Conta(1287,0);

c.obterSaldo(); /* envia a mensagem obterSaldo para o
objecto referenciado pela varivel c */
Conta b = c; /* as variveis b e c passam referenciar o
mesmo objecto */

E possive| a ex|slrc|a de ra|s do que ura relerrc|a para o resro oojeclo. Ex|sle aperas ura cp|a do oojeclo
ras vr|as var|ve|s capazes de o rar|pu|ar. Coro lodas se relerer ao resro oojeclo, se a|gura provocar ura
rod|l|caao soore e|e lodas as oulras vr essa rod|l|caao.
No exerp|o 1, quardo dec|arros a var|ve| o do l|po Conta e l|zeros b = c, passros a ler duas var|ve|s
capazes de rar|pu|ar o oojeclo que lo| cr|ado cor new Conta(1287,0).
3e |rvocarros o rlodo ooler sa|do soore as duas, ooleros o resro resu|lado (b.obterSaldo()ou
c.obterSaldo() aroos relorrar 0).
3e l|zerros b.recebeOrdenado(600.0) eslaros a ad|c|orar 00C ao sa|do da corla. Coro corsequrc|a,
se depo|s l|zerros c.obterSaldo() ver|l|caros que d 00, da resra lorra que b.obterSaldo()
laror va| resu|lar er 00. lslo porque aroas as var|ve|s rar|pu|ar o resro e ur|co oojeclo - b e c so
refernc|as para o mesmo objecto.

Exemp|o 5:

import java.io.*;
public class Untitled1
{
{
Random objectoDaClassRandom; // declarao
objectoDaClassRandom = new Random(); // instanciao

int var1, var2; double varD, varG;

var1 = objectoDaClassRandom.nextInt(); // mensagem
var2 = objectoDaClassRandom.nextInt(50); // mensagem
varD = objectoDaClassRandom.nextDouble(); // mensagem
varG = objectoDaClassRandom.nextGaussian(); // mensagem

System.out.println("var1= "+ var1 + " var2=" + var2);
System.out.println("varD= "+ varD + " varG=" + varG);
}
}


7.7 - Mtodos e Passagem de Parmetros (reviso)
0s rlodos sao ercarados coro suo-prograras. J v|ros que ur suo-prograra pode receoer parrelros que sao
dec|arados rura ||sla de parrelros lorra|s e quardo lr va|ores assoc|ados sao deror|rados de parrelros
corcrelos ou aclua|s.
v|ros laror que a passager de parrelros para ur suo-prograra (rlodo) pode ser le|la de duas lorras: por
va|or, ou por relerrc|a.

Em Java, rao se esco|re a lorra coro os parrelros sao passados:
Parrelros cujo l|po seja pr|r|l|vo (|rl, srorl, |org, douo|e, ooo|ear, crar,...) sao serpre passados por va|or.
0u seja, derlro do corpo do rlodo o que rar|pu|aros ura cp|a do va|or do parrelro ul|||zado ra
|rvocaao do rlodo.
0ados de l|pos que rao sejar pr|r|l|vos sao oojeclosl
o var|ve|s corresporderles a ur 0ojeclo rao arrazerar o 0ojeclo, ras s|r o erdereo de
rerr|a desse oojeclol (sao relerrc|as)
o 0uardo ur parrelro lorra| ura |rslrc|a de ura c|asse (ur 0ojeclo) o que passado para
o rlodo o erdereo de rerr|a orde esl arrazerado o 0ojeclo (a relerrc|a para o
oojeclo).
o E erlao as a|leraoes execuladas ro |rler|or do rlodo soore o Parrelro Forra| que seja ur
0ojeclo rel|ecler-se ro Parrelro Corcrelo cor que o rlodo lo| |rvocado.
o 0u seja, eslaros perarle ur caso de corporlarerlo er ludo equ|va|ente a passagem por
refernc|a

Exemp|o :

// Exemplo de um programa que demonstra a passagem por valor
class PassagemPorValor
{

// incrementa: recebe um inteiro x e soma-lhe o valor 1
public static void incrementa(int x) {
x = x + 1;
System.out.println (x = + x);
}

public static void main(String [] args) {
PassagemPorValor p;
p = new PassagemPorValor();

int y = 1;

System.out.println(y = + y);

p.incrementa(y);

System.out.println(y = + y);
}
}

// O valor da varivel x alterado,
// mas o valor da varivel y no


Exemp|o 7:

// Exemplo de um programa que demonstra a passagem por valor
public class PassagemPorValor
{
{
int pcA = 10, pcB = 20;
System.out.println(pcA= + pcA + pcB= pcB);
metPassagemValor(pcA,pcB);//invocacao do mtodo metPassagemValor
System.out.println (pcA= + pcA + pcB= pcB);
}

static void metPassagemValor(int pfA, int pfB)
{
pfA = 111;
pfB = 222;
System.out.println(Como o que est a passar para dentro do");
System.out.println(mtodo so os valores 10 e 20 e no);
System.out.println(Os endereos de memria das variveis pcA e);
System.out.println (pcB, os seus valores no so alterados);
}
}

Exemp|o 8:

// Exemplo que demonstra o funcionamento
// das referncias para objectos quando passados
// como parmetros a mtodos
class Referencia {

// redefine: recebe uma referncia para uma conta bancria
// cria uma nova conta, credita a primeira e depois
// credita a nova conta acabada de criar
void redefine (Conta a) {
Conta b = new Conta(567-8,55);
a.creditar(100);
a = b;
a.creditar(100);
}

public static void main(String args[]){
Referencia r;
r = new Referencia();
Conta c = new Conta(123-4,12);
r.redefine(c);
System.out.println(c.getSaldo());
}
}
// no altera o valor de c
// altera o estado do objecto referenciado por c


7.8 - Construtores
ura das parles ra|s |rporlarles da prograraao or|erlada por oojeclos saoer ul|||zar correclarerle os
corslrulores de oojeclos.
0 corslrulor ur rlodo espec|a| ul|||zado aperas ra cr|aao e |r|c|a||zaao de oojeclos de ura delerr|rada c|asse.
0 seu ur|co e exc|us|vo oojecl|vo |r|c|a||zar os alr|oulos, ou seja, dar um estado |n|c|a| ao objecto.
Poder ex|sl|r corslrulores cor parrelros, corslrulores ser parrelros e corslrulores crarados oelau|r (erlre
oulros que rao varos rerc|orar agora).
E |rporlarle reler que o corslrulor sempre public e ler sempre o mesmo nome que a c|asse para a qua|
cr|ado.

Exemp|o 9:

public class Conta {
private double saldo;

public Conta() { // Construtor sem parmetros
saldo = 0.0; // quando um objecto do tipo conta criado
// com este construtor, fica com saldo 0
}

public Conta(double saldoInicial) { // Construtor com parmetros

saldo = saldoInicial; // quando um objecto do tipo Conta
// criado com este contrutor
// fica com um saldo cujo
// valor inicial dado pela varivel
// dada como argumento (saldoInicial)
}

Conta(String numeroConta, double saldoInicial)
{ // mais um exemplo de um construtor com parmetros
// numeroConta e saldoInicial so os parmetros formais...

numero = numeroConta;
saldo = saldoInicial;
}
}

0uardo rao se del|re rerrur corslrulor ra c|asse que espec|l|ca o oojeclo, a rqu|ra v|rlua| ercarrega-se de cr|ar
ur er lerpo de execuao, equ|va|erle a:

<nome da classe>(){}

Esle corslrulor |r|c|a||za os alr|oulos do oojeclo cor va|ores oelau|r, que corresporder a:
0 se o alr|oulo lor de l|po rurr|co (short, byte, int, long, double,float, char)
false se o alr|oulo lor de l|po boolean
null para relerrc|as

Nota: null represerla ura relerrc|a ru|a, rao ex|slerle, para ur oojeclo perlercerle a ura qua|quer c|asse.


Exemp|o 10:

class Funcionario{
String nome, codigo; // Atributos
float salario;

Funcionario(String nomef,String ident,float sal){ // Construtor
nome=nomef;
codigo=ident;
salario=sal;
}
...
}

class admissao{
Funcionario func = new Funcionario(Pedro,15080,150);
...
} // cria uma referncia chamada func para um Funcionrio que
// construdo com o valor inicial Pedro para o nome,
// 15080 para o cdigo e 150 para o salrio
}

Exemp|o 11:

// Exemplo que demonstra a utilizao de um construtor implcito
// ou default
class Funcionario{

// atributos
String nome, codigo;
float salario;

// admite: atribui novos valores aos atributos de um Funcionario
void admite(String nomef,String ident,float sal){
nome=nomef;
codigo=ident;
salario=sal;
}...
} // note-se que a classe Funcionrio no tem construtor!

class admissao{

Funcionario ze = new Funcionario(); //chamada ao construtor
//default!
ze.admite(Z,15090,150); // invocao do mtodo admite
...
}
}


7.9 - Definio de Novas Classes
Para a|r de ul|||zar as c|asses pr-del|r|das pe|a ||rguager, rorra| que seja recessr|o del|r|r rovas c|asses que
ros ajuder a reso|ver os rossos proo|eras (a||s, |sso que leros v|rdo a lazer er ru|los dos exerp|os. A c|asse
Corla, por exerp|o, rao laz parle da ||rguager).

0el|r|r ura c|asse s|gr|l|ca ooedecer a segu|rle eslrulura:
0el|r|r alr|oulos (var|ve|s) de c|asse
0el|r|r alr|oulos (var|ve|s) de |rslrc|a (que vereros ra|s ad|arle) se lor recessr|o
0el|r|r corslrulores
0el|r|r rlodos

NF (s|mp||f|cada}:

<Definio de Classe> ::=
// comentrios sobre a classe
public class <nome da classe>
{
//definio dos atributos de Classe
<tipo1> <atributo1>;
<tipo2> <atributo2>, <atributo3>;
...
//definio dos atributos de Instncia
<tipo1> <atributo1>;
<tipo2> <atributo2>, <atributo3>;

// definio dos construtores
<construtores>
...
// definio dos mtodos de classe
static void <mtodo1>(){...}
static void <mtodo2>(<parmetros>){...}
static <tipo> <mtodo3>(){...}
static <tipo> <mtodo4>(<parmetros>){...}

// definio dos mtodos de instncia
void <mtodo1>(){...}
void <mtodo2>(<parmetros>){...}
<tipo> <mtodo3>(){...}
<tipo> <mtodo4>(<parmetros>){...}
}


Exemp|o 12:

// Definir uma Classe
public class A_MinhaClasse ()
{
// Atributo
double contaNoBanco;

// Mtodo
private static recebeOrdenado (double ordenado)
{
// Instruo
contaNoBanco = contaNoBanco + ordenado;
}
}

...

// Criar um objecto a partir da classe definida, ou seja,
// Instanciar a classe
A_MinhaClasse contaDoBanco = new A_MinhaClasse();
7.10 - Variveis de Classe
ura var|ve| de c|asse ur alr|oulo da c|asse que possu| ura caraclerisl|ca ru|lo espec|a|: lodos os oojeclos que
lorer cr|ados a parl|r dessa c|asse parl||rar o resro va|or para esse alr|oulo (la| coro parl||rar os rlodos que a
c|asse del|re).
var|ve|s de c|asse er Java sao del|r|das recorrerdo a pa|avra reservada static (Exerp|o: static double
valor_cambio_dolar).

0a resra lorra que ex|sler var|ve|s esll|cas laror ex|sler rlodos esll|cos. 0s rlodos esll|cos poder
ser |rvocados soore a c|asse, rao recessr|o cr|ar rerrura |rslrc|a da c|asse er que lorar dec|arados para os
poderros ul|||zar (ur oor exerp|o d|slo sao os rlodos del|r|dos ra c|asse Math).
E |rporlarle rerc|orar que os rlodos esll|cos aperas poder rar|pu|ar var|ve|s |oca|s ou erlao alr|oulos
esll|cos.

Exemp|o 13:

// Exemplo que demonstra a utilizao de atributos e mtodos estticos
class Produtoexportacao
{
String nome;
float preco_venda,preco_compra;
static float valor_dolar;

Produtoexportacao(String nome,float precov,float precoc)
{
this.nome=nome;
this.preco_venda=precov;
this.preco_compra=precoc;
}

...


static void cambio(float valor)
{
valor_dolar=valor;
}
}

class ComercioExterior{

{
float cotacao = 1.50;

// Chamada de mtodo esttico sem instanciao
Produtoexportacao.cambio(cotacao);
}
}
7.11 - Variveis de Instncia
As var|ve|s de |nstnc|a sao as var|ve|s rao esll|cas del|r|das rura c|asse, lora dos rlodos. 0s oojeclos
cr|ados a parl|r dessa c|asse possuer, cada ur de|es, ura cp|a dessa var|ve|.
0 va|or arrazerado er cada ura dessas cp|as corsl|lu| ura caraclerisl|ca ou propr|edades especil|ca desse
oojeclo.
Perlercer ao oojeclo coro ur lodo e rao a ur rlodo er parl|cu|ar.
7.12 - O Operador de Auto-Referenciao this
A pa|avra reservada this pode ser ul|||zada, derlro de ur o|oco de ur rlodo, para reler|r o oojeclo aclua|.
this ur 'aporlador ou ura relerrc|a para o oojeclo er queslao. usardo esle aporlador, ur rlodo pode
aceder a lodas os alr|oulos da c|asse a que perlerce.
this cr|ado auloral|carerle quardo ur oojeclo crara ur rlodo e 'aporla para o prpr|o oojeclo que crarou
o rlodo.

Exemp|o 14:

class Funcionario{

String nome, codigo;
float salario;

Funcionario(String nome,String codigo,float salario)
{
this.nome=nome; // Acesso aos atributos
this.codigo=codigo;
this.salario=salario;
} // neste caso o operador this ajuda ainda a resolver
// ambiguidades. Caso contrrio como saberamos de que nome
// codigo ou salario se estava a falar?
// nome=nome no tem significado!
// qual deles o atributo da classe funcionrio e qual o
// que foi passado como parmetro?
}



0bject|vos da 8r|e:

. Correa as oases da prograraao or|erlada pe|os oojeclos
Z. 3a|oa cr|ar rovas c|asses e |rslarc|-|as

Parte | - 0uestes Ter|cas

10. lrd|que a|guras d|lereras erlre a prograraao eslrulurada e a prograraao or|erlada aos oojeclos.
11. ura c|asse e ur oojeclo sao a resra co|sa? 3e rao sao, erlao qua| (ou qua|s) as d|lereras erlre esles
do|s corce|los?
12. No seu porlo de v|sla o que sao alr|oulos, rlodos e rersagers?
13. 0ua|s sao as |rslruoes que recess|la de ul|||zar para proceder a |rslarc|aao de ura c|asse? 0 ur
exerp|o.
11. E possive| ra resra ap||caao ul|||zar ra|s do que ura relerrc|a para o resro oojeclo, lerdo ass|r
lorras d|lererles de rar|pu|ar ura cp|a ur|ca de |rlorraao. verdade|ro ou la|so? 3e lor verdade,
corerle a al|rraao jusl|l|cardo e d exerp|os.
15. Para que serve a |rslruao relurr?
1. 0ua|s sao as lorras que correce para erv|ar rersagers a ur oojeclo?
1Z. 0 que ur corslrulor?
18. 0ue l|pos de corslrulores correce?
19. ur corslrulor pode ou rao ler parrelros. E l|po de relorro, ler?
20. 0|ga o que erlerde por var|ve| de c|asse e var|ve| de |rslrc|a. Verc|ore as d|lereras erlre aroas e
jusl|l|que a resposla.
21. Coro pode cr|ar e ul|||zar var|ve|s de c|asse? lslo , qua|s sao os passos a dar? Jusl|l|que e d exerp|os.
22. Para ul|||zar ura var|ve| e/ou ur rlodo esll|co de ura c|asse recess|la de |rslarc|ar a c|asse?
Jusl|l|que.
23. Vlodos esll|cos poder relererc|ar alr|oulos que rao sejar esll|cos? Jusl|l|que.
21. 0 que e para que serve o operador lr|s?

Parte || - Ap||cao de 6once|tos Usando Pequenos Programas

Exerc. 1: 0ado o leorera de P|lgoras: '0 quadrado da r|polerusa |gua| a sora dos quadrados dos calelos

A||nea A
Proporra ur a|gor|lro para ca|cu|ar a r|polerusa usardo o Teorera de P|lgoras. Escreva-o er pseudo cd|go ou
l|uxograra.

A||nea
Escreva o cd|go de ur prograra er Java para elecluar o c|cu|o ro corpulador

A||nea 6
E|aoora o rlodo para lazer o ca|cu|o e a|lera o prograra para usar o rlodo.

A||nea 0
lderl|l|que ro seu prograra orde eslao as var|ve|s |oca|s

A||nea E
lderl|l|que ro seu prograra se r e orde eslao as var|ve|s g|ooa|s

A||nea F

Para o rlodo |rd|que orde eslao a |rvocaao, os parrelros lorra|s e os parrelros aclua|s.

Exerc. 2: ur porlo ro espao del|r|do pe|as suas coorderadas carles|aras x e y.

A||nea A
Escreva o cd|go de ura c|asse Java para corcrel|zar a del|r|ao de porlo.

A||nea
Nessa c|asse |rp|ererle rlodos para:
1. 0elerr|rar a d|slrc|a erlre do|s porlos
2. 0elerr|rar a d|slrc|a de ur porlo a or|ger

A||nea 6
Escreva o rlodo ra|r, orde receoer do lec|ado as coorderadas de do|s porlos e roslre o resu|lado do c|cu|o da
d|slrc|a de cada ur de|es a or|ger e do c|cu|o da d|slrc|a erlre s|.

A||nea 0
lderl|l|que ro seu prograra orde eslao as var|ve|s |oca|s.

A||nea E
lderl|l|que ro seu prograra se r e orde eslao as var|ve|s g|ooa|s.

A||nea F
Para o rlodo |rd|que orde esla as |rvocaao, os parrelros lorra|s e os parrelros aclua|s.

Exerc. 3: A lurao para o c|cu|o de coro|raoes de r p a p del|r|da por:
!
!( )!
n
p
n
C
p n p
=

Escreva ur prograra que ca|cu|e Cpr e |rpr|ra os resu|lados para va|ores de r e de p (rureros |rle|ros) dados
pe|o ul|||zador. 0 prograra deve lazer uso da c|asse laclor|a| que serve para ca|cu|ar o laclor|a| de ur rurero e |re
lorrec|da er arexo:

public class Factorial{
static long calcula(int n) {
if (n < 2) return 1;
return n*f(n-1);
}
}

Exerc. 1: lrd|que qua| o resu|lado v|sua||zado ro ecra aps a execuao do segu|rle prograra:

public class VariavelDeClasse {
static int n = 2;
String descricao;
{
VariavelDeClasse v1 = new VariavelDeClasse();
v1.n = 1;
VariavelDeClasse.n--;
v1.descricao = "Ola";
VariavelDeClasse v2 = new VariavelDeClasse();
v2.n = 2;
VariavelDeClasse.n++;
v2.descricao = "isto e um teste";

System.out.print(v1.descricao + " ");
System.out.print(v1.n);
System.out.print(" ** ");
System.out.print(v2.descricao + " ");
System.out.print(v2.n);
}
}

a) 0|a 1 |slo e ur lesle 2
o) 0|a 2 |slo e ur lesle 3
c) 0|a 3 |slo e ur lesle 3
d) 0|a 0 |slo e ur lesle 3

Exerc. 5: No exercic|o arler|or, |rd|que orde se ercorlra ura var|ve| de c|asse e ura var|ve| de |rslrc|a.

Exerc. : Cr|e ur prograra que delerr|re a parl|r das coorderadas de 3 porlos, lorrec|das pe|o ul|||zador, o l|po de
lr|rgu|o que eslas represerlar (equ||lero, |ssce|es ou esca|ero). 0eve laror roslrar se se lrala ou rao de ur
lr|rgu|o reclrgu|o.

Nota:
1. Tr|rgu|o equ||lero ler os 3 |ados |gua|s.
2. Tr|rgu|o |ssce|e ler 2 |ados |gua|s.
3. Tr|rgu|o esca|ero ler os 3 |ados d|lererles.
1. ur lr|rgu|o reclrgu|o quardo ver|l|ca a propr|edade dada pe|o leorera de P|lgoras: o quadrado da
r|polerusa |gua| a sora dos quadrados dos calelos.

0eve |rp|ererlar:
1. A c|asse porlo para represerlar as coorderadas e
2. A c|asse lr|argu|o para represerlar lr|rgu|os.
3. Er separado ler a c|asse que corlr o prograra pr|rc|pa| e laz uso das oulras duas para curpr|r os
oojecl|vos prelerd|dos.


8 - Recursividade
8.1 - Definies
A repel|ao de execuao de ur grupo de |rslruoes para d|lererles va|ores de dados pode ser |rp|ererlada de duas
lorras:
lleral|va (ou exp|ic|la).
Recurs|va (ou |rp|ic|la). 0uardo ur rlodo esl del|r|do er lerros de|e prpr|o.

Por exerp|o, vejaros o c|cu|o do laclor|a| de ur rurero ralura|. Esle pode ser le|lo de duas lorras:

Forra |leral|va
rl = r(r-1)(r-2).1

Forra recurs|va (del|r|rdo-se ura lorra recurs|va da lurao)
1l=1
rl = r(r-1)l

ver|l|ca-se que recorre a s| prpr|a, dai o rore de lurao recurs|va
Nas |rp|ererlaoes recurs|vas, as duas corporerles pr|rc|pa|s de ura del|r|ao recurs|va sao as segu|rles:

ur caso e|ererlar (ou cr|lr|o de parager)
No exerp|o do c|cu|o do laclor|a| esle cr|lr|o dado por 1l=1.

0 caso gera|, ou parle recurs|va, rl=r(r-1)l

A recurs|v|dade ru|lo usada por exerp|o ro c|cu|o de proo|eras ralerl|cos, corludo a recurs|v|dade pode
causar proo|eras de rerr|a er v|rlude da dup||caao de var|ve|s |oca|s, |rc|u|rdo os parrelros.

Exemp|os:

No exerp|o segu|rle ser apreserlado o c|cu|o do laclor|a| de ur rurero ralura| alravs da lorra |leracl|va e
recurs|va.

|terat|va

public class FacInt {

{
for (int i = 0; i < 9; i++)
System.out.println("f(" + i + ") = " + factorial(i));
}

static long factorial(int n)
{
long f = 1;
while (n > 1)
f *= n--;
return f;

}
}

/*
Output:

f(0) = 1
f(1) = 1
f(2) = 2
f(3) = 6
f(4) = 24
f(5) = 120
f(6) = 720
f(7) = 5040
f(8) = 40320
*/

Recurs|va

public class TestFactorialRec

{ public static void main(String[] args)
{
for (int i = 0; i < 9; i++)
System.out.println("f(" + i + ") = " + fact(i));
}

static long fact(int n)
{
if (n < 2) return 1;
return n*fact(n-1);
}
}

/*
Output:

f(0) = 1
f(1) = 1
f(2) = 2
f(3) = 6
f(4) = 24
f(5) = 120
f(6) = 720
f(7) = 5040
f(8) = 40320
*/


veja-se para esle u|l|ro caso o raslo do c|cu|o do laclor|a|

l(3) = 3 l(2) =
j
2 l(1) = 2
j
1 1 = 1

Para l|ra||zar, repare-se que:
Nura |rp|ererlaao |leral|va o c|c|o esl preserle exp||c|larerle coro eslrulura de repel|ao.
Nura |rp|ererlaao recurs|va o c|c|o esl preserle, ras rascarado por ura eslrulura de se|ecao.
8.2 - Exerccios prticos
Exerc.1 - Faa ura lurao recurs|va que ca|cu|e o va|or de 3, orde 3 = 1 1/3 1/5 1/N.

Exerc.2 - Escreva ura lurao recurs|va que ca|cu|a e relorra o va|or de 3, orde 3 = 1 1/1l l 1/3l 1 /Nl.

Exerc.3 - Escreva ur rlodo recurs|vo que ca|cu|a e relorra o va|or de 3. 3 = 2/1 5/5 10/ 1Z/Z 2/8 ...
(r21)/(r3)

Exerc.1 - Escreva ur rlodo recurs|vo que ca|cu|e o va|or do co-sero de x alravs de 20 lerros da sr|e segu|rle:
co-sero(x) = 1 - x2 x1 - x ....2l 1l l

Exerc.5 - Escreva ura lurao recurs|va que ca|cu|a e relorra a lurao polrc|a X".

Exerc. - Faa ur proced|rerlo recurs|vo que ordere er order crescerle os r e|ererlos de ur veclor de |rle|ros
de r pos|oes.

Exerc.Z - Faa ura lurao recurs|va que ca|cu|e o rdc erlre do|s rureros:
rdc(r1,r2) = r1 , se r2 = 0
rdc(r1,r2) = rdc( r2, r1 rod r2), se r2 l= 0

Exerc.8 - 0ada a lurao X del|r|da aoa|xo:

A|gor|lro X(r,r: |rle|ro): |rle|ro;

inicio
se (n=m) ou (m=0)
entao
X = 1
senao
X = X(n-1,m) + X(n-1,m-1)
fim
0ua| o va|or de X(5,3) ?
0uarlas craradas serao le|las ra ava||aao ac|ra ?

va|or 1
3aida
Prograra
var|ve| 1
var|ve| 2
var|ve| 3
va|or 2
va|or 3
va|or 1
va|or 2
va|or 3
3aida
va|or 1
va|or r
...
Prograra
var|ave|
9 - Tabelas
9.1 - Motivao
ur prograra que rar|pu|e vr|os va|ores, arrazera esles va|ores er a|guras var|ve|, laz o respecl|vo
processarerlo e erv|a o resu|lado para o exler|or (l|g.-1).

F|gura 11. Arrazerarerlo, processarerlo de va|ores e saida.

Ner serpre os prograras rar|pu|ar lao poucos va|ores, poderdo recess|lar de rar|pu|ar vr|os va|ores. Esles
poder ser ||dos e processados ur de cada vez(l|g.-2).

F|gura 12. Var|pu|aao de vr|os va|ores


lrag|reros agora ur prograra que |r |er vr|os va|ores e |rpr|r|-|os pe|a order |rversa. 0 prograra deve
process-|os 'quase lodos ao resro lerpo para produz|r a saida desejada (l|g. 3).

F|gura 13. Le|lura de vr|os va|ores e sua v|sua||zaao pe|a order |rversa

A a|lerral|va para esle l|po de s|luaoes o uso de Taoe|as, que rao sao ra|s do que ura ||sla de va|ores. Ass|r,
para o exerp|o da l|g. 3 poder|aros arrazerar os va|ores rura var|ve| do l|po laoe|a e aceder aos va|ores pe|a
order desejada (l|g.1).

F|gura 11. Arrazerarerlo de vr|os va|ores rura laoe|a.

va|or 1
3aida
Prograra
...
var|ve| 1
va|or 2
va|or 3
va|or 1
va|or 5
va|or r
var|ve| 2
var|ve| 3
var|ve| 1
var|ve| 5
var|ve| r
...
va|or 1
3aida
Prograra
var|ve|
Taoe|a
va|or 2
va|or 3
va|or 1
va|or 5
va|or r
...

9.2 - Tabela Unidimensional

Ex|sler duas lorras de dec|arar ura laoe|a er Java:

(1) <l|po> <var|ve|> [ |
(2) <l|po> [ | <var|ve|>

Exemp|os .

(1) |rl lao [ | ;
(2) |rl [ | lao ;
9.2.1 - Variveis Simples e do tipo tabela

Fazerdo ura pequera rev|sao soore as var|ve|s s|rp|es, eslas :

arrazerar ur s va|or.
sao cr|adas quardo da sua dec|araao.
arrazerar l|pos pr|r|l|vos, que sao rar|pu|ados por va|or.

As laoe|as:

sao ur agragado de va|ores, lodos do resro l|po.
eslao |rdexadas a parl|r de 0.
ura vez cr|adas possuer ur lararro l|xo.
sao cr|adas er java d|rar|carerle, ou seja, er lerpo de execuao.
o seu espao auloral|carerle reaprove|lado quardo de|xar de eslar relererc|ados.
9.2.2 - Passos para utilizar uma tabela

0s passos para ul|||zar ura laoe|a sao lrs, dec|araao, |rslarc|aao e relererc|aao:

1) 0eclarao :

int [] tab; // declara uma referncia para uma tabela de inteiros
com qualquer dimenso, iniciada com null

2) lnstanciao :

tab = new int[5] ; //criao de uma tabela com capacidade para 5
inteiros

ru|| lao


ura laoe|a er java serpre cr|ada d|rar|carerle cor o operador new
0 ird|ce dos e|ererlos corea er 0 e lerr|ra er lararro 1, ou seja, ura laoe|a de lararro
N |rdexada de 0 a N-1. Caso se exceda a d|rersao da laoe|a gerada ura excepao.
0epo|s de |rslarc|ado poderos saoer a sua d|rersao corsu|lardo o alr|oulo s de |e|lura
length ( exp: tab.length).
As laoe|as de va|ores rurr|cos sao |r|c|a||zadas a zero.

A |rslarc|aao (cr|aao) de ura laoe|a pode ser le|la ro rorerlo de dec|araao, se se |rd|car o corleudo.

int tab [ ] = {1,1,2,3,5,8,13,34}; // criada uma tabela com
// 8 elementos

3) Referenciao :

tab[1] = 12; // o elemento com o ndice 1 da tabela
// passa a armazenar o valor 123

lao 1 12

2 3
lao[0| lao[3|
lao[2|
lao[1|
5 8 13 31
... lao[Z|
lao 1 1

2 3
lao[0| lao[3|
lao[2|
lao[1|
5 8 13 31
... lao[Z|
lao
lao[0| lao[1| lao[2| lao[3| lao[1|


Exemp|o do uso de tabe|a e var|ve|s s|mp|es

Uso Var|ve| 8|mp|es Tabe|a
Atr|bu|o valor = 10.6; tab[3] = 10.6;
Entrada valor = Le.umDouble ( ); tab[3] = Le.umDouble ( );
8a|da System.out.println(valor); System.out.println(tab[3]);
Expresso x = valor / 2; x = tab[3] / 2;
6omparao if (valor > 5.0); if (tab[3] > 5.0);
Parmetros Testa(valor); Testa(tab[3]);

Exemp|os de acesso aos e|ementos de uma tabe|a:

Exemp|o 1

Nesle exerp|o prelerde-se ca|cu|ar o va|or rd|o da p|uv|s|os|dade er 18 aros. Para la|, cr|a-se ura laoe|a que
guarde 18 va|ores e preercresse a laoe|a cor os va|ores da p|uv|s|os|dade:

double [ ] pluv = new double [18];

pluv [0] = 30.55;
pluv [1] = 23.94;
.
//restante valores

0epo|s eleclua-se a sora dos va|ores, que pode ser le|la por duas lorras :

double total = pluv[0] + pluv[1] + pluv[2] + pluv[3]
+ pluv[4] + pluv[5] + pluv[6] + pluv[7]
+ pluv[16] + pluv[17];

ou

double total = 0.0;
for ( int ano = 0; ano < pluv.length; ano ++)
total = total + pluv[ano];

Nota :
re|erore-se que o ird|ce do veclor corea er 0 e pode |r al length-1

Cor o va|or da sora elecluado, poderos ca|cu|ar a rd|a e |rpr|r|r para o ecrar o va|or:

System.out.println(O valor mdia de pluviosidade +(total/pluv.length));

Exemp|o 2

0 exerp|o segu|rle ler coro oojecl|vo ped|r ao ul|||zador o va|or de c|rco |rle|ros, |rpr|r|r ro ecrar os va|ores
|rlroduz|dos, ca|cu|ar a sora, a rd|a e o va|or rx|ro desles va|ores (l|g. 5).


import Le;

public class MaxTotal{

{
int n1[] = new int[5];
int soma=0;
int max=0;

//Ler array

for(int i=0;i<5; i++) {
n1[i]=Le.umInt();
System.out.println(Introduza um valor: );
}

//Mostrar array
for(int i=0;i<5; i++)
System.out.println("i["+i+"]="+n1[i]);

//Calcular mximo, total
for(int i=0;i<5; i++){
soma+=n1[i];
if (max<n1[i])
max=n1[i];
}

//Mostrar resultados
System.out.println("Total:"+soma);
System.out.println("Media:"+(float)soma/n1.length);
System.out.println("Maximo:"+max);

//Nota: na media necessrio fazer uma divisao
//de floats.
}

F|gura 15. Cr|aao e preercr|rerlo da laoe|a do exerp|o 2.
3
1 1
Tabela criada com 5
elementos indexados
de 0 a +
Depois de uma
iteraao
do ciclo
10
11
2
3
1
Depos de duas
iteraoes
do ciclo
Depos das cinco
iteraoes
do ciclo
0
1
2
3
+
indices

9.2.3 - Acesso a elementos no existentes

Cors|dere o exerp|o 2, do porlo 1.2.1, ro qua| cr|ado e preercr|do ur arra, de c|rco e|ererlos. Caso se lerlasse
aceder a ur e|ererlo |rex|slerle, durarle a execuao do prograra ser|a deleclado ur erro:

n1 [5] = 4; //acesso a um ndice que no existe

0 erro deleclado ser|a:

Java.lang.ArrayIndexOutOfBoundsException:19
At Teste.main(Test.java)
9.3 - Passagem de tabelas como parmetros de mtodos
ura laoe|a pode ser passada coro parrelro a ur rlodo. 0 que passado coro parrelro (por va|or) a
relerrc|a da laoe|a, o que s|gr|l|ca a a|leraraao de ur e|ererlo da laoe|a derlro do rlodo, a|lera a laoe|a or|g|ra|.

Taror possive| passar coro parrelro ur e|ererlo de ura laoe|a, desde que se s|gar as regras relererles ao
seu l|po.

E possive| passar coro parrelro ur e|ererlo de ura laoe|a, desde que se s|gar as regras relererles ao seu l|po.

Exemp|o:

public class programa {

public static void main(String args[]) {
int [] array = new int[2];

array[0]=12;
array[1]=10;

for(int i=0;i<array.length;i++)
System.out.println(array[i]);

metodo_1(array);


metodo_2(array[1]);

}

public static void metodo_1(int [] varray) {
array[i]=array[i]+1;
}

public static void metodo_2(int var) {
System.out.println(O valor recebido :+var);
}
}

/*
O output do cdigo atrs apresentado, luz dos conceitos introduzidos
:

12
10
13
11
O valor recebido 11.
13
11
*/
9.4 - Tabela Multidimensional
ura laoe|a ur|-d|rers|ora| represerla ura ||sla de va|ores erquarlo que ura laoe|a ru|l|d|rers|ora| represerla
ura ralr|z, cor ||rras e co|uras.

Cada e|ererlo de ura laoe|a ru|l|d|rers|ora| relererc|ado usardo do|s ird|ces.
Er Java, ura laoe|a ru|l|d|rers|ora| ura laoe|a de laoe|as, ou seja ura laoe|a ur|-d|rers|ora| er que cada
e|ererlo ura relerrc|a para ur oojeclo do l|po laoe|a.

0ec|arao:

<tipo> [ ] [ ] <varivel>

Exemp|o

int [ ] [ ] tab;

0 cd|go ac|ra dec|ara lao coro ura laoe|a o|d|rers|ora| de |rle|ros ou coro ura laoe|a de laoe|as, er que
aperas se cr|a ura relerrc|a.

A |r|c|a||zaao que cr|a a laoe|a cor os corpr|rerlos respecl|vos:

1) tab = new int [2] [3];
ou
2) tab [][]={1,2,3} {4,5,6};

lao[0| 1

2 3

1

5

lao[1|

lao lao[0|[0|
lao[1|[2|
lao[0|[2|

Para percorrer a laoe|a usar-se c|c|os for ercadeados.

Exemp|o

public class Matriz {

public static void main(string args[]) {

int tab[][] = {{ 1, 2, 3 }, { 4, 5, 6 }};

for(int i = 0; i < tab.length; i++)
for(int j = 0; j < tab[i].length; j++)
System.out.print("tab[" + i + "][" + j + "] = " + tab[i][j]);
}
}

0 Java ura ||rguager lorlererle l|pada, serdo porlarlo o rurero de d|rersoes da ralr|z e o l|po dos e|ererlos
sao del|r|dos. 0 rurero de e|ererlos er cada d|rersao pode var|ar e o corleudo dos e|ererlos de ura laoe|a
pode ser de qua|squer oojeclos ou l|pos pr|r|l|vos.

Exemp|o

0 exerp|o segu|rle roslra ura ralr|z 30 de veclores de corpr|rerlo var|ado.

Random gerador = new Random();
Integer a3[][][] = new Integer[gerador.nextInt(7)][][];

for(int i = 0; i < a3.length; i++)
{
a3[i] = new Integer[gerador.nextInt(7)][];

for(int j = 0; j < a3[i].length; j++)
{
a3[i][j] = new Integer[gerador.nextInt(5)];
for(int k = 0; k < a3[i][j].length; k++)
a3[i][j][k] = new Integer(i*j+k);
}
}

for(int i = 0; i < a3.length; i++)
for(int j = 0; j < a3[i].length; j++)
for(int k = 0; k < a3[i][j].length; k++)
System.out.print("a3["+i+"]["+j+"]["+k+"] = " + a3[i][j][k]);
9.5 - Tabelas de Objectos
As laoe|as de oojeclos rao sao ra|s do que laoe|as er que cada e|ererlo ura relerrc|a a ur oojeclo de ura
delerr|rada c|asse. Todas as laoe|as de oojeclos sao |r|c|a||zadas a null.


Exemp|os:

Tabe|a de 8tr|ngs

No exerp|o er segu|da apreserlado dec|arada ura laoe|a de 3lr|rgs que rao ra|s do que ura laoe|a er que
cada e|ererlo da laoe|a ura relerrc|a a ura String.

final int NUM_NOMES = 5;

// Declarao e instanciao
String[] nome = new String [NUM_NOMES ] ;

// Inicializao ou Atribuio
nome[0] = "Smith";
nome[1] = "Jones";
nome[2] = "Miller";
nome[3] = "Lui";
nome[4] = "Gonzales";

// Sada
System.out.println ("Resultado:");
for (int indice = 0; indice < nome.length; indice ++)
System.out.println (nome[ + indice + "]: " + nome[indice]);

Tabe|a de 0bjectos da c|asse pessoa

0 cd|go da c|asse pessoa, apreserla-se er segu|da:

class Pessoa
{
String nome;
int idade;
String BI;

public Pessoa (String pfN, String pfC, int pfI)
{
nome = pfN;
BI = pfC;
idade = pfI;
}

public void apresentar()
{
System.out.println(Meu nome + nome);
System.out.println(Tenho + idade + anos);
}

public String getBI()
{
return BI;
}

public String toString()
{
return (nome=+nome+com +idade+anos);
}
}


A c|asse segu|rle lesla a ul|||zaao da c|asse pessoa.

public class Teste
{
public static void main (String args[])
{
Pessoa Pedro;
Pessoa Nuno;
Pedro = new Pessoa(Pedro Martins,403.234.567, 34);
Nuno = Pedro;
Pedro.apresentar();
Nuno.apresentar();
System.out.println(O BI de Pedro e +Pedro.getBI());
}
}

Er segu|da apreserla-se o cd|go orde se cr|a ura laoe|a de oojeclos da c|asse pessoa, que ura laoe|a er que
cada e|ererlo ura relerrc|a a ur oojeclo da c|asse pessoa.

public class TabelaDeObjectos
{
{
//Declarao e Instanciao da tabela
Pessoa[ ] grupo = new Pessoa [4];

//Inicializao dos elementos da tabela (Atribuio)
grupo[0] = new Pessoa("Pedro Sousa", "403234567",34);
grupo[1] = new Pessoa("Antnio Pereira", "233544325",37);
grupo[2] = new Pessoa("Joo Silva", "763234567",40);
grupo[3] = new Pessoa("Joaquim Feliz", "213456567",20);

//Sada
System.out.println("Contedos de cada elemento da tabela:");
for (int pessoa = 0; pessoa < 4; pessoa ++)
System.out.println((pessoa + 1) + " Pessoa do Grupo: " +
grupo[pessoa].toString );
}
}

F|gura 1. Exerp|o grl|co dos resu|lados ool|dos cor o cd|go arler|or

Tabe|a d|nm|ca

No exerp|o apreserlado er segu|da ser cr|ada ura laoe|a d|rr|ca, ||da ura ||sla de rureros |rle|ros lerr|rada
por 0 e depo|s cor os va|ores |||dos ca|cu|ada a rd|a e o va|or rx|ro.

import Le;


Pedro
3ousa
Arlr|o
Pere|ra
Joao 3||va Joaqu|r
Fe||z
grupo[0| grupo[1| grupo[2| grupo[3|

{
//Declarao de uma tabela de inteiros com
// dimenso ainda indefinida

int tab[ ]={};

int soma=0;
int max=0;
int i=1;

//Ler 1 valor

System.out.print(Insira o 1 inteiro:> );
int n =Le.umInt();

while (n!=0)
{
//criar tabela temporria

int tabTemp[]=new int[tab.length+1];

//copiar valores

for(int j=0;j<tab.length;j++)
tabTemp[j]=tab[j];

//inserir novo valor

tabTemp[tabTemp.length-1]=n;

//colocar a tabela temporria na definitiva

tab = tabTemp;

System.out.print(Insira o + j + inteiro:> );
n = Le.umInt();
}

//Mostrar tabela

for(i=0; i<tab.length; i++)
System.out.println(tab[ + i + "]="+ tab[i]);

//Calcular o valor mximo e a soma total

for(i=0; i<tab.length; i++)
{
soma+ = tab[i];
if (max < tab[i])
max = tab[i];
}

//Mostrar resultados

System.out.println("Total:"+soma);

//Nota: na media necessrio fazer uma divisao
//de floats.

System.out.println("Media:"+(float)soma/n1.length);
System.out.println("Maximo:"+max);


}

L|sta Te|efn|ca

No exerp|o segu|rle prelerde-se cr|ar ura ||sla le|elr|ca. Para la|, cr|a-se a c|asse Corlaclo, cujos alr|oulos sao o
rore e o le|elore da pessoa:

public class Contacto {

//Atributos
String nome;
int telefone;

//Construtores
public Contacto(String nomeContacto, int telefoneContacto)
{
nome=nomeContacto;
telefone=telefoneContacto;
}

//Mtodos
public String mostrarContacto()
{
return nome + " - " + telefone;
}

public int obterTelefone()
{
return telefone;
}

public String obterNome()
{
return nome;
}

}

Er segu|da vereros a c|asse L|sla le|elr|ca ra qua| rar|pu|ado ura laoe|a de oojeclos do l|po Corlaclo:

public class ListaTelefonica {

//Atributos
private static final int MAXCONTACTOS= 20;
private Contacto contactos [] = new Contacto[MAXCONTACTOS];
private int nContactos=0;

//Construtores

public ListaTelefonica(){
}

//Mtodos
public void adicionar(){
String nome;
int telefone;

System.out.println("Introduza o nome:");
nome= Le.umaString();
System.out.println("Introduza o telefone:");
telefone= Le.umInt();
Contacto c = new Contacto(nome,telefone);
contactos[nContactos]=c;
nContactos++;
}

public void mostrar(){
for ( int i=0; i<nContactos; i++)
System.out.println(contactos[i].mostrarContacto());
}

public void procurar(){
System.out.println("Qual o telefone:");
int telefone=Le.umInt();
int i=0;
while(i<nContactos && contactos[i].obterTelefone()!=telefone)
i++;
if (i!=nContactos)
System.out.println(contactos[i].mostrarContacto());
else
System.out.println("O nmero no se encontra na lista.");
}

public void ordenar(){
quickSort(0, nContactos-1);
}

private void quickSort( int pri, int ult)
{
int i = pri;
int j = ult;
if (pri > ult)
return;
String pivot = contactos[(pri + ult)/2].obterNome();
do
{
while (contactos[i].obterNome().compareToIgnoreCase(pivot) < 0)
i++;
while (contactos[j].obterNome().compareToIgnoreCase(pivot) > 0)
j--;
if (i <= j)
trocaContactos(i++, j--);
}
while (i <= j) ;
quickSort(pri, j);
quickSort(i, ult);
}

private void trocaContactos(int i, int j){
Contacto tmp = contactos[i];
contactos[i] = contactos[j];
contactos[j] = tmp;
}

//Mtodo Main
{
ListaTelefonica listaTelefonica = new ListaTelefonica();


int seleccao;
do
{
System.out.println("Organizer");
System.out.println("");
System.out.println("1 - Adicionar");
System.out.println("2 - Mostrar");
System.out.println("3 - Procurar");
System.out.println("4 - Ordenar");
System.out.println("5 - Sair");
System.out.println("_______________________");
System.out.println("Qual a sua escolha?");
seleccao = Le.umInt();

switch(seleccao){
case 1:
listaTelefonica.adicionar();
break;
case 2:
listaTelefonica.mostrar();
break;
case 3:
listaTelefonica.procurar();
break;
case 4:
listaTelefonica.ordenar();
break;
case 5:
System.out.println("Adeus.");
break;
default:
System.out.println("Opo errada. Tente de Novo.");
break;
}
}
while(seleccao != 5);
}
}
9.6 - Classe Vector
9.6.1 - Introduo
A c|asse Vector laz parle do package java.util e lurc|ora de lorra |drl|ca a ura laoe|a, perr|l|rdo a
arrazerarerlo de va|ores e a relerrc|a a esles alravs de ur ird|ce. A grarde d|lerera erlre ura laoe|a e ur
oojeclo do l|po Vector que esle pode crescer e d|r|ru|r d|rar|carerle er lararro, erquarlo que ura laoe|a
ler serpre ur lararro l|xo.

0ulra d|lerera cors|sle ro laclo de ur oojeclo do l|po veclor rao ser dec|arado para guardar ur l|po de va|or. ur
oojeclo do l|po Vector gere ura ||sla de relerrc|as para a c|asse Object, perr|l|rdo ass|r guardar qua|quer
l|po de va|or.
9.6.2 - Alguns mtodos da classe Vector
Htodo 0escr|o

Vector ( ) Cr|a ur veclor vaz|o
void addElement (Object obj) Ad|c|ora o oojeclo espec|l|cado ao l|r
do veclor
void insertelementAt (Object obj, int index) Ad|c|ora o e|ererlo ro ird|ce
espec|l|cado
Object remove ( int index) Rerove ur oojeclo do ird|ce
espec|l|cado e relorra-o
Boolean removeElement (Object obj) Rerove a pr|re|ra ocorrrc|a do
oojeclo espec|l|cado.
void removeElementAt( int index) Rerove ur oojeclo do ird|ce
espec|l|cado
void clear ( ) Rerove lodos os e|ererlos do veclor
Boolean contains (Object obj) Relorra lrue se o oojeclo esl ro veclor
int indexOf (Object obj) Relorra o ird|ce do oojeclo
espec|l|cado. Relorra -1 caso o oojeclo
rao ex|sla.
Object elementAt (int index) Relorra o 0ojeclo ro |rd|ce
espec|l|cado
Booleam isEmpty ( ) Relorra lrue se o veclor esl|ver vaz|o
int size ( ) Relorra o rurero de e|ererlos do
veclor

Nota:
Para ra|s |rlorraoes soore os rlodos d|spor|o|||zados por esla c|asse, corsu|lar a docurerlaao do Java.

Exemp|o

Nesle exerp|o ser cr|ado ur oojeclo da c|asse Vector que arrazerar rores. 3erao depo|s ap||cadas a|guras
operaoes ao veclor, coro |rser|r, rerover, ver|l|car que e|ererlo esl rur delerr|rado ird|ce.

public class Nomes {

public static void main ( String [] args){
Vector nomes = new Vector( );

nomes.addElement(Ricardo);
nomes.addElement(Joo);
nomes.addElement(Nuno);
nomes.addElement(Daniel);

System.out.println(nomes);

Nomes.removeElement(Joo);

System.out.println(nomes);
System.out.println(No ndice 1: + nomes.elementAt(1));

nomes.insertAt(Carlos,2);

System.out.println(Tamanho do vector + nomes.size());
}
}

/*Resultado de sada do exemplo:

Ricardo, Joo, Nuno, Daniel

Ricardo, Nuno, Daniel
No ndice 1: Nuno
Tamanho do vector 4
*/
Exerc.1 - Escreva ur prograra que preercra ura laoe|a cor os va|ores |rle|ros gerados a|ealor|arerle e |rpr|ra
lodos os va|ores da laoe|a. Acrescerle depo|s as segu|rles lurc|ora||dades ao seu prograra:
lrd|car quarlos va|ores regal|vos eslao guardados ra laoe|a
lrpr|r|r os va|ores pos|l|vos da laoe|a
lrd|car o ra|or va|or da laoe|a
3uosl|lu|r lodos os va|ores d|v|sive|s por 3 pe|o va|or zero
lrd|car a pos|ao do reror va|or da laoe|a

Exerc.2 - lrp|ererle ur rlodo que relorra o produlo dos e|ererlos de ura laoe|a.
A ass|ralura do rlodo a que se segue:

static double produto(int [ ] x)

Exerc.3 - lrp|ererle ur rlodo que relorra o reror va|or de ura laoe|a.

static double min(double [ ] x)

Exerc.1 - Escrever ur rlodo que, dada ura sequrc|a de n va|ores |rle|ros, relorre a d|lerera erlre os va|ores
rx|ro e rir|ro da sequrc|a.

Exerc.5 - Escrever ur rlodo que rel|re lodas ocorrrc|as de ur caracler carC de ura slr|rg. A ass|ralura do
rlodo a que se segue:

slal|c 3lr|rg rerove(3lr|rg s, crar carC )

Exerc. - Escrever ur prograra que corverla ura slr|rg rura laoe|a de caracleres.

Exerc.Z - Escrever ur rlodo que receoa ur rurero e ura laoe|a e devo|va a pos|ao ra laoe|a orde esle rurero
ocorra ou o va|or -1 ro caso do rurero rao ex|sl|r ra laoe|a. A ass|ralura do rlodo a que se segue:

static int procuraTabela (double v, double[ ] tabDouble)

Exerc.8 - Escrever ur rlodo que |rverla a order dos e|ererlos de ura laoe|a de |rle|ros, passada coro
parrelro.

Exerc.9 - lrp|ererle ur rlodo que suosl|lua o caracler c1 pe|o caracler c2 rura laoe|a. 0 rlodo deve relorrar o
rurero de suosl|lu|oes.

static int substituicao(char c1, char c2, char[ ] tabCar)

Exerc.10 - Escrever ur prograra que devo|va a pos|ao da u|l|ra ocorrrc|a do va|or rx|ro e a pos|ao da
pr|re|ra ocorrrc|a do va|or rir|ro er ura laoe|a de va|ores do l|po douo|e.


Exerc.11 - Escrever ur rlodo que receoa duas laoe|as e relorre lrue se as laoe|as sao |gua|s.

Exerc.12 - Escrever ur prograra que, para ur dada laoe|a de |rle|ros A, corslrua ura laoe|a P lorrada pe|os
ird|ces dos e|ererlos pares de A. Exerp|o: Para A = ( 1 3 Z 8 ), o prograra deve corslru|r P = ( 3 5 ).

Exerc.13- Escrever ur rlodo (e ur prograra que exerc|le la| rlodo) que delerr|re se os e|ererlos de ura
laoe|a ercorlrar-se er order decrescerle ou rao.

Exerc.11 - Escrever ur prograra que, dada ura sequrc|a de n va|ores |rle|ros (gerados a|ealor|arerle) que
represerlar o resu|lado de n |ararerlos de ur dado, delerr|re o rurero de ocorrrc|as de cada lace ra
sequrc|a ara||sada.

Exerc.15 - 0ada ura sequrc|a de r rureros rea|s, lazer ur prograra que delerr|re os rureros que corpoer a
sequrc|a e a lrequrc|a de la|s rureros ra sequrc|a dada.

Exerp|o:

r = 10
3equrc|a: 3.2 8.1 2.5 3.2 Z.1 8.1 3.2 .3 Z.1 3.2

3aida:
Nur Freq
3.2 1
8.1 2
2.5 1
Z.1 2
.3 1

Exerc.1 - Escrever ur prograra que delerr|re o ra|or va|or er ura ralr|z de va|ores |rle|ros cor r>0 ||rras e
r>0 co|uras. Er segu|da a|lere o prograra arler|or para |rd|car lodas as pos|oes da ralr|z er que se ercorlra la|
va|or rx|ro.

Exerc.1Z - lrp|ererle ur rlodo que relorre o c|cu|o do produlo exlerro erlre duas ralr|zes. A ralr|z resu|larle
ca|cu|a-se da segu|rle lorra p[||[j|=x[||y[j|, orde x e y sao os veclores de erlrada.
A ass|ralura do rlodo :

static double[][] productoExterno(double[] x, double[] y)

Exerc.18 - Escrever ur prograra que |r|c|a|rerle | ur rurero |rle|ro N. 3e o va|or |rlroduz|do lor reror que 2
(do|s) l|ra||zar o prograra. Caso corlrr|o, cr|a d|rar|carerle ura ralr|z de |rle|ros NxN. Er segu|da | ur va|or
para cada pos|ao da ralr|z e, ro l|ra|, roslrar se a ralr|z possu| a|gur va|or repel|do.

Exerc. 19 - 0el|ra ura c|asse weo3|le caracler|zada pe|o rore, erdereo e ||sla de leras que se poder ercorlrar
ro resro. lrp|ererle as segu|rles lurc|orao|||dades a esla c|asse:
0elerr|raao de quarlos leras possu| o Weos|le
ver|l|car se ur delerr|rado lera ex|sle ro Weos|le
Rerover ur lera

E|aoore ura c|asse Cala|ogoweo que |rp|ererla ur arqu|vo soore Weo3|les e cujas lurc|orao|||dades sao:
0elerr|raao do rurero lola| de Weos|les do cal|ogo
L|slar os weos|les que lralar ur delerr|rado lera T
Rerover ur Weos|le

Exerc.20 - lrp|ererle as c|asses que acrar recessr|as para o segu|rle corlexlo:


ur 8arco gere ur corjurlo de corlas seus c||erles, perr|l|rdo que esles depos|ler, |evarler e ||sler os seus
sa|dos.

Para que ura corla seja correclarerle cr|ada recessr|o o rore e r de corlr|ou|rle do c||erle e ur sa|do rir|ro
de 50C.

0 c||erle s poder rea||zar |evarlarerlos se o seu sa|do ass|r o perr|l|r.

lrp|ererle ura c|asse que perr|la leslar lodas as lurc|ora||dades alrs descr|las para as c|asses que cr|ar.

Exerc.21 - Cod|l|que ura c|asse, des|grada por A|uno cor os segu|rles alr|oulos: nome, numero e md|a.

E|aoore ura c|asse Turma cor as segu|rles caraclerisl|cas:
ura lurra corposla por vr|os a|uros, Cada lurra possu| ura |derl|l|caao ur|ca corposla por ura dig|lo (que
represerla o aro: 1,2,3,1 ou 5) e ura |elra (A,8,C ou 0). Cada lurra s poder ler ro rx|ro 30 A|uros.

Faa ur prograra Esco|a que lesle as c|asses e|aooradas. 0 prograra deve cr|ar duas lurras: 1A e 18, er segu|da
cada lurra deve ser preercr|da cor a |rlorraao soore 10 A|uros, |rlroduz|dos pe|o ul|||zador. Aps a cr|aao e
preercr|rerlo das lurras, o prograra deve rea||zar as segu|rles acoes:
lrpr|r|r lodos os a|uros da lurra 1A cor a rd|a super|or a 15 va|ores.
lrpr|r|r lodos os a|uros cor o rore Joao er aroas as lurras.
0rderar os a|uros pe|o rurero de a|uro er cada ura das lurras.

Ateno: Para os rlodos |rp|ererlados, e|aoore ura so|uao, ra qua| seja prev|slo o aurerlo das lurras da
Esco|a.


10 - Algoritmos de Procura/Pesquisa
10.1 - Introduo
A procura de |rlorraao ura acl|v|dade quol|d|ara: procuraros rureros er ||slas le|elr|cas, pa|avras er
d|c|orr|os, elc.

Esludareros er segu|da do|s rlodos para procurar ur e|ererlo rura laoe|a:
A procura sequerc|a|.
A procura o|rr|a.

A procura de |rlorraao lrequerlererle execulada er laoe|as. Ao |orgo desle capilu|o varos ul|||zar ura laoe|a
preercr|da. varos para la| lazer uso de ura c|asse (Tabe|a) que possu| ur rlodo (preenche) que preercre ura
laoe|a, passada coro parrelro, cor va|ores |rle|ros gerados a|ealor|arerle erlre 0 e 100. 0 cd|go da c|asse
er segu|da apreserlado:


class Tabela {

public static void preenche(int tabela[]){

for (int i=0; i < tabela.length; i++)
tabela[i] = random.nextInt(100);

}

public static void imprime(int tabela[]){

System.out.println(" "+i+":"+ tabela[i]+"; ");
}
}
10.2 - Procura Sequencial
10.2.1 - Simples
ura lorra s|rp|es de procurar cors|sle er:
Corear ro |r|c|o da laoe|a.
Corparar sucess|varerle o e|ererlo procurado cor o e|ererlo da laoe|a.
Repel|r o processo al ercorlrar o e|ererlo ou al|rg|r o l|r da laoe|a.
Coro a laoe|a percorr|da sequerc|a|rerle, o a|gor|lro deror|rado por procura sequerc|a|.

No exerp|o segu|rle prelerde-se saoer qua| a pos|ao que o va|or Z5 (se ex|sl|r) ocupa ra laoe|a de rureros.


Pos|ao 0
Corpara-se Z5 cor 10 3ao d|lererles
lrcrererlo a pos|ao
Pos|ao 1
Corpara-se Z5 cor 20 3ao d|lererles
lrcrererlo a pos|ao
Pos|ao 2
Corpara-se Z5 cor Z5 3ao |gua|s
Parar a procura

0 va|or procurado acrado e ocupa a lerce|ra pos|ao da laoe|a.

0 prx|ro exerp|o ul|||za ur prograra que preercre ura laoe|a cor rureros gerados a|ealor|arerle (erlre 0 e
100) e perr|le, er segu|da, procurar rureros que lorar |rser|dos.

public class ProcuraSequencial{

public static int procura (int tab[], int valor) {
int i = 0;

while (i < tab.length && tab[i] != valor )
i++;

if ( i != tab.length)
return(i); // retorna indice;
else
return(-1);
}

public static void main(String[] args){

int tabela[] = new int[100];

Tabela.preenche(tabela);

System.out.println("Resultado:"+procura(tabela,67);
System.out.println("Resultado:"+procura(tabela,33));
}
}

10 20 Z5 9 1 3
0 1 2 1 3 5 lrd|ce

0 rlodo procura relorra o ird|ce do va|or ra laoe|a se ercorlrar o va|or, caso corlrr|o relorra -1. Nole-se que ro
c|c|o corresporderle a procura propr|arerle d|la,

while (i < tab.length && tab[ i ] != valor ) {

ler de se elecluar corl|ruarerle do|s lesles:
ver|l|car se o va|or desejado lo| ercorlrado e
ver|l|car se o l|r da laoe|a lo| al|rg|do.

Eroora a pr|re|ra ver|l|caao seja esserc|a| a segurda ser|a desrecessr|a se pudesse gararl|r que o va|or a
procurar se ercorlrava ra laoe|a.
10.2.2 - Com Sentinela
ura lcr|ca ul|||zada para presc|rd|r do segurdo lesle cors|sle er ul|||zar ur deror|rado va|or serl|re|a. ur va|or
serl|re|a ur va|or espec|a| que |rser|ros ra laoe|a para gararl|r que a procura ler sucesso. Nesle caso lrala-se de
|rser|r o va|or procurado a segu|r ao u|l|ro e|ererlo da laoe|a.

A ul|||zaao de ur va|or serl|re|a ex|ge a ex|slrc|a de ura pos|ao ad|c|ora| ra laoe|a para arrazerar o va|or
serl|re|a. A pr|re|ra operaao a elecluar, a|rda arles da procura, a |rserao do va|or serl|re|a ro l|ra| da laoe|a.
3e ro l|r da procura o va|or ercorlrado lor o serl|re|a, erlao o va|or procurado rao ex|sle ra laoe|a.

No exerp|o segu|rle procede-se a |rp|ererlaao da procura sequerc|a| cor serl|re|a, ul|||zardo ur prograra que
preercre ura laoe|a cor rureros gerados a|ealor|arerle (erlre 0 e 100) e perr|le, er segu|da, procurar rureros
que lorar |rser|dos.

public class ProcuraSequencialSentinela {

public static int procura(int tab[], int valor){
int i = 0;

tab[tab.length-1] = valor; //SENTINELA

while (tab[ i ] != valor )
i++;

if ( i != tab.length-1)
return(i);
else
return(-1);
}


int tab[] = new int[101];

Tabela.preenche(tabela);

System.out.println("Resultado:"+procura(tab,67));

System.out.println("Resultado:"+procura(tab,102);
}
}
10.3 - Procura Binria
A procura sequerc|a| ru|lo s|rp|es, ras pode ex|g|r a |rspecao de lodos os e|ererlos da laoe|a. lslo acorlece
serpre que o e|ererlo que eslaros a procurar rao se ercorlra ra laoe|a.

A procura o|rr|a ura a|lerral|va ra|s el|caz, ras ex|ge que os e|ererlos soore os qua|s a procura esl a ser
elecluada se ercorlrer orderados.

0 a|gor|lro o segu|rle:

1. Ercorlraros o re|o da laoe|a.
2. Cors|deraros u|l|ro o e|ererlo da 1 relade da laoe|a.
3. 3e o e|ererlo procurado reror do que o u|l|ro o e|ererlo da 1 relade da laoe|a, poderos gararl|r
que o procurado rao se ercorlra ra 2 relade da laoe|a.
1. Repel|ros erlao processo para a 1 relade da laoe|a.
5. 3e o e|ererlo procurado ra|or do que o u|l|ro o e|ererlo da 1 relade da laoe|a, poderos gararl|r que
o procurado rao se ercorlra ra 1 relade da laoe|a.
. Repel|ros erlao o processo para a 2 relade da laoe|a.
Z. 3e o e|ererlo ro re|o da laoe|a lor |gua| ao procurado a procura lerr|ra.
8. Nole-se que er cada passo a procura o|rr|a reduz o rurero de e|ererlos a cors|derar para relade

0 prx|ro exerp|o ul|||za ur prograra que | 100 rureros e perr|le, er segu|da, procurar os rureros que lorar
|rser|dos.

public class ProcuraBinaria {

public static int procuraBinaria(int tab[], int valor) {
boolean achou = false;

int alto = tab.length - 1;
int baixo = 0;
int meio = (alto + baixo )/2;

while (!achou && alto >= baixo )
{
if (valor == tab[meio ])
achou = true;
else if (valor < tab[meio ])
alto = meio - 1;
else
baixo = meio + 1;

meio = (alto + baixo )/2;
}

return((achou ) ? meio : -1);


}

int tabela[] = new int[100

tabela[i] = i;

System.out.println("Resultado:"+procuraBinaria (tabela,67));
}
}

Exemp|o (Pesqu|sa de um va|or |nex|stente na tabe|a}

F|gura 1Z. Pesqu|sa o|rr|a de ur va|or |rex|slerle ra laoe|a.

public static int procuraBinaria (int tab[], int valor)
{
boolean achou = false;
int alto = tab.length - 1;
1 3 3 5 7 8 9
2
baixo
(>x)
alto
baixo
meio
(>x)
1 |leraao
2 |leraao
alto baixo meio
(<x)
3 |leraao
alto
baixo
1 |leraao
v:
x:
5 7 8 9 1 3 3
3 3 5 7 8 9 1
1 3 3 5 7 8 9
Valor a Procurar
0 va|or 2 rao ex|sle ra laoe|a

int baixo = 0;
int meio = alto/2;

while (!achou && alto >= baixo ){
if (valor == tab[meio ])
achou = true;
else if (valor < tab[meio ])
alto = meio - 1;
else
baixo = meio + 1;

meio = (alto + baixo )/2;
}
return((achou ) ? meio : -1);

}

Exemp|o (Pesqu|sa de um va|or ex|stente na tabe|a}

F|gura 18. Pesqu|sa o|rr|a de ur va|or ex|slerle ra laoe|a
Exerc.1 - lrp|ererle o rlodo rx|ro que relorra o ra|or va|or dos e|ererlos da laoe|a x. ul|||ze o a|gor|lro de
procura sequerc|a|.

Exerc.2 - lrp|ererle o rlodo rir|ro que relorra o ird|ce do e|ererlo de reror va|or da laoe|a laoF. A ass|ralura
do rlodo

1 3 3 5 7 8 9
1
baixo alto meio
(>x)
alto
baixo
meio
(>x)
1 |leraao
2 |leraao
alto baixo meio
(<x)
3 |leraao
v:
x:
5 7 8 9 1 3 3
3 3 5 7 8 9 1
Valor a Procurar
0 va|or 1 ex|sle ra laoe|a

public static int minimo(float[ ] tabF).

Exerc.3 - lrp|ererle o rlodo procuraCar que relorra o ird|ce da pr|re|ra ocorrrc|a do caracler c1 ra laoe|a
laoCar. ul|||ze o rlodo de procura o|rr|a. A ass|ralura do rlodo :

public static int procuraCar(car[ ] tabCar, car c1)

Exerc.1 - Teros ura laoe|a cor as lerperaluras rd|as ao |orgo dos d|as de rs. 0uereros saoer para ur
delerr|rado rs:
1. 0ua| lo| a lerperalura ra|s oa|xa
2. Er que d|a ocorreu a lerperalura ra|s e|evada
3. 0ua| lo| a d|lerera erlre a lerperalura ra|s oa|xa e a lerperalura ra|s a|la.

Exerc.5 - lrp|ererle o rlodo procuraF|oal que procura ra laoe|a v, que ler coro cr|lr|o de parager o va|or de s,
se esla corler o e|ererlo x. Caso a procura seja rea||zada cor sucesso relorra o ird|ce do e|ererlo, serao relorra
-1. ass|ralura do rlodo

public static int procuraInteiro(int[] v, int x, int s)

Exerc. - ur s|slera de corlro|o de preseras ||gado ao s|slera de rarcaao de porlo, rarlr ura ||sla de lodos
os lraoa|radores que rur delerr|rado rorerlo se ercorlrar derlro da erpresa. E recessr|o |rp|ererlar ur
rlodo que dado o rore de ura pessoa, e|e ros va||de se esla pessoa se ercorlra derlro da erpresa ou rao.
ul|||ze a procura o|rr|a ra |rp|ererlaao desla lurao.

Nota: a ||sla lerr|rada cor a pa|avra ' '
A ass|ralura do rlodo :

public static boolean procuraPessoa(String[ ] v)


11 - Algoritmos de Ordenao
11.1 - Introduo
ur corjurlo de e|ererlos rorra|rerle orderado para lac|||lar a procura. 0rderaros as co|sas para lac|||lar a
procura e rao por serros ralura|rerle arrurados. lrag|re que ler|a de procurar o rurero de le|elore de ur ar|go
rura ||sla le|elr|ca que rao esl|vesse orderada a|laoel|carerle. 3er|a cal|co cerlarerle.

Er prograraao, a ul|||zaao de laoe|as orderadas perr|le escrever a|gor|lros de procura ra|s el|c|erles.

Nos a|gor|lros de orderaao que serao er segu|da |rlroduz|dos, varos supor que prelerderos orderar ura
sequrc|a de |rle|ros cor ur rx|ro de 100 e|ererlos.

Cor o oojecl|vo de separar a|guras operaoes que se repeler ao |orgo dos exerp|os de orderaao, varos
apreserlar de segu|da ura c|asse (Taoe|a) que perr|le rea||zar as segu|rles luroes, soore ura laoe|a:

Preercr|rerlo de ura laoe|a cor va|ores |rle|ros, rao orderados, gerados a|ealor|arerle.
Troca de e|ererlos de ura laoe|a.
lrpressao dos e|ererlos de ura laoe|a.


class Tabela {

//(1) preenche uma tabela

public static void preenche(int tabela[]) {
tabela[i] = random.nextInt(100);
}

//(2) troca as posies de dois elementos da tabela

public static void troca(int tabela[], int x, int y){
int tmp;
tmp = tabela[x];
tabela[x] = tabela[y];
tabela[y] = tmp;
}

//(3) Imprime a tabela

public static void imprime(int tabela[]) {
System.out.println(" "+i+": "+ tabela[i]+" ; ");
}
// O mtodo main vai variar para cada implementao
}

11.2 - BubbleSort
Esle a|gor|lro cors|sle er:
Percorrer os e|ererlos a orderar, corparardo e|ererlos adjacerles e lrocardo os pares de
e|ererlos que se ercorlrar lora de order.
Al que se lerra elecluado ura passager corp|ela er que rao raja rerrura lroca de pos|oes.

Nole que a laoe|a ercorlra-se orderada quardo se eleclua ura passager corp|ela er que rerrur par de
e|ererlos lrocou de pos|ao.

0e ur rodo gera| ura ur|ca passager pe|o corjurlo de e|ererlos rao ordera a laoe|a.

0 lerpo de execuao proporc|ora| a r2, orde r o rurero de e|ererlos a serer orderados.

Cors|dereros a segu|rle laoe|a, orde se ap||car o a|gor|lro 3uoo|e$orr:

vereros a evo|uao da pos|ao dos e|ererlos ao |orgo das passagers e da var|ve| lrocou que perr|le saoer se ao
|orgo da passager rouve lrocas de pos|ao.

Pr|re|ra passager
lrocou = la|se
1 8 1Z 3 11 2
1 8 1Z 3 11 2
1 8 3 1Z 11 2 (lrocou=lrue)
1 8 3 11 1Z 2 (lrocou=lrue)
1 8 3 11 2 1Z (lrocou=lrue)

3egurda passager
lrocou = la|se
1 8 3 11 2 1Z
1 3 8 11 2 1Z
1 3 8 2 11 1Z

Terce|ra passager
lrocou = la|se
3 1 8 2 11 1Z
3 1 2 8 11 1Z
3 1 2 8 11 1Z

0uarla passager
lrocou = la|se
3 1 2 8 11 1Z
1 8 1Z 3 11 2
0 1 2 1 3 5
lrd|ce

3 2 1 8 11 1Z
3 2 1 8 11 1Z
3 2 1 8 11 1Z

0u|rla passager
lrocou = la|se
2 3 1 8 11 1Z
2 3 1 8 11 1Z
2 3 1 8 11 1Z
2 3 1 8 11 1Z

3exla passager
lrocou = la|se
2 3 1 8 11 1Z
2 3 1 8 11 1Z
2 3 1 8 11 1Z
2 3 1 8 11 1Z
2 3 1 8 11 1Z
lrocou == la|se - Terr|ral

0 cd|go da |rp|ererlaao do a|gor|lros 8uoo|e3orl apreserlado er segu|da:

public class OrdenacaoBubbleSort {
public static void bubbleSort(int tabela[ ] ) {
boolean houveTroca;

do
{
houveTroca = false;
for (int j = 0; j < tabela.length-1; j++)
if (tabela[j] > tabela[j+1]){
Tabela.troca(tabela, j, j+1);
houveTroca = true;
}
}while (houveTroca);


Tabela.preenche(tabela); //preenche tabela
Tabela.imprime(tabela); //imprime tabela antes da ordenao

bubbleSort(tabela); //ordena tabela

Tabela.imprime(tabela); //imprime tabela depois de ordenada
}
}

11.3 - ShellSort
A orderaao $ne||$orr ura var|arle da orderaao 3uoo|e$orr e cors|sle er corparar e lrocar, rao e|ererlos
adjacerles, ras s|r e|ererlos separados por ur cerlo |rlerva|o.

Coro |rlerva|o |r|c|a| cors|dera-se relade do rurero de e|ererlos a orderar.
Aps ura orderaao corp|ela, do l|po 3uoo|e$orr, cor o |rlerva|o |r|c|a|, esse |rlerva|o d|v|d|do ao re|o e o
processo repele-se para o rovo |rlerva|o.

Esle processo repele-se al que o |rlerva|o seja 1 (corresporderle a ura orderaao por 3uoo|e$orr).

Nole que a orderaao 3re||3orl ra|s el|c|erle (ra|s rp|da) do que a orderaao 3uoo|e$orr porque as pr|re|ras
passagers cors|derar aperas ur suocorjurlo dos e|ererlos a orderar e as u|l|ras passagers j os ercorlrar
parc|a|rerle orderados.

Cors|dereros a laoe|a que lo| usada ro exerp|o do 3uoo|esorr:

vejaros a evo|uao da pos|ao dos e|ererlos ao |orgo das passagers, da var|ve| lrocou que perr|le saoer se ao
|orgo da passager rouve lrocas de pos|ao e da var|ve| |rlerva|o que del|re a d|slrc|a erlre e|ererlos
corparados.

Passager 1
lrlerva|o=3
lrocou=Fa|se
3 8 1Z 4 11 2 (lrocou=lrue)
3 8 1Z 1 11 2
3 8 2 1 11 17 (lrocou=lrue)

Passager 2
lrlerva|o=3
lrocou=Fa|se
3 8 2 4 11 1Z
3 8 2 1 11 1Z
3 8 2 1 11 17

Passager 3
lrlerva|o=1
lrocou=Fa|se
3 8 2 1 11 1Z
3 2 1 8 11 1Z
3 2 1 8 11 1Z

Passager 1
1 8 1Z 3 11 2
0 1 2 1 3 5 lrd|ce

lrlerva|o=1
lrocou=Fa|se
2 3 1 8 11 1Z
2 3 1 8 11 1Z
2 3 1 8 11 1Z
2 3 1 8 11 1Z

Passager 5
lrlerva|o=1
lrocou=Fa|se
2 3 1 8 11 1Z
2 3 1 8 11 1Z
2 3 1 8 11 1Z
2 3 1 8 11 1Z
2 3 1 8 11 1Z

0 cd|go da |rp|ererlaao do a|gor|lro $ne||$orr apreserlado er segu|da:

public class OrdenacaoShell {

public static void shell (int tabela[ ] ) {
boolean nenhumaTroca;
int intervalo;
intervalo = tabela.length / 2;

do
{
do
{
nenhumaTroca = true;

for (int j = 0; j < tabela.length-intervalo; j++)
if (tabela[j] > tabela[j+intervalo]) {
Tabela.troca(tabela, j, j+intervalo);
nenhumaTroca = false;
}

}while (!nenhumaTroca);

intervalo = intervalo / 2;

}while ( intervalo > 0);
}



shell(tabela); //ordena tabela


}
}

11.4 - Ordenao por seleco
A orderaao por se|ecao cors|sle er percorrer os e|ererlos a orderar e, er cada passager, co|ocar ur e|ererlo
ra sua pos|ao correcla:

o Na 1 passager co|oca-se o reror e|ererlo ra sua pos|ao correcla.
o Na 2 passager co|oca-se o segurdo reror.
o E ass|r sucess|varerle.

Cors|dereros rovarerle a laoe|a que lo| usada ro exerp|o do 3uoo|esorr:

vejaros a evo|uao da pos|ao dos e|ererlos ao |orgo das passagers:

Pr|me|ra passagem (4 8 17 3 11 2}
3 8 1Z 4 11 2
2 8 1Z 1 11 3

8egunda passagem (2 8 17 4 11 3}
2 8 1Z 1 11 3
2 4 1Z 8 11 3
2 3 1Z 8 11 4

Terce|ra passagem (2 3 17 8 11 4}
2 3 8 17 11 1
2 3 4 1Z 11 8

0uarta passagem (2 3 4 17 11 8}
2 3 4 11 17 8
2 3 4 8 1Z 11

0u|nta passagem (2 3 4 8 17 11}
2 3 4 8 11 17

0 cd|go da |rp|ererlaao do a|gor|lro apreserlado er segu|da:

public class OrdenacaoSeleccao {

public static void seleccao (int tabela[ ] ){
for (int j = 0; j < tabela.length-1; j++)
for (int k = j+1; k < tabela.length ; k++)
if (tabela[j] > tabela[k])
Tabela.troca(tabela, k, j);
}

1 8 1Z 3 11 2
0 1 2 1 3 5 lrd|ce



seleccao(tabela); //ordena tabela

}
}

11.5 - Algoritmo QuickSort
E ur a|gor|lro recurs|vo oaseado ra lcr|ca o|v|oe ano conquerl

o Esco|rer ur e|ererlo aro|lrr|o (x) da laoe|a (crarado p|vol)
o Passo de 0|v|sao
0|v|d|r os reslarles er do|s grupos (esquerdo e d|re|lo).
0 grupo esquerdo corposlo pe|os e|ererlos rerores ou |gua|s que o e|ererlo p|vol.
0 grupo d|re|lo corposlo pe|os e|ererlos ra|ores que o e|ererlo p|vol.
0 e|ererlo p|vol co|ocado erlre os do|s grupos.

o Passo Recurs|vo
0rderar os do|s grupos esquerdo e d|re|lo, usardo o resro rlodo recurs|varerle

Re|al|varerle ao passo da d|v|sao:

3eja a Taoe|a v cor r e|ererlos.
3eja x o e|ererlo p|vol corl|do ro re|o da laoe|a (x = v[r/2|).

Poder ser |rlroduz|do o segu|rle rel|rarerlo:

lr|c|a||zar | = 0 (ird|ce da 1 pos|ao da laoe|a).
lr|c|a||zar j = r-1 (ird|ce da u|l|ra pos|ao da laoe|a).
Erquarlo | j, lazer:
Erquarlo v[|| < x ( serpre | r-1), |rcrererlar |
Erquarlo v[j| > x ( serpre j 0), decrererlar j
3e | j, lrocar v[|| cor v[j|, |rcrererlar | e decrererlar j

0 grupo esquerdo (cor va|ores x) v[0|, ..., v[j|
(vaz|o se j<0)
0 grupo d|re|lo (cor va|ores x) v[||, ..., v[r-1|
(vaz|o se |>r-1)

0 lerpo de execuao proporc|ora| a

r |og r

orde n o rurero de e|ererlos a serer orderados.

A |de|a 'de ace|eraao por lrs do a|gor|lro Du|ck$orr que ra|s rp|do orderar duas sequrc|as de n/2
e|ererlos do que ura sequrc|a de n e|ererlos.


vereros er segu|da ur exerp|o do passo da d|v|sao.

F|gura 19. Passo da d|v|sao

0 cd|go da |rp|ererlaao do a|gor|lro apreserlado er segu|da:




quickSort(tabela, 0, tabela.length); //ordena tabela

}

public static void bubbleSort(int tabela[ ] )
{
int k;;
do
{
k = 1;

for (int j = 0; j < tabela.length-k; j++)
if (tabela[j] > tabela[j+1])
Tabela.troca(tabela, j, j+1);
}
k++;
3 1 2 5 4 6 9 8 7
8 9 2 5 4 6 1 3 7
v:
8 9 2 5 4 6 1 3 7
| j
x=4
3 9 2 5 4 6 1 8 7
|
j
3 1 2 5 4 6 9 8 7
|
j
3 1 2 4 5 6 9 8 7
| j
<
x x
(3.3)
(3.3)
(3.13.2)
| j
(3.3)
| j

(3.13.2)


}

while (k < tabela.length);
}
Exerc.1 - lrp|ererle ur rlodo que receoa coro parrelro ura laoe|a de |rle|ros e relorre a laoe|a orderada
usardo o a|gor|lro 8uoo|e 3orl

Exerc.2 - lrp|ererle ur rlodo que receoa coro parrelro ura laoe|a de |rle|ros e relorre ura oulra laoe|a
orderada. use o a|gor|lro 3e|ecl|or 3orl.

Exerc.3 - Faa ur rlodo que receoa coro parrelro ura laoe|a de oojeclos do l|po lurc|orr|o (rore e rurero
l|sca|) e relorre ura laoe|a orderada. use o a|gor|lro 3re|| 3orl

Exerc.1 - lrp|ererle ur prograra que dado ura laoe|a de caracleres a ordere o a|gor|lro 3e|ecl|or 3orl.

Exerc.5 - lrp|ererle ur prograra que:
1. receoa o reg|slo de aulorve|s (Varca e r. reg|slo)
2. guarde esles reg|slos rura laoe|a
3. 0rdere a laoe|a por rarca, segurdo o rlodo qu|c| 3orl.
1. Apreserle er segu|da o resu|lado ro ecrar.

Exerc. - ura |oja prelerde d|spor os seus arl|gos de veslur|o segurdo cores. Para |sso prec|sa de lazer ura
pequera a|leraao a ap||caao de suporle a geslao da |oja, de rodo a acrescerlar a lurc|ora||dade de ||slager de
arl|gos por order de cor, serdo a order de cores desejada (arare|o, |ararja, caslarro, oeje, verde, azu|, verre|ro,
c|rzerlo e prelo).
lrp|ererle o rlodo que perr|le reorderar a laoe|a de oojeclos Arl|govesluar|o segurdo a order de cores desejada

public class ArtigoVestuario {
public int cod;
public String artigo, cor;

}

12 - Anexo I Classe Le.java

import java.io.*;
import java.awt.*;
import java.awt.event.*;

/**
* Classe simples para ler dados de entrada (pela entrada padro ou
atravs de uma janela grfica.
* @verso 2 - 20 Jan 2002
* @autor: Paulo Marques (pmarques@dei.uc.pt)
*/

public class Le
{
private static final int BUF_SIZE = 1024;

// Inibe o constructor por defeito
private Le()
{
}

/**
* Le um inteiro da entrada padro.
* A entrada terminada com um return. Se a entrada no for vlida
mostrada a mensagem
* "!!! No um inteiro !!!" e o utilizador pode tentar de novo.
*
* @devolve o nmero lido
*/
public static int umInt()
{
while(true)
{
try
{
return Integer.valueOf(umaString().trim()).intValue();
}
catch(Exception e)
{
System.out.println("!!! No um inteiro !!!");
}
}
}

/**
* Le um double da entrada padro.
mostrada a mensagem
* "!!! No um double !!!" e o utilizador pode tentar de novo.
*

*/
public static double umDouble()
{
while(true)
{
try
{
return
Double.valueOf(umaString().trim()).doubleValue();
}
catch(Exception e)
{
System.out.println("!!! No um double !!!");
}
}
}

/**
* Le um float da entrada padro.
mostrada a mensagem
* "!!! No um float !!!" e o utilizador pode tentar de novo.
*
*/
public static float umFloat()
{
while(true)
{
try
{
return Float.valueOf(umaString().trim()).floatValue();
}
catch(Exception e)
{
System.out.println("!!! No um float !!!");
}
}
}

/**
* Le uma String da entrada padro.
* A entrada terminada com um return.
*
* @devolve a String lida
*/
public static String umaString()
{
String s = "";

try
{
BufferedReader in = new BufferedReader(new
InputStreamReader(System.in), 1);

s = in.readLine();
}
catch (IOException e)
{
System.out.println("Error reading from the input stream.");
}

return s;
}

/**
* Le um caracter da entrada padro.
* A entrada terminada com um return.
*
* @devolve o caracter lido
*/
public static char umChar()
{
char c=' ';

try
{
BufferedReader in = new BufferedReader(new
InputStreamReader(System.in), 1);
c = (char)in.read();
}
catch (IOException e)
{
System.out.println("Error reading from the input stream.");
}

return c;
}

/**
* Le um inteiro usando uma janela grfica.
* A entrada terminada quando o boto Ok seleccionado
*
*/
public static int grafUmInt(String msg)
{
ReadIntFrame intFrame = new ReadIntFrame(msg);
return intFrame.getValue();
}

/**
* Le um inteiro usando uma janela grfica.
* A entrada terminada quando o boto Ok seleccionado
*
*/
public static double grafUmDouble(String msg)
{
ReadDoubleFrame doubleFrame = new ReadDoubleFrame(msg);
return doubleFrame.getValue();

}
}

/**
* Classe auxiliar que l inteiros numa janela
* @verso 1.0 - 13 Jan 1999
* @autor Paulo Marques (pmarques@dei.uc.pt)
*/
class ReadIntFrame
implements ActionListener
{
/**
* Construtor.
* @parmetro msg - a mensagem a aparecer como ttulo.
*/
public ReadIntFrame(String msg)
{
this.msg = new String(msg);
valid = false;

window = new Frame();
window.setTitle(msg);
window.setLayout(new FlowLayout());

valueArea = new TextField("", 15);
Button done = new Button(" Ok ");
done.addActionListener(this);

window.add(valueArea);
window.add(done);
window.setSize(320, 100);
window.setBackground(Color.gray);
window.setLocation(100, 100);
window.setResizable(false);
window.show();
}

/**
* Metodo chamado quando o Ok seleccionado.
*/
public synchronized void actionPerformed(ActionEvent e)
{
try
{
value =
Integer.valueOf(valueArea.getText().trim()).intValue();
valid = true;

window.dispose();
notify();
}
catch (Exception exc)
{
window.setTitle("!!! No um inteiro !!! --- " +
msg);
}

}

/**
* Devolve o valor fornecido pelo utilizador.
*/
public synchronized int getValue()
{
try
{
if (!valid)
wait();
}
catch (Exception e)
{
}

return value;
}

private boolean valid;
private int value;
private String msg;
private Frame window;
private TextField valueArea;
}

/**
* Classe auxiliar que l doubles numa janela.
* @version 1.0 - 13 Jan 1999
* @author Paulo Marques (pmarques@dei.uc.pt)
*/
class ReadDoubleFrame
implements ActionListener
{
/**
* Constructor.
* @parmetro msg - a mensagem a aparecer como ttulo.
*/
public ReadDoubleFrame(String msg)
{
this.msg = new String(msg);
valid = false;

window = new Frame();
window.setTitle(msg);
window.setLayout(new FlowLayout());

valueArea = new TextField("", 15);
Button done = new Button(" Ok ");
done.addActionListener(this);

window.add(valueArea);
window.add(done);
window.setSize(320, 100);
window.setBackground(Color.gray);
window.setLocation(100, 100);

window.setResizable(false);
window.show();
}

/**
* Metodo chamado quando o Ok seleccionado.
*/
public synchronized void actionPerformed(ActionEvent e)
{
try
{
value =
Double.valueOf(valueArea.getText().trim()).doubleValue();
valid = true;

window.dispose();
notify();
}
catch (Exception exc)
{
window.setTitle("!!! No um double !!! --- " + msg);
}
}

/**
* Devolve o valor fornecido pelo utilizador.
*/
public synchronized double getValue()
{
try
{
if (!valid)
wait();
}
catch (Exception e)
{
}

return value;
}

private boolean valid;
private double value;
private String msg;
private Frame window;
private TextField valueArea;

13 - Anexo II Glossrio

Nota:

0s s|gr|l|cados apreserlados para as pa|avras co|ocadas resle g|ossr|o sao aperas os que se cors|derarar
recessr|os ro ro|lo da cade|ra de lrlroduao a Prograraao.
As pa|avras ercorlrar-se descr|las por order a|laol|ca.

Abordagem: corjurlo de acoes loradas para del|r|r a lorra de al|rg|r a so|uao de ur delerr|rado proo|era.

A|gor|tmo: Corjurlo de |rslruoes que reso|ver ur proo|era.

Amb|gu|dade: Expressao cujo s|gr|l|cado rao pode ser delerr|rado a parl|r do corlexlo er que esl |rser|da (ou
seja, que a parl|r de delerr|rado porlo olerece ra|s do que ur car|rro a segu|r, poderdo |evar a resu|lados
d|lererles).

ottom-Up: Corslruao de ura so|uao parl|rdo dos e|ererlos ra|s pequeros.

6d|go fonte: Cd|go escr|lo pe|o prograrador.

6d|go executve|: Resu|lado da corp||aao do cd|go lorle.

6onceber: Cr|ar.

6omp||ador: Prograra que saoe |rlerprelar o cd|go escr|lo rura delerr|rada ||rguager de prograraao. Receoe
cd|go lorle coro e|ererlo de erlrada e produz cd|go execulve|.

6omp||ao: Processo de gerar cd|go execulve| a parl|r de cd|go lorle recorrerdo a ur corp||ador.

0|v|de-And-6onquer: Velodo|og|a ou lorra de reso|uao de proo|eras que ervo|ve parl|r ur proo|era er
suoproo|eras ra|s pequeros, cujas so|uoes coro|radas represerlar a so|uao do proo|era or|g|ra|.

Estado: 3|luaao er que se ercorlra ura var|ve| er lerros de va|or aclua|. 0 eslado de ur oojeclo o corjurlo
de va|ores dos seus alr|oulos. No que d|z respe|lo a ur proo|era, ler ur eslado |r|c|a| que corresporde ao va|or do
resu|lado que a|rda rao ex|sle, e ur eslado l|ra| que o va|or de resu|lado aps passar pe|a lase de lrarslorraao.

hardware: Corporerles lis|cos de ur corpulador (d|scos, ror|lores, co|uras, elc.)

|mp|ementao: Cd|go produz|do por ur prograrador e que represerla ura so|uao possive| para ur delerr|rado
proo|era.

L|nguagem de Programao: L|rguager arl|l|c|a| ul|||zada para |evar a caoo a |rp|ererlaao de prograras de
corpulador.

Hqu|na V|rtua|: Na prl|ca ur corpulador s|ru|ado derlro do prpr|o corpulador alravs de sollWare prpr|o
cr|ado para esse ele|lo. Corporla-se coro se losse ur corpulador |rdeperderle. A rqu|ra v|rlua| Java aclua
coro ur aro|erle de execuao de prograras Java aulo-corl|do.

Notao: Vecar|sro que serve para del|r|r o lorralo de delerr|rado l|po de |rlorraao. Por exerp|o: a 8NF serve
para del|r|r grarl|cas para var|ados l|pos de ||rguagers, la| coro o XVL serve para del|r|r lorralo de dados, os
siroo|os rus|ca|s server para del|r|r rus|cas ras parl|luras, elc, elc.


0perandos: e|ererlos ervo|v|dos rura delerr|rada operaao.

0uot|d|ano: a|go re|al|vo ao d|a-a-d|a.

Pseudocd|go: lorra s|rp||l|cada de descrever ur a|gor|lro recorrerdo a pa|avras crave sere|rarles as da
||rguager ralura|, ras que sao eslruluradas a sere|rara de ur prograra de corpulador.

8|stema de Numerao: Esquera de represerlaao de ragr|ludes ou quarl|dades alravs de ur grupo de dig|los.
8as|carerle, ura rolaao de represerlaao de rureros.

8|stema 0perat|vo: Prograra de corpulador de grardes d|rersoes e corp|ex|dade que resporsve| rao s por
escorder os dela|res do rardWare aos ul|||zadores e prograradores, coro laror ler de ger|r a rerr|a
d|sporive| para cada ap||caao(prograra er execuao, laror crarado de processo) e ger|r a execuao dessas
resras ap||caoes, ger|r o s|slera de corur|caao cor oulras rqu|ras, elc.

8oftware: Prograra de corpulador. Represerla a parle |g|ca, ao corlrr|o do rardWare que represerla a parle
lis|ca de ur corpulador.

8ubprograma: Taror crarados de rol|ras (ou rlodos ro caso de ||rguagers or|erladas a oojeclos coro o
caso do Java), sao pequeros prograras que poder ser crarados e crarar oulros prograras para que er corjurlo
co|aoorer ra oolerao de ura so|uao para delerr|rado proo|era.

Top-0own: Cosrlruao de ura so|uao er que a parl|r do proo|era ra|or se lerla |r descerdo de rive| e
espec|l|cardo a cada passo os rive|s |rlerrd|os, ou seja, os proo|eras ra|s pequeros.


14 - Anexo III - Bibliografia

Furdarerlos de Prograraao er Java2 - Arlr|o Verdes, Var|a Jos Varce||ro, FCA
Java 3ollWare 3o|ul|ors, Jorr LeW|s, Add|sor wes|ey
Prograraao er Java2 - Pedro Coe|ro, FCA
lrlroduao a Prograraao ul|||zardo Pasca|, Pavao Varl|rs, Vc0raW-l|||
Tre Java Prograrr|rg Larguage - Ker Arro|d, Jares 0os||rg . Add|sor wes|ey
Acelalos de lP dos aros |ecl|vos 2000/2001 al 2003/2001

Sebenta

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Sebenta

Diunggah oleh

Hak Cipta:

Format Tersedia

3eoerla da 0|sc|p||ra de lrlroduao a Prograraao

@ Esco|a 3uper|or de Tecro|og|a de 3eluoa| 2001-2005 Pg|ra 1

Anda mungkin juga menyukai