Java eLearning Kit For Dummies (2014)

---

You can use objects directly as shown in the example. Java automatically unboxes the object to obtain the value and display it on screen. Objects also include special object-related methods, such as compareTo(), which lets you compare one value to another. The floatValue() method outputs the byte value in the Byte as a float. So you can also cast between types using a method call when such a method is provided.

This particular example also shows how to add a blank space between lines. You can either use System.out.println(); or add \n in front of the text that should appear with a space before it. The second form, \n, is called an escape character. When you use more than one pair of these characters, it’s called an escape sequence. The “Using Escape Sequences” section of Chapter 4 tells you a lot more about working with escape sequences.

3. Save the code to disk using the filename ByteVersusByte.java.

4. In your command prompt, type javac ByteVersusByte.java and press Enter.

The compiler compiles your application and creates a .class file from it.

5. Type java ByteVersusByte and press Enter.

You see the application output shown in Figure 3-4. As you might expect, the byte value consumes 8 bits, it has a minimum value of –128 and a maximum value of 127, and it has a type of byte. Notice that Value3actually contains 21. That’s because the application creates it as a hexadecimal value of 15, which equates to a decimal value of 21. Value1 and Value2 are equal, so there is a 0 difference between them. However, there is a -6 difference between Value1 and Value3. Finally, notice that the floatValue() method actually does output Value1 as a float.

Figure 3-4:

Short versus short

The Short object contains all the same features that the Byte object does, so you can perform tasks such as obtaining the size, minimum value, and maximum value of the type. It also includes the same valueOf() methods.

In the following exercise, you discover a method for letting users enter numbers in octal (base 8), decimal (base 10), or hexadecimal (base 16) format.

Files needed: ShortVersusShort.java

1. Open the editor or IDE that you’ve chosen to use for this book.

2. Type the following code into the editor screen.

// Import the required API classes.
import java.lang.Short;

public class ShortVersusShort
{
public static void main(String[] args)
{
// Obtain a Short value from the command line.
Short MyShort = Short.decode(args[0]);

// Display the value on screen.
System.out.println("The value of MyShort is: "
+ MyShort);
}
}

The code for this example looks and acts the same as the ShowByte example that you worked with in Chapter 2, but with a couple of important differences. Because this example works with a Short, you can use the Short.decode() method to obtain user input in octal, decimal, or hexadecimal format using specially formatted strings (as you’ll discover later in the exercise). After the user types a numeric value, the code decodes it into a Short object (labeled MyShort) and then displays the value of MyShort on screen.

In addition to the ability to work with multiple bases, this application also accepts input from the command line, rather than using a Scanner object. The difference means that you type the value you want to use at the command line, rather than separately after the program provides a prompt. This form of input is used when you need to automate an application in some way. Automation makes it possible to include the application in a script or use it in some other way that requires the application to work without user interaction.

3. Save the code to disk using the filename ShortVersusShort.java.

4. In your command prompt, type javac ShortVersusShort.java and press Enter.

The compiler compiles your application and creates a .class file from it.

5. Type java ShortVersusShort 15 and press Enter.

The application outputs a value of 15 as expected. Notice that you don’t have to wait for a prompt. The application processes the information directly from the command line.

6. Repeat Step 5, but type a value of 015 (with a leading zero) this time.

The application outputs a value of 13. When you type a value of 015, the application sees it as octal input. In this case, octal means that the usual tens position actually equals 8. So, 8 + 5 = 13 (15 octal equals 13 decimal).

7. Repeat Step 5, but type a value of 0x15 this time.

The application outputs a value of 21, which is the decimal equivalent of the hexadecimal 15. Figure 3-5 shows the outputs of this example.

Figure 3-5:

Try performing Step 5 with a value of 019. The application displays an error in this case because 9 doesn’t exist in octal — the highest value is 7. Perform Step 5 again with a value of 0x1A. You should see an output of 26. Hexadecimal values use the letters A through F to represent the decimal numbers 10 through 15. That’s right: A hexadecimal number can range from 0 through F. (That’s 0 through 15 decimal.) Try performing Step 5 with other values, both positive and negative. For example, what do you see when you type –022? Playing with this application helps you understand how different bases of numbers work on the computer.

Integer versus int

The Integer class is one of the most flexible used for data types. It includes more methods than either Byte or Short for interacting with values.

In the following example, you try out a few of the special Integer methods.

Files needed: IntegerVersusInt.java

1. Open the editor or IDE that you’ve chosen to use for this book.

2. Type the following code into the editor screen.

// Import the required API classes.
import java.util.Scanner;
import java.lang.Integer;

public class IntegerVersusInt
{
public static void main(String[] args)
{
// Create the scanner.
Scanner GetInteger = new Scanner(System.in);

// Obtain an Integer value.
System.out.print("Type any number: ");
Integer MyInteger = Integer.valueOf(GetInteger.nextLine());

// Display some of the Integer outputs.
System.out.println("\nVarious Base Output:");
System.out.println("Binary MyInteger: "
+ Integer.toBinaryString(MyInteger));
System.out.println("Octal MyInteger: "
+ Integer.toOctalString(MyInteger));
System.out.println("Decimal MyInteger: "
+ MyInteger);
System.out.println("Hexadecimal MyInteger: "
+ Integer.toHexString(MyInteger));

// Display the bit information.
System.out.println("\nBit Information:");
System.out.println("Bit Count (1's): "
+ Integer.bitCount(MyInteger));
System.out.println("Highest 1 Bit: "
+ Integer.highestOneBit(MyInteger));
System.out.println("Lowest 1 Bit: "
+ Integer.lowestOneBit(MyInteger));
System.out.println("Number of Leading 0s: "
+ Integer.numberOfLeadingZeros(MyInteger));
System.out.println("Number of Trailing 0s: "
+ Integer.numberOfTrailingZeros(MyInteger));
}
}

As with some of the other examples in this chapter, this example asks the user for some numeric input and then manipulates that input in various ways. In this case, you get to see the output using various bases, and then you see some information about the actual bits used to create the value.

Integer provides a number of other methods, but the methods shown in this example are the most useful for right now. You can also use Integer to change the position of the bits in the value. Programmers sometimes need to perform some odd tasks with numeric values andInteger is one of the most flexible classes for accomplishing such tasks.

3. Save the code to disk using the filename IntegerVersusInt.java.

4. In your command prompt, type javac IntegerVersusInt.java and press Enter.

The compiler compiles your application and creates a .class file from it.

5. Type java IntegerVersusInt and press Enter.

The application asks you to type any number, but note that an int is limited to a range of –2,147,483,648 to 2,147,483,647.

6. Type 85 and press Enter.

You see the output shown in Figure 3-6. Notice the binary output of this application. If you really want to understand how bits work, trying various numbers out with this program will help.

Looking at the Binary MyInteger: line in Figure 3-6, you can see that there are indeed four 1s in the binary version of the output. The highest 1 is in the 64 position and the lowest is in the 1 position. There are seven digits in the binary output, which means there are 25 leading 0s, just as the application says. There aren’t any trailing 0s because the lowest position has a 1 in it.

Figure 3-6:

Perform Steps 5 and 6 again to rerun the application. This time, try a value of 170. The output changes to show how this number differs from 85. More importantly, this is an example of what happens when you reverse the values of the bottom eight bits (01010101 or 85 versus 10101010 or 170). Try other values to see what happens to the output.

Long versus long

The Long class provides all of the interesting features of the Integer class, but as an added bonus has the extended storage capacity of the long type. (A long can hold numbers from –9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.) For example, you have access to the useful output methods such as toBinary(). The Long class also provides all of the bit manipulation features of the Integer class, so you can use it to create some really complex applications.

Scope is an important element of application development. The scope of a variable determines which parts of the application can see it. There are many ways in which Java uses scope to control variable visibility. One of those ways is to differentiate between global and local variables. A global variable is visible to every method within the class, while a local variable is visible only to the part of the application in which the variable is defined (such as a method).

It’s time to see your first use of scope in action. In the following example, you use the Long class to learn how global and local scope works in a Java application.

Files needed: LongVersusLong.java

1. Open the editor or IDE that you’ve chosen to use for this book.

2. Type the following code into the editor screen.

// Import the required API classes.
import java.lang.Long;

public class LongVersusLong
{
// Create a global variable.
public static Long MyLong;

public static void main(String[] args)
{
// Assign a value to the global variable
// and display its value on screen.
MyLong = Long.valueOf(500);
System.out.println("MyLong = " + MyLong);

// Call function1 to modify the value of
// MyLong and display the result on screen.
function1();
System.out.println("MyLong in main() = " 
+ MyLong);

// Call function2 to modify the value of
// MyLong and display the result on screen.
function2();
System.out.println("MyLong in main() = " 
+ MyLong);
}

public static void function1()
{
// Assign a value to the global variable
// and display its value on screen.
MyLong = Long.valueOf(700);
System.out.println("MyLong in function1() = " 
+ MyLong);
}

public static void function2()
{
// Create a local MyLong, assign it a value
// and display its value on screen.
Long MyLong;
MyLong = Long.valueOf(900);
System.out.println("MyLong in function2()= " 
+ MyLong);
}
}

This application demonstrates two Java features you haven’t yet had a chance to use in this book. First, it shows how to create and use methods other than main() in an application — in this particular case, two additional methods known as function1() and function2(). You’ll see a lot more examples of how methods work throughout the book, but this is the simplest way to work with them. The main() method calls function1() and function2() as needed to perform tasks. Working with methods this way helps keep your code readable by preventing methods from getting too large.

The second feature is the use of a global variable. Notice that the declaration of MyLong appears outside of the methods. All of the methods can see the global version of MyLong so it has a global scope. The function2() method also has a variable named MyLong defined in it. This is a local variable. Only function2() can see this variable, so any changes you make to it only appear in function2(). When a method has a choice between a global variable and a local variable of the same name, it always uses the local variable by default.

3. Save the code to disk using the filename LongVersusLong.java.

4. In your command prompt, type javac LongVersusLong.java and press Enter.

The compiler compiles your application and creates a .class file from it.

5. Type java LongVersusLong and press Enter.

The application displays a sequence of outputs that demonstrate one way in which scope works in a Java application, as shown in Figure 3-7. Notice that function1() modifies the global variable, MyLong, so that main() also sees the change it makes. Meanwhile, function2()modifies alocal variable, MyLong, which means that main() doesn’t see this change. The local copy of MyLong in function2() is invisible to main().

Figure 3-7:

Create a Long version of the IntegerVersusInt example described in the “Integer versus int” section of the chapter and name it LongVersusLong. Everywhere you see the word Integer, replace it with the word Long. Now run the new application to see what happens. Most of the output is the same if you use the same input values. However, there is at least one important difference. (Hint: Look at the Number of Leading 0s: output.) Try typing a really large value that you can’t use with the IntegerVersusInt program, such as 5,700,000,000 (without the commas). If you were to try a number this large with the IntegerVersusInt application, you’d see an error.

Float versus float

The Float class definitely makes working with float values easier, especially if the math you perform falls into the more esoteric range. For example, you can use the Float class to create a float value that contains either positive or negative infinity. There are concepts associated withfloat values that are well outside the scope of this book and if you’re not working with that sort of math, you’ll never need to worry about them. However, it’s nice to know that the Float class makes it possible to do some amazing things with float values.

Floating point values approximate real numbers. In the following example, you see how the Float class can interact with floating point numbers and make them easier to work with.

Files needed: FloatVersusFloat.java

1. Open the editor or IDE that you’ve chosen to use for this book.

2. Type the following code into the editor screen.

// Import the required API classes.
import java.lang.Float;

public class FloatVersusFloat
{
public static void main(String[] args)
{
// Create some variables to work with.
Float Value1 = Float.valueOf(11.55f);
Float Value2 = Float.valueOf("11.55");
Float Value3 = Float.parseFloat("0.1155e2");
Float Value4 = Float.POSITIVE_INFINITY;

// Show the actual values.
System.out.println("Value1 = " + Value1);
System.out.println("Value2 = " + Value2);
System.out.println("Value3 = " + Value3);
System.out.println("Value4 = " + Value4);

// Determine some information about the values.
System.out.println("\nValue1 Compared to Value2: " +
Value1.compareTo(Value2));
System.out.println("Value1 Compared to Value3: " +
Value1.compareTo(Value3));
System.out.println("Value1 Compared to Value4: " +
Value1.compareTo(Value4));
System.out.println("Value1 Infinite? "
+ Value1.isInfinite());
System.out.println("Value4 Infinite? "
+ Value4.isInfinite());
System.out.println("Value1 Integer Portion: "
+ Value1.intValue());
System.out.println("Value3 as a String: "
+ Value3.toString());
System.out.println("Value4 as a String: "
+ Value4.toString());
}
}

The example begins by creating four Float objects, Value1, Value2, Value3, and Value4. When working with floating point values, you can assign a value using the valueOf() method, the parseFloat() method, or a constant, such as Float.POSITIVE_INFINITY. When you assign a numeric value, you either have to perform a cast, or you can simply add an f after the number to ensure Java knows that you mean to create a float, and not a double. The parseFloat() method is nice because you can use scientific notation with it. The value after the e is the exponent, so this method actually contains 0.1144 * 10^2.

After creating the variables, the application begins working with them. When you want to compare two values, you must use the compareTo() method, just as you do with integer-based objects. Because floating point values can be infinite, the Float class provides the isInfinite()method. You can also work with just the integer portion of a floating point number, which means that you have full access to the features provided by integer-based values such as the Integer class. The example also shows what happens when you convert a floating point value to a string.

3. Save the code to disk using the filename FloatVersusFloat.java.

4. In your command prompt, type javac FloatVersusFloat.java and press Enter.

The compiler compiles your application and creates a .class file from it.

5. Type java FloatVersusFloat and press Enter.

The application outputs the results of the various floating point operations as shown in Figure 3-8.

Figure 3-8:

You should notice a few special things about the output in Figure 3-8. First of all, even if you provide input to the Float type in scientific notation, the number is stored as a standard float, so "0.1155e2" becomes 11.55. Second, any object that contains an infinite value outputsInfinity as its value. Third, you’re seeing your first Java inconsistency. When you worked with the Byte version of compareTo(), it output the actual difference between the two numbers. The Float version of compareTo() outputs a 0 when the numbers are the same, a –-1 when the first number is less than the second number (infinity is definitely greater than 11.55), and a 1 when the first number is more than the second number.

Most programming languages contain inconsistencies because the language develops over time and is the product of many developers’ input. Always read the documentation to ensure you understand how a method works. In this case of compareTo(), the Byte and Float versions work differently, so you need to consider this difference when you write an application.

Double versus double

The Double type provides the same functionality as Float, except that it offers 64-bit precision. Consequently, you can perform the same sorts of tasks that you would with a Float. The differences between Float and Double are the same as those between float and double. A Floatconsumes less memory and could potentially offer slightly better speed, while a Double offers better precision (less error).

Create a Double version of the FloatVersusFloat example shown in the “Float versus float” section of the chapter. Replace every instance of the word Float with the word Double. If you run the application at this point, you’ll run into something odd, as shown in Figure 3-9.

Figure 3-9:

Notice that Value1 doesn’t contain the value you expected. That’s because the code still assigns it the value of 11.55f (for float). The example illustrates the inaccuracies that exist when using both float and double. To fix this problem, you must remove the f after 11.55 in your code so that Java uses a double to create Value1. The results will precisely match the FloatVersusFloat example at this point.

Boolean versus boolean

There really isn’t much to say about the Boolean object type. It does offer some methods, such as valueOf(), but none of them are particularly compelling. You can’t even offer an alternative output. About the only time where you might use the Boolean object type is when working with system information. The Boolean object type includes a getBoolean() method that lets you do things like access environment variables. This is one situation where you’ll end up using the primitive type in your application in favor of the object type in most situations.

Character versus char

It may not seem as though you can do a lot with a single character, but the Character type really can do quite a lot. When you work with Character, you obtain a lot more than the value that char provides. For example, you can determine whether a character is of a particular type. This type also provides a number of ways to output the value.

Some of the Character methods and properties are beyond the scope of this book. For example, it’s unlikely that you’re going to want to modify individual bits within a Character, but the Character type provides the means for doing so.

In this exercise, you explore some of the more common ways to work with the Character type. Just be aware that you can do more.

Files needed: CharacterVersusChar.java

1. Open the editor or IDE that you’ve chosen to use for this book.

2. Type the following code into the editor screen.

// Import the required API classes.
import java.lang.Character;

public class CharacterVersusChar
{
public static void main(String[] args)
{
// Create some Characters.

Character Char1 = Character.valueOf('$');
Character Char2 = Character.valueOf('a');
Character Char3 = Character.valueOf('1');

// Determine some characteristics about the
// Characters.
boolean IsChar1Currency =
(Character.getType(Char1) ==
Character.CURRENCY_SYMBOL);

boolean IsChar2Lowercase =
(Character.getType(Char2) ==
Character.LOWERCASE_LETTER);

// Describe Char1.
System.out.println("It's " +
IsChar1Currency
+ " that the " + Char1 +
" is a currency symbol and its name is: " +
Character.getName(Char1) + ".");

// Describe Char2.
System.out.println("It's " + IsChar2Lowercase +
" that Char2 is lowercase and that " +
Character.toUpperCase(Char2) +
" is the uppercase version and " +
Character.toTitleCase(Char2) +
" is the title case version.");

// Describe Char3.
System.out.println("Char3 has a value of " +
Character.getNumericValue(Char3) +
". It's " + Character.isDigit(Char3) +
" that Char3 is a digit.");
}
}

This example doesn’t begin to show you everything the Character class can do with individual characters, but it does give you some ideas. To begin, there isn’t anything fancy about creating a Character. The only option you have is the valueOf() method.

After you have a character to work with, you can start learning all sorts of things about it. For example, you can determine whether the character is a currency symbol or whether it’s a lowercase letter. Whenever you want to learn about the kind of character you’re working with, you call the getType() method and then compare the output against Character constants such as CURRENCY_SYMBOL.

Use the getName() method to obtain the official Unicode name for any character. Because these names are constant and unique, you can check the precise input the user has provided. Character also provides methods such as isDigit() that let you perform additional checks on the character value.

You have access to a number of output features. The toUpperCase(), toLowerCase(), and toTitleCase() methods are the ones that you’ll use most often.

3. Save the code to disk using the filename CharacterVersusChar.java.

4. In your command prompt, type javac CharacterVersusChar.java and press Enter.

The compiler compiles your application and creates a .class file from it.

5. Type java CharacterVersusChar and press Enter.

Figure 3-10 shows the output of the Character class features used in this exercise.

Figure 3-10:

Using the New Date and Time API

In the past, Java lacked a good way to work with date and time values. Yes, there were two attempts to address the problem using the Date class first and then the Calendar class, but they proved clunky. Java 8 fixes this problem by creating an entire API devoted to date and time with special classes for each. The following sections describe the date and time API from an overview perspective.

Viewing the date and time API

Java developers have been asking for better date and time management functionality for a long time. Working with the older Date and Calendar classes was difficult, and you couldn’t easily do things such as compare two time values. The new date and time API is immense, but it contains most of the features that developers have requested.

There are a lot of classes that you could use to interact with the date and time. However, you use the following classes most often: