1 Programação – JAVA Unidade 2 – Dados, Variáveis e Cálculos Prof. Aparecido V. de Freitas...

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


int x = 5;int y = 10;int z = 0;

z = ++x + y; // z = 16 , x = 6

18


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


short x =5;

short y =10;

short z =0;

z = x + y;

Execute o programa acima e verifique se o mesmo irá compilar !!!

21


• 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[])

{


double numOranges = 50.0E-1;

double numApples = 1.0E1;

double averageFruit = 0.0;

averageFruit = (numOranges + numApples) / 2.0;


System.out.println("Average fruit is " + averageFruit);

}

}

Exemplo

26

Exemplo public class AverageFruit

{


{




double fruitTypes = 0.0;


averageFruit = (numOranges + numApples) / fruitTypes;



}

}

27

Exemplo public class AverageFruit

{


{




double fruitTypes = 0.0;


averageFruit = (numOranges - 5.0)/(numApples - 10.0);



}

}

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.

1 Programação – JAVA Unidade 2 – Dados, Variáveis e Cálculos Prof. Aparecido V. de Freitas...

Documents

Transcript of 1 Programação – JAVA Unidade 2 – Dados, Variáveis e Cálculos Prof. Aparecido V. de Freitas...