Chapter 4

Java Basics

CONTENTS

• Statements and Expressions
• Variables and Data Types
  • Declaring Variables
  • Notes on Variable Names
  • Variable Types
  • Assigning Values to Variables
• Comments
• Literals
  • Number Literals
  • Boolean Literals
  • Character Literals
  • String Literals
• Expressions and Operators
  • Arithmetic
  • More About Assignment
  • Incrementing and Decrementing
  • Comparisons
  • Logical Operators
  • Bitwise Operators
  • Operator Precedence
• String Arithmetic
• Summary
• Q&A

On Days 1 and 3, you learned about Java programming in very broad terms-what a Java program and an executable look like, and how to create simple classes. On Day 2 you learned about the Café desktop. For the remainder of this week, you're going to get down to details and deal with the specifics of what the Java language looks like and how you can use Café to make understanding Java easier.

Today, you won't define any classes or objects or worry about how any of them communicate inside a Java program. Rather, you'll draw closer and examine simple Java statements-the basic things you can do in Java within a method definition such as main().

Today you'll learn about the following:

• Java statements and expressions
• Variables and data types
• Comments
• Literals
• Arithmetic
• Comparisons
• Logical operators

Statements and Expressions

A statement is the simplest thing you can do in Java; a statement forms a single Java operation. All of the following are simple Java statements:

int i = 1;
import java.awt.Font;
System.out.println("This motorcycle is a "
    + color + " " + make);
m.engineState = true;

Statements sometimes return values-for example, when you add two numbers together or test to see whether one value is equal to another. These kind of statements are called expressions. We'll discuss them later on today.

The most important thing to remember about Java statements is that each one ends with a semicolon. Forget the semicolon and you will get an error when you compile your Java program.

Java also has compound statements, or blocks, that can be placed wherever a single state-
ment can. Block statements are surrounded by braces ({}). You'll learn more about blocks on Day 6.

Variables and Data Types

Variables are locations in memory in which values can be stored. They have a name, a type, and a value. Before you can use a variable, you have to declare it. After it is declared, you then can assign values to it.

Java actually has three kinds of variables: instance variables, class variables, and local variables.

Instance variables, as you learned yesterday, are used to define attributes or the state for a particular object. Class variables are similar to instance variables, except that their values apply to all of that class's instances (and to the class itself) rather than having different values for each object.

Local variables are declared and used inside method definitions-for example, for index counters in loops, as temporary variables, or to hold values that you need only inside the method definition itself. They also can be used inside blocks ({}), which you'll learn about later this week. Once the method (or block) finishes executing, the variable definition and its value cease to exist. Use local variables to store information needed by a single method and instance variables to store information needed by multiple methods in the object.

Although all three kinds of variables are declared in much the same way, class and instance variables are accessed and assigned in slightly different ways from local variables. Today, you'll focus on variables as used within method definitions; tomorrow, you'll learn how to deal with instance and class variables.

Declaring Variables

To use any variable in a Java program, you must first declare it. Variable declarations consist of a type and a variable name:

int myAge;
String myName;
boolean isTired;

Variable definitions can go anywhere in a method definition (that is, anywhere a regular Java statement can go), although they are most commonly declared at the beginning of the definition before they are used:

public static void main (String args[]) {
    int count;
    String title;
    boolean isAsleep;
...
}

You can string together variable names with the same type:

int x, y, z;
String firstName, LastName;

You also can give each variable an initial value when you declare it:

int myAge, mySize, numShoes = 28;
String myName = "Laura";
boolean isTired = true;
int a = 4, b = 5, c = 6;

If there are multiple variables on the same line with only one initializer (as in the first of the previous examples), the initial value applies to only the last variable in a declaration. You also can group individual variables and initializers on the same line using commas, as with the last example, above.

Local variables must be given values before they can be used. (Your Java program will not compile if you try to use an unassigned local variable.) For this reason, it's a good idea to always give local variables initial values. Instance and class variable definitions do not have this restriction (their initial value depends on the type of the variable: null for instances of classes, 0 for numeric variables, '\0' for characters, and false for booleans).

Notes on Variable Names

Variable names in Java can start with a letter, an underscore (_), or a dollar sign ($). They cannot start with a number. After the first character, your variable names can include any letter or number. Symbols, such as %, *, @, and so on, often are reserved for operators in Java, so be careful when using symbols in variable names. A good programming practice is to not use symbols in variable names-unless there is a very good reason to.

In addition, the Java language uses the Unicode character set. Unicode is a character set definition that not only offers characters in the standard ASCII character set, but also several million other characters for representing most international alphabets. This means that you can use accented characters and other glyphs as legal characters in variable names, as long as they have a Unicode character number above 00C0.

Finally, note that the Java language is case-sensitive, which means that uppercase letters are different than lowercase letters. This means that the variable X is different from the variable x, and a rose is not a Rose is not a ROSE. Keep this in mind as you write your own Java programs and as you read Java code other people have written.

By convention, Java variables have meaningful names, often made up of several words combined. The first word is lowercase, but all following words have an initial uppercase letter:

Button theButton;
long reallyBigNumber;
boolean currentWeatherStateOfPlanetXShortVersion;

Variable Types

In addition to the variable name, each variable declaration must have a type, which defines what values that variable can hold. The variable type can be one of three things:

• One of the eight basic primitive data types
• The name of a class or interface
• An array

You'll learn about how to declare and use array variables on Day 6.

The eight primitive data types handle common types for integers, floating-point numbers, characters, and boolean values (true or false). They're called primitive because they're built into the system and are not actual objects, which makes them more efficient to use. Note that these data types are machine-independent, which means that you can rely on their sizes and characteristics to be consistent across your Java programs.

There are four Java integer types, each with a different range of values (as listed in Table 4.1). All are signed, which means they can hold either positive or negative numbers. The type you choose for your variables depends on the range of values you expect that variable to hold; if a value becomes too big for the variable type, it silently is truncated.

Floating-point numbers are used for numbers with a decimal part. Java floating-point numbers are compliant with IEEE 754 (an international standard for defining floating-point numbers and arithmetic). There are two floating-point types: float (32 bits, single-precision) and double (64 bits, double-precision).

The char type is used for individual characters. Because Java uses the Unicode character set, the char type has 16 bits of precision, unsigned.

Finally, the boolean type can have one of two values, true or false. Note that unlike in other C-like languages, boolean is not a number, nor can it be treated as one. All tests of boolean variables should test for true or false.

In addition to the eight basic data types, variables in Java also can be declared to hold an instance of a particular class:

String LastName;
Font basicFont;
OvalShape myOval;

Each of these variables then can hold only instances of the given class. As you create new classes, you can declare variables to hold instances of those classes (and their subclasses) as well.

Assigning Values to Variables

Once a variable has been declared, you can assign a value to that variable by using the assignment operator =:

size = 14;
tooMuchCaffiene = true;

Comments

Java has three kinds of comments. /* and */ surround multiline comments, as in C or C++. All text between the two delimiters is ignored:

/* I don't know how I wrote this next part; I was working
    really late one night and it just sort of appeared. I
    suspect the code elves did it for me. It might be wise
    not to try and change it.
*/

These comments cannot be nested; that is, you cannot have a comment inside a comment.

Double slashes (//) can be used for a single line of comment. All the text up to the end of the line is ignored:

int vices = 7; // are there really only 7 vices?

The final type of comment begins with /** and ends with */.

Literals

Literals are used to indicate simple values in your Java programs.

Literal is a programming language term, which essentially means that what you type is what you get. For example, if you type 4 in a Java program, you automatically get an integer with the value 4. If you type 'a', you get a character with the value a.

Literals might seem intuitive most of the time, but there are some special cases of literals in Java for different kinds of numbers, characters, strings, and boolean values.

Number Literals

There are several integer literals. 4, for example, is a decimal integer literal of type int (although you can assign it to a variable of type byte or short because it's small enough to fit into those types). A decimal integer literal larger than an int is automatically of type long. You also can force a smaller number to a long by appending an L or l to that number (for example, 4L is a long integer of value 4). Negative integers are preceded by a minus sign-for example, -45.

Integers also can be expressed as octal or hexadecimal: a leading 0 indicates that a number is octal-for example, 0777 or 0004. A leading 0x (or 0X) means that it is in hex (0xFF, 0XAf45). Hexadecimal numbers can contain regular digits (0-9) or upper- or lowercase hex digits (a-f or A-F).

Floating-point literals usually have two parts: the integer part and the decimal part-for example, 5.677777. Floating-point literals result in a floating-point number of type double, regardless of the precision of that number. You can force the number to the type float by appending the letter f (or F) to that number-for example, 2.56F.

You can use exponents in floating-point literals using the letter e or E followed by the exponent (which can be a negative number): 10e45 or .36E-2.

Boolean Literals

Boolean literals consist of the keywords true and false. These keywords can be used anywhere you need a test or as the only possible values for boolean variables.

Character Literals

Character literals are expressed by a single character surrounded by single quotes: 'a', '#', '3', and so on. Characters are stored as 16-bit Unicode characters. Table 4.2 lists the special codes that can represent nonprintable characters, as well as characters from the Unicode character set. The letter d in the octal, hex, and Unicode escapes represents a number or a hexadecimal digit (a-f or A-F).

String Literals

A combination of characters is a string. Strings in Java are instances of the class String. Strings are not simple arrays of characters as they are in C or C++, although they do have many array-like characteristics (for example, you can test their length and access and change individual characters). Because string objects are real objects in Java, they have methods that enable you to combine, test, and modify strings very easily.

String literals consist of a series of characters inside double quotes:

"Hi, I'm a string literal."
"" //an empty string

Strings can contain character constants such as newline, tab, and Unicode characters:

"A string with a \t tab in it"
"Nested strings are \"strings inside of\" other strings"
"This string brought to you by Java\u2122"

In the last example, the Unicode code sequence for \u2122 produces a trademark symbol (™).

When you use a string literal in your Java program, Java automatically creates an instance of the class String for you with the value you give it. Strings are unusual in this respect; the other literals do not behave in this way (none of the primitive base types are actual objects), and usually creating a new object involves explicitly creating a new instance of a class. You'll learn more about strings, the String class, and the things you can do with strings later today and tomorrow.

Expressions and Operators

Expressions are the simplest form of statement in Java that actually accomplishes something.

Expressions are statements that return a value.

Operators are special symbols that commonly are used in expressions.

Arithmetic and tests for equality and magnitude are common examples of expressions. Because they return a value, you can assign that result to a variable or test that value in other Java statements.

Operators in Java include arithmetic, various forms of assignment, increment and decrement, and logical operations. This section describes all of these things.

Arithmetic

Java has five operators for basic arithmetic (see Table 4.3).

Each operator takes two operands, one on either side of the operator. The subtraction operator (-) also can be used to negate a single operand.

Integer division results in an integer. Because integers don't have decimal fractions, any remainder is ignored. The expression 31 / 9, for example, results in 3 (9 goes into 31 only 3 times).

Modulus (%) gives the remainder once the operands have been evenly divided. For example, 31 % 9 results in 4 because 9 goes into 31 three times, with 4 left over.

When dealing with integers in binary arithmetic (arithmetic operations involving two operands and one operator), if either operand is of type long then the other operand will automatically be promoted to long and the resulting value will be a long. This is also true if either operand is type float. If, on the other hand, you are using the short or byte integer data type as one of your operands, they will automatically be promoted to type int-as will the result. Note that all of the promotions described in binary arithmetic increase the bit width of the data type, thus there is no potential for data loss except in the case of floats where there is a potential for rounding. The next several paragraphs will be a runnable example of arithmetic.

Create a new project called Arithmetic.prj using Table 4.4 to input to the ProjectExpress wizard.

After this is done, open a new Source window text editor and input the code from Listing 4.1 into it.

Listing 4.1. The code for Arithmetic.java.

1: class ArithmeticTest {
2: public static void main (String args[]) {
3:     short x = 6;
4:     int y = 4;
5:     float a = 12.5f;
6:     float b = 7f;
7:
8:     System.out.println("x is " + x + ", y is " + y);
9:     System.out.println("x + y = " + (x + y));
10:     System.out.println("x - y = " + (x - y));
11:     System.out.println("x / y = " + (x / y));
12:     System.out.println("x % y = " + (x % y));
13:
14:     System.out.println("a is " + a + ", b is " + b);
15:     System.out.println("a / b = " + (a / b));
16: }
17:
18: }

Once you have finished copying the code from Listing 4.1 into the Source window text editor, save it as ArithmeticTest.java in the ..\Cafe\Projects directory and add it to the project Arithmetic. Once you have completed that, go ahead and mark ArithmeticTest.java as Main. Your Project window then should look something like Figure 4.1.

Figure 4.1 : Project Window for Arithmetic.prj.

Now you are ready to compile the project by clicking Project and Rebuild All.

When you run the Java application, you should see the following:

x is 6, y is 4
x + y = 10
x - y = 2
x / y = 1
x % y = 2
a is 12.5, b is 7
a / b = 1.78571

In this simple Java application (note the main() method), you initially define four variables in lines 3 through 6: x and y, which are integers (type int), and a and b, which are floating-point numbers (type float). Keep in mind that the default type for floating-point literals (such as 12.5) is double, so to make sure that these are numbers of type float, you have to use an f after each one (lines 5 and 6).

The remainder of the program merely does some math with integers and floating-point numbers and prints out the results.

There is one other thing to mention about this program: the method System.out.println(). You've seen this method on previous days, but you haven't really learned exactly what it does. The System.out.println() method merely prints a message to the standard output of your system-to the screen, to a special window, or maybe just to a special log file, depending on your system and the development environment you're running (Sun's JDK prints it to the screen). The System.out.println() method takes a single argument-a string-but you can use + to concatenate values into a string, as you'll learn later today.

More About Assignment

Variable assignment is a form of expression; in fact, because one assignment expression results in a value, you can string them together like this:

x = y = z = 0;

In this example, all three variables now have the value 0.

The right side of an assignment expression always is evaluated before the assignment takes place. This means that expressions such as x = x + 2 do the right thing; 2 is added to the value of x, and then that new value is reassigned to x. In fact, this sort of operation is so common that Java has several operators to do a shorthand version of this, borrowed from C and C++. Table 4.5 shows these shorthand assignment operators.

Incrementing and Decrementing

As in C and C++, the ++ and -- operators are used to increment or decrement a value by 1. For example, x++ increments the value of x by 1 just as if you had used the expression x = x + 1. Similarly x-- decrements the value of x by 1. (Unlike C and C++, Java allows x to be floating point.)

These increment and decrement operators can be prefixed or postfixed; that is, the ++ or
-- can appear before or after the value it increments or decrements. For simple increment or decrement expressions, the one you use isn't overly important. In complex assignments, where you are assigning the result of an increment or decrement expression, the one you use makes a difference.

Take, for example, the following two expressions:

y = x++;
y = ++x;

These two expressions give very different results because of the difference between prefix and postfix. When you use postfix operators (x++ or x--), y gets the value of x before x is changed; using prefix, the value of x is assigned to y after the change has occurred. Our next project will show how all of this works.

Create a new project called Operators.prj using Table 4.6 to input to the ProjectExpress wizard.

After this is done, open a new Source window text editor and input the code from Listing 4.2 into it.

Listing 4.2. The code for Operators.java.

1: class Operators {
2:
3:    public static void main (String args[]) {
4:        int x = 0;
5:        int y = 0;
6:
7:        System.out.println("x and y are " + x + " and " + y );
8:        x++;
9:        System.out.println("x++ results in " + x);
10:       ++x;
11:       System.out.println("++x results in " + x);
12:       System.out.println("Resetting x back to 0.");
13:       x = 0;
14:       System.out.println("------");
15:       y = x++;
16:       System.out.println("y = x++ (postfix) results in:");
17:       System.out.println("x is " + x);
18:       System.out.println("y is " + y);
19:       System.out.println("------");
20:
21:       y = ++x;
22:       System.out.println("y = ++x (prefix) results in:");
23:       System.out.println("x is " + x);
24:       System.out.println("y is " + y);
25:       System.out.println("------");
26:
27:    }
28:
29: }

Once you have finished copying the code from Listing 4.2 into the Source window text editor, save it as Operators.java in the ..\Cafe\Projects directory and then add it to the project Operators. Once you have completed that, mark Operators.java as Main. Now you are ready to compile this new project by clicking Project and Rebuild All. Run it using the interpreter to see the following output:

x and y are 0 and 0
x++ results in 1
++x results in 2
Resetting x back to 0.
------------
y = x++ (postfix) results in:
x is 1
y is 0
------------
y = ++x (prefix) results in:
x is 2
y is 2
------------

In the first part of this example, you increment x alone using both prefix and postfix increment operators. In each, x is incremented by 1 each time. In this simple form, using either prefix or postfix works the same way.

In the second part of this example, you use the expression y = x++, in which the postfix increment operator is used. In this result, the value of x is incremented after that value is assigned to y. Hence the result: y is assigned the original value of x (0), and then x is incremented by 1.

In the third part, you use the prefix expression y = ++x. Here, the reverse occurs: x is incremented before its value is assigned to y. Because x is 1 from the previous step, its value is incremented (to 2), and then that value is assigned to y. Both x and y end up being 2.

Comparisons

Java has several expressions for testing equality and magnitude. All of these expressions return a boolean value (that is, true or false). Table 4.7 shows the comparison operators:

Logical Operators

Expressions that result in boolean values (for example, the comparison operators) can be combined by using logical operators that represent the logical combinations AND, OR, XOR, and logical NOT.

For AND combinations, use either the & or &&. The expression will be true only if both expressions also are true; if either expression is false, the entire expression is false. The difference between the two operators is in expression evaluation. Using &, both sides of the expression are evaluated regardless of the outcome. Using &&, if the left side of the expression is false, the entire expression returns false, and the right side of the expression never is evaluated.

For OR expressions, use either | or ||. OR expressions result in true if either or both of the operands is also true; if both operands are false, the expression is false. As with & and &&, the single | evaluates both sides of the expression regardless of the outcome; with ||, if the left expression is true, the expression returns true and the right side is never evaluated.

In addition, there is the XOR operator ^, which returns true only if its operands are different (one true and one false, or vice versa) and false otherwise (even if both are true).

In general, only the && and || are commonly used as actual logical combinations. &, |, and ^ are more commonly used for bitwise logical operations.

For NOT, use the ! operator with a single expression argument. The value of the NOT expression is the negation of the expression; if x is true, !x is false.

Bitwise Operators

Finally, here's a short summary of the bitwise operators in Java. These all are inherited from C and C++ and are used to perform operations on individual bits in integers. This book does not go into bitwise operations; it's an advanced topic covered better in books on C or C++. Table 4.8 summarizes the bitwise operators.

Operator Precedence

Operator precedence determines the order in which expressions are evaluated. This, in some cases, can determine the overall value of the expression. For example, take the following expression:

y = 6 + 4 / 2

Depending on whether the 6 + 4 expression or the 4 / 2 expression is evaluated first, the value of y can end up being 5 or 8. Operator precedence determines the order in which expressions are evaluated, so you can predict the outcome of an expression. In general, increment and decrement are evaluated before arithmetic, arithmetic expressions are evaluated before comparisons, and comparisons are evaluated before logical expressions. Assignment expressions are evaluated last.

Table 4.9 shows the specific precedence of the various operators in Java. Operators further up in the table are evaluated first; operators on the same line have the same precedence and are evaluated left to right based on how they appear in the expression itself. For example, given that same expression y = 6 + 4 / 2, you now know, according to this table, that division is evaluated before addition, so the value of y will be 8.

You always can change the order in which expressions are evaluated by using parentheses around the expressions you want to evaluate first. You can nest parentheses to make sure that expressions evaluate in the order you want them to (the innermost parenthetical expression is evaluated first). Consider the following expression:

y = (6 + 4) / 2

This results in a value of 5, because the 6 + 4 expression is evaluated first, and then the result of that expression (10) is divided by 2.

Parentheses also can be useful in cases where the precedence of an expression isn't immediately clear-in other words, they can make your code easier to read. Adding parentheses doesn't hurt, so if they help you figure out how expressions are evaluated, go ahead and use them.

String Arithmetic

One special expression in Java is the use of the addition operator (+) to create and concatenate strings. In most of the previous examples shown today and in earlier lessons, you've seen lots of lines that looked something like this:

System.out.println(name + " is a " + color " beetle");

The output of that line (to the standard output) is a single string, with the values of the variables (here, name and color), inserted in the appropriate spots in the string. So what's going on here?

The + operator, when used with strings and other objects, creates a single string that contains the concatenation of all its operands. If any of the operands in string concatenation is not a string, it is automatically converted to a string, making it easy to create these sorts of output lines.

String concatenation makes lines such as the previous one especially easy to construct. To create a string, just add all of the parts together-the descriptions plus the variables-and output it to the standard output, to the screen, to an applet, or anywhere.

The += operator, which you learned about earlier, also works for strings. For example, take the following expression:

myName += " Jr.";

This expression is equivalent to the following:

myName = myName + " Jr.";

This works the same as it would for numbers. In this case, it changes the value of myName (which might be something like John Smith) to have a Jr. at the end (John Smith Jr.).

Summary

As you learned in the last two lessons, a Java program is made up primarily of classes and objects. Classes and objects, in turn, are made up of methods and variables, and methods are made up of statements and expressions. It is those last two things that you've learned about today; the basic building blocks that enable you to create classes and methods and build them up to a full-fledged Java program.

Today, you learned about variables, how to declare them and assign values to them; literals for easily creating numbers, characters, and strings; and operators for arithmetic, tests, and other simple operations. With this basic syntax, you can move on tomorrow to learning about working with objects and building simple useful Java programs.

To finish up this summary, Table 4.10 is a list of all the operators you learned about today so that you can refer back to them.

Q&A