Day 3

Java Basics

by Laura Lemay

• 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
  

Already this week you've learned about Java programming in very broad terms-what a Java program and an executable look like, and how to create simple classes. 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.

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 indicates the simplest tasks you can accomplish in Java; a statement forms a single Java operation. All 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. You'll learn about these later today.

White space in Java statements, as with C, is unimportant. A statement can be contained on a single line or on multiple lines, and the Java compiler will be able to read it just fine. The most important thing to remember about Java statements is that each one ends with a semicolon (;). Forget the semicolon, and your Java program won't compile.

Java also has compound statements, or blocks, which can be placed wherever a single statement can. Block statements are surrounded by braces ({}). You'll learn more about blocks on Day 5, "Arrays, Conditionals, and Loops."

Variables and Data Types

Variables are locations in memory in which values can be stored. Each one has a name, a type, and a value. Before you can use a variable, you have to declare it. After it is declared, you can then assign values to it (you can also declare and assign a value to a variable at the same time, as you'll learn in this section).

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

Instance variables, as you learned yesterday, are used to define the attributes of a particular object. Class variables are similar to instance variables, except their values apply to all 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 can also be used inside blocks, which you'll learn about on Day 5. 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 ways, 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 on one line:

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

You can also 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 can also group individual variables and initializers on the same line using commas, as with the last example.

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 always to 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, are often reserved for operators in Java, so be careful when using symbols in variable names.

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 includes several thousand 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 from 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 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 5; this lesson focuses on the primitive and class types.

Primitive Types

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 3.1). All are signed, which means they can hold either positive or negative numbers. Which 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 is silently 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.

Note that all the primitive types are in lowercase. Be careful when you use them in your programs that you do use the lowercase, because there are also classes with the same names (and an initial capital letter) that have different behavior-so, for example, the primitive type boolean is different from the Boolean class. You'll learn more about these special classes and what they're used for on Day 4, "Working with Objects."

Class Types

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

String LastName;
Font basicFont;
OvalShape myOval;

Each of these variables can hold instances of the named class or of any of its subclasses. The latter is useful when you want a variable to be able to hold different instances of related classes. For example, let's say you had a set of fruit classes-Apple, Pear, Strawberry, and so on- all of which inherited from the general class Fruit. By declaring a variable of type Fruit, that variable can then hold instances of any of the Fruit classes. Declaring a variable of type Object means that variable can hold any object.

Assigning Values to Variables

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

size = 14;
tooMuchCaffiene = true;

Comments

Java has three kinds of comments: two for regular comments in source code and one for the special documentation system javadoc.

The symbols /* 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 */. The contents of these special comments are used by the javadoc system, but are otherwise used identically to the first type of comment. javadoc is used to generate API documentation from the code. You'll learn more about javadoc on Day 22, "Java Programming Tools."

Literals

Literal is a programming language term that 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 are used to indicate simple values in your Java programs.

Literals may 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 can also 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.77777. A floating-point literal results in a floating-point number of type double, regardless of the precision of the 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 3.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 simply 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 data 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: All expressions, when evaluated, return a value (other statements don't necessarily do so). 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.

Most of the expressions in Java use operators. Operators are special symbols for things like arithmetic, various forms of assignment, increment and decrement, and logical operations.

Arithmetic

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

Each operator takes two operands, one on either side of the operator. The subtraction operator (-) can also 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.

Note that the result type of most arithmetic operations involving integers is an int regardless of the original type of the operands (shorts and bytes are both automatically converted to int). If either or both operands is of type long, the result is of type long. If one operand is an integer and another is a floating-point number, the result is a floating point. (If you're interested in the details of how Java promotes and converts numeric types from one type to another, you may want to check out the Java Language Specification on Sun's official Java Web site at http://java.sun.com/; that's more detail than I want to cover here.)

Listing 3.1 is an example of simple arithmetic in Java.

Listing 3.1. Simple arithmetic.

 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: }

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

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. The System.out.println() method takes a single argument-a string-but you can use + to concatenate multiple values into a single 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 is always 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 3.4 shows these shorthand assignment operators.

Incrementing and Decrementing

As in C and C++, the ++ and -- operators are used to increment or decrement a variable's 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, which one you use isn't overly important. In complex assignments, where you are assigning the result of an increment or decrement expression, which one you use makes a difference.

Take, for example, the following two expressions:

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

These two expressions yield 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. Listing 3.2 is a Java example of how all this works.

Listing 3.2. Test of prefix and postfix increment operators.

 1: class PrePostFixTest {
 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: }

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 3.5 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 && operators. The entire expression will be true only if both expressions on either side of the operator are also 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 is assumed to be false (the value of the right side doesn't matter), so the expression returns false, and the right side of the expression is never evaluated. (This is often called a "short-circuited" expression.)

For OR expressions, use either | or ||. OR expressions result in true if either or both of the expressions on either side is also true; if both expression operands are false, the expression is false. As with & and &&, the single | evaluates both sides of the expression regardless of the outcome; and || is short-circuited: 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. Most of these expressions 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 3.6 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 3.7 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 can always 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 expressions evaluate in the order you want them to (the innermost parenthetic expression is evaluated first). The following expression 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:

y = (6 + 4) / 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 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 (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 the parts together-the descriptions plus the variables-and print 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 this:

myName = myName + " Jr.";

just as it would be 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 have 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 have 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 3.8 is a list of all the operators you have learned about today so that you can refer back to them.

Q&A