Você está na página 1de 55

| 



  

 

 

÷  
 !
| 

  
|||
@    

p  


      p 


     

p    p

    p

    p

     p

     
    p

 p    
    p
J
| 

  


á  


á 

 
 


 



 

 
á
 !"
!
#
#

G
| 

  

á $ 


á%á%  

 &
%


á
á
#


  
áá

   

#

 

  
á'á

   

#
((((((((((( $)* *+",-)
º
| 

  



 

  
á.á

   

#


/  



 
á
 0)  
10  

#

#223 $ 


| 

  



Ex.1:
á  
4

á 

 
 

 




 

 
á
 !" !
#
#

l À :
Na linha:
p  p 
 

estamos fazendo uma coersão de dados (͞Ô ±  de forma que a variável soma
assuma que é do tipo byte.
À motivo: os computadores modernos fazem todas as operações de números
inteiros com precisão de 32 ou 64 bits e não com precisão de 8 bits. Com isso
todas as atribuições de valores a variáveis do tipo byte devem ser convertidas para

esse tipo.
| 

  



l Ex.2:

á $ 

á%á%  

 &
%


á
á
#


  

áá

   

#

 

  

á'á

   
#
u
| 

  



 

  

á.á

   
#

/  



 
á
 0)  
10  

#
#
á 5 á
á 

 
 

$ 6 7$ 
6  &
%
8
6 
6 
/  

#
#
Œ
| 

  


l 


uporta números de 16 bits.
As mesmas regras aplicadas ao tipo byte se aplicam ao tipo short. As atribuições de
valores a variáveis do tipo short sempre devem ser convertidas para esse tipo de
dado.

Ex.:
á  
9

á 

 
 
9
 
9

9
9
 

 
á
 !" !
#
#


| 

  

!"

l 
#

uporta números de 64 bits.
Deve ser utilizado o literal ͞L± para informar ao compilador que se trata de um tipo
long caso contrário ele tentará atribuir o valor a um tipo int como um valor do
tipo long pode extrapolar os limites do tipo de dado int um erro de compilação
será assinalado.
Ex.:

á  
: 
á 

 
 
  ;;;;;;;;;;;:
 :
  

 
á
 !" !
#
#
!
| 

  
$!|
l 
%#


À tipo float armazena números de ponto flutuante em 32 bits.


Devemos utilizar um literal float ͞F±.

Em java atribuições de valores de ponto flutuante assumem o tipo de dado 


&#
como padrão.

l Ex.:
á  
<

á 

 
 
3
 = ><
3
8 ><
3
 

 
á
 !" !
#
#
!!
| 

  

'(!
l 

&#
À tipo double armazena números de ponto flutuante em 64 bits.
À tipo double é o tipo padrão em java para atribuições de valores em ponto
flutuante desta forma as linhas:

double um = 6.5;
double dois= 3.5D;

estão corretas. Como double é o tipo padrão costuma-se omitir o sufixo ͞D±.
Ex.:
á  
?  
á 

 
 
   = >
  8 >
   

 
á
 !" !
#
!J
#
| 

  

'(!
l uponha o código:
á  
?  
á 

 
 
3
 = ><
3
8 ><
   

 
á
 !" !
#
#

l À código seria compilado corretamente?


l empre podemos atribuir uma variável de menor capacidade a uma variável de
capacidade maior. Então o código acima seria executado sem nenhum problema.

!G
| 

  

)|
l 

Armazena valores sem sinal em 16 bits. Podemos representar dados de caracteres.


Às valores do tipo char devem ser expressos em aspas simples.

Ex.:
á  
$9
á 

 
 
9 @"A
9@4A

 
á
 !)   !

#
#


| 

  

"

l 
 
Ouando você trabalha com string de caracteres em Java você utiliza as
instâncias da classe 2.

Ouando Java encontra uma string literal em aspas cria automaticamente um


objeto tring.
As declarações podem ser implícitas ou explícitas:

Ex.:

   !BC22 DEáF

)+

    7
 !BC22$ 
Gá

 6

22
& á  7

!
| 

  

"

l ignifica que Java trata uma string de caracteres literal como um objeto tring o
que significa que podemos utilizar os métodos da classe tring como:

a) l
) : è    


!HE BC  
9

p) cca
p S
  ) :$ 
  
 


 %
!"4$C
!IJKC

 8  
22 

L 

225 
1 
&
22á 
22
 8!!

!
| 

  

 
als p S
  ) :       


 %
!"4$C
!"4$?MC
3 N 

 
á
 !"
 E OC
M

 
á
 !"
 E3 
OC

alsI as p S
  ) :         !  
!  


   !H)")C

   !6EC
3   N    $   

 
á
 !"
 E OC
M

 
á
 !"
 E3 
OC
!u
| 

  

"

?
?         ??    ?
     

   !< 
C

 
á
     G)3!C22 G 
áDE;

22  E 
 G .
3  
?         ?
  ?      

   !C

 
á
   
 G)3!C22 G 
áDE8

22  E 
 G .
  ? 
?    ??   ?

 +/:9

á:22777  3
á 

 
á
 +/: 

P
9!9

áC22
á 
 !Œ
| 

  

"

9 ? 


?    ??   ?


 +/:9

á:22777  3
á 23 9


 
á
 +/: P
9!9
C22
á 


  ?  ?? ?   !     ?


 ?? ?      ?
? 


 
   )3;22
 3 
22
  
 

!
| 

  
)
 
& 
*
 

l   + ,
*  - ó Converte um objeto tring para um tipo
primitivo int.
Ex.: int num = Integer.parseInt(͞100± ;

l (+ (,
*  - ó Converte um objeto tring para um tipo
primitivo byte.

l 
+ 
,
*  - ó Converte um objeto tring para um tipo
primitivo short.

l $#
+ $#
,
*  - ó Converte um objeto tring para um tipo
primitivo float.

l 
&#+ 
&#,
*  - ó Converte um objeto tring para um tipo
primitivo double.

J
| 

  
)
 
& 
*
 

l Passo 1: Recebendo dois valores do tipo tring passados como parâmetro


no método main:

á : Q
á 

 
 

 

 

 
á
 0)á   
:00)    :
0

 
á
 0"  
:0
#
#

J!
| 

  
)
 
& 
*
 

l Passo 2: Transformando os dois valores do tipo tring em valores do tipo


inteiro:

á : Q
á 

 
 


  á



  á




 
á
 0)á   
:00)    :
0

 
á
 0"  :0
#
#

JJ
| 

  
)
 
& 
*
 

l À :
l 1 Para executar a classe LeiaValor e LeiaValor2 é necessário que sejam
passados os parâmetros args[0] e args[1] solicitados pelo método main no
momento da chamada da classe.

l Ex.:

]
args[1]
args[0]

]

JG
| 

  
)
 
& 
*
 

l Trabalho 01:

1 Fazer:
Crie uma classe Gato e uma classe Cachorro.
Inicialize a idade do Gato.
Inicialize a idade do Cachorro.
Uma ação efetuada pelo Gato é imprimir na tela (͞ou um gato minha idade é ±idadeDoGato
Uma ação efetuada pelo Cachorro é imprimir na tela (͞ou um cachorro minha idade
é±idadeDoCachorro
Crie um objeto Gato um objeto Cachorro.
À gato deve ter 2 anos e o cachorro 4 anos.
Imprima na tela do computador a idade do gato e do cachorro.


| 

  
)
 
& 
*
 

2 Fazer:

Transforme o modelo RegistroAluno numa classe.


Escreva uma outra classe DemoRegAluno aonde você crie dois objetos do tipo RegistroAluno:
. " 
 B

 8;

 
282RS>
. " 
 <

 8;

 
822RTR
 N á  1
    E
á 
á    
 / 
" 
 
  ?" %   B
 

J
| 

  
)
 
& 
*
 


? *
%14
% ? B
F 
á DE
 &/ 
* %B
F %?
%
4%N " 
 
 ?" * 
L ? B
F B
F 

? *
?

14

4
 ? B
F N " 
3
á DE B  22  
 
 
 
  ;
 14
    2

   
3

J
| 

  
)
 
& 
*
 

á DE
/ 
22
 

U
 
á !* " C
á   ?" 
á !* ?B
 C
á   ?B
 
á !?
 *
C

? *
 
?

 14
  á !) 1

C
 Eá !  E1
C
á !"  B
F :C
á  ? B
F 
33

Ju
| 

  
 


l  
'. 

ad sc 

ÎÎ  

""  

l ão aqueles que trabalham com apenas


um elemento.


| 

  
 


l Incremento:
l i : Avalia o valo de i e depois o incrementa em uma unidade.
l Ex.:
á  G á
á 

 
 

>



 
á
 0"0


 
á
 0" 
   
"0
#
#22> =
l i : Incrementa o valor de i em uma unidade e depois o avalia.

J
| 

  
 


l Ex.:
á  G á
á 

 
 

>



 
á
 0"0


 
á
 0" 
   
"0
#
#22= =

G
| 

  
 


l Decremento:
l i-- : Avalia o valor de i e depois o decrementa em uma unidade.
l --i : Decrementa o valor de i em uma unidade e depois o avalia.
l Ex:
á  G á
á 

 
 

>


 
á
 0" 
   
"0
..

 
á
 0?    
"0
#
#

G!
| 

  
 


l  
. 


ad sc 

Î #

" $ p#

% &  #

' (

) è   ( 

GJ
| 

  
 


l Ex:
á  G á8
á 

 
 

 
á
 0>0>

 
á
 0>.0>.

 
á
 0>' ‰ "#>'

 
á
 0>20>2

 
á
 0>V0>V
#
#

GG
| 

  
 


l  
 # Ô
 
ad sc 

8 &  * 

+ &  * 

8 &  *    

+ &  *    

 

, 
#
l Dadas as variáveis verifique o valor de retorno
l a=5;
l b=2;


| 

  
 


l aior que
l 5>2
l retorno: verdadeiro
l enor que
l 5<2
l retorno: falso
l aior que ou igual a
l 5 >= 2
l retorno: verdadeiro
l enor que ou igual a
l 5<=2
l retorno: falso
l Igualdade
l 5= = 2
l retorno: falso
l Diferença
l 5 != 2
l retorno: verdadeiro

G
| 

  
 


l Ex.:
á  G á;
á 

 
 

>



 
á
 0W0W

 
á
 0X0X

 
á
 0W ‰ "#W

 
á
 0X0X

 
á
 00

 
á
 0O0O
#
#

G
| 

  
 


l (

# 

ad sc 
ff è 
     
   - . / 0

 1
è 
  p

 
è  (  p

(

22 è  (    


34    -3è.  / 0
 (1
è  (  p

(
è 
  p

 

, è   #   ( 


  3 p 
Gu
| 

  
 


l Ex.:
á  G á>
á 

 
 
  
  
>W
X>

 
á
 0"E  0

 
á
 0YY0YY

 
á
 0ZZ ‰ "#ZZ
#
#


| 

  
 


l  
  & 

ad sc 


p   ( 
Î p   ( 5    " 
(  / 
/  Î 1
''  Î 1
" p   ( 5 p " 
(  / 
/  " 1
''  " 1
% p   ( 5    "
 (  / 
/
/  % 1
''  % 1 G
| 

  
 


ad sc 


' p   ( 5 (
/   (  p 6 
/  ' 1
''  ' 1

) p   ( 5    


 (  (  /  
(  p 6 
/  ) 1
''  ) 1

º
| 

  
 


l Ex.:
á  G á=
á 

 
 



 
á
 0;  :0
;

 
á
 0  :0
;

 
á
 0.  : "#.

#
#

º!
| 

  
 


l  
 Ô. 

ad sc 

§ 7       
       
 

ºJ
| 

  
 


l upondo:
> 
W[0W  0:0W30

 :W  
l Ex.:
á  G áT
á 

 
 

>



 
W[0W  0:0W30

 
á
 
#
#

ºG
| 

  
 && )

#

l $/!
3 DE


#
 
3 DE


#  



 

#

ºº
| 

  
 && )

#

l Ex.:
á  G áS
á 

 
 

  9
 0 
0
3 9
 0MM0

 
á
 0 9
 

\ 
\0
 

 
á
 0 9
  E

\ 
\0#223  
#223  G áS

º
| 

  
 && )

#

l Ex.:
á  G áS
á 

 
 



.
3X

'.
3X
'.

 
á
 !) 21:!2
#


 
á
 !) 21:!2
#223  
#223  G áS

º
| 

  
 && )

#

l - Oual o valor retornado no exemplo08b?


l !/$
3 DE


#  3 DE


#  


#
l Ex.:
á  G áR
á 

 
 




3

ºu
| 

  
 && )

#


 
á
 !Q  OOC
 3

 
á  !Q  C
#  

 
á
 !Q E  
 C
#
#223  
#223  G áR
l Ex.:
á  G áR
á 

 
 




ºŒ
| 

  
 && )

#

á  G áR
á 

 
 




3


 
á
 !Q  OOC

 3

 
á
 0Q  0
 38

 
á
 0Q  80


 
á
 !Q E  
   8C

#223  
#223  G áR

º
| 

  
 && )

#

l 0)+++)|
7
9
 :

 :

 8:


  :

#

l Ex.:
á  G á
á 

 
 

.
7
9
 :


| 

  
 && )

#


 
á
 !)  !
 ]
 .:

 
á
 !)  !
 ]
 .S:

 
á
 !)  !
 ]
 3 
:

 
á
 !)  !
 ]
#2237
9
#
#

!
| 

  
 && )

#

l À :

l a Na estrutura switch quando a primeira coincidência é encontrada todas as coincidências


restantes também são consideradas válidas portanto temos que utilizar a instrução ͞break±
para forçar a saída da estrutura.

l b À case padrão (com rótulo default pode aparecer em qualquer posição da estrutura.
Entretando é normalmente colocado por último.

l c A expressão deve ser avaliada somente para valores do tipo byte short int ou char.

J
| 

  
 && )

#

l $
3^ ^  DE  
2  
 


#
l Ex.:
á  G á
á 

 
 
3
X

 
á
 !)  1!
#
#
#

G
| 

  
 && )

#

l 0!
79  DE
?

#
l Ex.:
á  G á
á 

 
 


79 X

 
á
 !)   !

#
#
#


| 

  
 && )

#

l 0!



#79  DE
l Ex.:
á  G á8
á 

 
 




 
á
 !)  1C

#79 X

#
#