「java传递参数保证安全」java参数传递机制
本篇文章给大家谈谈java传递参数保证安全，以及java参数传递机制对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
关于java方法参数传递的问题
Java代码
public final 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();
// 为基本类型参数重新赋值
t.change(t.num);
System.out.println(t.num);
// 为引用型参数重新赋值
t.change(t);
System.out.println(t.num);
// 改变基本类型参数的值
t.add(t.num);
System.out.println(t.num);
// 改变引用类型参数所指向对象的属性值
t.add(t);
System.out.println(t.num);
}
}
这段代码的运行结果如下：
20
从上面这个直观的结果中我们很容易得出如下结论：
对于基本类型，在方法体内对方法参数进行重新赋值，并不会改变原有变量的值。
对于引用类型，在方法体内对方法参数进行重新赋予引用，并不会改变原有变量所持有的引用。
方法体内对参数进行运算，不影响原有变量的值。
方法体内对参数所指向对象的属性进行运算，将改变原有变量所指向对象的属性值。
上面总结出来的不过是我们所看到的表面现象。那么，为什么会出现这样的现象呢？这就要说到值传递和引用传递的概念了。这个问题向来是颇有争议的。
大家都知道，在JAVA中变量有以下两种：
基本类型变量，包括char、byte、short、int、long、float、double、boolean。
引用类型变量，包括类、接口、数组（基本类型数组和对象数组）。
当基本类型的变量被当作参数传递给方法时，JAVA虚拟机所做的工作是把这个值拷贝了一份，然后把拷贝后的值传递到了方法的内部。因此在上面的例子中，在调用
Java代码
// 为方法参数重新赋值
public void change(int i) {
i = 5;
}
方法的情况下，变量i和ParamTest型对象t的属性num具有相同的值，却是两个不同变量。变量i是由JAVA虚拟机创建的作用域在change (int i)方法内的局部变量，在这个方法执行完毕后，它的生命周期就结束了。
Java编程中参数传递
两个情况:
1、args的长度不等于3，退出。
2、args的长度等于3,但不会进for循环，因为x已经等于0是不可能大于3的。
(x=0,还xargs.length??那args必须比0小才行啊!)
这要看args的长度来判断了，你这样断章起义很难判断啊!楼主!
java 参数传递问题
1.JAVA基本类型和String型作为参数时，为传值方式，只把值传入方法，不管在方法中怎么处理这个参数，原值不变的；
2.按你写的代码 A2是没法在CHANGE内初始化的。
3.建议去看下JAVA传值和传址的区别，你就会很明白的！
java 参数传递 规则
简言之：Java都是值传递(pass-by-value)
在Java中，无非就是两种类型，即基本类型和从Object继承下来的对象类型，而对象类型又包括String这种一旦初始化就不可改变内容的类型和BufferString这种可以初始化后可
以改变内容的类型。
然后看一下代码示例：
java 代码
1.package test;
2.
3.public class Test {
1. public static void main(String args[]) {
2. Integer interger1, interger2;
3. int i, j;
4. interger1 = new Integer(10);
5. interger2 = new Integer(50);
6. i = 5;
7. j = 9;
8. System.out.println("Before Swap, Interger1 is " + interger1);
9. System.out.println("Before Swap, Interger2 is " + interger2);
10. swap(interger1, interger2);
11. System.out.println("After Swap Interger1 is " + interger1);
12. System.out.println("After Swap Interger2 is " + interger2);
13. System.out.println("Before Swap i is " + i);
14. System.out.println("Before Swap j is " + j);
15. swap(i, j);
16. System.out.println("After Swap i is " + i);
17. System.out.println("After Swap j is " + j);
18.
19. StringBuffer sb = new StringBuffer("I am StringBuffer");
20. System.out.println("Before change, sb is " + sb + "");
21. change(sb);
22. System.out.println("After change sb is " + sb + "");
23. }
24.
25. public static void swap(Integer ia, Integer ib) {
26. Integer temp = ia;
27. ia = ib;
28. ib = temp;
29. }
30.
31. public static void swap(int li, int lj) {
32. int temp = li;
33. li = lj;
34. lj = temp;
35. }
36.
37. public static void change(StringBuffer ia) {
38. ia.append(", but my content can be changed");
39. //ia = new StringBuffer(",but my content can be changed");
40. }
41.}
42.
输出：
Before Swap, Interger1 is 10
Before Swap, Interger2 is 50
After Swap Interger1 is 10
After Swap Interger2 is 50
Before Swap i is 5
Before Swap j is 9
After Swap i is 5
After Swap j is 9
Before change, sb is I am StringBuffer
After change sb is I am StringBuffer, but my content can be changed
这很好解释，对于基本类型诸如int，传递进去的是存放int值的“内存单元”的一个copy，所以函数swap里面的int和外面的int根本就不是一个东西，当然不能反射出去影响外面
的int。而对于对象类型，我们同样可以这样认为，传递进去的是存放对象类型的指针的“内存单元”一个copy（虽然Java里面没有指针的概念，但这并不妨碍我们理解）。这样，
在swap函数里面，对其指针本身的值做任何操作当然不会影响外面的Integer，因为interger1和interger2的“内存单元”里面的值是不变的，其指向的对象类型也是没有变的。
然后这里需要说明一个问题，就是StringBuffer这种类型的对象了。因为其内容是可以改变的，所以change函数里面的“指针”通过类似“*”的操作，改变了StringBuffer对象的
本身，就显而易见了。(StringBuffer对象本身只有一个副本)
关于java参数传递
Java基本数据类型传入方法是值传递，也就是将值赋值给方法参数，在方法在改参数与原变量无关。
而其他三个都是引用数据类型，传递的都是地址，方法根据地址操作都是原对象，所以修改了。
关于java传递参数保证安全和java参数传递机制的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。