III. Variable Names

1. The name that you choose for a variable, or indeed the name that you

choose for anything in Java, is called an identifier. An identifier can be any

length, but it must start with a letter, an underscore (_), or a dollar sign ($).

The rest of an identifier can include any characters except those used as

operators in Java (such as +, –, or *), but you will be generally better off

if you stick to letters, digits, and the underscore character.

2. Java is case sensitive, so the names Newton and newton are not the

same. You must not include blanks or tabs in the middle of a name, so

Joe Smith is out, but you could have JoeSmith or even Joe_Smith.

3. Subject to the restrictions we have mentioned, you can name a variable

almost anything you like, except for two additional restraints – you can't

use keywords in Java as a name for something, and a name can't be

anything that is a constant value.

4. Keywords are words that are an essential part of the Java language.

The restriction on constant values is there because, although it is obvious

why a name can't be 1234 or 37.5, constants can also be alphabetic, such

as true and false for example. 

5. Clearly, it makes sense to choose names for your variables that give a

good indication of the sort of data they hold. If you want to record the

size of a hat, for example, hatSize is not a bad choice for a variable name

whereas qqq would be a bad choice. It is a common convention in Java to

start variable names with a lower case letter and, where you have a name

that combines several words, to capitalize the first letter of each word, as

in hatSize or moneyWellSpent. You are in no way obliged to follow this

convention but since almost all the Java world does, it helps to do so.

Take a look at http://www.javasoft.com/docs/codeconv/.

int numberOfCats;

1. Any integer literal that you specify is of type int by default. Thus 1,

-9999, and 123456789 are all literals of type int. If you want to define an

integer of type long, and the value that you assign to the variable is bigger

than an int, you need to append an L to the value. The values 1L, -9999L,

and 123456789L are all of type long. You can also use a lower case letter l,

but don't – it is too easily confused with the digit 1.

2. You are perhaps wondering how you specify literals of type byte or short.

Because of the way integer arithmetic works in Java, they just aren't

necessary in the main. We will see a couple of instances where an integer

literal may be interpreted by the compiler as type byte or short later in this

chapter, but these situations are the exception.

3. As you saw earlier, we can declare a variable of type long with the

statement:

long bigOne;

This statement is a declaration for the variable bigOne. This specifies that

the variable bigOne will store a value of type long. When this statement is

compiled, 8 bytes of memory will be allocated for the variable bigOne.

4. Java does not automatically initialize a variable such as this. If you want

your variables to have an initial value rather than a junk value left over from

when the memory was last used, you must specify your own value in the

declaration. To declare and initialize the variable bigOne to 2999999999,

you just write:

long bigOne = 2999999999L;

5. You can declare and define multiple variables in a single statement.

For example:

long bigOne = 999999999L, largeOne = 100000000L;

6. You can declare as many variables as you like in a single statement,

although it is usually better to stick to declaring one variable in each

statement as it helps to make your programs easier to read. A possible

exception occurs with variables that are closely related – an (x,y)

coordinate pair representing a point, for example, which you might

reasonably declare as:

int xCoord = 0, yCoord = 0;       // Point coordinates

7. On the same line as the declaration of these two variables, we have a

comment following the double slash, explaining what they are about. The

compiler ignores everything from the double slash until the end of the line.

8. You can also spread a single declaration over several lines if you want.

This also can help to make your program more readable. For example:

int miles    = 0,          // One mile is 8 furlongs
    furlongs = 0,          // One furlong is 220 yards
    yards    = 0,          // One yard is 3 feet
    feet     = 0;

9. Naturally, you must be sure that an initializing value for a variable is

within the range of the type concerned, otherwise the compiler will

complain. Your compiler is intelligent enough to recognize that you can't

get a quart into a pint pot, or, alternatively, a long constant into a

variable of type int, short, or byte.

10. To complete the set we can declare and initialize a variable of type

byte and one of type short with the following two statements:

byte luckyNumber = 7;
short smallNumber = 1234;

11. Most of the time you will find that variables of type int will cover your

needs for dealing with integers, with long ones being necessary now and

again when you have some really big integer values to deal with.

12. Variables of type byte and short do save a little memory, but unless

you have a lot of values of these types to store, that is, values with a

very limited range, they won't save enough to be worth worrying about.

13. They also introduce complications when you use them in calculations,

as we shall see shortly, so generally you should not use them unless it is

absolutely necessary. Of course, when you are reading data from some

external source, a disk file for instance, you will need to make the type

of variable for each data value correspond to what you expect to read.

VIII. Floating Point Values

1. When you are specifying floating point literals they are of type double

bydefault, so 1.0 and 345.678 are both of type double. When you want to

specify a value of type float, you just append an f, or an F, to the value,

so 1.0f and 345.678F are both constants of type float.

2. If you are new to programming it is important to note that you must not

include commas as separators when specifying numerical values in your

program code. Where you might normally write a value as 99,786.5, in your

code you must write it without the comma, as 99786.5.

3. When you need to write very large or very small floating point values,

you will usually want to write them with an exponent – that is, as a decimal

value multiplied by a power of 10. You can do this in Java by writing the

number as a decimal value followed by an E, or an e, preceding the power

of 10 that you require.

4. For example, the distance from the Earth to the Sun is approximately

149,600,000 kilometers, more conveniently written as 1.496E8. Since the

E (or e) indicates that what follows is the exponent, this is equivalent to

1.496x10⁸.

5. At the opposite end of the scale, the mass of an electron is around

0.0000000000000000000000000009 grams. This is much more convenient,

not to say more readable, when it is written as 9.0E-28 grams.

IX. Declaring Floating Point Variables

1. You declare floating point variables in a similar way to that we've

already used for integers. We can declare and initialize a variable of type

double with the statement:

double sunDistance = 1.496E8;

2. Declaring a variable of type float is much the same. For example:

float electronMass = 9E-28F;

You can of course declare more than one variable of a given type in a

single statement:

float hisWeight = 185.2F, herWeight = 108.5F;

3. Note that you must put the F or f for literals of type float. If you leave

it out, the literal will be of type double, and the compiler won't convert it

automatically to type float.

XI. Integer Calculations

1. The basic operators you can use on integers are +, -, *, and /, which

have the usual meanings – add, subtract, multiply, and divide, respectively.

Each of these is a binary operator; that is, they combine two operands to

produce a result, 2 + 3 for example.

2. An operand is a value to which an operator is applied. The priority or

precedence that applies when an expression using these operators is

evaluated is the same as you learned in school.

3. Multiplication and division are executed before any addition or

subtraction operations, so the expression:

20 – 3*3 – 9/3

will produce the value 8, since it is equivalent to 20 – 9 – 3.

4. As you will also have learned in school, you can use parentheses in

arithmetic calculations to change the sequence of operations.

Expressions within parentheses are always evaluated first, starting

with the innermost when they are nested. Therefore the expression:

(20 – 3)*(3 – 9)/3

is equivalent to 17*(-6)/3 which results in -34.

5. Of course, you use these operators with variables that store integer

values as well as integer literals. You could calculate a value for area

of type int from values stored in the variables length and width, also

of type int, by writing:

area = length * width;

6. The arithmetic operators we have described so far are binary operators,

so called because they require two operands. There are also unary versions

of the + and – operators that apply to a single operand to the right of the

operator.

7. Note that the unary – operator is not just a sign, as in a literal such

as –345, it is an operator that has an effect. When applied to a variable it

results in a value that has the opposite sign to that of the value stored in

the variable.

8. For example, if the variable count has the value -10, the expression

–count has the value +10. Of course, applying the unary + operator to the

 value of a variable results in the same value.

9. Key in the example below and save it in a file Fruit.java. You will

remember from before that each file will contain a class, and that the

name of the file will be the same as that of the class with the extension

 .java. Store the file in a directory that is separate from the hierarchy

containing the SDK. You can give the directory any name that you want,

even the name Fruit if that helps to identify the program that it contains.

10. In some Java development environments, the output may not be

displayed long enough for you to see it. If this is the case, you can add a

few lines of code to get the program to wait until you press Enter before

it ends. The additional lines to do this are shown shaded in the following

listing:

import java.io.IOException;  // For code that delays ending the program

public class Fruit {
  public static void main(String[] args) {
    // Declare and initialize three variables
    int numOranges = 5;                 // Count of oranges
    int numApples = 10;                 // Count of apples
    int numFruit = 0;                   // Count of fruit

    numFruit = numOranges + numApples;  // Calculate the total fruit count

    // Display the result
    System.out.println("A program that totals fruit.");
    System.out.println("Total fruit is " + numFruit);
    // Code to delay ending the program
    System.out.println("(press Enter to exit)");

    try {
      System.in.read();               // Read some input from the keyboard

    } catch (IOException e) {         // Catch the input exception
      return;                         // and just return
    }
  }
}

We won't go into this extra code here. If you need to, just put it in for the

moment. You will understand exactly how it works later in the book.

If you run this program, the output will be similar to the following window:

 

11. Our program consists of just one class, Fruit, and just one method,

main(). Execution of an application always starts at the first executable

statement in the method main(). There are no objects of our class Fruit

defined, but the method main() can still be executed because we have

specified it as static. 12. The method main() is always specified as public

and static and with the return type void. We can summarize the effects of

these on the method as:

1. When you divide one integer by another and the result is not exact, any

remainder is discarded, so the final result is always an integer. The division

3/2, for example, produces the result 1, and 11/3 produces the result 3.

2. This makes it easy to divide a given quantity equally amongst a given

number of recipients. To divide numFruit equally between four children, you

could write:

int numFruitEach = 0;                // Number of fruit for each child
numFruitEach = numFruit/4;

3. Of course, there are times where you may want the remainder. On these

occasions you can calculate the remainder using the modulus operator, %.

If you wanted to know how many fruit were left after dividing the total

by 4, you could write:

int remainder = 0;
remainder = numFruit % 4;   // Calculate the remainder after division by 4

4. You could add this to the program too if you want to see the modulus

operator in action. The modulus operator has the same precedence as

multiplication and division, and is therefore executed in a more complex

expression before any add or subtract operations.

XIII. The Increment and Decrement Operators

1. If you want to increment an integer variable by one, instead of using

an assignment you can use the increment operator, which is written as

two successive plus signs, ++. For example, if you have an integer

variable count declared as:

int count = 10;

you can then write the statement:

++count;     // Add 1 to count

which will increase the value of count to 11.

2. If you want to decrease the value of count by 1 you can use the

decrement operator, --:

--count;     // Subtract 1 from count

3. At first sight, apart from reducing the typing a little, this does not

seem to have much of an advantage over writing:

count = count – 1;     // Subtract 1 from count

4. One big advantage of the increment and decrement operators is that

you can use them in an expression. A further property of the increment

and decrement operators is that they work differently in an expression

depending on whether you put the operator in front of the variable, or

following it.

5. When you put the operator in front of a variable it's called the prefix

form. The converse case, with the operator following the variable, is

called the postfix form.

6. The effect of the postfix increment operator is to change the value of

a variable after the original value has been used in an expression. The

postfix decrement operator works similarly, and both operators can be

applied to any type of integer variable.

XV. Explicit Casting

1. It may well be that the default treatment of mixed expressions listed

above is not what you want. For example, if you have a double variable

result, and you compute its value using two int variables three and two

with the values 3 and 2 respectively, with the statement:

result = 1.5 + 3/2;

the value stored will be 2.5, since 3/2 will be executed as an integer

operation and will produce the result 1.

2. You may have wanted the term 3/2 to produce the value 1.5 so the

overall result would be 3.0. You could do this using an explicit cast:

result = 1.5 + (double)3/2;

3. This causes the value stored in three to be converted to double before

the divide operation takes place. Then the first rule applies for the divide

operation, and the operand two is also converted to double before the

divide is executed. Hence the value of result will be 3.0.

1. When the type of the result of an expression on the right of an

assignment statement differs from the type of the variable on the left,

an automatic cast will be applied as long as there is no possibility of

losing information.

2. If you think of the basic types that we have seen so far as being in

the sequence:  byte -> short -> int -> long -> float -> double

then an automatic conversion will be made as long as it is upwards

through the sequence, that is, from left to right. If you want to go in

the opposite direction, from double to float or long, for example, then

you must use an explicit cast.