Tipos Primitivos, estruturas de iteração e decisão.

Transcrição

1 Tipos Primitivos, estruturas de iteração e decisão. André Luis Meneses Silva andreluis.ms@gmail.com Agenda Tipos Primitivos de Dados Variáveis e Constantes es Comandos Condicionais Comandos de Repetição Comentários Classificação Lógico Numéricos Inteiros Numéricos Reais Caractere Valor padrão Para cada tipo há um valor padrão Lógico (false), Caractere (\u0000), Numéricos Inteiros (0) e Numéricos Reais (0.0) Lógico boolean valores: ou false (padrão) Não são inteiros e não podem ser tratados como tal Caractere Caracteres Unicode de \u0000 a \uffff Padrão de codificação de caracteres que resolve o problema de compatibilidade apresentado pelas demais (ASCII pt, ASCII en, EBCDIC, etc). Valor padrão \u0000 Delimitado por apóstrofo A ou \u0041 Numéricos Inteiros Tipo Tamanho Valor Mínimo Valor Máximo byte 8 bits short 16 bits int 32 bits long 64 bits

2 s byte b = 127; short s = 32767; int i = ; long l = L; Numéricos Reais Tipo Tamanho Valor Mínimo Valor Máximo float 32 bits E E+48 double 64 bits E E+308 Observação: Para definir valores long deve-se incluir l ou L após o número s float f1 = 0.0f; float f2 = 3.00e+8F; double d1 = 0.0; double d2 = 3.00E+8; Observação: Para definir valores float deve-se incluir f ou F após o número (poderia provocar perda de precisão pois o padrão é double) [ Variáveis ] Declaração de variáveis <tipo> <nome-da-variável> [=<valor-inicial>] Os identificadores são case-sensitives Uma variável pode ser declarada em qualquer parte de uma classe ou em qualquer lugar dentro de um método s: double valor; long x, y = 10, z = 100; boolean ok = false TiposPrimitivos [ Constantes ] Modificador final e valor inicial final <tipo> <nome-da-variável> [=<valor-inicial>] Costumam ser escritas com letras maiúsculas. Tarefas 2

3 Aritméticos + X + Y Soma X e Y X Y Subtrai Y de X * X * Y Multiplica X por Y 3 * 4 12 / X / Y Divide X por Y (retorna um inteiro se X e Y forem inteiros) % X % Y Resto da divisão de X por Y 5 / 2 5 / % 2 1 Lógicos && X && Y AND com curto-circuito (não avalia Y caso X seja false) & X & Y AND sem curto-circuito (sempre avalia X e Y) X Y OR com curto-circuito (não avalia Y caso X seja ) X Y OR sem curto-circuito (sempre avalia X e Y)!! X NOT Relacionais == X == Y Igual 2 == 5 3 == 3!= X!= Y Diferente 5!= 2 3!= 3 < X < Y Menor que 2 < 5 2 < 2 > X > Y Maior que 5 > 2 2 > 2 <= X <= Y Menor ou igual >= X >= Y Maior ou igual 2 <= 5 2 <= 2 5 >= 2 2 >= 2 false false false false Binários (32 bits) 8 = Comp de 1 = Comp de 2 = = >> X >> N shift binário para direita de X, N posições << X << N shift binário para esquerda de X, N posições >>> X >>> Y shift binário para direita de X, N posições (unsigned) 8 >> 2-8 >> 2 8 << 2-8 << 2 8 >>> 2-8 >>> Binários (continuação) & X & Y AND binário 1 & 32 4 & 15 X Y OR binário ^ X ^ Y XOR binário 5 ^ 6 3 ~ ~ X complemento binário ~ Atribuição Operado r = X = Y Atribui a X o valor de Y X = 2 += X += Y Atribui a X o valor de X + Y X = 7 -= X -= Y Atribui a X o valor de X Y X = 3 *= X *= Y Atribui a X o valor de X * Y X = 10 /= X /= Y Atribui a X o valor de X / Y X = 2 %= X %= Y Atribui a X o valor de X % Y X = 1 * Considere o valores de X e Y iguais a 5 e 2, respectivamente 3

4 Atribuição (continuação) Incremento e Decremento Operado r Equivalência &= X &= Y X = X & Y = X = Y X = X Y ^= X ^= Y X = X ^ Y <<= X <<= Y X = X << Y >>= X >>= Y X = X >> Y >>>= X >>>= Y X = X >>> Y ++ Pré-incremento ++ Pós-incremento -- Pré-decremento -- Pós-decremento ++X; X++; --Y Y-- * Considere o valor inicial de X a 2 Incrementa a variável antes de retornar o valor Incrementa a variável depois de retornar o valor Decrementa a variável antes de retornar o valor Incrementa a variável depois de retornar o valor Y = ++X X = 3 Y = 3 Y = X++ X = 3 Y = 2 Y = --X X = 1 Y = 1 Y = X-- X = 1 Y = 2 Ternário ou Condicional? X? Y:Z Quando a expressão antes do? É, retorna Y. Caso contrário, retorna Z X=(exp1)? S : N Y=(exp2)? S : N X = S Y = N * Considere exp1 uma expressão que retorna e exp2 uma que retorna false instanceof instanceof X instanceof Y Retorna quando X é uma instância da classe Y, ou é uma subclasse de Y. Quando Y é uma interface, retorna quando X é objeto cuja classe implementa a interface Y. Typecast Conversão explícita de um tipo em outro : <var-destino> = (tipo) <var-origem>; : double a = 10.5; byte i; i = (byte) a; // recebe o valor 10 Precedência dos operadores Precedênci a 1 type cast e operadores unários es (Type-cast),!, ~, +, -, ++, -- 2 multiplicativos *, /, % 3 aditivos +, - 4 shift <<, >>, >>> 5 relacional <, >, <=, >=, instanceof 6 Igualdade ==,!= 4

5 Precedência dos operadores (continuação) Precedênci a 7 AND binário 8 XOR binário es 9 OR binário 10 AND lógico && 11 OR lógico 12 condiciona l 13 atribuição =, +=, -=, *=, /=, %=, &=, =, ^=, <<=, >>=, >>>= & ^?: Servem para selecionar um ou mais comandos a executar a depender de um ou mais condições Java tem 2 tipos de comandos condicionais: if e switch Semelhantes aos comandos disponíveis no C Comando if Forma mais simples if (expr) // Executado quando expr retorna Utilizando um bloco de comandos { } if (expr) { // Quando a expr retorna, os comandos que // estão entre { e } são executados comando1; comando2; } Forma completa if (expr) comando1; // Executado quando expr retorna else comando2; // Executado quando expr retorna false Ou expr?comando1:comando2; Utilizando um bloco de comandos { } if (expr) { comando1; // Executados quando expr comando2; // retorna } else { comando3; // Executados quando expr comando4; // retorna false } CalcularConceito Comando switch Avalia uma expressão que pode retornar valores dos tipos (byte, char, short, int e long). Com o resultado dessa expressão, verifica se há algum rótulo que seja igual ao valor retornado pela expressão. Caso haja, os comandos contidos no switch a partir deste rótulo serão executados até encontrar o comando break ou até chegar ao fim do switch, mesmo invadindo os comandos de outros rótulos. Se nenhum dos rótulos for igual ao valor da expressão, os comandos contidos em default serão executados. 5

6 do switch switch (expr) { case rotulo1: comando1; break; case rotulo2: comando2; break; default: comando3; break; } Java possui três tipos de laços: while do while for DiasNoMes Laço while O comando dentro do while é executado enquanto a expressão expr retorna : while (expr) : ImprimirMeses Laço do while O laço do while é muito parecido com o while. A única diferença é que faz o teste no final do laço. Os comandos dentro do laço são executados pelo menos uma vez : do while (expr); : ImprimirMeses2 Laço for É o mais genérico dos laços em Java : for (inicialização; testedetérmino; incremento) Os comandos contidos em inicialização (separados por vírgula) são executados uma única vez e no início do laço. A expressão em testedetérmino é executada antes de cada iteração e quando retornar false o laço se encerra. O incremento é executado após o final de cada iteração. Todos esses componentes são opcionais e é possível optar por usar apenas alguns deles, desde que sejam mantidos os caracteres ; entre eles. : ImprimirMeses3 6

7 Laços infinitos while () do while (); for (;;) Comando break Pode ser usado em switch, for, while e do while. Provoca a saída do laço ou switch mais interno no qual foi chamado. WhileBreak Às vezes temos que sair de mais de um laço quando executamos um break. A solução tradicional é ajustar uma variável antes de executar o break no laço mais interno, indicando que o laço mais externo também deve ser encerrado. Uma outra forma de resolver isso é através de comando break junto com um label. ForBreakLabel Comando continue Faz com que um laço continue na próxima iteração, ignorando o restante dos comandos dentro do laço. Ao contrário do break, não encerra a execução do laço. O comando continue também pode ser usado junto com o label, quando provoca o início da próxima iteração. DoWhileContinue [ Comentários ] Tipos de Comentários /* Estilo C padrão */ // Estilo C++ /** Especial para geração de Javadoc */ [ Exercícios ] 1) Escreva um programa que receba um parâmetro pela linha de comando e imprima as letras contidas no parâmetro em linhas separadas. O primeiro caractere deve ser impresso apenas uma vez na linha, o segundo duas vezes e assim por diante. Por exemplo, para um parâmetro igual a ABC, o resultado apresentado deve ser: A BB CCC 7

8 [ Bibliografia ] Deitel (capítulos 4 e 5) Core Java 2 Fundamentals (capítulo 3) 8