- The ABCs of Java
- Variables and Data Types
- Comments
- Literals
- Expressions and Operators
- String Arithmetic
- Summary
- Q&A
- Quiz
- Exercises
This chapter is from the book
This chapter is from the book
This chapter is from the book
Variables and Data Types
In the VolcanoRobot application you created during Day 2, "Object-Oriented Programming," you used variables to keep track of information.
New Term
Variables are a place where information can be stored while a program is running. The value can be changed at any point in the program—hence the name.
To create a variable, you must give it a name and identify what type of information it will store. You also can give a variable an initial value at the same time you create it.
There are three kinds of variables in Java: instance variables, class variables, and local variables.
Instance variables, as you learned yesterday, are used to define an object's attributes. Class variables define the attributes of an entire class of objects, and apply to all instances of it.
Local variables are used inside method definitions, or even smaller blocks of statements within a method. They can be used only while the method or block is being executed by the Java interpreter, and they cease to exist afterward.
Although all three kinds of variables are created in much the same way, class and instance variables are used in a different manner than local variables. You learn about local variables today and cover instance and class variables during Day 4, "Working with Objects."
NOTE
Unlike other languages, Java does not have global variables (variables that can be used in all parts of a program). Instance and class variables are used to communicate information from one object to another, and these replace the need for global variables.
Creating Variables
Before you can use a variable in a Java program, you must create the variable by declaring its name and the type of information it will store. The type of information is listed first, followed by the name of the variable. The following are all examples of variable declarations:
int loanLength; String message; boolean gameOver;
NOTE
You learn about variable types later today, but you might be familiar with the types used in this example. The int type represents integers, boolean is used for true/false values, and String is a special variable type used to store text.
Local variables can be declared at any place inside a method, just like any other Java statement, but they must be declared before they can be used. The normal place for variable declarations is immediately after the statement that names and identifies the method.
In the following example, three variables are declared at the top of a program's main() method:
public static void main(String[ ] arguments ) {
int total;
String reportTitle;
boolean active;
}
If you are creating several variables of the same type, you can declare all of them in the same statement by separating the variable names with commas. The following statement creates three String variables named street, city, and state:
String street, city, state;
Variables can be assigned a value when they are created by using an equal sign (=) followed by the value. The following statements create new variables and give them initial values:
int zipCode = 02134; int box = 350; boolean pbs = true; String name = "Zoom", city = "Boston", state = "MA";
As the last statement indicates, you can assign values to multiple variables of the same type by using commas to separate them.
Local variables must be given values before they are used in a program, or the program won't compile successfully. For this reason, it is good practice to give initial values to all local variables.
Instance and class variable definitions are given an initial value depending on the type of information they hold:
Numeric variables 0
Characters '\0'
Booleans false
Objects null
Naming Variables
Variable names in Java must start with a letter, an underscore character (_), or a dollar sign ($). They cannot start with a number. After the first character, variable names can include any combination of letters or numbers.
NOTE
In addition, the Java language uses the Unicode character set, which includes the standard character set plus thousands of others to represent international alphabets. Accented characters and other symbols can be used in variable names as long as they have a Unicode character number.
When naming a variable and using it in a program, it's important to remember that Java is case sensitive—the capitalization of letters must be consistent. Because of this, a program can have a variable named X and another named x—and a rose is not a Rose is not a ROSE.
In programs in this book and elsewhere, Java variables are given meaningful names that include several words joined together. To make it easier to spot the words, the following rule of thumb is used:
The first letter of the variable name is lowercase.
Each successive word in the variable name begins with a capital letter.
All other letters are lowercase.
The following variable declarations follow this rule of naming:
Button loadFile; int areaCode; boolean quitGame;
Variable Types
In addition to a name, a variable declaration must include the type of information being stored. The type can be any of the following:
One of the basic data types
The name of a class or interface
An array
You learn how to declare and use array variables on Day 5. This lesson focuses on the other variable types.
Data Types
There are eight basic variable types for the storage of integers, floating-point numbers, characters, and Boolean values. These often are called primitive types because they are built-in parts of the Java language rather than being objects, which makes them more efficient to use. These data types have the same size and characteristics no matter what operating system and platform you're on, unlike some data types in other programming languages.
There are four data types that can be used to store integers. The one to use depends on the size of the integer, as indicated in Table 3.1.
Table 3.1 Integer Types
|
Type |
Size |
Values That Can Be Stored |
|
byte |
8 bits |
–128 to 127 |
|
short |
16 bits |
–32,768 to 32,767 |
|
int |
32 bits |
–2,147,483,648 to 2,147,483,647 |
|
long |
64 bits |
–9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 |
All these types are signed, which means that they can hold either positive or negative numbers. The type used for a variable depends on the range of values it might need to hold. None of these integer variables can reliably store a value that is too large or too small for its designated variable type, so you should take care when designating the type.
Another type of number that can be stored is a floating-point number, which has the type float or double. Floating-point numbers represent numbers with a decimal part. The float type should be sufficient for most uses because it can handle any number from 1.4E-45 to 3.4E+38. If not, the double type can be used for more precise numbers ranging from 4.9E-324 to 1.7E+308.
The char type is used for individual characters such as letters, numbers, punctuation, and other symbols.
The last of the eight basic data types is boolean. As you have learned, Boolean values hold either true or false in Java.
All these variable types are listed in lowercase, and you must use them as such in programs. There are classes with the same name as some of these data types but different capitalization—for example, Boolean and Char. These have different functionality in a Java program, so you can't use them interchangeably. You will see how these special classes are used tomorrow.
Class Types
In addition to the eight basic data types, a variable can have a class as its type, as in the following examples:
String lastName = "Hopper"; Color hair; VolcanoRobot vr;
When a variable has a class as its type, the variable refers to an object of that class or one of its subclasses.
The last example in the preceding list, VolcanoRobot vr; creates a variable named vr that is reserved for a VolcanoRobot object, although the object itself might not exist yet. You'll learn tomorrow how to associate objects with variables.
Referring to a superclass as a variable type is useful when the variable might be one of several different subclasses. For example, consider a class hierarchy with a CommandButton superclass and three subclasses: RadioButton, CheckboxButton, and ClickButton. If you create a CommandButton variable called widget, it could be used to refer to a RadioButton, CheckboxButton, or ClickButton object.
Declaring a variable of type Object means that it can be associated with any kind of object.
NOTE
Java does not have anything comparable to the typedef statement from C and C++. To declare new types in Java, a new class is declared and variables can use that class as their type.
Assigning Values to Variables
After a variable has been declared, a value can be assigned to it with the assignment operator, an equal sign (=). The following are examples of assignment statements:
idCode = 8675309; accountOverdrawn = false;
Constants
Variables are useful when you need to store information that can be changed as a program runs. If the value should never change during a program's runtime, you can use a special type of variable called a constant.
New Term
A constant, which also is called a constant variable, is a variable with a value that never changes. This might seem like a misnomer, given the meaning of the word "variable."
Constants are useful in defining shared values for all methods of an object—in other words, for giving meaningful names to unchanging values that an entire object must have access to. In Java, you can create constants for all kids of variables: instance, class, and local.
NOTE
Constant local variables were not possible in Java 1.0, but were added to the language for all subsequent versions. This becomes important if you're trying to create an applet that is fully compatible with Java 1.0, as you will learn during Day 7, "Writing Java Applets."
To declare a constant, use the final keyword before the variable declaration and include an initial value for that variable, as in the following:
final float PI = 3.141592; final boolean DEBUG = false; final int PENALTY = 25;
In the preceding statements, the names of the constants are capitalized: PI, DEBUG, and PENALTY. This isn't required, but it is a convention used by many Java programmers—Sun uses it in the Java class library. The capitalization makes it clear that you're using a constant.
Constants can be useful for naming various states of an object and then testing for those states. Suppose you have a program that takes directional input from the numeric keypad on the keyboard—push 8 to go up, 4 to go left, and so on. You can define those values as constant integers:
final int LEFT = 4; final int RIGHT = 6; final int UP = 8; final int DOWN = 2;
Using constants often makes a program easier to understand. To illustrate this point, consider which of the following two statements is more informative of its function:
this.direction = 4; this.direction = LEFT;