Operadores Unários de Incremento e Decremento em Java

Operadores unários

Operadores unários são aqueles operadores em Java que precisam apenas de um único operando para executar qualquer função. Eles trabalham com o mesmo princípio das operações unárias em matemática. Por exemplo, você pode usar operadores unários para representar um valor positivo, valor negativo, incrementar um valor em 1, diminuir um valor em 1 ou negar um valor.

• +x (valor positivo)
• -x (valor negativo)
• ++x (operação de incremento)
• --x (operação de decremento)
• !x (negação)

Tipos de Operadores Unários

Existem 5 tipos de Operadores Unários

1. Unário Plus

Representa um valor positivo como +x = x ou +5 = 5.

2. Unário Menos

Representa um valor negativo como -x = -x ou -5 = -5.

3. Operador Unário de Incremento

Ele incrementa o valor em 1 onde ++x = x+1.

4. Operador unário de decremento

Ele diminui o valor em 1 onde --x = x-1.

5. Complemento Lógico

Ele inverte logicamente o valor de um booleano como se x = true, então !x será false.

Operador de incremento (++)

O operador de incremento (++) (também conhecido como operador unário de incremento) em Java é usado para aumentar o valor de uma variável em 1. Como é um tipo de operador unário, pode ser usado com um único operando.

Sintaxe

A sintaxe do operador de incremento é um par de sinais de adição, ou seja; O operador pode ser aplicado antes ou depois da variável. Ambos terão o mesmo incremento de 1. No entanto, ambos têm usos separados e podem ser categorizados como os seguintes tipos.

• Operador de pré-incremento
• Operador pós-incremento

Exemplo

public class IncrementOperator {

	public static void main(String[] args) {

		int variable = 15;
		System.out.println("Original value of the variable = " + variable);
		
		// after using increment operator 
		variable++; 	 //  increments 1, variable = 16
		System.out.println("variable++ = " + variable); 

		++variable;		//  increments 1, variable = 17
		System.out.println("++variable = " + variable); 
	}
}

Saída

Operador de pré-incremento (++x;)

Se o operador de incremento (++) for especificado antes da variável como um prefixo (++x), ele será chamado de operador de pré-incremento. Nesse caso, o valor da variável é primeiro incrementado em 1 e, em seguida, cálculos adicionais são executados.

Exemplo

public class PreIncrementOperator {

	public static void main(String[] args) {

		int variable = 5;
		System.out.println("Original value of the variable = " + variable);
		
		// using pre-increment operator 
		int preIncrement = ++variable; 

		System.out.println("variable = " + variable); 
		System.out.println("preIncrement = " + preIncrement); 
		System.out.println("++preIncrement = " + ++preIncrement); 	
	}
}

Saída

Operador pós-incremento (x++;)

Se o operador de incremento (++) for especificado após a variável como um postfix (x++), ele será chamado de operador de pós-incremento. Nesse caso, o valor original da variável (sem incremento) é usado para cálculos e depois é incrementado em 1.

Exemplo

public class PostIncrementOperator {

	public static void main(String[] args) {

		int variable = 100;
		System.out.println("Original value of the variable = " + variable);
		
		// using post-increment operator 
		int postIncrement = variable++; // postIncrement = 100, variable = 101

		System.out.println("postIncrement = " + postIncrement); 
		System.out.println("variable = " + variable + "\n"); 
		
            // postIncrement = 101
		System.out.println("postIncrement++ = " + postIncrement++);
            // postIncrement = 102
		System.out.println("postIncrement++ = " + postIncrement++); 
            // postIncrement = 103
		System.out.println("postIncrement++ = " + postIncrement++); 
		
		System.out.println("\npostIncrement = " + postIncrement); 
	}
}

Saída

Operador de Decremento (--)

O decremento, como o nome indica, é usado para reduzir o valor de uma variável em 1. Também é um dos tipos de operador unário, portanto pode ser usado com um único operando.

Sintaxe

A sintaxe do operador de decremento é um par de sinais negativos, ou seja; Assim como o operador de incremento, o operador de decremento (--) também pode ser aplicado antes e depois da variável. Ambos resultarão no mesmo decremento de 1. Ambos têm usos distintos e podem ser divergidos em outros tipos.

• Operador de pré-decremento
• Operador pós-decremento

Operador de pré-decremento (--x;)

Se o operador de decremento (--) for mencionado antes da variável como um prefixo (--x), ele será chamado de operador de pré-decremento. Para este caso, o valor da variável é primeiro decrementado em 1 e, em seguida, outros cálculos são executados.

Exemplo

public class PreDecrementOperator {

	public static void main(String[] args) {
	
		int variable = 11;
		System.out.println("Original value of the variable = " + variable);
		
		// using preDecrement operator 
		int preDecrement = --variable; 
            
            // variable = 10
		System.out.println("variable = " + variable); 
            // preDecrement = 10
		System.out.println("preDecrement = " + preDecrement); 
            // preDecrement = 9		
		System.out.println("--preDecrement = " + --preDecrement);  	}
}

Saída

Operador pós-decremento (x--;)

Se o operador de decremento (--) for mencionado após a variável como um pós-fixo (x--), ele será chamado de operador de pós-decremento. Para este caso, o valor original da variável (sem decremento) é usado para cálculos e depois é decrementado em 1.

Exemplo

public class PostDecrementOperator {

	public static void main(String[] args) {
	
		int variable = 75;
		System.out.println("Original value of the variable = " + variable);
		
		// using postDecrement operator 
            // postDecrement = 75, variable = 74
		int postDecrement = variable--; 
		System.out.println("postDecrement = " + postDecrement); 
		System.out.println("variable = " + variable + "\n"); 
		// postDecrement = 74
		System.out.println("postDecrement-- = " + postDecrement--); 
            // postDecrement = 73
		System.out.println("postDecrement-- = " + postDecrement--); 
            // postDecrement = 72
		System.out.println("postDecrement-- = " + postDecrement--);
		
		System.out.println("\npostDecrement = " + postDecrement); 
	}
}

Conclusão

Ao final deste post, esperamos que você esteja bem familiarizado com os operadores unários de incremento e decremento em Java. Você é encorajado a praticar os casos de limite e outros problemas práticos no CodeGym para ter confiança em suas habilidades. Para reforçar o que você aprendeu, sugerimos que você assista a uma vídeo aula do nosso Curso de Java Boa sorte e bom aprendizado!