Variáveis e operadores

A declaração de variáveis em Java é bastante simples. Se for um tipo primitivo o formato será:

  [final] tipo variavel [= valor];

Se for uma classe:


  [final] NomeDaClasse variavel [= New NomeDaClasse(param1, param2, ....)];

As declarações entre parênteses são opcionais. Vamos ver isto em uma classe real:

public class ExemploDeclaracaoVariaveis {


 public static void main(String[] args) {
  // ******** V A R I A V E I S
  int x, y; //declarando duas variáveis inteiras
  x = 1; //atribuindo valores a variáveis
  y = 2;


  float f = 0.0f; //ponto flutuante - PI


  double w = 1.0d; //ponto flutuante - dupla precisão
  
  //Existem duas maneiras de fazer conversões de tipos:
  //   1ª) Conversão implícita:
  // ocorre quando o tamanho da variável destino é maior 
  // que o tamanho da variável origem
  // ou o valor que está sendo atribuído pode ser atribuído
  double fAsDoubleImplicito = f;
  //   2ª) Conversão explícita:
  // declaramos o tipo de destino
  double fAsDoubleExplicito = (double) f; 
  // note a declaração do tipo entre parênteses




  char ch = 'a'; // letra a 
  String s = "Esta é uma string";


  // ********* C O N S T A N T E
  final float PI = 3.141516f; 
  // esta constante já existe em java.lang.Math.PI como static double



  System.out.println(f);
  System.out.println(w);
  System.out.println(fAsDoubleImplicito);
  System.out.println(fAsDoubleExplicito);
  System.out.println(ch);
  System.out.println(s);
  System.out.println(PI);

 }  
}

Compile e rode a classe para ver o resultado abaixo:

Em Java podemos realizar diversas operações. Vamos vê-las em uma classe também.


public class ExemploOperadores {   
   public static void main(String[] args) {


/*
 Operações aritméticas uniárias (aplicadas sobre uma única variável


 Op  Operação         Uso        Descrição  
 ++  Incremento  var++ / ++var  Retorna e adiciona / adiciona e retorna.  
 --  Decremento  var-- / --var  Retorna e subtrai / subtrai e retorna.   
 -   Negativo        -var       Inverte o sinal da variável   
 +   Positivo        +var       Não tem efeito. 
*/


    int x = 40;
    int y = 5;


    x++;
    y++;
    System.out.println("******** Operacoes aritmeticas sobre 1 variavel");
    System.out.println("Operador ++: x="+x+" - y="+y);
    System.out.println("Operador x--: (antes)  "+x--);
    System.out.println("Operador x--: (depois) "+x);
    y=-y;
    System.out.println("Operador -y: "+y);


/**
 Operações aritméticas sobre 2 variáveis


 Op  Operação      Uso    Descrição   
 +   Adição        x + y  Soma x com y.   
 -   Subtração     x - y  Subtrai y de x.   
 *   Multiplicação x * y  Multiplica x por y.   
 /   Divisão       x / y  Divide x por y.   
 %   Resto         x % y  Resto da divisão de x por y. 
**/


    System.out.println("******** Operacoes aritmeticas sobre 2 variaveis");
    System.out.println("x="+x+" y="+y);
    System.out.println("Operador x+y: " + (x+y));
    System.out.println("Operador x-y: " + (x-y));
    System.out.println("Operador x*y: " + (x*y));
    System.out.println("Operador x/y: " + (x/y));
    System.out.println("Operador x%y: " + (x%y));


/**


 Operações de lógica e relacionais


 Op        Operação             Uso            Descrição   
 >         Maior que            x > y          x maior que y.   
 >=        Maior ou igual a     x >= y         x maior ou igual a y.   
 <         Menor que            x < y          x menor que y  
 <=        Menor ou igual a     x <= y         x menor ou igual a y.   
 ==        Igual a              x == y         x igual a y.   
 !=        Diferente de         x != y         x diferente de y.   
 !         NÃO lógico (NOT)     !y             contrário de y.   
 &&        E lógico (AND)       x && y         x e y.   
 ||        OU lógico (OR)       x ||y          x ou y.   


**/


    System.out.println("******** Operacoes lógicas");
    System.out.println("x="+x+" y="+y);
    if (x > y) {
      System.out.println("x eh maior que y");
    }
    else
    {
      if (x < y) {
        System.out.println("x eh menor que y");
      }
      else {
        System.out.println("x é igual a y");
      }
    }


/**


 Operações sobre bits


 Op    Nome              Uso      Descrição   
 ~     Inversão          ~x       Inversão dos bits de x.   
 &     E lógico         x & y     AND bit a bit entre x e y.   
 |     OU lógico        x | y     OR bit a bit entre x e y.   
 ^     OU excl. lógico  x ^ y     XOR bit a bit entre x e y.   
 <<    Desloc. a esq.   x << y    Desloc. a dir os bits de x, y vezes.    
 >>    Desloc. a dir.   x >> y    Desloca a direita os bits de x, y vezes.   
 >>>   Desloc. a dir.   x >>> y   Preenche zero a esquerda de x, y vezes.


**/


    int b1 = 36;
    int b2 = 15;
    int b3 = 2;


    System.out.println("******** Operacoes sobre bits");
    System.out.println("b1 = "+Integer.toBinaryString(b1));
    System.out.println("b2 = "+Integer.toBinaryString(b2));
    System.out.println("b3 = "+Integer.toBinaryString(b3));
    System.out.println("~b2 = "+Integer.toBinaryString(~b2));
    System.out.println("b1 & b2 = "+Integer.toBinaryString(b1 & b2));
    System.out.println("b1 | b2 = "+Integer.toBinaryString(b1 | b2));
    System.out.println("b2<<b3 = "+Integer.toBinaryString(b2<<b3));
    System.out.println("b1>>b3 ="+Integer.toBinaryString(b1>>b3));


   }  
}


O resultado é

Faça variações deste programa colocando outras operações para comparar o resultado.

Se temos uma operação como " 1 + 1 * 2 " como sabemos o resultado? O Java possui uma ordem de precedência para execução das operações. Isto é, ele realiza primeiro a multiplicação e depois a soma, assim o resultado seria 3. A ordem precedência dos operadores é (no que as operações mais em cima ocorrem antes):

1. ++  --  +  -   !   (cast)  
2. * / %
3. + -
4. <<   >>    >>>  
5. <   >   <=     >=     instanceof  
6. == !=  
7. &  
8. ^  
9. |  
10. &&  
11. | |  
12. ?:  
13. =   *=    /=   %=    +=  -=   <<=    >>=   >>>=     &=     |=

É boa prática a utilização de parênteses, assim na nossa operação acima escreveríamos "1 + (1 * 2)" e não há erro de interpretação do ser humano.