Java Data and Operators

1. Introduction

OBJECTIVES

After studying this chapter, you will 

• Understand the role that data play in effective program design. 
• Be able to use all of Java’s primitive types and their operators.
• Appreciate the importance of information hiding. 
• Be able to use class constants and class methods. 
• Know how to use Java’s Math and NumberFormat classes. 
• Be able to perform various kinds of data conversions.

This chapter has two primary goals. One is to elaborate on Java's primitive data types, which were first introduced in Chapter 1. We will cover boolean, integer, character, and real number data types, including the various operations that you can perform on these types. We will provide examples, including several modifications of the OneRowNim class, to show typical uses of the various data types. 

Our second goal is to illustrate the idea that programming is a matter of choosing an appropriate way to represent a problem as well as choosing an appropriate sequence of actions to solve the problem. Programming is a form of problem solving that can be viewed as a two-part process: representation and action.

Representation means finding a way to look at the problem. This might involve seeing the problem as closely related to a known problem or seeing that parts of the problem can be broken up into smaller problems that you already know how to solve. In terms of programming problems, representation often means choosing the right kinds of objects and structures. 

Action is the process of taking well-defined steps to solve a problem. Given a particular way of representing the problem, what steps must we take to arrive at its solution? 

Choosing an appropriate representation is often the key to solving a problem. For example, consider this problem: Can a chess board, with its top-left and bottom-right squares removed, be completely tiled by dominoes that cover two squares at a time? 

One way to solve this problem might be to represent the chess board and dominoes as shown in Figure 5.1. If we represent the board in this way, then the actions needed to arrive at a solution involve searching for a tiling that completely covers the board. In other words, we can try one way of placing the dominoes on the board. If that doesn't work, we try another way. And so on. This process will be very time consuming, because there are millions of different ways of trying to tile the board.

An alternative way to represent this problem comes from seeing that the top-left and bottom-right squares of the board are both white. If you remove them, you'll have a board with 62 squares, 32 black and 30 white. Because each domino must cover one white and one black square, it is impossible to tile a board with an unequal number of black and white squares.

Thus, by representing the problem as the total number of black and white squares, the actions required to solve it involve a very simple reasoning process. This representation makes it almost trivial to find the solution. On the other hand, the brute force representation presented first - trying all possible combinations - made it almost impossible to solve the problem.

Source: R. Morelli and R. Walde, Trinity College
This work is licensed under a Creative Commons Attribution 4.0 License.

2. Boolean Data and Operators

George Boole

As we have learned, the boolean type is one of Java's primitive types. For this type, there are only two possible values, true and false. The boolean type is derived from the work of British mathematician George Boole, who in the 1850s, developed an algebra to process logical expressions such as p and q. Such boolean expressions produce a value that is either true or false. Every modern programming language provides some means of representing boolean expressions.

Conditional statement

The boolean type has several important uses. As we saw in Chapter 1, expressions of the form num == 7 and 5<7 have boolean values. Similarly, as we saw in Chapter 3, the boolean type is also used to represent the condition in the if statement:

  if (boolean expression)
 statement ;

Boolean flag

For this reason, boolean expressions are also called conditions. Along these same lines, a boolean variable can be used as a flag or a signal to "remember" whether or not a certain condition holds. For example, in the following code fragment, we use isDone to mark when a particular process is completed:

boolean isDone = false;        // Initialize the flag
...                            // Do some processing task
isDone = true;                 // Set flag when the task done
...                            // Do some other stuff
if (isDone)                    // Check if finished the task
...                            // If so, do something
else                                      
...                            // Or, do something else

2.1. Boolean (or Logical) Operations

Data and operations

Like all the other simple data types, the boolean type consists of certain data - the values true and false - and certain actions or operations that can be performed on those data. For the boolean type there are four basic operations: AND (&&), OR (||), EXCLUSIVE-OR (^), and NOT (!). These are defined in the truth table shown in Table 5.1. A truth tables defines boolean operators by giving their values in all possible situations. The first two columns of the table give possible boolean values for two operands, o1 and o2. An operand is a value used in an operation. Note that each row gives a different value assignment to the two operands, so that all possible assignments are represented. The remaining columns give the values that result for the various operators given the assignment of values to o1 and o2.

TABLE 5.1 Truth-table definitions of the boolean operators: AND (&&), OR (||), EXCLUSIVE-OR (^), and NOT (!)

Binary operator

To see how to read this table, let's look at the AND operation, which is defined in column 3. The AND operator is a binary operator - that is, it Binary operator requires two operands, o1 and o2. If both o1 and o2 are true, then (o1 && o2) is true (row1). If either o1 or o2 or both o1 and o2 are false, then the expression (o1 && o2) is false (rows 2 and 3). The only case in which (o1 && o2) is true is when both o1 and o2 are true (row 4).

The boolean OR operation (column 4 of Table 5.1) is also a binary operation. If both o1 and o2 are false, then (o1 || o2) is false (row 4). If either o1 or o2 or both o1 and o2 are true, then the expression (o1 || o2) is true (rows 1-3). Thus, the only case in which (o1 || o2) is false is when both o1 and o2 are false.

The boolean EXCLUSIVE-OR operation (column 5 of Table 5.1) is a binary operation, which differs from the OR operator in that it is true when either o1 or o2 is true (rows 2 and 3), but it is false when both o1 and o2 are true (row 1).

Unary operator

The NOT operation (the last column of Table 5.1) is a unary operator - it takes only one operand - and it simply reverses the truth value of its operand. Thus, if o1 is true, !o1 is false, and vice versa.

2.2. Precedence and Associativity

In order to evaluate complex boolean expressions, it is necessary to understand the order in which boolean operations are carried out by the computer. For example, what is the value of the following expression?

Parentheses supersede

As this example illustrates, the boolean operators have a built-in precedence order which is used to determine how boolean expressions are to be evaluated (Table 5.2). A simple method for evaluating an expression is to parenthesize the expression and then evaluate it. For example, to evaluate the complex expression

would be evaluated as follows:

2.3. Short-Circuit Evaluation

Another important feature of the boolean operators is that they utilize a form of evaluation known as short-circuit evaluation. In short-circuit evaluation, a boolean expression is evaluated from left to right, and the evaluation is discontinued as soon as the expression's value can be determined, regardless of whether it contains additional operators and operands. For example, in the expression

In addition to being a more efficient form of evaluating boolean expressions, short-circuit evaluation has some practical uses. For example, we can use short-circuit evaluation to guard against null pointer exceptions. Recall from Chapter 2 that a null pointer exception results when you try to use an uninstantiated reference variable - that is, a reference variable that has not been assigned an object. For example, if we declare a OneRowNim variable without instantiating it and then try to use it, a null pointer exception will result:

In this code, a null pointer exception results when we use game in the method call game.gameOver(). We can use short-circuit evaluation to prevent the exception from occurring:

2.4. Are We Computers?

George Boole published his seminal work, An Investigation of the Laws of Thought, in 1854. His achievement was in developing an algebra for logic - that is, a purely abstract and symbolic system for representing the laws of logic. Boole's was not the first attempt to explore the relationship between the human mind and an abstract system of computation. Back in 1655, Thomas Hobbes had already claimed that all thought was computation.

It is estimated that the human brain contains (10¹² = 10,000,000,000,000) neurons, and each neuron contains something like 10,000 dendrites, the fibers that connect one neuron to another. Together, the neurons and dendrites make up a web of enormous complexity. Since the 1840s it has been known that the brain is primarily electrical, and by the 1940s scientists had developed a pretty good model of the electrical interactions among neurons. According to this model, neurons emit short bursts of electricity along their axons, which function like output wires. The bursts leap over the gap separating axons and dendrites, which function like the neurons' input wires.

In 1943, just before the first digital computers were developed, Warren McCulloch, a neurophysiologist, and Walter Pitts, a mathematician, published a paper titled, "A Logical Calculus of the Ideas Imminent in Nervous Activity". In this paper, they showed that all of the boolean operators - AND, OR, NOT, and EXCLUSIVE-OR - could be represented by the behavior of small sets of neurons. For example, they showed that three neurons could be connected together in such a way that the third neuron fired if and only if both of the other two neurons fired. This is exactly analogous to the definition of the boolean AND operator.

A few years later, when the first computers were built, many scientists and philosophers were struck by the similarity between the logic elements that made up the computer's circuits and the neuronal models that McCulloch and Pitts had developed.

The area of neural networks is a branch of artificial intelligence (one of the applied areas of computer science) and is based on this insight by McCulloch and Pitts. Researchers in this exciting and rapidly advancing field develop neural network models of various kinds of human thinking and perception.

2.5. Using Booleans in OneRowNim

Now that we have introduced the boolean data type, let's use it to improve the OneRowNim class, the latest version of which, from Chapter 3, is given in Figure 3.16 . Previously we used an int variable, player, to represent who's turn it is. For a two-person game, such as One Row Nim, a boolean variable is well suited for this purpose, because it can toggle between true and false. For example, let's declare a variable, onePlaysNext, and initialize it to true, to represent the fact that player one will play first:

private boolean  onePlaysNext =   true ; 

When onePlaysNext is true, it will be player one's turn. When it is false, it will be player two's turn. Note that we are deliberately remaining uncommitted as to whether one or the other player is the computer.

Given this new variable, it is necessary to redefine the methods that had previously used the player variable. The first method that needs revision is the constructor:

public  OneRowNim (int sticks, int starter)
{    nSticks = sticks;
     onePlaysNext  = (starter  == 1); 
}    // OneRowNim () constructor3

In the constructor, the starter parameter is used with a value of 1 or 2 to set which player goes first. Note how we use an assignment statement to set onePlaysNext to true if starter equals 1; otherwise it is set to false. The assignment statement first evaluates the expression on its right hand side (starter == 1). Because this is a boolean expression, it will have a value of true or false, which will be assigned to onePlaysNext. Thus, the assignment statement is equivalent to the following if/else statement:

if
  (player==1)
   onePlaysNext = true;
else
onePlaysNext =false;
,

The remaining changes are shown in Figure 5.2 . There are only two instance methods that need revision to accommodate the use of boolean  variables. The takeSticks() method contains two revisions. The first uses the boolean OR operator to test whether a move is valid:

public booleantakeSticks (int num)
{   if (num < 1 || num >3 || num > nSticks)
          return false;         //Error
    else                       //Valid move
    {         nSticks = nSticks - num;
              onePlaysNext = !onePlaysNext;
              return true;
    }   // else
}   // takeSticks ()

It also uses the boolean NOT operator to toggle the value of onePlaysNext, to switch to the other player's turn:

onePlaysNext = !onePlaysNext; 

Finally, the getPlayer() method now uses a if/else statement to return either 1 or 2 depending on who's turn it is:

public int getPlayer ()
{   if (onePlaysNext)
         return 1;
        else return2;
}  // getPlayer ()

3. Numeric Data and Operators

Java has two kinds of numeric data: integers, which have no fractional part, and real numbers or floating-point numbers, which contain a fractional component. Java recognizes four different kinds of integers: byte, short, int, and long, which are distinguished by the number of bits used to represent them. A binary digit, or bit, is a 0 or a 1. (Recall that computers read instructions as series of 0s and 1s.) Java has two different kinds of real numbers, float and double, which are also distinguished by the number of bits used to represent them. See Table 5.3.

public class OneRowNim 
{     private int nSticks = 7; 
      private boolean onePlaysNext = true; 
      public OneRowNim()            
      {
      } //OneRowNim() constructor1
      public OneRowNim(int sticks)
      { nSticks = sticks;    
      } // OneRowNim() constructor2 
      public OneRowNim(int sticks, int starter) 
      { nSticks = sticks; 
       onePlaysNext = (starter - 1); 
      } // OneRowNim() constructor3 
      public boolean takeSticks(int num) 
      { if (num < 1 num > 3 II num > nSticks)
            return false;     // Error 
        else                    // valid move 
      {  nSticks = nSticks — num;
         onePlaysNext = ! onePlaysNext; 
         return true;
        } // else
      } // takeSticks ()     
      public int getSticks () 
      { return nSticks; } {\ color{cyan} // getSticks 
      public int getPlayer () 
     {   if (onePlaysNext) return   1; 
         else return 2;                
     } // getPlayer ()        
     public boolean gameOver() 
     { return (nSticks <= 0); 
     } // gameOver () 
     public int getWinner () 
     { if (nSticks < 1) return getPlayer (); 
       else return 0; // game is not over 
     } // getWinner () 
     public void report () 
     { System. out. println ("Number of sticks left :                  
                              +  getSticks ()); 
       System. out . println ("Next turn by player"
                              + getPlayer ());  
     } // report ()               
     } // OneRowNim class

The more bits a data type has, the more values it can represent. One bit can represent two possible values, 1 and 0, which can be used to stand for true and false, respectively. Two bits can represent four possible values: 00, 01, 10, and 11; three bits can represent eight possible values: 000, 001, 010, 100, 101, 110, 011, 111. And, in general, an n-bit quantity can represent 2ⁿ different values.

Integer data types

As illustrated in Table 5.3, the various integer types represent positive or negative whole numbers. Perhaps the most commonly used integer type in Java is the int type, which is represented in 32 bits. This means that Java can represent 2³² different int values, which range from 2,147,483,648 to 2,147,483,647, that is, from - 2³¹ to (2³¹ -1). Similarly, an 8-bit integer, a byte, can represent 2⁸ or 256 different values, ranging Integer data types from 128 to +127. A 16-bit integer, a short, can represent 2¹⁶ different values, which range from 32768 to 32767. And a 64-bit integer, a long, can represent whole number values ranging from 2⁶³ to 2⁶³ -1.

For floating-point numbers, a 32-bit float type can represent 2³² different real numbers and a 64-bit double value can represent 2⁶⁴ different real numbers.

JAVA EFFECTIVE DESIGN Platform Independence. In Java, a data type's size (number of bits) is part of its definition and, therefore, remains consistent across all platforms. In C and C++, the size of a data type is dependent on the compiler.

Data types are abstractions

It is worth noting that just as model airplanes are representations of real airplanes, Java's numeric types are representations or models of the numbers we deal with in mathematics. In designing Java's data types, various trade-offs have been made in order to come up with practical implementations.

Representation trade-offs

One trade-off is that the set of integers is infinite, but Java's int type can only represent a finite number of values. Similarly, Java cannot represent the infinite number of values that occur between, say, 1.111 and 1.112. So, certain real numbers cannot be represented at all. For example, because Java uses binary numbers to represent its numeric types, one number that cannot be represented exactly is 1/10 . This inability to exactly represent a value is known as round-off error. Being unable to represent certain values can cause problems in a program. For example, it might be difficult to represent dollars and cents accurately in a program.

Round-off error

Another source of problems in dealing with numeric data is due to limits in their precision. For example, a decimal number represented as a double value can have a maximum of 17 significant digits, and a float can have a maximum 8. A significant digit is one that contributes to the number's value. If you tried to store values such as 12345.6789 or 0.123456789 in a float variable, they would be rounded off to 12345.679 and 0.12345679, respectively, causing a possible error.

JAVA DEBUGGING TIP Significant Digits. In using numeric data, be sure the data type you choose has enough precision to represent the values your program needs.

3.1. Numeric Operations

if (N % 2 == 0) 

System . out . println (N + " is even" );

byte n = 125;
short m = 32000;
n * m;

3.2. Operator Precedence

The built-in precedence order for arithmetic operators is shown in Table 5.6. 

Table 5.6 Precedence order of the arithmetic operators

Parenthesized expressions have highest precedence and are evaluated first. Next come the multiplication, division, and modulus operators, followed by addition and subtraction. When we have an unparenthesized expression that involves both multiplication and addition, the multiplication would be done first, even if it occurs to the right of the plus sign. Operators at the same level in the precedence hierarchy are evaluated from left to right. For example, consider the following expression:

9 + 6 - 3 * 6 / 2

In this case, the first operation to be applied will be the multiplication (*), followed by division (/), followed by addition (+), and then finally the subtraction (). We can use parentheses to clarify the order of evaluation. A parenthesized expression is evaluated outward from the innermost set of parentheses:

Parentheses can (and should) always be used to clarify the order of operations in an expression. For example, addition will be performed before multiplication in the following expression:

( a + b) * c

Another reason to use parentheses is that Java's precedence and promotion rules will sometimes lead to expressions that look fine but contain subtle errors. For example, consider the following expressions:

System. out. println (5/ 3/ 2.0);           // 0.5
System. out. println (5/(3 / 2.0));        // 3.33 

JAVA PROGRAMMING TIP Parenthesize! To avoid subtle bugs caused by Java's precedence and promotion rules, use parentheses to specify the order of evaluation in an expression.

3.3. Increment and Decrement Operators

Java provides a number of unary operators that are used to increment or decrement an integer variable. For example, the expression k++ uses the increment operator ++ to increment the value of the integer variable k. The expression k++ is equivalent to the following Java statements:

int k;
k = k + 1; // Add 1 to k and assign the result back to k

Preincrement and postincrement

The unary ++ operator applies to a single integer operand, in this case to the variable k. It increments k's value by 1 and assigns the result back to k. Preincrement and postincrement It may be used either as a preincrement or a postincrement operator. In the expression k++, the operator follows the operand, indicating that it is being used as a postincrement operator. This means that the increment operation is done after the operand's value is used.

Contrast that with the expression ++k in which the ++ operator precedes its operand. In this case, it is used as a preincrement operator, which means that the increment operation is done before the operand's value is used.

When used in isolation, there is no practical difference between k++ and ++k. Both are equivalent to k=k+1. However, when used in conjunction with other operators, there is a significant difference between preincrement and postincrement. For example, in the following code segment,

int j = 0, k = 0;  // Initially both j and k are 0
j = ++k;  // Final values of both j and k are 1

Precedence order

the variable k is incremented before its value is assigned to j. After execution of the assignment statement, j will equal 1 and k will equal 1. The sequence is equivalent to

int j = 0, k = 0        // Initially both j and k are 0
k = k + 1;
j = k;    // Final values of both j and k are  1

However, in the following example,

int i = 0, k = 0;       // Initially both i and k are 0
i = k++;               // Final value of i is 0 and k is  1

the variable k is incremented after its value is assigned to i. After execution of the assignment statement, i will have the value 0 and k will have the value 1. The preceding sequence is equivalent to

int i = 0, k = 0     // Initially both i and k are 0
i = k;
k = k + 1;           // Final value of i is 0 and k is  1
 

In addition to the increment operator, Java also supplies the decrement operator --, which can also be used in the predecrement and postdecrement forms. The expression --k will first decrement k's value by 1 and then use k in any expression in which it is embedded. The expression k-- will use the current value of k in the expression in which k is contained and then it will decrement k's value by 1. Table 5.7 summarizes the increment and decrement operators. The unary increment and decrement operators have higher precedence than any of the binary arithmetic operators.

Table 5.7 Java's increment and decrement operators

JAVA LANGUAGE RULE Pre- and Postincrement/Decrement. If an expression like ++k or  –  – k occurs in an expression, k is incremented or decremented before its value is used in the rest of the expression. If an expression like k++ or k-- occurs in an expression, k is incremented or decremented after its value is used in the rest of the expression.

JAVA PROGRAMMING TIP Increment and Decrement Operators. Because of their subtle behavior, be careful in how you use the unary increment and decrement operators. They are most appropriate and useful for incrementing and decrementing loop variables, as we'll see later.

3.4. Assignment Operators

In addition to the simple assignment operator (=), Java supplies a number of shortcut assignment operators that allow you to combine an arithmetic operation and an assignment in one operation. These operations can be used with either integer or floating-point operands. For example, the += operator allows you to combine addition and assignment into one expression. The statement

is equivalent to the statement

Similarly, the statement

is equivalent to

As these examples illustrate, when using the += operator, the expression on its right-hand side is first evaluated and then added to the current value of the variable on its left-hand side.

Table 5.8 lists the other assignment operators that can be used in combination with the arithmetic operators. 

Table 5.8 Java's assignment operators

For each of these operations, the interpretation is the same: Evaluate the expression on the right-hand side of the operator and then perform the arithmetic operation (such as addition or multiplication) to the current value of the variable on the left of the operator.

3.5. Relational Operators

There are several relational operations that can be performed on integers: <, >, <=, >=, ==, and !=. These correspond to the algebraic operators <, >, , , =, and 6=. Each of these operators takes two operands (integer or real) and returns a boolean result. They are defined in Table 5.9.

Table 5.9 Relational operators

Note that several of these relational operators require two symbols in Java. Thus, the familiar equals sign (=) is replaced in Java by ==. This is so the equality operator can be distinguished from the assignment operator.

Also, less than or equal to (<=), greater than or equal to (>=), and not equal to (!=) require two symbols, instead of the familiar , , and 6= from algebra. In each case, the two symbols should be consecutive. It is an error in Java for a space to appear between the < and = in <=.

Among the relational operators, the inequalities (<, >, <=, and >=) have higher precedence than the equality operators (== and !=). In an expression that involves both kinds of operators, the inequalities would be evaluated first. Otherwise, the expression is evaluated from left to right.

Taken as a group the relational operators have lower precedence than the arithmetic operators. Therefore, in evaluating an expression that involves both arithmetic and relational operators, the arithmetic operations are done first. Table 5.10 includes all of the numeric operators introduced so far.

Table 5.10 Numeric operator precedence including relations

To take an example, let us evaluate the following complex expression:

To clarify the implicit operator precedence, we first parenthesize the expression

(9 + 6) <= ((25 * 4) + 2)

and then evaluate it step by step:

The following expression is an example of an ill-formed expression:

9+6 <= 25 * 4 == 2

That the expression is ill formed becomes obvious if we parenthesize it and then attempt to evaluate it:

4. From the Java Library

THE java.lang.Math class provides many common mathematical functions that will prove useful in performing numerical computations. As an element of the java.lang package, it is included implicitly in all Java programs. Table 5.11 lists some of the most commonly used Math class methods.

Table 5.11 A selection of Math class methods

All Math methods are static class methods and are, therefore, invoked through the class name. For example, we would calculate 2⁴ as Math.pow(2,4), which evaluates to 16. Similarly, we compute the square root of 225.0 as Math.sqrt(225.0), which evaluates to 15.0. Indeed, Java's Math class cannot be instantiated and cannot be subclassed. Its basic definition is

public final class Math // Final , can't subclass 
{                private Math() {} // Private , can't invoke 
...
public static native double sqrt (double a) 
throws ArithmeticException;
}

Defining the Math class in this way makes it easy to use its methods, because you don't have to create an instance of it. It is also a very efficient design because its methods are static elements of the java.lang package. This means they are loaded into memory at the beginning of your program's execution, and they persist in memory throughout your program's lifetime. Because Math class methods do not have to be loaded into memory each time they are invoked, their execution time will improve dramatically.

5. Numeric Processing Examples

In this section we consider several numeric programming examples. They are carefully chosen to illustrate different issues and concepts associated with processing numeric data.

5.1. Example: Rounding to Two Decimal Places

As an example of how to use Math class methods, let's consider the problem of rounding numbers. When dealing with applications that involve monetary values – dollars and cents – it is often necessary to round a calculated result to two decimal places. For example, suppose a program computes the value of a certificate of deposit (CD) to be 75.19999. Before we output this result, we would want to round it to two decimal places – to 75.20. The following algorithm can be used to accomplish this:  Algorithm design

Step 3 of this algorithm can be done using the Math.floor(R) method, which rounds its real argument, R, to the largest integer not less than R (from Table 5.11). If the number to be rounded is stored in the double variable R, then the following expression will round R to two decimal places:

5.2. Example: Converting Fahrenheit to Celsius

To illustrate some of the issues that arise in using numeric data, let's design a program that performs temperature conversions from Fahrenheit to Celsius and vice versa.

Problem Decomposition

Figure 5.3 Interacting objects: The user interacts with the user interface (TempeartureUI), which interacts with the Temperature object.

Class Design: Temperature

The purpose of the Temperature class is to perform the temperature conversions. To convert a Celsius temperature to Fahrenheit or vice versa, it is not necessary to store the temperature value. Rather, a conversion method could take the Celsius (or Fahrenheit) temperature as a parameter, perform the conversion, and return the result. Therefore, the Temperature class does not need any instance variables. Note that in this respect the Temperature class resembles the Math class. Unlike OneRowNim , which stores the game's state – the number of sticks remaining and whose turn it is – the Math and Temperature classes are stateless.

Thus, following the design of the Math class, the Temperature class will have two public static methods: one to convert from Fahrenheit to Celsius and one to convert from Celsius to Fahrenheit. Recall that static methods are associated with the class rather than with its instances. Therefore, we needn't instantiate a Temperature object to use these methods. Instead, we can invoke the methods through the class itself.

The methods will use the standard conversion formulas: F = 9/5 C + 32 and C = 5/9 (F - 32). Each of these methods should have a single parameter to store the temperature value that is being converted.

Because we want to be able to handle temperatures such as 98.6, we should use real-number data for the methods' parameters. Generally speaking, because Java represents real literals such as 98.6 as doubles, the double type is more widely used than float. Because doubles are more widely used in Java, using double wherever a floating point value is needed will cut down on the number of implicit data conversions that a program would have to perform. Therefore, each of our conversion methods should take a double parameter and return a double result. 

The implementation of the Temperature class is shown in Figure 5.5 . Note that because celsToFahr() uses the double value temp in its calculation, it uses floating-point literals (9.0, 5.0, and 32.0) in its conversion expression. This helps to reduce the reliance on Java's built-in promotion rules, which can lead to subtle errors. For example, to the design shown in Figure 5.4 , suppose we had written what looks like an equivalent expression using integer literals:

Figure 5.4: The Temperature class. Note that static elements are underlined in UML. (NEEDS REVISION)

Because 9 divided by 5 gives the integer result 1, this expression is always equivalent to temp + 32, which is not the correct conversion formula. This kind of subtle semantic error can be avoided if you avoid mix types wherever possible.

Testing and Debugging 

The next question to be addressed is how should this program be tested? As always, you should test the program in a stepwise fashion. As each method is coded, you should test it both in isolation and in combination with the other methods, if possible. 

Also, you should develop appropriate test data. It is not enough to just plug in any values. The values you use should test for certain potential problems. For this program, the following tests are appropriate: 

public class Temperature 
{ 
public Temperature() {} 
public static double fahrToCels(double temp) 
{ 
return (5.0 * (temp  –  32.0) / 9.0); 
} 
public static double celsToFahr(double temp) 
{ 
return (9.0 • temp / 5.0 + 32.0); 
}
// Temperature

Figure 5.5: The Temperature class.

The TemperatureUI Class 

The purpose of the TemperatureUI class is to serve as a user interface – that is, as an interface between the user and a Temperature object. It will accept a Fahrenheit or Celsius temperature from the user, pass it to one of the public methods of the Temperature object for conversion, and display the result that is returned. 

As we discussed in Chapter 4, the user interface can take various forms, ranging from a command-line interface to a graphical interface. Figure 5.6 shows a design for the user interface based on the command-line interface developed in Chapter 4. The TemperatureUI uses a KeyboardReader to handle interaction with the user and uses static methods in the Temperature class to perform the temperature conversions. 

Figure 5.6: A command-line user interface.

SELF-STUDY EXERCISES 

EXERCISE 5.1 Following the design in Figure 5.6, implement the TemperatureUI class and use it to test the methods in Temperature class. The run() method should use an input-process-output algorithm: Prompt the user for input, perform the necessary processing, and output the result. Note that because Temperature's conversion methods are class methods, you do not need to instantiate a Temperature object in this project. You can invoke the conversion methods directly through the Temperature class: 

double fahr = Temperature.celsToFahr (98.6); 

EXERCISE 5.2 Following the design for the GUI developed in Chapter 4, implement a GUI to use for testing the Temperature class. The GUI should have the layout shown in Figure 5.7. Figure 5.7 Figure 5.7: Layout design of a GUI that performs temperature conversions.

5.3. Example: Using Class Constants

As we noted in Chapter 0, in addition to instance variables, which are associated with instances (objects) of a class, Java also allows class variables, which are associated with the class itself. One of the most common uses of such variables is to define named constants to replace literal values. A named constant is a variable that cannot be changed once it has been given an initial value. In this section, we use our running example, OneRowNim, to illustrate using class constants.

Recall that methods and variables that are associated with a class must be declared with the static modifier. If a variable is declared static, there is exactly one copy of that variable created no matter how many times its class is instantiated. To turn a variable into a constant, it must be declared with the final modifier. Thus, the following would be examples of a class constants, constant values that are associated with the class rather than with its instances:

public static final int PLAYER_ONE = 1;
public static final int PLAYER_TWO = 2;
public static final int MAX_PICKUP = 3;
public static final int MAX_STICKS = 7;

Note how we use uppercase letters and underscore characters ( ) in the names of constants. This is a convention that professional Java programmers follow, and its purpose is to make it easy to distinguish the constants from the variables in a program. This makes the program easier to read and understand.

Another way that named constants improve the readability of a program is by replacing the reliance on literal values. For example, for the OneRowNim class, compare the following two if conditions:

if (num <
1 || num > 3 || num > nSticks) ...
if (num < 1 || num > MAX_PICKUP || num > nSticks) ...

public int getPlayer ()
{     if (onePlaysNext)
           return PLAYER_ONE;
      else return PLAYER_TWO;
} // getPlayer ()

So far, all of the examples we have presented show why named constants (but not necessarily class constants) are useful. Not all constants are class constants. That is, not all constants are declared static. However, the idea of associating constants with a class makes good sense. In addition to saving memory resources, by creating just a single copy of the constant, constants such as MAX STICKS and PLAYER ONE make more conceptual sense to associate with the class itself rather than with any particular OneRowNim instance.

Class constants are used extensively in the Java class library. For example, as we saw in Chapter 2, Java's various built-in colors are represented as constants of the java.awt.Color class—Color.blue and Color.red. Similarly, java.awt.Label uses int constants to specify how a label's text should be aligned: Label.CENTER.

Another advantage of class constants is that they can be used before instances of the class exist. For example, a class constant (as opposed to an instance constant) may be used during object instantiation:

Note how we use the name of the class to refer to the class constant. Of course, MAX STICKS has to be a public variable in order to be accessible outside the class. To use MAX STICKS as a constructor argument it has to be a class constant because at this point in the program there are no instances of OneRowNim. A new version of OneRowNim that uses class constants is shown in Figure 5.8.

It is important to note that Java also allows class constants to be referenced through an instance of the class. Thus, once we have instantiated game, we can refer to MAX STICKS with either OneRowNim.MAX STICKS or game.MAX STICKS.

SELF-STUDY EXERCISE

EXERCISE 5.3 Implement a command-line interface class named KBTestOneRowNim, that uses our new version of OneRowNim . Make use of the MAX STICKS and MAX PICKUP in the user interface.

5.4. OBJECT-ORIENTED DESIGN: Information Hiding

The fact that our new versions of OneRowNim – we've developed two new versions in this chapter – are backward compatible with the previous version is due in large part to the way we have divided up its public and private elements. Because the new versions still present the same public interface, programs that use the OneRowNim class, such as the OneRowNimApp from Chapter 4 (Fig. 4.24), can continue to use the class without changing a single line of their own code. To confirm this, see the Self-Study Exercise at the end of this section.

public class OneRowNim 
{ public static final int PLAYER.ONE = 1; 
  public static final int PLAYER:IWO= 2; 
  public static final int MAX_PICKUP= 3; 
  public static final int MAXSTICKS = 11; 
  public static final boolean GAMEDVER = false; 
   private int nSticks = MAX_SIICKS; 
   private boolean onePlaysNext = true;                     
   public OneRowl'Sm() { //OneRowNim() constructorl 
   public OneRowlstun(int sticks) 
    { nSticks = sticks; 
    } // OneRowNim() constructor2 
   public OneRowbrun(int sticks, int starter) 
   { nSticks = sticks; 
     onePlaysNext = (starter == PLAYERDNE); 
    } // OneRowNim() constructor3 
    public boolean takeSticks(int num) 
    { if (num < 1 I num > MA)U'ICKUP I I num > nSticks ) 
    return false; // Error  else // Valid move 
    { nSticks = nSticks — rum; 
     onePlaysNext = !onePlaysNext;
     return true; 
     }  //else 
     } // takeSticks() 
     public int getSticks() 
     { return nSticks; }
     }//getSticks 
   public int getPlayer() 
   { if (onePlaysNext) 
   return PLAYER_ONE; 
   else return PLAYER_TWO; 
   } //getPlayer() 
   public boolean gameOver() 
   { return (nSticks <= 0); } 
   } // gameOver () 
   public int getWinner() 
   { if (nSticks < 1) 
   return getPlayer (); 
     else return 0; // Came is not over 
   } // getWinner() 
   public String report() 
   { return ("Number of sticks left : " + getSticks() 
   + "\ nNext turn by player " + getPlayer () + " \ n" );
   } // report () 
} // OneRowNim class 

Figure 5.8: This version of OneRowNim uses named constants.

Although we have made significant changes to the underlying representation of OneRowNim, the implementation details – its data and algorithms – are hidden from other objects. As long as OneRowNim's public interface remains compatible with the old version, changes to its private elements won't cause any inconvenience to those objects that were dependent on the old version. This ability to change the underlying implementation without affecting the outward functionality of a class is one of the great benefits of the information hiding principle.

The lesson to be learned here is that the public parts of a class should be restricted to just those parts that must be accessible to other objects. Everything else should be private. Things work better, in Java programming and in the real world, when objects are designed with the principle of information hiding in mind.

SELF-STUDY EXERCISE 

EXERCISE 5.4 To confirm that our new version of OneRowNim still works correctly with the user interfaces we developed in Chapter 4, compile and run it with OneRowNimApp (Fig. 4.24).

5.5. Example: A Winning Algorithm for One Row Nim

Now that we have access to numeric data types and operators, lets develop an algorithm that can win the One Row Nim game. Recall that in Chapter 4 we left things such that when the computer moves, it always takes 1 stick. Let's replace that strategy with a more sophisticated approach.

If you have played One Row Nim, you have probably noticed that in a game with 21 sticks, you can always win the game if you leave your opponent with 1, 5, 9, 13, 17, or 21 sticks. This is obvious for the case of 1 stick. For the case where you leave your opponent 5 sticks, no matter what the opponent does, you can make a move that leaves the other player with 1 stick. For example, if your opponent takes 1 stick, you can take 3; if your opponent takes 2, you can take 2; and, if your opponent takes 3, you can take 1. In any case, you can win the game by making the right move, if you have left your opponent with 5 sticks. The same arguments apply for the other values: 9, 13, 17, and 21.

What relationship is common to the numbers in this set? Notice that if you take the remainder after dividing each of these numbers by 4 you always get 1:

1 % 4 == 1
5 % 4 == 1
9 % 4 == 1
13 % 4 == 1
17 % 4 == 1
21 % 4 == 1

Thus, we can base our winning strategy on the goal of leaving the opponent with a number of sticks, N, such that N%  4 equals 1.

To determine how many sticks to take in order to leave the opponent with N, we need to use a little algebra. Let's suppose that sticksLeft represents the number of sticks left before our turn. The first thing we have to acknowledge is that if sticksLeft % 4 == 1, then we have been left with 1, 5, 9, 13, and so on, sticks, so we cannot force a win. In that case, it doesn't matter how many sticks we pick up. Our opponent should win the game.

So, let's suppose that sticksLeft % 4 != 1 , and let M be the number of sticks to pickup in order to leave our opponent with N , such that N % 4 == 1. Then we have the following two equations:

sticksLeft 
- M == N
N% 4 ==
     1
        

By adding M to both sides and subtracting 1 from both sides of this equation, we get:

The examples in this table show that when we use (sticksLeft-1 % 4) to calculate our move, we always leave our opponent with a losing situation. Note that when sticksLeft equals 9 or 5, we can't apply this strategy because it would lead to an illegal move.

Let's now convert this algorithm into Java code. In addition to incorporating our winning strategy, this move() method makes use of two important Math class methods:

public int move() 
{ int sticksLeft = nim . getSticks // Get number of sticks 
   if (sticksLeft % (nim.MAXPICKUP + 1) != 1)// If winnable 
     return (sticksLeft — 1) % (nim.MPJCPICKUP +1); 
   else // Else pick random 
     int maxPickup = Math.min(nim.MAX.PICKUP, sticksLeft); 
     return 1 + (int )(Math.random() s maxPickup); 
   }
}

The move() method will return an int representing the best move possible. It begins by getting the number of sticks left from the OneRowNim object, which is referred to as nim in this case. It then checks whether it can win by computing (sticksLeft-1) % 4. However, note that rather than use the literal value 4, we use the named constant MAX PICKUP , which is accessible through the nim object. This is an especially good use for the class constant because it makes our algorithm completely general – that is, our winning strategy will continue to work even if the game is changed so that the maximum pickup is 5 or 6. The then clause computes and returns (sticksLeft-1) % nim.MAX PICKUP+1, but here again it uses the class constant.

The else clause would be used when it is not possible to make a winning move. In this case we want to choose a random number of sticks between 1 and some maximum number. The maximum number depends on how many sticks are left. If there are more than 3 sticks left, then the most we can pick up is 3, so we want a random number between 1 and 3. However, if there are 2 sticks left, then the most we can pick up is 2 and we want a random number between 1 and 2. Note how we use the Math.min() method to decide the maximum number of sticks that can be picked up:

The min() method returns the minimum value between its two arguments.

Finally, note how we use the Math.random() method to calculate a random number between 1 and the maximum:

SELF-STUDY EXERCISE

EXERCISE 5.5  Implement a class named NimPlayer that incorporates the move() method designed in this section. The class should implement the design shown in Figure 5.9. That is, in addition to the move() method, it should have an instance variable, nim , which will serve as a reference to the OneRowNim game. Its constructor method should take a OneRowNim parameter, allowing the NimPlayer to be given a reference when it is instantiated.

+ NimPlayer(g:OneRowNim)
+ move():int

EXERCISE 5.6 Modify OneRowNim's command-line interface to play One Row Nim between the user and the computer, where the NimPlayer implemented in the previous exercise represents the computer.

6. From the Java Library

+ format(in n:double):String
+ format(in n:long):String

NumberFormat dollars = NumberFormat. getCurrencylnstance 0; 
System. out . println ( dollars . format (10962.555));

NumberFormat percent = NumberFormat. getPercentlnstance (); 
percent. setMaximumFractionDigits (2); 
System. out . println (percent . format (6.55));

- principal: double
- rate: double
- years: double

+ BankCD(p:double,r:double,
y:double)
+ calcYearly():double
+ calcDaily():double

7. Character Data and Operators

Another primitive data type in Java is the character type, char. A character in Java is represented by a 16-bit unsigned integer. This means that a total of 2¹⁶ or 65536 different Unicode characters can be represented, corresponding to the integer values 0 to 65535. The Unicode character set is an international standard that has been developed to enable computer languages to represent characters in a wide variety of languages, not just English. Detailed information about this encoding can be obtained at

7.1. Character to Integer Conversions

Is 'A' a character or an integer? The fact that character data are stored as integers in the computer's memory can cause some confusion about whether a given piece of data is a character or an integer. In other words, when is a character, for example 'A', treated as the integer (65) instead of as the character 'A'? The rule in Java is that a character literal – 'a' or 'A' or '0' or '?' – is always treated as a character, unless we explicitly tell Java to treat it as an integer. So if we display a literal's value

char ch = 'a';
System.out.printIn(ch);     // Displays 'a'

int k = (int)'a';           //  Converts 'a' to 97
System.out.printIn(k);  // Displays 97

As these examples show, a cast is a type conversion operator. Java allows a wide variety of both explicit and implicit type conversions. Certain conversions (for example, promotions) take place when methods are invoked, when assignment statements are executed, when expressions are evaluated, and so on.

Type conversion in Java is governed by several rules and exceptions. In some cases Java allows the programmer to make implicit cast conversions. For example, in the following assignment a char is converted to an int even though no explicit cast operator is used:

char ch;
int k;
k = ch;    //   convert a char into an int

On the other hand, trying to assign an int value to a char variable leads to a syntax error:

char ch;
int k;
ch = k;          // Syntax error:  can't assign int to char

The cast operator can be used with any primitive type. It applies to the variable or expression that immediately follows it. Thus, parentheses must be used to cast the expression m+n into a char:

7.2. Lexical Ordering

The order in which the characters of a character set are arranged, their lexical order, is an important feature of the character set. It especially comes into play for such tasks as arranging strings in alphabetical order.

Although the actual integer values assigned to the individual characters by ASCII and UNICODE encoding seem somewhat arbitrary, the characters are, in fact, arranged in a particular order. For example, note that various sequences of digits, '0'...'9', and letters, 'a'...'z' and 'A'...'Z', are represented by sequences of integers (Table 5.11). This makes it possible to represent the lexical order of the characters in terms of the less than relationship among integers. The fact that 'a' comes before 'f' in alphabetical order is represented by the fact that 97 (the integer code for 'a') is less than 102 (the integer code for 'f'). Similarly, the digit '5' comes before the digit '9' in an alphabetical sequence because 53 (the integer code for '5') is less than 57 (the integer code for '9').

This ordering relationship extends throughout the character set. Thus, it is also the case that 'A' comes before 'a' in the lexical ordering because 65 (the integer code for 'A') is less than 97 (the integer code for 'a'). Similarly, the character '[' comes before '}' because its integer code (91) is less than 125, the integer code for '}'.

7.3. Relational Operators

Given the lexical ordering of the char type, the following relational operators can be defined: <, >, <=, >=, ==, !=. Given any two characters, ch1 and ch2, the expression ch1 < ch2 is true if and only if the integer value of ch1 is less than the integer value of ch2. In this case we say that ch1 precedes ch2 in lexical order. Similarly, the expression ch1 > ch2 is true if and only if the integer value of ch1 is greater than the integer value of ch2. In this case we say that ch1 follows ch2. And so on for the other relational operators. This means that we can perform comparison operations on any two character operands (Table 5.14).

Table 5.14  Relational operations on characters

8. Example: Character Conversions

Another interesting implication of representing the characters as integers is that we can represent various character operations in terms of integer operations. For example, suppose we want to capitalize a lowercase letter. Table 5.13 shows that the entire sequence of lowercase letters ('a' ... 'z') is displaced by 32 from the sequence of uppercase letters ('A' ... 'Z') , so we can convert any lowercase letter into its corresponding uppercase letter by subtracting 32 from its integer value, provided we perform an explicit cast on the result. When we perform the cast (char) ('a' - 32 ), the resulting value is 'A', as the following example shows:

char toUpperCase(char ch) { 
   if ((ch >= 'a') && (ch C= 5:1)) 
      return ch — 32 ; 0 Error : can 't return an int 
   return ch;
}

This method takes a single char parameter and returns a char value. It begins by checking if ch is a lowercase letter—that is, if ch falls between 'a' and 'z' inclusive. If so, it returns the result of subtracting 32 from ch. If not, it returns ch unchanged. However, the method contains a syntax error Type error that becomes apparent if we trace through its steps. If we invoke it with the expression toUpperCase('b'), then since 'b' is between 'a' and 'z', the method will return 'b'- 32. Because the integer value of 'b' is 98, it will return 98 - 32 or 66, which is the integer code for the character ' B'. However, the method is supposed to return a char, so this last statement will generate the following syntax error:

Incompatible type for return. An explicit cast needed to convert int to char.

>> return ch - 32 ;
>> ^

char toUppercase (char ch) {
if ((ch >= 'a') && (ch <= 'z'))
return (char) (ch - 32); // Explicit cast
return ch;
}

Another common type of conversion is to convert a digit to its corresponding integer value. For example, we convert the character '9' to the integer 9 by making use of the fact that the digit '9' is 9 characters beyond the digit '0' in the lexical order. Therefore, subtracting '0' from '9' gives integer 9 as a result:

('9' - '0') ==> (57 - 48) ==>  9

More generally, the expression ch - '0' will convert any digit, ch, to its integer value. We can encapsulate these ideas into a method that converts any digit into its corresponding integer value:

int digitToInteger (char ch) {
  if (( ch >= '0') && (chy <= '9'))
    return ch - '0';
  return -1;
}

This method takes a single char parameter and returns an int. It first checks that ch is a valid digit, and if so, it subtracts the character '0' from it. If not, the method just returns -1, which indicates that the method received an invalid input parameter. Obviously, when an object invokes this method, it should first make sure that the value it passes is in fact a digit.

The Java application program shown in Figure 5.12 illustrates several of the ideas discussed in this section. Note that both the digitToInteger() and toUpperCase() are declared static. This allows us to call them directly from the (static) main() method, as useful and justifiable shortcut if, as in this case, we are just testing the methods.

9. Problem Solving = Representation + Action

As you have seen in this chapter, designing classes involves a careful interplay between representation (data) and action (methods). Our several modifications to the OneRowNim class illustrate that the data used to represent an object's state can either complicate or simplify the design of the methods needed to solve a problem.

We hope that it is becoming clear to you that in writing object-oriented programs, choosing an appropriate data representation is just as important as choosing the correct algorithm. The concept of an object allows us to encapsulate representation and action into a single entity. It is a very natural way to approach problem solving.

If you look closely enough at any problem, you will find this close relationship between representation and action. For example, compare the task of performing multiplication using Arabic numerals – 65 * 12 = 380 – and the same task using Roman numerals – LXV * XII = DCCLXXX. It's doubtful that our science and technology would be where they are today if our civilization had to rely forever on the Roman way of representing numbers!

public class Test {
   public s t a t ic void main ( S t ring argv [ ] ) {
     char ch = ’ a ’ ; // Local variables
     int k= ( int ) ’b ’ ;
     System . out . prin tln ( ch ) ;
     System . out . prin tln (k ) ;
     ch = ( char )k; // Cast needed here
     System . out . prin tln ( ch ) ;
     System . out . prin tln ( toUpperCase ( ’ a ’ ));
     System . out . prin tln ( toUpperCase ( ch ) ) ;
     System . out . prin tln ( digitToInteger ( ’ 7 ’ ));
   }
   public static char toUpperCase ( char ch ) {
     i f ( ( ch >= ’ a ’ ) && ( ch <= ’ z ’ ) )
       return ( char ) ( ch  32);
     return ch ;
   }
   public static int digitToInteger ( char ch ) {
     if ( ( ch >= ’ 0 ’ ) && ( ch <= ’ 9 ’ ) )
     return ch  ’ 0 ’ ;
    return 1 ;
   }
} // Test

10. Chapter Summary

Technical Terms

Summary of Important Points

• The way we approach a problem can often help or hinder us in our ability to solve it. Choosing an appropriate representation for a problem is often the key to solving it. 
• In order to evaluate complex expressions, it is necessary to understand the precedence order and associativity of the operators involved. Parentheses can always be used to override an operator's built-in precedence. 
• Java provides several types of integer data, including the 8-bit byte, 16-bit short, 32-bit int, and 64-bit long types. Unless otherwise specified, integer literals are represented as int data in a Java program. 
• Java provides two types of floating-point data, the 32-bit float type and the 64-bit double type. Unless otherwise specified, floating-point literals are represented as double data. 
• In general, if a data type uses n bits in its representation, then it can represent 2ⁿ different values. 
• The fact that Java's primitive types are defined in terms of a specific number of bits is one way that Java promotes platform independence. 
• It is necessary to distinguish integer operations from floating-point operations even though the same symbols are used. For example, (7/2) is 3, while (7.0/2) is 3.0.
• In revising a class that is used by other classes it is important to preserve as much of the class's interface as possible. 
• In Java, character data are based on the Unicode character set, which provides 2¹⁶ = 65,536 different character codes. To provide backward compatibility with the ASCII code, the first 128 characters are the ASCII coded characters. 
• Java operators are evaluated according to the precedence hierarchy shown in Table 5.15. The lower the precedence number, the earlier an operator is evaluated. So the operators at the top of the table are evaluated before operators that occur below them in the table. Operators at the same precedence level are evaluated according to their association, either left to right (L to R) or right to left (R to L).