Java参数传递

package test;

/**
 *
 * @author KingSlayer
 */
public class Main {
    /**
     * @param args the command line arguments
     * java分两种数据类型
     * 1. 基本类型：char、byte、short、int、long、float、double、boolean
     * 2. 引用类型：类、接口、数组 （基本类型数组和对象数组）。 可以当做指针了解。
     * 
     * 
     *
     * 1. 对于基本类型，在方法体内对方法参数进行重新赋值，并不会改变原有变量的值。
     * 2. 对于引用类型，在方法体内对方法参数进行重新赋予引用，并不会改变原有变量所持有的引用。
     *    就像两个指针指向一个地址，你对所指向的类型进行修改时可以的，
     *    但是直接赋值就相当于直接给予了一个新的地址，源地址的东西没有改变。
     *    （String类型没有能直接改变自己属性的方法）
     * 3. 方法体内对参数进行运算，不影响原有变量的值。
     * 4. 方法体内对参数所指向对象的属性进行运算，将改变原有变量所指向对象的属性值。
     */
    public Main(int i){
        attr = i;
    }
    public static void swapInt(int i1, int i2){
        System.out.println("Java没有指针和引用，所以int型的肯定是值传递了，这个应该没有争议");
    }
    public static void changeString(String str){
        str="new String";
    }
    public static void addDivider(){
        System.out.println("-------------华丽的分割线----------------");
    }
    public static void changeStringBuffer(StringBuffer strB1, StringBuffer strB2){
        strB1.append(" has been changed!");
        strB2 = strB1;
    }
    public static void changeClass(Main a){
        a.attr=1;
    }
    public static void swapClass(Main a, Main b){
       Main c = a;
       a = b;
       b = c;
    }
    public static void main(String[] args) {
        // TODO code application logic here
        int i1 = 0, i2 = 0;
        swapInt(i1,i2);
        addDivider();
        String str = "String str";
        changeString(str);
        System.out.println(str);
        addDivider();
        StringBuffer strB1 = new StringBuffer("StringBuffer strB");
        StringBuffer strB2 = new StringBuffer("StringBuffer strB");
        changeStringBuffer(strB1,strB2);
        System.out.println(strB1);
        System.out.println(strB2);
        Main a = new Main(0);
        System.out.print("修改属性是可以的：begin:" + a.attr);
        changeClass(a);
        System.out.println("    end:" + a.attr);
        Main b = new Main(0);
        addDivider();
        System.out.print("原来a"+a.attr+"    b"+b.attr+"的值    ");
        swapClass(a, b);
        System.out.print("现在a"+a.attr+"    b"+b.attr+"的值");

    }
    private int attr = 0;
}

结果：

run：
Java没有指针和引用，所以int型的肯定是值传递了，这个应该没有争议
-------------华丽的分割线----------------
String str
-------------华丽的分割线----------------
StringBuffer strB has been changed!
StringBuffer strB
修改属性是可以的：begin:0    end:1
-------------华丽的分割线----------------
原来a1    b0的值    现在a1    b0的值成功生成（总时间：0 秒）

//所以修改链表里面的指针是可以传递的
//修改数组里面的元素也是可以的
{
    int[] a = {1, 2};
    swap(a);
    //result a[0]=2; a[1]=1;
}
public static void swap(int[] a){
    int i = a[0];
    a[0] = a[1];
    a[1] = i;
}