Aprenda + sobre JAVA

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

---

Elementos básicos da síntaxe

Comandos

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

Variáveis

• 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
  
  nomeDaVariahvel = ;
  onde representa um dos tipos primitivos (discutidos na próxima seção) e 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.

Comentários

• 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

---

Tipos de dados primitivos

Números inteiros

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

Números em ponto flutuante

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

Caráteres

• 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

Booleanos

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

---

Expressões e operadores

Uma expressão é uma instrução de realizar uma operação que produz um valor (valor de retorno). Operadores são símbolos especiais utilizados para operações matemáticas, atribuições, comparações e operações lógicas.

Operadores aritméticos

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

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

• 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

Operadores de comparação

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

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 for 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 um comando sujeita a uma condição:
  
  if( ) ;
  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( ){
  ;
  ;
  <...
  }
• Para executar certos comandos caso uma condição for satisfeita, e outros comandos caso contrário:
  
  if( ){
  ;
  ;
  }
  else{
  ;
  ;
  }
  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:
  
  = ? : ;
  Aqui, recebe se for true e se for false.

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

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 = ; i <= ; i++ ){
  ;
  ;
  }
  Note a declaração int i do contador. O teste i <= é 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( ){
  ;
  ;
  }
  Obviamente a deve ser do tipo boolean. Uma forma um pouco diferente é:
  
  do{
  ;
  ;
  }
  while( )
  A diferença é que a é 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( ){
  ;
  if( ) break;
  ;
  }
  O laço é interrompido quando a assume o valor true.

• Para passar à iteração seguinte de um laço, usa-se o comando continue:
  
  for( int i = ; i <= ; i++ ){
  ;
  if( ) continue;
  ;
  <}
  Se for true, o programa "pula por cima" do 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( ){
  ;
  for( int i = ; i <= ; i++ ){
  if( ) break rohtulo;
  ;
  }
  }
  ;
  }
  Se for true, o programa sai do bloco rotulado, pulando por cima de e .
  rohtulo:{
  for( int k = ; k <= ; k++ ){
  ;
  for( int i = ; i <= ; i++ ){
  if( ) continue rohtulo;
  ;
  }
  }
  }
  Se for true, o programa sai de ambos os laços.