大家好，今天Win10系统之家小编给大家分享「java如何传递引用」的知识，如果能碰巧解决你现在面临的问题，记得收藏本站或分享给你的好友们哟~，现在开始吧！

1.java string怎么传引用传递

　　你是C/C++或是VB转过来的吗？在Java中过多考虑引用（指针）和值之间的关系是步入歧途，这正是Java的设计者极力避免你考虑的问题。
你需要明白的是：
1、Java中所有方法的参数的传递都是“值传递”；
2、Java中所有对象类型的变量的“值”，本质上说，包含了Java堆中的实际对象的地址，你可以大体认为Java的变量对应了C/C++中的指针（其实这里面有更复杂的机制）。事实上，Java并不像C/C++一样明确的区分“值语义”与“引用语义”，Java栈中也不会存放任何对象的实体（这点与C/C++不同，C/C++栈中可以存放对象实体），所有的Java对象都是在堆中。
概念上的区别在于，我这里提到的“变量”是指Java栈中的内容，对应你说的“引用”；我提到的“对象”是指Java堆中的实体，对应你说的“值”。而一般Java教材中提到的“值传递”，是指这些“变量”的内容的传递，不是Java堆中的对象实体的传递。
你用字符串来做实验，并推广为所有Java对象的做法，并不是特别合适。Java的String类型有特殊的处理：所有编译期认识的字符串，都会被放到常量池，于是下面的语句：
a = "s";
b = "s";
a和b并不像其它对象一样有创建的动作，都是直接指向常量池中的"s"，所以你可以得到a==b。而下面的语句：
a = new String("s");
b = new String("s");
是分别在Java堆中创建了2个对象，此时a!=b。
本质上说，对于基本数据类型（整数、字符等），Java的符号==，用于判断二者的值是否相等；对于对象类型，Java的符号==，用于判断两个变量是否是“同一个对象”，equals()方法才是用于判断两个对象是否相等。
你希望实现的swap逻辑，在Java中通常认为是无法实现的。拿你这个例子来说，swapValue()中的tmpValue无论怎么更改，只是改变tmpValue自己的内容（即不断指向不同的对象），并不会改变value中的内容（始终指向同一个对象）。这也是为什么Java最初说自己永远是值传递。你只有改变tmpValue指向的对象的值（通过调用这个对象的方法或是更改它的属性），使用value访问时，才能看到这些改变。
为了弥补这个缺陷，C#才加入了ref关键字，允许传入变量的引用（如果参考C/C++，C#传递的实际是二级指针，它的内容是栈中的变量的地址）。

2.java怎么实现String的引用传递

　　你是c/c++或是vb转过来的吗？在java中过多考虑引用（指针）和值之间的关系是步入歧途，这正是java的设计者极力避免你考虑的问题。
你需要明白的是：
1、java中所有方法的参数的传递都是“值传递”；
2、java中所有对象类型的变量的“值”，本质上说，包含了java堆中的实际对象的地址，你可以大体认为java的变量对应了c/c++中的指针（其实这里面有更复杂的机制）。事实上，java并不像c/c++一样明确的区分“值语义”与“引用语义”，java栈中也不会存放任何对象的实体（这点与c/c++不同，c/c++栈中可以存放对象实体），所有的java对象都是在堆中。
概念上的区别在于，我这里提到的“变量”是指java栈中的内容，对应你说的“引用”；我提到的“对象”是指java堆中的实体，对应你说的“值”。而一般java教材中提到的“值传递”，是指这些“变量”的内容的传递，不是java堆中的对象实体的传递。
你用字符串来做实验，并推广为所有java对象的做法，并不是特别合适。java的string类型有特殊的处理：所有编译期认识的字符串，都会被放到常量池，于是下面的语句：
a = "s";
b = "s";
a和b并不像其它对象一样有创建的动作，都是直接指向常量池中的"s"，所以你可以得到a==b。而下面的语句：
a = new string("s");
b = new string("s");
是分别在java堆中创建了2个对象，此时a!=b。
本质上说，对于基本数据类型（整数、字符等），java的符号==，用于判断二者的值是否相等；对于对象类型，java的符号==，用于判断两个变量是否是“同一个对象”，equals()方法才是用于判断两个对象是否相等。
你希望实现的swap逻辑，在java中通常认为是无法实现的。拿你这个例子来说，swapvalue()中的tmpvalue无论怎么更改，只是改变tmpvalue自己的内容（即不断指向不同的对象），并不会改变value中的内容（始终指向同一个对象）。这也是为什么java最初说自己永远是值传递。你只有改变tmpvalue指向的对象的值（通过调用这个对象的方法或是更改它的属性），使用value访问时，才能看到这些改变。
为了弥补这个缺陷，c#才加入了ref关键字，允许传入变量的引用（如果参考c/c++，c#传递的实际是二级指针，它的内容是栈中的变量的地址）。

3.java中参数传递，按引用传递？？

　　Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。另外，Java 还为每个原始类型提供了封装类(Wrapper)。如果需要一个整型变量，是使用基本的 int 型呢，还是使用 Integer 类的一个对象呢？如果需要声明一个布尔类型，是使用基本的 boolean，还是使用 Boolean 类的一个对象呢？本文可帮助您作出决定。
下表列出了原始类型以及它们的对象封装类。
原始类型 封装类 
=================
boolean Boolean 
char Character 
byte Byte 
short Short 
int Integer 
long Long 
float Float 
double Double 
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。例如，假定一个方法中有两个局部变量，一个变量为 int 原始类型，另一个变量是对一个 Integer 对象的对象引用：
int i = 5; // 原始类型
Integer j = new Integer(10); // 对象引用
这两个变量都存储在局部变量表中，并且都是在 Java 操作数堆栈中操作的，但对它们的表示却完全不同。（本文中以下部分将用通用术语堆栈代替操作数堆栈或局部变量表。）原始类型 int 和对象引用各占堆栈的 32 位。（要表示一个 int 或一个对象引用，Java 虚拟机实现至少需要使用 32 位存储。）Integer 对象的堆栈项并不是对象本身，而是一个对象引用。
Java 中的所有对象都要通过对象引用访问。对象引用是指向对象存储所在堆中的某个区域的指针。当声明一个原始类型时，就为类型本身声明了存储。前面的两行代码表示如下：
引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。
许多程序的代码将同时包含原始类型以及它们的对象封装。当检查它们是否相等时，同时使用这两种类型并了解它们如何正确相互作用和共存将成为问题。程序员必须了解这两种类型是如何工作和相互作用的，以避免代码出错。
例如，不能对原始类型调用方法，但可以对对象调用方法：
int j = 5;
j.hashCode(); // 错误
//...
Integer i = new Integer(5);
i.hashCode(); // 正确
使用原始类型无须调用 new，也无须创建对象。这节省了时间和空间。混合使用原始类型和对象也可能导致与赋值有关的意外结果。看起来没有错误的代码可能无法完成您希望做的工作。例如：
import java.awt.Point;
class Assign
{
 public static void main(String args[])
 {
 int a = 1;
 int b = 2;
 Point x = new Point(0,0);
 Point y = new Point(1,1); //1
 System.out.println("a is " + a);
 System.out.println("b is " + b);
 System.out.println("x is " + x);
 System.out.println("y is " + y);
 System.out.println("Performing assignment and " +
 "setLocation...");
 a = b;
 a++;
 x = y; //2
 x.setLocation(5,5); //3
 
 System.out.println("a is "+a);
 System.out.println("b is "+b);
 System.out.println("x is "+x);
 System.out.println("y is "+y);
 }
} 
这段代码生成以下输出：
a is 1
b is 2
x is java.awt.Point[x=0,y=0]
y is java.awt.Point[x=1,y=1]
Performing assignment and setLocation...
a is 3
b is 2
x is java.awt.Point[x=5,y=5]
y is java.awt.Point[x=5,y=5] 
修改整数 a 和 b 的结果没什么意外的地方。b 的值被赋予整型变量 a，结果 a 的值增加了 1。这一输出反映了我们希望发生的情况。但是，令人感到意外的，是在赋值并调用 setLocation之后 x 和 y 对象的输出。我们在完成 x = y 赋值之后特意对 x 调用了 setLocation，x 和 y 的值怎么会相同呢？我们毕竟将 y 赋予 x，然后更改了 x，这与我们对整数 a 和 b 进行的操作没什么不同。
这种混淆是由原始类型和对象的使用造成的。赋值对这两种类型所起的作用没什么不同。但它可能看起来所有不同。赋值使等号 (=) 左边的值等于右边的值。这一点对于原始类型（如前面的 int a 和 b）是显而易见的。对于非原始类型（如 Point 对象），赋值修改的是对象引用，而不是对象本身。因此，在语句
x = y;
之后，x 等于 y。换句话说，因为 x 和 y 是对象引用，它们现在引用同一个对象。因此，对 x 所作的任何更改也会更改 y。下面是 //1 处的代码执行以后的情况：
执行 //2 处的赋值以后情况如下：
当在 //3 处调用 setLocation 时，这一方法是对 x 引用的对象执行的。因为 x 引用的 Point 对象也正是 y 所引用的对象，所以我们现在得到以下结果：
因为 x 和 y 引用同一个对象，所以对 x 执行的所有方法与对 y 执行的方法都作用于同一个对象。
区分引用类型和原始类型并理解引用的语义是很重要的。若做不到这一点，则会使编写的代码无法完成预定工作。

4.java按引用传递？！

　　我写了下面这些代码：
public class Test {
 static Integer i = new Integer(10);
 Test(){
 i = 5;
 }
 static void change(Integer f){
 System.out.println(f);
 f = 3;
 System.out.println(f);
 System.out.println(i);
 }
 public static void main(String args[]){
 Test t= new Test();
 change(t.i);
 System.out.println(t.i);
 }
}
测试了下，结果为：5535.郁闷死，难道这就能证明封装后的基本类型还是值传递吗？
做如下测试：
public class Person {
 public String name = "tom";
 public int age = 11;
 Person(){}
 Person(String name,int age){
 this.name = name;
 this.age = age;
 }
public void change1(String name, int age){
 this.name = name;
 this.age = age;
 }
 public String toString(){
 return name+age; 
 }
 public static void change2(Person p){
 p.name = "bob";
 p.age = 33;
 }
 public static void change3(Person p){
 p = new Person("test",44);
 }
 public static void main(String args[]){
 Person p = new Person();
 System.out.println(p.toString());
 p.change1("jenny", 22);
 System.out.println(p.toString());
 change2(p);
 System.out.println(p.toString());
 change3(p);
 System.out.println(p.toString());
 }
}
结果为：
tom11
jenny22
bob33
bob33
哈哈，这个就有意思了。请注意这里的change1、change2、change3方法，对比后你会发现微妙的地方。我主要讲一下change3方法：
在进入函数时，创建一个Person对象的引用，并且将main函数中的p对象的引用赋给它，造成的影响就是他们指向同一块内存。在函数体内部，你又新建一个对象，并且将新对象的引用赋给函数参数，造成的影响是参数的那个引用和新对象指向同一内存，对p对象毫无影响，因此结果还是bob33。Integer的道理是一样的。
在这里要纠正一些概念：
值传递：说的是将变量的内容传递过去，java基本类型就如此。并不是说有了值传递在进入有参数的方法体时就不创建新变量了。
引用传递：说的是将该变量的首地址传递过去，java的类对象就如此。并不是说有了值传递在进入有参数的方法体时就不创建新变量了。（如果java的类对象也采用值传递那就不需要clone（）了）

以上就是关于「java如何传递引用」的全部内容，本文讲解到这里啦，希望对大家有所帮助。如果你还想了解更多这方面的信息，记得收藏关注本站~

文①章♂来自Win10系统之家wｗw.ghoｓｔ5８０.Ｎet，转载请联系！