Operadores numéricos em Java

Oi! Hoje vamos considerar um tópico muito importante, ou seja, operadores numéricos em Java . Na programação, os números estão por toda parte. Se você se aprofundar e se lembrar do ensino médio, deve se lembrar de que um computador representa todas as informações em um formato numérico: combinações de zeros e uns, também conhecidas como código binário. Existem muitos operadores numéricos na programação, então usaremos exemplos para explorar os mais importantes deles :) Vamos começar com o mais simples: operadores aritméticos . Estes são os conhecidos operadores de adição ( +), subtração ( -), multiplicação ( *) e divisão ( /).

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       System.out.println(x+y);
       System.out.println(x-y);
       System.out.println(x*y);
       System.out.println(x/y);
   }
}

Saída do console: 1032 966 32967 30 Você já usou tudo isso. A este grupo, você pode adicionar o %operador restante ou módulo ( ).

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 33%2;
       System.out.println(y);
   }
}

Saída do console: 1 Neste exemplo, dividimos 33 por 2. Isso resulta em 16, com uma "cauda" extra (um) que não é divisível por 2. Essa "cauda" é o resultado da operação "resto da divisão". Java também implementa operadores de comparação/relacionais (assim como na matemática). Eles provavelmente são familiares para você da escola também:

• igual a ( ==)
• maior que ( >)
• menor que ( <)
• maior ou igual a ( >=)
• menor ou igual a ( <=)
• diferente ( !=)

Aqui você deve prestar atenção a um ponto importante que faz com que muitos iniciantes cometam erros. O operador "igual" é escrito ==, não =. Em Java, um único =é o operador de atribuição , que é usado quando uma variável recebe um número, string ou o valor de outra variável.

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// We expect false to be displayed
   }
}

Saída do console: 999 Ops! Obviamente, este não é o resultado que esperávamos. É um tipo de dados totalmente diferente: esperávamos ver um boolean , mas obtivemos um número. Tudo porque usamos um operador de atribuição entre parênteses em vez de uma comparação . x=y O valor de y(999) foi atribuído à variável x, e então exibimos o valor de x. Aqui está a maneira certa de fazer isso:

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x==y);
   }
}

Saída do console: false Agora comparamos os dois números corretamente! :) Aqui está outro recurso do operador de atribuição ( =): ele pode ser "encadeado":

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;
       int z = 256;

       x = y = z;
       System.out.println(x);
   }
}

Saída do console: 256 Lembre-se de que a atribuição é da direita para a esquerda . Esta expressão ( x = y = z) será executada em etapas:

• y = z, aquilo é,y = 256
• x = y, aquilo é,x = 256

Operadores unários.

Eles são chamados de " unários " da palavra " uno ", que significa " um ". Eles receberam esse nome porque, ao contrário das operadoras anteriores, atuam em um único número, não em vários. Esses incluem:

• Unário menos. Ele inverte o sinal do número.

public class Main {

   public static void main(String[] args) {

       int x = 999;

       // Change the sign for the first time
       x = -x;
       System.out.println(x);

       // Change the sign for the second time
       x= -x;
       System.out.println(x);
   }
}

Saída do console: -999 999 Usamos o operador menos unário duas vezes. Como resultado, nosso número foi primeiro negativo e depois voltou a ser positivo!

• Incremento (++) e decremento (--)

O ++operador aumenta um número em um e o --operador reduz um número na mesma quantidade.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       x++;
       System.out.println(x);

       x--;
       System.out.println(x);
   }
}

Saída do console: 1000 999 Esta notação pode ser familiar para você se já ouviu falar da linguagem C++. Seus criadores usaram esse nome interessante para transmitir a ideia de que "C++ é uma extensão da linguagem C". Existem dois tipos de operadores de incremento e decremento: postfix e prefix . x++- postfix ++x- prefix Qual é a diferença fundamental entre colocar os mais/menos antes ou depois do número? Veremos no exemplo a seguir:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
   }
}

Saída do console: 999 Algo não está certo! Queríamos aumentar xem 1 e atribuir o novo valor à variável y. Em outras palavras, y deveria ser 1000. Mas, em vez disso, obtemos outra coisa: 999. Parece que x não foi aumentado e que o operador de incremento não funcionou? Mas funcionou. Para se convencer, tente exibir xno final :)

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
       System.out.println(x);
   }
}

Saída do console: 999 1000 Na verdade, é exatamente por isso que essa operação é chamada de postfix: ela é executada após a expressão principal. Isso significa, no nosso caso: int y = x++; y = xé executado primeiro (e a variável yserá inicializada com o valor de x), e só então será x++executado E se este não for o comportamento que desejamos? Então precisamos usar a notação de prefixo :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = ++x;
       System.out.println(y);
   }
}

Neste caso, ++xé processado primeiro e só depois é y = x; executado. Você deve gravar essa diferença na memória imediatamente para evitar erros em um programa real, onde usar o postfix em vez do prefixo pode virar tudo de cabeça para baixo :)

Operadores compostos

Além disso, em Java existem os chamados operadores compostos. Eles combinam dois operadores:

• Atribuição
• Operadores aritméticos

Esses incluem:

• +=
• -=
• *=
• /=
• %=

Vamos considerar um exemplo:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       x += y;
       System.out.println(x);
   }
}

Saída do console: 1032 x += y significa x = x + y. Os dois símbolos são usados ​​consecutivamente por uma questão de brevidade. As combinações -=, *=, /=e %=funcionam de maneira semelhante.

Operadores lógicos

Além dos operadores numéricos, Java também possui operações que envolvem valores booleanos ( true e false ). Essas operações são realizadas usando operadores lógicos

• !- lógico NÃO . Ele inverte o valor de um booleano

public class Main {

   public static void main(String[] args) {

       boolean x = true;
       System.out.println(!x);
   }
}

Saída do console: falso

• &&- E lógico . Retorna verdadeiro somente se ambos os operandos forem verdadeiros.

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}

Saída do console: false true O resultado da primeira operação é false, porque um dos operandos é false, ou seja 100 > 200, . Para retornar verdadeiro, o &&operador exige que ambos os operandos sejam verdadeiros (como é o caso da segunda linha).

• ||- OU lógico . Retorna verdadeiro quando pelo menos um dos operandos for verdadeiro.

Quando usamos esse operador, nosso exemplo anterior produz um resultado diferente:

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}

Saída do console: true A expressão 100 > 200ainda é false, mas para o operador OR é totalmente suficiente que a primeira parte ( 100 > 10) seja true.