Programação – JAVA Unidade 2 – Dados, Variáveis e Cálculos

Apresentação em tema: "Programação – JAVA Unidade 2 – Dados, Variáveis e Cálculos"— Transcrição da apresentação:

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, e 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 L 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= L; int miles =0, fur =0, feet=0;

7 Ponto Flutuante float (4 bytes) double (8 bytes)

8 Valores Ponto Flutuante
Literais ponto flutuante são double por default. Assim, 1.0 e 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 F são constantes literais do tipo float.

9 Valores muito grandes ou muito pequenos
A distância da Terra ao Sol é de kilômetros. Em Java poderíamos definir por: double sunDistance = 1.496E8; A massa de um elétron é gramas. Em Java poderíamos definir float eletronMass = 9E-28F;

10 Cálculos Aritméticos numFruit = numApples + numOranges;
numApples = numApples + 1; a = b = c = 777;

11 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.

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 Execute o programa acima e verifique
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 O compilador irá converter a expressão
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 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); }

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 ); 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 = three / two; // result = 2.5 result = (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 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"); }

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;
mask 0x i & 0x4 0x

44 Operadores Bitwise i = 0xFF09; var = i & 0x4;
mask 0x i & 0x4 0x

45 Operadores Bitwise i = 0xFF09; var = i | 0x4;
mask 0x i | 0x4 0xFF0D

46 Operadores Bitwise i = 0xFF07; i &= ~0x4; i 0xFF07 1111 1111 0000 0111
mask 0x ~mask 0xFFFB i=i & (~0x4) 0xFF

47 Operadores Bitwise a = 0xFF07; b = 0xABAD; a^b;
a 0xD00F b 0xABAD a^b 0x7BA a=a ^b 0x7BA

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 Prioridade e associatividade
dos operadores As regras de prioridade e de associatividade dos operadores são semelhantes ao C++. Todos os operadores binários, excepto os de afectação, são associativos à esquerda. A prioridade é a indicada na tabela.