- 2.1 Introduction
- 2.2 Your First Program in Java: Printing a Line of Text
- 2.3 Modifying Your First Java Program
- 2.4 Displaying Text with printf
- 2.5 Another Application: Adding Integers
- 2.6 Memory Concepts
- 2.7 Arithmetic
- 2.8 Decision Making: Equality and Relational Operators
- 2.9 Wrap-Up
- Summary
- Self-Review Exercises
- Answers to Self-Review Exercises
- Exercises
- Making a Difference
This chapter is from the book
This chapter is from the book
This chapter is from the book
2.5 Another Application: Adding Integers
Our next application reads (or inputs) two integers (whole numbers, such as –22, 7, 0 and 1024) typed by a user at the keyboard, computes their sum and displays it. This program must keep track of the numbers supplied by the user for the calculation later in the program. Programs remember numbers and other data in the computer's memory and access that data through program elements called variables. The program of Fig. 2.7 demonstrates these concepts. In the sample output, we use bold text to identify the user's input (i.e., 45 and 72 ).
Fig 2.7. Addition program that displays the sum of two numbers.
1// Fig. 2.7: Addition.java2// Addition program that displays the sum of two numbers.3import java.util.Scanner; // program uses class Scanner4 5public classAddition 6 { 7// main method begins execution of Java application8public static voidmain( String[] args ) 9 { 10// create a Scanner to obtain input from the command window11Scanner input = new Scanner( System.in );12 13int number1; // first number to add14int number2; // second number to add15int sum; // sum of number1 and number216 17 System.out.print("Enter first integer: " ); // prompt18number1 = input.nextInt(); // read first number from user19 20 System.out.print("Enter second integer: " ); // prompt21number2 = input.nextInt(); // read second number from user22 23sum = number1 + number2; // add numbers, then store total in sum24 25System.out.printf( "Sum is %d\n", sum ); // display sum26 }// end method main27 }// end class Addition
Import Declarations
Lines 1–2
|
state the figure number, file name and purpose of the program.
A great strength of Java is its rich set of predefined classes that you can reuse rather than "reinventing the wheel." These classes are grouped into packages—named groups of related classes—and are collectively referred to as the Java class library, or the Java Application Programming Interface (Java API). Line 3
|
is an import declaration that helps the compiler locate a class that's used in this program. It indicates that this example uses Java's predefined Scanner class (discussed shortly) from package java.util .
Common Programming Error 2.5
All import declarations must appear before the first class declaration in the file. Placing an import declaration inside or after a class declaration is a syntax error.
Error-Prevention Tip 2.8
Forgetting to include an import declaration for a class used in your program typically results in a compilation error containing a message such as "cannot find symbol." When this occurs, check that you provided the proper import declarations and that the names in them are correct, including proper capitalization.
Declaring Class Addition
Line 5
|
begins the declaration of class Addition. The file name for this public class must be Addition.java. Remember that the body of each class declaration starts with an opening left brace (line 6) and ends with a closing right brace (line 27).
The application begins execution with the main method (lines 8–26). The left brace (line 9) marks the beginning of method main's body, and the corresponding right brace (line 26) marks its end. Method main is indented one level in the body of class Addition, and the code in the body of main is indented another level for readability.
Declaring and Creating a Scanner to Obtain User Input from the Keyboard
A variable is a location in the computer's memory where a value can be stored for use later in a program. All Java variables must be declared with a name and a type before they can be used. A variable's name enables the program to access the value of the variable in memory. A variable's name can be any valid identifier. A variable's type specifies what kind of information is stored at that location in memory. Like other statements, declaration statements end with a semicolon (;).
Line 11
Scanner input =
|
is a variable declaration statement that specifies the name (input) and type (Scanner) of a variable that's used in this program. A Scanner enables a program to read data (e.g., numbers and strings) for use in a program. The data can come from many sources, such as the user at the keyboard or a file on disk. Before using a Scanner, you must create it and specify the source of the data.
The = in line 11 indicates that Scanner variable input should be initialized (i.e., prepared for use in the program) in its declaration with the result of the expression to the right of the equals sign—new Scanner(System.in). This expression uses the new keyword to create a Scanner object that reads characters typed by the user at the keyboard. The standard input object, System.in , enables applications to read bytes of information typed by the user. The Scanner translates these bytes into types (like ints) that can be used in a program.
Declaring Variables to Store Integers
The variable declaration statements in lines 13–15
|
declare that variables number1, number2 and sum hold data of type int —they can hold integer values (whole numbers such as 72, –1127 and 0). These variables are not yet initialized. The range of values for an int is –2,147,483,648 to +2,147,483,647. [Note: Actual int values may not contain commas.]
Other types of data include float and double , for holding real numbers, and char , for holding character data. Real numbers contain decimal points, such as 3.4, 0.0 and –11.19. Variables of type char represent individual characters, such as an uppercase letter (e.g., A), a digit (e.g., 7), a special character (e.g., * or %) or an escape sequence (e.g., the newline character, \n). The types int, float, double and char are called primitive types. Primitive-type names are keywords and must appear in all lowercase letters. Appendix D summarizes the characteristics of the eight primitive types (boolean, byte, char, short, int, long, float and double).
Several variables of the same type may be declared in a single declaration with the variable names separated by commas (i.e., a comma-separated list of variable names). For example, lines 13–15 can also be written as:
|
Good Programming Practice 2.7
Declare each variable on a separate line. This format allows a descriptive comment to be inserted next to each declaration.
Good Programming Practice 2.8
Choosing meaningful variable names helps a program to be self-documenting (i.e., one can understand the program simply by reading it rather than by reading manuals or viewing an excessive number of comments).
Good Programming Practice 2.9
By convention, variable-name identifiers begin with a lowercase letter, and every word in the name after the first word begins with a capital letter. For example, variable-name identifier firstNumber starts its second word, Number, with a capital N.
Prompting the User for Input
Line 17
System.out.print(
|
uses System.out.print to display the message "Enter first integer: ". This message is called a prompt because it directs the user to take a specific action. We use method print here rather than println so that the user's input appears on the same line as the prompt. Recall from Section 2.2 that identifiers starting with capital letters typically represent class names. So, System is a class. Class System is part of package java.lang . Notice that class System is not imported with an import declaration at the beginning of the program.
Software Engineering Observation 2.1
By default, package java.lang is imported in every Java program; thus, classes in java.lang are the only ones in the Java API that do not require an import declaration.
Obtaining an int as Input from the User
Line 18
number1 = input.nextInt();
|
uses Scanner object input's nextInt method to obtain an integer from the user at the keyboard. At this point the program waits for the user to type the number and press the Enter key to submit the number to the program.
Our program assumes that the user enters a valid integer value. If not, a runtime logic error will occur and the program will terminate. Chapter 11, Exception Handling: A Deeper Look, discusses how to make your programs more robust by enabling them to handle such errors. This is also known as making your program fault tolerant.
In line 18, we place the result of the call to method nextInt (an int value) in variable number1 by using the assignment operator, = . The statement is read as "number1 gets the value of input.nextInt()." Operator = is called a binary operator, because it has two operands—number1 and the result of the method call input.nextInt(). This statement is called an assignment statement, because it assigns a value to a variable. Everything to the right of the assignment operator, =, is always evaluated before the assignment is performed.
Good Programming Practice 2.10
Placing spaces on either side of a binary operator makes the program more readable.
Prompting for and Inputting a Second int
Line 20
System.out.print(
|
prompts the user to input the second integer. Line 21
number2 = input.nextInt();
|
reads the second integer and assigns it to variable number2.
Using Variables in a Calculation
Line 23
sum = number1 + number2;
|
is an assignment statement that calculates the sum of the variables number1 and number2 then assigns the result to variable sum by using the assignment operator, =. The statement is read as "sum gets the value of number1 + number2." In general, calculations are performed in assignment statements. When the program encounters the addition operation, it performs the calculation using the values stored in the variables number1 and number2. In the preceding statement, the addition operator is a binary operator—its two operands are the variables number1 and number2. Portions of statements that contain calculations are called expressions. In fact, an expression is any portion of a statement that has a value associated with it. For example, the value of the expression number1 + number2 is the sum of the numbers. Similarly, the value of the expression input.nextInt() is the integer typed by the user.
Displaying the Result of the Calculation
After the calculation has been performed, line 25
System.out.printf(
|
uses method System.out.printf to display the sum. The format specifier %d is a placeholder for an int value (in this case the value of sum)—the letter d stands for "decimal integer." The remaining characters in the format string are all fixed text. So, method printf displays "Sum is ", followed by the value of sum (in the position of the %d format specifier) and a newline.
Calculations can also be performed inside printf statements. We could have combined the statements at lines 23 and 25 into the statement
System.out.printf(
|
The parentheses around the expression number1 + number2 are not required—they're included to emphasize that the value of the entire expression is output in the position of the %d format specifier.
Java API Documentation
For each new Java API class we use, we indicate the package in which it's located. This information helps you locate descriptions of each package and class in the Java API documentation. A web-based version of this documentation can be found at
download.oracle.com/javase/6/docs/api/ |
You can download it from
www.oracle.com/technetwork/java/javase/downloads/index.html |
Appendix E shows how to use this documentation.