Java基础：Java运算符

爱被打了一巴掌 2024-03-31 11:18 71阅读 0赞

#### 文章目录 ####

*   *  一、基本运算符
     *   *  1.算数运算符：
         *  2.赋值运算符：
         *  3.自增自减运算符：
         *  4.关系运算符：
         *  5.逻辑运算符：
         *  6.短路逻辑运算符：
         *  7.三目运算符
         *  8.运算符优先级
         *  9.instanceof 运算符
         *  10.移位运算符

> 磨墨为铁未曾试，始知学书费苦辞。

### 一、基本运算符 ###

#### 1.算数运算符： ####

\+（加）、-（减）、\*（乘）、/（除）、%（取余）

注意：

/*char类型参与算术运算，使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值：
    ‘a’ – 97 a-z是连续的，所以’b’对应的数值是98，'c’是99，依次递加
    ‘A’ – 65 A-Z是连续的，所以’B’对应的数值是66，'C’是67，依次递加
    ‘0’ – 48 0-9是连续的，所以’1’对应的数值是49，'2’是50，依次递加
    */
     // 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少
    char ch1 = 'a';
    System.out.println(ch1 + 1); // 输出98，97 + 1 = 98
    char ch2 = 'A';
    System.out.println(ch2 + 1); // 输出66，65 + 1 = 66
    char ch3 = '0';
    System.out.println(ch3 + 1); // 输出49，48 + 1 = 49
    byte b1 = 10;
    byte b2 = 20;
    // byte b3 = b1 + b2; // 该行报错，因为byte类型参与算术运算会自动提示为int，int赋值给byte可能损失精度
    int i3 = b1 + b2; // 应该使用int接收
    byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型
    //不会报错
    int num1 = 10;
    double num2 = 20.0;
    double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型
    //当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。
    System.out.println("itheima"+ 666); // 输出：itheima666

#### 2.赋值运算符： ####

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>作用</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>=</td> 
   <td>赋值</td> 
   <td>a=1,把1赋值给变量a</td> 
  </tr> 
  <tr> 
   <td>+=</td> 
   <td>加后赋值</td> 
   <td>a+=1,a+1赋值给变量a</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>减后赋值</td> 
   <td>a-=1,a-1赋值给变量a</td> 
  </tr> 
  <tr> 
   <td>*=</td> 
   <td>乘后赋值</td> 
   <td>a*=1,a × 1 赋值给变量a</td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>除后赋值</td> 
   <td>a/=1,a / 1 赋值给变量a</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>取余后赋值</td> 
   <td>a%=1,a 除以1取余数赋值给a</td> 
  </tr> 
 </tbody> 
</table>

short s = 1;
    s = s + 1; // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度
    s += 1; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);

#### 3.自增自减运算符： ####

int i = 10;
    i++; // 单独使用
    System.out.println("i:" + i); // i:11
    int j = 10;
    ++j; // 单独使用
    System.out.println("j:" + j); // j:11
    int x = 10;
    int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
    System.out.println("x:" + x + ", y:" + y); // x:11，y:10
    int m = 10;
    int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
    System.out.println("m:" + m + ", m:" + m); // m:11，m:11

#### 4.关系运算符： ####

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>==</td> 
   <td>a==b,判断a和b的值是否相等，成立为true，不成立为false。</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>a!=b,判断a和b的值是否不相等，成立为true，不成立为false。</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>a&gt;b,判断a是否大于b，成立为true，不成立为false。</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>a&lt;b,判断a是否小于b，成立为true，不成立为false。</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>a&gt;=b,判断a是否大于并且等于b，成立为true，不成立为false。</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>a&lt;=b,判断a是否小于并且等于b，成立为true，不成立为false。</td> 
  </tr> 
 </tbody> 
</table>

注意：

==：等于号，分下面两种情况：
    - 基本类型：比较的是变量值(栈中的值) 是否相同(Integer类型缓存范围是-128到127)。
    - 引用类型：比较的是引用地址(堆中内存对象的地址) 是否相同。

#### 5.逻辑运算符： ####

a和b都是一个表达式。

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>作用</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&amp;</td> 
   <td>逻辑与</td> 
   <td>a&amp;b,a和b都为true，结果才为true，否则false</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>逻辑或</td> 
   <td>a|b,a和b都为false，结果才为false，否则true</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>逻辑异或</td> 
   <td>a^b, a和b结果不同为true，相同就为false</td> 
  </tr> 
  <tr> 
   <td>!</td> 
   <td>逻辑非</td> 
   <td>a&amp;b,a和b都为true，结果才为true，否则false</td> 
  </tr> 
 </tbody> 
</table>

#### 6.短路逻辑运算符： ####

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>作用</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&amp;&amp;</td> 
   <td>短路与</td> 
   <td>作用与&amp;相同，但是有短路效果,如果左边为假，右边不执行。</td> 
  </tr> 
  <tr> 
   <td>||</td> 
   <td>短路或</td> 
   <td>作用与|相同，但是有短路效果,如果左边为真，右边不执行。</td> 
  </tr> 
 </tbody> 
</table>

#### 7.三目运算符 ####

语法： 关系表达式 ? 表达式1 : 表达式2;

int a = 10;
    int b = 20;
    int c = a > b ? a : b; // 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值

#### 8.运算符优先级 ####

<table> 
 <thead> 
  <tr> 
   <th>优先级</th> 
   <th>运算符</th> 
   <th>结核性</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>()、[]</td> 
   <td>从左向右</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>！、~、++、–</td> 
   <td>从右向左</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>*、/、%</td> 
   <td>从左向右</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>+、-</td> 
   <td>从左向右</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>&lt;&lt;、&gt;&gt;、&gt;&gt;&gt;</td> 
   <td>从左向右</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>&lt;、&lt;=、&gt;、&gt;=、instanceof</td> 
   <td>从左向右</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>==、!=</td> 
   <td>从左向右</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>&amp;</td> 
   <td>从左向右</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>^</td> 
   <td>从左向右</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>|</td> 
   <td>从左向右</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>&amp;&amp;</td> 
   <td>从左向右</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>||</td> 
   <td>从左向右</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>? :</td> 
   <td>从左向右</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td>=、+=、-=、*=、/=、%=、^=、~=、&lt;&lt;=、&gt;&gt;=、&gt;&gt;&gt;=</td> 
   <td>=从右向左</td> 
  </tr> 
 </tbody> 
</table>

#### 9.instanceof 运算符 ####

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

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);
       }
    }

#### 10.移位运算符 ####

Java 中有三种移位运算符：

*  `<<` :左移运算符，向左移若干位，高位丢弃，低位补零。x << 1,相当于 x 乘以 2(不溢出的情况下)。
 *  `>>` :带符号右移，向右移若干位，高位补符号位，低位丢弃。正数高位补 0,负数高位补 1。x >> 1,相当于 x 除以 2。
 *  `>>>`:无符号右移，忽略符号位，空位都以 0 补齐。

由于 double，float 在二进制中的表现比较特殊，因此不能来进行移位操作。

移位操作符实际上支持的类型只有int和long，编译器在对short、byte、char类型进行移位前，都会将其转换为int类型再操作。  
如果移位的位数超过数值所占有的位数会怎样？

int i = -1;
    System.out.println("初始数据：" + i);
    System.out.println("初始数据对应的二进制字符串：" + Integer.toBinaryString(i));
    i <<= 10;
    System.out.println("左移 10 位后的数据 " + i);
    System.out.println("左移 10 位后的数据对应的二进制字符 " + Integer.toBinaryString(i));

当 int 类型左移/右移位数大于等于 32 位操作时，会先求余（%）后再进行左移/右移操作。也就是说左移/右移 32 位相当于不进行移位操作（32%32=0），左移/右移 42 位相当于左移/右移 10 位（42%32=10）。当 long 类型进行左移/右移操作时，由于 long 对应的二进制是 64 位，因此求余操作的基数也变成了 64。

也就是说：x<<42等同于x<<10，x>>42等同于x>>10，x >>>42等同于x >>> 10。

初始数据：-1
    初始数据对应的二进制字符串：11111111111111111111111111111111
    左移 10 位后的数据 -1024
    左移 10 位后的数据对应的二进制字符 11111111111111111111110000000000