CodeGym/Java blog/Tilfældig/Øg og sænk unære operatører i Java
John Squirrels
Niveau
San Francisco

Øg og sænk unære operatører i Java

Udgivet i gruppen

Unære operatører

Unære operatorer er de operatorer i Java, der kun behøver en enkelt operand for at udføre en funktion. De arbejder på samme princip som unære operationer i matematik. Du kan f.eks. bruge unære operatorer til at repræsentere en positiv værdi, negativ værdi, øge en værdi med 1, formindske en værdi med 1 eller til at negere en værdi.
  • +x (positiv værdi)
  • -x (negativ værdi)
  • ++x (increment operation)
  • --x (reducer operation)
  • !x (negation)

Typer af unære operatører

Der er 5 typer af Unary Operators

1. Unary Plus

Det repræsenterer en positiv værdi som +x = x eller +5 = 5.

2. Unær minus

Det repræsenterer en negativ værdi som -x = -x eller -5 = -5.

3. Øg unær operatør

Det øger værdien med 1, hvor ++x = x+1.

4. Formindsk unær operatør

Det formindsker værdien med 1, hvor --x = x-1.

5. Logisk komplement

Det inverterer logisk værdien af ​​en boolean, som hvis x = sand, så vil !x være falsk.

Forøg operatør (++)

Increment (++) operatoren (også kendt som increment unary operator) i Java bruges til at øge værdien af ​​en variabel med 1. Da det er en type unær operator, kan den bruges med en enkelt operand.

Syntaks

Syntaksen for inkrementoperator er et par additionstegn, dvs.;
++x; x++;
Operatoren kan anvendes enten før eller efter variablen. Begge vil have samme stigning på 1. De har dog begge separate anvendelser og kan kategoriseres som følgende typer.
  • Pre-Increment Operatør
  • Post-Inkrement-operatør

Eksempel

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);
	}
}

Produktion

Variablens oprindelige værdi = 15 variabel++ = 16 ++variabel = 17

Pre-Increment Operator (++x;)

Hvis inkrementoperatoren (++) er angivet før variablen som et præfiks (++x), så kaldes det pre-increment-operator. I dette tilfælde øges værdien af ​​variablen først med 1, og derefter udføres yderligere beregninger.

Eksempel

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);
	}
}

Produktion

Variablens oprindelige værdi = 5 variabel = 6 preIncrement = 6 ++preIncrement = 7

Post-increment-operatør (x++;)

Hvis inkrementoperatoren (++) er angivet efter variablen som en postfix (x++), så kaldes den post-increment-operator. I dette tilfælde bruges den oprindelige værdi af variablen (uden stigning) til beregninger, og derefter øges den med 1.

Eksempel

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);
	}
}

Produktion

Oprindelig variabel = 100 postIncrement = 100 variabel = 101 postIncrement++ = 100 postIncrement++ = 101 postIncrement++ = 102 postIncrement = 103

Reducer operatør (--)

Reduktion, som navnet antyder, bruges til at reducere værdien af ​​en variabel med 1. Det er også en af ​​de unære operatortyper, så den kan bruges med en enkelt operand.

Syntaks

Syntaksen for dekrementoperator er et par negative fortegn, dvs.;
--x; x--;
Ligesom inkrementoperatoren kan decrement (--) operatoren også anvendes før og efter variablen. Begge vil resultere i den samme reduktion på 1. De har begge forskellige anvendelser og kan adskilles i de andre typer.
  • Før-dekrement operatør
  • Post-decrement operatør

Før-dekrement operatør (--x;)

Hvis dekrementoperatoren (--) er nævnt før variablen som et præfiks (--x), så kaldes den en pre-dekrementoperator. I dette tilfælde dekrementeres værdien af ​​variablen først med 1, og derefter udføres andre beregninger.

Eksempel

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);  	}
}

Produktion

Variablens oprindelige værdi = 11 variabel = 10 preDecrement = 10 --preDecrement = 9

Post-decrement operatør (x--;)

Hvis dekrementoperatoren (--) er nævnt efter variablen som en postfix (x--), så kaldes den en post-dekrementoperator. I dette tilfælde bruges den oprindelige værdi af variablen (uden formindskelse) til beregninger, og derefter dekrementeres den med 1.

Eksempel

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);
	}
}
Variablens oprindelige værdi = 75 postDecrement = 75 variable = 74 postDecrement-- = 75 postDecrement-- = 74 postDecrement-- = 73 postDecrement = 72

Konklusion

Ved slutningen af ​​dette indlæg håber vi, at du er blevet godt bekendt med de unære operatører for stigning og reduktion i Java. Du opfordres til at øve dig i grænsetilfældene og andre praksisproblemer hos CodeGym for at være sikker på dine færdigheder. For at styrke det, du har lært, foreslår vi, at du ser en videolektion fra vores Java-kursus
Held og lykke og god læring!
Kommentarer
  • Populær
  • Ny
  • Gammel
Du skal være logget ind for at skrive en kommentar
Denne side har ingen kommentarer endnu