java 按值传递还是按照引用传递

于 2017-09-05 21:13:46 发布
阅读量255 收藏 1
点赞数 1
分类专栏： Java Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/uncle_gy/article/details/77856375
版权

java只有值传递，没有引用传递。

java中一共有两种变量类型:
1. ——基本类型——（包括 byte ,short , int，double，long，float，char , bool）,
2. ——引用类型——（比如：Person person =new Person();在这个语句中new运算符在堆中开辟一个空间并且在“（）”运算符之后对这个里的数据进行初始化操作，在等号的左边定义了一个引用person这个person引用在栈空间内，并且保存指向堆里的对象的地址。）

几个相关的小问题：

问题1：什么是值传递

值传递就是在实参和形参之间的数据传递，在java方法中传入的参数不会被方法直接操作，将实参值传递给形参。对形参的操作不会影响到实参。这一点java和C++相同。

问题2：什么是引用，java和C++有什么不同

__什么是引用:引用就是别名（比如诸葛亮的别名卧龙先生，庞统的别名凤雏先生，刘备说我要去请卧龙先生，指的就是诸葛亮。引用保存的是地址。）
__在C++中基本数据类型也可以有引用，比如int a=0; int &b=a;
这时候a的别名就是b;对b的操作就相当于对a;
__在java中基本数据类型没有引用（装箱操作应该可以不过那是包装类），所以在基本数据类型没有引用。但是在类中可以有引用。（比如Person person=new Person(),那个person就是引用）。
__注：在java中不可以直接取得变量的地址，java中内存部分对用户来说是相对透明的。

问题3：什么是指针，java有没有指针

在C++中指针保存的是所指向内存的地址，通过*运算符可以取出内存萝莉保存的数据。并且指针的指向是可变的，java中的引用也是可以改变的。所有java中虽然没有指针，但是可以通过引用来实现类似的操作（java的引用不能进行++或–操作，因为这么做会直接操作内存，这和java的设计初衷是违背的。）
比如:
在C++中：

#include <iostream>

using namespace std;

int main()
{
     int  a=0;
     int *b=&a;
     cout<<"loc of b "<<b<<endl;
     cout<<"value of b point  "<<*b<<endl;
     int c=1 ;
     b=&c;
      cout<<"loc of b "<<b<<endl;
     cout<<"value of b point  "<<*b<<endl;
     int &d=a;
     d=2;
     cout<<"loc of a "<<&a<<endl;
     cout<<"value of a   "<<a<<endl;
     cout<<"loc of d "<<&d<<endl;
     cout<<"value of d   "<<d<<endl;
     int x=0;
     int y=x;
     cout<<"loc of x "<<&x<<endl;
     cout<<"value of x  "<<x<<endl;

     cout<<"loc of y "<<&y<<endl;
     cout<<"value of y "<<y<<endl;
    return 0;
}

输出结果(不同电脑可能不同)：

loc of b 0x6afef4
value of b point  0
loc of b 0x6afef0
value of b point  1
loc of a 0x6afef4
value of a   2
loc of d 0x6afef4
value of d   2
loc of x 0x6afeec
value of x  0
loc of y 0x6afee8
value of y 0

Process returned 0 (0x0)   execution time : 0.409 s
Press any key to continue.

貌似在java中基本数据类型无法像C++中那么玩；java 对于基本数据类型只能想上面的C++代码中的x,y 一样，在赋值之后x,y的地址不同，java和C++都是在栈空间中重新开辟空间然后将原值拷贝，对于新值得操作对原值没有任何影响。
但是java中无法查看变量地址，所以用赋值来间接体现这一过程。

package tablejava;

public class ZhiCD {
    public static void main(String[] args) {
         int a =0;
         int b=a;
         b=1;
         System.out.println("a="+a);
         System.out.println("b="+b);
    }
}

a=0
b=1

java程序员真的无法直接控制内存。:`(

java的值传递

最直观的基本数据类型的传递一定是值传递（byte,char,short,int,long,double,float,bool）

图解：

未标题-1.png

代码：
package tablejava;

public class ZhiCD {

    public static void zhiCD(int c,int d) {
        c++;
        d++;
        System.out.println("c="+c);
        System.out.println("d="+d);
    }
    public static void main(String[] args) {
        int a =0;
        int b=1;
        zhiCD(a,b);
        System.out.println("a="+a);
        System.out.println("b="+b);
    }
}
输出结果：
c=1
d=2
a=0
b=1

java的“引用传递”

java的引用传递，说到底还是值传递，因为传递的是引用的地址。java的引用可以朝三暮四。这和C++里的对象指针十分类似。
先来看看java的引用。

代码：
package tablejava;
class Person {
    private int age;
    public Person() {
        this.age=20;
    }
    public Person(int age) {
       this.age=age;
    }
    public int getAge() {
        return this.age;
    }
    public void setAge(int age) {
        this.age=age;
    }

}
public class YYCD {
    public static void main(String []args) {
        Person person1=new Person(20);
        Person person2=new Person(22);

        Person personref=person1;
        personref.setAge(21);
        System.out.println("person1= "+person1.getAge());
        System.out.println("personref = "+personref.getAge());

        personref=person2;
        personref.setAge(23);
        System.out.println("personref = "+personref.getAge());
        System.out.println("person1= "+person1.getAge());
        System.out.println("person2= "+person2.getAge());
    }
}

person1= 21
personref = 21
personref = 23
person1= 21
person2= 23

引用就是一种指针保存了对象在内存的地址。

代码：
package tablejava;
public class YYCD {

    public static void change(Person per1,Person per2) {
        per1.setAge(18);
        per2.setAge(19);
        System.out.println("per1= "+per1.getAge());
        System.out.println("per2= "+per2.getAge());
    }

    public static void main(String []args) {

        Person person1=new Person(20);
        Person person2=new Person(22);
        change(person1,person2);
        System.out.println("person1= "+person1.getAge());
        System.out.println("person2= "+person2.getAge());

    }
}
结果：
per1= 18
per2= 19
person1= 18
person2= 19

看起来和C++没有区别，但是换一种方式：

package tablejava;

public class YYCD {

    public static void swap(Person per1,Person per2) {
        Person persontemp;
        persontemp=per1;
        per1=per2;
        per2=persontemp;
        System.out.println("per1= "+per1.getAge());
        System.out.println("per2= "+per2.getAge());
    }

    public static void main(String []args) {

        Person person1=new Person(20);
        Person person2=new Person(22);
        swap(person1,person2);
        System.out.println("person1= "+person1.getAge());
        System.out.println("person2= "+person2.getAge());

    }
}

如果java进行的是引用传递，在交换的时候必定交换的是引用，但是在结果中我们可以看到，最后的输出结果没有被改变。所以java进行的是“引用的值传递”，依旧是值传递。
C++的引用传递

代码：
#include <iostream>
using namespace std;
void switchab(int &ar,int &br){
    int c;
    c=ar;
    ar=br;
    br=c;
    cout<<"ar="<<ar<<endl;
    cout<<"br="<<br<<endl;
}
int main()
{
    int a=0;
    int b=1;
    cout<<"a="<<a<<endl;
    cout<<"b="<<b<<endl;
    cout<<"after switch"<<endl;
    switchab(a,b);
    cout<<"a="<<a<<endl;
    cout<<"b="<<b<<endl;
    return 0;
}
结果：
a=0
b=1
after switch
ar=1
br=0
a=1
b=0

Process returned 0 (0x0)   execution time : 0.995 s
Press any key to continue.

C++的值传递

代码：
#include <iostream>

using namespace std;

void switchab(int ar,int br){
    int c;
    c=ar;
    ar=br;
    br=c;
    cout<<"ar="<<ar<<endl;
    cout<<"br="<<br<<endl;
}
int main()
{
    int a=0;
    int b=1;
    cout<<"a="<<a<<endl;
    cout<<"b="<<b<<endl;
    cout<<"after switch"<<endl;
    switchab(a,b);
    cout<<"a="<<a<<endl;
    cout<<"b="<<b<<endl;
    return 0;
}

a=0
b=1
after switch
ar=1
br=0
a=0
b=1

Process returned 0 (0x0)   execution time : 0.932 s
Press any key to continue.

C++的指针传递

代码：
#include <iostream>

using namespace std;

void switchab(int *ar,int* br){
    int *temp=ar;
    ar=br;
    br=temp;
    cout<<"ar="<<*ar<<endl;
    cout<<"br="<<*br<<endl;
}
int main()
{
    int a=0;
    int b=1;
    cout<<"a="<<a<<endl;
    cout<<"b="<<b<<endl;
    cout<<"after switch"<<endl;
    switchab(&a,&b);
    cout<<"a="<<a<<endl;
    cout<<"b="<<b<<endl;
    return 0;
}
结果：
a=0
b=1
after switch
ar=1
br=0
a=0
b=1

Process returned 0 (0x0)   execution time : 0.880 s
Press any key to continue.

是不是似曾相识，在java的引用传递中我们也得到了类似的结果，传递的只是地址。如果想完成交换只需要修改

void switchab(int *ar,int* br){
    int temp=*ar;
    *ar=*br;
    *br=temp;
    cout<<"ar="<<*ar<<endl;
    cout<<"br="<<*br<<endl;
}

总结

java 和C++的引用传递的区别：

java的引用传递，传递的是引用的地址，就是引用的值，是值传递；
C++的引用传递，传递的是引用，是变量的别名。
C++的指针传递，和java的引用传递非常类似。这个上面的代码已经交代了。
其实，两者的区别的比较大多是没有意义的，虽然java基于C++但是java和C++的区别还是特别多的，强行的比较意义不大。

王先生的副业
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值