Chapter 2: Introduction to Java Applications; Input/Output and Operators

Condition

A *condition* is an expression that can be *true* or *false*

Class Body

A *left brace* (as in line 5 of image), *{*, begins the body of every class declaration. A corresponding *right brace* (at line 11 of image),* }*, must end each class declaration. Lines 6-10 in image are indented

Identifier

A class name is an *identifier* - a series of characters consisting of letters, digits, underscores (_), and dollar signs ($) that does not begin with a digit and does not contain spaces. Some valid identifiers are Welcome1, $value, _value, m_inputField1, and button7

Java Application

A computer program that executes when you use the *java command* to launch the Java Virtual Machine(JVM)

Packages

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)*

Variable

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

Filename for a public Class

A public class must be placed in a file that has a filename of the form ClassName.java, so class Welcome1 is stored in the file Welcome1.java

Newline Characters

A single statement can display multiple lines by using newline characters, which indicate to System.out's print and println methods when to position the output cursor at the beginning of the next line in the command window

The Format Specifier %s

The format specifier %s is a placeholder for a string. The format string in line 9 specifies that printf should output two strings, each followed by a newline character.

Format Specifier %d

The format specifier *%d* in this image is a placeholder for an int value (in this case the value of sum)—the letter d stands for "decimal integer."

Body of the Method Declaration

The left brace in line 8 of this image begins the body of the method declaration. A corresponding right brace must end it (line 10). Line 9 in the method body is indented between the braces

new Keyword

This expression uses the *new* keyword to create a Scanner object that reads characters typed by the user at the keyboard

if Selection Statement

Allows a program to make a decision based on a condition's value. If the condition in an if statement is true, the body of the if statement executes. If the condition is false, the body does not execute

Arithmetic Expressions in Straight-Line Form

Arithmetic expressions in Java must be written in *straight-line form* to facilitate entering programs into the computer. Thus, expressions such as "a divided by b" must be written as a / b, so that all constants, variables and operators appear in a straight line

Equality and Relational Operators

Conditions in if statements can be formed by using the equality operators (== and !=) and relational operators (>, <, >= and <=). Both equality operators have the same level of precedence, which is lower than that of the relational operators. The equality operators associate from left to right. The relational operators all have the same level of precedence and also associate from left to right.

Prompt

Directs the user to take a specific action. This image uses System.out.print to display the message "Enter first integer: "

Expressions

Portions of statements that contain calculations

Variables to Store Data

Programs remember numbers and other data in the computer's memory and access that data through program elements called *variables*

Integer Division

*Integer division* yields an integer quotient. For example, the expression 7 / 4 evaluates to 1, and the expression 17 / 5 evaluates to 3. Any fractional part in integer division is simply truncated (i.e., discarded)—no rounding occurs

Variable Name

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—again, a series of characters consisting of letters, digits, underscores (_) and dollar signs ($) that does not begin with a digit and does not contain spaces.

Variable Type

A variable's type specifies what kind of information is stored at that location in memory

Syntax Error

An error that occurs when the compiler encounters code that violates Java's language rules. Syntax errors are also called *compiler errors, compile-time errors, or compilation errors*, because the compiler detects them when compiling the program

Keywords(Reserved Words)

Are words reserved for use by Java and are always spelled with all lowercase letters

Class Names

By convention, class names begin with a capital letter and capitalize the first letter of each work they include (e.g., SampleClassName)

java.lang

Class *System* is part package. 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.

End-of-line Comments

Comments that terminate at the end of the line on which the // appears. An end-of-line comment need not begin a line; it also can begin in the middle of a line and continue until the end

Format Specifier

Each format specifier is a placeholder for a value and specifies the type of data to output. Format specifiers also may include optional formatting information. Format specifiers begin with a percent sign (%) followed by a character that represents the data type

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.

Standard input object, System.in

Enables applications to read bytes of data typed by the user. The Scanner translates these bytes into types (like ints) that can be used in a program

public Keyword

Every class we define begins with the *public* keyword

Fixed Text

Fixed text is output by printf just as it would be by print or println

Type float and double

Hold real numbers. Real numbers contain decimal points, such as in 3.4, 0.0 and -11.19

Nested Parentheses

If an expression contains nested parentheses, such as, ((a + b) * c, )the expression in the innermost set of parentheses (a + b in this case) is evaluated first

Command Line

In UNIX/Linux/Mac OS X, the command window is called a *terminal window* or a *shell*. Many programmers call it simply the *command line*.

Assignment Operator(=)

In line 18 of this image, 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().

Keyword void

Indicates that this method will not return any information

Traditional Comments

Java also has *traditional comments*, which can be spread over several lines. These begin and end with delimiters, /* and */. The compiler ignores all text between the delimiters

Rules of Operator Precendence

Java applies the operators in arithmetic expressions in a precise sequence determined by the *rules of operator precedence*, which are generally the same as those followed in algebra

Java is Case Sensitive

Java is *case sensitive*—uppercase and lowercase letters are distinct—so value and Value are different (but both valid) identifiers

Javadoc Comments

Java provides comments of a third type - *Javadoc comments*. These are delimited bby /** and */. The compiler ignores all text between the delimiters. These comments allow you to embed program documentation directly in your programs

Remainder Operator

Java provides the *remainder operator*, %, which yields the remainder after division. The expression x % y yields the remainder after x is divided by y. Thus, 7 % 4 yields 3, and 17 % 5 yields 2.

Variable Declaration Statement

Like other statements, declaration statements end with a semicolon (;). Line 11 of this image, Scanner input = new Scanner(System.in);, is a variable declaration statement that specifies the name (input) and type (Scanner) of a variable that's used in this program

nextInt Method

Line 18 of this image 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

import Declaration

Line 3 of this image, import java.util.Scanner; // program uses class Scanner, is an import declaration that helps the compiler locate a class that's used in this program. It indicates that the program uses the predefined Scanner class (discussed shortly) from the package named *java.util*. The compiler then ensures that you use the class correctly

Declaring a Class

Line 4 of this image, public class Welcome1, begins a *class declaration* for class Welcome1. Every Java program consists of at least one class that you (the programmer) define. The *class keyword* introduces a class declaration and is immediately followed by the *class name* (Welcome1)

main Method

Line 6 in this image, // main method begins execution of Java application, is an end-of-line comment indicating the purpose of lines 7-10 of the program. Line 7 in this image, *public static void main(String[] args)*, is the starting point of every Java application. For a Java application, one of the methods must be called main and must be defined as shown in line 7; otherwise, the Java Virtual Machine (JVM) will not execute the application

Performing Output with System.out.println

Line 9 of this image, System.out.println("Welcome to Java Programming!");, instructs the computer to perform an action—namely, to display the characters contained between the double quotation marks (the quotation marks themselves are not displayed)

Calling System.out.printf

Lines 9-10 in this image call method System.out.printf to display the program's output. The method call specifies three arguments. When a method requires multiple arguments, they're placed in a *comma-separated list*. Calling a method is also referred to as *invoking* a method.

Method System.out.println

Method *System.out.println* displays (or prints) a line of text in the command window. The string in the parentheses in line 9 of this image is the *argument* to the method. When System.out.println completes its task, it positions the output cursor (the location where the next character will be displayed) at the beginning of the next line in the command window

Format String

Method printf's first argument is a *format string* that may consist of *fixed text* and *format specifiers*.

Parentheses for Grouping Expressions

Parentheses are used to group terms in Java expressions in the same manner as in algebraic expressions. For example, to multiply a times the quantity b + c, we write, a * (b + c)

Alternate Way of Declaring Variables

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)

Arithmetic Operators

Shown in image. The *asterisk (*)* indicates multiplication, and the percent sign *(%)* is the *remainder operator*. The arithmetic operators shown in image are binary operators, because each operates on two operands

System.out Object

The *System.out* object—which is predefined for you—is known as the *standard output object*. It allows a Java application to display information in the *command window* from which it executes

Displaying Text with printf

The *System.out.printf* method (f means "formatted") displays formatted data. This image uses this method to output on two lines the strings "Welcome to" and "Java Programming!".

Backslash(\)

The *backslash (\)* is an *escape character*, which has special meaning to System.out's print and println methods. When a backslash appears in a string, Java combines it with the next character to form an *escape sequence*—\n represents the newline character

javadoc Utility Program

The *javadoc utility program* (part of the JDK) reads Javadoc comments and uses them to prepare program documentation in HTML format

Declaring a Method

The *parentheses* after the identifier main in this image indicate that it's a program building block called a *method*. Java class declarations normally contain one or more methods. Methods perform tasks and can return information when they complete their tasks

Initialized

The = in line 11 of this image 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)

Statement

The entire line 9, including System.out.println, the argument "Welcome to Java Programming!" in the parentheses and the *semicolon* (;), is called a *statement*. A method typically contains one or more statements that perform its task. Most statements end with a semicolon.

Primitive Types

The types int, float, double and char are called primitive types. Primitive-type names are keywords and must appear in all lowercase letters

Type int

They can hold integer values (whole numbers such as 72, -1127 and 0). The range of values for an int is -2,147,483,648 to +2,147,483,647.

String

Together, the quotation marks and the characters between them are a *string*—also known as a *character string* or a *string literal*. White-space characters in strings are not ignored by the compiler. Strings cannot span multiple lines of code.

Memory Concepts

Variable names such as number1 actually correspond to locations in memory. Every variable has a *name*, a *type*, a *size*(in bytes), and a *value*. In the statement, number1 = input.nextInt(); // read first number from user, the number typed by the user is placed into a memory location corresponding to the name number1

Type char

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 tab character, \t.

Comments

We insert *comments* to *document programs* and improve their readability. The Java compiler ignores comments, so they do not cause the computer to perform any action when the program is run

%n Format Specifier

the %n format specifier, which is a line separator that's portable across operating systems. You cannot use %n in the argument to System.out.print or System.out.println; however, the line separator output by System.out.println after it displays its argument is portable across operating systems