Expressions may be formed that combine variables and method results using arithmetic, assignment, bitwise, equality, logical and relational operators, as well as a few that do not fit with in these convenient categories.

**Arithmetic operators** include the
usual add, subtract multiple, divide and reminder (modulas).

The **assignment operators** (=, +=,
-=, *=, /=) include the simple assignment operator that we have
already seen:

a = 1;

and also include convenience combinations of arithmetic and assignment in one operator, such as

a += 5; // Add 5 to a

**Bitwise operators** are rarely
used in the Patchworks API, and are used to combine bit patterns in
integral primitive variables. Search the web for “Java bitwise
operators” for more information about these operators.

**Relational operators** include
equal (==), not equal (!=), greater than (>), greater than or equal
to (>=), less than (<) and less than or equal to (<=).
Relational operators test the left and right hand values and return
a Boolean value (true/false) having the result of the test.

a = 2; if (a < 5) print("less than 5");

Object equality and comparisons | |
---|---|

These relational operators test the values that are on either side of the operator. As we noted before, primitive values are stored directly in the variable so the above comparison will work as expected, but objects are stored as a reference to the object in heap memory. When you try to use the relational operators to compare objects, you will actually be comparing object references which in most cases is meaningless. For example, we could easily have two different String objects in two different locations in heap memory that both contain the value "John". If we compared these two references with an == test the result would be false because the references are different, when in fact the string values within the objects are identical. Similarly the > and < operators are only comparing the heap memory locations, not the object contents. Instead, when comparing objects for equality we must use the equals() method that is implemented by all objects. The equals() method will perform the steps required to compare object content, which may need several comparisons for complex objects. For example: firstName = "John"; if (firstName.equals("John")) print("They are the same"); If you want to do an ordering comparison (such as "less than" or "greater than"), then you will need to use the compareTo() method which is supported by classes that have a "natural ordering", such as numbers and strings. The compareTo() method compares one object to another of the same type, and returns an integer that is less than, greater than or equal to zero depending on whether the first object is less than, greater than or equal to the second object: a = "q"; if (a.compareTo("m") > 0) print("The string '"+m+"' is higher in sorting order than 'm'"); |

The instanceof** type comparison
operator** compares an object to the specified type. The
operator returns true If the object or one of its super classes
matches the specified type:

a = "John"; if (a instanceof String) print(a+" is a String type");

**Logical operators** combine
Boolean values using ‘and’ (&&) or ‘or’ (||) tests. These
operators are most often used to combine multiple relational
test.

if (a >= 0 && a <= 5) print(“The value of a is between 0 and 5”);

The **ternary operator** is an
expression element that is similar to an if-else statement. The
operator contains three parts: the conditional test, the true value
and the false value. The conditional test is evaluated and if true
the true value is used as the result of the operator, otherwise the
false value is used.

print("a is "+((a<5) ? "less than" : "greater than")+" five");

Ternary expression can reduce the number of lines required to test and use a value. They can also be difficult to read and benefit from the liberal use of parenthesis to clearly indicate the intent of the operation.

See Java documentation about operators or search the web for “Java operators” for details about the complete set of operators.