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
2) 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
4) 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
*/
