Home > Articles > Programming > Java

Controlling Program Flow in Java

  • Print
  • + Share This
This excerpt from Thinking In Java shows you how to use operators and execution control statements. It covers precedence, assignment, regular expressions, relational and logical operators, and short circuiting. You'll learn to use Java's execution control statements, including loops and switches.
This chapter is from the book

This chapter is from the book

Like a sentient creature, a program must manipulate its world and make choices during execution.

In Java you manipulate data using operators, and you make choices with execution control statements. Java was inherited from C++, so most of these statements and operators will be familiar to C and C++ programmers. Java has also added some improvements and simplifications.

If you find yourself floundering a bit in this chapter, make sure you go through the multimedia CD ROM bound into this book: Foundations for Java. It contains audio lectures, slides, exercises, and solutions specifically designed to bring you up to speed with the fundamentals necessary to learn Java.

Using Java operators

An operator takes one or more arguments and produces a new value. The arguments are in a different form than ordinary method calls, but the effect is the same. Addition (+), subtraction and unary minus (-), multiplication (*), division (/), and assignment (=) all work much the same in any programming language.

All operators produce a value from their operands. In addition, an operator can change the value of an operand. This is called a side effect. The most common use for operators that modify their operands is to generate the side effect, but you should keep in mind that the value produced is available for your use, just as in operators without side effects.

Almost all operators work only with primitives. The exceptions are ‘=’, ‘==’ and ‘!=’, which work with all objects (and are a point of confusion for objects). In addition, the String class supports ‘+’ and ‘+=’.

Precedence

Operator precedence defines how an expression evaluates when several operators are present. Java has specific rules that determine the order of evaluation. The easiest one to remember is that multiplication and division happen before addition and subtraction. Programmers often forget the other precedence rules, so you should use parentheses to make the order of evaluation explicit. For example:

a = x + y - 2/2 + z; 

has a very different meaning from the same statement with a particular grouping of parentheses:

a = x + (y - 2)/(2 + z); 

Assignment

Assignment is performed with the operator =. It means “take the value of the right-hand side (often called the rvalue) and copy it into the left-hand side (often called the lvalue).” An rvalue is any constant, variable, or expression that can produce a value, but an lvalue must be a distinct, named variable. (That is, there must be a physical space to store the value.) For instance, you can assign a constant value to a variable:

a = 4; 

but you cannot assign anything to constant value—it cannot be an lvalue. (You can’t say 4 = a;.)

Assignment of primitives is quite straightforward. Since the primitive holds the actual value and not a reference to an object, when you assign primitives, you copy the contents from one place to another. For example, if you say a = b for primitives, then the contents of b are copied into a. If you then go on to modify a, b is naturally unaffected by this modification. As a programmer, this is what you’ve come to expect for most situations.

When you assign objects, however, things change. Whenever you manipulate an object, what you’re manipulating is the reference, so when you assign “from one object to another,” you’re actually copying a reference from one place to another. This means that if you say c = d for objects, you end up with both c and d pointing to the object that, originally, only d pointed to. Here’s an example that demonstrates this behavior:

//: c03:Assignment.java 
// Assignment with objects is a bit tricky. 
import com.bruceeckel.simpletest.*; 

class Number { 
  int i; 
} 

public class Assignment { 
  static Test monitor = new Test(); 
  public static void main(String[] args) { 
    Number n1 = new Number(); 
    Number n2 = new Number(); 
    n1.i = 9; 
    n2.i = 47; 
    System.out.println("1: n1.i: " + n1.i + 
      ", n2.i: " + n2.i); 
    n1 = n2; 
    System.out.println("2: n1.i: " + n1.i + 
      ", n2.i: " + n2.i); 
    n1.i = 27; 
    System.out.println("3: n1.i: " + n1.i + 
      ", n2.i: " + n2.i); 
    monitor.expect(new String[] { 
      "1: n1.i: 9, n2.i: 47", 
      "2: n1.i: 47, n2.i: 47", 
      "3: n1.i: 27, n2.i: 27" 
    }); 
  } 
} ///:~ 

First, notice that something new has been added. The line:

import com.bruceeckel.simpletest.*; 

imports the “simpletest” library that has been created to test the code in this book, and is explained in Chapter 15. At the beginning of the Assignment class, you see the line:

static Test monitor = new Test(); 

This creates an instance of the simpletest class Test, called monitor. Finally, at the end of main( ), you see the statement:

monitor.expect(new String[] { 
  "1: n1.i: 9, n2.i: 47", 
  "2: n1.i: 47, n2.i: 47", 
  "3: n1.i: 27, n2.i: 27" 
}); 

This is the expected output of the program, expressed as an array of String objects. When the program is run, it not only prints out the output, but it compares it to this array to verify that the array is correct. Thus, when you see a program in this book that uses simpletest, you will also see an expect( ) call that will show you what the output of the program is. This way, you see validated output from the program.

The Number class is simple, and two instances of it (n1 and n2) are created within main( ). The i value within each Number is given a different value, and then n2 is assigned to n1, and n1 is changed. In many programming languages you would expect n1 and n2 to be independent at all times, but because you’ve assigned a reference, you’ll see the output in the expect( ) statement. Changing the n1 object appears to change the n2 object as well! This is because both n1 and n2 contain the same reference, which is pointing to the same object. (The original reference that was in n1, that pointed to the object holding a value of 9, was overwritten during the assignment and effectively lost; its object will be cleaned up by the garbage collector.)

This phenomenon is often called aliasing, and it’s a fundamental way that Java works with objects. But what if you don’t want aliasing to occur in this case? You could forego the assignment and say:

n1.i = n2.i; 

This retains the two separate objects instead of tossing one and tying n1 and n2 to the same object, but you’ll soon realize that manipulating the fields within objects is messy and goes against good object-oriented design principles. This is a nontrivial topic, so it is left for Appendix A, which is devoted to aliasing. In the meantime, you should keep in mind that assignment for objects can add surprises.

Aliasing during method calls

Aliasing will also occur when you pass an object into a method:

//: c03:PassObject.java 
// Passing objects to methods may not be what 
// you're used to. 
import com.bruceeckel.simpletest.*; 

class Letter { 
  char c; 
} 

public class PassObject { 
  static Test monitor = new Test(); 
  static void f(Letter y) { 
    y.c = 'z'; 
  } 
  public static void main(String[] args) { 
    Letter x = new Letter(); 
    x.c = 'a'; 
    System.out.println("1: x.c: " + x.c); 
    f(x); 
    System.out.println("2: x.c: " + x.c); 
    monitor.expect(new String[] { 
      "1: x.c: a", 
      "2: x.c: z" 
    }); 
  } 
} ///:~ 

In many programming languages, the method f( ) would appear to be making a copy of its argument Letter y inside the scope of the method. But once again a reference is being passed, so the line

y.c = 'z'; 

is actually changing the object outside of f( ). The output in the expect( ) statement shows this.

Aliasing and its solution is a complex issue and, although you must wait until Appendix A for all the answers, you should be aware of it at this point so you can watch for pitfalls.

Mathematical operators

The basic mathematical operators are the same as the ones available in most programming languages: addition (+), subtraction (-), division (/), multiplication (*) and modulus (%, which produces the remainder from integer division). Integer division truncates, rather than rounds, the result.

Java also uses a shorthand notation to perform an operation and an assignment at the same time. This is denoted by an operator followed by an equal sign, and is consistent with all the operators in the language (whenever it makes sense). For example, to add 4 to the variable x and assign the result to x, use: x += 4.

This example shows the use of the mathematical operators:

//: c03:MathOps.java 
// Demonstrates the mathematical operators. 
import com.bruceeckel.simpletest.*; 
import java.util.*; 

public class MathOps { 
  static Test monitor = new Test(); 
  // Shorthand to print a string and an int: 
  static void printInt(String s, int i) { 
    System.out.println(s + " = " + i); 
  } 
  // Shorthand to print a string and a float: 
  static void printFloat(String s, float f) { 
    System.out.println(s + " = " + f); 
  } 
  public static void main(String[] args) { 
    // Create a random number generator, 
    // seeds with current time by default: 
    Random rand = new Random(); 
    int i, j, k; 
    // Choose value from 1 to 100: 
    j = rand.nextInt(100) + 1; 
    k = rand.nextInt(100) + 1; 
    printInt("j", j);  printInt("k", k); 
    i = j + k; printInt("j + k", i); 
    i = j - k; printInt("j - k", i); 
    i = k / j; printInt("k / j", i); 
    i = k * j; printInt("k * j", i); 
    i = k % j; printInt("k % j", i); 
    j %= k; printInt("j %= k", j); 
    // Floating-point number tests: 
    float u,v,w;  // applies to doubles, too 
    v = rand.nextFloat(); 
    w = rand.nextFloat(); 
    printFloat("v", v); printFloat("w", w); 
    u = v + w; printFloat("v + w", u); 
    u = v - w; printFloat("v - w", u); 
    u = v * w; printFloat("v * w", u); 
    u = v / w; printFloat("v / w", u); 
    // the following also works for 
    // char, byte, short, int, long, 
    // and double: 
    u += v; printFloat("u += v", u); 
    u -= v; printFloat("u -= v", u); 
    u *= v; printFloat("u *= v", u); 
    u /= v; printFloat("u /= v", u); 
    monitor.expect(new String[] { 
      "%% j = -?\\d+", 
      "%% k = -?\\d+", 
      "%% j \\+ k = -?\\d+", 
      "%% j - k = -?\\d+", 
      "%% k / j = -?\\d+", 
      "%% k \\* j = -?\\d+", 
      "%% k % j = -?\\d+", 
      "%% j %= k = -?\\d+", 
      "%% v = -?\\d+\\.\\d+(E-?\\d)?", 
      "%% w = -?\\d+\\.\\d+(E-?\\d)?", 
      "%% v \\+ w = -?\\d+\\.\\d+(E-?\\d)??", 
      "%% v - w = -?\\d+\\.\\d+(E-?\\d)??", 
      "%% v \\* w = -?\\d+\\.\\d+(E-?\\d)??", 
      "%% v / w = -?\\d+\\.\\d+(E-?\\d)??", 
      "%% u \\+= v = -?\\d+\\.\\d+(E-?\\d)??", 
      "%% u -= v = -?\\d+\\.\\d+(E-?\\d)??", 
      "%% u \\*= v = -?\\d+\\.\\d+(E-?\\d)??", 
      "%% u /= v = -?\\d+\\.\\d+(E-?\\d)??" 
    }); 
  } 
} ///:~ 

The first thing you will see are some shorthand methods for printing: the printInt( ) prints a String followed by an int and the printFloat( ) prints a String followed by a float.

To generate numbers, the program first creates a Random object. Because no arguments are passed during creation, Java uses the current time as a seed for the random number generator. The program generates a number of different types of random numbers with the Random object simply by calling the methods: nextInt( ) and nextFloat( ) (you can also call nextLong( ) or nextDouble( )).

The modulus operator, when used with the result of the random number generator, limits the result to an upper bound of the operand minus 1 (99 in this case).

Regular expressions

Since random numbers are used to generate the output for this program, the expect( ) statement can’t just show literal output as it did before, since the output will vary from one run to the next. To solve this problem, regular expressions, a new feature introduced in Java JDK 1.4 (but an old feature in languages like Perl and Python) will be used inside the expect( ) statement. Although coverage of this intensely powerful tool doesn’t occur until Chapter 12, to understand these statements you’ll need an introduction to regular expressions. Here, you’ll learn just enough to read the expect( ) statements, but if you want a full description, look up java.util.regex.Pattern in the downloadable JDK documentation.

A regular expression is a way to describe strings in general terms, so that you can say: “If a string has these things in it, then it matches what I’m looking for.” For example, to say that a number might or might not be preceded by a minus sign, you put in the minus sign followed by a question mark, like this:

-? 

To describe an integer, you say that it’s one or more digits. In regular expressions, a digit is ‘\d’, but in a Java String you have to “escape” the backslash by putting in a second backslash: ‘\\d’. To indicate “one or more of the preceding expression” in regular expressions, you use the ‘+’. So to say “possibly a minus sign, followed by one or more digits,” you write:

-?\\d+ 

Which you can see in the first lines of the expect( ) statement in the preceding code.

One thing that is not part of the regular expression syntax is the ‘%%’ (note the space included for readability) at the beginning of the lines in the expect( ) statement. This is a flag used by simpletest to indicate that the rest of the line is a regular expression. So you won’t see it in normal regular expressions, only in simpletest expect( ) statements.

Any other characters that are not special characters to regular expression searches are treated as exact matches. So in the first line:

%% j = -?\\d+ 

The ‘j = ’ is matched exactly. However, in the third line, the ‘+’ in ‘j + k’ must be escaped because it is a special regular expression character, as is ‘*’. The rest of the lines should be understandable from this introduction. Later in the book, when additional features of regular expressions are used inside expect( ) statements, they will be explained.

Unary minus and plus operators

The unary minus (-)and unary plus (+) are the same operators as binary minus and plus. The compiler figures out which use is intended by the way you write the expression. For instance, the statement

x = -a; 

has an obvious meaning. The compiler is able to figure out:

x = a * -b; 

but the reader might get confused, so it is clearer to say:

x = a * (-b); 

Unary minus inverts the sign on the data. Unary plus provides symmetry with unary minus, although it doesn’t have any effect.

Auto increment and decrement

Java, like C, is full of shortcuts. Shortcuts can make code much easier to type, and either easier or harder to read.

Two of the nicer shortcuts are the increment and decrement operators (often referred to as the auto-increment and auto-decrement operators). The decrement operator is -- and means “decrease by one unit.” The increment operator is ++ and means “increase by one unit.” If a is an int, for example, the expression ++a is equivalent to (a = a + 1). Increment and decrement operators not only modify the variable, but also produce the value of the variable as a result.

There are two versions of each type of operator, often called the prefix and postfix versions. Pre-increment means the ++ operator appears before the variable or expression, and post-increment means the ++ operator appears after the variable or expression. Similarly, pre-decrement means the -- operator appears before the variable or expression, and post-decrement means the -- operator appears after the variable or expression. For pre-increment and pre-decrement, (i.e., ++a or --a), the operation is performed and the value is produced. For post-increment and post-decrement (i.e. a++ or a--), the value is produced, then the operation is performed. As an example:

//: c03:AutoInc.java 
// Demonstrates the ++ and -- operators. 
import com.bruceeckel.simpletest.*; 

public class AutoInc { 
  static Test monitor = new Test(); 
  public static void main(String[] args) { 
    int i = 1; 
    System.out.println("i : " + i); 
    System.out.println("++i : " + ++i); // Pre-increment 
    System.out.println("i++ : " + i++); // Post-increment 
    System.out.println("i : " + i); 
    System.out.println("--i : " + --i); // Pre-decrement 
    System.out.println("i-- : " + i--); // Post-decrement 
    System.out.println("i : " + i); 
    monitor.expect(new String[] { 
      "i : 1", 
      "++i : 2", 
      "i++ : 2", 
      "i : 3", 
      "--i : 2", 
      "i-- : 2", 
      "i : 1" 
    }); 
  } 
} ///:~ 

You can see that for the prefix form, you get the value after the operation has been performed, but with the postfix form, you get the value before the operation is performed. These are the only operators (other than those involving assignment) that have side effects. (That is, they change the operand rather than using just its value.)

The increment operator is one explanation for the name C++, implying “one step beyond C.” In an early Java speech, Bill Joy (one of the Java creators), said that “Java=C++--” (C plus plus minus minus), suggesting that Java is C++ with the unnecessary hard parts removed, and therefore a much simpler language. As you progress in this book, you’ll see that many parts are simpler, and yet Java isn’t that much easier than C++.

Relational operators

Relational operators generate a boolean result. They evaluate the relationship between the values of the operands. A relational expression produces true if the relationship is true, and false if the relationship is untrue. The relational operators are less than (<), greater than (>), less than or equal to (<=), greater than or equal to (>=), equivalent (==) and not equivalent (!=). Equivalence and nonequivalence work with all built-in data types, but the other comparisons won’t work with type boolean.

Testing object equivalence

The relational operators == and != also work with all objects, but their meaning often confuses the first-time Java programmer. Here’s an example:

//: c03:Equivalence.java 
import com.bruceeckel.simpletest.*; 

public class Equivalence { 
  static Test monitor = new Test(); 
  public static void main(String[] args) { 
    Integer n1 = new Integer(47); 
    Integer n2 = new Integer(47); 
    System.out.println(n1 == n2); 
    System.out.println(n1 != n2); 
    monitor.expect(new String[] { 
      "false", 
      "true" 
    }); 
  } 
} ///:~ 

The expression System.out.println(n1 == n2) will print the result of the boolean comparison within it. Surely the output should be true and then false, since both Integer objects are the same. But while the contents of the objects are the same, the references are not the same and the operators == and != compare object references. So the output is actually false and then true. Naturally, this surprises people at first.

What if you want to compare the actual contents of an object for equivalence? You must use the special method equals( ) that exists for all objects (not primitives, which work fine with == and !=). Here’s how it’s used:

//: c03:EqualsMethod.java 
import com.bruceeckel.simpletest.*; 

public class EqualsMethod { 
  static Test monitor = new Test(); 
  public static void main(String[] args) { 
    Integer n1 = new Integer(47); 
    Integer n2 = new Integer(47); 
    System.out.println(n1.equals(n2)); 
    monitor.expect(new String[] { 
      "true" 
    }); 
  } 
} ///:~ 

The result will be true, as you would expect. Ah, but it’s not as simple as that. If you create your own class, like this:

//: c03:EqualsMethod2.java 
import com.bruceeckel.simpletest.*; 

class Value { 
  int i; 
} 

public class EqualsMethod2 { 
  static Test monitor = new Test(); 
  public static void main(String[] args) { 
    Value v1 = new Value(); 
    Value v2 = new Value(); 
    v1.i = v2.i = 100; 
    System.out.println(v1.equals(v2)); 
    monitor.expect(new String[] { 
      "false" 
    }); 
  } 
} ///:~ 

you’re back to square one: the result is false. This is because the default behavior of equals( ) is to compare references. So unless you override equals( ) in your new class you won’t get the desired behavior.

Unfortunately, you won’t learn about overriding until Chapter 7 and about the proper way to define equals( ) until Chapter 11, but being aware of the way equals( ) behaves might save you some grief in the meantime.

Most of the Java library classes implement equals( ) so that it compares the contents of objects instead of their references.

Logical operators

Each of the logical operators AND (&&), OR (||) and NOT (!) produces a boolean value of true or false based on the logical relationship of its arguments. This example uses the relational and logical operators:

//: c03:Bool.java 
// Relational and logical operators. 
import com.bruceeckel.simpletest.*; 
import java.util.*; 

public class Bool { 
  static Test monitor = new Test(); 
  public static void main(String[] args) { 
    Random rand = new Random(); 
    int i = rand.nextInt(100); 
    int j = rand.nextInt(100); 
    System.out.println("i = " + i); 
    System.out.println("j = " + j); 
    System.out.println("i > j is " + (i > j)); 
    System.out.println("i < j is " + (i < j)); 
    System.out.println("i >= j is " + (i >= j)); 
    System.out.println("i <= j is " + (i <= j)); 
    System.out.println("i == j is " + (i == j)); 
    System.out.println("i != j is " + (i != j)); 
    // Treating an int as a boolean is not legal Java: 
//! System.out.println("i && j is " + (i && j)); 
//! System.out.println("i || j is " + (i || j)); 
//! System.out.println("!i is " + !i); 
    System.out.println("(i < 10) && (j < 10) is " 
       + ((i < 10) && (j < 10)) ); 
    System.out.println("(i < 10) || (j < 10) is " 
       + ((i < 10) || (j < 10)) ); 
    monitor.expect(new String[] { 
      "%% i = -?\\d+", 
      "%% j = -?\\d+", 
      "%% i > j is (true|false)", 
      "%% i < j is (true|false)", 
      "%% i >= j is (true|false)", 
      "%% i <= j is (true|false)", 
      "%% i == j is (true|false)", 
      "%% i != j is (true|false)", 
      "%% \\(i < 10\\) && \\(j < 10\\) is (true|false)", 
      "%% \\(i < 10\\) \\|\\| \\(j < 10\\) is (true|false)" 
    }); 
  } 
} ///:~ 

In the regular expressions in the expect( ) statement, parentheses have the effect of grouping an expression, and the vertical bar ‘|’ means OR. So:

(true|false) 

Means that this part of the string may be either ‘true’ or ‘false’. Because these characters are special in regular expressions, they must be escaped with a ‘\\’ if you want them to appear as ordinary characters in the expression.

You can apply AND, OR, or NOT to boolean values only. You can’t use a non-boolean as if it were a boolean in a logical expression as you can in C and C++. You can see the failed attempts at doing this commented out with a //! comment marker. The subsequent expressions, however, produce boolean values using relational comparisons, then use logical operations on the results.

Note that a boolean value is automatically converted to an appropriate text form if it’s used where a String is expected.

You can replace the definition for int in the preceding program with any other primitive data type except boolean. Be aware, however, that the comparison of floating-point numbers is very strict. A number that is the tiniest fraction different from another number is still “not equal.” A number that is the tiniest bit above zero is still nonzero.

Short-circuiting

When dealing with logical operators, you run into a phenomenon called “short circuiting.” This means that the expression will be evaluated only until the truth or falsehood of the entire expression can be unambiguously determined. As a result, the latter parts of a logical expression might not be evaluated. Here’s an example that demonstrates short-circuiting:

//: c03:ShortCircuit.java 
// Demonstrates short-circuiting behavior. 
// with logical operators. 
import com.bruceeckel.simpletest.*; 

public class ShortCircuit { 
  static Test monitor = new Test(); 
  static boolean test1(int val) { 
    System.out.println("test1(" + val + ")"); 
    System.out.println("result: " + (val < 1)); 
    return val < 1; 
  } 
  static boolean test2(int val) { 
    System.out.println("test2(" + val + ")"); 
    System.out.println("result: " + (val < 2)); 
    return val < 2; 
  } 
  static boolean test3(int val) { 
    System.out.println("test3(" + val + ")"); 
    System.out.println("result: " + (val < 3)); 
    return val < 3; 
  } 
  public static void main(String[] args) { 
    if(test1(0) && test2(2) && test3(2)) 
      System.out.println("expression is true"); 
    else 
      System.out.println("expression is false"); 
    monitor.expect(new String[] { 
      "test1(0)", 
      "result: true", 
      "test2(2)", 
      "result: false", 
      "expression is false" 
    }); 
  } 
} ///:~ 

Each test performs a comparison against the argument and returns true or false. It also prints information to show you that it’s being called. The tests are used in the expression:

if(test1(0) && test2(2) && test3(2)) 

You might naturally think that all three tests would be executed, but the output shows otherwise. The first test produced a true result, so the expression evaluation continues. However, the second test produced a false result. Since this means that the whole expression must be false, why continue evaluating the rest of the expression? It could be expensive. The reason for short-circuiting, in fact, is that you can get a potential performance increase if all the parts of a logical expression do not need to be evaluated.

Bitwise operators

The bitwise operators allow you to manipulate individual bits in an integral primitive data type. Bitwise operators perform Boolean algebra on the corresponding bits in the two arguments to produce the result.

The bitwise operators come from C’s low-level orientation, where you often manipulate hardware directly and must set the bits in hardware registers. Java was originally designed to be embedded in TV set-top boxes, so this low-level orientation still made sense. However, you probably won’t use the bitwise operators much.

The bitwise AND operator (&) produces a one in the output bit if both input bits are one, otherwise it produces a zero. The bitwise OR operator (|) produces a one in the output bit if either input bit is a one and produces a zero only if both input bits are zero. The bitwise EXCLUSIVE OR, or XOR (^), produces a one in the output bit if one or the other input bit is a one, but not both. The bitwise NOT (~, also called the ones complement operator) is a unary operator; it takes only one argument. (All other bitwise operators are binary operators.) Bitwise NOT produces the opposite of the input bit—a one if the input bit is zero, a zero if the input bit is one.

The bitwise operators and logical operators use the same characters, so it is helpful to have a mnemonic device to help you remember the meanings: because bits are “small,” there is only one character in the bitwise operators.

Bitwise operators can be combined with the = sign to unite the operation and assignment: &=, |= and ^= are all legitimate. (Since ~ is a unary operator, it cannot be combined with the = sign.)

The boolean type is treated as a one-bit value, so it is somewhat different. You can perform a bitwise AND, OR, and XOR, but you can’t perform a bitwise NOT (presumably to prevent confusion with the logical NOT). For booleans, the bitwise operators have the same effect as the logical operators except that they do not short circuit. Also, bitwise operations on booleans include an XOR logical operator that is not included under the list of “logical” operators. You’re prevented from using booleans in shift expressions, which are described next.

Shift operators

The shift operators also manipulate bits. They can be used solely with primitive, integral types. The left-shift operator (<<) produces the operand to the left of the operator shifted to the left by the number of bits specified after the operator (inserting zeroes at the lower-order bits). The signed right-shift operator (>>) produces the operand to the left of the operator shifted to the right by the number of bits specified after the operator. The signed right shift >> uses sign extension: if the value is positive, zeroes are inserted at the higher-order bits; if the value is negative, ones are inserted at the higher-order bits. Java has also added the unsigned right shift >>>, which uses zero extension: regardless of the sign, zeroes are inserted at the higher-order bits. This operator does not exist in C or C++.

If you shift a char, byte, or short, it will be promoted to int before the shift takes place, and the result will be an int. Only the five low-order bits of the right-hand side will be used. This prevents you from shifting more than the number of bits in an int. If you’re operating on a long, you’ll get a long result. Only the six low-order bits of the right-hand side will be used, so you can’t shift more than the number of bits in a long.

Shifts can be combined with the equal sign (<<= or >>= or >>>=). The lvalue is replaced by the lvalue shifted by the rvalue. There is a problem, however, with the unsigned right shift combined with assignment. If you use it with byte or short, you don’t get the correct results. Instead, these are promoted to int and right shifted, but then truncated as they are assigned back into their variables, so you get -1 in those cases. The following example demonstrates this:

//: c03:URShift.java 
// Test of unsigned right shift. 
import com.bruceeckel.simpletest.*; 

public class URShift { 
  static Test monitor = new Test(); 
  public static void main(String[] args) { 
    int i = -1; 
    System.out.println(i >>>= 10); 
    long l = -1; 
    System.out.println(l >>>= 10); 
    short s = -1; 
    System.out.println(s >>>= 10); 
    byte b = -1; 
    System.out.println(b >>>= 10); 
    b = -1; 
    System.out.println(b>>>10); 
    monitor.expect(new String[] { 
      "4194303", 
      "18014398509481983", 
      "-1", 
      "-1", 
      "4194303" 
    }); 
  } 
} ///:~ 

In the last shift, the resulting value is not assigned back into b, but is printed directly, so the correct behavior occurs.

Here’s an example that demonstrates the use of all the operators involving bits:

//: c03:BitManipulation.java 
// Using the bitwise operators. 
import com.bruceeckel.simpletest.*; 
import java.util.*; 

public class BitManipulation { 
  static Test monitor = new Test(); 
  public static void main(String[] args) { 
    Random rand = new Random(); 
    int i = rand.nextInt(); 
    int j = rand.nextInt(); 
    printBinaryInt("-1", -1); 
    printBinaryInt("+1", +1); 
    int maxpos = 2147483647; 
    printBinaryInt("maxpos", maxpos); 
    int maxneg = -2147483648; 
    printBinaryInt("maxneg", maxneg); 
    printBinaryInt("i", i); 
    printBinaryInt("~i", ~i); 
    printBinaryInt("-i", -i); 
    printBinaryInt("j", j); 
    printBinaryInt("i & j", i & j); 
    printBinaryInt("i | j", i | j); 
    printBinaryInt("i ^ j", i ^ j); 
    printBinaryInt("i << 5", i << 5); 
    printBinaryInt("i >> 5", i >> 5); 
    printBinaryInt("(~i) >> 5", (~i) >> 5); 
    printBinaryInt("i >>> 5", i >>> 5); 
    printBinaryInt("(~i) >>> 5", (~i) >>> 5); 

    long l = rand.nextLong(); 
    long m = rand.nextLong(); 
    printBinaryLong("-1L", -1L); 
    printBinaryLong("+1L", +1L); 
    long ll = 9223372036854775807L; 
    printBinaryLong("maxpos", ll); 
    long lln = -9223372036854775808L; 
    printBinaryLong("maxneg", lln); 
    printBinaryLong("l", l); 
    printBinaryLong("~l", ~l); 
    printBinaryLong("-l", -l); 
    printBinaryLong("m", m); 
    printBinaryLong("l & m", l & m); 
    printBinaryLong("l | m", l | m); 
    printBinaryLong("l ^ m", l ^ m); 
    printBinaryLong("l << 5", l << 5); 
    printBinaryLong("l >> 5", l >> 5); 
    printBinaryLong("(~l) >> 5", (~l) >> 5); 
    printBinaryLong("l >>> 5", l >>> 5); 
    printBinaryLong("(~l) >>> 5", (~l) >>> 5); 
    monitor.expect("BitManipulation.out"); 
  } 
  static void printBinaryInt(String s, int i) { 
    System.out.println( 
      s + ", int: " + i + ", binary: "); 
    System.out.print("   "); 
    for(int j = 31; j >= 0; j--) 
      if(((1 << j) &  i) != 0) 
        System.out.print("1"); 
      else 
        System.out.print("0"); 
    System.out.println(); 
  } 
  static void printBinaryLong(String s, long l) { 
    System.out.println( 
      s + ", long: " + l + ", binary: "); 
    System.out.print("   "); 
    for(int i = 63; i >= 0; i--) 
      if(((1L << i) & l) != 0) 
        System.out.print("1"); 
      else 
        System.out.print("0"); 
    System.out.println(); 
  } 
} ///:~ 

The two methods at the end, printBinaryInt( ) and printBinaryLong( ), take an int or a long, respectively, and print it out in binary format along with a descriptive string. You can ignore the implementation of these for now.

You’ll note the use of System.out.print( ) instead of System.out.println( ). The print( ) method does not emit a newline, so it allows you to output a line in pieces.

In this case, the expect( ) statement takes a file name, from which it reads the expected lines (which may or may not include regular expressions). This is useful in situations where the output is too long or inappropriate to include in the book. The files ending with “.out” are part of the code distribution, available for download from www.BruceEckel.com, so you can open the file and look at it to see what the output should be (or simply run the program yourself).

As well as demonstrating the effect of all the bitwise operators for int and long, this example also shows the minimum, maximum, +1, and -1 values for int and long so you can see what they look like. Note that the high bit represents the sign: 0 means positive and 1 means negative. The output for the int portion looks like this:

-1, int: -1, binary: 
   11111111111111111111111111111111 
+1, int: 1, binary: 
   00000000000000000000000000000001 
maxpos, int: 2147483647, binary: 
   01111111111111111111111111111111 
maxneg, int: -2147483648, binary: 
   10000000000000000000000000000000 
i, int: 59081716, binary: 
   00000011100001011000001111110100 
~i, int: -59081717, binary: 
   11111100011110100111110000001011 
-i, int: -59081716, binary: 
   11111100011110100111110000001100 
j, int: 198850956, binary: 
   00001011110110100011100110001100 
i & j, int: 58720644, binary: 
   00000011100000000000000110000100 
i | j, int: 199212028, binary: 
   00001011110111111011101111111100 
i ^ j, int: 140491384, binary: 
   00001000010111111011101001111000 
i << 5, int: 1890614912, binary: 
   01110000101100000111111010000000 
i >> 5, int: 1846303, binary: 
   00000000000111000010110000011111 
(~i) >> 5, int: -1846304, binary: 
   11111111111000111101001111100000 
i >>> 5, int: 1846303, binary: 
   00000000000111000010110000011111 
(~i) >>> 5, int: 132371424, binary: 
   00000111111000111101001111100000 

The binary representation of the numbers is referred to as signed two’s complement.

Ternary if-else operator

This operator is unusual because it has three operands. It is truly an operator because it produces a value, unlike the ordinary if-else statement that you’ll see in the next section of this chapter. The expression is of the form:

boolean-exp ? value0 : value1 

If boolean-exp evaluates to true, value0 is evaluated, and its result becomes the value produced by the operator. If boolean-exp is false, value1 is evaluated and its result becomes the value produced by the operator.

Of course, you could use an ordinary if-else statement (described later), but the ternary operator is much terser. Although C (where this operator originated) prides itself on being a terse language, and the ternary operator might have been introduced partly for efficiency, you should be somewhat wary of using it on an everyday basis—it’s easy to produce unreadable code. The conditional operator can be used for its side effects or for the value it produces, but in general you want the value, since that’s what makes the operator distinct from the if-else. Here’s an example:

static int ternary(int i) { 
  return i < 10 ? i * 100 : i * 10; 
} 

You can see that this code is more compact than what you’d need to write without the ternary operator:

static int alternative(int i) { 
  if (i < 10) 
    return i * 100; 
  else 
    return i * 10; 
} 

The second form is easier to understand, and doesn’t require a lot more typing. So be sure to ponder your reasons when choosing the ternary operator—it’s generally warranted when you’re setting a variable to one of two values.

The comma operator

The comma is used in C and C++ not only as a separator in function argument lists, but also as an operator for sequential evaluation. The sole place that the comma operator is used in Java is in for loops, which will be described later in this chapter.

String operator +

There’s one special usage of an operator in Java: the + operator can be used to concatenate strings, as you’ve already seen. It seems a natural use of the + even though it doesn’t fit with the traditional way that + is used. This capability seemed like a good idea in C++, so operator overloading was added to C++ to allow the C++ programmer to add meanings to almost any operator. Unfortunately, operator overloading combined with some of the other restrictions in C++ turns out to be a fairly complicated feature for programmers to design into their classes. Although operator overloading would have been much simpler to implement in Java than it was in C++, this feature was still considered too complex, so Java programmers cannot implement their own overloaded operators like C++ programmers can. The use of the String + has some interesting behavior. If an expression begins with a String, then all operands that follow must be Strings (remember that the compiler will turn a quoted sequence of characters into a String):

int x = 0, y = 1, z = 2; 
String sString = "x, y, z "; 
System.out.println(sString + x + y + z); 

Here, the Java compiler will convert x, y, and z into their String representations instead of adding them together first. And if you say:

System.out.println(x + sString); 

Java will turn x into a String.

Common pitfalls when using operators

One of the pitfalls when using operators is attempting to leave out the parentheses when you are even the least bit uncertain about how an expression will evaluate. This is still true in Java.

An extremely common error in C and C++ looks like this:

while(x = y) { 
  // .... 
} 

The programmer was clearly trying to test for equivalence (==) rather than do an assignment. In C and C++ the result of this assignment will always be true if y is nonzero, and you’ll probably get an infinite loop. In Java, the result of this expression is not a boolean, but the compiler expects a boolean and won’t convert from an int, so it will conveniently give you a compile-time error and catch the problem before you ever try to run the program. So the pitfall never happens in Java. (The only time you won’t get a compile-time error is when x and y are boolean, in which case x = y is a legal expression, and in the preceding example, probably an error.)

A similar problem in C and C++ is using bitwise AND and OR instead of the logical versions. Bitwise AND and OR use one of the characters (& or |) while logical AND and OR use two (&& and ||). Just as with = and ==, it’s easy to type just one character instead of two. In Java, the compiler again prevents this, because it won’t let you cavalierly use one type where it doesn’t belong.

Casting operators

The word cast is used in the sense of “casting into a mold.” Java will automatically change one type of data into another when appropriate. For instance, if you assign an integral value to a floating-point variable, the compiler will automatically convert the int to a float. Casting allows you to make this type conversion explicit, or to force it when it wouldn’t normally happen.

To perform a cast, put the desired data type (including all modifiers) inside parentheses to the left of any value. Here’s an example:

void casts() { 
  int i = 200; 
  long l = (long)i; 
  long l2 = (long)200; 
} 

As you can see, it’s possible to perform a cast on a numeric value as well as on a variable. In both casts shown here, however, the cast is superfluous, since the compiler will automatically promote an int value to a long when necessary. However, you are allowed to use superfluous casts to make a point or to make your code more clear. In other situations, a cast may be essential just to get the code to compile.

In C and C++, casting can cause some headaches. In Java, casting is safe, with the exception that when you perform a so-called narrowing conversion (that is, when you go from a data type that can hold more information to one that doesn’t hold as much), you run the risk of losing information. Here the compiler forces you to do a cast, in effect saying “this can be a dangerous thing to do—if you want me to do it anyway you must make the cast explicit.” With a widening conversion an explicit cast is not needed, because the new type will more than hold the information from the old type so that no information is ever lost.

Java allows you to cast any primitive type to any other primitive type, except for boolean, which doesn’t allow any casting at all. Class types do not allow casting. To convert one to the other, there must be special methods. (String is a special case, and you’ll find out later in this book that objects can be cast within a family of types; an Oak can be cast to a Tree and vice-versa, but not to a foreign type such as a Rock.)

Literals

Ordinarily, when you insert a literal value into a program, the compiler knows exactly what type to make it. Sometimes, however, the type is ambiguous. When this happens, you must guide the compiler by adding some extra information in the form of characters associated with the literal value. The following code shows these characters:

//: c03:Literals.java 

public class Literals { 
  char c = 0xffff; // max char hex value 
  byte b = 0x7f; // max byte hex value 
  short s = 0x7fff; // max short hex value 
  int i1 = 0x2f; // Hexadecimal (lowercase) 
  int i2 = 0X2F; // Hexadecimal (uppercase) 
  int i3 = 0177; // Octal (leading zero) 
  // Hex and Oct also work with long. 
  long n1 = 200L; // long suffix 
  long n2 = 200l; // long suffix (but can be confusing) 
  long n3 = 200; 
  //! long l6(200); // not allowed 
  float f1 = 1; 
  float f2 = 1F; // float suffix 
  float f3 = 1f; // float suffix 
  float f4 = 1e-45f; // 10 to the power 
  float f5 = 1e+9f; // float suffix 
  double d1 = 1d; // double suffix 
  double d2 = 1D; // double suffix 
  double d3 = 47e47d; // 10 to the power 
} ///:~ 

Hexadecimal (base 16), which works with all the integral data types, is denoted by a leading 0x or 0X followed by 0-9 or a-f either in uppercase or lowercase. If you try to initialize a variable with a value bigger than it can hold (regardless of the numerical form of the value), the compiler will give you an error message. Notice in the preceding code the maximum possible hexadecimal values for char, byte, and short. If you exceed these, the compiler will automatically make the value an int and tell you that you need a narrowing cast for the assignment. You’ll know you’ve stepped over the line.

Octal (base 8) is denoted by a leading zero in the number and digits from 0-7. There is no literal representation for binary numbers in C, C++, or Java.

A trailing character after a literal value establishes its type. Uppercase or lowercase L means long, upper or lowercase F means float and uppercase or lowercase D means double.

Exponents use a notation that I’ve always found rather dismaying: 1.39 e-47f. In science and engineering, ‘e’ refers to the base of natural logarithms, approximately 2.718. (A more precise double value is available in Java as Math.E.) This is used in exponentiation expressions such as 1.39 x e-47, which means 1.39 x 2.718-47. However, when FORTRAN was invented, they decided that e would naturally mean “ten to the power,” which is an odd decision because FORTRAN was designed for science and engineering, and one would think its designers would be sensitive about introducing such an ambiguity.1 At any rate, this custom was followed in C, C++ and now Java. So if you’re used to thinking in terms of e as the base of natural logarithms, you must do a mental translation when you see an expression such as 1.39 e-47f in Java; it means 1.39 x 10-47.

Note that you don’t need to use the trailing character when the compiler can figure out the appropriate type. With

long n3 = 200; 

there’s no ambiguity, so an L after the 200 would be superfluous. However, with

float f4 = 1e-47f; // 10 to the power 

the compiler normally takes exponential numbers as doubles, so without the trailing f, it will give you an error telling you that you must use a cast to convert double to float.

Promotion

You’ll discover that if you perform any mathematical or bitwise operations on primitive data types that are smaller than an int (that is, char, byte, or short), those values will be promoted to int before performing the operations, and the resulting value will be of type int. So if you want to assign back into the smaller type, you must use a cast. (And, since you’re assigning back into a smaller type, you might be losing information.) In general, the largest data type in an expression is the one that determines the size of the result of that expression; if you multiply a float and a double, the result will be double; if you add an int and a long, the result will be long.

Java has no “sizeof”

In C and C++, the sizeof( ) operator satisfies a specific need: it tells you the number of bytes allocated for data items. The most compelling need for sizeof( ) in C and C++ is portability. Different data types might be different sizes on different machines, so the programmer must find out how big those types are when performing operations that are sensitive to size. For example, one computer might store integers in 32 bits, whereas another might store integers as 16 bits. Programs could store larger values in integers on the first machine. As you might imagine, portability is a huge headache for C and C++ programmers.

Java does not need a sizeof( ) operator for this purpose, because all the data types are the same size on all machines. You do not need to think about portability on this level—it is designed into the language.

Precedence revisited

Upon hearing me complain about the complexity of remembering operator precedence during one of my seminars, a student suggested a mnemonic that is simultaneously a commentary: “Ulcer Addicts Really Like C A lot.”

Mnemonic

Operator type

Operators

Ulcer

Unary

+ - ++--

Addicts

Arithmetic (and shift)

* / % + - << >>

Really

Relational

> < >= <= == !=

Like

Logical (and bitwise)

&& || & | ^

C

Conditional (ternary)

A > B ? X : Y

A Lot

Assignment

= (and compound assignment like *=)


Of course, with the shift and bitwise operators distributed around the table it is not a perfect mnemonic, but for non-bit operations it works.

A compendium of operators

The following example shows which primitive data types can be used with particular operators. Basically, it is the same example repeated over and over, but using different primitive data types. The file will compile without error because the lines that would cause errors are commented out with a //!.

//: c03:AllOps.java 
// Tests all the operators on all the primitive data types 
// to show which ones are accepted by the Java compiler. 

public class AllOps { 
  // To accept the results of a boolean test: 
  void f(boolean b) {} 
  void boolTest(boolean x, boolean y) { 
    // Arithmetic operators: 
    //! x = x * y; 
    //! x = x / y; 
    //! x = x % y; 
    //! x = x + y; 
    //! x = x - y; 
    //! x++; 
    //! x--; 
    //! x = +y; 
    //! x = -y; 
    // Relational and logical: 
    //! f(x > y); 
    //! f(x >= y); 
    //! f(x < y); 
    //! f(x <= y); 
    f(x == y); 
    f(x != y); 
    f(!y); 
    x = x && y; 
    x = x || y; 
    // Bitwise operators: 
    //! x = ~y; 
    x = x & y; 
    x = x | y; 
    x = x ^ y; 
    //! x = x << 1; 
    //! x = x >> 1; 
    //! x = x >>> 1; 
    // Compound assignment: 
    //! x += y; 
    //! x -= y; 
    //! x *= y; 
    //! x /= y; 
    //! x %= y; 
    //! x <<= 1; 
    //! x >>= 1; 
    //! x >>>= 1; 
    x &= y; 
    x ^= y; 
    x |= y; 
    // Casting: 
    //! char c = (char)x; 
    //! byte B = (byte)x; 
    //! short s = (short)x; 
    //! int i = (int)x; 
    //! long l = (long)x; 
    //! float f = (float)x; 
    //! double d = (double)x; 
  } 
  void charTest(char x, char y) { 
    // Arithmetic operators: 
    x = (char)(x * y); 
    x = (char)(x / y); 
    x = (char)(x % y); 
    x = (char)(x + y); 
    x = (char)(x - y); 
    x++; 
    x--; 
    x = (char)+y; 
    x = (char)-y; 
    // Relational and logical: 
    f(x > y); 
    f(x >= y); 
    f(x < y); 
    f(x <= y); 
    f(x == y); 
    f(x != y); 
    //! f(!x); 
    //! f(x && y); 
    //! f(x || y); 
    // Bitwise operators: 
    x= (char)~y; 
    x = (char)(x & y); 
    x  = (char)(x | y); 
    x = (char)(x ^ y); 
    x = (char)(x << 1); 
    x = (char)(x >> 1); 
    x = (char)(x >>> 1); 
    // Compound assignment: 
    x += y; 
    x -= y; 
    x *= y; 
    x /= y; 
    x %= y; 
    x <<= 1; 
    x >>= 1; 
    x >>>= 1; 
    x &= y; 
    x ^= y; 
    x |= y; 
    // Casting: 
    //! boolean b = (boolean)x; 
    byte B = (byte)x; 
    short s = (short)x; 
    int i = (int)x; 
    long l = (long)x; 
    float f = (float)x; 
    double d = (double)x; 
  } 
  void byteTest(byte x, byte y) { 
    // Arithmetic operators: 
    x = (byte)(x* y); 
    x = (byte)(x / y); 
    x = (byte)(x % y); 
    x = (byte)(x + y); 
    x = (byte)(x - y); 
    x++; 
    x--; 
    x = (byte)+ y; 
    x = (byte)- y; 
    // Relational and logical: 
    f(x > y); 
    f(x >= y); 
    f(x < y); 
    f(x <= y); 
    f(x == y); 
    f(x != y); 
    //! f(!x); 
    //! f(x && y); 
    //! f(x || y); 
    // Bitwise operators: 
    x = (byte)~y; 
    x = (byte)(x & y); 
    x = (byte)(x | y); 
    x = (byte)(x ^ y); 
    x = (byte)(x << 1); 
    x = (byte)(x >> 1); 
    x = (byte)(x >>> 1); 
    // Compound assignment: 
    x += y; 
    x -= y; 
    x *= y; 
    x /= y; 
    x %= y; 
    x <<= 1; 
    x >>= 1; 
    x >>>= 1; 
    x &= y; 
    x ^= y; 
    x |= y; 
    // Casting: 
    //! boolean b = (boolean)x; 
    char c = (char)x; 
    short s = (short)x; 
    int i = (int)x; 
    long l = (long)x; 
    float f = (float)x; 
    double d = (double)x; 
  } 
  void shortTest(short x, short y) { 
    // Arithmetic operators: 
    x = (short)(x * y); 
    x = (short)(x / y); 
    x = (short)(x % y); 
    x = (short)(x + y); 
    x = (short)(x - y); 
    x++; 
    x--; 
    x = (short)+y; 
    x = (short)-y; 
    // Relational and logical: 
    f(x > y); 
    f(x >= y); 
    f(x < y); 
    f(x <= y); 
    f(x == y); 
    f(x != y); 
    //! f(!x); 
    //! f(x && y); 
    //! f(x || y); 
    // Bitwise operators: 
    x = (short)~y; 
    x = (short)(x & y); 
    x = (short)(x | y); 
    x = (short)(x ^ y); 
    x = (short)(x << 1); 
    x = (short)(x >> 1); 
    x = (short)(x >>> 1); 
    // Compound assignment: 
    x += y; 
    x -= y; 
    x *= y; 
    x /= y; 
    x %= y; 
    x <<= 1; 
    x >>= 1; 
    x >>>= 1; 
    x &= y; 
    x ^= y; 
    x |= y; 
    // Casting: 
    //! boolean b = (boolean)x; 
    char c = (char)x; 
    byte B = (byte)x; 
    int i = (int)x; 
    long l = (long)x; 
    float f = (float)x; 
    double d = (double)x; 
  } 
  void intTest(int x, int y) { 
    // Arithmetic operators: 
    x = x * y; 
    x = x / y; 
    x = x % y; 
    x = x + y; 
    x = x - y; 
    x++; 
    x--; 
    x = +y; 
    x = -y; 
    // Relational and logical: 
    f(x > y); 
    f(x >= y); 
    f(x < y); 
    f(x <= y); 
    f(x == y); 
    f(x != y); 
    //! f(!x); 
    //! f(x && y); 
    //! f(x || y); 
    // Bitwise operators: 
    x = ~y; 
    x = x & y; 
    x = x | y; 
    x = x ^ y; 
    x = x << 1; 
    x = x >> 1; 
    x = x >>> 1; 
    // Compound assignment: 
    x += y; 
    x -= y; 
    x *= y; 
    x /= y; 
    x %= y; 
    x <<= 1; 
    x >>= 1; 
    x >>>= 1; 
    x &= y; 
    x ^= y; 
    x |= y; 
    // Casting: 
    //! boolean b = (boolean)x; 
    char c = (char)x; 
    byte B = (byte)x; 
    short s = (short)x; 
    long l = (long)x; 
    float f = (float)x; 
    double d = (double)x; 
  } 
  void longTest(long x, long y) { 
    // Arithmetic operators: 
    x = x * y; 
    x = x / y; 
    x = x % y; 
    x = x + y; 
    x = x - y; 
    x++; 
    x--; 
    x = +y; 
    x = -y; 
    // Relational and logical: 
    f(x > y); 
    f(x >= y); 
    f(x < y); 
    f(x <= y); 
    f(x == y); 
    f(x != y); 
    //! f(!x); 
    //! f(x && y); 
    //! f(x || y); 
    // Bitwise operators: 
    x = ~y; 
    x = x & y; 
    x = x | y; 
    x = x ^ y; 
    x = x << 1; 
    x = x >> 1; 
    x = x >>> 1; 
    // Compound assignment: 
    x += y; 
    x -= y; 
    x *= y; 
    x /= y; 
    x %= y; 
    x <<= 1; 
    x >>= 1; 
    x >>>= 1; 
    x &= y; 
    x ^= y; 
    x |= y; 
    // Casting: 
    //! boolean b = (boolean)x; 
    char c = (char)x; 
    byte B = (byte)x; 
    short s = (short)x; 
    int i = (int)x; 
    float f = (float)x; 
    double d = (double)x; 
  } 
  void floatTest(float x, float y) { 
    // Arithmetic operators: 
    x = x * y; 
    x = x / y; 
    x = x % y; 
    x = x + y; 
    x = x - y; 
    x++; 
    x--; 
    x = +y; 
    x = -y; 
    // Relational and logical: 
    f(x > y); 
    f(x >= y); 
    f(x < y); 
    f(x <= y); 
    f(x == y); 
    f(x != y); 
    //! f(!x); 
    //! f(x && y); 
    //! f(x || y); 
    // Bitwise operators: 
    //! x = ~y; 
    //! x = x & y; 
    //! x = x | y; 
    //! x = x ^ y; 
    //! x = x << 1; 
    //! x = x >> 1; 
    //! x = x >>> 1; 
    // Compound assignment: 
    x += y; 
    x -= y; 
    x *= y; 
    x /= y; 
    x %= y; 
    //! x <<= 1; 
    //! x >>= 1; 
    //! x >>>= 1; 
    //! x &= y; 
    //! x ^= y; 
    //! x |= y; 
    // Casting: 
    //! boolean b = (boolean)x; 
    char c = (char)x; 
    byte B = (byte)x; 
    short s = (short)x; 
    int i = (int)x; 
    long l = (long)x; 
    double d = (double)x; 
  } 
  void doubleTest(double x, double y) { 
    // Arithmetic operators: 
    x = x * y; 
    x = x / y; 
    x = x % y; 
    x = x + y; 
    x = x - y; 
    x++; 
    x--; 
    x = +y; 
    x = -y; 
    // Relational and logical: 
    f(x > y); 
    f(x >= y); 
    f(x < y); 
    f(x <= y); 
    f(x == y); 
    f(x != y); 
    //! f(!x); 
    //! f(x && y); 
    //! f(x || y); 
    // Bitwise operators: 
    //! x = ~y; 
    //! x = x & y; 
    //! x = x | y; 
    //! x = x ^ y; 
    //! x = x << 1; 
    //! x = x >> 1; 
    //! x = x >>> 1; 
    // Compound assignment: 
    x += y; 
    x -= y; 
    x *= y; 
    x /= y; 
    x %= y; 
    //! x <<= 1; 
    //! x >>= 1; 
    //! x >>>= 1; 
    //! x &= y; 
    //! x ^= y; 
    //! x |= y; 
    // Casting: 
    //! boolean b = (boolean)x; 
    char c = (char)x; 
    byte B = (byte)x; 
    short s = (short)x; 
    int i = (int)x; 
    long l = (long)x; 
    float f = (float)x; 
  } 
} ///:~ 

Note that boolean is quite limited. You can assign to it the values true and false, and you can test it for truth or falsehood, but you cannot add booleans or perform any other type of operation on them.

In char, byte, and short, you can see the effect of promotion with the arithmetic operators. Each arithmetic operation on any of those types produces an int result, which must be explicitly cast back to the original type (a narrowing conversion that might lose information) to assign back to that type. With int values, however, you do not need to cast, because everything is already an int. Don’t be lulled into thinking everything is safe, though. If you multiply two ints that are big enough, you’ll overflow the result. The following example demonstrates this:

//: c03:Overflow.java 
// Surprise! Java lets you overflow. 
import com.bruceeckel.simpletest.*; 

public class Overflow { 
  static Test monitor = new Test(); 
  public static void main(String[] args) { 
    int big = 0x7fffffff; // max int value 
    System.out.println("big = " + big); 
    int bigger = big * 4; 
    System.out.println("bigger = " + bigger); 
    monitor.expect(new String[] { 
      "big = 2147483647", 
      "bigger = -4" 
    }); 
  } 
} ///:~ 

You get no errors or warnings from the compiler, and no exceptions at run time. Java is good, but it’s not that good.

Compound assignments do not require casts for char, byte, or short, even though they are performing promotions that have the same results as the direct arithmetic operations. On the other hand, the lack of the cast certainly simplifies the code.

You can see that, with the exception of boolean, any primitive type can be cast to any other primitive type. Again, you must be aware of the effect of a narrowing conversion when casting to a smaller type, otherwise you might unknowingly lose information during the cast.

  • + Share This
  • 🔖 Save To Your Account