Jednoargumentowe operatory inkrementacji i dekrementacji w Javie

Operatory jednoargumentowe

Operatory jednoargumentowe to te operatory w Javie, które potrzebują tylko jednego operandu do wykonania dowolnej funkcji. Działają na tej samej zasadzie, co operacje jednoargumentowe w matematyce. Na przykład można użyć operatorów jednoargumentowych do przedstawienia wartości dodatniej, wartości ujemnej, zwiększenia wartości o 1, zmniejszenia wartości o 1 lub zanegowania wartości.

• +x (wartość dodatnia)
• -x (wartość ujemna)
• ++x (operacja przyrostowa)
• --x (operacja zmniejszania)
• !x (negacja)

Rodzaje operatorów jednoargumentowych

Istnieje 5 typów operatorów jednoargumentowych

1. Jednoargumentowy plus

Reprezentuje wartość dodatnią, taką jak +x = x lub +5 = 5.

2. Jednoargumentowy minus

Reprezentuje wartość ujemną, taką jak -x = -x lub -5 = -5.

3. Jednoargumentowy operator inkrementacji

Zwiększa wartość o 1, gdzie ++x = x+1.

4. Jednoargumentowy operator dekrementacji

Zmniejsza wartość o 1, gdzie --x = x-1.

5. Dopełnienie logiczne

Logicznie odwraca wartość logiczną, na przykład jeśli x = prawda, to !x będzie fałszywe.

Operator przyrostu (++)

Operator inkrementacji (++) (znany również jako jednoargumentowy operator inkrementacji) w Javie służy do zwiększania wartości zmiennej o 1. Ponieważ jest to typ operatora jednoargumentowego, można go używać z pojedynczym operandem.

Składnia

Składnia operatora inkrementacji to para znaków dodawania, tj.; Operator można zastosować przed lub po zmiennej. Oba będą miały ten sam przyrost 1. Jednak oba mają różne zastosowania i można je sklasyfikować jako następujące typy.

• Operator preinkrementacji
• Operator postinkrementacji

Przykład

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

Wyjście

Operator preinkrementacji (++x;)

Jeśli operator inkrementacji (++) jest określony przed zmienną, jak przedrostek (++x), wówczas jest on nazywany operatorem preinkrementacji. W tym przypadku wartość zmiennej jest najpierw zwiększana o 1, a następnie wykonywane są dalsze obliczenia.

Przykład

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

Wyjście

Operator postinkrementacji (x++;)

Jeśli operator inkrementacji (++) jest określony po zmiennej, jak przyrostek (x++), to jest nazywany operatorem postinkrementacji. W tym przypadku do obliczeń używana jest oryginalna wartość zmiennej (bez inkrementacji), a następnie zwiększana o 1.

Przykład

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

Wyjście

Operator dekrementacji (--)

Dekrementacja, jak sama nazwa wskazuje, służy do zmniejszania wartości zmiennej o 1. Jest to również jeden z typów operatorów jednoargumentowych, więc można go używać z pojedynczym operandem.

Składnia

Składnia operatora dekrementacji to para znaków ujemnych, tj.; Podobnie jak operator inkrementacji, operator dekrementacji (--) można również zastosować przed i po zmiennej. Oba spowodują ten sam spadek o 1. Oba mają różne zastosowania i mogą być rozbieżne w dalszych typach.

• Operator przeddekrementacyjny
• Operator postdekrementacyjny

Operator poprzedzający dekrementację (--x;)

Jeśli operator dekrementacji (--) jest wymieniony przed zmienną jak przedrostek (--x), to jest nazywany operatorem dekrementacji. W tym przypadku wartość zmiennej jest najpierw zmniejszana o 1, a następnie wykonywane są inne obliczenia.

Przykład

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

Wyjście

Operator po dekrementacji (x--;)

Jeśli operator dekrementacji (--) jest wymieniony po zmiennej, jak przyrostek (x--), to jest nazywany operatorem dekrementacji. W tym przypadku do obliczeń używana jest pierwotna wartość zmiennej (bez dekrementacji), a następnie zmniejszana o 1.

Przykład

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

Wniosek

Mamy nadzieję, że do końca tego wpisu zapoznałeś się już z jednoargumentowymi operatorami inkrementacji i dekrementacji w Javie. Zachęcamy do ćwiczenia przypadków granicznych i innych problemów praktycznych w CodeGym, aby mieć pewność swoich umiejętności. Aby utrwalić to, czego się nauczyłeś, zalecamy obejrzenie lekcji wideo z naszego kursu języka Java

Powodzenia i przyjemnej nauki!