Java之操作符学习

ゞ浴缸里的玫瑰 2022-02-09 10:29 296阅读 0赞

今天继续我的“java从入门到放弃”之路?，上次学了static关键字的作用，这次则是学习Java的操作符。第一次这么专心的学习基础知识(上次操作符的学习大概是在上大学的时候，还很无知，仅仅是听老师在讲些东西，具体讲的是什么，可能我还不是特别关心?)，但是打好坚实的基础，是能够继续下去的关键，所以我不想跳过这些内容。而且认真学习后才发现，Java里的操作符和C语言里的并不是完全相同，某些用法还是不一样的。

###### java中的操作符大致分为以下几类： ######

*  1.算术操作符：+、-、\*、/、%、++、–
 *  2.关系操作符：>、 >=、 <、 <=、 ==、 !=
 *  3.逻辑操作符：&&、 ||、 ！
 *  4.位操作符：&、 |、^、 ~、<<、 >>、 >>>
 *  5.赋值操作符：=、 -=、 +=、 \*=、 /=、 %=、 <<=、 >>=、 >>>==
 *  6.强制类型转换操作符：（类型）

###### 1.算术操作符 ######

Java里的算术操作符与其它语言里的算术操作符用法相同。对于整数除法则是直接去掉小数位，而不是四舍五入得到结果(这一点当然也和C语言的用法一致)。

代码举例：

import java.util.*;
    public class AriOpe
    {
        
        public static void main(String[] args)
        {
        
            Random ran = new Random(47);//生成一个产生随机数的对象
            int i1 = ran.nextInt(50) + 1;//生成一个0-50的随机数，+1是为了防止出现除1
            int i2 = ran.nextInt(50) + 1;
            int i3;
            System.out.println("i1 = " + i1 + " i2 = " + i2);
            i3 = i1 + i2;
            System.out.println("i1 + i2 = " + i3);
            i3 = i1 - i2;
            System.out.println("i1 - i2 = " + i3);
            i3 = i1 * i2;
            System.out.println("i1 * i2 = " + i3);
            i3 = i1 / i2;
            System.out.println("i1 / i2 = " + i3);
            i3 = i1 % i2;
            System.out.println("i1 % i2 = " + i3);
            float f1 = ran.nextFloat();
            float f2 = ran.nextFloat();
            float f3;
            System.out.println("f1 = " + f1 + " f2 = " + f2);
            f3 = f1 + f2;
            System.out.println("f1 + f2" + f3);
            f3 = f1 - f2;
            System.out.println("f1 - f2 = " + f3);
            f3 = f1 * f2;
            System.out.println("f1 * f2 = " + f3);
            f3 = f1 / f2;
            System.out.println("f1 / f2 = " + f3);
        }
    }

运行结果：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaTIwMTRsZWk_size_16_color_FFFFFF_t_70][]

###### 2.关系操作符 ######

关系操作符计算的是操作数的值之间的关系，产生的是一个布尔类型的结果。对于基本类型的数据来说，则是直接比较相应的值。但是对于对象来说，==和!=则是比较两个引用是否指向同一个对象，而要比较对象里面的内容则要使用equals()方法来比较。

代码示例：

public class Equals
    {
        
        String name;
        String says;
        public static void main(String[] args)
        {
        
            int i1 = 5;
            int i2 = 5;
            int i3 = 10;
            Integer n1 = new Integer(2);
            Integer n2 = new Integer(2);
            System.out.println("i1 = " + i1 + " i2 = " + i2 + " i3 = " + i3);
            System.out.println("i1 < i2 : " + (i1 < i2));
            System.out.println("i1 <= i2 : " + (i1 <= i2));
            System.out.println("i1 > i3 : " + (i1 > i3));
            System.out.println("n1 = " + n1 + " n2 = " + n2);
            System.out.println("n1 == n2 : " + (n1 == n2));
            System.out.println("n1 != n2 : " + (n1 != n2));
            System.out.println("n1.equals(n2) : " + n1.equals(n2));
            Equals e1 = new Equals();
            Equals e2 = new Equals();
            Equals e3 = new Equals();
            e1.name = "spot";
            e1.says = "Ruff";
            e2.name = "scruffy";
            e2.says = "Wurf";
            e3.name = "spot";
            e3.says = "Ruff";
            System.out.println("e1.name:" + e1.name + " e1.says:" + e1.says);
            System.out.println("e2.name:" + e2.name + " e2.says:" + e2.says);
            System.out.println("e1 == e2 : " + (e1 == e2));
            System.out.println("e1.equals(e2) : " + e1.equals(e2));
            System.out.println("e1 == e3 : " + (e1 == e3));
            System.out.println("e1.equals(e3) : " + e1.equals(e3));
        }
    }

运行结果：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaTIwMTRsZWk_size_16_color_FFFFFF_t_70 1][]  
  由于Integer为Java的内置类类型，具有equals()方法，所以进行equals比较的时候得到的是正确结果；而Equals是自己写的类，并且没有重写equals()方法，所以及时两个对象里面的内容完全一样的时候也不会得出true的结果。关于重写方法，后续会再接触到。

###### 3.逻辑操作符 ######

Java中的逻辑操作符与C语言里的逻辑操作符用法有较大的区别，Java中的逻辑操作符只能作用于布尔类型，而C语言里的逻辑操作符可以作用于整数。

代码示例：

import java.util.*;
    public class LogicOp
    {
        
        public static void main(String[] args)
        {
        
            Random ran = new Random(47);
            int i1 = ran.nextInt(50);
            int i2 = ran.nextInt(50);
            System.out.println("i1 = " + i1 + " i2 = " + i2);
            System.out.println("i1 > i2 is " + (i1 > i2));
            System.out.println("i1 > 10 is " + (i1 > 10));
            System.out.println("i2 > 10 is " + (i2 > 10));
            System.out.println("!(i2 > 10) is " + (!(i2 > 10)));
            System.out.println("i1 > 10 && i2 > 10 is " + ((i1 > 10) && (i2 > 10)));
            System.out.println("i1 > 10 || i2 > 10 is " + ((i1 > 10) || (i2 > 10)));
            //System.out.println("i1 && i1 > 10 is " + (i1 && (i1 > 10)));//错误，非布尔类型值不能出现在逻辑操作符两侧
            System.out.println("i1 > 10 && (!(i2 > 10)) is " + ((i1 > 10) && (!(i2 > 10))));
            System.out.println("i1 > 10 || (!(i2 > 10)) is " + ((i1 > 10) || (!(i2 > 10))));
        }
    }

运行结果：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaTIwMTRsZWk_size_16_color_FFFFFF_t_70 2][]  
  进行逻辑运算的时候可能会遇到短路的情况。比如（表达式1）&& （表达式2）当表达式1为false的时候，则表达式2是不会被计算的，因为&&运算符有一个false，则整个表达式的值即为false。同理，对于表达式：（表达式1）|| （表达式2）当表达式1为true的时候，则表达式2是不会被计算的，因为||运算符有一个true，则整个表达式的值即为false。

###### 4.位操作符 ######

说到位操作符，则先要提到数值在计算机中的表示形式。数值在计算机中有三种表示形式：原码、补码、反码，但是通常使用的是原码和补码。原码表示是把十进制数转换成二进制数的表示形式，对于正的数值，符号为为0，对于负数，符号为为1；反码是对原码的各个位取反(符号位保持不变)；补码则是对原码(除符号位)的各个位取反加一。

如-1的原码为：10000000,00000000,00000000,00000001，反码：11111111,11111111,11111111,11111110，补码：11111111，11111111，11111111，11111111。具体的关于原码、反码、补码的内容后续也会更新，或者可以找《计算机组成原理》这本书看一下。  
  位操作符的&类似于&&逻辑操作符，只是&是进行位运算，而&&是进行逻辑运算。如：1&1=1、1&0=0、0&0=0；1 | 1 = 1、1 | 0 = 1、0 | 0 = 0；1 ^ 1 = 0、1 ^ 0 = 1 、0 ^ 0 = 0；～1 = 0、～0 = 1。  
  移位操作符只能用来处理整数类型。左移操作符(<<)可以按照操作符右侧的值将左侧的操作数向左移动（在低位补0）；“有符号”右移操作符(>>)则按照操作符右侧的数将操作数向右移动，移动规则为正数在高位补0、负数在高位补1；Java中新加里一种无符号右移操作(>>>)，这种右移则是无论是正数还是负数，均在高位补0。  
  如果对char、byte、short类型的数进行移位操作，则在进行移位之前，它们会首先被转换为int类型，然后再进行处理，并且处理后得到的结果也是int类型。  
代码示例：

public class BitOperator
    {
        
        public static void main(String[] args)
        {
        
            int i1 = 0x5555;
            int i2 = 0xaaaa;
            System.out.println("i1:" + Integer.toBinaryString(i1));
            System.out.println("i2:" + Integer.toBinaryString(i2));
            System.out.println("i1 | i2 :" + Integer.toBinaryString(i1 | i2));
            System.out.println("i1&i2:" + Integer.toBinaryString(i1 & i2));
            System.out.println("i1 ^ i2:" + Integer.toBinaryString(i1 ^ i2));
            System.out.println("~i1:" + Integer.toBinaryString(~i1));
            System.out.println("i1:" + Integer.toBinaryString(i1));
            int i3 = 0xffff;
            int n = 0;
            System.out.println("i3:" + Integer.toBinaryString(i3));
            for(n = 0;n < 16;n++)
            {
        
                i3 >>= 1;
                System.out.println("i3 >> " + (n + 1) + " : " + Integer.toBinaryString(i3));
            }
            int i4 = 0xffffffff;
            System.out.println("i4:" + Integer.toBinaryString(i4));
            for(n = 0;n < 4;n++)
            {
        
                i4 <<= 1;
                System.out.println("i4 << " + (n + 1) + Integer.toBinaryString(i4));
            }
            n = 0;
            while(0 != i4)
            {
        
                n++;
                i4 >>>= 1;
                System.out.println("i4 >>> " + n + ":" + Integer.toBinaryString(i4));
            }
            char ch1 = 'a';
            System.out.println("ch1 :" + Integer.toBinaryString(ch1));
            int i = -1;
            System.out.println(Integer.toBinaryString(i));
            i >>>= 10;
            System.out.println(Integer.toBinaryString(i));
            byte b = -1;
            System.out.println(Integer.toBinaryString(b));
        }
    }

运行结果如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaTIwMTRsZWk_size_16_color_FFFFFF_t_70 3][]  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaTIwMTRsZWk_size_16_color_FFFFFF_t_70 4][]  
  由于打印内容较多，所以截了两次屏幕。示例包含里所有的位操作符。

###### 5.赋值操作符 ######

赋值操作符的右边可以是常量、表达式、变量，但是赋值操作符的左边只能是变量。 赋值操作符可以用于

*  基本类型
 *  对象

基本数据类型：  
当“=”用于基本数据类型时，功能就是给左边的变量赋以右边的值。但是对于+=这种类型的赋值，其操作符还具有强制类型转换的功能。  
示例代码：

public class AriOpe
    {
        
        public static void main(String[] args)
        {
        
            short s = 3;
            System.out.println("s = " + s);
            //s = s + 3;//错误，因为3默认是int类型，进行计算后，结果位int类型的数据，无法赋值给short类型的变量
            s = (short)(s + 3);
            System.out.println("s:(short)(s + 3) = " + s);
            s += 3;
            System.out.println("s:(s += 3) = " + s);
        }
    }

运行结果为：  
![20190502150217882.png][]  
ps:除了+=这种类型的赋值运算符具有自动进行强制类型转换的功能外，++、–也具有自动进行强制类型转换的功能。在本文最后进行举例说明。  
对象类型：  
  对对象进行操作时，我们操作的其实是该对象的引用，所以如果将“一个对象赋值给另一个对象”，其实是将一个对象的引用从一个地方复制到另一个地方。例如：e1 = e2，则将e1和e2都指向里原本只有e2指向的那个对象。这就是对象的别名问题。  
代码示例：

public class Equals
    {
        
        String name;
        String says;
        public static void main(String[] args)
        {
        
            Equals e1 = new Equals();
            Equals e2 = new Equals();
            Equals e3 = new Equals();
            e1.name = "spot";
            e1.says = "Ruff";
            e2.name = "scruffy";
            e2.says = "Wurf";
            e3.name = "spot";
            e3.says = "Ruff";
            System.out.println("e1.name:" + e1.name + " e1.says:" + e1.says);
            System.out.println("e2.name:" + e2.name + " e2.says:" + e2.says);
            System.out.println("e3.name:" + e3.name + " e3.says:" + e3.says);
            e3 = e2;
            System.out.println("After e3 = e2 :");
            System.out.println("e3.name:" + e3.name + " e3.says:" + e3.says);
            e2.name = "test";
            System.out.println("After e2.name = \"test\"");
            System.out.println("e2.name:" + e2.name + " e2.says:" + e2.says);
            System.out.println("e3.name:" + e3.name + " e3.says:" + e3.says);
            e3.says = "hello";
            System.out.println("After e3.says = \"hello\"");
            System.out.println("e2.name:" + e2.name + " e2.says:" + e2.says);
            System.out.println("e3.name:" + e3.name + " e3.says:" + e3.says);
        }
    }

运行结果为：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaTIwMTRsZWk_size_16_color_FFFFFF_t_70 5][]

###### 6.强制类型转换操作符 ######

Java允许把任何基本数据类型转换成别的基本数据类型（布尔类型除外）。如果要执行窄化转换（将能容纳信息更多的一种数据类型转换成能容纳信息更少的数据类型），编译器会要求进行强制类型转换；而对于扩展转换，则不必进行强制类型转换。如把浮点数值赋值给整数，则要用到窄化转换转换方式为直接截断；若想要进行四舍五入，则需要用到java.lang.Math里的round()函数。 示例代码：

import java.util.*;
    public class AriOpe
    {
        
        public static void main(String[] args)
        {
        
            Random ran = new Random(47);
            int i1 = ran.nextInt(50) + 1;
            int i2 = ran.nextInt(50) + 1;
            int i3,i4;
            float f1 = ran.nextFloat();
            float f2 = ran.nextFloat();
            float f3;
            System.out.println("f1 = " + f1 + " f2 = " + f2);
            f3 = f1 + f2;
            System.out.println("f1 + f2" + f3);
            f3 = f1 - f2;
            System.out.println("f1 - f2 = " + f3);
            f3 = f1 * f2;
            System.out.println("f1 * f2 = " + f3);
            f3 = f1 / f2;
            System.out.println("f1 / f2 = " + f3);
            //i3 = f1 - i1;//编译错误，提示不兼容，不能从float到int类型的转换
            i3 = (int)(f1 - i1);
            i4 = Math.round(f1 - i1);
            System.out.println("(int)(f1 - i1) = " + i3 + " Math.round(f1 - i1) = " + i4);
            f3 = f1 - i1;
            System.out.println("f1 - i1 = " + f3);
            //i3 = f1 + i1;//编译错误，提示不兼容，不能从float到int类型的转换
            i3 = (int)(i1 + f1);
            i4 = Math.round(i1 + f1);
            System.out.println("(int)(f1 + i1) = " + i3 + " Math.round(i1 + f1) = " + i4);
            f3 = i1 + f1;
            System.out.println("f1 + i1 = " + f3);
            //i3 = f1 * i1;//编译错误，提示不兼容，不能从float到int类型的转换
            i3 = (int)(i1 * f1);
            i4 = Math.round(i1 * f1);
            System.out.println("(int)(f1 * i1) = " + i3 + " Math.round(i1 * f1) = " + i4);
            f3 = i1 * f1;
            System.out.println("f1 * i1 = " + f3);
            //i3 = f1 / i1;//编译错误，提示不兼容，不能从float到int类型的转换
            i3 = (int)f1;
            i4 = Math.round(f1);
            System.out.println("(int)f1 = " + i3 + " Math.round(f1) = " + i4);
            f3 = i2;
            System.out.println("f3 = " + f3);
            short s = 3;
            System.out.println("s = " + s);
            s++;
            System.out.println("s++ = " + s);
            //s = s + 3;//错误，因为3默认是int类型，进行计算后，结果位int类型的数据，无法赋值给short类型的变量
            s = (short)(s + 3);
            System.out.println("s:(short)(s + 3) = " + s);
            s += 3;
            System.out.println("s:(s += 3) = " + s);
        }
    }

运行结果：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaTIwMTRsZWk_size_16_color_FFFFFF_t_70 6][]  
  今天的“Java从入门到放弃”?，虽然内容不是很多，都是基础知识，但是有些知识还是让我觉得收获颇多。首先是关于逻辑操作符的用法，只能操作符两侧只能是布尔类型的数据，而不是类似C语言里可以是整数类型的数。还有就是位操作符，尤其是在进行了实际的操作之后，才会印象深刻，最后是赋值操作符，无论是自动进行强制类型转换还是对象的别名问题，对于我来说都是新知识点(因为以前总是模棱两可)，现在可以说自己清晰的掌握了这个知识点。总之，今天收获很大。希望“放弃之路”不要那么短！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaTIwMTRsZWk_size_16_color_FFFFFF_t_70]: /images/20220206/4e5bfa1a966a45979d3f5b60c8382794.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaTIwMTRsZWk_size_16_color_FFFFFF_t_70 1]: /images/20220206/748172466e0346059a8644f24f1552e6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaTIwMTRsZWk_size_16_color_FFFFFF_t_70 2]: /images/20220206/308c53c1ee184906b1227182fd0aa85f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaTIwMTRsZWk_size_16_color_FFFFFF_t_70 3]: /images/20220206/f954e94f4725488abeb4bd794dafa7dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaTIwMTRsZWk_size_16_color_FFFFFF_t_70 4]: /images/20220206/af0918cdf8bf47f4a35bb14c943e30d0.png
[20190502150217882.png]: /images/20220206/9db84f158e1e4b22b90050305cda26dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaTIwMTRsZWk_size_16_color_FFFFFF_t_70 5]: /images/20220206/5dc7f7c0325145228df32af02931e713.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaTIwMTRsZWk_size_16_color_FFFFFF_t_70 6]: /images/20220206/ca4ebd3914a8443dbf21a0a67d59c842.png