Objetivos
        
    
    
    
        
Expressões e operadores
    
    
        
            
                Para declararmos expressões em qualquer linguagem de programação precisamos utilizar os operadores. 
                Os conceitos de expressões e operadores já foram vistos em 
                Portugol: Expressões e Operadores e 
                C: Operadores. 
                Em caso de dúvida é recomendado a leitura.
            
            
                A linguagem Java utiliza os mesmos operadores básicos da linguagem C/C++ para criarmos 
                expressões dos tipos aritméticas, lógicas e relacionais e bit-a-bit/bitwise. 
                Nesta seção vamos aprender o uso desses operadores.
            
         
     
    
    
        
            
                Para atribuirmos valores à variáveis e constantes, Java utiliza os operadores de atribuição
                apresentados na tabela abaixo:
            
            
                Tab. 1: Operadores Aritméticos
                
                    
                        | Operador | 
                        Descrição | 
                        Exemplo | 
                    
                
                
                    
                        | = | 
                        Atribuição | 
                        a=b | 
                    
                    
                        | += | 
                        Atribuição acumulativa de adição | 
                        a+=b | 
                    
                    
                        | -= | 
                        Atribuição acumulativa de subtração | 
                        a-=b | 
                    
                    
                        | *= | 
                        Atribuição acumulativa de multiplicação | 
                        a*=b | 
                    
                    
                        | %= | 
                        Atribuição acumulativa de Módulo | 
                        a%=b | 
                    
                    
                        | /= | 
                        Acumulação de divisão | 
                        a%=b | 
                    
                    
                        | |= | 
                        Acumulação de OU bit-a-bit | 
                        a|=b | 
                    
                    
                        | &= | 
                        Acumulação de E bit-a-bit | 
                        a&=b | 
                    
                    
                        | ^= | 
                        Acumulação de Ou-Exclusivo bit-a-bit | 
                        a^=b | 
                    
                    
                        | <<= | 
                        Acumulação de deslocamento | 
                        a<<=b | 
                    
                    
                        | >>= | 
                        Acumulação de deslocamento | 
                        a>>=b | 
                    
                
            
            Sintaxe
            valor ou expressão operador valor ou expressão
variavel1 operador= variavel2 ou expressão
            Exemplo 1
            
public class Main
{
	public static void main(String[] args) 
	{
        int a=1,
            b=2;
            
        a += b;
        System.out.println(a);
        a -= b;
        System.out.println(a);
        a *= b;
        System.out.println(a);
        a /= b;
        System.out.println(a);
        a %= b;
        System.out.println(a);
        a |= b;
        System.out.println(a);
        a &= b;
        System.out.println(a);
        a ^= b;
        System.out.println(a);
        a >>= b;
        System.out.println(a);
        a <<= b;
        System.out.println(a);
	}
}
            Saída
            
3
1
2
1
1
3
2
0
0
0
         
     
    
    
        
            
                Para criação de expressões aritméticas, utilizamos os operadores abaixo suportados pela 
                linguagem Java:
            
         
     
    
        
            
                Tab. 2: Operadores Relacionais
                
                    
                        | Operador | 
                        Descrição | 
                        Exemplo | 
                    
                
                
                    
                        | + | 
                        Adição | 
                        a+b | 
                    
                    
                        | - | 
                        Subtração | 
                        a-b | 
                    
                    
                        | * | 
                        Multiplicação | 
                        a*b | 
                    
                    
                        | / | 
                        Divisão | 
                        a/b | 
                    
                    
                        | % | 
                        Módulo | 
                        a%b | 
                    
                    
                        | ++ | 
                        Incremento | 
                        ++a , a++ | 
                    
                    
                        | -- | 
                        Decremento | 
                        --a, a-- | 
                    
                
            
            
                Os operadores -- e ++ utilizados antes ou depois da variável são chamados pré incrementado e pós 
                incrementado. O funcionamento desses operadores foi dicutida quando operadores aritméticos foram estudados em 
                Portugol: Operadores aritméticos.
                
            
            Sintaxe
            valor1 ou expressão1 operador valor2 ou expressão2
            Exemplo 2
            
public class Main
{
	public static void main(String[] args) 
	{
        int a=1,
            b=2;
            
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);
        System.out.println(++a);
        System.out.println(--a);
	}
}
            Saída
            
3
-1
2
0
3
2
1
         
     
    
    
        
            
                Para a tomada de decições, a linguagem Java fornece os operadores mostrados abaixo. 
                Estes operadores retornam true ou false.
            
            
                Tab. 3: Operadores Relacionais
                
                    
                        | Operador | 
                        Descrição | 
                        Exemplo | 
                    
                
                
                    
                        | == | 
                        Igual | 
                        a == b | 
                    
                    
                        | >= | 
                        Maior ou igual | 
                        a >= b | 
                    
                    
                        | <= | 
                        Menor ou igual | 
                        a <= b | 
                    
                    
                        | != | 
                        Diferente | 
                        a != b | 
                    
                    
                        | > | 
                        Maior | 
                        a>b | 
                    
                    
                        | < | 
                        Menor | 
                        a<b | 
                    
                
            
            Sintaxe
            valor1 ou expressão1 operador valor2 ou expressão2
            Exemplo 3
            
import java.lang.String;
public class Main
{
	public static void main(String[] args) 
	{
        int a=1,
            b=3;
            
        System.out.println(a != b);
        System.out.println(a > b);
        System.out.println(a < b);
        System.out.println(a <= b);
        System.out.println(a >= b);
	}
}
            Saída
            true
false
true
true
false
         
     
    
    
        
            
                Para entendermos sobre a aplicação dos operadores lógicos é importante entender sobre a tabela verdade 
                que foi explicado em 
                Portugol: Operadores Lógicos e 
                Tutorial C: Operadores Lógicos.
            
            
                Tab. 4: Operadores lógicos
                
                    
                        | Operador | 
                        Significado | 
                        Exemplo | 
                    
                
                
                    
                        | && | 
                        E lógico | 
                        a && b | 
                    
                    
                        | ! | 
                        Não lógico | 
                        !a | 
                    
                    
                        | || | 
                        OR lógico | 
                        a || b | 
                    
                
            
            
                Os operadores lógicos retornam um valor booleano true ou false. Esse tipo de operador 
                é muito utilizado na tomadas de decisão.
            
            Sintaxe
            valor1 ou expressão1 operador valor2 ou expressão2
            Exemplo 4
            
#include <iostream>
using namespace std;
int main()
{
    bool a = false, 
        b = true;
    cout << "\n" << (a||b) ;
    cout << "\n" << (a&&b);
    cout << "\n" << (!a);
    return 0;
}
            Saída
            true
false
false
            
            
         
     
    
        Operadores bit-a-bit/bitwise
        
     
    
        
            
                O uso dos operadores bit-a-bit já foi estudado em  
                Tutorial C: Operadores bit-a-bit . 
                É importante entender sobre a tabela verdade que foi explicado em 
                Portugol: Operadores Lógicos e 
                Tutorial C: Operadores Lógicos.
            
            
                Esse operadores aplicam operações lógicas bit-a-bit tendo como resultado os valores 0 ou 1 de 
                acordo com suas tabelas verdades, exceto quando os operadores de deslocamento estão envolvido.
            
            
                Tab. 5: Operadores bitwise
                
                    
                        | Operador | 
                        Descrição | 
                        Exemplo | 
                    
                
                
                    
                        | & | 
                        E bit-a-bit | 
                        a & b | 
                    
                    
                        | | | 
                        OR bit-a-bit | 
                        a | b | 
                    
                    
                        | ^ | 
                        Ou Exclusivo | 
                        a<<b | 
                    
                    
                        | ~ | 
                        Não bit-a-bit | 
                        ~a | 
                    
                    
                        | >> | 
                        Desloca N bits à direita | 
                        a>>b | 
                    
                    
                        | << | 
                        Desloca N bits à esquerda | 
                        a<<b | 
                    
                
            
            Sintaxe
            valor1 operador valor2
valor << quantidade_bits
valor >> quantidade_bits
~valor
            Exemplo 5
            
import java.lang.String;
public class Main
{
	public static void main(String[] args) 
	{
        int a=1, b=2;
            
        System.out.println(a & b);
        System.out.println(a | b);
        System.out.println( ~a);
        System.out.println( a<<1);
        System.out.println( b>>1);
        System.out.println( a ^ b);
	}
}
            Saída
            0
3
-2
2
1
0
         
     
    
        Precedência de operadores
        
     
    
        
            
                O validação do uso dos operadores estudados acima seguem uma ordem ou precedência. A tabela abaixo resume essa precedência da mais alta até a mais baixa.
            
            
                Tab. 6: Precedência
                
                    
                        | # | 
                        Operador | 
                        Descrição | 
                    
                
                
                    
                        | 1 | 
                        :: | 
                        Escopo | 
                    
                    
                        | 2 | 
                        x++ x-- | 
                        Incremento/Decremento | 
                    
                    
                         | 
                        . -> | 
                        Acesso a membros | 
                    
                    
                        | 3 | 
                        ++x --x | 
                        Incremento / Decremento | 
                    
                    
                        | - | 
                        +x -x | 
                        Unário | 
                    
                    
                        | - | 
                        ! ~ | 
                        Não lógico / bit-a-bit | 
                    
                    
                        | - | 
                        *x | 
                        Contéudo de  | 
                    
                    
                        | - | 
                        &x | 
                        Endereço de | 
                    
                    
                        | 5 | 
                        * / % | 
                        Multiplicação, divição e módulo | 
                    
                    
                        | 6 | 
                        + - | 
                        Soma e subtração | 
                    
                    
                        | 7 | 
                        << >> | 
                        Deslocamento | 
                    
                    
                        | 8 | 
                        < <= => > | 
                        Comparação | 
                    
                    
                        | 9 | 
                        == != | 
                        Comparação | 
                    
                    
                        | 10 | 
                        & | 
                        E lógico | 
                    
                    
                        | 11 | 
                        ^ | 
                        Ou-Exclusivo | 
                    
                    
                        | 12 | 
                        | | 
                        Ou bit-a-bit | 
                    
                    
                        | 13 | 
                        && | 
                        E lógico | 
                    
                    
                        | 14 | 
                        || | 
                        Ou lógico | 
                    
                    
                        | 15 | 
                        x?y:z | 
                        if ternário | 
                    
                    
                        | - | 
                        = | 
                        Atribuição | 
                    
                    
                        | - | 
                        += -= | 
                        Atribuição | 
                    
                    
                        | - | 
                        *= /= %= | 
                        Atribuição | 
                    
                    
                        | - | 
                        <<= >>= | 
                        Atribuição | 
                    
                    
                        | - | 
                        &= ^= |= | 
                        Atribuição | 
                    
                    
                        | - | 
                        , | 
                        Vírgula | 
                    
                
            
         
     
    
        Histórico de atualizações
        
     
    
        
            
                - 22/07/2025 - revisão 3 - adição: explicação bitwise; correção: ajustes em sintaxes, target de links
 
                - 23/09/2024 - revisão 2 - remoção: imports em exemplos; correção: links portugol, sintaxes; ajustes gramaticais pontuais
 
                - 06/02/2024 - revisão 1 - correção em navegação, erros gramaticais e adição de operador "<" 
 
                - 04/09/2023 - versão inicial
 
            
         
     
    
            
            
                
                    
                    Os cursos oferecidos nesta página são cursos fornecidos por parceiros. Ao comprar um curso clicando
                em seu banner, você está ajudando a manter o projeto TutorialDev vivo. Os sites dos cursos parceiros utilizam cookies.