Under what circumstances will a method receive the actual memory address of a passed array?

When you write your method, you determine the number and type of the arguments required by that method. You declare the type and name for each argument in the method signature. For example, the following is a method that computes the monthly payments for a home loan based on the amount of the loan, the interest rate, the length of the loan (the number of periods), and the future value of the loan (presumably the future value of the loan is zero because at the end of the loan, you've paid it off).

double computePayment(double loanAmt, double rate, double futureValue, int numPeriods) {
    double I, partial1, denominator, answer;

    I = rate / 100.0;
    partial1 = Math.pow((1 + I), (0.0 - numPeriods));
    denominator = (1 - partial1) / I;
    answer = ((-1 * loanAmt) / denominator) - ((futureValue * partial1) / denominator);
    return answer;
}

As you can see from the body of the method, you simply use the argument name to refer to its value.

When you declare an argument to a Java method, you provide a name for that argument. This name is used within the method body to refer to the item. As with other names in Java, an argument name must be a legal Java identifier.

A method argument can have the same name as one of the class's member variables. If this is the case, then the argument is said to hide the member variable. Arguments that hide member variables are often used in constructors to initialize a class. For example, take the following Circle class and its constructor:

class Circle {
    int x, y, radius;
    public Circle(int x, int y, int radius) {
        . . .
    }
}

The argument names hide the member variables. Thus using x, y or radius within the body of the constructor refers to the argument, not to the member variable. To access the member variable, you must reference it through this--the current object:

class Circle { 
    int x, y, radius; 
    public Circle(int x, int y, int radius) {  
        this.x = x;
        this.y = y;
        this.radius = radius;
    } 
}

In Java methods, arguments of simple data types are passed by value. When invoked, the method receives the value of the variable passed in, not a reference to the variable itself. For example, consider this series of Java statements which attempts to retrieve the current color of a Pen object in a graphics application:

. . .
int r = -1, g = -1, b = -1;
pen.getRGBColor(r, g, b);
System.out.println("red = " + r + ", green = " + g + ", blue = " + b);
. . .

However, the Java runtime passes the variables' values (-1) into the getRGBColor() method; not a reference to the r, g, and b variables. Thus the call to getRGBColor() actually looks like this: getRGBColor(-1, -1, -1).

When control passes into the getRGBColor() method, new, local variables are created with the names of the parameters provided in the method signature and are initialized to the value passed into the method.

class Pen {
    int redValue, greenValue, blueValue;
    void getRGBColor(int red, int green, int blue) {
        . . .
    }
}

Now, let's look at the implementation of getRGBColor() within the Pen class that the method signature above implies:

class Pen {
    int redValue, greenValue, blueValue;
    void getRGBColor(int red, int green, int blue) {
	red = redValue;
	green = greenValue;
	blue = blueValue;
    }
}

. . .
int r = -1, g = -1, b = -1;
pen.getRGBColor(r, g, b);
System.out.println("red = " + r + ", green = " + g + ", blue = " + b);
. . .

To allow a method to modify a argument, you must pass in an object. Objects in Java are also passed by value, however, the value of an object is a reference. So, the effect is that the object is passed in by reference. When passing an argument by reference, the method gets a reference to the object. A reference to an object is the address of the object in memory. Now, the local variable within the method is referring to the same memory location as the variable within the caller.

So, let's rewrite the getRGBColor() method so that it actually works. First, you must introduce a new object, RGBColor, that can hold the red, green and blue values of a color in RGB space.

class RGBColor {
    public int red, green, blue;
}

class Pen {
    int redValue, greenValue, blueValue;
    void getRGBColor(RGBColor aColor) {
	aColor.red = redValue;
	aColor.green = greenValue;
	aColor.blue = blueValue;
    }
}

. . .
RGBColor penColor = new RGBColor();
pen.getRGBColor(penColor);
System.out.println("red = " + penColor.red + ", green = " + penColor.green + ", blue = " + penColor.blue);
. . .

The data type wrapper classes (Float, Integer, and so on) provided in the java.lang package are particularly useful for returning a single value whose type is one of Java's built-in simple types through a method's arguments.

Under what circumstances can you return a reference from a method?

What type of statement causes a value to be sent back to the calling method?

What is the return type of the readLine method call?

When you declare an array What are the numeric fields initialized to?