⭐️JavaSE系列文章⭐️JAVA基础语法——数据类型与运算符

文章前提：
各位程序员大家好！！这是博主的一篇的全新系列文章，C语言的解析已经告于段落。下面我们进行Java的学习，相对C语言Java是一门面向对象的语言，而C语言则是面向过程的程序设计语言，并且在Java中摒弃了C语言中难懂的指针知识。我们在Java中会接触到一些全新的知识：包装类，成员变量等一些Java相关知识。下面文章正式开始介绍JavaSE的基础语法——数据类型与运算符。

博客主页：博客主页
欢迎大家交流学习期待大家留言以及一键三连❤️
文章发布时间：2021年10月14日
作者本人也是刚刚接触Java有一些地方如果存在错误，还请大家及时指出！谢谢大家！！❤️
gitee链接：博主平时练习的一些代码以及Java的笔记

导航栏
1.数据类型
✨1.1.整型
✨1.2.浮点型
✨1.3.字符型
✨1.4.布尔类型
✨1.5.字符串类型
✨1.6.转义字符
✨1.7.变量和常量
✨1.8.类型转换
✨1.9.数值提升
2.运算符
✨2.1.算术运算符
✨2.2.关系运算符
✨2.3.逻辑运算符
✨2.4.位运算符
✨2.5.移位运算符
✨2.6.条件运算符
✨2.7.运算符的优先级
✨2.5.移位运算符
3.注释
✨3.1 基本规则
✨3.2 注释规范
4.关键字

---

---

1.数据类型

我们学习一门语言先要研究的就是它的数据类型，在程序运行时会开辟对应的空间去存储不同类型的数据。类型对变量的种类进行了划分，不同的变量具有不同的特性，我们所讨论的 "变量" 主要和我们的 "内存" 这样的硬件设备密切相关：

下面我们看著名的冯诺依曼体系：

 简化后：

冯·诺伊曼体系结构简介：

冯·诺伊曼体系结构是现代计算机的基础，现在大多计算机仍是冯·诺伊曼计算机的组织结构，只是作了一些改进而已，并没有从根本上突破冯体系结构的束缚。冯·诺伊曼也因此被人们称为“计算机之父”。然而由于传统冯·诺伊曼计算机体系结构天然所具有的局限性，从根本上限制了计算机的发展。根据冯·诺伊曼体系结构构成的计算机，必须具有如下功能：把需要的程序和数据送至计算机中。必须具有长期记忆程序、数据、中间结果及最终运算结果的能力。能够完成各种算术、逻辑运算和数据传送等数据加工处理的能力。能够根据需要控制程序走向，并能根据指令控制机器的各部件协调操作。能够按照要求将处理结果输出给用户。将指令和数据同时存放在存储器中，是冯·诺伊曼计算机方案的特点之一。计算机由控制器、运算器、存储器、输入设备、输出设备五部分组成。冯·诺伊曼提出的计算机体系结构，奠定了现代计算机的结构理念。

---

✨1.1整型变量

1.1.1.int类型

1️⃣ 基本语法格式：

int 变量名 = 初始值;

2️⃣ int 类型的大小：4字节

❗️ 无论是16位，32位，64位平台操作系统Java中的 int 类型都是大小都是 4 个字节

 这就说明Java有很强的可移植性

❗️ Java中的 int 类型没有无符号整型（unsigned int）统一都是有符号数 

3️⃣ int 类型的取值范围：

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a);
        //计算int的最小值
        System.out.println(Integer.MIN_VALUE);
        //计算int的最大值
        System.out.println(Integer.MAX_VALUE);
    }
}

这里的 Integer 为 int 的包装类，8种基本类型都是存在包装类的，通过包装类可以实现不同的功能，如图的 MIN_VALUE 和 MAX_VALUE 是分别用来求得 int 类型的最小值和最大值的

运行结果：

10

-2147483648//最小值

2147483647//最大值

❓ 这样的结果是如何计算出来的呢 

我们知道 int 类型的大小是 4 个字节，4 个字节就是 32 个 bit 位，最高位是符号位，所以除去最高位剩下的 31 位都是有效位，所以 int 类型的范围结果就是从 -2^31~2^31-1，计算出来就是我们如图的数值

1.1.2.long类型（长整型）

❓ 如果存在大于我们 int 类型范围的数值无法在 int 类型中存储的数据时应该怎么办呢

这就需要进入我们的 long 类型

1️⃣ 基本语法格式：

long 变量名 = 初始值;

2️⃣ long 类型的大小：8字节 

3️⃣ long 类型的取值范围：

public class TestDemo {
    public static void main(String[] args) {
        long a = 10L;
        System.out.println(a);
        //计算最大值
        System.out.println(Long.MAX_VALUE);
        //计算最小值
        System.out.println(Long.MIN_VALUE);
    }

❓ 这样的结果是如何计算出来的呢 

我们知道 long 类型的大小是 8 个字节，8 个字节就是 64 个 bit 位，最高位是符号位，所以除去最高位剩下的 63 位都是有效位，所以 long 类型的范围结果就是从 -2^63~2^63-1，计算出来就是我们如图的数值

10
9223372036854775807
-9223372036854775808

❗️ 在定义长整型的时候在数字的末尾加一个大写或小写的 l  表示长整型， 博主在这里推荐大写的 L ，小写的 l 写在数字后会容易看出数字 1 ，引发不必要的错误

 推荐写法：

long a = 10L;

1.1.3.short类型（短整型）

1️⃣ 基本语法格式：

short 变量名 = 初始值; 

2️⃣ short 类型的大小：2字节 

3️⃣ long 类型的取值范围：

public class TestDemo {
    public static void main(String[] args) {
        short a = 10;
        System.out.println(a);
        //计算最大值
        System.out.println(Short.MAX_VALUE);
        //计算最小值
        System.out.println(Short.MIN_VALUE);
    }

❓ 这样的结果是如何计算出来的呢 

我们知道 short 类型的大小是 2 个字节，2 个字节就是 16 个 bit 位，最高位是符号位，所以除去最高位剩下的 63 位都是有效位，所以 short 类型的范围结果就是从 -2^15~2^15-1，计算出来就是我们如图的数值

10
32767
-32768

1.1.4.byte类型（字节类型）

1️⃣ 基本语法格式：

byte 变量名 = 初始值

2️⃣ byte 类型的大小：1字节 

相当于 C 语言中的 char 类型

3️⃣ byte 类型的取值范围：

public class TestDemo {
    public static void main(String[] args) {
        byte a = 10;
        System.out.println(a);
        //最小值
        System.out.println(Byte.MIN_VALUE);
        //最大值
        System.out.println(Byte.MAX_VALUE);
    }

运行结果：

10
-128
127 

❓ 这样的结果是如何计算出来的呢 

我们知道 byte 类型的大小是 1 个字节，1 个字节就是 8 个 bit 位，最高位是符号位，所以除去最高位剩下的 7 位都是有效位，所以 byte 类型的范围结果就是从 -2^7~2^7-1，计算出来就是我们如图的数值

✨1.2浮点类型

1.2.1.单精度浮点类型

1️⃣ 基本语法格式：

float 变量名 = 初始值;

2️⃣ float 类型的大小：4字节 

3️⃣ float 类型的取值范围：

public class TestDemo {
    public static void main(String[] args) {
        float a = 12.5f;
        System.out.println(a);
        //计算最大值
        System.out.println(Float.MAX_VALUE);
        //计算最小值
        System.out.println(Float.MIN_VALUE);

    }

运行结果：

12.5
3.4028235E38
1.4E-45

❓ 同样是 4 个字节大小为什么计算出来后是这样的结果

❗️ 因为小数本身一个没有精确度的数字它只能精确到小数点后几位，比如 float 可以精确到小数点后 6 位，所以这里没有精确的最大最小数值，还有就是浮点数和整数在内存中的存储方式不同，具体请参考：浮点数的存储方式

❗️ 在单精度浮点数进行定义的时候在小数的结尾一定要加上一个小写的 f 这样表示定义的是单精度浮点类型 

float a = 12.5f;

❗️ 如果这里的小 f 忘记写会导致程序出错 

我们看到这里程序在这里报错了，因为如果不写 f 编译器默认 12.5 是一个双精度浮点类型，我们知道双精度浮点类型的大小是 8 个字节，单精度的 float 类型大小是 4 个字节，所以 a 存不下双精度的 12.5 

❗️ float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 float.

1.2.2.双精度浮点类型

1️⃣ 基本语法格式：

double 变量名 = 初始值;

2️⃣ double 类型的大小：8字节 

3️⃣ double 类型的取值范围：

public class TestDemo {
    public static void main(String[] args) {
        double a = 12.5;
        System.out.println(a);
        //计算最大值
        System.out.println(Double.MAX_VALUE);
        //计算最小值
        System.out.println(Double.MIN_VALUE);

    }

12.5
1.7976931348623157E308
4.9E-324

❗️ 这里这样的数值和 float 的原因是一致的，不过多介绍

✨1.3.字符类型 

字符类型（char）

1️⃣ 基本语法格式：

char 变量名 = 初始值;

2️⃣ char 类型的大小：2字节 

❗️ Java 中的 char 类型是 2 个字节与 C 语言中的大小不同

3️⃣ char 类型的使用：

public class TestDemo {
    public static void main(String[] args) {
        char a = 'A';
        char b = '哈';
        System.out.println(a);
        System.out.println(b);
    }

运行结果：

A
哈

✨1.4布尔类型

布尔类型（boolean）

1️⃣ 基本语法格式：

boolean 变量名 = 初始值; 

2️⃣ boolean 类型的大小：有些书说是一个字节，有的书说是一个 bit 位，JVM的规范中并没有给出明确的定义说明布尔类型的具体数值是多少

❗️ 所以布尔类型的大小是一个不确定的数值

3️⃣ boolean 类型的使用：

public class TestDemo {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        System.out.println(a);
        System.out.println(b);
    }

运行结果：

true
false

在 C 语言中，0代表假，非0代表真

❗️ 而在 Java 中 boolean 类型只有两个取值：true / false （真/假）其他的不行

❗️ 由于布尔类型不是一个具体的数字所以无法与数值进行加和：下面为错误代码实例

✨1.5字符串类型

字符串类型（String）

1️⃣ 基本语法格式：

String 变量名 = "初始值";

2️⃣什么是字符串？

单引号引来的单个字母叫字符，双引号引起来的若干字符叫字符串

3️⃣ String 类型的使用：

public class TestDemo {
    public static void main(String[] args) {
        String str = "hello";
        System.out.println(str);
    }

运行结果：

hello

4️⃣ 引用类型：

String 类型又叫引用类型，我们的数据类型分为基本数据类型和引用类型两种，如图：

5️⃣ 加号在字符串类型中的作用：

public class TestDemo {
    public static void main(String[] args) {
        String str = "hello";
        String str1 = "world";
        System.out.println(str+str1);
    }

 ❓ 我们看到这样两个字符加在一起可以产生怎样的结果呢

运行结果：

helloworld

  我们看到加号在字符串中的作用就是把加号两侧的字符串拼接起来组成一个新的字符串

我们再看一个代码：

public class TestDemo {
    public static void main(String[] args) {
        System.out.println("hello"+10+20);
    }

❓ 这样的一个代码会运行出来怎样的结果呢 

运行结果：

hello1020

  我们看到这里的拼接是把其他的数据类型与字符串拼接结果还是一个字符串

对比如下代码：

System.out.println(10+20+"hello");

❓ 这样的代码又会运行出来怎样的结果呢 

运行结果:

30hello

这里由于程序是自左向右运行的这里的前两个是整数所以相加后还是整数，再和后面的 hello 进行进加和最后拼接成一个字符串

✨1.6转义字符

转义字符	解释
\n	换行
\t	水平制表符
\'	单引号
\''	双引号
\\	反斜杠

我们通过上述的 8 种基本数据类型，知道了如何打印对应的变量

❓假设：当我们需要打印一个 bit 的时候

这样编写代码即可：

public class TestDemo {
    public static void main(String[] args) {
        System.out.println("bit");
    }

❓ 但是我们思考如果想要打印 “bit“ ，\bit\ , \\bit\\ 呢，这就需要用到转义字符 

public class TestDemo {
    public static void main(String[] args) {
        System.out.println("bit");
        System.out.println("\"bit\"");
        System.out.println("\\bit\\");
        System.out.println("\\\\bit\\\\");
    }

运行结果：

bit
"bit"
\bit\
\\bit\\

其他的转义字符都是经常使用的，不过多赘述

✨1.7变量和常量

1.71变量的作用域

变量分为：如图的两种情况

这里的成员变量在后面会再进行仔细的讲解，本博客先主要讨论局部变量 

我们需要以下注意几点：

❗️ 在 Java 中不存在全局变量这样的概念 

❗️ 寻找变量的作用域就去寻找花括号的范围即可

1.7.2变量的命名规则

命名只能包括：美元符号$  字母  数字  下划线

我们需要以下注意几点：

❗️ 但是数字不能作为变量名的开头

❗️ 命名的方式推荐使用小驼峰：maxNum，maxnum

❗️ 不推荐使用美元符号 $ 进行命名，合法但是不合理

❗️ 变量命名后一定要赋初值，Java为安全性较高的语言，不初始化变量程序会报错

1.7.3常量

常量我们在 Java 中分为两类：字面值常量和被 final 修饰的常量

我们知道：

变量：是程序运行时可以改变的量

常量：是在程序运行时不可以被修改的，在程序开始的时候已经确定了常量的数值，也就是说在定义常量的时候，只能进行一次赋值，中途不可以被修改

变量：

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        a = 99;
    }

❗️ 这里的 a 在运行时数值改变了由最开始的 10 变成了 99，所以 a 是一个变量

常量：

❗️  字面值常量：

10 // int 字面值常量(十进制)

010 // int 字面值常量(八进制) 由数字 0 开头. 010 也就是十进制的 8

0x10 // int 字面值常量(十六进制) 由数字 0x 开头. 0x10 也就是十进制的 16

10L // long 字面值常量. 也可以写作 10l (小写的L)

1.0 // double 字面值常量. 也可以写作 1.0d 或者 1.0D

1.5e2 // double 字面值常量. 科学计数法表示. 相当于 1.5 * 10^2

1.0f // float 字面值常量, 也可以写作 1.0F

true // boolen 字面值常量, 同样的还有 false

'a' // char 字面值常量, 单引号中只能有一个字符

"abc" // String 字面值常量, 双引号中可以有多个字符.

❗️ 被 final 修饰的常量

public class TestDemo {
    public static void main(String[] args) {
        final int a = 10;
    }

❗️ 这里的 a 被 final 修饰这时候的 a 就是一个常量了，并且 a 已经赋初值，所以下面 a 的数值绝对不允许改变，否则程序就会报错

❗️ 这里的 final 的作用类似于 C 语言中的 const 语句用于保护变量

✨1.8类型转化

 我们先看这样一个代码：

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        long b = a;
        System.out.println(b);
    }

  我们看到这里 a 的数值成功赋值给了 b ，是因为 a 是 int 类型 4 个字节，而 b 是 long 类型 8 个字节，小类型存储到大类型中，当然没有问题

对比：我们如果把 a 和 b 的类型倒转过来看又会发生什么

public class TestDemo {
    public static void main(String[] args) {
        long a = 10;
        int b = a;
        System.out.println(b);
    }

❗️  我们可以看到这里程序报错了，这是因为我们把大类型存储到了小类型中，我们知道 long 类型范围很大，不可能会存不下 10  ，但为什么程序在这里还会报错

首先 Java 是强类型语言，而 C 是弱语言，像上图这样的代码在 C 中只会报一个警告，而 Java 为了保证程序的安全，会在这里报错

其次由于这里的 a 是一个变量，不知道在运行时后面的代码还会不会改变变量 a 的数值，所以这里为了防止超过 int 类型的最大存储范围，这里程序会报错

解决办法：强制类型转换

public class TestDemo {
    public static void main(String[] args) {
        long a = 10;
        int b = (int)a;
        System.out.println(b);
    }

这里把 a 强制类型转换成 int 类型后程序就没有问题了，这就是强制类型转换的作用

❗️ 但是强制类型转换存在风险 

❗️ 可能会造成数据的丢失

❗️ 两种类型不存在相关性，无法进行强制类型转换

❗️ 超出变量存储的范围

当浮点类型和整型数据相互转换时候：

public class TestDemo {
    public static void main(String[] args) {
        double a = 3.14;
        int b = (int) a;
        System.out.println(b);
    }

运行结果：

3

我们可以看到结果只有一个 3 小数部分就丢失了，这就是强制类型转换导致的类型丢失

当整型和布尔类型互相赋值时即使强制类型转换，程序也会报错

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        boolean flg = (boolean) a;
    }

❗️ 这里错误是提升类型不兼容无法进行相互赋值，即使进行了强制类型转换

当整型给字节类型赋值时，注意 byte 的最大存储范围

public class TestDemo {
    public static void main(String[] args) {
        int a = 130;
        byte b = (byte)a;
    }

❗️ 我们通过上面的讲解知道字节类型变量的范围是 -128~127所以这里的130超出了byte类型的范围，所以这里得不到想要的结果

✨1.9数值提升

这里我们需要知道一个知识，在CPU在解算我们的代码的时候会把小于4个字节的类型统一提升成整型进行计算

我们看这样一个代码：

public class TestDemo {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        byte c = a + b;
    }
}

代码显示赋值这一条语句存在问题，我们知道 byte 是可以存放下 30 的但为什么这里不行，因为如果单单把 30 赋值给 c 完全没有问题，因为 30 是一个字面值常量。

❗️ 而这里的 c 是由 a+b组成的，所以在程序运算时把 a和b 提升为四字节的整型变量，整型加整型结果还是整型，所以这里需要一步强制类型转换，才可以把a + b的结果存储到 c 中

public class TestDemo {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        byte c = (byte)(a + b);
    }
}

对比：当一个整型和一个长整型进行相加时

public class TestDemo {
    public static void main(String[] args) {
        long a = 10;
        int b = 20;
        int c = b + a;
    }
}

❗️ 整型和长整型的大小都是大于4个字节的，这里程序也会报错，这是为什么呢 

这里CPU会把小类型转换为大类型进行加和计算，所以这里把 b 转换为 long 类型再进行的加和，长整型+长整型还是长整型所以这里相当于把一个长整型赋值给了 c ，程序当然会报错

解决办法：强制类型转换

public class TestDemo {
    public static void main(String[] args) {
        long a = 10;
        int b = 20;
        int c = (int)(b + a);
    }
}

数值间的相互转换：

int 和 String 类型间的相互转换：（省去了如图C语言中atoi函数的使用）

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        String str = String.valueOf(a);
        System.out.println(str);
        String ret = "123";
        int b = Integer.valueOf(ret);
        System.out.println(b);
    }
}

10

123

这里借助包装类的功能就能实现 valueof 用来实现转换功能的

---

2.运算符

✨2.1算术运算符

基本四则运算符 + - * / %

  int / int 结果还是 int, 需要使用 double 来计算.

public class TestDemo {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a/b);
    }
}

0

这里的结果还是 0 ，如果想要打印 0.5 需要定义double类型

0 不能作为除数

public class TestDemo {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        System.out.println(a/b);
    }
}

❗️ 这里会出现算术异常错误，所以 0 一定不能当除数

% 表示取余, 不仅仅可以对 int 求模, 也能对 double 来求模

public class TestDemo {
    public static void main(String[] args) {
        int a = 10%3;
        double b = 12.5%3;
        System.out.println(a);
        System.out.println(b);
    }
}

1
0.5

增量赋值运算符 += -= *= /= %=

我们看一个代码：

public class TestDemo {
    public static void main(String[] args) {
        short a = 10;
        a = a + 9;
    }
}

❗️ 这样由于数值提升相当于右边把一个 int 类型的数值赋值给了左边的 short 程序会报错

解决方法： 

强制类型转换

public class TestDemo {
    public static void main(String[] args) {
        short a = 10;
        a = (short)(a + 9);
    }
}

利用我们的增量赋值运算符

public class TestDemo {
    public static void main(String[] args) {
        short a = 10;
        a += 9;
    }
}

❓ 这样程序就不会报错了，为什么呢

因为增量赋值运算符自带强制类型转换的功能，这里在运算的时候已经转换好了

自增/自减运算符 ++ --

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        a++;
        int b = 10;
        b--;
        System.out.println(a);
        System.out.println(b);
    }
}

11
9

结论:

1. 如果不取自增运算的表达式的返回值, 则前置自增和后置自增没有区别.

2. 如果取表达式的返回值, 则前置自增的返回值是自增之后的值, 后置自增的返回值是自增之前的值

✨2.2 关系运算符

  == != < > =

public class TestDemo {
    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);
    }
}

false
true
true
false
true
false

 注意: 关系运算符的表达式返回值都是boolean 类型

✨2.3逻辑运算符

&& || !

❗️ 注意: 逻辑运算符的操作数(操作数往往是关系运算符的结果)和返回值都是 boolean

❗️ 逻辑运算符中存在短路的知识：在逻辑与中如果第一个表达式判断为假，那么第二个表达式不进行操作。同样对应逻辑或，当第一个表达式判断为真，第二个表达式就不进行操作

1️⃣ 逻辑与 &&

❗️ 规则: 两个操作数都为 true, 结果为 true, 否则结果为 false

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        System.out.println(a < b && b < c);
    }
}

true

❗️ 短路案例：

public class TestDemo {
    public static void main(String[] args) {
        System.out.println(10>=20 && 10/0==0);
    }
}

false

我们看到第二个表达式显然是错误的，因为 0 不能做除数，但是由于第一个表达式是 false 的所以第二个表达式不判断，这里直接可以打印 false

2️⃣逻辑或 ||

❗️规则: 两个操作数都为 false, 结果为 false, 否则结果为 true

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        System.out.println(a < b || b < c);
    }
}

true

❗️ 短路案例：

public class TestDemo {
    public static void main(String[] args) {
        System.out.println(10<20 || 10/0==0);
    }
}

true

我们看到第二个表达式显然会导致程序出错，因为 0 不能做除数，但是由于第一个表达式是 true 的所以第二个表达式不判断，这里直接可以打印 true

3️⃣ 逻辑非 !

❗️ 规则: 操作数为 true, 结果为 false; 操作数为 false, 结果为 true(这是个单目运算符, 只有一个操作数).

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(!(a < b));
    }
}

false

我们可以看到 a结果为 true 然后逻辑非就是 false

✨2.4 位运算符

Java 中对数据的操作的最小单位不是字节, 而是二进制位. 位运算符主要有四个:

 & | ~ ^

❗️ 位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算.

1️⃣ 按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a & b);
    }
}

0

2️⃣ 按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1. 

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a | b);

    }
}

30

❗️ 注意: 当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表示逻辑运算

public class TestDemo {
    public static void main(String[] args) {
        boolean flg = true;
        boolean flg2 = false;
        System.out.println(flg&flg2);
        System.out.println(flg|flg2);
    }
}

false
true

3️⃣ 按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0

public class TestDemo {
    public static void main(String[] args) {
        int a = 0xf;
        System.out.printf("%x\n", ~a);
    }
}

fffffff0

❗️ 注意：

1. 0x 前缀的数字为 十六进制 数字. 十六进制可以看成是二进制的简化表示方式. 一个十六进制数字对应 4 个二进 制位.

2. 0xf 表示 10 进制的 15, 也就是二进制的 1111

3. printf 能够格式化输出内容, %x 表示按照十六进制输出. 4. \n 表示换行符 

4️⃣ 按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.

按位异或实质就是找不同：

public class TestDemo {
    public static void main(String[] args) {
        int a = 0x1;
        int b = 0x2;
        System.out.printf("%x\n", a ^ b);
    }
}

3

 ✨2.5移位运算(了解)

移位运算符有三个:

<< >> >>>

都是按照二进制位来运算.

1️⃣ 左移 <<: 最左侧位不要了, 最右侧补 0

public class TestDemo {
    public static void main(String[] args) {
        int a = 0x10;
        System.out.printf("%x\n", a << 1);
    }
}

20

 2️⃣ 右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

正数案例：正数是补0

public class TestDemo {
    public static void main(String[] args) {
        int a = 0x10;
        System.out.printf("%x\n", a >> 1);
    }
}

8

负数案例：高位补1

public class TestDemo {
    public static void main(String[] args) {
        int a = -1;
        System.out.printf("%x\n", a >> 1);
    }
}

ffffffff 

3️⃣ 无符号右移 >>>: 最右侧位不要了, 最左侧补 0.

public class TestDemo {
    public static void main(String[] args) {
        int a = 0xffffffff;
        System.out.printf("%x\n", a >>> 1);
    }
}

 7fffffff

 

 ❗️ 注意: 

1. 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.

2. 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.

3. 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.

4. 移动负数位或者移位位数过大都没有意义.

✨ 2.6 条件运算符

条件运算符只有一个:

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

当表达式1 的值为 true 时, 整个表达式的值为表达式 2 的值;

当表达式1 的值为 false 时, 整个表达式的值为 表达式 3 的值.

也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法.

public class TestDemo {
    public static void main(String[] args) {
        // 求两个整数的最大值
        int a = 10;
        int b = 20;
        int max = a > b ? a : b;
        System.out.println(max);
    }
}

20

✨2.7运算符的优先级

运算符之间是有优先级的. 具体的规则我们不必记忆. 在可能存在歧义的代码中加上括号即可

---

3.注释

✨ 3.1基本规则

Java中的注释主要分为以下三种

单行注释：// 注释内容（用的最多）

多行注释：/* 注释内容*/（不推荐）

文档注释： /** 文档注释 */（常见于方法和类之上描述方法和类的作用)，可用来自动生成文档

✨ 3.2 注释规范

❗️  注意：

1. 内容准确: 注释内容要和代码一致, 匹配, 并在代码修改时及时更新.

2. 篇幅合理: 注释既不应该太精简, 也不应该长篇大论.

3. 使用中文: 一般中国公司都要求使用中文写注释, 外企另当别论.

4. 积极向上: 注释中不要包含负能量

---

4. 关键字

关键字是 Java 中的一些具有特定含义的单词.

❗️ 注意：定义的变量名不能和关键字冲突 

---

希望本博客对大家的 java 学习有一定的帮助，如果有用希望各位大佬点赞评论三连，学习大家的支持了！！！！！