java传参是按什么传递 java中参数传递,按引用传递
大家好，如果您还对java传参是按什么传递不太了解，没有关系，今天就由本站为大家分享java传参是按什么传递的知识，包括java中参数传递,按引用传递的问题都会给大家分析到，还望可以解决大家的问题，下面我们就开始吧！
java中参数传递方式
在 Java应用程序中永远不会传递对象，而只传递对象引用。因此是按引用传递对象。Java应用程序按引用传递对象这一事实并不意味着 Java应用程序按引用传递参数。参数可以是对象引用，而 Java应用程序是按值传递对象引用的。
对象是按引用传递的；
Java应用程序有且仅有的一种参数传递机制，即按值传递；
按值传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的一个副本；
按引用传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的内存地址，而不是值的副本。
Java应用程序中的变量可以为以下两种类型之一：引用类型或基本类型。当作为参数传递给一个方法时，处理这两种类型的方式是相同的。两种类型都是按值传递的；没有一种按引用传递。
注：参数是按值而不是按引用传递的，说明 Java应用程序有且仅有的一种参数传递机制，即按值传递。
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执行的方法都作用于同一个对象。
区分引用类型和原始类型并理解引用的语义是很重要的。若做不到这一点，则会使编写的代码无法完成预定工作。
Java中函数参数的传递是怎样进行的
Java中函数参数的传递是按值传递。
下面证明Java中参数传递是完完全全是传值而不是传址。
一：
package com.sitinspring;
public class ChangeClass{
public void changeInt(int i){
i=5;
}
public void changeLong(long i){
i=555;
}
public void changeString(String str){
str="5555";
}
public void changeMember(Member member){
member=new Member("Cindy",35);
}
public void changeMemberField(Member member){
member.setAge(20);
member.setName("Andy");
}
public static void main(String[] args){
ChangeClass changeClass=new ChangeClass();
int intValue=10;
changeClass.changeInt(intValue);
System.out.println(intValue);
long longValue=10;
changeClass.changeLong(longValue);
System.out.println(longValue);
String stringValue="1234";
changeClass.changeString(stringValue);
System.out.println(stringValue);
Member member2=new Member("Douglas",45);
changeClass.changeMember(member2);
System.out.println(member2);
Member member=new Member("Bill",25);
changeClass.changeMemberField(member);
System.out.println(member);
}
}
二：
package com.sitinspring;
public class Member{
private String name;
private int age;
public Member(String name,int age){
this.age=age;
this.name=name;
}
public String toString(){
return"Member name="+name+" age="+age;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age= age;
}
public String getName(){
return name;
}
public void setName(String name){
this.name= name;
}
}
输出：
10
10
1234
Member name=Douglas age=45
Member name=Andy age=20
解释：
第一个输出10是因为int是基本类型,传递的参数是intValue的拷贝,对拷贝的修改对原值intValue没有影响.
第一个输出10和上面是一个道理.
第三个输出1234.由于String是类类型, str是stringValue的地址拷贝,参数str指向的地址和stringValue的一致,但在函数changeString中,由于String的特殊性, str=“5555”和str=new String(“5555”)是等价的, str指向了新的”5555”所在的地址,此句后str就与原来的stringValue彻底脱离了联系.
第四个输出Member?name=Douglas?age=45的道理和上面相同.
第五个输出Member?name=Andy?age=20是因为changeMemberField函数中修改了参数member的值,也就是修改member指向实例的值,而这个实例正是member指向的值,因此member就变成了name=Andy且age=20.
结论：
Java中参数传递的都是值,对应基本类型,传递的是原值的拷贝;对于类类型,传递的是引用即地址的拷贝.
对于函数对参数的改变是否会影响原值的问题:值类型自然不会影响到原值.而对于类类型要看改变的是参数的地址还是值,如果是前者,参数和原引用指向了不同的地址,它们自然脱离了关系;如果是后者,修改的实例就是原引用指向的实例,这当然对原值进行了修改.
关于本次java传参是按什么传递和java中参数传递,按引用传递的问题分享到这里就结束了，如果解决了您的问题，我们非常高兴。