Aula 2

Elementos básicos da síntaxe
Tipos de dados primitivos
Expressões e operadores
Estruturas de controle de fluxo

• Comandos em Java são separadas por um ponto-vírgula. É permitido colocar vários comandos sobre a mesma limha.
• Comandos são organizadas em blocos definidos por chaves {...}. 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> nomeDaVariahvel = <valor>;
  onde <tipo> representa um dos tipos primitivos (discutidos na próxima seção) e <valor> um valor adequado para este tipo. Repare a notação <...> utilizada nestas notas para indicar um elemento de código que deve ser substituido por uma palavra chave, ou um valor concreto. Existem valores "default" para os tipos primitivos.
• As variáveis associadas a objetos, que são referências aos mesmos, precisam ser declaradas. Os objetos por sua vez precisam ser criados. Declaração e criação podem sem realizadas por comandos separados:
  
     NomeDaClasse nomeDoObjeto;
     nomeDoObjeto = new NomeDaClasse();
  A primeira linha informa que a variável nomeDoObjeto vai designar um objeto que é uma instância da classe NomeDaClasse. A segunda linha cria um novo objeto pertencente àquela classe e atribui a este objeto a referência nomeDoObjeto. A parte NomeDaClasse() do comando é na verdade uma chamada ao método construtor da classe. Em muitos casos, este método pode receber parâmetros que são incluídos nas parénteses e servem para especificar a inicialização do objeto.
  As duas linhas acima podem ser combinadas numa só:
  
     NomeDaClasse nomeDoObjeto = new NomeDaClasse();
• O escopo de uma variável, ou seja a região do programa na qual ela está definida, é limitado ao bloco no qual ela foi declarada.

• Um comentário curto relativo a uma linha de código pode ser incluido no fim da linha, precedido de // :
  
     ... ; // Comentário sobre o comando ...
• Um comentário precedido de /* e seguido de */ pode ocupar várias linhas:
  
  /* Comentário maior,
  que pode ocupar várias linhas. */
  Obviamente, isto serve também para forçar o compilador a ignorar temporariamente um trecho de código.
• O JDK oferece um recurso para gerar automaticamente um arquivo HTML documentando uma classe. Comentários que forem precedidos de /** e seguidos de */ serão incluidos neste arquivo:
  
  /** Este comentário será incluído no arquivo HTML
  documentando a classe. */
  Para gerar a documentação relativa à(s) classe(s) cuja(s) fonte(s) estam no arquivo MeuPrograma.java, digita-se na linha de comando:

     javadoc MeuPrograma.java

• Há quatro tipos de inteiros em Java:

  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, mesmo com a coerção, 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.

• Há dois tipos, de precisão simples e de precisão dupla:

  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. De novo, mesmo com a coerção, 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.

• Note que Java não possui tipos primitivos representando números complexos. Não há recursos para lidar com números complexos nas bibliotecas fornecidas com o JDK, mas vários pacotes avulsos são disponíveis. Não sendo tipos primitivos, números complexos devem ser objetos em Java.

• Há um tipo primitivo que representa um caráter:

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

  Java utiliza o padrão de caráteres Unicode, que abrange os conjuntos de caráteres de muitas linguas.

• Um literal de caráter é especificado por um único caráter entre apóstrofes simples:
  
    char exemplo = 'a';
• Para caráteres de escape, usa-se a barra invertida:

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

• São variáveis lógicas que podem assumir os valores verdadeiro e falso:

  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.

• Os operadores aritméticos disponíveis em Java são:

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

• Note que Java não possui um operador específico para potência (tal como ** em FORTRAN). Para calcular uma potência, você deve usar o método pow da classe Math do pacote lang, ou seja, para calcular x^y, você escreve Math.pow(x, y), onde x e y são de tipo double, e o resultado também.

• 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

• São operadores que atuam sobre uma única variável numérica, aumentando ou diminuindo o seu valor de uma unidade:

  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

• Estes operadores atuam sobre valores numéricos e retornam valores booleanos, true (verdadeiro) ou false (falso):

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

• O operador == também serve para comparar outros tipos de dados, inclusive objetos.

• 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 for false ou vice-versa. Senão retorna false
  !	NÃO ("logical NOT")	!a	retorna true se a for false. Senão retorna false

• 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

• Para executar um comando sujeita a uma condição:
  
    if( <condição> ) <comando>;
  A variável ou expressão condição deve ser do tipo boolean. O comando é executado se condição possuir o valor true.

• Para executar vários comandos sujeitos a uma condição, coloca-se os comandos num bloco:
  
    if( <condição> ){
      <comando 1>;
      <comando 2>;
      <...
    }

• Para executar certos comandos caso uma condição for satisfeita, e outros comandos caso contrário:
  
    if( <condição> ){
      <comando 1>;
      <comando 2>;
    }
    else{
      <comando 3>;
      <comando 4>;
    }
  No este exemplo, comando 1 e comando 2 são executados se condição for true. Caso contrário, comando 3 e comando 4 são executados.

• O operador ?: pode ser utilizado em certos casos simples como um atalho para a estrutura if...else:
  
    <variável> = <condição> ? <valor 1> : <valor 2>;
  Aqui, <variável> recebe <valor 1> se <condição> for true e <valor 2> se <condição> for false.

• Escolhas múltiplas de comandos a serem executados, dependendo do valor de uma variável, podem ser implementadas da seguinte maneira:
  
    switch( <controle> ){
      case <valor 1>:
        <comando 1>;
        <comando 2>;
        break;
      case <valor 2>: case <valor 3>:
        <comando 3>;
        <comando 4>;
        break;
      case <valor 4>:
        ...
        break;
      default:
        <comando 5>;
    }
  O <controle> deve ser de tipo int ou char. Se ele assume o <valor 1>, <comando 1> e <comando 2> são executados. O comando break determina então a saida do bloco. Se o <controle> assume o <valor 2> ou o <valor 3>, <comando 3> e <comando 4> são executados. O comando break de novo determina a saida do bloco, etc. O <comando 5> é executado se o valor do <controle> é diferente de todos os valores listados.

• Para repetir um conjunto de instruções, controlando o número de repetições com um contador:
  
    for( int i = <iinicial>; i <= <ifinal>; i++ ){
      <comando 1>;
      <comando 2>;
    }
  Note a declaração int i do contador. O teste i <= <ifinal> é realizado antes de cada entrada no laço. O incremento i++ é realizado no fim de cada passagem pelo laço.

• Para repetir um conjunto de instruções enquanto uma certa condição for satisfeita:
  
    while( <condição> ){
      <comando 1>;
      <comando 2>;
    }
  Obviamente a <condição> deve ser do tipo boolean. Uma forma um pouco diferente é:
  
    do{
      <comando 1>;
      <comando 2>;
    }
    while( <condição> )
  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( <condição 1> ){
      <comando 1>;
      if( <condição 2> ) break;
      <comando 2>;
    }
  O laço é interrompido quando a <condição 2> assume o valor true.

• Para passar à iteração seguinte de um laço, usa-se o comando continue:
  
    for( int i = <inicial>; i <= <ifinal>; i++ ){
      <comando 1>;
      if( <condição 2> ) continue;
      <comando 2>;
    <}
  Se <condição 2> for true, o programa "pula por cima" do <comando 2> e passa à iteração seguinte.

• 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( <condição 1> ){
        <comando 1>;
        for( int i = <iinicial>; i <= <ifinal>; i++ ){
          if( <condição 2> ) break rohtulo;
          <comando 2>;
        }
      }
      <comando 3>;
    }
  Se <condição 2> for true, o programa sai do bloco rotulado, pulando por cima de <comando 2> e <comando 3>.
    rohtulo:{
      for( int k = <kinicial>; k <= <kfinal>; k++ ){
        <comando 1>;
        for( int i = <iinicial>; i <= <ifinal>; i++ ){
          if( <condição 2> ) continue rohtulo;
          <comando 2>;
        }
      }
    }
  Se <condição 2> for true, o programa sai de ambos os laços.