When you pass an object reference as an argument to a method call what gets passed?

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;
}

double loanAmt

double rate

double futureValue

int numPeriods

type name

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

Argument Types

In Java, you can pass an argument of any valid Java data type into a method. This includes simple data types such as doubles, floats and integers as you saw in the

Polygon polygonFrom(Point listOfPoints[]) {
    . . .
}

1 method above, and complex data types such as objects and arrays. Here's an example of a method that accepts an array as an argument. In this example, the method creates a new Polygon object from a list of

Polygon polygonFrom(Point listOfPoints[]) {
    . . .
}

2,

Polygon polygonFrom(Point listOfPoints[]) {
    . . .
}

3 points.

Polygon polygonFrom(Point listOfPoints[]) {
    . . .
}

Unlike some other languages, you cannot pass methods into Java methods.

Argument Names

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 Circle class has three member variables

Polygon polygonFrom(Point listOfPoints[]) {
    . . .
}

2, y and

Polygon polygonFrom(Point listOfPoints[]) {
    . . .
}

5. In addition, the constructor for the Circle class accepts three arguments each of which shares its name with the member variable for which the argument provides an initial value.

The argument names hide the member variables. Thus using

Polygon polygonFrom(Point listOfPoints[]) {
    . . .
}

2,

Polygon polygonFrom(Point listOfPoints[]) {
    . . .
}

3 or

Polygon polygonFrom(Point listOfPoints[]) {
    . . .
}

5 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

Polygon polygonFrom(Point listOfPoints[]) {
    . . .
}

9--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;
    } 
}

Names of method arguments cannot be the same as another argument name for the same method, the name of any variable local to the method, or the name of any parameter to a

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

0 clause within the same method.

Pass by Value

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);
. . .

At the time when the

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

1 method is called, the variables

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

2,

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

3, and

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

4 all have the value -1. The caller is expecting the

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

1 method to pass back the red, green and blue values of the current color in the

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

2,

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

3, and

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

4 variables.

However, the Java runtime passes the variables' values (

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

9) into the

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

1 method; not a reference to the

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

2,

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

3, and

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

4 variables. Thus the call to

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

1 actually looks like this:

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

5.

When control passes into the

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

1 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) {
        . . .
    }
}

So,

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

1 gets access to the values of

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

2,

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

3, and

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

4 in the caller through its local variables

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

1,

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

2, and

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

3, respectively. The method gets a new copy of the values to use locally. Any changes made to those local variables are not reflected in the original variables from the caller.

Now, let's look at the implementation of

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

1 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;
    }
}

This method will not work. When control gets to the

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

5 statement in this code snippet,

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

1's local variables

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

1,

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

2, and

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

3 no longer exist. Therefore the assignments made to those variables had no effect;

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

2,

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

3, and

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

4 are all still equal to

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

9.

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

Passing variables by value affords the programmer some safety. Methods cannot unintentially modify a variable that is outside of its scope. However, you often want a method to be able to modify one or more of its arguments. The

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

1 method is a case in point. The caller wants the method to return three values through its arguments. However, the method cannot modify its arguments, and, furthermore, a method can only return one value through its return value. So, how can a method return more than one value, or have an effect (modify some value) outside of its scope.

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

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

1 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;
}

Now, we can rewrite

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

1 so that it accepts an RGBColor object as an argument. The

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

1 method returns the current color of the pen by setting the

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

1,

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

2 and

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

3 member variables of its RGBColor argument.

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

And finally, let's rewrite the calling sequence:

Polygon polygonFrom(Point listOfPoints[]) {
    . . .
}

0

The modifications made to the RGBColor object within the

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

1 method affect the object created in the calling sequence, because the names

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

2 (in the calling sequence) and

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

3 (in the

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

1 method) refer to the same object.

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.

What happens when an argument is passed by reference to a method?

Pass-by-reference means to pass the reference of an argument in the calling function to the corresponding formal parameter of the called function. The called function can modify the value of the argument by using its reference passed in. The following example shows how arguments are passed by reference.

When you pass an object reference as an argument to a method call what gets passed linkedin?

To state this more fully, when an object is passed into a method as a parameter, a copy of the variable on the stack containing the reference to the object is passed.

When an object is passed as an argument to a method what is passed into the methods parameter variable?

When code in a method changes the value of a parameter, it also changes the value of the argument that was passed into the parameter. When an object, such as a String , is passed as an argument, it is actually a reference to the object that is passed. The contents of a String object cannot be changed.

When we pass an object by reference which is called?

Passing a pointer to an object is passing that object by reference. – Benjamin Lindley. Aug 9, 2013 at 13:21.