Aula 2

Elementos básicos da síntaxe

• Instruções em Java são separadas por um ponto-vírgula. É permitido colocar várias instruções sobre a mesma limha.
• Instruções são organizadas em blocos definidos por colchetes {...}. Em especial, classes e métodos são blocos. Blocos podem conter outros blocos.
• Nomes de variáveis devem começar com uma letra, um caráter de sublinhado _ ou um cifrão $. Não podem começar por um número. É convencional (mas não obrigatório) usar uma letra minúscula para a primeira letra do nome de uma variável.
• Todas as variáveis de tipos primitivos precisam ser declaradas e inicializadas, através de uma instrução da forma
  
  tipo variável = valor;
  
  Existem valores "default" para os tipos primitivos.
• As variáveis associadas a objetos precisam ser declaradas e os objetos criados, através de uma instrução da forma
  
  ClasseDoObjeto variável = new ClasseDoObjeto();
  
  Em muitos casos, parâmetros podem ser incluídos nas parénteses acima para especificar a inicialização do objeto.
• Comentários podem ser incluídos no código de três maneiras distintas:
  • Comentário curto relativo a uma linha de código:
    
    alguma instrução; // Comentário relativo a esta instrução

  • Comentário mais comprido, ocupando uma linha inteira ou várias linhas:
    
    /* Comentário maior
que pode ocupar várias linhas. */

  • Comentário a ser incluído no arquivo HTML documentando a classe construída pelo código:
    
    /** Este comentário será incluído no arquivo HTML
documentando a classe. */
    O arquivo HTML em questão é gerado pela ferramenta javadoc incluída no JDK, digitando-se na linha de comando do DOS:
    
    javadoc MeuPrograma.java

Tipos de dados primitivos

• Números inteiros

  Tipo	Tamanho	Valor
  byte	8 bits	-128 a 127
  short	16 bits	-32.768 a 32.767
  int	32 bits	-2.147.483.648 a 2.147.483.647
  long	64 bits	-9.223.372.036.854.775.808 a 9.223.372.036.854.775.807

  
  Um número inteiro pode sempre ser atribuído a outro de maior precisão:
  
  int a = 274;
long b = a;
  A operação inversa requer coerção explicita ("casting"):
  
  long a = 274;
int b = ( int ) a;
  Sem esta coerção, haverá erro de compilação. Note que ainda pode haver problema na execução, caso o valor do número atribuído ultrapassar o maior valor possível para o tipo em questão.

• Números em ponto flutuante

  Tipo	Tamanho	Valor
  float	32 bits	-3.40292347E+38 a +3.40292347E+38
  double	64 bits	-1.79769313486231570E+308 a +1.79769313486231570E+308

  
  Um número de precisão simples pode sempre ser atribuído a outro de precisão dupla:
  
  float a = 2.74F; // F (ou f) após o literal indica precisão simples
double b = a;
  A operação inversa requer coerção explicita:
  
  double a = 2.74e12;
float b = ( float ) a;
  Sem esta coerção, haverá erro de compilação. Note que ainda pode haver problema na execução, caso o valor do número de precisão dupla ultrapassar o maior valor possível para um número de precisão simples.

• Caráteres

  Tipo	Tamanho	Valor
  char	16 bits	'\u0000' a '\uFFFF'

  
  Java utiliza o padrão de caráteres Unicode. Um literal de caráter é especificado por um único caráter entre apóstrofes:
  
  char exemplo = 'a';

  Códigos de escape de caráter

  Escape	Significado
  \n	nova linha
  \t	tabulação
  \b	passo para trás
  \r	retorno do carro
  \\	barra invertida
  \'	apóstrofe
  \"	aspas

• Booleanos

  Tipo	Tamanho	Valor
  boolean	1 bit	true ou false

  
  Note que, em Java, estas variáveis não podem ser interpretadas como os números inteiros 0 e 1.

Expressões e operadores

• Operadores aritméticos

  Operador	Significado
  +	adição
  -	subtração
  *	multiplicação
  /	divisão
  %	resto da divisão (módulo)

• Operadores de atribuição

  Estes operadores são simplesmente uma notação compacta para uma operação aritmética seguida da atribuição do valor de retorno à variável que continha o primeiro termo da operação.

  Operador	Exemplo	Expressão equivalente
  +=	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

• Operadores de incremento e decremento

  Operador	Exemplo	Significado
  ++	++a	adicionar 1 à variável a e depois calcular a expressão na qual a reside
  	a++	calcular a expressão na qual a reside e depois adicionar 1 à variável a
  --	--a	subtrair 1 da variável a e depois calcular a expressão na qual a reside
  	a--	calcular a expressão na qual a reside e depois subtrair 1 da variável a

  Exemplo:
  
  int x = 5, y = 7; // x vale 5 e y vale 7
y += ++x; // x agora vale 5 + 1 = 6 e y vale 7 + 6 = 13
x -= y--; // x agora vale 6 - 13 = - 7 e y vale 13 - 1 = 12

• Operadores de comparação

  Estes operadores retornam valores booleanos, true ou false.

  Operador	Significado
  ==	igual a
  !=	diferente de
  <	menor que
  >	maior que
  <=	menor ou igual a
  >=	maior ou igual a

• Operadores lógicos

  Estes operadores atuam sobre valores booleanos e retornam valores booleanos, true ou false.

  Operador	Significado	Exemplo	Explicação
  &&	E ("logical AND")	a && b	retorna true se a e b forem ambos true. Senão retorna false. Se a for false, b não é avaliada.
  &	E ("boolean logical AND")	a & b	retorna true se a e b forem ambos true. Senão retorna false. Ambas expressões a e b são sempre avaliadas.
  ||	OU ("logical OR")	a || b	retorna true se a ou b for true. Senão retorna false. Se a for true, b não é avaliada.
  |	OU ("boolean logical inclusive OR")	a | b	retorna true se a ou b for true. Senão retorna false. Ambas expressões a e b são sempre avaliadas.
  ^	OU EXCLUSIVO ("boolean logical exclusive OR")	a ^ b	retorna true se a for true e b false ou vice-versa. Senão retorna false
  !	NÃO ("logical NOT")	!a	retorna true se a for false. Senão retorna false

• Precedência e associatividade dos operadores

  Os operadores estão listados na tabela abaixo em ordem decrescente de prioridade.

  Operador	Associatividade
  ()	da esquerda para a direita
  ++ -- + - !	unários; da direita para a esquerda
  * / %	da esquerda para a direita
  + -	da esquerda para a direita
  < <= > >=	da esquerda para a direita
  == !=	da esquerda para a direita
  &	da esquerda para a direita
  ^	da esquerda para a direita
  |	da esquerda para a direita
  &&	da esquerda para a direita
  ||	da esquerda para a direita
  = += -= *= /= %=	da direita para a esquerda

Estruturas de controle de fluxo

• Estruturas de seleção

  Para executar uma instrução sujeita a uma condição:
  
  if( a ) b; // a boolean, b uma instrução qualquer
  Para executar várias instruções sujeitas a uma condição:
  
  if( a )// a boolean
{
   b1; // b1 uma instrução qualquer
   b2; // b2 outra instrução qualquer
}
  Para executar certas instruções caso uma condição for satisfeita, e outras instruções caso contrário:
  
  if( a )// a boolean
{
   b1; // b1 uma instrução a ser realizada se a verdadeira
   b2; // b2 outra instrução a ser realizada se a verdadeira
}
else
{
   b3; // b3 uma instrução a ser realizada se a falsa
   b4; // b4 outra instrução a ser realizada se a falsa
}
  O operador ?: pode ser utilizado em certos casos simples como um atalho para a estrutura if...else:
  
  var = cond ? v1 : v2; // a variável recebe o valor v1 se cond for verdadeira
// e o valor v2 se cond for falsa
moda = a >= 0 ? a : -a; // exemplo
  Escolhas múltiplas de instruções a serem realizadas, dependendo do valor de uma variável, podem ser implementadas da seguinte maneira:
  
  switch( a ) // a inteiro ou caráter
{
   case a1: // a1 um valor constante do mesmo tipo que a
     b1; // instrução a ser realizada se a = a1
     bp1; // outra instrução a ser realizada se a = a1
     break; // cair fora
   case a2: // a2 um valor constante do mesmo tipo que a
     b2; // instrução a ser realizada se a = a2
     bp2; // outra instrução a ser realizada se a = a2
     break; // cair fora
...
   default:
     bd; // instrução a ser realizada se nenhum dos casos acima foi verdadeiro
     bpd; // outra instrução a ser realizada se nenhum dos casos acima foi verdadeiro
     break; // cair fora
}

• Estruturas de repetição (laços)

  Para repetir um conjunto de instruções, controlando o número de repetições com um contador
  
  for( int i = iini; i <= ifin; i++ ) // i é o contador
{
   a1; // instrução
   a2; // outra instrução
}
  Para repetir um conjunto de instruções enquanto uma certa condição for satisfeita:
  
  while( cond ) // cond boolean; o bloco a seguir é executado enquanto cond = true
{
   a1; // instrução
   a2; // outra instrução
}
  Uma forma um pouco diferente é:
  
  do
{
   a1; // instrução
   a2; // outra instrução
}
while( cond ) // cond boolean; o bloco acima é executado de novo se cond = true
  A diferença é que a condição é testada após a execução do bloco de instruções. Portanto, este bloco é executado no mínimo uma vez.
  
  Para interromper um laço, usa-se o comando break:
  
  while( cond )
{
   a1; // instrução
   if( outracond ) break; // interromper o laço se outracond = true
   a2; // outra instrução
}
  Para passar à iteração seguinte de um laço, usa-se o comando continue:
  
  for( int i = iini; i <= ifin; i++ )
{
   a1; // instrução
   if( outracond ) continue; // passar para a próxima iteração se outracond = true
   a2; // outra instrução
}
  Os comandos break e continue sem rótulos atuam sobre o laço mais interno no qual eles se encontram. No caso de laços aninhados, comandos rotulados podem ser utilizados para saltar para um laço mais externo:
  
  rohtulo:
{
   while( cond )
   {
     a1; // instrução
     for( int i = iini; i <= ifin; i++ )
     {
       if( outracond ) break rohtulo; // interromper o laço mais externo se
        // outracond = true
       a2; // outra instrução
     }
   }
   a3; //outra instrução
}
  rohtulo:
{
   for( int k = kini; k <= kfin; k++ )
  {
     a1; // instrução
     for( int i = iini; i <= ifin; i++ )
     {
       if( outracond ) continue rohtulo; // passo seguinte do laço mais externo
       // se outracond = true
       a2; // outra instrução
     }
   }
}