- Parameter passing mechanism =
agreement between
the calling method and
the called method on
how a
parameter is
passed between them
(See: click here )
- The Java programming language
uses only the
pass-by-value mechanism.
(See: click here )
- Agreement used in the
Pass-by-value mechanism:
- The calling method passes the information stored inside a variable by passing (= copying) the value contained inside a variable into the parameter variable.
- For an worked out example on what happens in the pass-by-value mechanism, see: click here
- Java program:
public class MinArray1 { public static void main(String[] args) { double[] a = { 2.3, 3.4 , 4.5, 5.6, 1.2, 7.8, 8.9 }; // 7 elements int i; // array index double min; // Current min value min = a[0]; // Initial min. value for ( i = 1 ; i < a.length ; i++ ) { if ( a[i] < min ) { min = a[i]; // Found a smaller min. value } } System.out.println( min ); } }
- Problem Description:
- Write a Java program that finds
the minimum values in
2 different arrays
a and
b
I.e.: find the minimum value in array a and find the minimum value in array b
- Write a Java program that finds
the minimum values in
2 different arrays
a and
b
- Naive solution:
- We can cut and paste the "find minimum value in an array" algorithm and change the name of the array variable
Example:
public class MinArray1 { public static void main(String[] args) { double[] a = { 2.3, 3.4 , 4.5, 5.6, 1.2, 7.8, 8.9 }; // 7 elements double[] b = { -8.8, 9.7, -14.6, 89.8 }; // 4 elements int i; // array index double min; // Current min value /* ----------------- min of array a -------------------- */ min = a[0]; // Initial min. value for ( i = 1 ; i < a.length ; i++ ) { if ( a[i] < min ) { min = a[i]; // Found a smaller min. value } } System.out.println( min ); /* ----------------- min of array b -------------------- */ min = b[0]; // Initial min. value for ( i = 1 ; i < b.length ; i++ ) { if ( b[i] < min ) { min = b[i]; // Found a smaller min. value } } System.out.println( min ); } }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: javac MinArray4.java
- To run: java MinArray4
Output of the program:
1.2 -14.6
- Observation:
- The cut-and-paste technique is
very inefficient
- It is better to use methods
Requirement:
- We must pass an
array variable as
parameter to
the method !!!
We have never done this before...
- The cut-and-paste technique is
very inefficient
- Problem Description:
- Write a Java method that
find the minimum value
in a (double) array
- The Java method receives the array as a parameter
- Write a Java method that
find the minimum value
in a (double) array
- The following method definition
uses an array as
parameter:
public static double minArray( double[] a ) { int i; // array index double min; // Current min value min = a[0]; // Initial min. value for ( i = 1 ; i < a.length ; i++ ) { if ( a[i] < min ) { min = a[i]; // Found a smaller min. value } } return(min); // Return the min found (instead of printing it) }Explanation:
- The algorithm used to find
the minimum value
is unchanged
- The parameter variable
double[] a tells the
Java compiler that the
parameter name a is
an array of double
BTW, we must use the variable a accordingly.
We must use:a[i]
- Instead of printing the
minimum value found, it is
more flexible to
return the value.
The user can print it out if he/she chooses to do so.
- In addition, he/she can also use the
returned value in
further computations !!!
(So more flexible !!)
- In addition, he/she can also use the
returned value in
further computations !!!
- The algorithm used to find
the minimum value
is unchanged
- The following main method
passes 2 different arrays
to the minArray method:
public static void main(String[] args) { double[] a = { 2.3, 3.4 , 4.5, 5.6, 1.2, 7.8, 8.9 }; // 7 elements double[] b = { -8.8, 9.7, -14.6, 89.8 }; // 4 elements int i; // Array index double min; // Current min value /* ----------------- min of array a -------------------- */ min = minArray( a ) ; // Find min value in array a System.out.println( min ); /* ----------------- min of array b -------------------- */ min = minArray( b ) ; // Find min value in array b System.out.println( min ); }
- Complete Java program:
we can put both methods inside
one class
public class ArrayParam1 { public static double minArray( double[] a ) { int i; // array index double min; // Current min value min = a[0]; // Initial min. value for ( i = 1 ; i < a.length ; i++ ) { if ( a[i] < min ) { min = a[i]; // Found a smaller min. value } } return(min); // Return the min found (instead of printing it) } public static void main(String[] args) { double[] a = { 2.3, 3.4 , 4.5, 5.6, 1.2, 7.8, 8.9 }; // 7 elements double[] b = { -8.8, 9.7, -14.6, 89.8 }; // 4 elements int i; // Array index double min; // Current min value /* ----------------- min of array a -------------------- */ min = minArray( a ) ; // Find min value in array a System.out.println( min ); /* ----------------- min of array b -------------------- */ min = minArray( b ) ; // Find min value in array b System.out.println( min ); } }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: javac ArrayParam1.java
- To run: java ArrayParam1
- Previously discussed:
updating a
parameter variable in Java:
We learned in this webpage that:
- The method will update the
formal parameter
- The actual parameter that is passed-by-value will not be updated
- The method will update the
formal parameter
- The following Java program illustrates this
fact again:
public class SimpleParam { public static void updateParam( double x ) { x = 9999; // Update parameter variable } public static void main(String[] args) { double a = 2.3; System.out.println("Variable before calling updateArray:"); System.out.println( a ); // Prints 2.3 updateParam( a ); // ****** Call updataParam System.out.println("Variable AFTER calling updateArray:"); System.out.println( a ); // Prints 2.3 } }Output:
2.3 2.3 (did not update the actual parameter) (This is the pass-by-value mechanism)
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: javac SimpleParam.java
- To run: java SimpleParam
- Now let's take a look at
this Java program where we
update an array element
in the array parameter variable:
public class ArrayParam2 { public static void updateParam( double[] x ) { x[0] = 9999; // Update one of the array element } public static void main(String[] args) { double[] a = { 2.3, 3.4 , 4.5 }; System.out.println("Array before calling updateParam:"); for (int i = 0; i < a.length; i++) System.out.println( a[i] ); updateParam( a ); // Call updateParam System.out.println("Array AFTER calling updateParam:"); for (int i = 0; i < a.length; i++) System.out.println( a[i] ); } }$64,000 question:
- What will be printed after the execution of the updataParam method ???
Output:
Array before calling updateArray: 2.3 3.4 4.5 Array AFTER calling updateArray: 9999.0 3.4 4.5
Can you explain why a[0] was updated ???
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: javac ArrayParam2.java
- To run: java ArrayParam2
- Fact:
- An array is
stored differently than
a simple variable
Simple variable:
Array variable:
- An array is
stored differently than
a simple variable
- What exactly is going on when we
pass an array variable:
- Let's look at the situation when
we call the
updateParam method:
- According to the
pass-by-value mechanism
(
click here ):
- The caller
first
creates the
parameter variable(s):
-
Then
copies the
value of the
actual parameter into
the
formal parameter variable(s):
Result:
- An array parameter variable is an alias of the original array !!!
- The caller
first
creates the
parameter variable(s):
- Observation:
- We have seen this
alias phenomenon
before !!!
Remember the failed attempt to make a copy of an array:
For more details, see: click here
- We have seen this
alias phenomenon
before !!!
- Let's look at the situation when
we call the
updateParam method:
- Now, when the
updateParam method
updates the
array element x[0]:
The array a[0] is also changed because it is the same array element !!!!
- An array parameter
passed to a method consists of
the reference (location) of the
array
- An array parameter variable is an alias of the original array !!!
- When the method uses the array parameter to update some element(s) of the (passed) array, then the elements in the original array will be updated
|
|