java的参数值传递

      今天被问到一个问题，什么情况下java参数的传递为值传递，什么情况为引用传递，回答是基本数据类型如 int, float, double等为值传递，对象形式的参数为引用传递，这个回答被人给反驳了，理由是String 也是对象，为什么是值传递呢? 无语，这个我真不知道。

 

       于是我把值传递与引用传递的几种情况做了个例子，尽量做得最简单。

 

  1) 自定义对角的传递。

 

public class Test {
	
	
	
	@SuppressWarnings("unchecked")
	public Test()
	{
		Catalog catalog =new Catalog();
		catalog.setId(1L);
		catalog.setName("食品");
		catalog.setShortname("工业基");
		catalog.setTpl("ttp");
		catalog.setFoods(new LinkedHashSet());
		System.out.println(TypeUtil.typeToString("catalog", saveCatalog(catalog)));
	}
	
	private void initDefValue(Catalog catalog) {
	
		 catalog.setId(2L);
		 catalog.setName("FOOFOO");
	}
	
        public Catalog	saveCatalog(Catalog catalog)
       {
	   initDefValue(catalog);
	   return catalog;
       }
   
       public static void main(String[]arg)
      {
	   
	   Test test =new Test();
      }

    }

  

    运行结果为:

    catalog.id: 2
    catalog.name: FOOFOO
    catalog.shortname: 工业基
    catalog.tpl: ttp
    catalog.foods[]: empty

     1) java对角的传递。  

public class Test2 {

	public Test2()
	{
		Set<Catalog> catalogSet =new LinkedHashSet<Catalog>();
		Catalog catalog =new Catalog();
		catalog.setId(1L);
		catalog.setName("食品");
		catalog.setShortname("工业基");
		catalog.setTpl("ttp");
		catalog.setFoods(new LinkedHashSet());
		catalogSet.add(catalog);
		changeSet(catalogSet);
		System.out.println(TypeUtil.typeToString("Set",catalogSet));
	}
	public void changeSet(Set<Catalog> catalogSet)
	{
		Catalog catalog2 =new Catalog();
		catalog2.setId(1L);
		catalog2.setName("水果");
		catalog2.setShortname("食品基");
		catalog2.setTpl("ccf");
		catalog2.setFoods(new LinkedHashSet());
		catalogSet.add(catalog2);
	}
	
	public static void main(String[] args) {
		
           Test2 test2 =new Test2();
	}

}

 

运行结果为:

Set[0].id: 1
Set[0].name: 食品
Set[0].shortname: 工业基
Set[0].tpl: ttp
Set[0].foods[]: empty
Set[1].id: 1
Set[1].name: 水果
Set[1].shortname: 食品基
Set[1].tpl: ccf
Set[1].foods[]: empty

 

  1) String与int 的传递。

public class Test3 {

	public Test3()
	{
		String str =new String("99990");
		int num =999;
		changeValue(str,num);
		System.out.println(str);
		System.out.println(num);
	}
	public void changeValue(String str,int num)
	{
		str ="111111";
		num=20;
	}
	
	public static void main(String[] args) {
		
		Test3 test3 =new Test3();

	}

}

 运行结果为:

 99990
 999

 

结果正如人家反驳的那样子，于是把String类拿出来看了下子, 顶上面就有注释。

写道

/**
* The <code>String</code> class represents character strings. All
* string literals in Java programs, such as <code>"abc"</code>, are
* implemented as instances of this class.
* <p>
* Strings are constant; their values cannot be changed after they
* are created. String buffers support mutable strings.
* Because String objects are immutable (永远不变的)they can be shared. For example:
* <p><blockquote><pre>
* String str = "abc";
* </pre></blockquote><p>
* is equivalent to:
* <p><blockquote><pre>
* char data[] = {'a', 'b', 'c'};
* String str = new String(data);
* </pre></blockquote><p>
* Here are some more examples of how strings can be used:
* <p><blockquote><pre>
* System.out.println("abc");
* String cde = "cde";
* System.out.println("abc" + cde);
* String c = "abc".substring(2,3);
* String d = cde.substring(1, 2);
* </pre></blockquote>
* <p>
* The class <code>String</code> includes methods for examining
* individual characters of the sequence, for comparing strings, for
* searching strings, for extracting substrings, and for creating a
* copy of a string with all characters translated to uppercase or to
* lowercase. Case mapping is based on the Unicode Standard version
* specified by the {@link java.lang.Character Character} class.
* <p>
* The Java language provides special support for the string
* concatenation operator ( + ), and for conversion of
* other objects to strings. String concatenation is implemented
* through the <code>StringBuilder</code>(or <code>StringBuffer</code>)
* class and its <code>append</code> method.
* String conversions are implemented through the method
* <code>toString</code>, defined by <code>Object</code> and
* inherited by all classes in Java. For additional information on
* string concatenation and conversion, see Gosling, Joy, and Steele,
* <i>The Java Language Specification</i>.
*
* <p> Unless otherwise noted, passing a <tt>null</tt> argument to a constructor
* or method in this class will cause a {@link NullPointerException} to be
* thrown.
*
* <p>A <code>String</code> represents a string in the UTF-16 format
* in which <em>supplementary characters</em> are represented by <em>surrogate
* pairs</em> (see the section <a href="Character.html#unicode">Unicode
* Character Representations</a> in the <code>Character</code> class for
* more information).
* Index values refer to <code>char</code> code units, so a supplementary
* character uses two positions in a <code>String</code>.
* <p>The <code>String</code> class provides methods for dealing with
* Unicode code points (i.e., characters), in addition to those for
* dealing with Unicode code units (i.e., <code>char</code> values).
*
* @author Lee Boynton
* @author Arthur van Hoff
* @version 1.205, 02/26/09
* @see java.lang.Object#toString()
* @see java.lang.StringBuffer
* @see java.lang.StringBuilder
* @see java.nio.charset.Charset
* @since JDK1.0
*/

 

是不是可以这样理解， String类是final的, 所以与Integer,Byte,Long,Double等等一样不能改变，每次改变都是创建新对象，或是直接赋的常量值，它们可以用做类来使用，但在传参是是值传递。