Sebenta Introdução À Programação

#
$
%"
$&
$
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' !
#'# ( )
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' !
#' *
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' !
#' '# *
$
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' +
#' '
,
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' .
#' '/ $
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #
#'/
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #
#'/'# *
0
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #
#'/' $
$
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ##
#' 1
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #/
#' '#
1
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #/
#'! - 1
2 ) ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #
#'!'# $
2 ) ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #
#'+ 3 4
"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #!
5
6
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #+
'# ( )
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #+
'
3 ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #+
7
" ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #+
'/
8
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #9
8
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #9
'
"
8
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #9
'!
0
7
"
:
3 ; '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #.
'+ <
% <5 ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #.
'9
"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'. 3 4
"
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
/
$
%"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' +
/'#
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' +
/'
0
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' +
/'/
) *
)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 9
/'
4
=
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 9
/'! = ") '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' .
/'+
6
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' .
/'9 $
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' >
/'.
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' /
/'.'#
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' /#
/'.' *
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' /
/'.'/ $
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' //
/'.' 1 ?
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' /
/'.'! @
1?
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' /
/'.'+ @
*
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' /
/'>
A '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' /!
/'>'# $
" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' /+
/'>'
0
B
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' /+
/'# C
2 ) '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' /9
/'## 3 4
"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' /.
D
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'#
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'#'# @
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'#' @
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #
'
3
A '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #
' '# $ ) A
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
"
4.3 - $
Math Random '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' /
'/'# %
$
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'/' $
Math''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'/'/ $
Random'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'
4
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' +
' '#
4
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' +
' '
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 9
' '/ $
Le ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 9
' ' $
String''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' >
'! 3 4
"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' !
!
A
$
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' !
!'#
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' !
!'#'#
E if''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' !
!'#'
) E if-else''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' !
!'#'/
(
E switch - case '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' !>
!' *
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' +
!' '#
*
while ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' +/
!' '
*
do-while ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' +!
!' '/
*
for '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' +9
!'/ 3 4
"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 9#
+
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 9>
+'#
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' .
+' 5 A ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' .#
+'/
8
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' .
+'
8
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' .
+'! =
= ") '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' .+
+'+ 3 4
"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ..
9
$
@ F
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' .>
9'# @ F
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' .>
9' $
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' >
9'/ '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' >
9' (,
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' >
9'!
$
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' >#
9'+ * 0
@ F
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' >#
9'9 (,
8
: )
; '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' >/
9'. $
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' >!
9'>
0
< ) $
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' >9
9'# = ")
$
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' >.
9'## = ")
8
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' >>
9'# @ @
- * 0
this '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' >>
9'#/ 3 4
"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #
.
*
)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # /
.'#
0 A '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # /
.'
3 4
"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # !
>
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # +
>'# ( )
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # +
>'
C
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # .
>' '# = ")
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # .
>' '
6
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # .
>' '/ 3
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ##
>'/
8
,
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ##
>' #' G
(
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ##/
>'!
@ F
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ##
>'+ $
Vector''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #
"
>'+'#
>'+' >'9 3 4
#
# '#
# '
# ' '#
# ' ' $
# '/
# '
3 4
##
##'#
##' %
##'/ H
##' @
##'! ##'+ 3 4
#
- 3
#/
- 3
#
- 3
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #
Vector'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #
"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #
B D
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # !
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # !
D
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # !
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # !
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # 9
% " '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # .
"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #/
@
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #/
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #/
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #//
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #/!
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #/9
I J
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #/.
"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' #
G$
1 'F ) ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # #
G7
" '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # 9
%
0 ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' # >
,
"
EF
$
0
-
K
" D ,
F " 0
'
0
"
" D
K
3
)
4)
K
K
)
B
D
0
# ,
6
0 )
'
,
0 &
K
0
F"
/B
)
H
H
)
'
K
K)
'
"
1-
Conceitos Bsicos de Cincias da Computao
1.1 - Motivao
<
)
'
@ 0
F
A
,
A
)
'-
'
6
, L
04
D &
'
1.2 - Resoluo de Problemas

@
KD
0
K
K,
,
) 6 K
6
A
K,
)
&
K
0
0
"
'
'I
"
"
0
0 K
K
K
A
"
H"
0
,
'
) 'C
) N
'
0
0 6
F K D
,
=
D
KD
H D
D
KD
,D
'
D
K
8
'
3
A
''$
(
0
H
? K
0 D
"
K
'
'
0
"
O
E
E
:-
#'
#'# %
#' #'/ 2
#' $
,
)
H
N
0
'
'# -D
"
' $
E
-0
, ?
)
)
-D
P
)
'
1.2.1 - Resoluo de Problemas num Computador

I
D
0
F
*
7
@
@
0
0
A
A
0
6
,
?
)"
A
A
*
C
:
:
) ) 0
;
;
0
3
")
:D D
F
"
D
K 0 6
),
H
K
O;
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.
E
K
"
E$
E"
K
"
E
1&
1&
1&
-
Q
Q
Q
Q
R
#R
R
3 R S) -
S
S
S
Q
T S-
#T S-
E C
F )
U V ! G !W
K 0
0
XV ! G# W ;
U V! G W K V! U
&
"
+W '
D
) )
,D
'
E
1&
1&
Q
Q
,
Q Q
S K +
U!
R K
U !
R K#
R K !
5 Q
Q Q
5 Q
)
3
Q Q
/E $
E
@ <
@ <
,D
T<
<
<
T#
D
R
<
R#
R
<
,D
T<
R<
<
T#
X#
)
E
R
R
1 )
D
:)
R
R
XR ;
T)
T#
1 )
"
5 Q
D
R
) L$ F
R
)
) 6 M
5 Q
1.2.2 - Tcnicas de Descrio de Algoritmos

@
3
D
C
,
0
)
")
K
D
H F D
,
D
D
:
;' @
' @
4
KD
3
'@
0 3
)
'3
) K
'
0 3
K
D &
6
),
:) 0
3 ;'
#' *
"0
'
B5
1 H
0 3
"
'
0 3
6
3
0 3
0
'
4
K
04
'@
0 3
'( K
) 6
6 '
<
#X)
<
)
#U)
)
)
#,
/'
0 3
'
"
>
1
1
)
)
)
) L
#
#X)
) )
)
# L,
#U)
) )
L,
) L)
5 Q
5 Q
5
5
'
?
K
'
0
D
'
3
K
)
@
, D
F K
0
0
)
'
1.2.3 - Criao de Algoritmos

-
, 0
3
) )
K
'-
) '
,
H
H
A
K)
"
M :
;K
H '<
3 , )
'
" K
D
6
,
,
' I
,
K
F K
'
'
D
"
D
KD
D
MK
D
F
0 6
K
F K )
D
F
'<
)
,
0
H
6
?
D
,
'
H
H K
0
1.3 - Do Algoritmo ao Programa

1.3.1 - Representao Digital da Informao
@
"
6
,
0
K
')
'@
"
KD
#'
E
!
"#
$#
%#
"
/
!
+
9
'''
$
) 0
<
#
'''
R.
#
#
##
#
#
##
'''
#
# #
##
###
'''
' I
<
K
K
6 K
R
#
/
'
"
, ,
K) F
111 = 1*22 + 1*21 + 1*20 = 7

101 = 1*22 + 0*21 + 1*20 = 5
" K
0 6
) A
E
7 / 2
= 3 e o resto da diviso 1
3 / 2 = 1 e o resto da diviso 1
1 / 2 = 0 e o resto da diviso 1
@
$
'
Z
,
&
1
1
1
1
1
3
3
'
bit
byte
Kilobyte
Megabyte
Gigabyte
0
';' = F
N/A
8 bit
1024 byte
1024 Kilobyte
1024 Megabyte
,
E
)* #
)+
b
B
KB
MB
GB
" K
H 3
'
1.3.2 - Componentes de um Computador

C
04
04
;K
;K
'K
'
"
##
C
$
:$ C ;
0,
0,
4
?
"
!' $
'
,
$ C ,
:$ C G
) 6'
;' - 0
"
;
:
: 3
@ $ C ,
;'
E
B1 ?
"
K
,
)
C
?3
:
;
D
"
5
+' $
@
"
$ C'
0
,
0
D
?
D
,
,
$
I
?
)
6
) )
G
:) 0
) N
H
?
? K
* -( :!
4
E
) " N
3 ;N
"
;' [
"
"
) N
, 3
:(% G #
;K
Z
\%
D
;K
6
:7 % G #
E$
:\ % G
(%
;
D
4 H
#\ % :# \
Z ;K
,
z
0
512
)
)
)
K
B 4 E
N
'
K,
?
6
G
6
?
x
1024
...
E
4 E
0
,
3
;E
6,
,
) K
...
:* -(;
K 3
3
' $,
12
256
...
?
K
:
5
,
: D
#K K ''' !+K
$ C
Z ;K D
"0
a
2
9' *
,
#(% :# (
"0
* -(
" E
) "
"
"D
4
0
"0
K $ *
'
1.4 - Linguagens de Programao

D
0 K,
'
6
]" )
4)
E
4
#.E
,
A
F 0
'@
' -
# K
'
4
) 6
H
# '
D &
?3
*( E
6
6
?
0"
]"
"
"D
H
'
D
E $K
K1
K $TT 2 ) '
1.4.1 - Traduo de Linguagens de Programao

C
,0
"D
K
'@
?
4) ;
-
D
D
3
D
") :
'
?
0 6
"D
,) 0
D
'<
"
K
0
0
?
6
:
;'
?
D
3
H ,0
K
"
'"
'
"
#/
0
8
;' <
'
F K
4
?
F
D
'
,
F
1.5 - A Linguagem Java

2 -=- ,
) )
D
'
'
#
D
1.5.1 - Compilar um Programa em Java

C
) )
3
F
2 )
6
0
,
,
0
2 ) '
3
) A
( @ K ;'
'@
/ (
F 3
D
/ ( KD
,
("D
-0
6
3
")
)
:^
3
_ KC
@ L?
0
K,
0
0
'
L?
, '
3
"D
,0
?
D
"
2 =( :%
MK
'
K
&
;'
2 )
2 ) ;
.'
3
D
3
3K
2 ) '
("D
:2 =(K
3K 1
MK D
2 )
2 )
?
?
2 )
")
H
D
<
%Z
'
$?
D
?
'<
'
K
H
2 ) '
"D
D
0
D
K D
2 )
'
"
"
'
"
2 ) ,
( :2
\;
"
'
'
1.6 - Exerccios Prticos

)
' #E = 0
' E
# # '
)
' :<
' /E
' E
' !E $
' +E
' 9E
' .E
' >E
K5
\ ) K
'
3
"
"
D
,
6
K
ET
D
'
K
#
)
3
K
$
E `$ R :`5 / ;S!B>N `\ R `$T 9/'#!;
F
0 &
3
'
),
'- ?
'
,
'
'
"
#!
2-
Formalizao
2.1 - Motivao
I
0
,0
'
K,
3
K
0
0 6
A
:
'
3
K
A
3
;
0
3
' -
8
,
K
0
'-
D
6
:0
;'
2.2 - Sintaxe
-
3
)
,
"
,
''-
0
"
)"
'-
3
, ,
),
'
Gramtica
$
'
)
L) % *
0
L
M ,
0
L) % * M
L@ 2
H
M ,
&
'
4
)
L@ M
M
M'
L2
) 6K
)
H
M'
M' @
L
5
<
=
<
<
<
@
5
>'
2
0
'
0
E
L)
% * M
"
#+
-0
"
'<
3
) 0
K 0
D
0 6
'
2.3 - Semntica
-
:)
'
3
'C
0
0
'
Ambiguidade Semntica
-
"
4
4
,D
' C
0
,
4)
"
# '
4)
;'
<
<
"
K
6
3
A
"
K
'
L'
:&
K
,
D
)
KD
D
'C
'
2.4 - Erros Sintcticos e Erros Semnticos

@
E
-
A
6
"
'
K
),
'
G @
1
)
D &
'
"
#9
04
3E
6
:3 T#;
) 6
'
:3 #;
2.5 - Definio de Gramticas (Sintaxes)

$
F" )
"
3 ;D
"
),
'
<
"
'
0
"
"
)* #
)* #
D
: 3'
"
M;
KD
)
)"
4
'
: 3'
)
;
4
-
'
)"
F
)
)* #
"
)"
"
E
% <5K
"
'
2.6 - Notao BNF

-
% <5 0
%
0
:% <5
L
"
"
M;'
D
'
<
"
% <5K
)* #
)* #
@
@
2
U 4
4 :
EER
4
4
#E
LUM LXM
X
a a;
0 L,
4)
M
D
U 4
4
G
EER
X EER
&
<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)
"
D &
% <5K
"
"
#'
<nmero binrio>
::= <digito binrio> |

<digito binrio><nmero binrio>
<digito binrio > ::= 0 | 1
- #b
"
"
"
"
- b
4
4
4
3
"
"
#'
"
E
#
E
/E
"
% <5
<inteiro>::= <nmero > | + <nmero > | - <nmero >

<nmero> ::= <digito > | <digito > <nmero >
<digito> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
- #b
0
K
G'
- b
0
4
4
- /b
0
D ,
4 '
4
4
4
3
'
E
E TK K K #K K /K K !K +K 9K .K >
E
K
E
H
"
<Tempo>
::=
<Horas>
::=
<Minutos> ::=
<Segundos>::=
<Horas>
0 | 1
00 | 01
00 | 01
!E $
% <5
'
:
|
|
|
<Minutos>
2 | 3 |
02 | 03 |
02 | 03 |
: <Segundos>
4 | 5 | 23
04 | 05 | 59
04 | 05 | 59
"
% <5'
5 )6 7 # 5 6
5 6 7 #5' 64 5 64#
"
#>
5' 6 7
4
4
4
E
E K
E K%
;-0
#b
b
b
b
b
*
*
*
*
*
U% X
U% X
U% X
U% X
D
4)
;-0
#b *
<
#b
'
O
U% X
;-0
#b *
b*
/b *
U% X
U$X
D
4)
#b K b /b
2.7 - Diagramas Sintcticos

C
)
"
"
% <5
'
)
)* #
D
)* #
8
)* #
4
)* #
<
D
4
:&
:&
M;'
L M;
"
#E
&
Diagrama sintctico para a Frase (F):

F
SN
SV
5;6
5 ) 6 5 )0 6
Diagrama sintctico para o sintagma nominal (SN):

SN
Det
5) 6
5!
' =
- (
)0
-
SN
0
E
D &
65 6
Diagrama sintctico para o sintagma verbal (SV):

SV
<
5 )0 6
50 65) 6
"
"
"
"
#'
!*
!*
!*
"
3
4
D
:
,
;'
4)
K ?
"
"
/E
"
'
#
/
<
E $
3
. / 001
. / 001
. / 001
!
+
9
.
>
"
% <5
. /
. / 2 . / 2

3
' #E
"
<Comp>::=
<Dum+>::=
<Dum> ::=
<Bum> ::=
;
;
0D
KF 0
% <5E
<Bum> <Dum+> <Bum> | <Dum+> <Bum>

<Dum> <Dum+> | <Dum>
B | C | D
A | E
"
KD
'
0
"
1)EFA
2)AA
3)ACC
4)ABCDE
5)BBAAAAE
6)EDDCCE
"
7)BBCA
;-
"
' E
D )
"
% <5E
<S>::=<A> a
<A>::=a 
::=<A> a | b
0D
4
U X'
KD
0
;
KF
"
&
"
"
1)aabaa
2)abc
3)abaa
4)aaaabaaaa
5)aaaba
;-
"
' /E
D )
"
% <5E
<Blop>::= c <Gulp> s
<Gulp>::= a | b <Gulp> | x <Bat> y
<Bat> ::= x | y <Bat>
;
;
0D
KF 0
"
KD
'
1)cas
2)cGulps
3)bay
4)cxxy
5)cxxayys
;-
"
' E
"
D )
K
% <5
"
'
3
' !E
"
4
3
' +E
)
0
'C
3
K
?)
' 9E
E
)
"
% <5
0
,
% <5
"
6
'
F
"
'
"
4
H )
KD
D
0
D
E K K K K '
% <5E
"
<Princ>::= a <Meio> a
<Meio> ::= b <Fim> b
<Fim> ::= c | c <Fim>
;
;
0D
)
' .E
"
"
)
0
E
:#; 0
: ; 0
:/;
'
' >E
K
K
6
D )
"
'
"
% <5
'
"
3
3
c D
E K
0
"
% <5
D
,
K D
L M
K
0
0D
;-
LTM
" K
D )
"
'# E
L L LM ,
"
T '
K
'
"
4
'
K '! /'
T/
'
% <5E
<confuso> | <confuso> ; else <Expresso> ;

if ( <Condio> ) <Expresso> ;
k == m | k != m | k <= m | k>=m | k<m | k>m
<Id> + <Id>|<Id> - <Id> | <Id> * <Id> | <Id> / <Id>
e | f | g | h
4
&
G ' K '
% <5E
0D
 ) 2 ( <C> ) 3 ( <C> ) | 1 ( ) 2 <C>

| k<>m | k<=m | k>=m
+ <D> | <D> - <D> | <D> * <D>
f | g | h
<Seleco> ::=
<confuso> ::=
<Condio> ::=
<Expresso>::=
<Id>
::=
;
'
% <5
"
1 (
k=m
<D>
e |
'
" K
3
0
E
<s> <A> <s> i
L-M L% M
KL M,
3 '
<A>::=
::=
<C>::=
<D>::=
;
;-
' ##E
"
'C
'
3
D
,
' !N
40
'
D
D
'C
)
D
'# E
KD
"
"
'
"
D )
'
"
' #/E
"
% <5E
<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
0D
4
&
"
"
'
;3 '# E
"
D )
'
% <5K
"
, comp'E
<ins> ::= <ins1> | <ins1> ; <ins>

<comp> ::= begin <ins> end
<ins1> ::= <comp> | a | b | c
;
0D
4
;*
)
6
;= 0D
)
"
K
"
'
'
K
"
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
3
4
' #!E
: 3 'E #K
)
#K !!!!!K
"
'; ' *
6
)
"
K
% <5'
"
3-
Conceitos Bsicos de Programao
3.1 - Estrutura de um Programa

@
&
E
!
> G
)
?
6
0
) ) N
+
> G
D
) 0
N
Comentrios so teis para os humanos, mas so ignorados pelo computador.
'-
&
2 ) :
"
"
6
0
K 4
'
3.2 - Identificadores
@
4
;' 3
D
2 ) K
:0
K ) ")
'
K
:
<
:Q ;
K 4
:d ;
0 ;
K 2 )
A
a
B
b
public static void
PUBLIC STATIC VOID
)
6
A
)
$
D
,
:)
K,
'
E
H")
,
: 3E - ;
: 3 E main() )
;
K
) )
;
K
)
D
) 0D
H
2 ) ,
@
I
F E
: 3E
, )
;
)
'
;
<identificador>
<letra>
<caracter>
<string>
/ (
::=
::=
::=
::=
<letra> | <caracter><string>
a | b | ....| z | A | B | ... | Z |
<letra> | _ | $
<caracter ou digito> |
<caracter ou digito><string>
<caracter ou digito> ::= <caracter> | <digito>
<digito>
::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
"
1_x
X1
M&M
int
$dlar
limite Inf
)"
2 )
invlido,
vlido
invlido,
invlido,
invlido,
invlido,
comea por dgito

carcter & ilegal
uma palavra reservada
carcter acentuado no nome
espao em branco
3.3 - Palavras Reservadas

@
: 3E
0
6
E 3
K
0
&
;' <
(
2
?
,
' -
)
3 '-
'
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
##' 1
2 )
3.4 - Smbolos e Valores

@
@
0
2 )
E TK K S R
E eK fK :K ; N
)
)
K
)* #
)
4
E
&
0 '
@
3 4
'
3
<
<
@
$
E
E +! / #
E /'# #!>K '
E g cK g-c gh c
E L%
!'..0
PM
"
3.5 - Variveis
C
= ") ,
'-
) ")
'
@ )
) ")
)
'$
)
) ")
3
) 0
) ") '
'<
K
int num = 145;

Num -> EM 1002
# ' *
) ")
) )
num = 210;
Clula de
Memria
1002
K
6
Clula de
Memria
1002
"0
) ")
3.6 - Declarao e Inicializao

) ")
:
)4
"
;
:N;'
)
,
0 6
2 )
K
;' D D
0
,
'
int total;
int count, temp, result;
9
5
#/'
) ")
(
<declarao vars> ::= <modificadores> <tipo> <variaveis>; |

<tipo> <variaveis> ;
<variaveis>
::= <identificador> |
<identificador>, <variaveis>
-+
) ")
: 3 E total = 0;).
"
<
( '
<inicializao vars> ::= <identificador> = <expresso>;
) ")
'
int sum = 0;
int base = 32, max = 149;
;
<declarao com inicializao vars> ::= <modificadores> <tipo>

<identificador> = <expresso>;
) ")
' - ) ")
6 ;'
0
0
: ?
)
)
) ") , 0
)
'<
K,
:)
?
) ") 0
3 ;'
"
)
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
C
? K
)
) 6' -
K )
)
?
2 ) K ,
'
K,
K
6
) ") K
3
,
0
?
'- " K
'
)
final
final int MIN_TEMP = -10;
"
>
final <tipo> <nome_var> ou

static final <tipo> <nome_var>
final double PREVISAO_VENDAS = 350000.0;

static final double PREVISAO_VENDAS = 350000.0;
'
<declarao constantes> ::= <constante> |

<constante>; <declarao constantes>
<constante>
::= final <modificadores> <tipo> <variaveis>
) ")
&
&
0
)
)
)
) ")
3.8 - Tipos de Dados

2 )
4)
!
'E
E
( E
)
F
'
Z K
:)
;'
int x = 10;
// int um tipo primitivo
String str= new String (Ola);
// String uma referncia
"
# ' *
"0
,
0
4)
) ")
>
'
)
) '
2 )
E byte, short, int, long

*
E float, double
E char
1?
E boolean
I
C
C
3.8.1 - Inteiros
Tipo
Inteiro
Tamanho
byte
1 byte
(8 bits)
short
Menor Valor
Maior Valor
128
127
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
#!'
0
) ")
byte:
short:
int:
long:
2 ) '<
K
)
) ")
) ")
40
-22 500
1 500 000
4 000 000 000
"
/#
Operao
Smbolo
Exemplo
Resultado
Adio
26 + 10
36
Subtraco
26 - 1
25
Multiplicao
26 * 10
260
Diviso
26 / 10
Mdulo
(resto)
26 % 10
#+' $ F
@
E System.out.println(30 + 10 / 2);
-
A
30 + 10
= 20
2
4)
>
'
30 +
10
= 35
2
correcto!
errado!
Grau de
Precedncia
Operao
Alto
()
Mdio
-, + (unrios)
*, /, %
Baixo
5
#.'
4)
#9'
+, &
3.8.2 - Reais
C
K
3
: ;
3 E !' K # '/ K ' K !'.K # ' K !'+
Tipo
Tamanho
float
4 bytes (32 bits)
double
8 bytes (64 bits)
#>'
2 )
"
Tipo
Menor Valor
Maior Valor
float
1.40129846432481707e-45
3.40282346638528860e+38
double
4.94065645841246544e-324
1.79769313486231570e+308
' (
")
2 )
@
float
double' -
&
D
D
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
#' @
6
double'
4)
Grau de
Precedncia
Operao
Alto
()
Mdio
-, + (unrios)
*, /
+, -
Baixo
5
'
&
3.8.3 - Caracteres
@
2 ) ,
0
D
char' <
?
, 4
char
?
,
) ")
,4 ) ''
0
'
@
char
: ' ;E
// 'a' 'X' '7' '$' ',' '\n'

// so valores do tipo char
char letra = 'a;
"
//
3.8.4 - Lgico
@
)
-
E)
boolean, D
2 ) ,
0
'
true false
)"
K )
1?
boolean terminado = false;
3.8.5 - Operadores Lgicos

-
@ <@
"
?
!
NOT
&&
AND
||
OR
;K
'
D
-<
@ *
"
:&
;
a
true
true
false
false
5
5
b
true
false
true
false
/'
'
a && b
true
false
false
false
a || b
true
true
true
false
a
true
true
false
false
! a
false
false
true
true
i i K jj P
3.8.6 - Operadores Relacionais

*
)
Operador
>
>=
<
<=
==
!=
booleanE
Designao
Maior que
Maior ou igual a
Menor que
Menor ou igual a
Igual a
Diferente de
"
-0
4)
)"
+
*
/
float,
double
++
--
>
>=
<
<=
==
!=
byte, short,
int, long
+
*
/
%
>
>=
<
<=
==
!=
char
boolean
+
>
>=
<
<=
==
!=
||
&&
>
>=
<
<=
==
!=
3.9 - Instrues
$
F" 0
A
) 0 6 ' -
E
( G
3
No executveis constituem directivas para a JVM
// executveis
System.out.println("Ol!");
aluno.inscricao();
// no executveis
public static void main(String[ ] args)
import desenhograficos.*;
I
3
+
+
> )
> '
L e k fM
)
A
:N;
4
)"
"
/!
// instruo simples
// instruo composta
{
System.out.println("Bom trabalho!");
}
;
>
<bloco de instrues> ::= { <instrues> }

<instrues>
::= <instruo>; | <instruo>;<instrues>
C
@ $
6
,
main()K
main
D ,
3
K
D
3
:)
main
3
D
-
A
3 '
D
D
'
)
D
'
;'
K
3.10 - Comentrios
@
"
3
'<
'
'
@
"
2 ) &
// formato utilizado para comentrios no final da linha

/* formato para comentrios que se
estendem por mais de uma
linha
*/
3.11 - Paragrafao / Indentao

$
'@
6
'
'
C
2 )
'
"
/+
/ (
package meuteste;
public class OlaMundo {
public static void main(String[] args) {
System.out.println("Ol Mundo!");
}
}
/ (
package
meuteste;
public
class
OlaMundo
{
public
static
main(String[] args) { System.out.println("Ol Mundo!"); } }
@ $
void
H '
3.12 - Um programa em Java

$
@
D K
6
K
, 0
G
)
)
6
@
) "
K
D
'
,
'
),
'
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);
}
}
"
"
)
0
? '
G !
,
0
"
(
"
/9
:String nome);
6
Z
6
'
'
:L
E
6
M;N
Le.umaString() ,
D
0
L'
M' @ )
6
) ")
nome.
System.out.println(Ol+nome+bom trabalho para a disciplina de

Introduo Programao);
<
) ")
"
:L M;' I
)
G 0
! (
D
?
KD
) D
3
D 06
K
<
) ")
6
?
"
D
) '
"
D
F"
0
D
6")
'
?
) '<
?
,
//Declarao de variveis
//Mostra a mensagem

3
0
' #E
D
'
#O <
1
0
true
' E
23E5
-255
false
300
23.4E300
8000000
D
)
)"
7E10
32767
-127
'
D
1E3
-32767
123
, )"
0D
'
666
777.
888.0
6.66e2
483,500
1666667e -6
' /E
D
; CONST
a = 3;
b = 4;
F"
2 ) E
' E
; CONSTANT PI = 3.14;
conta
diferenca
fraccao
cor
3
-2
0.33333
Azul
'2
0D
'
; CONST e = 2.718;
"
/.
; CONST a, b = 12;
; VAR y : INTEGER
F; VAR x = REAL;
; CONST a = 12; b = 12;
0; CONST valor = 2
H; VAR x, y : CHAR;
; VAR x : BOLEAN;
J ; VAR x : CHAR;
; VAR a: CHAR;
VAR b : REAL;
; VAR a : INTEGER;
b : CHAR; c : INTEGER;
; VAR a; b : INTEGER;
c : REAL;
"
/>
4-
Sequenciao
4.1 - Instruo de Atribuio

-
6
"
) ") '
'
<instruo de atribuio>::= <identificador>=<expresso>;
- 3
,
3 K
?
-
4
) ") K
)
M'
) ") D
D
) ")
'<
) ") '
'$
K,
) ") conta
)
R
T #N
,
:
5
!' *
conta
;
"
) ")
E
R !!N
@ )
) ") total ,
!!
int conta ;
conta = 25;
sum = conta;
conta = sum + 15;
conta = conta + 1;
!
!
#
4.1.1 - Operadores de Atribuio

) 6
,
"
) ") ' @
3
K
, D )
) ") K
2 )
6
A
'
num += conta;
num = num + conta;
"
TR
R
SR
BR
W R
+'
3
3
3
3
3
D )
TR Z
RZ
SR Z
BR Z
W RZ
3
3
3
3
3
R3
R3
R3
R3
R3
TZ
Z
SZ
BZ
W Z
4.1.2 - Operadores de Incremento e Decremento

@
,
) ") K
'
conta = conta + 1;
conta++;
++conta;
// Verso Sufixo
// Verso Prefixo
3
3
int x = 0, y = 1;
x = y++;
BB Z , K 3 , #
3
int x = 0, y = 1;
x = ++y;
// y 2, x 2
@
--
count--;
--count;
4.2 - Expresses
C
3
) )
D &
'-
'
"
E
G
>
) )
5 * ( 2 + 3 ) + ( 7 3 ) / 2
-
,
>
Resultado: 27
G &
) )
E
3
#E
)
2
3-4*2+1
2*(12%5)-(8-3)/2
2*12%5-8-3/2
2.5+6%4*2.1
!
+'9
S:: B+;T:/S: #'!;;;W : '!T# #'!;

3
#'
A
2
3+5/2) >= (1-4%2)

x=3 == 4;
8-1 != 3 + 4
a < b || c < a
(!a && b)|| (a || !b)
3 0
0
R0
4.2.1 - Converses de Tipo

@
3
K
"
)
0
A
A
4)
D
'
D
4) ' 3 E
" ,
4)
)
'
D
:
'
? K
'
D
"
H F
)
)
0
,)
;'
"
Z
)"
0
;N
'
X H
X
G
X0
)
X
3
"
'
"
resultado_int = (int) (valor_double + valor_int)
E
3
#E $
int var_int=10, resultado_int;

double var_double= 5.2, resulatdo_double;
resultado_double = var_int + var_double;
var_int ,
<
double ,
, double
, 0
resultado_int = var_int + var_double;

double
6
;'
) ") int
4)
resultado_int = (int) (var_int + var_double);

3
E I
6 A
)
) ")
double x, y=6.3, z=2.2;

x= y/z;
x= (int)y/z;
x= y/(int)z;
x= (int) y /(int)z;
x = (int)(y/z);
-2.8636363636363633
-2.727272727272727
-3.15
-3.0
-2.0
4.3 - Classe Math e Random

(
K0
F"
D
,
"
D
K
'
K
-
) )
K)
0 A
0
?
K
0 &
)
0
)
'
"
0
3
?
)
)
D
A
"
D
K
'
F
0
K
F
0
6
?
D
'
'
'
"
4.3.1 - Biblioteca de Classes

C
) )
-
K D
'
K
@ F
java.lang
java.util
java.applet
etc.
C
$
;E
)
"
_
4.3.2 - Classe Math

C
D
)
0
"
Math.sin() G
Math
: 3E
N
46 D
';
java.lang K
$
40
'
6
3
$
Math D
)
Math.sqrt() G
:import; 3
"
'
E
&
'
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

Random ,
java.util :0
java.lang ,
"
F ) '
I
,
6
"
'*
;' $
N
$
) importK
'
"
Random
,
(,
*
:;
3 :
3 :;
3 :
3
;
;
:;
$
7
*
*
*
?
?
?
?
? K
)
#'
'

java.util.Random r = new java.util.Random();
int resultado = r.nextInt();
}
}
,D
'
4) K
3 4
import java.util.Random;
Random r = new Random(); //agora j mais legvel...
int resultado = r.nextInt();
}
}
J
F ) '
'SN
"
'
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

@
"
6
)
@
C
A
6
'@
F K
'
:
E,0
;
),
4.4.1 - Sada de Dados

-
print
System.out (package SystemK

out;' I D
K 0
0
println 0
print '
)
8
) K
println
3
)
print
println
&
'
&
E
System.out.print (Ol a todos);

)
E Ol a todos
println (
print
System.out.println()
"
System.out.println(Primeira mensagem");
System.out.println(Segunda mensagem");
X
X
XQ
System.out.print()
(
'
'
:a
a;N
System.out.print("Segunda mensagem ");
Q
E
3
#E
) ")
R //N
//
System.out.println(idade);
3
) )"
?) 6
@
//
int idade = 33;

System.out.println(O Pedro tem +idade+ anos);
/E 3
)
-
,!
int x = 3, y = 2;
System.out.println(A soma dos dois nmeros + (x + y));
4.4.2 - Entrada de Dados

-
2 )
'<
D
40
A
K
,
K
K F" D
04
0
System.out.read()
6
K
0
)"
) 6 D
6
6
4
D
)
0
'
4.4.3 - Classe Le
0
6
L'
MK
4
0 H
Le.javaK D
'D D
?,
6
D
F
6
'
3 '
"
0 H
E
=
$H
int
float
double
String
-
Le.umInt()
Le.umFloat()
Le.umDouble()
Le.umaString()
'
double var_double = Le.umDouble();

E
3
#E
: 0
/+ `;
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);
}
}
)
K
K
W
"
0
W
0
H 0
E+ W
'
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

C
String' [
2 ) ,
'
String
)
'-
KD
) 6D
tring
F
) )
)
String
) String :String
String frase = Introduo Programao
String
(,
:;
char charAt(int index)
int compareTo(String anotherString)
int indexOf(String str)
String toUpperCase()
int lenght()
E
index
) )
&
0
*
,
String
2 ) '
E
String frase = Hoje quinta feira;
2
int tamanho = frase.lenght();
H R#>
String palavra = frase.substring(0,4);
) RL] F M
String novaPalavra = frase.toLowerCase(0,4);
)
) RLH F M
char c = palavra.charAt(2);
RgFc
boolean b = novaPalavra.equals(Hoje)N
R0
int indice = frase.indexOf(qui);
R9
String outraPalavra = frase.substring(indice,indice+7);
) RLD
M
String outra = outraPalavra.trim();
RLD
M
"
>

3
' #E I
a + b + c + d + e
a / (b + c) - d % e
a + b * c - d / e
a / (b * (c + (d - e)))
' E
"
"
0D
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
' /E
)
2 ) D
)
D
4
< R !.#
@
4
$
H E
3
$
) ")
)
!.#
'-
!K .K #K
B#
W R#
'
' E
)
23 + 34 < 123
89.1 * 100 > 200
78 / 2 == 50
67.23 * 200 <= 500
4) '
(23+34<123) && (89.1*100>200)

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

34.3 != 34
' !E
)
) ")
(900200>=1000) && (67.23*200<=500)

(34.3!=34) || (78/2==50)
(,
H
4 '= 0D
3
,
& K
- E
( E
2 H
E
)
K-
K(
# '
# '
.
##'//////
,
gh c
;1
;1
;1
A
"
)
K 0
K 0
)
)
'
'
'
' 9E
"
3
$
D
' .E
' >E
)
/K#W
)
)4
?
)4
'1
'
'# E
)
'
'!/+' -
D
H
'
'
:a
EaT
; 3
3 Ta
Math.sin(value)
)
0
)
'
"
'
Math.cos(value)' <
F H '
0
E
'
' +E
)
&
,
EaT
,
6
) ") '
3 Ta
EaT
) ")
& ) ")
;N
'! /+
' ##E
3
)
H
)
Math.sin Math.cos' @
Math.PI
D
" H
)
"
,
)
Pi'
"
!#
5-
Instrues de Controlo
-, D K
H
H
A
D
06
;K
'
, 3
6
A
A
"
$
) 6
) ,
'
)
2
:
0
' @ D
'<
F K
6 '
D
' @
3
D
)
3
"
0 3
?
D
*
)
:0 3
)
0
, 3
;'
5.1 - Seleco
-
A
6
D
'
A
-
)"
F ) 0
'
3
3
'$
'
E-
2 )
0
A
A
A
3
9
( E
3
E$
) 0
, K
"
) '
if/else
switch - case
A
&
'
5.1.1 - Seleco Simples: if

C
0 3
'''
9' 5 3
$
)
A
?
'$
" K
2 ) K
'
, 3
'
ifK
3 ,
if
.'
expresso
instruo
if
"
B if
<instruo if> ::=
if (<expresso-lgica>)
<instruo>;
'
if (condio) {
instrues;
}
"
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);
}
}
$
// Programa que gera um nmero aleatrio e reporta se
// o nmero gerado ou no negativo
public class NumNeg
{
"
!/
{
int n = random.nextInt();
System.out.println(n = + n);
if (n < 0)
System.out.println(*** n < 0! ***);
System.out.println(Adeus.);
}
f
5.1.2 - Seleco Em Alternativa: if-else

(
3
) 6
'[
D
D
E
KD
) 0
"
) KD
'''
)
E
F
0 3
>' 5 3
*
KH F
'''
F 0
K
0 )
A % '@
K, 3
-'
3 2 ) K
0
)
K, 3
3
'
if
expresso
instruo
else
/ '
instruo
if-else
"
"
( C D
<instruo if> ::=
'
if (<expresso-lgica>)
<instruo>;
else
<instruo>;
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;
}
"
public class TesteNota
{
{
int Nota = 14;
// Resultado da avaliao
if (nota < 10)
System.out.println(Nota negativa);
else
System.out.println(Nota positiva);
}
}
$
// 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);
}
}
-
if
H F )"
'
%
// Determinar a ordem de grandeza
// dos trs nmeros (a, b, c) usando ifs encadeados.
U U
U U
: U ;O
: U ;O
: U ;O
U U
U U
U U
: U ;O
: U ;O
U U
// 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");
"
!+
E
// Determinar a ordem da grandeza
// dos trs nmeros (a, b, c) usando ifs paralelos.
//
if
if
if
if
if
if
U O
U O
U U
U O
U O
U U
U O
U O
U U
U O
U O
U U
U O
U O
U U
U O
U O
U U
cdigo:
(a < b &&
(a < c &&
(b < a &&
(b < c &&
(c < a &&
(c < b &&
b
c
a
c
a
b
<
<
<
<
<
<
c)
b)
c)
a)
b)
a)
System.out.println("a
System.out.println("a
System.out.println("b
System.out.println("b
System.out.println("c
System.out.println("c
ifs
K
0
<
<
<
<
<
<
c");
b");
c");
a");
b");
a");
'
40
K
<
<
<
<
<
<
) 0
b
c
a
c
a
b
) elseK H"
K
F K
0 6 '] "
4)
else
D
A
'
F
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");
,
if
elseA
0
"
?
numeroAluno > 1200''''
(
?
numeroAluno < 2000'
else
else
)
)
"
!9
<
2 )
F
8
'@
2 ) K
<
,
'
ifBelse
D
if
else'
F K
K
else
K
else a
if D
ifK
'
D
0 6
)
D
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");
<
)
K 6
;K 0 6
if
D
A
"
)
4 :
numeroAluno > 1200
F
true'
'
H ) ifs
elsesK
"
'
G
//
//
//
//
//
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 ");
}
}
) 0
- "D
D
else
pontos > 95P
"
D
D
,
8
K
4
'
if
"D
?3
2 )
K
3
else
if
H"
'
'
"
!.
5.1.3 - Seleco Mltipla: switch - case

<
A
0
<
?
) 0 "
), '
) D
) D
D
0 3
2 )
4)
)
0
0
0
),
6'
5$- G 5
H ;E
=#
/#' 5 3
$
)
)
)
3
'
3
H"
"
D
)# ) '
0
)
H
)
H"
2 ) K
switch ,
:
3
)
)#''' ) K
H
H
)
A
H K
A
A
A
3
H
0 3
;'
D
,
;
K 3
H
3
'
0
)"
D
)
)
4)
) ")
F
switch' 3
A
3
"
)
'
!>
"
!
switch
(expresso)
case
constante
/ '
brea
k
instruo
defaul
t
switch-case
"
C switch/case
switch (<expresso>)
{
case <valor 1>:
<instruo 1>;
break;
case <valor n>: [case <valor m>:]

<instruo x>;
break;
default:
<instruo y>;
break;
}
break ?
)
3
switch F
'
@ default ,
D
)
@
D
F
3
default 0
D
6
default
?3
A
H
switch
A
break
3
'
break 0 6
) :
0 3
default
3
' ] "K
H"
D
,
'- 3
K
;'
&
A
" '
)
cases
default
K
default
'
?
F
'
K,
"
"
@ break
defaultK
:
D
;K
&
" '(
'
"
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!");
}
}
}
$
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
Switch
@ if ,
@ switch 0 6
A
C 6
if D
o @
o I
o H ,
C 6
switch D
o
3
3
)
D
)
3
)
)
F
x>1K
y>100 && y>200''' ;
")
5.2 - Repetio
[0
0 &
H"
? 3
D
&
,
0 D
)
3
)
) K,
0 K
) 6 K
)
K
) 6
?
4)
?
A
A
K
'
D
)
,
'
'<
"
'
D &
'[
I
+
$
C
D
A
D
) 6
0 K
3
3
F K
K
;'
K 6
"0
6 "
'
0
D
'
'
A
D
F")
3
D
,
? K
K
A
'
2 ) :
,
K
") H )
4) ;K H" &
while
do-while
for
"
5.2.1 - Instruo de Repetio while

)
3
'
D
:true;K
0 3
K
3
,D
'
5
O
=
while
//' 5 3
"
!
)
while
/ '
;
expresso-lgica
instruo
while
"
while
<instruo while> ::= while (<expresso>)

<instruo>;
'
H =
// as chavetas aparecem se houver mais do que uma instruo

// a executar no corpo do ciclo
while(condio){
instrues;
}
"
+/
- ?
"
- )
false;'
@
'
K H"
0 6 E
)
'
D
) 0
"
)
0
0
)
,K
"
0
0 6
:true
A
0 )
K
'
H )
D
H
D
D
'
'
)
A
'
"
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?
$
/* 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.");
}
}
"
%
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

do-while ,
)
0 )
D
)
:while;K
)
3
3
0
)
while
0 3
D
"
D
D
'
'
0 6
K
while
while
:
0 K
do-while
( ? '
)
'
F K H" D
0
do-while
)
0
D
'
_H
H
( ?
0 0
'
) 6' @ do-
=
O
5
5
/!' 5 3
do-while
"
+!
do
instruo
while
expresso-lgica
5
/+'
do-while
"
do-while
<instruo do-while> ::= do

<instruo>
while(<expresso>);
do-while
'
do { // as chavetas aparecem quando o corpo do ciclo tem

// mais do que uma instruo a executar!
instrues;
} while(condio);
"
public class CicloDoWhile
{
{
int a=0, i=0;
do
{
++a;
++i;
System.out.println(A + a);
}
while (i<3);
}
} // qual o resultado produzido?
$
// Programa que gera um nmero entre 1 e 100
// e verifica se o nmero primo.
public class Primo
{
"
++
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.");
}
}
2
while
o
o
o
o
o
o
o
$
o
o
0 )
3
-
A
)
)
0
3
do-whileE
3
A
-)
3
0 )
E
do-while 3
while 3
K
A
6
) 6
) 6
5.2.3 - Instruo de Repetio for

for ,
A
D
- 3
"
0
:
"K
K
) 6
F K
K
;'
)
) ")
'
for
expresso
expresso
lgica
expresso
instruo
/9'
for
"
"
+9
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>
6
3
,
$
,
D
D
D
6
, 0
)
)
'
) ")
) ")
U) $
'
for
'
for(expresso1;expresso2;expresso3){
instrues
}
@
0
,
E
#'
expresso1'
' -)
expresso2'
o
,)
E
3
3
expresso1
o
0 3
,0
expresso3
) ")
for
;E
/.' 5 3
3 /
3 #
for
"
+.
<
K ?,
forK
H
3
<
) ")
"
K
0
H
H
:
),
6
)
3 '
K
K
K
for'
8
forK
K
"
)
A
H
) 6
D
'
0
H ;'
B?
'
"
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);
}
}
}
$
// 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.");
}
}
"
+>
/ 3
expresso2K 2 )
0
'
expresso1
expresso3
'
, trueK
D
6
) ")
'
A
'
A
F K
'
-
"
'
H '
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();
}
}
}
<
H")
K
while
- ?
)
C
'
3
F K
6 ")
do-whileI
04
'
&
'
for
) ED
O
forK
2 ) K for , 0 3 4)
,
K
H
D
0
A
D
4)
A
?
3
A
A
K
H
, ,
'
F
'<
04
'
"
do-while
K
while'
A
K )
K
) 6' - " K ,
'
do-while
,
D

$
,
$ H
-
#'
'
3
+CJ
#'
'
/'
I

!'
+'
9'
.'
>'
D
'
'
3
D
) ")
final int MAX = 25, LIMIT = 100;

int num1 = 12, num2 = 25, num3 = 87;
*
if (num3 >= LIMIT)
System.out.println ("ma");
System.out.println ("laranja");
System.out.println ("pera");
*
if (num2 == MAX)
{
}
*
'
if (LIMIT+num3 <= 150)
{
"
9#
}
else
*
!
if (num1 < MAX)
if (LIMIT >= num2)
*
if (LIMIT%num1 + 4 == num1 + (MAX-num2))
{
}
else
{
System.out.println ("banana");
}
*
;
if (num2 > 18)
if (num1 < 0)
else
K
if (num3 >= MAX)
{
if (MAX/num2 == 1)
System.out.println
System.out.println
if (LIMIT-num3 > num1+2)
System.out.println
else
{
System.out.println
System.out.println
}
}
else
if (num2*2 == MAX*2)
System.out.println
("ma");
("laranja");
("pera");
("banana");
("kiwi");
("uva");
L
if (LIMIT >= 4*num2)
if (MAX == 25)
else
else
System.out.println ("pera");'
"
' E
*
L]
PM
L<
,6
) ")
) 4)
) MK L<
)
0
@
#'
'
) MK
'
) ")
!
L
M
3
'
MK L<
L 0
' /E <
) ")
float
)
) #
8
0
3
H
4
3
'
'
'E
"
final int MIN = 10, MAX = 20;

int num = 15;
*
while (num < MAX)
{
System.out.println (num);
num = num + 1;
}
*
do
{
num = num + 1;
}
while (num <= MAX);
*
'
for (int count1=1; count1 <= 5; count1++)
{
for (int count2=1; count2 <= 5; count2++)
System.out.print (count1*count2 + " ");
}
!
while (num > MIN)
{
num = num - 1;
}
*
while (num < MAX)
{
if (num%2 == 0)
num++;
}
"
9/
;
for (int value=7; value < 0; value--)
System.out.println (value);
K
do
{
num = num + 1;
if (num*2 > MAX+num)
}
while (num <= MAX);
L
for (int value=num; value <= MAX; value++)
if (value%4 != 0)
System.out.println(value);
' E
*
= 0
*
= 0
_H '
) K
_H '
'
# '
!
/
' !E I
, /'
D )
if (condio1)
if (condio2)
instruo
If (condio1)
Instruo1
else if (condio2)
instruo1
If (condio1 || condio2)
instruo
If (condio1 && condio2)

instruo
' +E 1
' 9E 1
' .E 1
&
' >E
'# E
' ##E
'
4
'
'
6
&
'
'
6
'
"
3
!'
3
'# E5
KD
' #/E
0
K
2 ) KD
, ) 4)
6
, ) 4)
'
3
'# E
2 )
' #!E
2 ) D
' #+E
) '
' #9E
) 0
, ) 4)
K /K !K +K # K #!
?3
KD
) )
K CalcIRS D
/ '
'
,
E
Ordenado
<100.000
>= 100 000 e
> 300 000
Taxa
5%
15%
25%
< 300 000
Tabela 2
3
' #.E @
' #>E
'
E$
K 0
)
8
)
D
)
?
&
'K
D
H D
K
:TK K SKB;'
&
'
KD
K ?
' /E 5
'
& )
) '
H
,
3
D
"
D
3
KD
' #E
0D
'
! )
"
3
D
'
"
6
,6
# D
"
'@
46
D &
D &
'
)
?
2 ) KD
F
6
'@ F
) '
E@
'-D
0
K F
,
'
"
9!
' !E $
'
' +E 5
KD
' 9E $
' .E
' >E
) K
) K
,
KD
'
'
L0 MK
D )
'
E
while (i<100)
System.out.println(i,ao quadrado igual a ,Math.sqr(i));
3
'/ E
'*
? '
D
D
' /#E
?
,
2 ) KD
n
i2 =
i =1
)
3
'/ E@
) 0D
,
) 4)
n ( n + 1 ) ( 2n + 1)
6
K
)
0?
#
D
?
D
# '
E
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);
}
}
3
' //E @
D
0
E
'<
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;
}
"
9+
System.ou.println(\tcount= + count);
}
}
}
3
'/ E@
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);
}
}
3
' /!E
' /+E C
2 ) KD
)
#
D
@
3
' /9E
,
: ?
'
# # '
K5
K1
D
D
'-
H D
';
)
8
'
'
#'! V
'9!V
'!!V
'.!V
%
*
'
*
<
,
*
4)
0 6
'!V'
'
)
3
0
!V &
' /.E C
W '
&
K
'
4
0
D
K
"
)
#
&
0D
>> )' -
2 )
(
^ #
&
) ")
&
E
&
U#
# UR
U!
"
99
! UR
U
UR
U#
XR #
-
3
3
' />E
K
D
)
6
) '
2 ) D
0c
'
D
) 0D
D E
E(
E( 4
E 0
E%
E(
%
!>
# #/
# #9
#.
3
^
^ /
(
'
) ,
K
4
0
D
'
H"
2 )
#'
'@
0
)
F
) "
D
D
3
K
:
3
" K
;' $
' ) "
'
"
9.
6-
Sub-Programas
K
'(
) 6 K
D
)
0
')
K
'
&
C
$
D
H
4)
40
:
3 '
K
,
0
&
"
:' ' D
0 60
;K
F
)
'
0
6
;K
) "
'=
K &
F K
MK
3
3
) 6
)
0
L )
) #B3
4
0
H
'
A
0
) 6
3
E
$
"
'
0 '
?
'
) #B3
,
0
D
&
'=
&
H ,
' [
D
0 H
:;K
'%
D
:, D
;'
"
resultado = Math.pow(2,4);
powK 3
3
)
:Z ; ;K D
H
)
&
8
?
"0
:3 ;
Math
Z' <
#+' [
2 ) '
"
)
D
) ")
'
numero = Math.random();
<
D
H
?
A '
"
K
K
) 0
( H'
H
"
"
9>
'
) #B3
H E
:D
) 6 ;
"
)
)
:D
)
'
) ")
;K
) '
'
'
&
)
"
D
KD
) '
,D
%
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()
Cabealho do sub-programa
{
System.out.println("Ol Mundo!");
Instrues a executar
}
}
C
3
$
"
F K
;'
2 )
@
D
0
0 6
'] " ,
'
6.1 - Procedimentos
C
,
D
0
A
D
0 H K
D
F
0 '
K
3
A
0 H
"
' 3
,
0
0 '@
'[
0 ,
?
B
K
" '
"
C
:
)
;' @
K D
(
2 ) ,
3
)
/
void
,
,
3
'
6.2 - Funes
C
&
3
[
-0
, voidK
,
'
"
;'
return'
2
3
0 3
) )
'
return <expresso>;
@ )
, )
,
: ,
<expresso>)K
3
;'
'
void;K
3
return
: ? ) 0
3 4
:
K
"
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;
}
}
"
.#
10.5 ) ") varA

double'
)
) ") '
- 0 6
varA = funcao();
H
,
D
funcao' <
3
'
0
3
0
,
?
0
'
,
0
D
,
E,
?
,
random
Math ,
)
) ") valor1'
K,
?
0
)
,
) ") valor2'
0 K
) ") resultado'
K 0
"
0
K ) )
'
return' - 0 6 return resultado;
0
)
) ")
D
H
K D
0
0
main
varA=funcao() ;' , D
"
0
funcao 0
6
) ") varA'
@
A D
3
KD
) )
) ") varA ,
:L!b
3
,
<
K
KD
H
)
K
:
),
,
)
M;'
6.3 - Parmetros
2" 0
D
:
) K
-
K
D
) 6 K
0
P5
H K
' ;'
'
0 K
'''
6 H
1
;
) '''; D
3 1
0
D
0
-D
) ")
0 '
6
,
3
A
H
:
D
&
3
K
'
D
'
"
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");
}
}
<
3
K)
pfA pfB'
) 0
D
) ") pcA
)
10 pcB )
20'
K, )
,
procComParams' <
8
) ") pcA pcB'
8
K D
)
,
)
H
3
)
0 '
pcA pcB
K
)
K
) ") pfA pfBK
KD
,
0 6
System.out.println (pfA+pfB);
30K
'
<
,
D
@
$
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);
}
}
3
,
H
pfA pfB' @
) ") varC
0
3
K 3
0
D
pcA pcBK
0
:
F K
)
8
8
pfA
pfB
;'
H"
D
) K
F
)
]"
3
0
8
,
8
2 ) ';' -
'
8
H )
K
D
0
8
,
int
D
D
&
"
'
8
'@
charK ,
D
4)
F K
,
H
"
./
char
0
int
&
'@
&
'
6.4 - Passagem de Parmetros

8
'
3
?
)
?
0
/ ( K
"M
)
0 &
8
8
0 &
)
'
K
8
D
' 1
D &
'
,
'
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
System.out.println(pcB
= + pcA); // pcA manteve o valor 10!

= + 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);
}
}
= F
'''
"
// Antes da invocao de procComParams!

pcA
pfA
pcB
pfB
AAAAAA AAAAAB AAAAAC AAAAAD AAAAAE AAAAAF AAAAB0 AAAAB1

pfA e pfB so
CPIAS
mudaramde
depcA e
pcB!
valor mas pcA e
pcB No!
// Invocao de procComParams!
pcA
pfA
pcB
pfB
AAAAAA AAAAAB AAAAAC AAAAAD AAAAAE AAAAAF AAAAB0 AAAAB1

5
/>'
8
2 ) D
)
0 &
F
6
)
F
D
;
;' - ) ")
6
'
8
0 &
) ") K
'
D
F
&
?
)
0 &
$M
) ") D
K
D
0 &
'
K
06
H
)&
'
K) F
E
1
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!);
}
}
)
) 0
// Antes da invocao de procComParams!

exemplo
s
Teste
passagem
por
referncia
AAAAAA
AAAAAB AAAAAC AAAAAD AAAAAE AAAAAF AAAAB0 AAAAB1
Logo,
quando
s muda
s uma
referncia
de
valor,
exemplo
para o objecto
tambm
sofre
apontado
poras
consequncias!
// Invocao de procComParams!
exemplo
s
Isto FOI
Teste
um
teste
passagem
passagem
por
por
referncia
referncia
AAAAAA
5
exemplo
AAAA
AAAAAA
AAAAAB AAAAAC AAAAAD
'
AAAAAE
AAAAAF AAAAB0 AAAAB1
0 &
6.5 - Visibilidade das Variveis

*
D
0
K
)
2 )
6 )
D
K
2 ) K
H
main D
'
3
2 ) ;E
) ")
,D
K
D
O;
,
F
'C
'
o
o
, E
A
C
) ")
'
)
;
D
:)
4
) ' :-
&
,
F
"
"
5$- G 5
N
main()N
"
.+
@
o
o
o
@
D
F
& E
) ")
'
$H
K
: ,
H
8
[
) ") ,
';N
;'
)
6 :,
D
0
) ")
,
D H F
) ")
0
0
K
(
(
) ")
) K
'
C
) ")
) 4)
D
< ,
?
0
,
,D
) ") ' =
) ") ,
0
0
D
P;'
, H
D
,
D
KD
)
H
) ")
'C
4 D
) ")
) ")
'
K
'
D
, D
D
4
D
) ")
)
K
H
D
'
)
6
K
D
) ")
'
A
04
6
,D
) 4)
,
,
D
'
) )
'
"
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);
}
}
"
.9

<#8
,
#'
'
/'
'
!'
A
8
8
0
+CJ
#'
'
/'
0 &
>
D
D
)
@ D
8
C
) ")
3 4
'
O
0
O2
) ") D
0D
,
H
K)
,
O
H OI
@ D
I
8
2 )
,
O
0
O & 3
9'
.'
>'
) ")
I
0
I
0
< 2 ) 3
'
!'
+'
),
,
0
& 3
4)
0D
"
0
O2
'
6
D
'
O
O2
0D
& 3
'
3
3
3
++ C
'
' #E C 6
34
E
)
D
3
D
34
: ,
0
;
'
)
) ")
) ")
'<
) ")
'
K0
2 )
'
3
&
D
,D
6
: ,
0
D
' E
&
&
3
3 ,
'
' /E $
&
,K
,
'
'[
O2
0D
"
..
'
7-
Classes e Objectos
@
:
2 )
"
B
2 )
3
A
) )
)
,
2 ) ;' - - 2 )
0
"
F" 3
0
A
) )
2 )
"
'
' @ 0
E
F
'<
) 0
)
A
'
K ) 0
- 4
?) ' -
'
D
?)
' '
:
K
;
D
K
)
?)
?) K D
H ) K
ND
'
H '
'
D
?)
'
'
0
0 K
D
) 0
'
0 H
D
0
K
?)
H"
)
,
)
0 K
'
8
; KD
:
D
0
K
;'
F
'
<#8
A
0
K
8
'<
8
K
'
E
0
F
o
o
I
I
"
4
0
7.1 - Objectos
8
& E
o
o
o
0
0
'
'
: 0
;N
;G$
,
H
,
'
'
F
K
0
),
: )
"
.>
),
),
'
7.2 - Classes
0
D
)
)
"
'
F
: 0
F
0
'
: ,
'
'
0
0
:) ")
0
;
F
: ,
7.3 - Atributos
0
'
&
'
7.4 - Mtodos
0
'
)
0
-
F
,
F
C
0 6
)
;
F
F
8
&
3
&
&
'<
2 ) K
: 3E <
: 3E
@ F
;'
: 3E
,
,
4)
'
F
@ 0
K D
'
'
0
: 0
:
;K
;'
// J vimos isto quando falmos de sub-programas!

tipoRetorno nomeMetodo(listaParametros) {
declaracoes;
instrues;
retorno (se for o caso);
}
"
>
7.5 - Instanciao de Classes

,
: F
'
F"
0 6
''';'
8
newK D
"
, 3
? '
new <nome da classe> ();

ou
new <nome da classe> (<lista de parmetros actuais>);
"
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

* 0
6"
4 K
F
0 &
K 0
F
6
D
6
F
0
) ") D
) '
?
#;'
'
'
F K
K
D
F"
"
'
System.out.println(OLA);
)
System.outK
D
?
F K
)
)
,
)
3
println
println
8
F
System.out D
OLA
'
contaDoBanco.recebeOrdenado (500.5);
"
>#
F
;K
F K
(,
contaDoBanco :
D
)
recebeOrdenado D
)
,
recebeOrdenado
8
D
" 0
Conta'
Conta F"
3
8
)
500.5' @
500.5
F
contaDoBanco'
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 */
4)
3 &
D
0 &
F
' 3
)"
) ")
6
'$
0
F
0
)&
0
'
< 3
KD
"
) ")
Conta 0 6
b = cK
6
F
D 0
new Conta(1287,0)'
)
,
K
c.obterSaldo()
0;'
06
b.recebeOrdenado(600.0)
+ V
06
c.obterSaldo() ) 0
D
"+ K
0
, )
+ '
D
) ")
@
#8
'
?
K
F
)
"
) ")
:b.obterSaldo()
'$
D &
K
b.obterSaldo()
F
Gb c
F
import java.io.*;
public class Untitled1
{
{
Random objectoDaClassRandom;
objectoDaClassRandom = new Random();
// declarao
// instanciao
int var1, var2; double varD, varG;

var1
var2
varD
varG
=
=
=
=
objectoDaClassRandom.nextInt();
// mensagem
objectoDaClassRandom.nextInt(50);
// mensagem
objectoDaClassRandom.nextDouble();
// mensagem
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)

@
,
8
' 2" )
D
D
&
D
8
'
=
)
, D
0 &
K
/ ( K
8
H
8
@
0
F
8
) : K H K
,
D
F K
)
o
o
,
'
D
= ")
?
I
,
,
F
;'
)
F
o
o
: ,
'
A
@ F
@
P:
0
E
K
F
P
@ F
0 &
;
,
8
?
@ F
:
"
K H K''';
?
)
F K
@ F
@ F
6
,
)
8
8
)
, (
,
0 &
'
O
@
G
// 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
"
>/
'
P
// 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);
}
}
Q
// 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
C
F
F
@
@
,
)
6
F
) ,
6
8
'
K
'
F K
'
#8
H
;'
D
public
'
R
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;
}
}
0
3
H
K D )
"D
<nome da classe>(){}
0
false
null
null
,
0
)
KD
E
:short, byte, int, long, double,float, char;
boolean
0 &
0 &
'
"
>!
":
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
}
""
// 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

,
$
F
K
0
0
0
0
,
)
K
K,
: " K,
;'
0 6
F
0 6
"
)
3
D
'-
E
:) ")
:) ")
;
;
:D
"
; M
<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>){...}
}
"
>9
"$
// 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

C
0
) ")
0 ;'
= ")
2 )
valor_cambio_dolar;'
0
K
6 :
) ")
,
"
"
3
H
,
,
8
0
"
E
H
3
D
"
)
)
static : 3
"
'@
D
F
,
D
D
E static double
"
Math;'
) ")
'
"%
// 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

- (
@ )
F
) ")
K
"
K
K0
'@
) ") '
4
F
40
'
F
'
7.12 - O Operador de Auto-Referenciao this

)
this ,
)
L
this
M
this ,
,
'
6
0 &
D
D
K
F
,
'C
'
K
'
F
"E
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?
}
"
>>

<#8
,
$ H
+'
9'
3
)
D
E
F
+CJ
"
>
# '
##' C
F
F
'
O
# ' <
#/' I
3
# ' [
0
#!'
#+'
#9'
#.'
#>'
'
O &
D
0 &
?
0
)
0
D
I
@ D
I
C
O
6
0
F
& 3
' =
F
O
K
0
'
O
D
O
H
++ C
3
K ,
D
'
4)
O
8
'
) ")
F 0D
#' $
'
6
2 0D '
/' (,
"
' @ D ,
D
3
D
A
O
8
'(
'
6 ) ")
) ")
B
O2
0D
& 3
'
O
"
O2
0D
'
H O
&
"
,K D
"
'
' #E
) ")
3 ,
E L@ D
*
H
0 3
"
'
'
*
)
*
2 )
"
'
,
0 6
'
!
0D
) ")
*
0D
*
H"
) ")
"
,
3
' EC
'
Z'
*
)
2 )
'
*
<
,
#'
'
*
8
8
'
"
"
"
'
!
0D
) ")
'
*
0D
*
H"
'
;
,
) ")
' /E - 0
"
C pn =
)
D
6
'@
$
) 0 6
8
0
'
n!
p !(n p )!
)
H ,
3 E
public class Factorial{

static long calcula(int n) {
if (n < 2) return 1;
return n*f(n-1);
}
}
3
' E
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);
}
}
;@
;@
;@
;@
# SS
SS
/ SS
SS
' !E <
3
8
8
' +E $
D
/
/
/
3
) ")
D
: D
8
#'
'
/'
'
K ?
;'
/
)
K0
,
'
'
8
8
8
C
H
"
) ")
D "
?
8
/
D
'
'
0
) 0
'
"
'
E
#'
'
/'
"
F
8
,
'
0 6
'
"
8-
Recursividade
8.1 - Definies
0
) :
3 4 ;'
) :
4 ;' I
K) F
"
C
<
'
)
0
;
,
#PR#'
) K PR S: #;P
3
?
"
:
3
;SkS#
? K
) K
"
'
) : 0
#PR#
P R S: #;P
)
P R S: #;S:
= 0
<
<
"
"
"
) ")
"
)
8
'
),
) '
+
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)
f(1)
f(2)
f(3)
f(4)
f(5)
f(6)
f(7)
f(8)
*/
=
=
=
=
=
=
=
=
=
1
1
2
6
24
120
720
5040
40320
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)
f(1)
f(2)
f(3)
f(4)
f(5)
f(6)
f(7)
f(8)
*/
=
=
=
=
=
=
=
=
=
1
1
2
6
24
120
720
5040
40320
"
= F
"
0:/; R / S 0: ; R +
j
S 0:#; R
j
#S#R#
0
6 K
<
<
E
)
"
)
3
"
'
'
8.2 - Exerccios prticos

3
'# 5
'
0
)
) D
0
3 '/
)
T: T#;B: T/;
3
'
'!
'+ 5
A '
3
-
) D
'
R B T !B! T # B+ T #9B9 T +B. T '''

3
&
) D
0
o: K E
R # T #B#P T m P T #B/P T # B<P'
) D
'9 5
0
: #K ; R # K
R
: #K ; R
: K #
'.
R # T m T #B/ T n T #B! T #B<'
) D
)
,
) D
:3 ; R # 3 T 3 3 + T '''' P P +P
)
o
;E
op'
)
) D
;K
),
E
PR
3 E
inicio
se (n=m) ou (m=0)
entao
X = 1
senao
X = X(n-1,m) + X(n-1,m-1)
fim
I
)
o:!K/; O
I
H
0
)
"
# !
9-
Tabelas
9.1 - Motivao
C
)"
)
K
3
= ")
#' -
= ") /
<
4 '
)
) 6:0 ' ;'
) ") K 0 6
= ") #
6
:0 ' #;'
)"
'
=
=
=
=
'''
' (
)"
"
# +
D
"
"
LD
)"
)
6
' @
:0 ' /;'
= ") #
= ")
= ") /
4
= ")
= ") !
'''
'''
=
= ")
/' 1
-
)"
0 '/
:0 ' ;'
KD
6
D
) ")
'-
=
=
/
4
= ")
=
=
'''
=
' -
)"
'
"
# 9
9.2 - Tabela Unidimensional

3
0
:#; U
: ; U
'5
2 ) E
X U) ") X q r
X q r U) ") X
0
:#;
: ;
qrN
N
qr
9.2.1 - Variveis Simples e do tipo tabela

5 6
) ")
?)
'
'
) KD
'
)
3
K
'
'
) 6
F )
H 03 '
F K
)
3
D
'
'
9.2.2 - Passos para utilizar uma tabela

@
6
#;
& K
E
int [] tab; // declara uma referncia para uma tabela de inteiros
com qualquer dimenso, iniciada com null
E
tab = new int[5] ; //criao de uma tabela com capacidade para 5
inteiros
"
# .
q r
C
@ 4
N,
q#r
q r
q/r
q r
new
F K
F ) ,
3
0
3
0 N-1' $
H 1K
'
?
length : 3 E tab.length;'
)
,
:
'
'
int tab [ ] = {1,1,2,3,5,8,13,34}; // criada uma tabela com

// 8 elementos
q r
q/r
q#r
/;
#/
q9r
k''
q r
E
tab[1] = 12; // o elemento com o ndice 1 da tabela
// passa a armazenar o valor 123
q r
q/r
q#r
k''
#/
q9r
q r
"
# >
#
&
0
( )
valor = 10.6;
valor = Le.umDouble ( );
System.out.println(valor);
x = valor / 2;
if (valor > 5.0);
Testa(valor);
#
) *
'
3
#
tab[3] = 10.6;
tab[3] = Le.umDouble ( );
System.out.println(tab[3]);
x = tab[3] / 2;
if (tab[3] > 5.0);
Testa(tab[3]);
#
"
<
3
#. )
)
)
#.
E
'
double [ ] pluv = new double [18];

pluv [0] = 30.55;
pluv [1] = 23.94;
.
//restante valores
KD
double total = pluv[0] + pluv[1] + pluv[2] + pluv[3]

+ pluv[4] + pluv[5] + pluv[6] + pluv[7]
+ pluv[16] + pluv[17];
double total = 0.0;

for ( int ano = 0; ano < pluv.length; ano ++)
total = total + pluv[ano];
D
$
)
0
, length-1
System.out.println(O valor mdia de pluviosidade +(total/pluv.length));
$
@
F
6
6
)
"3
)
)
:0 ' !;'
"
##
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.
!
"
!
#
!
#
$
5
!' $
'
"
###
9.2.3 - Acesso a elementos no existentes

$
#' ' K
K
'$
n1 [5] = 4; //acesso a um ndice que no existe

@
Java.lang.ArrayIndexOutOfBoundsException:19
At Teste.main(Test.java)
9.3 - Passagem de tabelas como parmetros de mtodos

C
8
0 &
K D
, ,
'
[
4)
4)
'@ D
,
8
;,
'
0
0
'
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

C
)
6K
F ,
'
, 0
2 ) K
,
,
0 &
'
D
'
!
<tipo> [ ] [ ] <varivel>
int [ ] [ ] tab;
@
K
0 &
'
,D
) E
1) tab = new int [2] [3];

2) tab [][]={1,2,3} {4,5,6};
q rq r
q r
q#r
q rq r
q#rq r
"
##/
for
'
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]);
}
}
@ 2 ) ,
0
'@
D
) '
6/
'
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

-
D
'
D
F
,
6
0 &
null'
"
##
#
<
)
3
,
,
0 &
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]);
#
@
<#8
K
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);
}
}
"
##!
'
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());
}
}
?
,
0 &
KD
'
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[pessoa].toString );
}
}
q r
q#r
q r
- ?
+'
#
<
"0
Grupo:
"
q/r
2 D
5 6
1
3
"
)
8
"3
K
'
import Le;
"
##+
{
//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);
"
##9
<
0?
0
'
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;
}
}
0?
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
Vector 0 6
)
Vector , D
H 03 '
6
F
0
Vector
F
)
package java.util
0 &
),
0
4
'-
&
K
0
H K
)
D
ObjectK
0 &
'C
D
'
9.6.2 - Alguns mtodos da classe Vector

!
"
Vector ( )
void addElement (Object obj)
$
-
) 6
F
)
void insertelementAt (Object obj, int index)
Object remove ( int index)
Boolean removeElement (Object obj)
4
0
)
0
)
F
&
F
void removeElementAt( int index)
void clear ( )
Boolean contains (Object obj)
int indexOf (Object obj)
*
*
*
'
F
)
0
)
4
)
"
4
0
'*
3
Object elementAt (int index)
F
F
'
@ F
0
Booleam isEmpty ( )
int size ( )
<
"
*
*
)
F
K
) K) 0
) ) 6
Vector D
D
6
"
2 ) '
"
'
4
'
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
*/

3
'# G
)
3
-
')
)
0
)
)
)
) 4)
)
,
, D
'
,
'
E
static double produto(int [ ] x)

3
-
'/
,
, D
'
static double min(double [ ] x)

3 '
"3
,
D &
3 '!
,
, D
D
'
'+
'9
&
'-
E
) :
n)
D &
K H
$;
'
) )
'-
, D
static int procuraTabela (double v, double[ ] tabDouble)

3
'.
8
,
'
, D
'
'>
A
'@
static int substituicao(char c1, char c2, char[ ] tabCar)

3
'#
)
&
D
)
) )
)
&
'
"3
"
'##
'#
D
D
-' 3
4
3
'#/
'
-K
E
- R : # / + 9 . ;K
0
R : / ! ;'
;D
'
3
'#
n
D &
3
; D
&
'
'#!
D &
n )
D &
D &
K0 6
0 D &
D &
'
R#
D &
E /' .'# '! /' 9' .'# /' +'/ 9' /'
4 E
<
5 D
/'
.'#
'! #
9'
+'/ #
3 '#+
X
)
"3
3
'
'
A
,
D
q rqFrR3 q rSZ qFrK
'#9
0
"
Z
6 '-
D
6
'
,E
static double[][] productoExterno(double[] x, double[] y)

3
:
3
'#.
;0 6
' #>
D
'$
6 K
0
'
1
*
'
D
&
'
D
= 0
*
)
6
'
E
3
D )
"
_
)
0
D
<'
6
)
&
" K
K
D
_
D
"
3 E
"
# /
'
D
! V'
"
,
6
"
' # $
0D
"
,
E #K K/K
)"
!;
K$
:-K% K$
0
)
?
'@
# -
6
,
@
K
4
"
"3
)
K
6
A E
#! =
'
'
'
'
0
;' $
#-
'
D
)
K
4
4
'
D
3
/ 6
:D
'
E #- #% K
'- ?
'
"
10 - Algoritmos de Procura/Pesquisa
10.1 - Introduo
-
0
"
,
,
D
" '
0
H
0?
'
E
'
,0 D
0 6
8
K
'=
': #
;D
= ; D
# '@ ?
H
,
E
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
C
$
<
E
$
$
*
'
)
'
,
0
K
'
D
)
9! :
'
'
"
# !
9!
>
9!
# s
9!
9!
9! s
@ )
@ ?3
# ;
'
6
D
K
H
D
:
'
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));
}
}
"
# +
"
#' <
K
while (i < tab.length && tab[ i ] != valor ) {
0
) 0
) 0
E
)
0
0
0
) 0
)
'
"
'
10.2.2 - Com Sentinela

C
6
,
)
D
)
'-
&
K
0
K,
K
'
'
K
# ;
D
H
'C
'<
'
<
D
K
'
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];

System.out.println("Resultado:"+procura(tab,67));
"
# 9
System.out.println("Resultado:"+procura(tab,102);
}
}
10.3 - Procura Binria

-
'
"
'
)
6K
,
#'
'
/'
"
E
'
#b
'
D
,
D
*
'
!'
#b
b
#b
'
D
+'
9'
.'
#b
?3
'
"
'
D
3
'
0
<
'
#b
'
&#
'
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));
(tabela,33));
(tabela,1));
(tabela,101));
}
}
M3
baixo
#b
alto
baixo meio
Valor a Procurar
5
7
(>x)
3
3
(>x)
baixo meio alto
3
1
(<x)
/b
baixo alto
b
@ )
5
9'
"
3
3
'
public static int procuraBinaria (int tab[], int valor)

{
boolean achou = false;
int alto = tab.length - 1;
"
# >
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);
}
M3
meio
baixo
#b
5
7
(>x)
alto
baixo meio
Valor a Procurar
alto
3
3
(>x)
baixo meio alto
3
1
(<x)
/b
@ )
5
.'
"
# 3

3
'#
D
'
,
"3
3' C
'
D
5' -
"
#/
public static int minimo(float[ ] tabF).

3
'/
$ 'C
,
6
$ D
" '-
&
,
,E
public static int procuraCar(car[ ] tabCar, car c1)

3
#'
'
/'
3
'
& E
0
D
I
& 'I
)
0
'!
3
,
G#'
3' $
,
'
)K D
public static int procuraInteiro(int[] v, int x, int s)

'+ C
H
,
D
C 6
'[
K
"
)
)
0
,
-
,
"
'
'
L S gM
,E
public static boolean procuraPessoa(String[ ] v)
"
#/#
11 - Algoritmos de Ordenao
11.1 - Introduo
C
,
0?
'
6
#
'
0
K )
'
'
A
0
0
)
D
"3
D &
F
'@
<
$
0
D
'
0
;D
0
K
K )
E
'
'
'
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
E
K
D
<
-,D
'
H F
'
'
F
@
'
"
'
/
#9
##
) ")
H )
'
R0
. #9 / ##
. #9 / ##
. / #9 ## :
. / ## #9 :
. / ## #9 :
R0
. / ## #9
/ . ## #9 :
/ . ## #9
/ . ## #9 :
/ . ## #9
R0
/ . ## #9 :
/ . ## #9
/
. ## #9 :
/
. ## #9
/
. ## #9
R
R
R
;
;
;
I
/
/
R0
. ## #9
. ## #9 :
"
#//
/
/
/
. ## #9
. ## #9
. ## #9
I
/
/
/
/
/
R0
. ## #9 :
. ## #9
. ## #9
. ## #9
. ## #9
3
/
/
/
/
/
R0
. ## #9
. ## #9
. ## #9
. ## #9
. ## #9
RR 0
G
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);
f
Tabela.preenche(tabela); //preenche tabela
Tabela.imprime(tabela); //imprime tabela antes da
bubbleSort(tabela);
ordenao
//ordena tabela
Tabela.imprime(tabela); //imprime tabela depois de ordenada

}
}
"
#/
11.3 - ShellSort
-
,
F
$
- ?
K
)
'
K
,D
<
'
'
)
F #:
0
;'
"
D
F"
F
'
$
.
= F
#9
E
!
##
K
H )
) ")
) ")
0
D
8
'
#
R/
R5
% . #9 E ## :
/ Q #9 ""
/ . $ ## "P :
)
R
R
;
;
R/
R5
% . E ## #9
/Q
"" #9
/ . $ ## "P
/
R#
R5
/.
## #9
/ $ Q ## #9 :
/ E Q ## #9 :
/
. ## #9
/
. ## #9
)
"
#/!
)
$%
/
/
/
/
R#
R5
. ## #9 :
. ## #9
. ## #9
. ## #9
. ## #9
!
)
/
/
/
/
/
@
R#
R5
. ## #9
. ## #9
. ## #9
. ## #9
. ## #9
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);
}
Tabela.imprime(tabela); //imprime tabela antes da ordenao
shell(tabela);
//ordena tabela
"
#/+

}
}
11.4 - Ordenao por seleco

-
E
o
o
o
$
< #b
< b
'
'
)
D
#
.
= F
'
3
/
#9
E
!
##
E
3
% . #9 E ##
$ . #9 ## %
ME Q "P % "" $N
)
$ . #9 ## /
$ E #9 Q ## /
$ % #9 . ## E
M$ Q "P E "" %N
M$ % "P Q "" EN
$ % Q "P ##
$ % E #9 ## Q
J
$ % E "" "P .
$ % E Q #9 ""
M$ % E "P "" QN
J
$ % E Q "" "P
M$ % E Q "P ""N
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);
}
"
#/9

Tabela.imprime(tabela); //imprime tabela antes da ordenao
seleccao(tabela);
//ordena tabela

}
}
11.5 - Algoritmo QuickSort

[
o
o
"
:3 ;
) ,
'
D
)
F
F 3
:) 6
:) 6
@
'
)
:3 R )q B r;'
0
6 R :4
#`
6 F R # :4
FK 0 6 E
D
)q r U 3 :,
D
)qFr X 3 :,
FK
)q r
@
FU ;
@
X #;
) '
) '
"
;'
) ;
: D
@
@
@
: H
)
)
:
:
;'
;'
#;K
F ;K
3 ; , )q rK '''K )qFr
)
)
)qFrK
3 ; , )q rK '''K )q #r
S
,
-
'
M
D
"
D &
6
'
, D
"
D &
78
"
#/.
'
x=4
:/'#T/' ;
F
8
6U
:/'/;
:/'/;
F
3
4
F
:/'#T/' ;
3
5
F
:/'/;
3
>'
@

Tabela.imprime(tabela);
//preenche tabela
//imprime tabela antes da ordenao
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++;
"
#/>
}
while (k < tabela.length);
}

3
'#
%
3
'
'C
3
'/
;
'
'
'!
#'
'
/' @
' -
D E
?) :(
'+
'C
"
:
'
'`
'
'
)
F K
D
K
6
;'
,
"
'
:
F
K
-
F K
0 6
0
H K
F K)
K 6 K)
H K
F
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
atravs de
* @verso
* @autor:
*/
simples para ler dados de entrada (pela entrada padro ou

uma janela grfica.
2 - 20 Jan 2002
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
InputStreamReader(System.in), 1);
in
new
BufferedReader(new
"
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
private
private
private
private
boolean
int
String
Frame
TextField
valid;
value;
msg;
window;
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
private
private
private
private
boolean
double
String
Frame
TextField
valid;
value;
msg;
window;
valueArea;
"
# +
13 - Anexo II Glossrio
"
)
"
8
E
0 ,
'
E$ F
E 3
#
F KD
'
'
0
0
'
3
K
"
;'
B& E $
E $?
'
'
( E*
'
# E$
'
?
6 ?
0
E
'
! (
B'
?
,
E (
D
") '
")
'
D
E$
04
'< D
K
E1
'@
K
0
, )
E $?
) )
'
) ")
'*
3
'
0
K
'
'
'
'
';
4)
'
-
'
,
E<
0
E(
0
4
"
'$
3
D
"
)
?
0
2 )
)
)
),
"D
'-
0_
)
?
2 )
'
0
K
o(1
K
0
)
'
3
0
E % <5
)
K
'
"
# 9
<
) )
)
E 0
K
'
0
D
D
K,
( E
H
),
A
H
4)
D
,
K
3
H
"D
:
A
H
4
'
'
<
)
04
H )
'
H
E
)
%
'
'*
")
?
;
'
"
'
) #
E
2 ) ;K
,
D
F
D
,
F
'
B! H E $
0
D
4)
4)
K
F K
'
"
# .
14 - Anexo III - Bibliografia

5
2 )
H 2 )
-
0_
2 ) G- ? (
K2 H 1 _ K^
Z
2 ) G
$ H K 5$C 6
K ) (
1
G\ K2
7
)
B # ,
/B
K(
K( 7 _ ]
'-
,(
K 5$-
"
# >

Sebenta Introdução À Programação

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Sebenta Introdução À Programação

Enviado por

Direitos autorais:

Formatos disponíveis

#

Conceitos Bsicos de Cincias da Computao

1.2 - Resoluo de Problemas

1.2.1 - Resoluo de Problemas num Computador

1.2.2 - Tcnicas de Descrio de Algoritmos

1.2.3 - Criao de Algoritmos

1.3 - Do Algoritmo ao Programa

111 = 1*22 + 1*21 + 1*20 = 7

1.3.2 - Componentes de um Computador

1.4 - Linguagens de Programao

1.4.1 - Traduo de Linguagens de Programao

1.5 - A Linguagem Java

1.5.1 - Compilar um Programa em Java

1.6 - Exerccios Prticos

2.4 - Erros Sintcticos e Erros Semnticos

2.5 - Definio de Gramticas (Sintaxes)

2.6 - Notao BNF

<F> ::= <SN><SV>

::= <digito binrio> |

<inteiro>::= <nmero > | + <nmero > | - <nmero >

2.7 - Diagramas Sintcticos

Diagrama sintctico para a Frase (F):

Diagrama sintctico para o sintagma nominal (SN):

Diagrama sintctico para o sintagma verbal (SV):

2.8 - Exerccios Prticos

<Bum> <Dum+> <Bum> | <Dum+> <Bum>

<confuso> | <confuso> ; else <Expresso> ;

<B> ) 2 ( <C> ) 3 ( <C> ) | 1 ( <B> ) 2 <C>

<Seleco> ::= Switch ( <Expresso> ) { <Lista> } ;

<ins> ::= <ins1> | <ins1> ; <ins>

1)begin a;b; a end

Conceitos Bsicos de Programao

3.1 - Estrutura de um Programa

PUBLIC STATIC VOID

comea por dgito

3.3 - Palavras Reservadas

3.4 - Smbolos e Valores

int num = 145;

3.6 - Declarao e Inicializao

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

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

<declarao com inicializao vars> ::= <modificadores> <tipo>

int nomeDaVar; // declarao

final int MIN_TEMP = -10;

final <tipo> <nome_var> ou

final double PREVISAO_VENDAS = 350000.0;

<declarao constantes> ::= <constante> |

3.8 - Tipos de Dados

E byte, short, int, long

3 E !' K # '/ K ' K !'.K # ' K !'+

4 bytes (32 bits)

8 bytes (64 bits)

// 'a' 'X' '7' '$' ',' '\n'

boolean terminado = false;

3.8.5 - Operadores Lgicos

3.8.6 - Operadores Relacionais

<bloco de instrues> ::= { <instrues> }

// formato utilizado para comentrios no final da linha

3.11 - Paragrafao / Indentao

3.12 - Um programa em Java

public class PrimeiroPrograma {

System.out.println(Ol+nome+bom trabalho para a disciplina de

3.13 - Exerccios Prticos

111 = 122 + 121 + 1*20 = 7