WHCSRL 技术网

【JavaSE】 - 运算符

🐱‍🏍系列文章目录

哈喽大家好,我是Aaron,这篇文章将详细介绍在JavaSE中可能用到的运算符,本文将收录于JavaSE专栏中,该专栏将记录JavaSE中的所有语法,有兴趣可以收藏本专栏学习哦~
目前本专栏收集文章有:

  1. 😑Java基础语法 - Java数据类型
  2. 🎨 【初识Java】开发环境安装 - Java简介以及环境搭建

请添加图片描述

下面正文开始。🏆🏆

🥛文章前言

学习任何一门语言,都少不了运算,而运算就需要运算符。

按照博主的理解,在Java中,可以将运算符分为以下几类:

  1. 算数运算符
  2. 逻辑运算符
  3. 位运算符
  4. 条件运算符

下面本文将围绕这几种运算符展开介绍。


🦝算数运算符

算数运算符中分为不同的几种算数运算符:

  1. 基本算数运算符
  2. 增量算数运算符(复合运算符)
  3. 自增/自减运算符

下面将逐一介绍~


🤢基本算数运算符

和C语言类似,基本算数运算符分为+,-,*,/,%%%%%%%%%%%%%%%%。

接下来一一介绍:

加,减,乘比较简单,没有什么需要注意的点,所以简单用几个代码示例演示:

'+'运算符

代码示例:

public class Operator {

    public static void main(String[] args) {

        int a = 10;
        int b = 20;
        System.out.println(a+b);

    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

运行结果:

运行结果

'-'运算符

代码示例:

public class Operator {

    public static void main(String[] args) {

        int a = 10;
        int b = 5;
        System.out.println(a - b);

    }

}  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

运行结果:

运行结果

'*'运算符

代码示例:

public class Operator {

    public static void main(String[] args) {

        int a = 10;
        int b = 5;
        System.out.println(a*b);

    }

}  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

运行结果:

运行结果
以上就是+,-,*法的基本用法和示例,接下来详细介绍除法和取余运算符。

'/'运算符

在Java中,使用’/'运算符的时候要注意以下几点:

  1. 除数不能为0。

这在我们的没有印象当中应该是理所当然的,但在C语言中,除数作0是不会报错的,只会给出warning(警告),但在Java中会直接抛出异常,在编译阶段就直接报错。

例如:

public class Operator {

    public static void main(String[] args) {

        int a = 10;
        int b = 0;
        System.out.println(a/b);

    }

}   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

抛出异常:

异常抛出

  1. 整型 / 整型的结果只能是整型。

也就意味着,就算我们用浮点型的变量接收整型 / 整型的结果,但运算的结果依然会是整型。

public class Operator {

    public static void main(String[] args) {

        int a = 10;
        int b = 3;
        double c = a / b;
        System.out.println(c);

    }

}  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

运行结果:

运行结果

'%%%%%%%%%%%%%%%%'运算符

取余运算符(%%%%%%%%%%%%%%%%),也被称为取模运算符,但和C语言中的使用不同,在C语言中,取模运算只能是整型之间的运算,但在Java中引入了浮点数的取模运算以及负数的取模运算

下面介绍浮点数的取模运算和负数的取模运算。

  1. 浮点数取模运算。

浮点数的取模运算可以是:

  • 浮点数 %%%%%%%%%%%%%%%% 浮点数,
  • 整数 %%%%%%%%%%%%%%%% 浮点数
  • 浮点数 %%%%%%%%%%%%%%%% 整数

下面为代码示例:

public class Operator {

    public static void main(String[] args) {

        double a = 12.5;
        double b = 3.5;
        System.out.println(a%%%%%%%%%%%%%%%%b);

        int x = 10;
        double y = 3.5;
        System.out.println(x%%%%%%%%%%%%%%%%y);

        double m = 10.5;
        int n = 4;
        System.out.println(m%%%%%%%%%%%%%%%%n);

    }

}   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

运行结果:
运行结果

  1. 负数取模运算

在Java中,甚至可以对负数进行取模运算~

代码示例:

public class Operator {

    public static void main(String[] args) {

        int a = 10;
        int b = -3;
        System.out.println(a%%%%%%%%%%%%%%%%b);

    }

}  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

运行结果:

运行结果

这里给大家展示以下负数取模的运算过程~

运算过程
小学数学嗷~~


🍚增量算数运算符

增量算数运算符,又称复合运算符。

+=,-=,*=,/=。%%%%%%%%%%%%%%%%=,>>=等等

其实增量运算符非常好理解:

比如:

a += 1;
  • 1

完全等价于

a = a + 1;
  • 1

其他的类似。

不过有一点需要注意~~

如果变量a是整型,让a加上一个浮点数再赋给a是错误的运算,具体再本专栏数据类型一文中详细说明了~
Java基础语法 - Java数据类型

例如:

public class Operator {

    public static void main(String[] args) {

        int a = 10;
        a = a + 2.5;
        System.out.println(a);

    }

}  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

异常抛出:

异常抛出
这样的运算属于将高精度数字存入低精度变量中,将会抛出异常,但是如果使用增量运算符就不会抛出异常~

如下:

public class Operator {

    public static void main(String[] args) {

        int a = 10;
        a += 2.5;
        System.out.println(a);

    }

}   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

运行结果:

运行结果

当然运算结果不可能是12.5,因为变量a是整型变量,这里可以理解为进行了自动类型转换进行运算~


🔨自增/自减运算符

自增,自减运算符及"++,–"运算符。

自增自减运算符又分为前置++,后置++和前置–,后置–

下面介绍不同位置的不同用法:

前置++/–:先++/–,后使用
后置++/–:先使用,后++/–
单独使用:前置和后置将没有区别

下面使用代码进行解释:

public class Operator {

    public static void main(String[] args) {

        int a = 10;
        int b = 0;
        int c = 0;
        b = ++a;
        c = a++;
        System.out.println(b);
        System.out.println(c);
        System.out.println(a);

    }

}   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

运行结果:

运行结果

如以上结果:

b = ++a;
  • 1

a先自增1后再赋值给b,所以b等于11。

c = a++;
  • 1

先将a现在的值赋给c,即11赋给c,然后再将a自增1变成12。

所以最后的结果:b和c都是11,a是12。


💕逻辑运算符

按照博主的理解,可以将所以运算结果返回值为布尔类型的运算符叫做逻辑运算符。

其实按照细分应该可以分为两块:

  1. 基本逻辑运算符
  2. 关系操作运算符

下面对这两种运算符进行介绍~


🥪基本逻辑运算符

基本逻辑运算符有三个:

  1. 与运算(&&)
  2. 或运算(||)
  3. 非运算(!)

他们的基本逻辑都很简单~

  1. 与运算:

所有的操作数返回值均为真,则运算结果为真,返回true
如果有一个操作数返回值为假,则运算结果为假,返回false

全真则真,一假则假

  1. 或运算:

有一个操作数返回值为真,则整个表达式结果为真,返回true
所有操作数返回值为假,则整个表达式结果为假,返回false

一真则真,全假才假

  1. 非运算

将操作数的返回值颠倒,如果操作数的返回值为true,则表达式返回值为false,如果操作数返回值为false,则表达式返回值为true。

真即是假,假即是真

下面用代码的形式介绍其简单用法:

public class Operator {

    public static void main(String[] args) {

        boolean a = true;
        boolean b = false;

        System.out.println(a && b);
        System.out.println(a || b);
        System.out.println(!a);
        System.out.println(!b);

    }

}   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

运行结果:

运行结果
以上就是基本逻辑运算符的简单用法,但基本逻辑运算符中的逻辑与运算和逻辑或运算符合短路运算规则!

🤳短路运算

所谓短路运算就是:

  1. 对于逻辑与运算(&&):如果左侧表达式结果为false,则不会进行右侧表达式的运算。
  2. 对于逻辑或运算(||):如果左侧表达式的结果为true,则不会进行对右侧表达式的运算。

举个简单的例子:

我们在上文中提到过,在进行除法运算时,0不能被作为除数,否则在编译期间就会抛出异常。

但用以下短路运算则不会抛出异常:

public class Operator {

    public static void main(String[] args) {

        System.out.println(10 > 20 && 0 == 10 / 0);
        System.out.println(10 < 20 || 0 == 10 / 0);

    }

}   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

运行结果:

运行结果
可以看到,该程序正常的运行了,也就是说,发生了短路运算左侧表达式运行之后就不再运行右侧表达式了


🚆关系操作运算符

关系操作运算符,顾名思义,就是判断操作数之间的关系的操作符。

关系操作运算符有:

==,!=,>=,<=,<,>

注意: 关系操作运算符的返回类型都是布尔类型(boolean)

代码示例:

public class Operator {

    public static void main(String[] args) {

        int a = 10;
        int b = 20;

        System.out.println(a == b);
        System.out.println(a != b);
        System.out.println(a > b);
        System.out.println(a < b);
        System.out.println(a >= b);
        System.out.println(a <= b);

    }

}   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

运行结果:

运行结果

🌳位运算符

博主把所有的关于二进制位的运算符全部归于位运算符。

其中包括:

  1. 按位运算操作符
  2. 移位运算操作符

🚲按位运算操作符

对二进制位进行操作一般是较为面向底层的语言常用的操作符,比如C/C++这种与操作系统交互较多的语言,Java是偏注重应用的语言,所以我们这里了解即可。

Java中的按位运算操作符有:

按位与(&),按位或(|),按位异或(^)

下面一一介绍:

  1. 按位与(&)操作符

按位与(&)即对二进制序列进行按二进制位的与操作,如:

10010101001010011010010110101010
00010110101011101111010110001010 -- &
00010100001010001010010110001010
  • 1
  • 2
  • 3

同为1的与运算结果为1,有一个为0则结果为0。

  1. 按位或(|)操作符

按位或(|)即对二进制序列进行按二进制位的或操作,如:

01000010011101110100101000111010
10110011010010111100001010000100 -- |
11110011011111111100101010111110
  • 1
  • 2
  • 3

同为0时运算结果为0,有一个1则结果为1。

  1. 按位异或(^)操作符

按位异或在博主来看其实就是找不同,如果不同则运算结果为1,相同则为0。

找不同

如:

10010110110001011010010110100111
00101011010010011010100111011101 - ^
01000010011100111111001110000101
  • 1
  • 2
  • 3

就像是找不同一般,找到不同的,返回1,找到相同的,返回0。


🌹移位运算操作符

在Java中移位操作符有三个:

  1. 左移操作符(<<)
  2. 右移操作符(>>)
  3. 无符号右移操作符(>>>)

移位操作符都是按照二进制数来进行移位。

左移操作符(<<):

最左边位数不要了,其他位向左补齐,右边空出的位补0;

右移操作符(>>):

最右边位数不要了,其他位向右补齐,左边空出的位补符号位,即正数补0,负数补1;

无符号右移操作符(>>>):

最右边位数不要了,其他位向右补齐,左边空出的位补0,即不管是正数还是负数都补0;

比如:

10000000000000000000000000000011 - -3原码
11111111111111111111111111111100 - 反码
11111111111111111111111111111101 - 补码 

11111111111111111111111111111101 - -3
11111111111111111111111111111010  -  左移1位 - 补码
10000000000000000000000000000101
10000000000000000000000000000110 - 原码 - -6

11111111111111111111111111111101 - -3
11111111111111111111111111111110  -  右移1位 - 补码
10000000000000000000000000000001
10000000000000000000000000000010 - 原码 - -2

11111111111111111111111111111101 - -3
01111111111111111111111111111110  -  无符号右移1位 - 正数
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

我们看代码运行结果,10000011的值为-3

public class Operator {

    public static void main(String[] args) {

        int a = -3;

        System.out.println(a << 1);
        System.out.println(a >> 1);
        System.out.println(a >>> 1);

    }

}  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

运行结果:

运行结果

其实移位操作符还有一个小结论:

因为按位移动的是二进制位,所以:

  1. 左移1位,相当于原来的数乘以2
  2. 右移1位,相当于原来的数除以2

有了以上结论,我们在进行代码运算如果涉及2n的计算的时候可以采用移位操作符进行计算。

注意: 移动负数位或者移动位数过多将没有意义~


🐱‍🚀条件操作符(三目操作符)

在C语言中也有条件操作符,条件操作符也是C语言和Java中唯一的三木运算符,其基本使用规则如下:

表达式1 ? 表达式2 : 表达式3

即表达式1如果成立,则表达式2为整个表达式的结果,否则表达式3为表达式的结果。

在某些情况下条件操作符将异常好用。
比如:

public class Operator {

    public static void main(String[] args) {

        int a = 10;
        int b = 20;
        int max = a > b ? a : b;
        System.out.println(max);

    }

}   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

运行结果:

运行结果
其中,

表达式1为(a>b);
表达式2为(a);
表达式3为(b);


以上就是Java中涉及的所有操作符,接下来附加两个额外的小知识点。

🍦PS

在学习Java中还有一些不得不说的细节,比如接下来要讲的注释和关键字。

其中关键字将会在本专栏其他文章内容中分部讲解,这里只简单罗列。

🍎注释

学习任何一门计算机语言都少不了注释的学习,本文就简单介绍以下在Java中注释的用法和需要注意的东西~

首先我们知道,注释是不作为编程的代码部分的,他其实是为了使我们的代码更具有可读性而被添加上的描述信息,不参与编译,但是却非常重要~

基本规则:

Java中的代码注释分为以下三种:

  1. 单行注释://(注释内容)
  2. 块注释(多行注释):/ *(注释内容) * /
  3. 文档注释:/**(注释内容)*/

其中单行注释使用最多,块注释基本不使用,而文档注释一般位于类和方法之间,用于描述。


代码注释需要注意格式规范,下面列出几条规范注释风格的要求:

  1. 内容准确:要求注释内容应该和代码相符,如果修改了代码应该及时更新注释。
  2. 篇幅精炼:注释不适宜长篇大论,能让自己和别人看懂即可。
  3. 使用中文:代码的注释是给自己和同事看的,不要炫耀自己的英文水平,应该最大可能的让自己和别人看懂。
  4. 积极向上:不得出现辱骂国家,有损国家形象或者辱骂领导的语句词汇,不要涉及政治敏感词汇

🍃Java关键字

这里罗列Java关键字,但不会逐一讲解,先熟悉即可。

Java关键字

注意: 自己定义的变量名不能与关键字冲突!


😁总结

以上就是本文的全部内容,主要介绍了Java学习中会用到的所有运算符以及一些需要注意的点,接着补充了注释的内容以及Java关键字的图表,文章有任何不懂或者有问题的地方欢迎大家评论区留言或者私聊博主~

如果喜欢本文记得不要吝啬各位的三连哦~

👍点赞👍 + 👀关注👀 + ✔️收藏✔️

推荐阅读