直接上代码……

public class Swap {



    public static void main（String[] args） {

        int a[] = new int[]{1，2};

        System.out.println（a[0] +  +a[1]）;

        swap（a，0，1）;

        System.out.println（a[0] +  +a[1]）;



    }

private static void swap（int[] a， int i， int j） {

        

        int temp = a[i];

        a[i] = a[j];

        a[j] = temp;

    }

}

        办法调用（call by） 是一个标准的策画机科学术语，办法调用按照参数传递的景象又分为值调用（ call by reference ） 和引用调用（ call by value ） 。江湖上有很多关于这两种调用的定义 ，最凡是的说法是传递值的是值调用，传递地址的是引用调用。这其实很不恰当，这种 这些说法很轻易让我们联想到Java的对象参数传递是引用调用，实际上，Java的对象参数传递仍然是值调用 。 在main里输出还是本来的2、3，不管传递的是引用类型还是对象实例。

public class Swap1

{

    public static void main（String[] args）

    {

        Integer a=new Integer（2）;

        Integer b=new Integer（3）;

        TestSwap ts=new TestSwap（a，b）;

        System.out.println（before swap:）;

        ts.outPut（）;

        ts.dataSwap1（a，b）;

        System.out.println（after swap:）;

        ts.outPut（）;

    }

}



class TestSwap

{

    Integer a=null;

    Integer b=null;

    

    public TestSwap（Integer a，Integer b）

    {

        this.a=a;

        this.b=b;

    }

    /如许不成互换，互换的只是拷贝过来的引用，而

      输出还是成员变量（输出用的是类内的办法）

      首要的是，形参和实参所占的内存地址并不一样，

      形参中的内容只是实参中存储的对象引用的一份拷贝。

      /

    protected void dataSwap0（Integer a，Integer b）

    {

        Integer temp=a;

        a=b;

        b=temp;

    }

    protected void dataSwap（Integer a，Integer b）

    {

        this.a = b;

        this.b = a;

    }

    //如许也可以，不过须要类内的输出，就是说输出TestSwap的成员变量

    protected void dataSwap1（Integer a，Integer b）

    {

        Integer temp=this.a;

        this.a=this.b;

        this.b=temp;

    }

    protected void outPut（）

    {

        System.out.println（a=+a+ b=+b）;

    } 

}