Sponsored Link

Java语言的参数传递和处理方法 - 全面掌握Java参数传递与参数

2008-01-31 20:57Update

LifevV.COM编辑部

Page Options

Recommend To Friend

不只是对于Java初学者，就是对于有多年Java开发经验的老手来说，Java里的参数传递也是一个非常容易混淆弄错和被忽略的的概念。

而这种忽略，往往会造成一些非常隐蔽而难以被发现的错误。

尤其当一个程序日趋复杂庞大时，如果在参数传递方面不知道Java对参数的处理规则，将会给系统留下种种隐患。
本文将对Java语言对参数的传递和处理方法作一个全面深入地介绍。

一般的计算机语言，一个方法调用另一个方法（或者说父程序调用另一个子程序），参数传递一般可以分为：
按值调用（call-by-value）：
这种调用，即使在子程序中改变了参数值，但在父程序中该参数对应的原变量值并未改变。
引用调用（call-by-reference）：
这种调用，如果在子程序中改变了参数值，父程序中该参数对应的原变量值也将得到改变。

那么，Java语言在调用一个方法传递参数时，Java里的参数传递是怎么进行的，Java语言对参数是怎么处理的呢？

简单地说，Java语言对参数的处理也有2种方法，按值调用以及引用调用。如下：
1，按值调用方法：如果所传递的参数是String, Integer, int, Long, long, Boolean, boolean等简单类型，即使在一个方法内部改变了该参数的值，但并不影响方法外部参数本身的值。
2，引用调用方法：相反，如果所传递的参数是Java复合类型，则若在一个方法内部改变了该参数的值，则在该方法外部，该对象的值也跟着得到改变。

下面，用一个简单地例子说明：

											
											
											
											
											import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class TestJavaParam {

    /**
     * @param args
     */
    public static void main(String[] args) {
        TestJavaParam testJavaParam = new TestJavaParam();
        
        
        //测试 传递一个 Integer 参数: 简单类型的参数
        Integer param1 = new Integer(0);
        System.out.println("param1=" + param1.toString());
        testJavaParam.testSimpleValueParam(param1);
        System.out.println("param1=" + param1.toString());
        
        //测试 传递一个 int 参数: 简单类型的参数
        int param2 = 0;
        System.out.println("param2=" + param2);
        testJavaParam.testSimpleValueParam(param2);
        System.out.println("param2=" + param2);
        
        
        //测试 传递一个 String 参数: 简单类型的参数
        String param3 = "Hello ";
        System.out.println("param3=" + param3);
        testJavaParam.testSimpleValueParam(param3);
        System.out.println("param3=" + param3);
        
        //测试 传递一个 ComplextObject 参数: 复合类型的参数
        ComplextObject param4 = new ComplextObject("OldId", 0);
        System.out.println("param4=[ComplextObject.id]=" + param4.getId() + " [ComplextObject.index]=" + param4.getIndex());
        testJavaParam.testComplextObjectParam(param4);
        System.out.println("param4=[ComplextObject.id]=" + param4.getId() + " [ComplextObject.index]=" + param4.getIndex());
        
        //测试 传递一个 List 参数: 复合类型的参数        
        List param5 = new ArrayList();
        System.out.println("param5=[List.size]=" + param5.size());
        testJavaParam.testCollectionParam(param5);
        System.out.println("param5=[List.size]=" + param5.size());
    }
    
    
    public void testSimpleValueParam(Integer i) {
        i = i+1;
    }
    public void testSimpleValueParam(int i) {
        i = i+1;
    }
    public void testSimpleValueParam(String i) {
        i = i+ " test.";
    }
    
    
    public void testComplextObjectParam(ComplextObject obj) {
        obj.setId("ChangedId");
        obj.setIndex(1);
    }
    
    public void testCollectionParam(Collection collection) {
        collection.add("AddedString");
    }

}

class ComplextObject {
    private String id;
    private int index;
    
    public ComplextObject(String id, int index) {
        this.id = id;
        this.index = index;
    }
    
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public int getIndex() {
        return index;
    }
    public void setIndex(int index) {
        this.index = index;
    }
    
    
}

										


编译执行后，显示：
c:\>Java\javac TestJavaParam.java

c:\>Java\java TestJavaParam
param1=0
param1=0
param2=0
param2=0
param3=Hello 
param3=Hello 
param4=[ComplextObject.id]=OldId [ComplextObject.index]=0
param4=[ComplextObject.id]=ChangedId [ComplextObject.index]=1
param5=[List.size]=0
param5=[List.size]=1



我们发现，简单类型的参数param1，param2，param3的值在子方法的调用前后并未发生改变，而复合类型的参数param4，param5的值却发生了改变。
									