1 programação – java unidade 2 – dados, variáveis e cálculos prof. aparecido v. de freitas...
TRANSCRIPT
1
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
2
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).
3
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.
4
Tipos de dados inteiros
• byte (1 byte)• short (2 bytes)• int (4 bytes)• long (8 bytes)
5
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.
6
Exemplos
• long bigOne;
• long bigOne = 29999999L;
• long bigOne=99999L, largeOne= 10000000L;
• int miles =0,
fur =0,
feet=0;
7
Ponto Flutuante
• float (4 bytes)• double (8 bytes)
8
• 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.
Valores Ponto Flutuante
9
• 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;
Valores muito grandes ou muito pequenos
10
• numFruit = numApples + numOranges;
• numApples = numApples + 1;
• a = b = c = 777;
Cálculos Aritméticos
11
• 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.
Atribuições
12
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);
13
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
}
}
}
14
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.
15
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.
16
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.
17
Operador incremento e decremento
int x = 5;int y = 10;int z = 0;
z = ++x + y; // z = 16 , x = 6
18
Operador incremento e decremento
int x = 5;int y = 10;int z = 0;
z = x++ + y; // z = 15 , x = 6
19
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.
20
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 !!!
21
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 ? ? ?
22
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.
23
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.
24
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.
25
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);
}
}
Exemplo
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 + numApples) / fruitTypes;
System.out.println("A totally fruity program");
System.out.println("Average fruit is " + averageFruit);
}
}
27
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);
}
}
28
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.
29
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.
30
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.
31
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
32
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.
33
op=
count +=5; // count = count +5;
result /= a % b / (a+b);
/* result = result / (a%b(a+b);
34
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.
35
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");
}
}
Exemplo
36
Armazenando Caracteres
• Variáveis do tipo char armazenar um caractere simples.
• Cada caractere ocupa 16 bits, pois Java armazena em Unicode.
char myCaracter = 'x';
37
Caracteres Escape
• Forma alternativa de se especificar um caractere pelo seu código.
char myCaracter = '\u0058';
Código Unicode para a letra X
38
Caracteres Escape
• \b Backspace• \f Form Feed• \n New Line• \r Carriage Return• \t Tab
39
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
40
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.
41
Operadores Bitwise
& AND
| OR
^ OR EXCLUSIVE (XOR)
~ COMPLEMENT
42
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)
43
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
44
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
45
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
46
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
47
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
48
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
49
Variáveis Booleanas
boolean state = true;
boolean state = false;
50
Comentários
/*********************************
* Este eh um comentario *
* da Linguagem Java *
* para os alunos do Imes *
*********************************/
51
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
52
sufixos [] . (arg) ++ --prefixos ++ -- - + ~ ! tipo new (type)aritméticos {* / %} {+ -}shift >> << >>>relacionais > < >= <= instanceofigualdade == !=bit a bit {&} {^} {|}lógicos {&&} {||}ternários ?:afectação = += *= >>= etc.
Prioridade e associatividade dos operadores
• As regras de prioridade e de associatividade dos operadores sãosemelhantes ao C++.
• Todos os operadoresbinários, excepto osde afectação, sãoassociativos à esquerda.
• A prioridade é aindicada na tabela.