class Class1{ 
	public static void main(String argv[])
	{
		StringBuffer sb1 = new StringBuffer("Hi");
		StringBuffer sb2 = new StringBuffer("Hi");
		Class1 sbt = new Class1();
		sbt.method1(sb1, sb2);		
		System.out.println("sb1 is " + sb1 + "\nsb2 is " + sb2); 
	}
	
	public void method1(StringBuffer s1, StringBuffer s2)
		{
			s1.append("Umesh");
			s2 = s1; //lineX
		}
}

Output: sb1 is HiUmesh
sb2 is Hi

My question is why not s1 assigns value to S2 in the code marked lineX and prints following output:
sb1 is HiUmesh
sb2 is HiUmesh

Method() takes two StringBuffer args. These are copies of the original references to the objects created in the body of main.

In method() you change the object referred to as s1.

Now you assign the temporal reference s1 to s2.
Nice, but it is only a reference. Not the object.

When you leave method(), the original s2 still referres to the original object.

I hope I cleared it out...

class Class1{
	public static void main(String argv[]){
		String sb1 = new String("Hi");
		String sb2 = new String("Hi");
		Class1 sbt = new Class1();
		sbt.method1(sb1, sb2);
		System.out.println("sb1 is " + sb1 + "\nsb2 is " + sb2);
	}
	public void method1(String s1, String s2){
		s1.concat("Umesh");
		s2 = s1;
	}
}

Here is the output:
sb1 is Hi
sb2 is Hi

My understanding:
String produces immutable objects and any reference to it will modify the original object.

Incase of StringBuffer, its not immutable and original object can be modified thru reference.

But when the same method is slightly modified to take String as an arg, after the method is called, eventhough we tried to concat the input arg String sb1 with "Umesh" inside the method(String sb1, String sb2), what happened inside the method was a NEW String object was created, and the original String object passed to this method was UNTOUCHED. This proves the immutablity of String object.

You may find this particular discussion useful.

regds
maha anna