网上有关“java 在方法中改变int类型的值”话题很是火热，小编也是针对java 在方法中改变int类型的值寻找了一些与之相关的一些信息进行分析，如果能碰巧解决你现在面临的问题，希望能够帮助到您。
有耐心把我下面的看完了，你就明白了：
JAVA 中的传递都是值传递吗？有没有引用传递呢？
在回答这两个问题前，让我们首先来看一段代码：
Java 代码
public class ParamTest {
// 初始值为0
protected int num = 0;
// 为方法参数重新赋值
public void change(int i) {
i = 5;
}
// 为方法参数重新赋值
public void change(ParamTest t) {
ParamTest tmp = new ParamTest();
tmp.num = 9;
t = tmp;
}
// 改变方法参数的值
public void add(int i) {
i += 10;
}
// 改变方法参数属性的值
public void add(ParamTest pt) {
pt.num += 20;
}
public static void main(String[] args) {
ParamTest t = new ParamTest();
System.out.println("参数--基本类型");
System.out.println("原有的值：" + t.num);
// 为基本类型参数重新赋值
t.change(t.num);
System.out.println("赋值之后：" + t.num);
// 为引用型参数重新赋值
t.change(t);
System.out.println("运算之后：" + t.num);
System.out.println();
t = new ParamTest();
System.out.println("参数--引用类型");
System.out.println("原有的值：" + t.num);
// 改变基本类型参数的值
t.add(t.num);
System.out.println("赋引用后：" + t.num);
// 改变引用类型参数所指向对象的属性值
t.add(t);
System.out.println("改属性后：" + t.num);
}
}
这段代码的运行结果如下：
1. 参数--基本类型
2. 原有的值：0
3. 赋值之后：0
4. 运算之后：0
5.
6. 参数--引用类型
7. 原有的值：0
8. 赋引用后：0
9. 改属性后：20
从上面这个直观的结果中我们很容易得出如下结论：
1. 对于基本类型，在方法体内对方法参数进行重新赋值，并不会改变原有变量的值。
2. 对于引用类型，在方法体内对方法参数进行重新赋予引用，并不会改变原有变量所持
有的引用。
3. 方法体内对参数进行运算，不影响原有变量的值。
4. 方法体内对参数所指向对象的属性进行运算，将改变原有变量所指向对象的属性值。
上面总结出来的不过是我们所看到的表面现象。那么，为什么会出现这样的现象呢？这就要
说到值传递和引用传递的概念了。这个问题向来是颇有争议的。
大家都知道，在JAVA 中变量有以下两种：
1. 基本类型变量，包括char、byte、short、int、long、float、double、boolean 。
2. 引用类型变量，包括类、接口、数组 （基本类型数组和对象数组）。
当基本类型的变量被当作参数传递给方法时，JAVA 虚拟机所做的工作是把这个值拷贝了一
份，然后把拷贝后的值传递到了方法的内部。因此在上面的例子中，我们回头来看看这个方
法：
Java 代码
// 为方法参数重新赋值
public void change(int i) {
i = 5;
}
在这个方法被调用时，变量i 和ParamTest 型对象t 的属性num 具有相同的值，却是两个不同
变量。变量i 是由JAVA 虚拟机创建的作用域在 change(int i)方法内的局部变量，在这个方法
执行完毕后，它的生命周期就结束了。在JAVA 虚拟机中，它们是以类似如下的方式存储的：
很明显，在基本类型被作为参数传递给方式时，是值传递，在整个过程中根本没有牵扯到引
用这个概念。这也是大家所公认的。对于布尔型变量当然也是如此，请看下面的例子：
Java 代码
public class BooleanTest {
// 布尔型值
boolean bool = true;
// 为布尔型参数重新赋值
public void change(boolean b) {
b = false;
}
// 对布尔型参数进行运算
public void calculate(boolean b) {
b = b && false;
// 为了方便对比，将运算结果输出
System.out.println("b 运算后的值：" + b);
}
public static void main(String[] args) {
BooleanTest t = new BooleanTest();
System.out.println("参数--布尔型");
System.out.println("原有的值：" + t.bool);
// 为布尔型参数重新赋值
t.change(t.bool);
System.out.println("赋值之后：" + t.bool);
// 改变布尔型参数的值
t.calculate(t.bool);
System.out.println("运算之后：" + t.bool);
}
}
输出结果如下：
1. 参数--布尔型
2. 原有的值：true
3. 赋值之后：true
4. b 运算后的值：false
5. 运算之后：true
那么当引用型变量被当作参数传递给方法时JAVA 虚拟机又是怎样处理的呢？同样，它会拷
贝一份这个变量所持有的引用，然后把它传递给JAVA 虚拟机为方法创建的局部变量，从而
这两个变量指向了同一个对象。在篇首所举的示例中，ParamTest 类型变量t 和局部变量pt
在JAVA 虚拟机中是以如下的方式存储的：
有一种说法是当一个对象或引用类型变量被当作参数传递时，也是值传递，这个值就是对象
的引用，因此JAVA 中只有值传递，没有引用传递。还有一种说法是引用可以看作是对象的
别名，当对象被当作参数传递给方法时，传递的是对象的引用，因此是引用传递。这两种观
点各有支持者，但是前一种观点被绝大多数人所接受，其中有 《Core Java》一 的作者，以
及JAVA 的创造者James Gosling，而 《Thinking in Java》一 的作者Bruce Ecke 则站在了中
立的立场上。
我个人认为值传递中的值指的是基本类型的数值，即使对于布尔型，虽然它的表现形式为
true 和false，但是在栈中，它仍然是以数值形式保存的，即0 表示false，其它数值表示
true 。而引用是我们用来操作对象的工具，它包含了对象在堆中保存地址的信息。即使在被
作为参数传递给方法时，实际上传递的是它的拷贝，但那仍是引用。因此，用引用传递来区
别与值传递，概念上更加清晰。
最后我们得出如下的结论：
1. 基本类型和基本类型变量被当作参数传递给方法时，是值传递。在方法实体中，无法
给原变量重新赋值，也无法改变它的值。
2. 对象和引用型变量被当作参数传递给方法时，在方法实体中，无法给原变量重新赋值，
但是可以改变它所指向对象的属性。至于到底它是值传递还是引用传递，这并不重要，重要
的是我们要清楚当一个引用被作为参数传递给一个方法时，在这个方法体内会发生什么。
其中有两张图传不上来，你就凑合着看吧。
C#跟java语言相比有什么区别？
class A
{
int a=5;
}
class B
{
int a;
B(A a1)//通过构造器
{
this.a=a1.a;
}
public void setA(A a1)//通过调用方法可以
{
this.a=al.a;
}
}
另，通过继承也可以
class A
{
int a=5;
}
class B extends A
{
}
B类中有a;
Java和C#都是编程的语言，它们是两个不同方向的两种语言
相同点:
他们都是面向对象的语言,也就是说,它们都能实现面向对象的思想(封装,继承,多态)
区别：
1.c#中的命名空间是namespace类似于Java中的package（包），在Java中导入包用import而c#中用using。
2.c#和Java都是从main函数入口的，但是c#中的main函数的首字母必须大写，它有四种写法如下：
static void Main(string args[]){}
static int Main(string args[]){}
static void Main(){}
static void Main(){}
而Java中只有一种形式：static void main(String [] args){}
3．数据类型：Java跟c#基本都差不多，但是Java的String类型的首字母必须大写，而c#中可以小写也可以大写，还有布尔型，Java中是boolean，c#中是bool。
4．变量的命名：Java中可以用$符号，而c#中不可以使用。
5．注释：Java比c#少一种"///"的文档注释。
6．输出：c#有三种方式输出：Cosole.WriteLine(); Cosole.WriteLine(要输出的值); Cosole.WriteLine("格式字符串"，变量列表); 前两种的用法与Java中的ystem.out.println()方法的用法相同，第三种方式是根据占位符输出的，比Java更方便了。
7．控制流语句：c#跟Java类似,还有c#中的switch如果case后面有内容必须要有break;Java可以没有break；
8．数组：两种语言的声明都是用new关键字的。都可以在创建数组的同时初始化如：int a[]={1,2,3,5,5};但是c#比Java多两种初始化如：int a[]=new int[3]{1,2,3}; int a[]=new int[]{1,2,3};
9．方法中传递的参数：两种语言都使用值传递与引用传递。
C#的引用传递的关键字是ref与out，ref侧重于修改，out侧重于输出。而Java中都以传值方式;
10．访问修饰符：C#中的访问修饰符与Java中的基本对应，但多出了一个internal。简而言之，C#有5种类型的可访问性，如下所示：
public：成员可以从任何代码访问。 protected：成员只能从派生类访问。
internal：成员只能从同一程序集的内部访问。
protected：成员只能从同一程序集内的派生类访问。
private：成员只能在当前类的内部访问。
11．由于C#中不存在final关键词，如果想要某个类不再被派生，你可以使用sealed关键词密封。
12．集合：两种语言都有集合ArrayList，还有通过键访问值的Java中是HashMap而c#中是HashTable。c#比Java多泛型集合List<T>与Dictionary<K,V>更容易了，无需拆箱装箱了，更安全了。
13．继承：Java中用关键字extends，c#只用"："就行了.调用父类的构造方法Java用super关键字，而c#用base关键字。
14．多态：抽象类和抽象方法两种语言都用abstract关键字。Java中另外一个类如果继承了它，实现直接重写此方法就可以了；而c#必须加上关键字override实现。C#还比Java多一种虚方法来实现多态。
15．接口：都用关键字interface定义，Java实现用关键字implements；c#用"："实现。在C#中，接口内的所有方法默认都是公用方法。在Java中，方法声明可以带有public修饰符（即使这并非必要），但在C#中，显式为接口的方法指定public修饰符是非法的。
16．C#中的is操作符与Java中的instanceof操作符一样，两者都可以用来测试某个对象的实例是否属于特定的类型。在Java中没有与C#中的as操作符等价的操作符。as操作符与is操作符非常相似，但它更富有"进取心"：如果类型正确的话，as操作符会尝试把被测试的对象引用转换成目标类型；否则，它把变量引用设置成null。
17．枚举器即enum类型(java无),把它作为一个变量值的类型使用，从而把变量可能的取值范围限制为枚举器中出现的值。
18．结构（Struct）与类很相似,而结构是一种值类型，它存储在栈中或者是嵌入式的,结构可以实现接口，可以象类一样拥有成员，但结构不支持继承。
19．c#保留了指针。Unsafe。(C#使用指针不安全,最后这条有待考证)
关于“java 在方法中改变int类型的值”这个话题的介绍，今天小编就给大家分享完了，如果对你有所帮助请保持对本站的关注！
本文来自作者[逸仙仙]投稿，不代表盛龙号立场，如若转载，请注明出处：https://www.snlon.net/sn/7964.html
评论列表（3条）
我是盛龙号的签约作者“逸仙仙”
本文概览：网上有关“java 在方法中改变int类型的值”话题很是火热，小编也是针对java 在方法中改变int类型的值寻找了一些与之相关的一些信息进行分析，如果能碰巧解决你现在面临的问...
文章不错《java 在方法中改变int类型的值》内容很有帮助