In Java you manipulate objects and 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.
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. You should be reasonably comfortable with the general concept of operators from your previous programming experience. 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 ‘+=’.
93
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 a 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 handle 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 is copied into A. If you then go on to modify A, B is naturally unaffected by this modification.
This is what you’ve come to expect as a programmer for most situations.
When you assign objects, however, things change. Whenever you manipulate an object, what you’re manipulating is the handle, so when you assign “from one object to another”
you’re actually copying a handle 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. The following example will demonstrate this.
As an aside, the first thing you see is a package statement for package c03, indicating this book’s Chapter 3. The first code listing of each chapter will contain a package statement like this to establish the chapter number for the remaining code listings in that chapter. In Chapter 17, you’ll see that as a result, all the listings in chapter 3 (except those that have different package names) will be automatically placed in a subdirectory called c03, Chapter 4’s listings will be in c04 and so on. All this will happen via the CodePackager.java program shown in Chapter 17, and in Chapter 5 the concept of packages will be fully explained. What you need to recognize at this point is that, for this book, lines of code of the form package c03 are used just to establish the chapter subdirectory for the listings in the chapter.
In order to run the program, you must ensure that the classpath contains the root directory where you installed the source code for this book. (From this directory, you’ll see the subdirectories c02, c03, c04, etc.)
For later versions of Java (1.1.4 and on), when your main( ) is inside a file with a package statement, you must give the full package name before the program name in order to run the program. In this case, the command line is:
94
Thinking in Java
www.BruceEckel.com
java c03.Assignment
Keep this in mind any time you’re running a program that’s in a package.
Here’s the example:
//: Assignment.java