87-Java逻辑与运算符.md

注意

本博文仅供学术研究和交流参考，严禁将其用于商业用途。如因违规使用产生的任何法律问题，使用者需自行负责。

• 运算符（操作符）

  • 是一种特殊的符号，用以表示数据的运算、赋值和比较

  • 运算符的种类：

    • 算术运算符： +、﹣、*、/、%、++、 --

    • 赋值运算符：=、+=、﹣=、*=、/=、%=

    • 比较运算符：>、<、>=、 <=、= =、!=、instanceof

    • 逻辑运算符：!、&&、||

    • 位运算符： &、|、^ 、 ~、>>、<<、>>>

    • 条件运算符： ?：条件运算符很独特，因为它是用三个操作数组成表达式的三元运算符。它可以替代某种类型的 if-else 语句

• 算术运算符

符号	含义	备注
+	加法
-	减法
*	乘法
/	除法	若是两个整数相除，只保留整数部分；
%	取余	被模数为正数结果都为正，被模数为负数结果都为负
++	自增	++变量名：变量在参与其他操作前先将自己加1变量名++：先用原来的值参与其他操作后，再将自己加1
--	自减	算法同++
+	字符串连接	当操作数中只要有一个是String类型，系统会自动将另一个操作数转换成字符串类型，然后进行连接

• 算术运算符

  • 自增运算: ++, --

    • i++, 后++, 先将i的值作为整个表达的值, 然后将i增加1.

    • ++i, 先++, 先将i增加1, 然后将i的值作为整个表达的值.

如: 
int a = 1; int b=1;
b = a++;// 
1 a++表达式的值是1
2 执行a=a+1
3 执行赋值运算, 将表达式的值1赋值给b, 即b=1

• 赋值运算符

符号	含义	备注
=	x=y;	把变量y的值赋给x
+=	x+=y;	x=x+y;
-=	x-=y;	x=x-y;
*=	x*=y;	x=x*y;
/=	x/=y;	x=x/y;

• 关系运算符（比较运算符）

符号	含义	备注
==	相等于	注意不要误写成 “ = ”
!=	不等于
<	小于
>	大于
<=	小于等于（不大于）
>=	大于等于（不小于）

• 逻辑运算符（布尔运算符）

  • 逻辑运算符两端的操作数必须是布尔类型的值

符号	含义	备注
&&	逻辑与	相当于“且”，如果用&&连接表达式时，如果左面的表达式为false，则将不会计算其右边的表达式
||	逻辑或	相当于“或”，如果左面的表达式为true，则将不会计算其右边的表达式
!	逻辑非

• 位运算(只对byte、short、char、int、long有效)
  • 左移和右移运算相当于实现整数乘以或除以2的n次方

符号	含义	备注
&	按位“与”	只有参加运算的两位都为1，&运算的结果才为1，否则为0
|	按位“或”	只有参加运算的两位都为0，
^	异或	只有参加运算的两位不同，^运算的结果才为1，否则为0
<<	左移	a<<b,将a的二进制数据左移b位，右边移空的部分补0
>>	右移	a>>b,将a的二进制数据右移b位，如果最高位是0，则左边移空的部分补0，如果最高位是1，则左边移空的部分补1
>>>	无符号右移	不管最高位是0或1，左边移空部分都补0

• 逻辑与或同按位与或是有一定区别的：

  • 相同点是：都能参与逻辑运算，按位与或完全可以代替逻辑与或；

  • 区别是：按位与或可以参与位运算，逻辑与或只能参与逻辑运算，逻辑与或可以“短路”，按位与或不能“短路”。

• 短路运算

  • 作用运算符：逻辑与&&，逻辑或||

如（1）：逻辑表达式：a>b && c>d 假设a>b 为false，c>d为true，那么整个表达式结果为false; 假设a>b 为false，c>d为false，那么整个表达式结果还为false; 可见，a>b的结果已经决定了整个表达式的结果，而后面的c>d并不影响表达式的结果，可以说后半部分被“短路”了。 如（2）：逻辑表达式： a>b || c>d 假设a>b 为true，那么后半部分表达式将被“短路”

public class LogicDemo {
  public static void main(String[] args) {
    int i = 1;
    boolean b = i!=1 && (i++)==2;//短路与, i++不执行
    System.out.println(b);//false
    System.out.println(i);//1
    b = i!=1 & (i++)==2; //非短路运算, i++执行
    System.out.println(b);//false
    System.out.println(i);//2
    b = i==2 || (i++)==2;//短路或. i++不执行
    System.out.println(b);//true
    System.out.println(i);//2
    //自己演示非短路 "|"...
  }
}

• 三元运算符

  • 所谓三元运算符，是对三个表达式进行的集中比较，表达式1的结果为true时，就为第二个表达式，如果为false时，就为第三个表达式。语法是：

  • 表达式1？表达式2：表达式3

  • 通过下面代码说明三元运算符。

public class HelloWorld13
{
	public static void main(String args[])
	{	
		//4 < 3表达式的结果为true和false的其中一个。
		boolean n = (4 < 3) ? true : false;
		//打印并显示结果
		System.out.println(n);
	}
}

• 运算符的优先级

  • 按操作数多少划分

    • 一元操作符 > 二元操作符 > 三元操作符

  • 按运算类型划分

    • 算术运算符 > 关系运算符 > 逻辑运算符 > 赋值运算符

  • 尽量多的使用括号

    • 括号优先级别最高

表达式通常由多个运算符组成。优先级的规则决定每个运算符在任何给定表达式中的计算顺序

顺序	运算符
1.	括号
2.	一元运算符，如 -、++、- -和 !
3.	算术运算符，如 *、/、%、+ 和 -
4.	关系运算符，如 >、>=、<、<=、== 和 !=
5.	逻辑运算符，如 &、^、|、&&、||
6.	条件运算符和赋值运算符，如 ? ：、=、*=、/=、+= 和 -=

package net.tencent.demo.test;

public class Test位运算符 {

	public static void main(String[] args) {

		/**
		 * 位运算符：&、|、^、~、>>、<<、>>>
		 */
		
		// &：逻辑与运算符（只有参加运算的两位都为1，&运算的结果才为1，否则为0）
		
		int a = 3;
		int b = 2;
		//1.把a和b转换成二进制;
		//a: 11
		//b: 10
		//a&b:10
		System.out.println(a & b);//2
		
		int c = 4;//100
		int d = 6;//110
		System.out.println(c & d);//4
	}
}

//|:逻辑或运算符（只有参加运算的两位都为0，|运算的结果才为0，否则为1)
	int e = 5;//101
	int f = 7;//111
				//111
	System.out.println(e|f);

/**
* ^异或运算符
* 只有参加运算的两位不同，^运算的结果才为1，否则为0
*/
int g = 4;//0100
int h = 8;//1000
		  //1100
System.out.println(g^h);//12

int p = 36;
int k = 2;
/**
* p >> 2:右移缩小，移多少位，就除以2的多少次幂
* 36：  0010 0100
* >>2:      1001
*/
/**
* k<<3：左移扩大，移多少位，就乘以2的多少次幂
* 2:   0000 0010
* <<3: 0001 0000
*/
System.out.println(p >> 2);//36/2的2次幂=36/4=9
System.out.println(k << 3);//2*2的3次幂=2*8=16

package net.tencent.demo.test;

public class Test算术运算符 {

	public static void main(String[] args) {

		//算术运算符： +、﹣、*、/、%、++、 --
		
		//单目运算符： ++ --
		
		int a = 10;
		
		a++;//让a自增 1
		
		System.out.println("a: " + a);//11
		
		a--;
		
		System.out.println("a: " + a);//10
		
		int b = a++;//自增有两种情况:一种是前自增(++a)，先加1，后赋值，一种是后自增(a++)，先赋值，后加1
		

		System.out.println("b: " + b);//10
		
		int c = ++a;
		System.out.println("c: "+c);//12
		
		int d = 100;
		int e = d--;
		
		System.out.println("e: " + e);//e:100
		
		System.out.println("d: " + d);//99
		
		int f = --d;
		System.out.println("d: " + d);//98
		System.out.println("f: " + f);//98
		
	}

}

int p = 100;
int h = 20;
System.out.println(p + h);//120
System.out.println(p - h);//80
System.out.println(p * h);//5
System.out.println(p / h);//2000
System.out.println(p % h);//0

int k = 12345;
//需求：如何求出k数字各个数位上数字的和？
//k%10000 = 2345
//k/10000 = 1
int k_w = k/10000;
int k_k = k % 10000 / 1000;
int k_b = k % 1000 / 100;
int k_s = k % 100 / 10;
int k_g = k % 10;

System.out.println(k_w + k_k + k_b + k_s + k_g);

package net.tencent.demo.test;

public class Test赋值运算符 {

	public static void main(String[] args) {
     
		//赋值运算符：=、+=、﹣=、*=、/=、%=
		int a = 2;
		int b = 1;
		b += a;//给b重新赋值 b = b+a;
		int c = 2;
		c -= a;//c = c-a
		int d = 3;
		d *= a;//d = d*a
		int e = 4;
		e /= a;//e = e/a
		int f = 10;
		f %= a;//f = f%a
		
		/**
		 * 注意：以后这种写法比较多： b += a; 这种写法比较少 b = b + a;
		 * 原因：计算机执行第一种写法速度快;
		 */
	}
}

package net.tencent.demo.test;

public class Test比较运算符 {

	public static void main(String[] args) {

		//比较运算符：>、<、>=、 <=、= =、!=、instanceof
		
		//为了控制程序的运行，在代码中经常使用比较运算符

		int rows = 2;
		
		if(rows == 2) {
			System.out.println("支付成功");
		}else {
			System.out.println("支付失败");
		}
	}
}

instanceof运算符

package net.tencent.demo.test;

/**
 * 动物类
* <p>Title: Animal</p>  
* <p>Description: </p>  
* @author xianxian 
* @date 2019年7月2日
 */
public class Animal {

	//这是一个构造方法
	public Animal()
	{
		
	}
	
	private int age;
	private String name;
	private double weight;
	private String color;
	//....
	public void walk()
	{
		System.out.println(name + "is walking");
	}
	
	public void sleep()
	{
		System.out.println(name + "is sleeping");
	}
	
	public void eat()
	{
		System.out.println(name + "is eating");
	}
}

package net.tencent.demo.test;

public class Test比较运算符 {

	public static void main(String[] args) {
		//instanceof：判断某个对象是否是某个类的实例
		//new Test比较运算符();//当前类实例化
		//实例化一个对象
		Animal cat = new Animal();//Animal()这是一个构造方法，
		//只要是new的对象都在堆区，只要是声明一个变量就一定在栈区
		System.out.println(cat instanceof Animal);//cat这个变量是Animal类型的一个对象吗？---> true
		//System.out.println(cat instanceof Student);//因为不是Student类型的对象，所以代码根本不给 过
	}
}

逻辑运算符

package net.tencent.demo.test;

public class Test逻辑运算符 {

	public static void main(String[] args) {

		// ！ && ||
		// !:该操作符后面跟的是boolean类型的数据，对该数据取反
		boolean result = false;
		int a = 1;
		if(!result)
		{
			System.out.println("1");
		}else {
			System.out.println("2");
		}
		
		//&&：并且的意思 ，只有两个表达式都为真，才返回真
		
		int money = 200000;
		boolean haveHouse = true;
		if(haveHouse && money > 100000) {
			System.out.println("同意结婚");
		}else {
			System.out.println("不同意结婚");
		}
		
	
		//||:或者的意思，两个表达式有一个为真那么就返回真
		//这个女孩子特别贤惠：有房子可以结婚，有一点钱也可以结婚
		if(haveHouse || (money > 10000)) {
			System.out.println("同意结婚");
		}else {
			System.out.println("不同意结婚");
		}
		
		
		int y = 100;
		int x = 200;
		
		if((y++ > 1) || (x++ > 200)) {
			System.out.println("大于200");
		}else {
			System.out.println("没有大于200");
		}
		
		System.out.println("x: " + x);
		/*
		 * && || 都是短路运算符
		 * 相当于“且”，如果用&&连接表达式时，如果左面的表达式为false，则将不会计算其右边的表达式
		 * 相当于“或”，如果左面的表达式为true，则将不会计算其右边的表达式
		 */
	}

}

三元运算符

package net.tencent.demo.test;

public class Test三元运算符 {

	public static void main(String[] args) {

		//需求：服务器代码接收性别是男，希望转换成数字1，接收性别是女，希望转换成数字0
		
		String sex = "男";
		
		int s = 0;//把s变量初始化为0，不是最终结果
		
		if(sex.equals("男")) {
			s = 1;
		}else {
			s = 0;
		}
		System.out.println("性别： " + s);
		
		//那个需求有没有更好的实现方式呢？
		/**
		 * 三元表达式：
		 * 1、语法：表达式一？表达式一：表达式三
		 * 2、替换if--else语句
		 * 3、常用来做赋值操作
		 */
		int result = sex.equals("男") ? 1 : 0;
		System.out.println("性别： " + result);
	}

}

扩展知识

HTTP状态码-百度百科

HTTP状态码-菜鸟教程

---

分割线

---

相关信息

以上就是我关于 Java逻辑与运算符 知识点的整理与总结的全部内容，另附源码