java参数传入逻辑符号（java方法传参）

本文目录一览：

1、java逻辑运算符都有哪些
2、java 参数传递规则
3、java中的逻辑符号，运算符（位运算符）个代表什么
4、Java参数传递
5、Java在参数中用“ | ”符号是什么原理？我说的不是指判断true和false的或，而是参数中的“ | ”
6、java 中|| 和 && 这类的符号都表示什么？

java逻辑运算符都有哪些

逻辑运算符包括、||、！。其中和 || 是双目运算符，实现逻辑与、逻辑或；！是单目运算符，实现逻辑非。

结果为 boolean 型的变量或表达式可以通过逻辑运算符结合成为逻辑表达式。逻辑运算符、|| 和！按表 2 进行逻辑运算。

逻辑运算符的优先级为：！运算级别最高，运算高于 || 运算。！运算符的优先级高于算术运算符，而和 || 运算则低于关系运算符。结合方向是：逻辑非（单目运算符）具有右结合性，逻辑与和逻辑或（双目运算符）具有左结合性。

扩展资料：

逻辑运算符的示例。

x0 x=100 //第一行语句

y%4==0 || y%3==0 //第二行语句

!(xy) //第三行语句

其中，第一行语句用于判断 x 的值是否大于 0 且小于或等于 100，只有两个条件同时成立结果才为真（true）。

第二行语句用于判断 y 的值是否能被 4 或者 3 整除，只要有一个条件成立，结果就为真（true）。

第三行语句先比较 x 和 y，再将比较结果取反，即如果 x 大于 y 成立，则结果为假（false），否则为真（true）。

java 参数传递规则

简言之：Java都是值传递(pass-by-value)

在Java中，无非就是两种类型，即基本类型和从Object继承下来的对象类型，而对象类型又包括String这种一旦初始化就不可改变内容的类型和BufferString这种可以初始化后可

以改变内容的类型。

然后看一下代码示例：

java 代码

1.package test;

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中的逻辑符号，运算符（位运算符）个代表什么

算数运算符，+-*/(+=，-=，*=，、/*) p.s. 1/0 = NaN 无穷大。逻辑运算符，略转义序列符（例举），\b 退格, \t 制表, \n 换行（制图、一般println）, \r 回车, \” 双引号, \’ 单引号p.s. 取决于os，并不常用。递增/减 ++, –赋值 =比较 =，=, ==位移，, p.s. 图形用到注释，// 行注释，/* */段注释类型转换， a = (int)b; //括号。条件， if()… == a ? true : false //三目运算。正则表达式，应用类，用到这再说。

LZ是学Java的新手吧。嗯，慢慢学

Java参数传递

Java的方法参数传递都是值传递。这个问题需要楼主慢慢理解，如果基础薄弱（C、C++基础弱）就记住就好。如果基础好可以从内存角度理解。

从语法和简单层面理解：str是一个String类型的对象，传递给changeStr方法，传递的是str的引用内容，方法内的changeStr(String value)，value变量和str指向了同一个对象，但是value重新赋值后，它的指向改变了，但是str的指向不会发生，所以str的输出还是“Hello”，而changeObjValue方法传入的TEST的对象pt给changeObjValue(TEST ref)，ref变量和pt变量指向了同一对象，之后通过改变了对象的内容，pt变量的指向没变，但是执行的对象的变量变了。所以pt的ptValue值变了。

进一步理解，Java对字符串进行了特殊处理，因为字符串这种数据类型太常用了，为了节省内容提高效率。Java把字符串放入了常量池，所以我们没办法在运行时修改一个字符串对象的内容。也就是对value变量的赋值操作是重写建立了一个对象。楼主可以测试经典的java String的代码：

String a = “a”；

String b = “a”;

String c = new String(“a”);

String d = new String(“a”);

System.out.println(a==b);

System.out.println(a==c);

System.out.println(b==c);

System.out.println(d==c);

再深入，Java没有C和C++的指针概念，可以粗暴的理解Java的引用是一种特殊的指针（实际上Java尽量把程序猿从指针中解放出来，或者说避免直接操作内存对象）。有一种不负责的说法：Java的基本类型传递传递的是值，也就是值的副本，引用类型传递的时引用。但是要注意String对象的内容不可变，而且传递的引用指向不可变。运行时Java的局部变量在栈空间中（线程私有），对象在堆内存中（线程公有），changeStr方法相当于在堆内存中又开辟了一块儿空间重写分配了一个对象，但是str没有指向这个新new出来的对象。而changeObjValue方法修改的pt指向的对象的内容也就是修改的是堆内存的数据，ref和pt指向的是一块儿内存。所以pt的对象数据会变化。

Java在参数中用“ | ”符号是什么原理？我说的不是指判断true和false的或，而是参数中的“ | ”

这叫掩码，在C编程中很常见。

SWT.MIN是一个整型常量，SWT.RESIZE也是一个整型常量，将它们按位或（|），就可以将两者合并成一个参数传递到方法中，方法中再按位与（）来解包传递的参数。

例：SWT.MIN是0010，SWT.RESIZE是0100，两者按位或的结果就是0110，将0110作为参数传递给方法。方法内部拿到参数后，只要将参数按位与SWT.MIN，如果得到的结果不是0，那么就说明传递了SWT.MIN；同理将参数按位与SWT.RESIZE，如果得到的结果不是0那么就说明传递了SWT.RESIZE。

java 中|| 和 && 这类的符号都表示什么？

和||是一种逻辑运算符，是逻辑与，当两个数都为真，则结果为真。||是逻辑或，两个数任意一个为真，则结果为真。

举个例子：

1、a b

当a、b都为真时，结果为真。有一个为假或者都为假时结果为假。

2、a || b

当a、b有一个为真时，结果为真。a、b都为假时结果为假。

扩展资料：

在java中还有其他的逻辑符号，比如：！、|、

“！”是非运算符号，比如a为真，则！a则为假。a如果为假，则！a为真。

而“|”也是逻辑或，“”也是逻辑与，但是他们与“||”和“”有些区别，区别如下：

“”与“|”无论第一个判断条件是否成立，逻辑运算符前后两个条件都会进行判断。

“”与“||”，前者第一个条件不成立，后面的条件均不进行判断，返回false；后者第一个条件成立，后面的条件均不进行判断,返回true。

原创文章，作者：小蓝，如若转载，请注明出处：https://www.506064.com/n/250739.html