Download the JDK
Search the Tutorials
Hide the TOC
Trail: Learning the Java Language
Lesson: Language Basics
Section: Operators
Language Basics
Variables
Primitive Data Types
Arrays
Summary of Variables
Questions and Exercises
Operators
Assignment, Arithmetic, and Unary Operators
Equality, Relational, and Conditional Operators
Bitwise and Bit Shift Operators
Summary of Operators
Questions and Exercises
Expressions, Statements, and Blocks
Questions and Exercises
Control Flow Statements
The if-then and if-then-else Statements
The switch Statement
The while and do-while Statements
The for Statement
Branching Statements
Summary of Control Flow Statements
Questions and Exercises
Home Page > Learning the Java Language > Language Basics
« Previous • Trail • Next »
Assignment, Arithmetic, and Unary Operators

> The Simple Assignment Operator

> One of the most common operators that you'll encounter is the simple assignment operator "`=`". You saw this operator in the Bicycle class; it assigns the value on its right to the operand on its left:

> >      int cadence = 0;
> >      int speed = 0;
> >      int gear = 1;

> This operator can also be used on objects to assign object references, as discussed in Simple Data Objects.

> The Arithmetic Operators

> The Java programming language provides operators that perform addition, subtraction, multiplication, and division. There's a good chance you'll recognize them by their counterparts in basic mathematics. The only symbol that might look new to you is "`%`", which divides one operand by another and returns the remainder as its result.

> >     + 	additive operator (also used for String concatenation)
> >     - 	subtraction operator
> >     *	multiplication operator
> >     / 	division operator
> >     %	remainder operator

> The following program, `ArithmeticDemo`, tests the arithmetic operators.

> >     class ArithmeticDemo {

> >          public static void main (String[] args){

> >               int result = 1 + 2; // result is now 3
> >               System.out.println(result);

> >               result = result - 1; // result is now 2
> >               System.out.println(result);

> >               result = result * 2; // result is now 4
> >               System.out.println(result);

> >               result = result / 2; // result is now 2
> >               System.out.println(result);

> >               result = result + 8; // result is now 10
> >               result = result % 7; // result is now 3
> >               System.out.println(result);

> >          }
> >     }

> You can also combine the arithmetic operators with the simple assignment operator to create compound assignments. For example, `x+=1;` and `x=x+1;` both increment the value of `x` by 1.

> The `+` operator can also be used for concatenating (joining) two strings together, as shown in the following `ConcatDemo` program:

> >     class ConcatDemo {
> >          public static void main(String[] args){
> >               String firstString = "This is";
> >               String secondString = " a concatenated string.";
> >               String thirdString = firstString+secondString;
> >               System.out.println(thirdString);
> >          }
> >     }

> By the end of this program, the variable `thirdString` contains "This is a concatenated string.", which gets printed to standard output.

> The Unary Operators

> The unary operators require only one operand; they perform various operations such as incrementing/decrementing a value by one, negating an expression, or inverting the value of a boolean.

> >     + 	Unary plus operator; indicates positive value (numbers are positive without this, however)
> >     - 	Unary minus operator; negates an expression
> >     ++  	Increment operator; increments a value by 1
> >     --    	Decrement operator; decrements a value by 1
> >     !     	Logical complement operator; inverts the value of a boolean

> The following program, `UnaryDemo`, tests the unary operators:

> >     class UnaryDemo {

> >          public static void main(String[] args){
> >               int result = +1; // result is now 1
> >               System.out.println(result);
> >               result--;  // result is now 0
> >               System.out.println(result);
> >               result++; // result is now 1
> >               System.out.println(result);
> >               result = -result; // result is now -1
> >               System.out.println(result);
> >               boolean success = false;
> >               System.out.println(success); // false
> >               System.out.println(!success); // true
> >          }
> >     }

> The increment/decrement operators can be applied before (prefix) or after (postfix) the operand. The code `result++;` and `++result;` will both end in `result` being incremented by one. The only difference is that the prefix version (`++result`) evaluates to the incremented value, whereas the postfix version (`result++`) evaluates to the original value. If you are just performing a simple increment/decrement, it doesn't really matter which version you choose. But if you use this operator in part of a larger expression, the one that you choose may make a significant difference.

> The following program, `PrePostDemo`, illustrates the prefix/postfix unary increment operator:

> >     class PrePostDemo {
> >          public static void main(String[] args){
> >               int i = 3;
> >     	  i++;
> >     	  System.out.println(i);	// "4"
> >     	  ++i;
> >     	  System.out.println(i);	// "5"
> >     	  System.out.println(++i);	// "6"
> >     	  System.out.println(i++);	// "6"
> >     	  System.out.println(i);	// "7"
> >          }
> >     }

« Previous • Trail • Next »
Previous page: Operators
Next page: Equality, Relational, and Conditional Operators