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

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

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.

Tipos de dados inteiros byte (1 byte) short (2 bytes) int (4 bytes) long (8 bytes)

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.

Exemplos long bigOne; long bigOne = 29999999L; long bigOne=99999L, largeOne= 10000000L; int miles =0, fur =0, feet=0;

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

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.

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;

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

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.

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);

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

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.

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.

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.

Operador incremento e decremento int x = 5; int y = 10; int z = 0; z = ++x + y; // z = 16 , x = 6

Operador incremento e decremento int x = 5; int y = 10; int z = 0; z = x++ + y; // z = 15 , x = 6

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.

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 !!!

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 ? ? ?

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.

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.

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.

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); }

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); }

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); }

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.

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.

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.

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

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.

op= count +=5; // count = count +5; result /= a % b / (a+b); /* result = result / (a%b(a+b);

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.

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"); }

Armazenando Caracteres Variáveis do tipo char armazenar um caractere simples. Cada caractere ocupa 16 bits, pois Java armazena em Unicode. char myCaracter = 'x';

Caracteres Escape Forma alternativa de se especificar um caractere pelo seu código. char myCaracter = '\u0058'; Código Unicode para a letra X

Caracteres Escape \b Backspace \f Form Feed \n New Line \r Carriage Return \t Tab

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

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.

Operadores Bitwise & AND | OR ^ OR EXCLUSIVE (XOR) ~ COMPLEMENT

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)

Operadores Bitwise i = 0xFF07; var = i & 0x4; mask 0x4 0000 0000 0000 0100 i & 0x4 0x0004 0000 0000 0000 0100

Operadores Bitwise i = 0xFF09; var = i & 0x4; mask 0x4 0000 0000 0000 0100 i & 0x4 0x0000 0000 0000 0000 0000

Operadores Bitwise i = 0xFF09; var = i | 0x4; mask 0x4 0000 0000 0000 0100 i | 0x4 0xFF0D 1111 1111 0000 1101

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

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

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

Variáveis Booleanas boolean state = true; boolean state = false;

Comentários /********************************* * Este eh um comentario * * da Linguagem Java * * para os alunos do Imes * *********************************/

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

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.