Programação – JAVA
Unidade 2 – Dados,
Variáveis e Cálculos
Prof. Aparecido V. de Freitas
Mestre e Doutorando em Engenharia
da Computação pela EPUSP
1
Nomes de Variáveis
• São os identificadores.
• Podem ser de qualquer tamanho.
• Devem começar com uma letra, ou underscore
(_) ou o sinal de dolar ($).
• O restante pode incluir quaisquer caracteres
exceto aqueles usados como operadores (+, -, *).
• Java é sensitive case.
• Não podem ser keywords (nomes que são
essenciais para a linguagem Java).
2
Tipos Primitivos
• São os tipos fundamentais.
• Em Java não são considerados classes,
apenas tipos básicos.
• Correspondem a byte, short, int, long,
float, double, char e boolean.
3
Tipos de dados inteiros
•
•
•
•
byte (1 byte)
short (2 bytes)
int (4 bytes)
long (8 bytes)
4
Valores Inteiros
• Literais inteiros são int por default.
• Assim, 1, -9999 e 123456789 são todos literais do
tipo int.
• Literais do tipo long, são definidos acrescentando-se
um L ao final do literal. Os valores 1L, -9999L e
123456789L são todos do tipo long.
• Não é permitido a definição de literais do tipo short
ou byte.
• Literais inteiros também podem ser definidos de
forma hexadecimal. Ex. 0x100, 0x1234, 0xCAB.
5
Exemplos
•
•
•
•
long bigOne;
long bigOne = 29999999L;
long bigOne=99999L, largeOne= 10000000L;
int miles =0,
fur =0,
feet=0;
6
Ponto Flutuante
• float
• double
(4 bytes)
(8 bytes)
7
Valores Ponto Flutuante
• Literais ponto flutuante são double por
default.
• Assim, 1.0 e 345.768 são ambos do tipo
double.
• Literais do tipo float são especificadas
acrescentando-se um F ao final do literal.
• Assim, 1.0F e 345.678F são constantes
literais do tipo float.
8
Valores muito grandes ou
muito pequenos
•
•
A distância da Terra ao Sol é de
149600000 kilômetros. Em Java
poderíamos definir por:
double sunDistance = 1.496E8;
A massa de um elétron é
0.0000000000000000000000000009
gramas. Em Java poderíamos definir
float eletronMass = 9E-28F;
9
Cálculos Aritméticos
•
•
•
numFruit = numApples + numOranges;
numApples = numApples + 1;
a = b = c = 777;
10
Atribuições
•
•
•
Atribuições de valores constantes para
variáveis do tipo byte ou short, causam
armazenamento da variável com o tipo à
esquerda do sinal de =.
Exemplo:
short value = 0;
value = 10;
Neste caso, 10 será armazenado numa
área de 2 bytes e em seguida será copiado
para a variável value.
11
Exemplo
import java.io.IOException;
// For code that delays ending the program
public class Exerc_03
{
public static void main(String[] args)
{
// Declare and initialize three variables
int numOranges = 5;
int numApples = 10;
int numFruit = 0;
// Increment oranges and calculate the total fruit
numFruit = ++numOranges + numApples;
System.out.println("A totally fruity program");
// Display the result
System.out.println("Value of oranges is " + numOranges);
System.out.println("Total fruit is " + numFruit);
12
Exemplo
// Code to delay ending the program
System.out.println("(press Enter to exit)");
try
{
System.in.read();
// Read some input from the keyboard
}
catch (IOException e)
// Catch the input exception
{
return;
// and just return
}
}
}
13
Produzindo saída
•
System.out.println(“....texto....”);
É um método do
objeto out
Variável static na classe System
Nome da classe que
contêm o objeto out
Como o objeto é static, ele existirá
mesmo se não houver objetos do
tipo System.
14
Resto e Divisão inteira
int numFruit = 0;
numFruitEach = numFruit / 4;
int remainder = 0;
remainder = numFruit % 4;
Ao dividirmos um inteiro por outro, o resto é descartado, de
forma que o resultado também sempre será um inteiro.
O operador modulus (%) deverá ser usado para se obter o resto.
15
Operador incremento e
decremento
int count = 10;
++count; // Add 1 to count
--count; // Subtract 1 from count
Uma grande vantagem dos operadores incremento e decremento é
que podemos usá-los em uma expressão.
16
Operador incremento e
decremento
int x = 5;
int y = 10;
int z = 0;
z = ++x + y; // z = 16 , x = 6
17
Operador incremento e
decremento
int x = 5;
int y = 10;
int z = 0;
z = x++ + y; // z = 15 , x = 6
18
Computação com inteiros
shorter
• O resultado de operações aritméticas do
tipo int são processadas em valores
inteiros de 32 bits.
• Expressões usando variáveis do tipo
short ou byte também são executadas da
mesma forma, ou seja o resultado será
expresso em inteiros de 32 bits.
19
Computação com inteiros
shorter
short x =5;
short y =10;
short z =0;
z = x + y;
Execute o programa acima e verifique
se o mesmo irá compilar !!!
20
Computação com inteiros
shorter
• No exercício anterior, como a
expressão x + y produz um resultado
de 32 bits, o compilador não irá
conseguir armazenar este valor em z,
uma vez que z tem 16 bits (short).
O que fazer então ? ? ?
21
Casting
short x =5;
short y =10;
short z =0;
z = short (x + y);
O compilador irá converter a expressão
aritmética para 16-bits.
22
Computação com inteiros long
• Uma operação aritmética envolvendo um
valor do tipo long sempre produzirá
resultados em 64-bits.
• Se algum outro valor na expressão não
for do tipo long, então ele será convertido
(casting) para long antes da operação.
23
Casting
long result =0;
long fator =10L;
int numero =5;
result = fator * numero;
Como a multiplicação produzirá resultado
em 64 bits, o valor armazenado em numero
será convertido para long.
24
Exemplo
public class AverageFruit
{
public static void main(String args[])
{
// Declare and initialize three variables
double numOranges = 50.0E-1;
double numApples = 1.0E1;
double averageFruit = 0.0;
averageFruit = (numOranges + numApples) / 2.0;
System.out.println("A totally fruity program");
System.out.println("Average fruit is " + averageFruit);
}
}
25
Exemplo
public class AverageFruit
{
public static void main(String args[])
{
// Declare and initialize three variables
double numOranges = 50.0E-1;
double numApples = 1.0E1;
double fruitTypes = 0.0;
double averageFruit = 0.0;
averageFruit = (numOranges + numApples) / fruitTypes;
System.out.println("A totally fruity program");
System.out.println("Average fruit is " + averageFruit);
}
}
26
Exemplo
public class AverageFruit
{
public static void main(String args[])
{
// Declare and initialize three variables
double numOranges = 50.0E-1;
double numApples = 1.0E1;
double fruitTypes = 0.0;
double averageFruit = 0.0;
averageFruit = (numOranges - 5.0)/(numApples - 10.0);
System.out.println("A totally fruity program");
System.out.println("Average fruit is " + averageFruit);
}
}
27
Operador % p/Ponto Flutuante
• Podemos aplicar o operador % para
valores em ponto flutuante.
• floatoper1 % floatoper2
• O resultado será o resto em ponto
flutuante após dividir floatoper1 por
floatoper2 num inteiro de vezes.
• Assim, a expressão 12.6 % 5.1 dará como
resultado 2.4.
28
Expressões aritméticas mistas
• As regras em seqüência devem ser checadas:
• Se algum operador for do tipo double, os
outros serão convertidos para double antes
da operação ser executada.
• Se algum operador for do tipo float, os outros
serão convertidos para float antes da
operação ser executada.
• Se algum operador for do tipo long, os outros
serão convertidos para long antes da
operação ser executada.
29
Expressões aritméticas mistas
• Se nenhum operando for do tipo double, float ou
long, eles devem ser do tipo int, short ou byte e
assim, utilização 32 bits para as operações
aritméticas.
30
Casting explícito
double result;
int three = 3;
int two = 2;
result = 1.5 + three / two; // result = 2.5
result = 1.5 + (double) (three/two); // result =3.0
Casting explícito
31
Casting automático
• Quando o tipo do resultado de uma expressão
do lado direito de uma atribuição for diferente do
tipo da variável à esquerda, um cast automático
será aplicado.
• Haverá a possibilidade de perda de informação.
• A seqüência aplicada será:
byte -> short -> int -> long -> float -> double
• Se você quiser ir em direção oposta, então um
cast explícito deverá ser aplicado.
32
op=
count +=5; // count = count +5;
result /= a % b / (a+b);
/* result = result / (a%b(a+b);
33
Funções matemáticas e
constantes
• Disponíveis no pacote java.lang e, portanto,
acessadas automaticamente pelo programa.
• Os métodos são implementados na classe
Math como métodos static, e portanto, podem
ser diretamente acessadas por Math.metodo.
• Exemplo: Math.sqrt(aNumero) para produzir o
valor em ponto flutuante da raiz quadrada de
aNumero.
34
Exemplo
public class Exerc_04
{
public static void main(String[] args)
{
// Calculate the radius of a circle
// which has an area of 100 square feet
double radius = 0.0;
double circleArea = 100.0;
int feet = 0;
int inches = 0;
radius = Math.sqrt(circleArea/Math.PI);
feet = (int)Math.floor(radius);
// Get the whole feet and nothing but the feet
inches = (int)Math.round(12.0*(radius - feet));
System.out.println("The radius of a circle with area " + circleArea +
" square feet is\n " + feet + " feet " + inches + " inches");
}
}
35
Armazenando Caracteres
• Variáveis do tipo char armazenar um
caractere simples.
• Cada caractere ocupa 16 bits, pois Java
armazena em Unicode.
char myCaracter = 'x';
36
Caracteres Escape
• Forma alternativa de se especificar um
caractere pelo seu código.
char myCaracter = '\u0058';
Código Unicode
para a letra X
37
Caracteres Escape
•
•
•
•
•
\b
\f
\n
\r
\t
Backspace
Form Feed
New Line
Carriage Return
Tab
38
Aritmética de Caracteres
• Podemos executar operações aritméticas com
variáveis do tipo char.
char var = 'X';
var+=1;
• O resultado em var será 'Y'.
• Podemos usar variáveis do tipo char em expressões
aritméticas, e seus valores serão convertidos para
tipo int.
char aChar = 0;
char bChar = '\u0028'
aChar = (char)(2 * bChar + 8); // aChar = 0x0058
39
Operações Bitwise
• Variáveis inteiras são representadas
internamente como números binários.
• Um valor do tipo int consiste de 32 dígitos
binários, conhecidos por bits.
• Podemos operar nos bits dos valores inteiros
usando os operadores bitwise.
40
Operadores Bitwise
&
|
^
~
AND
OR
OR EXCLUSIVE (XOR)
COMPLEMENT
41
Operadores Bitwise
&
|
^
~
AND (1 se ambos forem 1)
OR (0 se ambos forem 0)
XOR (0 se bits forem iguais)
COMPLEMENT (1 se 0; 0 se 1)
42
Operadores Bitwise
i = 0xFF07;
var = i & 0x4;
i
0xFF07
1111
1111
0000
0111
mask
0x4
0000
0000
0000
0100
i & 0x4
0x0004
0000
0000
0000
0100
43
Operadores Bitwise
i = 0xFF09;
var = i & 0x4;
i
0xFF09
1111
1111
0000
1001
mask
0x4
0000
0000
0000
0100
i & 0x4
0x0000
0000
0000
0000
0000
44
Operadores Bitwise
i = 0xFF09;
var = i | 0x4;
i
0xFF09
1111
1111
0000
1001
mask
0x4
0000
0000
0000
0100
i | 0x4
0xFF0D
1111
1111
0000
1101
45
Operadores Bitwise
i = 0xFF07;
i &= ~0x4;
i
0xFF07
1111
1111
0000
0111
mask
0x4
0000
0000
0000
0100
~mask
0xFFFB
1111
1111
1111
1011
i=i & (~0x4) 0xFF03
1111
1111
0000
0011
46
Operadores Bitwise
a = 0xFF07;
b = 0xABAD;
a^b;
a
0xD00F
1101
0000
0000
1111
b
0xABAD
1010
1011
1010
1101
a^b
0x7BA2
0111
1011
1010
0010
a=a ^b
0x7BA2
0111
1011
1010
0010
47
Operações de Shift
<<
Shift Left, preenche com zeros a partir da direita
>>
Shift Right, propaga bit de sinal a partir da esquerda
>>>
Shift Right,preenche com zeros a partir da esquerda
48
Variáveis Booleanas
boolean state = true;
boolean state = false;
49
Comentários
/*********************************
* Este eh um comentario *
* da Linguagem Java
*
* para os alunos do Imes *
*********************************/
50
Operadores são
semelhantes ao C++
• Aritméticos
– binários: +, -, *, / e %
(+ entre strings)
– unários: + e - e ainda os prefixos e sufixos ++, -• Relacionais:
>, <, ==, <=, >=, !=,instanceof
• Condicionais:
&&, ||, !, ?:
• Bit a bit:
>>, <<, &, |, ^, ~, >>>
• Afectação: =, +=, -=, *=, etc.
• Especiais: [], (param), ., new, (type)
• Mas não permite a sobrecarga de operadores
51
Prioridade e associatividade
dos operadores
• As regras de prioridade e de associatividade dos
sufixos
[] . (arg) ++
operadores são
prefixos
++ -- - + ~ !
semelhantes ao C++.
• Todos os operadores
binários, excepto os
de afectação, são
associativos à esquerda.
• A prioridade é a
indicada na tabela.
tipo
aritméticos
shift
relacionais
igualdade
bit a bit
lógicos
ternários
afectação
--
new (type)
{* / %} {+ -}
>> << >>>
> < >= <= instanceof
== !=
{&} {^} {|}
{&&} {||}
?:
= += *= >>= etc.
52