今天被问到一个问题,什么情况下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 catalogSet =new LinkedHashSet();
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 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 String
class represents character strings. All
* string literals in Java programs, such as "abc"
, are
* implemented as instances of this class.
*
* 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:
*
* String str = "abc";
*
* is equivalent to:
*
* char data[] = {'a', 'b', 'c'};
* String str = new String(data);
*
* Here are some more examples of how strings can be used:
*
* System.out.println("abc");
* String cde = "cde";
* System.out.println("abc" + cde);
* String c = "abc".substring(2,3);
* String d = cde.substring(1, 2);
*
*
* The class String
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.
*
* 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 StringBuilder
(or StringBuffer
)
* class and its append
method.
* String conversions are implemented through the method
* toString
, defined by Object
and
* inherited by all classes in Java. For additional information on
* string concatenation and conversion, see Gosling, Joy, and Steele,
* The Java Language Specification.
*
*
Unless otherwise noted, passing a null argument to a constructor
* or method in this class will cause a {@link NullPointerException} to be
* thrown.
*
*
A String
represents a string in the UTF-16 format
* in which supplementary characters are represented by surrogate
* pairs (see the section Unicode
* Character Representations in the Character
class for
* more information).
* Index values refer to char
code units, so a supplementary
* character uses two positions in a String
.
*
The String
class provides methods for dealing with
* Unicode code points (i.e., characters), in addition to those for
* dealing with Unicode code units (i.e., char
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等等一样在内存中物理地址不能改变,String类在生成完结后原则上是不能改变的,每次改变只不过都是创建新的对象,或是直接赋其它的常量值,这就是为什么有"abc"与new String("abc");之说,所以String类在使用中传参是值传递。