阿药陪你学Java（第二讲）

于 2024-04-19 10:00:00 发布
阅读量788 收藏 13
点赞数 30
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scholar_yao/article/details/137942246
版权
本文详细介绍了Java中的各种运算符，包括算数运算符（加减乘除、取余），关系运算符（等于、不等于、大于、小于等），位运算符（按位与、或、异或、取反、左移、右移），逻辑运算符（与、或、非），赋值运算符（=、+=、-=等），以及条件运算符（?:）和instanceof用于类型检查。通过实例演示了这些运算符的用法和特性。
摘要由CSDN通过智能技术生成

第二讲：运算符

Java提供了一套丰富的运算符来帮助我们操纵变量。共8种，下面会分别进行介绍。

算数运算符

算数运算符和我们平时在数学中的作用一样。假设下表中A = 10，B = 20。

符号描述示例
+加法，符号两侧的数相加A + B = 30
-减法，符号两侧的数相减A - B = -10
*乘法，符号两侧的数相乘A * B = 200
/除法，符号两侧的数相除（注意：相除结果取商舍余）A / B = 0
%取余（取模），符号两侧的数相除（注意：相除结果取余不取商）A % B = 10
++自增，操作数的值加一A++ 或 ++A = 11
- -自减，操作数的值减一B-- 或 --B = 19

自增（++）和自减（–）运算符详解：

  1. 当运算符在操作数后面时，先使用操作数原值，然后再对操作数值加一或减一。
示例：
public class Demo {
	public static void main(String[] args) {
		int a = 10;
		int b = a++; // 运算符在操作数后面，先把a的值赋给b，然后再将a的值加一，a加一之后不会再次赋值给b。
		System.out.println("a的值为：" + a);
		System.out.println("b的值为：" + b);
		
		int c = 10;
		int d = c--; // 运算符在操作数后面，先把c的值赋给d，然后再将c的值减一，c减一之后不会再次赋值给d。
		System.out.println("c的值为：" + c);
		System.out.println("d的值为：" + d);
	}
}

输出：
a的值为：11
b的值为：10
c的值为：9
d的值为：10
  1. 当运算符在操作数前面时，先对操作数值加一或减一，然后使用操作数的值（此时使用的是加一或减一后的值）。
示例：
public class Demo {
	public static void main(String[] args) {
		int a = 10;
		int b = ++a; // 运算符在操作数前面，先对a的值加一，然后再将a加一后的值赋给b。
		System.out.println("a的值为：" + a);
		System.out.println("b的值为：" + b);
		
		int c = 10;
		int d = --c; // 运算符在操作数前面，先对c的值减一，然后再将c减一后的值赋给d。
		System.out.println("c的值为：" + c);
		System.out.println("d的值为：" + d);
	}
}

输出：
a的值为：11
b的值为：11
c的值为：9
d的值为：9

扩展：前缀运算过程拆分

int a = 3, c = 3;
int b = ++a; // 拆分运算过程为: a = a + 1 = 4; b = a = 4, 最后结果为b = 4,a = 4
int d = --c; // 拆分运算过程为: c = c - 1 = 2; d = c = 2, 最后结果为d = 2,c = 2

// 后缀运算过程拆分就留给给位小伙伴自己试一试络！！！

关系运算符

下表为Java中的关系运算符。假设下表中A = 10，B = 20。

符号描述示例
==判断两个操作数是否相等，相等则为真A == B 为假
!=判断两个操作数是否相等，不相等则为真A != B 为真
>判断左操作数是否大于右操作数，大于则为真A > B 为假
<判断左操作数是否小于右操作数，小于则为真A < B 为真
>=判断左操作数是否大于等于右操作数，大于等于则为真A >= B 为假
<=判断左操作数是否小于等于右操作数，小于等于则为真A <= B 为真
示例：
public class Demo {
	 public static void main(String[] args) {
         int a = 10;
         int b = 20;
         System.out.println("a == b = " + (a == b));
         System.out.println("a != b = " + (a != b));
         System.out.println("a > b = " + (a > b));
         System.out.println("a < b = " + (a < b));
         System.out.println("b >= a = " + (b >= a));
         System.out.println("b <= a = " + (b <= a));
	 }
}

输出：
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

位运算符

Java中的位运算符可以应用在所有整型和字符型中，包括byte，short，int，long，char。位运算符作用在所有位上，并且按位运算。假设下表中A = 60，B = 13。

符号描述示例
&如果相对应位都是1，则结果为1，否则为0A＆B 得到12，即0000 1100
|如果相对应位都是 0，则结果为 0，否则为 1A | B 得到61，即0011 0001
^如果相对应位值相同，则结果为0，否则为1A ^ B 得到49，即 0011 0001
~按位取反运算符翻转操作数的每一位，即0变成1，1变成0。~ A 得到-61，即1100 0011
<<按位左移运算符。左操作数按位左移右操作数指定的位数。A << 2 得到240，即 1111 0000
>>按位右移运算符。左操作数按位右移右操作数指定的位数。A >> 2 得到15即 1111
>>>按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。A>>>2 得到15即0000 1111
示例：
public class Demo {
	public static void main(String[] args) {
		 int a = 60; // 60 = 0011 1100 
         int b = 13; // 13 = 0000 1101
         int c = 0;
         c = a & b;  // 12 = 0000 1100
         System.out.println("a & b = " + c );
         c = a | b;  // 61 = 0011 1101
         System.out.println("a | b = " + c );
         c = a ^ b;  // 49 = 0011 0001
         System.out.println("a ^ b = " + c );
         c = ~a;     // -61 = 1100 0011
         System.out.println("~a = " + c );
         c = a << 2; // 240 = 1111 0000
         System.out.println("a << 2 = " + c );
         c = a >> 2; // 15 = 1111
         System.out.println("a >> 2  = " + c );
         c = a >>> 2; // 15 = 0000 1111
         System.out.println("a >>> 2 = " + c );
	}
}

输出：
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2  = 15
a >>> 2 = 15

逻辑运算符

下表是Java中的所有逻辑运算符。假设变量A = true，变量B = false。

符号描述示例
&&逻辑与运算符。两个操作数都为真，结果为真。A && B 为假
||逻辑或运算符。两个操作数有一个为真或两个都为真，结果为真。A || B 为真
!逻辑非运算符。反转操作数的逻辑；真反转为假，假反转为真。!A为假，!B为真
示例：
public class Demo {
	public static void main(String[] args) {
		 boolean a = true;
         boolean b = false;
         System.out.println("a && b = " + (a&&b));
         System.out.println("a || b = " + (a||b) );
         System.out.println("!(a && b) = " + !(a && b));
	}
}

输出：
a && b = false
a || b = true
!(a && b) = true

短路运算符详解：

使用逻辑运算符 && 时，只有两个条件均为true时结果为true，当第一个条件为false时，结果就只能是false，后面的条件无需判断。

示例：
public class Demo {
	public static void main(String[] args) {
		int a = 10;
		boolean res = (a < 1) && (++a < 20); // 当判断完(a < 1)为false后，不会在进行后续判断，也就不会执行++a
		System.out.println(res);
		System.out.println(a);
	}
}

输出：
false
10

使用逻辑运算符 || 时，只要两个条件有一个为true时结果为true，当第一个条件为true时，结果就一定为true，后面条件无需判断。

示例：
public class Demo {
	public static void main(String[] args) {
		int a = 10;
		boolean res = (a < 20) || (++a < 20); // 当判断完(a < 20)为true后，不会在进行后续判断，也就不会执行++a
		System.out.println(res);
		System.out.println(a);
	}
}

输出：
true
10

赋值运算符

符号描述示例
=将右操作数的值赋给左操作数A = B
+=将左操作数的值和右操作数的值相加的和赋给左操作数A += B 等价于 A = A + B
-=将左操作数的值和右操作数的值相减的差赋给左操作数A -= B 等价于 A = A - B
*=将左操作数的值和右操作数的值相乘的积赋给左操作数A *= B 等价于 A = A * B
/=将左操作数的值和右操作数的值相除的商赋给左操作数A /= B 等价于 A = A / B
%=将左操作数的值和右操作数的值**相除的模（余数）**赋给左操作数A %= B 等价于 A = A % B
<<=将左操作数的二进制位数向左移指定位数，移位结果赋给左操作数A <<= B 等价于 A = A << B
>>=将左操作数的二进制位数向右移指定位数，移位结果赋给左操作数A >>= B 等价于 A = A >> B
&=将左操作数的二进制位与右操作数的二进制位按位进行与运算，结果赋给左操作数A &= B 等价于 A = A & B
^=将左操作数的二进制位与右操作数的二进制位按位进行异或运算，结果赋给左操作数A ^= B 等价于 A = A ^ B
|=将左操作数的二进制位与右操作数的二进制位按位进行或运算，结果赋给左操作数A |= B 等价于 A = A | B

扩展：复合运算符中的秘密？

示例：
public class {
    public static void main(String[] args) {
        short a = 10;
        // a = a + 20; // 20默认是int类型，直接和short类型的a相加时会自动升级为int类型，所以赋值也必须时给一个int类型的变量
        int b = a + 20;
        System.out.println(b);
        a += 20; // 使用+=运算符运算时不会将a自动升级为int类型，而是将20降级为short类型，所以可以赋值给a
        System.out.println(a);
    }
}

输出：
30
30

条件运算符（ ? : ）

条件运算符（三元运算符），该运算符有3个操作数，需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

示例：
public class Demo {
   public static void main(String[] args) {
      int a , b;
      a = 10;
      // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
      b = (a == 1) ? 20 : 30;
      System.out.println( "Value of b is : " +  b );
      // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
      b = (a == 10) ? 20 : 30;
      System.out.println( "Value of b is : " + b );
   }
}

输出：
Value of b is : 30
Value of b is : 20

instanceof运算符

该运算符用于操作对象示例，检查该对象是否是一个特定类型（类类型或接口类型）。

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

示例：
String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

如果被比较的对象兼容于右侧类型，该运算符仍然返回true。

示例：
class Vehicle {}
public class Car extends Vehicle {
   public static void main(String[] args){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result);
   }
}

输出：
true
Coder_ayao
关注
  • 30
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值