Programming with Java, Swing and Squint phần 6 pot

Figure 7.1: Interface for a 4-function calculator program 170 // Create and place the calculator buttons and display in the window public IntCalculator() { this.createWindow( WINDOW_WIDTH, WINDOW_HEIGHT ); contentPane.add( new JButton( "1" ) ); contentPane.add( new JButton( "2" ) ); contentPane.add( new JButton( "3" ) ); contentPane.add( divide ); contentPane.add( new JButton( "4" ) ); contentPane.add( new JButton( "5" ) ); contentPane.add( new JButton( "6" ) ); contentPane.add( times ); contentPane.add( new JButton( "7" ) ); contentPane.add( new JButton( "8" ) ); contentPane.add( new JButton( "9" ) ); contentPane.add( minus ); contentPane.add( new JButton( "0" ) ); contentPane.add( clear ); contentPane.add( equals ); contentPane.add( plus ); entry.setHorizontalAlignment( JTextField.RIGHT ); contentPane.add( entry ); } Figure 7.2: The constructor for a simple calculator program of the instance variables used in the constructor is shown in Figure 7.3. The only new feature exhibited in this code is the invocation of a method named setHorizontalAlignment in the next to last line of the constructor. This invocation causes the value displayed in the calculator’s text field to be right justified within the field. The first five images in in Figure 7.1 show the program being used to perform the calculation “6 + 5 = 11”. This is accomplished by entering “6 + 5 =” on the calculator’s keypad with the mouse. The important thing to notice is that the “+” key on this calculator is not simply a replacement for the “Add to total” button in our adding machine program. When the “+” key is pressed, nothing actually changes in the program’s window The calculator cannot perform the addition because the second operand, 5 in this example, has not even been entered. Instead, the program waits until the second operand has been entered and the “=” key is pressed. At that point, it adds the two operands together. The “=” key, however, is also more than a replacement for the “Add to total” button. Pressing it does not always cause the program to add its operands. The operation performed depends on which keys had been pressed earlier. If the user had entered “6 - 5 =”, then the program should perform a subtraction when the “=” key is pressed. The program must 171 // A $5 Calculator public class IntCalculator extends GUIManager { // Change these values to adjust the size of the program’s window private final int WINDOW_WIDTH = 380, WINDOW_HEIGHT = 220; // Maximum number of digits allowed in entry private final int MAX_DIGITS = 9; // Used to display sequence of digits selected and totals private JTextField entry = new JTextField( "0", 25 ); // Operator buttons private JButton plus = new JButton( "+" ); private JButton minus = new JButton( "-" ); private JButton times = new JButton( "x" ); private JButton divide = new JButton("÷" ); private JButton equals = new JButton( "=" ); // The clear button private JButton clear = new JButton( "C" ); // Remember the number of digits entered so far private int digitsEntered = 0; // Value of current computation private int total = 0; Figure 7.3: Instance variable declarations for a simple calculator program 172 somehow remember the last operator key pressed until the “=” key is pressed. The remaining screen images in Figure 7.1 show how the program should behave if after com- puting “6 + 5 = 11”, the person using the calculator immediate enters “4 x 3 ÷ 2 =”. The interesting thing to notice is that when the user presses the ÷ key, the calculator displays the result of multiplying 4 and 3. This is exactly what the calculator would have done if the user had pressed the “=” key instead of the ÷ key at this point. From this we can see that the “=” key and all of the arithmetic operator keys behave in surprisingly similar ways. When you press any of these keys, the calculator performs the operation associated with the last operator key pressed to combine the current total with the number just entered. The only tricky cases are what to do if there is no “last operator key pressed” or no “number just entered”. The no “last operator key pressed” situation can occur either because the program just started running or because the last non-numeric key pressed was the “=” key. In these situations, the calculator should simply make the current total equal to the number just entered. The no “number just entered” situation occurs when the user presses two non-numeric keys in a row. Real calculators handle these situations in many distinct ways. For example, on many calculators, pressing the “=” key several times causes the calculator to perform the last operation entered repeatedly. We will take a very simple approach to this situation. If the user presses several non-numeric keys in a row, our calculator will ignore all but the first non-numeric key pressed. From this description of the behavior our calculator should exhibit, we can begin to outline the structure of the if statements that will be used in the buttonClicked method. Looking back at the code in the buttonClicked method of the last version of our adding machine program provides a good starting point. That code is shown in Figure 5.9. The if statement used in that method implemented a three-way choice so that the program could distinguish situations in which the user had pressed the “Clear Total” button, the “Add to Total” button, or a numeric key. From the discussion above, we can see that our calculator program must make a similar three-way choice. The cases it must distinguish are whether the user has pressed the clear button, a numeric key, or any of the other non-numeric keys (i.e., an operator key or the “=” key). In the case that the user has pressed an operator key, it needs to make a second decision. If no digits have been entered since the last operator key was pressed, it should ignore the operator. Based on these observations, we can sketch an outline for this program’s buttonClicked method as shown in Figure 7.4. Obviously, we cannot type a program containing code like the outline shown in this figure into our IDE and expect to run it. We can, however, type such an outline in and then use it as a template in which we “fill in the blanks” as we complete the program. With this in mind, we have indicated the places in our outline where detailed code is missing using ellipses preceded by comments explaining what the missing code should do. Writing such an outline can be a very useful step in the process of completing a program. Much as outlining a paper allows you to work out the overall organization of your thoughts without worrying about the precise wording you will use for every sentence, outlining a program enables you to focus on the high-level structure of your program. With a good understanding of this structure, it is generally much easier to fill in the many details needed to complete a program. 7.2 Smooth Operators One detail we obviously need to explore to complete our calculator is how to perform arithmetic operations other than addition. Performing arithmetic operators in Java is actually quite simple. 173 // Accept digits entered and perform arithmetic operations requested public void buttonClicked( JButton clickedButton ) { if ( /* clickedButton is an operator or the = key */ ) { if ( /* the last key pressed was not an operator or = key */ ) { // Apply last operator to the number entered and current total . . . } } else if ( clickedButton == clearButton ) { // Zero the total and clear the entry field . . . } else { // If clickedButton is a numeric key, add digit to entry . . . } } Figure 7.4: Outline for the buttonClicked method of a calculator program 174 In addition to the plus sign, + Java recognizes operators for the other three standard arithmetic operations. The minus sign, -, is used for subtraction, - the slash, /, is use d for division, and the asterisk, *, is used for multiplication. Thus, just as we used the statement total = total + Integer.parseInt( entry.getText() ); in our adding machine program, we can use a statement like total = total - Integer.parseInt( entry.getText() ); to perform subtraction 1 , or statements like total = total * Integer.parseInt( entry.getText() ); and total = total / Integer.parseInt( entry.getText() ); to perform multiplication and division. * / As we noted in the previous section, the operation performed by our calculator when an operator key or the “=” key is pressed is actually determined by which of these keys was the last such key pressed. Therefore, we will have to include an instance variable in our class that will be used to keep track of the previous operator key that was depressed. We can do this by adding a declaration of the form // Remember the last operator button pressed private JButton lastOperator = equals; to those already shown in Figure 7.3. We will use this variable in the buttonClicked method to decide what operation to pe rform. We will have to include code in the buttonClicked method to change the value of lastOperator each time an operator key is pressed. We have initialized lastOperator to refer to the equals key because when it first starts to run we want our calculator to behave as it does right after the “=” key is pressed. The code required to use lastOperator in this way is included in Figure 7.5. The code we have added in this figure begins by using Integer.parseInt to convert the digits entered by the user into a numb er. Then, we use a series of if statements to make a 5-way choice based on the previously pressed operator key by comparing the value of lastOperator to the names that refer to each of the operator keys. Each of the five lines that may be selec ted for execution by these if statements updates the value of the total variable in the appropriate way. Next, we display the updated value of total in the entry text field. Finally, but very importantly, we use an assignment statement to tell the computer to associate the name lastOperator with the button that was just pressed. This ensures that the next time an operator key is pressed, the program w ill be able to perform the correct operation. 1 In Java, the minus sign can also be used with a single operand. That is, if the value of total is 10, then executing the statement total = - total; will change the value to -10. 175 // Accept digits entered and perform arithmetic operations requested public void buttonClicked( JButton clickedButton ) { if ( /* clickedButton is an operator or the = key */ ) { if ( /* the last key pressed was not an operator or = key */ ) { // Apply last operator to the number entered and current total int numberEntered = Integer.parseInt( entry.getText() ); if ( lastOperator == plus ) { total = total + numberEntered; } else if ( lastOperator == minus ) { total = total - numberEntered; } else if ( lastOperator == times ) { total = total * numberEntered; } else if ( lastOperator == divide ) { total = total / numberEntered; } else { total = numberEntered; } entry.setText( "" + total ); lastOperator = clickedButton; . . . } } else if ( clickedButton == clearButton ) { // Zero the total and clear the entry field . . . } else { // If clickedButton is a numeric key, add digit to entry . . . } } Figure 7.5: Refined outline for calculator buttonClicked method 176 7.2.1 Relational Operators and boolean Values In the instance variable declarations for our calculator program (shown in Figure 7.3), we included a variable named digitsEntered. In the final version of our adding machine program we used a similar variable to keep track of the number of digits in the value the user was currently entering so that a user could not enter a value too big to be represented as an int. In our calculator program, this variable will serve two additional roles. First, we indicated earlier that our program should ignore all but the first op e rator key pressed when several operator keys are pressed consecutively. We will use digitsEntered to detect such situations. When an operator key is pressed, our program “consumes” the most recently entered number. We can therefore determine whether two operator keys have been pressed in a row by checking whether the value of digitsEntered is 0 when an operator key is pressed. Second, when the user presses an operator key, our program will display the current value of total in the entry field. This value should remain visible until the user presses a numeric key (or the clear button). As a result, our program must perform a special step when handling the first numeric key pressed after an operator key. It must clear the entry field. Again, we can use the value of digitsEntered to identify such situations. A revised version of our outline of the buttonClicked method, extended to include the code that updates and uses digitsEntered, is shown in Figure 7.6. Actually, it is a bit of a stretch to still call this an “outline”. The only detail left to be resolved is the condition to place in the if statement at the very beginning of the method. In the branch of the method’s main if statement that handles operator keys, we have added an assignment to associate 0 with the name digitsEntered. We have also filled in the branches of this if statement that handle the clear button and the numeric keys. The code for the clear button sets the total and the number of digits entered to zero. It also clears the entry field. Finally, it lies just a little bit by associating the “=” key with lastOperator. After the clear key is pressed we want the program to behave as if the last operator key pressed was “=”. The code for numeric keys begins by clearing the entry text field if the value of digitsEntered is 0. That is, it clears the text field when a numeric key is pressed immediately after one of the non-numeric keys has been pressed. The rest of the code for handling numeric keys is identical to the code we used in our adding machine program. Finally, we have replaced the comment in the if statement: if ( /* the last key pressed was not an operator or = key */ ) { with the condition digitsEntered > 0 The symbols ==, !=, <, <=, >=, and > are examples of what we call relational operators. The operator > can be used to make Java check whether one value is greater than another. The operator >= tells Java to check whether one value is greater than or equal to another. That is, >= is the equivalent of the mathematical symbol ≥. For example, as an alternative to the if statement if ( digitsEntered > 0 ) { we could have written 177 // Accept digits entered and perform arithmetic operations requested public void buttonClicked( JButton clickedButton ) { if ( /* clickedButton is an operator or the = key */ ) { if ( digitsEntered > 0 ) { // Apply last operator to the number entered and current total int numberEntered = Integer.parseInt( entry.getText() ); if ( lastOperator == plus ) { total = total + numberEntered; } else if ( lastOperator == minus ) { total = total - numberEntered; } else if ( lastOperator == times ) { total = total * numberEntered; } else if ( lastOperator == divide ) { total = total / numberEntered; } else { total = numberEntered; } entry.setText( "" + total ); digitsEntered = 0; lastOperator = clickedButton; } } else if ( clickedButton == clearButton ) { // Zero the total and clear the entry field total = 0; digitsEntered = 0; entry.setText( "0" ); lastOperator = equals; } else { // If clickedButton is a numeric key, add digit to entry if ( digitsEntered == 0 ) { entry.setText( "" ); } digitsEntered = digitsEntered + 1; if ( digitsEntered < MAX_DIGITS ) { entry.setText( entry.getText() + clickedButton.getText() ); } } } Figure 7.6: Calculator outline extended with details of using digitsEntered 178 if ( digitsEntered >= 1 ) { Similarly, the operator <= is used to check whether one value is less than or equal to another. Finally, the operator != is use d to ask if two values are different. That is, in Java, != is equivalent to the mathematical symbol =. The relational operators == and != can be used to compare values described by any two ex- pressions in a program. 2 The remaining relationals, <, >, <=, and >= can only be used to compare numeric values. The fact that <, >, ==, <=, >=, and != are referred to as relational operators reflects an important fact about the way these symbols are understood within the Java language. The other operators we have discussed are the arithmetic operators +, -, *, and /. Within a Java program, phrases that involve arithmetic operators are identified as expressions. That is, they are used in contexts where the programmer needs to describe values. For example, 3 * 4 is an expression that describes the value 12. We have also seen that even without knowing the exact value that an expression will produce in a Java program, we can always identify the type from which the value will come. For example, if x is an int variable, we know that the expression x + 1 will describe an int value rather than a String or JTextField, even though we cannot say which int value the expression describes until we determine the current value of x. If the relational operators are to be interpreted in a similar way, then we have to consider phrases like 3 != 4 and x > 0 as expressions and we have to be able to identify the type of value each such expression describes. The value described by an expression like x > 0 will not be another int or any of the other types we have encountered thus far. Instead, Java includes an additional type called boolean that consists of the values described by expressions involving relational operators. This type contains just two values described by the literals true and false. If the value associated with the variable x is 14, then we would informally say that it is true that x is greater than 0. In Java, therefore, if the value of x is 14, then the value described by the expression x > 0 is true. On the other hand, if x is 0 or any negative number then the value described by x > 0 is false. We will see in the next few sections, that the values of the type boolean can be manipulated in many of the same ways we can manipulate values like ints. We can declare variables that will refer to boolean values. There are operators that take boolean values as ope rands. We can describe boolean values in our program using the literals true and false just as we describe int values by including literals like 1 and 350 in our code. In addition, the type boolean plays a special role in Java. Expressions that produce boolean values are used as conditions in if statements and other structures used to control the sequence in which a program’s instructions are executed. 7.2.2 Primitive Ways It is important to note that there are several ways in which Java treats ints differently from many other types of information we manipulate in our programs. When we want to perform an operation on a JTextField or a JButton, we use method invocations rather than operators. The designers of the Java language could have also provided methods for the operations associated with arithmetic and relational operators. That is, we might have been expected to type things like x.plus(y) 2 Note: Although == can be used to compare any two values, we will soon see that it is often more appropriate to use a method named equals to compare certain types of values. 179 [...]... The “E” stands for “exponent” In general, to interpret a number output in this form you should raise 10 to the power found after the E and multiply the number before the E by the result The table below shows some examples of numbers written in this notation and the standard forms of the same values 1 86 E-notation 1.0E8 1.86E5 4.9E -6 Standard Representation 100, 000, 000 1 86, 000 0000049 Standard Scientific... interactions between ints and doubles, however, these rules often become more critical in Java programs than they typically are in math classes For example, in Java, the expressions 64 .0*1/3 189 and 1/3 *64 .0 produce different values! In the first expression, the computer first multiples 64 .0 times 1 Since the first operand is a double, the computer will produce the double result 64 .0 and then divide this by... while the types double and float are designed for working with numbers with fractional parts, Java’s other numeric types, including long, int, and short can only represent whole numbers The distinctions between doubles and floats and between longs, ints, and shorts involve the range of values that are supported by these types Java provides the operators +, -, *, and / for the standard operations of addition,... sodaRation; and then execute the assignment statements 187 ounces = 64 ; friends = 3; sodaRation = ounces/friends; the number associated with the name sodaRation will be 21.33333 On the other hand, if we declare the variables private int students; private int labs; private int labSize; and then execute the assignments students = 64 ; labs = 3; labSize = students/labs; the number associated with labSize... understand why Java rejects conditions of this form, you have to remember that Java interprets symbols like . notation and the standard forms of the same values. 1 86 E-notation Standard Representation Standard Scientific Notation 1.0E8 100, 000, 000 1 × 10 8 1.86E5 1 86, 000 1. 86 × 10 5 4.9E -6 .0000049. symbols like <= as operators and applies them exactly as it applies +, *, and other arithmetic operators. If you knew that the name x was associated with the number 6 and were asked to describe. between numbers and objects like JTextFields. First, it is worth noting that within Java we can manipulate numbers using many of the same mechanisms that are used with GUI components and other objects.