JavaRush /Blogue Java /Random-PT /Operações numéricas em Java

Nível 41

28 fevereiro 2021
54 views
0 comments

Operações numéricas em Java

Olá! Hoje veremos um tópico muito importante, a saber, operações numéricas em Java . Os números estão por toda parte na programação. Se você se aprofundar no currículo escolar, lembrará que todas as informações em um computador são apresentadas em formato numérico - combinações de zeros e uns - também chamado de código binário. Operações numéricas em Java - 2

Existem muitas operações com números na programação, então veremos as mais importantes delas com exemplos :)

Operaçoes aritimeticas

Vamos começar com a coisa mais simples - com operações aritméticas. São eles os conhecidos sinal (+), 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:

Você já usou tudo isso. Você pode adicionar uma operação a eles %- o restante da divisão.

public class Main {

   public static void main(String[] args) {

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

Saída do console:

Neste exemplo, dividimos 33 por 2. Como resultado, obtemos 16 e resta uma “cauda” extra que não é divisível por 2 - um. Esta “cauda” será o resultado da operação “resto de divisão”. Java (assim como matemática) implementa operadores de comparação . Você provavelmente também os conhece da escola:

é igual a ( ==)
mais ( >)
menos ( <)
Melhor que ou igual a ( >=)
menos que ou igual a ( <=)
não igual ( !=)

Aqui vale a pena prestar atenção a um ponto importante em que muitos iniciantes cometem erros. A operação “igual” é escrita como ==, e não com um sinal =. O sinal de unidade =em Java é um operador de atribuição, onde a uma variável é atribuído um número, string ou o valor de outra variável. Operações numéricas em Java - 3

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// expect false to be printed to the console
   }
}

Saída do console:

Ops! Este claramente não é o resultado que esperávamos. Este é um tipo de dado completamente diferente: esperávamos ver boolean, mas obtivemos um número. Isso ocorre porque entre parênteses temos uma operação de atribuição e não de comparação. x=y O valor y(999) foi atribuído à variável xe depois o imprimimos xno console. Opção correta:

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 corretamente os 2 números! :) Outra característica da operação de atribuição ( =) é que ela pode ser feita “encadeada”:

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:

Lembre-se: a atribuição é feita da direita para a esquerda. Esta expressão ( x = y = z) será executada em etapas:

y = z, ou seja, y = 256
x = y, isto é x = 256

Operações unárias

Eles são chamados de “unários” da palavra “uno” - “um”. Receberam este nome porque, ao contrário dos anteriores, são realizados num número e 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 a second time
       x= -x;
       System.out.println(x);
   }
}

Saída do console:


-999
999

Usamos o unário menos duas vezes. Como resultado, nosso número tornou-se inicialmente negativo e depois positivo novamente!

Incremento ( ++) e decremento ( --)

Uma operação ++aumenta um número em um e uma operação --o diminui na mesma unidade.

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 forma de notação pode ser familiar para você se você já ouviu falar da linguagem C++. Com a ajuda de um nome tão interessante, seus criadores transmitiram a ideia: “C++ é uma extensão da linguagem C”. Uma versão melhorada popular do Notepad é chamada Notepad++ Ponto importante. Existem dois tipos de operações de incremento e decremento: postfix e prefixo. x++- notação pós-fixada ++x- notação prefixada Qual é a diferença fundamental se você colocar pontos positivos e negativos antes ou depois do número? Vejamos em um exemplo:

public class Main {

   public static void main(String[] args) {

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

Saída do console:

Há algo de errado! Queríamos incrementar xem 1 e atribuir um novo valor à variável y. Ou seja, y deveria ser igual a 1000. Mas temos um resultado diferente - 999. Acontece que xnão foi aumentado e a operação de incremento não funcionou? Como funcionou. Para verificar isso, tente imprimir x no console no 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, é por isso que a operação postfix é chamada assim: ela é executada após a expressão principal. Ou seja, no nosso caso: int y = x++; primeiro ele é executado y = x(e será atribuído à variável y seu valor original x), e só então x++ ... E se não estivermos satisfeitos com esse comportamento? Você precisa 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);
   }
}

Nesse caso vai funcionar primeiro ++x e só depois, y = x; vale lembrar logo essa diferença para não cometer erros em um programa real, onde todo comportamento pode virar de cabeça para baixo por causa disso :)

Operações combinadas

Além disso, em Java existem as chamadas operações combinadas. Eles usam uma combinação de duas operações:

Atribuição
Operação aritmética

Isso inclui operações:

+=
-=
*=
/=
%=

Vejamos 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:

x += ysignifica x = x + y. Apenas por uma questão de brevidade, dois caracteres seguidos são usados. Isso também funciona com combinações de -=, *=e /=.%=

Operações lógicas

Além de operações com números, Java também possui operações com variáveis booleanas - truee false. Essas operações são realizadas usando operadores lógicos

!- Operador “NÃO”. Inverte o valor de uma variável booleana

public class Main {

   public static void main(String[] args) {

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

Saída do console:


false

&&- operador “E”. Retornará um valor truesomente se ambos os operandos forem true.
```
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, já que uma das condições é falsa, ou seja, 100 > 200. O operador exige que todas as condições sejam verdadeiras (como na segunda linha, por exemplo) &&para retornar .true
||- Operador “OU”. Retorna truequando pelo menos um dos operandos é verdadeiro.

Aqui nosso exemplo anterior funcionará de maneira 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 > 200 ainda é falsa, mas o operador “ou” está bastante satisfeito com o fato de a primeira parte (100 > 10) ser verdadeira.

Comentários

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION