Mark Lassoff [Mark Lassoff] - Java Programming for Beginners

It turns out that there's a slightly easier way to write the preceding program. When we write a conditional statement or rather a pair of conditional statements in which we're always going to execute one of the two code blocks, it's probably a good time to make use of the else keyword. The else keyword must follow a bracketed if block, then it's followed by brackets of its own. The else statement will evaluate to true and execute the code between its brackets only if the code between the previous if brackets was not executed:

If we run this program, we will get the same results as we did before with one less bit of logic code to write:

Let's end this topic with a brief run-through of what other operators we can use in our if statements, then we'll take a look at what to do if we need to compare items that are not primitives. In addition to the greater than and less than operators, we can also make use of the equality operator (==), which is true if the items on both the sides have the same value. Make sure when you use the equality operator, do not accidently use the assignment operator (=) instead:

In some instances, your program won't compile, but at other times it will compile and you'll get very weird results. If you'd like to use the opposite of the equality operator, you can use not equals (!=), which returns true if the two items do not have the same value:

To show this, let's modify our program so that we could take String as user input. We'll see whether String is equivalent to the secret password code:

If it is, it will print out YES; if not, it will print out NO. Now, NetBeans gives us a warning (as shown in the preceding screenshot); in fact, if we attempt to compare strings with some different operators, NetBeans would let us know that our program is probably not even going to compile. That's because Java does not expect us to compare instances of a class with these operators. Instead, classes should expose functions that allow us to compare them logically. Almost every object in Java has a few functions for this purpose. One of the most common ones is the equals() function that takes an object of the same type and lets us know whether they're equivalent. This function returns what's called a Boolean type, which is a primitive type of its own that can have a value of either true or false. Our if statement understands how to evaluate this Boolean type:

Let's run our program quickly and start by inputting a bad string, then let's input password to see our program work:

That's the basics of if-else statements. I would encourage you now to play with some of the comparison operators that we looked at and try nesting if...else statements within each other.

You can contact us at questions@packtpub.com if you are having a problem with any aspect of the book, and we will do our best to address it.

An ArrayList example in NetBeans

To see this in action, let's write a program that would actually be a little more difficult to write if we just used a standard array instead of an ArrayList. I'd like to write a program that will take an input string from the user. It will store this input string with every other input string the user has ever given it, and then print them all out each time the user inputs a new string.

This would be really difficult to do with an array because if the user ever inputs one more string than the array was designed to hold, our array would, in the best-case scenario, not accept the string; in the worst-case scenario, our program might crash. But, our ArrayList object will simply resize to fit the number of strings that it's currently holding.

Understanding Typed Variables

To create even modest Java programs, we're going to need a way to store and manipulate information. Our chief resource, when doing this, is the variable, and that's what we're going to take a look at in this chapter. We'll look at the different data types in Java and how to use them in our programs. We'll also see the Math class library and one of its functions.

Specifically, we'll walk through the following topics:

• Introduction to variables and why they're needed
• Integer variables
• Floating-point variables
• The Math class library and its pow() function
• Character variables
• The String class and its methods

Floating point variables

When we're simply counting and manipulating whole objects, integers are fantastic. However, sometimes we need to deal with numbers in a more mathematical sense, and we need a data type that will allow us to express ideas that are not entirely whole numbers. Floating-point numbers, or floats, are a Java primitive type that allow us to express numbers that have decimal points and fractions. In this section, we'll modify some float and integer variables side by side to see how they are similar and different.

Let's create a new Java project (you know the drill by now) and call it FloatingPointNumbers. Let's start by declaring two variables: one integer (iNumber) and one float (fNumber). As we know, once we've declared these variables, we're free to modify and assign values to them in our Java program later. This time, let me show you that we can also modify and assign to these variables in the same line that they're declared. So where I have declared my iNumber integer variable, I'm free to immediately give it the value of 5:

package floatingpointnumbers; public class FloatingPointNumbers { public static void main(String[] args) { int iNumber = 5; float fNumber; } }

Notice that if we try and do something very similar with our float variable, NetBeans will yell at us, by displaying a light bulb and red dot on the left-hand side:

In fact, if we attempt to compile our program, we'll get a legitimate compiler error message: