Understanding Parameter
Passing
Parameters are Passed by
Value
 It is important to understand how parameter passing
works. When you make changes to a parameter passed
to a method, a separate copy of the value is passed.
Any changes made to the parameter passed into the
method will have no effect on the actual parameter.
Parameters are Passed by
Value
 It is important to understand how parameter passing
works. When you make changes to a parameter passed
to a method, a separate copy of the value is passed.
Any changes made to the parameter passed into the
method will have no effect on the actual parameter.
 Java passes all parameters to a method by value.
Parameters are Passed by
Value
 It is important to understand how parameter passing
works. When you make changes to a parameter passed
to a method, a separate copy of the value is passed.
Any changes made to the parameter passed into the
method will have no effect on the actual parameter.
 Java passes all parameters to a method by value.
 This means that the current value of the actual
parameter is copied into the formal parameter in the
method header.
An Example
Using Primitive Data Types
public class PrimitiveParamTest
{
public void changeValue (int parameter)
{
parameter = 100;
System.out.println("Inside method changeValue,
parameter value changed to " + parameter);
}
public static void main (String args[])
{
int parameter = 25;
PrimitiveParamTest test = new PrimitiveParamTest();
System.out.println("Initial parameter value is " +
parameter);
test.changeValue(parameter);
System.out.println("After method changeValue call,
parameter value is " + parameter);
}
}
Using the code at left, we
will demonstrate how
primitive data types are
handled as parameters in
method calls.
An Example
Using Primitive Data Types
public class PrimitiveParamTest
{
public void changeValue (int parameter)
{
parameter = 100;
System.out.println("Inside method changeValue,
parameter value changed to " + parameter);
}
The program begins by
assigning the value 25 to
the integer variable
parameter.
public static void main (String args[])
{
int parameter = 25;
PrimitiveParamTest test = new PrimitiveParamTest();
System.out.println("Initial parameter value is " +
parameter);
value
parameter
test.changeValue(parameter);
System.out.println("After method changeValue call,
parameter value is " + parameter);
}
}
Output :
25
An Example
Using Primitive Data Types
public class PrimitiveParamTest
{
public void changeValue (int parameter)
{
parameter = 100;
System.out.println("Inside method changeValue,
parameter value changed to " + parameter);
}
The test object is
created.
public static void main (String args[])
{
int parameter = 25;
PrimitiveParamTest test = new PrimitiveParamTest();
System.out.println("Initial parameter value is " +
parameter);
value
parameter
test.changeValue(parameter);
System.out.println("After method changeValue call,
parameter value is " + parameter);
}
}
Output :
25
An Example
Using Primitive Data Types
public class PrimitiveParamTest
{
public void changeValue (int parameter)
{
parameter = 100;
System.out.println("Inside method changeValue,
parameter value changed to " + parameter);
}
The value of parameter
is displayed.
public static void main (String args[])
{
int parameter = 25;
PrimitiveParamTest test = new PrimitiveParamTest();
System.out.println("Initial parameter value is " +
parameter);
value
parameter
test.changeValue(parameter);
System.out.println("After method changeValue call,
parameter value is " + parameter);
}
}
Output :
Initial parameter value is 25
25
An Example
Using Primitive Data Types
public class PrimitiveParamTest
{
public void changeValue (int parameter)
{
parameter = 100;
System.out.println("Inside method changeValue,
parameter value changed to " + parameter);
}
The PrimitiveParamTest
object method
changeValue is called.
public static void main (String args[])
{
int parameter = 25;
PrimitiveParamTest test = new PrimitiveParamTest();
System.out.println("Initial parameter value is " +
parameter);
value
parameter
test.changeValue(parameter);
System.out.println("After method changeValue call,
parameter value is " + parameter);
}
}
Output :
Initial parameter value is 25
25
An Example
Using Primitive Data Types
public class PrimitiveParamTest
{
public void changeValue (int parameter)
{
parameter = 100;
System.out.println("Inside method changeValue,
parameter value changed to " + parameter);
}
public static void main (String args[])
{
int parameter = 25;
PrimitiveParamTest test = new PrimitiveParamTest();
System.out.println("Initial parameter value is " +
parameter);
As a result of the method
call, a copy of parameter is
made. This copy is called the
formal parameter. The
formal parameter is sent to
the method.
value
formal parameter
parameter
test.changeValue(parameter);
System.out.println("After method changeValue call,
parameter value is " + parameter);
}
}
Output :
Initial parameter value is 25
25
25
An Example
Using Primitive Data Types
public class PrimitiveParamTest
{
public void changeValue (int parameter)
{
parameter = 100;
System.out.println("Inside method changeValue,
parameter value changed to " + parameter);
}
public static void main (String args[])
{
int parameter = 25;
PrimitiveParamTest test = new PrimitiveParamTest();
System.out.println("Initial parameter value is " +
parameter);
When the method refers to
parameter, it uses the
formal parameter.
The formal parameter is
changed to 100.
value
formal parameter
parameter
test.changeValue(parameter);
System.out.println("After method changeValue call,
parameter value is " + parameter);
}
}
Output :
Initial parameter value is 25
100
25
An Example
Using Primitive Data Types
public class PrimitiveParamTest
{
public void changeValue (int parameter)
{
parameter = 100;
System.out.println("Inside method changeValue,
parameter value changed to " + parameter);
}
public static void main (String args[])
{
int parameter = 25;
PrimitiveParamTest test = new PrimitiveParamTest();
System.out.println("Initial parameter value is " +
parameter);
The value of the formal
parameter is displayed.
value
formal parameter
parameter
100
25
test.changeValue(parameter);
System.out.println("After method changeValue call,
parameter value is " + parameter);
}
}
Output :
Initial parameter value is 25
Inside method changeValue, parameter
value changed to 100
An Example
Using Primitive Data Types
public class PrimitiveParamTest
{
public void changeValue (int parameter)
{
parameter = 100;
System.out.println("Inside method changeValue,
parameter value changed to " + parameter);
}
public static void main (String args[])
{
int parameter = 25;
PrimitiveParamTest test = new PrimitiveParamTest();
System.out.println("Initial parameter value is " +
parameter);
As the method is left, the
formal parameter is
destroyed.
value
formal parameter
parameter
100
25
test.changeValue(parameter);
System.out.println("After method changeValue call,
parameter value is " + parameter);
}
}
Output :
Initial parameter value is 25
Inside method changeValue, parameter
value changed to 100
An Example
Using Primitive Data Types
public class PrimitiveParamTest
{
public void changeValue (int parameter)
{
parameter = 100;
System.out.println("Inside method changeValue,
parameter value changed to " + parameter);
}
Control is returned to the
calling method. The
formal parameter no
longer exists.
public static void main (String args[])
{
int parameter = 25;
PrimitiveParamTest test = new PrimitiveParamTest();
System.out.println("Initial parameter value is " +
parameter);
value
parameter
25
test.changeValue(parameter);
System.out.println("After method changeValue call,
parameter value is " + parameter);
}
}
Output :
Initial parameter value is 25
Inside method changeValue, parameter
value changed to 100
An Example
Using Primitive Data Types
public class PrimitiveParamTest
{
public void changeValue (int parameter)
{
parameter = 100;
System.out.println("Inside method changeValue,
parameter value changed to " + parameter);
}
The value of parameter
is displayed.
public static void main (String args[])
{
int parameter = 25;
PrimitiveParamTest test = new PrimitiveParamTest();
System.out.println("Initial parameter value is " +
parameter);
value
parameter
25
test.changeValue(parameter);
System.out.println("After method changeValue call,
parameter value is " + parameter);
}
}
Output :
Initial parameter value is 25
Inside method changeValue, parameter
value changed to 100
After method changeValue call,
parameter value is 25
Passing Objects as
Parameters
How does Java pass objects by value?
Passing Objects as
Parameters
How does Java pass objects by value?
When an object is passed to a method,
we are actually passing a reference to
that object.
Passing Objects as
Parameters
How does Java pass objects by value?
When an object is passed to a method,
we are actually passing a reference to
that object.
The value that is copied is the address of
the object.
Referencing Objects
Since a reference to an object actually contains the address of the object, the
name of the object can been viewed as a “pointer” to the actual object.
Remember that an object doesn’t “exist” until it is instantiated.
Shape myObject;
myObject
null
Instantiating Objects
The object comes into “existence” when it is instantiated. For example the
following code will create the object below:
myObject = new Shape();
myObject
Copying Objects
When an object is assigned to another object, a copy of the reference to the
object is made, not a copy of the actual object.
Shape myCopy = myObject;
myObject
myCopy
Copying Objects
In this example, myCopy is an alias for myObject. Both myObject and
myCopy refer to the same object.
myObject
myCopy
Passing Objects as
Parameters
In the example involving primitive data types, when an int type is passed as
a parameter, a copy, known as the formal parameter is used by the called
method. When an object is passed to a method, the formal parameter used is
an alias, which is a copy of the reference to an object.
myObject
Passing Objects as
Parameters
If the following method is called :
foo.someMethod(myObject);
A copy or alias of myObject is created and used as the formal parameter.
myObject
Passing Objects as
Parameters
If the following method is called :
foo.someMethod(myObject);
A copy or alias of myObject is created and used as the formal parameter.
myObject
The formal parameter
Passing Objects as
Parameters
If the following method is called :
foo.someMethod(myObject);
A copy or alias of myObject is created and used as the formal parameter.
myObject
The formal parameter
Inside a method, if the formal
parameter calls class methods
that modify the state of the
object, the object will remain
in that state when the program
flow returns to the instruction
following the method call.
Passing Objects as
Parameters
myObject
Given the following code fragments:
public class Foo {
public void changeObject(Shape myObject) {
myObject.changeShape();
}
. . .
}
. . .
Foo changer = new Foo();
myObject = new Shape();
changer.changeObject(myObject);
Passing Objects as
Parameters
myObject
Given the following code fragments:
public class Foo {
public void changeObject(Shape myObject) {
myObject.changeShape();
}
. . .
}
. . .
Foo changer = new Foo();
myObject = new Shape();
changer.changeObject(myObject);
When the changeShape method is called, a formal parameter is created.
Passing Objects as
Parameters
myObject
Given the following code fragments:
public class Foo {
public void changeObject(Shape passedObject) {
passedObject.changeShape();
}
. . .
}
The formal parameter
. . .
Foo changer = new Foo();
myObject = new Shape();
changer.changeObject(myObject);
When the changeShape method is called, a formal parameter is created.
This formal parameter is referred to as passedObject in the changeObject method.
Passing Objects as
Parameters
myObject
Given the following code fragments:
public class Foo {
public void changeObject(Shape passedObject) {
passedObject.changeShape();
}
. . .
}
The formal parameter
. . .
Foo changer = new Foo();
myObject = new Shape();
changer.changeObject(myObject);
When passedObject.changeShape() is called, the formal parameter, passedObject,
calls the object’s method changeShape().
Passing Objects as
Parameters
myObject
Given the following code fragments:
public class Foo {
public void changeObject(Shape passedObject) {
passedObject.changeShape();
}
. . .
}
The formal parameter
. . .
Foo changer = new Foo();
myObject = new Shape();
changer.changeObject(myObject);
This causes the object to change its state (in this case, its shape).
Passing Objects as
Parameters
myObject
Given the following code fragments:
public class Foo {
public void changeObject(Shape passedObject) {
passedObject.changeShape();
}
. . .
}
The formal parameter
. . .
Foo changer = new Foo();
myObject = new Shape();
changer.changeObject(myObject);
When the changeObject method ends, the formal parameter ceases to exist.
Passing Objects as
Parameters
myObject
Given the following code fragments:
public class Foo {
public void changeObject(Shape passedObject) {
passedObject.changeShape();
}
. . .
}
. . .
Foo changer = new Foo();
myObject = new Shape();
changer.changeObject(myObject);
When the changeObject method ends, the formal parameter ceases to exist.
BUT, the object still exists in its changed state.
Changing object formal
parameters
If an object formal parameter can change
an object’s state by calling the object’s
methods, what happens when the value of
the formal parameter is changed?
Changing object formal
parameters
public class Foo {
public void changeObject(Shape passedObject) {
The code from the previous
example is changed slightly.
Shape newObject = new Shape();
passedObject = newObject;
passedObject.changeShape();
}
. . .
}
Changing object formal
parameters
public class Foo {
public void changeObject(Shape passedObject) {
If myObject is passed to
the changeObject
method,
Shape newObject = new Shape();
passedObject = newObject;
passedObject.changeShape();
}
. . .
}
myObject
Changing object formal
parameters
public class Foo {
public void changeObject(Shape passedObject) {
If myObject is passed to
the changeObject
method,
Shape newObject = new Shape();
passedObject = newObject;
passedObject.changeShape();
a formal parameter
passedObject is created.
}
. . .
}
myObject
passedObject
Changing object formal
parameters
public class Foo {
public void changeObject(Shape passedObject) {
Another object, newObject
is created.
Shape newObject = new Shape();
passedObject = newObject;
passedObject.changeShape();
}
. . .
}
myObject
passedObject
newObject
Changing object formal
parameters
public class Foo {
public void changeObject(Shape passedObject) {
Another object, newObject
is created.
Shape newObject = new Shape();
passedObject = newObject;
The value of passedObject
is changed to newObject.
passedObject.changeShape();
}
. . .
}
myObject
passedObject
newObject
Changing object formal
parameters
public class Foo {
public void changeObject(Shape passedObject) {
The formal parameter
passedObject, calls the
method changeShape().
Shape newObject = new Shape();
passedObject = newObject;
passedObject.changeShape();
}
. . .
}
myObject
passedObject
newObject
Changing object formal
parameters
public class Foo {
public void changeObject(Shape passedObject) {
This causes the object to
change its state (in this case, its
shape).
Shape newObject = new Shape();
passedObject = newObject;
passedObject.changeShape();
}
. . .
}
myObject
passedObject
newObject
Changing object formal
parameters
public class Foo {
public void changeObject(Shape passedObject) {
When the changeObject method
ends, the formal parameter
passedObject ceases to exist.
Shape newObject = new Shape();
passedObject = newObject;
passedObject.changeShape();
}
. . .
}
myObject
passedObject
newObject
Changing object formal
parameters
public class Foo {
public void changeObject(Shape passedObject) {
When the changeObject method
ends, the formal parameter
passedObject ceases to exist.
Shape newObject = new Shape();
passedObject = newObject;
passedObject.changeShape();
myObject remains unchanged.
}
. . .
}
myObject
newObject
Summary
 Java passes all parameters to a method by value.
 This means that the current value of the actual
parameter is copied into the formal parameter in the
method header.
 Since a reference to an object actually contains the
address of the object, the name of the object can been
viewed as a “pointer” to the actual object.
Summary
 When an object is passed to a method, the formal
parameter used is an alias, which is a copy of the
reference to an object.
 An object’s formal parameter can change an object’s
state by calling the class’ methods, but,
If the value of the formal parameter is changed, the actual
object remains unchanged.