3.1.1.1. Variable Assignment¶

Now that we have declared variables, we want to use them to store values. We do that with an assignment statement

int ageInYears = 29; // 29 is the initial value for ageInYears
ageInYears = 21;  // set ageInYears to now store 21

This example shows a variable declaration followed by an assignment statement. In Java, all local variables must be given an initial value, and we use the same “=” character to show the value stored in the variable as part of its declaration. However, after we declare a variable, we can change its value any time we need to, and we do that using an assignment statement. Here, we write the variable by itself, followed by an equal sign (=), followed by the new variable we want the variable to store. An assignment statement changes the value stored in the variable, so that the next time we use the variable, the corresponding value will be the new one. Remember that the name “variable” reflects that fact that its value can change (or vary) over time as your program runs, and assignment is how you change that value.

Programmers may use phrases like “set ageInYears to 21”, or “assign 21 to ageInYears”, or even “change ageInYears to 21”. The vocabulary can be confusing here, but the idea is straightforward:

• When you declare a variable, you create a named storage location and give it an initial value.

• When you assign to a variable, you update its value, replacing whatever value it previously held.

As a general rule, a variable has to have the same type as the value you assign to it. For example, you cannot store a string in ageInYears, since it can only hold an integer. We will see some examples that seem to break this rule, but we’ll get to that later.

Variables must always be initialized (assigned for the first time) when they are declared, which you write on the same line:

int ageInYears = 29;

3.1.1.2. A Note About the = Sign¶

Lets take a look at the following code example:

int a = 5;
int b = 7;
a = b;

Because Java uses the = symbol for assignment, it is tempting to interpret the assignment statement a = b as a statement of equality. It is not!

Equality is commutative, and assignment is not. For example, in mathematics if a = 7 then 7 = a. In Java a = 7; is a legal assignment statement, but 7 = a; is not. This is because an assignment statement is an action that changes the variable on the left by setting its value to be the value appearing on the right of the = sign. As a result, the left side of an assignment statement has to be a storage location such as a variable.

Also, in mathematics, a statement of equality is true for all time. If a = b now, a is always equal to b. In Java, an assignment statement can make two variables equal, but they don’t have to stay that way:

int a = 5;
int b = a; //a and b are now equal
a = 3;     //a and b are no longer equal!

The first line declares variable a and initializes it with the value 5. The second line declares variable b and initializes it with the value of a, which at that point is 5. The third line changes the value of a to 3, but it does not change the value of b, so they are no longer equal. a now has a value of 3, while b has a value of 5.

3.1.1.3. Arithmetic Operators¶

Operators are symbols that represent simple computations. For example, the addition operator is +, subtraction is -, multiplication is *, and division is /.

The following program converts a time of day to minutes:

int hour = 11;
int minutes = 59;
int timeAsMinutes = hour * 60 + minutes;

In this program, hour * 60 + minutes is an expression that represents a single value to be computed. The operators are * and +, which represent multiplication and division. The operators work with are called operands (which is a fancy name for parameters). When the program runs, each variable is replaced by its current value, and then the operators are applied.

So even though you write hour * 60 + minutes, java will compute that as 11 * 60 + 59 and assign timeAsMinutes the value 719. Expressions are generally a combination of numbers, variables, and operators. When compiled and executed, they are evaluated to produce a single value. It is also important to note that order of operations applies in Java just as it does in math. 11 * 60 will get computed before 59 gets added, since multiplication has higher precedence than addition.

While addition (+), subtraction (-), multiplication (*), and division(/) are all mathematical operators you can use in programming, Java supports two more unary operators you may not have seen. These are ++ and --. These add or subtract one, and are often used to incrementally increase or decrease the value stored in a variable as part of a calculation.

3.1.1.4. A Note About Ints and Division¶

Addition, subtraction, and multiplication all do what you expect, but you might be surprised by division. For example, the following fragment tries to compute the fraction of an hour that has elapsed:

int minutes = 59;
int fractionOfHour = minutes / 60;

fractionOfHour will actually be assigned the value 0 in this situation! This result often confuses people. The value of minutes` is 59, and 59 divided by 60 should be 0.98333, not 0. Java performs “integer division” when the operands are integers, as in this case. By design, integer division always rounds toward zero, even in cases like this one where the next integer is close. Further, fractionOfHour is declared to be an int variable, so it can only hold an integer value anyway, not a decimal fraction.

As an alternative, we can calculate a percentage rather than a fraction:

int minute = 59;
int fractionOfHour = (minute * 100) / 60;

Now, fractionOfHour is assigned to 98. Again the result is rounded down, but at least now it’s approximately correct.

3.1.1.5. A New Type: Double¶

While the examples above all make use of the data type int, we can use variables to store more than just integer values.

A more general solution for creating an accurate fractionOfHour variable is to use a different type of data called a double (short for double-precision) which can represent fractions as well as integers. A double value is actually a digital approximation of a real number in the mathematical sense. You can create double variables and assign values to them using the same syntax we used for the other types:

double pi = 3.14159;

Java performs “floating-point division” when one or more operands are double values. So we can solve the problem we saw in the previous section:

double minutes = 59.0;
double fractionOfHour = minutes / 60;

Now, fractionOfHour is set to the value 0.9833333333333333.

Although floating-point numbers are useful, they can be a source of confusion. For example, Java distinguishes the integer value 1 from the floating-point value 1.0, even though they seem to be the same number. They belong to different data types, and strictly speaking, you are not allowed to make assignments between types.

The following is illegal because the variable being declared is an int and the initial value on the right is a double:

int x = 1.1; // compiler error

It is easy to forget this rule because in many cases Java automatically converts from one type to another:

double y = 1; // legal, but bad style

The above example should be illegal, but Java allows it by automatically converting the int value 1 to the double value 1.0 automatically. This leniency is convenient, but it often causes problems for beginners. For example:

double y = 1 / 3; // common mistake

You might expect the variable y to get the value 0.333333, which is a legal value for a double. But instead it gets the value 0.0. The expression on the right divides two integers, so Java does integer division, which yields the int value 0. This int value is then implicitly converted to double so it can be used as the initial value of y, so the value assigned to y is 0.0.

3.1.1.6. Using Booleans as Variables¶

When working with conditions in the previous two modules, you may remember hearing a lot about the boolean values. Just like int and double, boolean is another data type Java provides. Unlike ints or doubles, a boolean value can only be true or false.

We use these when working with while loops or if statements like this:

if (this.hasFlower())
{
    this.hop();
}

In this code, if the jeroo has a flower, it will hop. hasFlower() is a method that will return true or false depending on if the jeroo has a flower.

We could store that boolean value in a variable if we wanted like this:

boolean pocketIsFull = this.hasFlower();

Here we’ve declared a boolean variable, named it pocketIsFull and set it equal to the result returned by the hasFlower() method.

If we wanted to, we could then use that variable in our conditional:

boolean pocketIsFull = this.hasFlower();
if (pocketIsFull)
{
    this.hop();
}

This is another way to write the same if statement!

Additionally, we can assign a boolean variable to the result of a compound conditional:

boolean shouldToss = this.hasFlower() && this.seesNet(AHEAD);
if (shouldToss)
{
    this.toss();
}

Remember above we declared and initialized an int variable that was the result of a mathmatical expression. The same thing will happen here. Java will evaluate this.hasFlower() && this.seesNet(AHEAD), and that compound expression will produce a value that is either true or false, then this value will be used as the initial value of the variable shouldToss.

Finally, if you just need a boolean value, you can initialize a boolean variable using the keywords true or false.

boolean x = true;
boolean y = false;

3.1.1.7. The Scope of a Local Variable¶

Local variables can be very useful tools. You should use a local variable whenever you need to refer to the same value more than once, since a local variable allows you to give a name to a value, so you can use that name in more than one place. If you only need a value one time, a name may not serve much of a purpose.

However, local variables are used for local names that are being used within a single method (or even just a few statements within a method). Programming languages use the term scope to refer to the region of the program text where a name can be used. For local variables, each variable declaration appears inside some pair of braces ({ }), such as the pair of braces surrounding the body of a method. This pair of braces forms the start and end of a block of program statements. The scope of that local variable is all of the statements between its declaration and the closing brace (}) at the end of the block of statements containing the declaration. The name will not be recognized outside that block. Most importantly, this means the variable declaration is not visible (can’t be used) in other methods.

public void doSomeStuff()
{
    int x = 17;  // declared here
    ...
    if (jeroo.getX() == 17)    // OK to use here, inside scope
    {
        ...
    }

    // scope of x ends at closing brace
}

public void doOtherStuff()
{
   if (x == 17)  // compiler error! x can't be referenced
   {
       ...
   }
}

In the code shown above, the local variable x is declared at the start of method doSomeStuff(), so that variable can be used anywhere inside that method. However, the scope of x ends at the end of doSomeStuff(), at the closing brace that marks the end of the method.

That is why local variables are called local: they can only be used in a small, localized region of your program text, only up until the next closing brace. As a further example:

public void doSomeStuff()
{
    ...
    if (jeroo.hasFlower())
    {
        int x = 17;  // declared here
        ...
        if (jeroo.getX() == 17)    // OK to use here, inside scope
        {
            ...
        }

        // scope of x ends at closing brace
    }

    x = 4;  // compiler error! x can't be referenced
}

Local variables can be declared inside any pair of braces demarking a series of statements. However, they are always local to that block of statements, and can’t be used outside that block. Here, x is declared inside the true branch of the first if statement, so x is local to that block of statements, and cannot be used outside the pair of braces where it is declared.

Variables are not visible, and cannot be used, outside of their scope. Their scope is the region of text where they are visible. In Java, scopes are typically marked by pairs of braces ({ }).

3.1.4.1. A Note on Scope¶

The bodies of the mutator methods make use of both fields and parameters. It is important to note that there is a difference in where these two types of variables can be used. Remember the scope of a name or method refers to where it can be used in a program.

A parameter’s scope is the body of the method in which it is declared.

For example consider the setLength() method below:

public class Rectangle
{
    private int length;

    public void setLength(int len)
    {
        this.length = len;
    }
}

In this code, the parameter name len` cannot be referenced outside of the setLength() method. It is completely invisible outside of the braces ({ }) that surround the method’s body.

Fields, on the other hand, are declared inside the braces ({ }) surrounding the whole class, and so their scope is the entire class–they can be used anywhere in the class, inside any method. The field length, for example, was declared outside of the setLength() method and can be accessed anywhere within the class.

Remember that local variables that are declared inside the body of a method have a scope that extends from the point where they are declared to the end of the block of code in which they are declared.

In summary:

• Fields are declared inside the class, so their scope is the entire class. They can be referenced inside any method in the class.

• Parameters are declared in the parameter list of a method declaration, so their scope is that entire method. They can be referenced anywhere inside the body of that method, but cannot be accessed outside the method where they are declared.

• Local variables are declared in a block of statements surrounded by braces ({ }). They can be accessed anywhere inside that block of code, from where the declaration is placed, up to the closing brace (}) marking the end of that block of code.

3.1.9.1. Doubling Back to Accessor Methods¶

Writing an accessor method for a field needs to have a return type because all fields have a type.

public class Rectangle
{
    private int length;

    public Rectangle()
    {
        this.length = 4;
    }

    public int getLength()
    {
        return this.length;
    }
}

In this situation our length field is of type int, therefore our accessor method for that field needs to also return an int.

3.1.9.2. Writing More Complex Methods with Return¶

Sometimes you may feel the need to write multiple return statements, for example, one in each branch of a conditional:

public double absoluteValue(double x)
{
    if (x < 0)
    {
        return -x;
    }
    else
    {
        return x;
    }
}

Since these return statements are in a conditional statement, only one will be executed. As soon as either of them executes, the method terminates without executing any more statements. Of course, this means that other parts of the method will not be executed after the return statement is reached. Further, since a method that returns a value must always use a return statement, no matter how the method ends, that is why you must include a return statement in each and every branch, not just the first one.

Because of these constraints, some beginners find it easier always to write a single return statement and place it as the very last statement in the method–this ensures the method always returns a value, and never accidentally skips any important steps. As you develop your skills, you may find using multiple return statements easier in some situations, but always remember they require more care and are subject to more possibilities for mistakes, so fall back on using a single return statement when you have trouble:

public double absoluteValue(double x)
{
    double answer = x;
    if (x < 0)
    {
        answer = -x;
    }
    return answer;
}

Here’s an example: calculateArea takes a double as a parameter and returns the area of a circle with that radius:

public double calculateArea(double radius)
{
   // Note that Math.PI is a constant with the value of pi
   double result = Math.PI * radius * radius;
   return result;
}

This last line is a return statement. This statement means, “exit immediately from this method and use the following expression as the return value.” Also, note the use of the constant PI from the built-in Java utility class called Math. The Java Math class provides many useful and common math functions, as well as definitions for the constants PI and E. In Java, by convention, programmers give constants names that are written in all capitals, so you can easily distinguish them from variables or fields.

The expression you provide in a return statement can be arbitrarily complex, so we could have written this method more concisely:

public double calculateArea(double radius)
{
   return Math.PI * radius * radius;
}

Code that appears after a return statement (in the same block), or any place else where it can never be executed, is called dead code. The compiler will give you an “unreachable statement” error if part of your code is dead. For example, this method contains dead code:

public double absoluteValue(double x)
{
   if (x < 0)
   {
      return -x;
   }
   else
   {
      return x;
   }
   x = 5;    // can never be executed
 }

That last line, x = 5 would never run as a value would always be returned from the method (ending the method) before that line could be reached.

If you put return statements inside a conditional statement, you have to make sure that every possible path through the program reaches a return statement. The compiler will let you know if that’s not the case. For example, the following method is incomplete:

public double absoluteValue(double x)
{
   if (x < 0)
   {
      return -x;
   }
   else if (x > 0)
   {
      return x;
   }
   // syntax error
}

When x is 0, neither condition is true, so the method ends without hitting a return statement. The error message in this case might be something like “missing return statement”, which is confusing since there are already two of them. But hopefully you will know what it means.

Again, if you run into difficulties, often an easy answer is to change the structure of the method so that there is only a single return statement at the very end of the method.

3.1.9.3. Using the Results of a Method¶

When you invoke a void method, the invocation is usually on a line all by itself. For example here is a simple hop and pick method for Jeroos.

public void hopAndPick()
{
    this.hop();
    this.pick();
}

And here is how it is called:

this.hopAndPick();

On the other hand, when you invoke a method with a return type, you have to do something with the return value. We usually assign it to a variable or use it as part of an expression.

Take for example this method:

public int square(int x)
{
    return x * x;
}

This method would take in some number x, and return the value of that number raised to the power of 2.

We could then call the method and instantiate a new variable to save the result:

int base = 3;
int raised = square(base);

In this situation, raised is set to the value 9 (the result of computing 3 * 3).

Additionally, we can use the result of a method as a parameter for another method call:

int base = 3;
int raisedAgain = square(square(base));

This new variable raisedAgain will be set equal to 81. The calls to square() are evaluated “inside out”, with the one inside parentheses performed first. So base is passed as the argument to square() in the first call, which returns 9. The return value 9 of the first call is used as the parameter value in a second call to square(), which then returns 9 * 9 = 81.

This might remind you of working with functions in algebra classes. In those classes, we might see this same idea written out as:

Assume f(x) = x * x What is the value of f(3)? What is the value of f(f(3))?

Java uses this same principle, though with many different types of data, things can get a bit more complex.