Java Data and Operators

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.