Kai Notes - http://www.jdiscuss.com/

[Arun Pai]

A class was given in the main() method:
Stack s1=new Stack();
Stack s2=new Stack();
method(s1,s2);
System.out.println("s1" + s1+" "+ "s2" + s2);
the method is so defined:
public static void method(Stack s1,Stack s2){
s1.push(new Integer(100));
s2=s1
}
what is the output ? I choose E
A. Compile error, because ...
B. Runtime error, because ...
C. s1[100]s2[100]
D. s1[ ]s2[ ]
E. s1[100]s2[ ]
F. s1[ ]s2[100]
Need to know the methods of Stack: push(), pop() and peek().
Stack is part of the java.util package - it is a subclass of Vector so I guess it is part of the objectives.
Kai: Many thought this is a Collection question, but I believe
it is more about argument passing.
-Arun

[luco zhao]

Originally posted by Arun Pai:

Kai: Many thought this is a Collection question, but I believe
it is more about argument passing.
-Arun

Yes, it is a question on argument passing, but why the correct output is E, not C. Thanks for yer kind explanation.

[Robert Ziel]

Hi Luco,
it's because you only
refer the local s1 to s2
so the original stays the same..

so answer would be E
Robert
[ May 12, 2002: Message edited by: Robert Ziel ]

[chiru mega]

This is not correct.
------------
Hi Luco,
it's because you only
refer the local s1 to s2
so the original stays the same..

so answer would be E
Robert
-------
since both will be passed by reference,changes made to s2 will also appear in main.
correct me if iam wrong

[Robert Ziel]

hi Chiru,
youre wrong because you in fact you have 4 references to 2 objects
when you say s1.push(100) you
change the object1
when you say
s1 = s2
then only the local copy of s1 refers to s2
when the method ends
s1 still refers to the first object
if find it poor programming
you should use differnt var names.
robert

[John Bateman]

Some code and some commentsa to further explain this 'phenomenon'.

import java.util.*;
public class TestingRefs {
   // Just out of habit I do this.
   public TestingRefs() {
      super();
   }
 
   public static void main( String[] args ) {
      // ORIGINAL stack s1
      Stack s1=new Stack();
 
      // ORIGINAL stack s2
      Stack s2=new Stack();
      s2.push( new Integer( 200 ) );
 
      System.out.println( "Initial values: s1" + s1 + " - " + "s2" + s2 );
      
      someMethod(s1,s2);
 
      System.out.println( "Final values: s1" + s1 + " - " + "s2" + s2 );
   }
 
   public static void someMethod( Stack s1, Stack s2 ) { 
 
      // Print out the values of the what the local "variables" are pointing to.
      System.out.println( "Initial *someMethod* values: s1" + s1 + " - "+ "s2" + s2 );
 
      // Add values to the stacks pointed to by the local variables.
      s1.push( new Integer( 100 ) ); 
      s2.push( new Integer( 400 ) ); 
 
      // Make my 'local s2' point to the same thing as 'local s1'.
      s2=s1;
 
      // They should be referring to the same object.. I.E. The ORIGINAL stack passed in called s1.
      System.out.println( "Check *someMethod* values: s1" + s1 + " - "+ "s2" + s2 );
 
      // Just to prove a point.
      s1.push( new Integer( 1777 ) ); 
      s2.push( new Integer( 2999 ) ); 
 
      System.out.println( "Final *someMethod* values: s1" + s1 + " - "+ "s2" + s2 );
 
      // As soon as this method ends the references (local s1 and local s2) are thrown away, 
      // or, in Java terms made ready for garbage collection.
   }
}

[ May 13, 2002: Message edited by: John Bateman ]