Java变量与运算符

关键字（keyword）

定义：被Java语言赋予了特殊含义，用做专门用途的字符串
- class、public 、 static 、 void 等，这些单词已经被Java定义好了。
特点：全部关键字都是小写字母。
官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

说明：

关键字一共50个，其中const和goto是保留字(reserved word)。

true，false，null不在其中，它们看起来像关键字，其实是字面量，表示特殊的布尔值和空值。

标识符( identifier)

Java中变量、方法、类等要素命名时使用的字符序列，称为标识符。

技巧：凡是自己可以起名字的地方都叫标识符。

标识符的命名规则（必须遵守的硬性规定）：

1
2
3
4
5


> 由26个英文字母大小写，0-9 ，_或 $ 组成  
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。 

标识符的命名规范（建议遵守的软性要求）:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


> 包名：多单词组成时所有字母都小写：xxxyyyzzz。
  例如：java.lang、com.atguigu.bean
  
> 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
  例如：HelloWorld，String，System等
  
> 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
  例如：age,name,bookName,main,binarySearch,getName
  
> 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
  例如：MAX_VALUE,PI,DEFAULT_CAPACITY

变量

变量是程序中不可或缺的组成单位，最基本的存储单元

变量的概念:

存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化
变量的构成包含三个要素：数据类型、变量名、存储的值
Java中变量声明的格式：数据类型变量名 = 变量值

变量的作用：用于在内存中保存数据。

使用变量注意：

Java中每个变量必须先声明，后使用。
使用变量名来访问这块区域的数据。
变量的作用域：其定义所在的一对{ }内。
变量只有在其作用域内才有效。出了作用域，变量不可以再被调用。
同一个作用域内，不能定义重名的变量。

Java中变量的数据类型分为两大类：

基本数据类型：包括 整数类型、浮点数类型、字符类型、布尔类型。
- byte\short\int\long
- float\double
- char
- boolean
引用数据类型：包括数组、 类、接口、枚举、注解、记录。
- array
- class
- interface
- enum
- annotation
- record

声明：

1
2


//数据类型  变量名;
int age; 

注意：变量的数据类型可以是基本数据类型，也可以是引用数据类型。

赋值：

变量可以反复赋值,也可以将变量的声明和赋值一并执行

1
2
3
4
5
6
7
8


//变量名 = 值;

//可以使用合适类型的`常量值`给已经声明的变量赋值
age = 18;
//可以使用其他`变量`或者`表达式`给变量赋值
int z = 2 * x + y;

boolean isBeauty = true;

基本数据类型

`整数类型`:int

byte\short\int\long

定义long类型的变量，赋值时需要以"l“或”L“作为后缀。
Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long。
Java的整型常量默认为 int 型。

计算机存储单位

**字节（Byte）：**是计算机用于计量存储容量的基本单位，一个字节等于8 bit。
**位（bit）：**是数据存储的最小单位。二进制数系统中，每个0或1就是一个位，叫做bit（比特），其中8 bit 就称为一个字节(Byte)。
转换关系：
- 8 bit = 1 Byte
- 1024 Byte = 1 KB
- 1024 KB = 1 MB
- 1024 MB = 1 GB
- 1024 GB = 1 TB

`浮点类型`:double

浮点型常量有两种表示形式：
- 十进制数形式。如：5.12 512.0f .512 (必须有小数点）
- 科学计数法形式。如：5.12e2 512E2 100E-2
float：单精度，4个字节，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
double：双精度，8个字节，精度是float的两倍。通常采用此类型。
定义float类型的变量，赋值时需要以”f“或”F“作为后缀。
Java 的浮点型常量默认为double型。

关于浮点型精度的说明

并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。
浮点类型float、double的数据不适合在不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度，需要使用BigDecimal类。

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


//测试1：（解释见章末企业真题：为什么0.1 + 0.2不等于0.3）
System.out.println(0.1 + 0.2);//0.30000000000000004

//测试2：
float ff1 = 123123123f;
float ff2 = ff1 + 1;
System.out.println(ff1);
System.out.println(ff2);
System.out.println(ff1 == ff2);
//1.2312312E8
//1.2312312E8
//true

为什么0.1+0.2不是0.3是0.3000…4

整数变为二进制，能够做到“每个十进制整数都有对应的二进制数”

对于小数，并不能做到“每个小数都有对应的二进制数字”；

二进制小数0.0010表示十进制数0.125；二进制小数0.0011表示十进制数0.1875。看，对于四位的二进制小数，二进制小数虽然是连贯的，但是十进制小数却不是连贯的。比如，你无法用四位二进制小数的形式表示0.125 ~ 0.1875之间的十进制小数。

所以在编程中，遇见小数判断相等情况，比如开发银行、交易等系统，可以采用四舍五入或者“同乘同除”等方式进行验证，避免上述问题。

`字符类型`：char

char 型数据用来表示通常意义上“字符”（占2字节）
Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。char类型是可以进行运算的。因为它都对应有Unicode码，可以看做是一个数值。

0-48,A-65,a-95

字符型变量的三种表现形式：

**形式1：**使用单引号(' ‘)括起来的单个字符。

例如：char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;
**形式2：**直接使用 Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。

例如：\u0023 表示 ‘#'。char c =95//a

**形式3：**Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。

例如：char c3 = ‘\n’; // ‘\n’表示换行符

转义字符	说明	Unicode表示方式
`\n`	换行符	\u000a
`\t`	制表符	\u0009
`\"`	双引号	\u0022
`\'`	单引号	\u0027
`\\`	反斜线	\u005c
`\b`	退格符	\u0008
`\r`	回车符	\u000d

`布尔类型`：boolean

1
2
3
4
5
6
7


编译时不谈占几个字节。

但是JVM在给boolean类型分配内存空间时，boolean类型的变量占据一个槽位(slot，等于4个字节)。
细节：true:1  false:0

>拓展：在内存中，byte\short\char\boolean\int\float : 占用1个slot
              double\long :占用2个slot

boolean 类型用来判断逻辑条件，一般用于流程控制语句中：
- if条件控制语句；
- while循环控制语句；
- for循环控制语句；
- do-while循环控制语句；
boolean类型数据只有两个值：true、false，无其它。
- 不可以使用0或非 0 的整数替代false和true，这点和C语言不同。
- 拓展：Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。——《java虚拟机规范 8版

经验之谈：

Less is More！建议不要这样写：if ( isFlag = = true )，只有新手才如此。关键也很容易写错成if(isFlag = true)，这样就变成赋值isFlag为true而不是判断！老鸟的写法是if (isFlag)或者if (!isFlag)。

基本数据类型变量间运算规则

在Java程序中，不同的基本数据类型（只有7种，不包含boolean类型）变量的值经常需要进行相互转换。

转换的方式有两种：自动类型提升和强制类型转换。

自动类型提升

规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型

并非是占空内存空间的大小而是指表示数据范围的大小，long(8字节)->float(4字节)

(byte,short,char) -> int -> long -> float -> double

当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时

1
2
3
4


int i = 'A';//char自动升级为int，其实就是把字符的编码值赋值给i变量了
double d = 10;//int自动升级为double 10.0
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，显式表示long类型。否则编译不通过

当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算。

1
2
3
4
5


int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double

当byte,short,char数据类型的变量进行算术运算时，按照int类型处理

1
2
3
4
5
6
7
8


byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int

char c1 = '0';
char c2 = 'A';
int i = c1 + c2;//至少需要使用int类型来接收
System.out.println(c1 + c2);//113 

强制类型转换

规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型。

自动类型提升是Java自动执行的，而强制类型转换是自动类型提升的逆运算，需要我们自己手动执行。

1

数据类型1 变量名 = (数据类型1)被强转数据值;  //()中的数据类型必须<=变量值的数据类型

当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会损失精度或溢出。

1
2
3
4
5
6
7


int i = (int)3.14;//损失精度 不是四舍五入，直接截断

double d = 1.2;
int num = (int)d;//损失精度

int i = 128;
byte b = (byte)i;//溢出 -128

当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是没有风险的，通常省略。

1
2
3


int i = 1;
int j = 2;
double bigger = (double)(i/j);

声明long类型变量时，可以出现省略后缀的情况。float则不同

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


long l1 = 123L;
long l2 = 123;//如何理解呢？ 此时可以看做是int类型的123自动类型提升为long类型

//long l3 = 123123123123; //报错，因为123123123123超出了int的范围。
long l4 = 123123123123L;


//float f1 = 12.3; //报错，因为12.3看做是double，不能自动转换为float类型
float f2 = 12.3F;
float f3 = (float)12.3;

?为什么标识符的声明规则里要求不能数字开头

1
2
3
4


//如果允许数字开头，则如下的声明编译就可以通过：
int 123L = 12;
//进而，如下的声明中l的值到底是123？还是变量123L对应的取值12呢？ 出现歧义了。
long l = 123L;

数字默认是int类型

基本数据类型与String的运算

字符串类型：String

String不是基本数据类型，属于引用数据类型
使用一对""来表示一个字符串，内部可以包含0个、1个或多个字符。
声明方式与基本数据类型类似。例如：String str = “kong”;

运算规则

1、任意八种基本数据类型的数据与String类型只能进行连接“+”运算，且结果一定也是String类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


System.out.println("" + 1 + 2);//12

int num = 10;
boolean b1 = true;
String s1 = "abc";

String s2 = s1 + num + b1;
System.out.println(s2);//abc10true

//String s3 = num + b1 + s1;//编译不通过，因为int类型不能与boolean运算
String s4 = num + (b1 + s1);//编译通过

2、String类型不能通过强制类型()转换，转为其他的类型

计算机底层如何存储数据

计算机世界中只有二进制，所以计算机中存储和运算的所有数据都要转为二进制。包括数字、字符、图片、声音、视频等。

十进制（decimal）
- 数字组成：0-9
- 进位规则：满十进一
二进制（binary）
- 数字组成：0-1
- 进位规则：满二进一，以0b或0B开头
八进制（octal）：很少使用
- 数字组成：0-7
- 进位规则：满八进一，以数字0开头表示
十六进制
- 数字组成：0-9，a-f
- 进位规则：满十六进一，以0x或0X开头表示。此处的 a-f 不区分大小写

进制转换(未看)

运算符（Operator）

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

运算符的分类：

按照功能分为：算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda运算符

分类	运算符
算术运算符（7个）	+、-、*、/、%、++、–
赋值运算符（12个）	=、+=、-=、*=、/=、%=、»=、«=、»>=、&=、\|=、^=等
比较(或关系)运算符（6个）	>、>=、<、<=、==、!=
逻辑运算符（6个）	&、\|、^、!、&&、\|\|
位运算符（7个）	&、\|、^、~、«、»、»>
条件运算符（1个）	(条件表达式)?结果1:结果2
Lambda运算符（1个）	->（第18章时讲解）

按照操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符（三目运算符）

分类	运算符
一元运算符（单目运算符）	正号（+）、负号（-）、++、–、!、~
二元运算符（双目运算符）	除了一元和三元运算符剩下的都是二元运算符
三元运算符（三目运算符）	(条件表达式)?结果1:结果2

算术运算符

取模以后，符号与被模数相同。-12/5=-2,12/-5=2

++a：先自增后运算，a++：先运算后自增

++，–不会改变数据类型

jclasslib.bytecode.viewer:打开字节码文件，查看字节码指令jvm中讲到

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


int i = 2;
int j = i++;
System.out.println(j);//2

int m = 2;
m = m++; //(1)先取b的值“2”放操作数栈 (2)m再自增,m=3 (3)再把操作数栈中的"2"赋值给m,m=2
System.out.println(m);

int n = 10;
n += (n++) + (++n);  //n = n + (n++) + (++n)
System.out.println(n);//32

赋值运算符

符号：=
- 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
- 支持连续赋值。int a,b; a=b=1

扩展赋值运算符： +=、 -=、*=、 /=、%=

赋值运算符	符号解释
`+=`	将符号`左边的值`和`右边的值`进行`相加`操作，最后将结果`赋值给左边的变量`
`-=`	将符号`左边的值`和`右边的值`进行`相减`操作，最后将结果`赋值给左边的变量`
`*=`	将符号`左边的值`和`右边的值`进行`相乘`操作，最后将结果`赋值给左边的变量`
`/=`	将符号`左边的值`和`右边的值`进行`相除`操作，最后将结果`赋值给左边的变量`
`%=`	将符号`左边的值`和`右边的值`进行`取余`操作，最后将结果`赋值给左边的变量`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


//练习1：开发中，如何实现一个变量+2的操作呢？	
	// += 的操作不会改变变量本身的数据类型。其他拓展的运算符也如此。
	//写法1：推荐
	short s1 = 10;
	s1 += 2; //编译通过，因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short
	System.out.println(s1);//12
	//写法2：
	short s2 = 10;
	//s2 = s2 + 2;//编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度
	s2 = (short)(s2 + 2);
	System.out.println(s2);

//练习2：开发中，如何实现一个变量+1的操作呢？
	//写法1：推荐
	int num1 = 10;
	num1++;
	System.out.println(num1);

	//写法2：
	int num2 = 10;
	num2 += 1;
	System.out.println(num2);

	//写法3：
	int num3 = 10;
	num3 = num3 + 1;
	System.out.println(num3);

short s = 3; s = s+2; //① 编译报错将int类型的结果赋值给short类型的变量s可能损失精度

s = (short)(s+2);

s += 2; //② 正常执行 JVM自动完成一步强制类型转换

比较(关系)运算符

比较运算符的结果都是boolean型，也就是要么是true，要么是false。
> < >= <= ：只适用于基本数据类型（除boolean类型之外）

== != ：适用于基本数据类型和引用数据类型
比较运算符“==”不能误写成“=”

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


int m = 10;
int n = 20;
System.out.println(m == n);//false
System.out.println(m = n);//20

boolean b1 = false;
//区分好==和=的区别。判断和赋值
if(b1 == true)  
//if(b1 = true)赋值符号，相当于if(b1)
	System.out.println("结果为真");
else
	System.out.println("结果为假");

逻辑运算符

逻辑运算符，操作的都是boolean类型的变量或常量，而且运算得结果也是boolean类型的值。
运算符说明：
- & 和 &&：表示"且"关系，当符号左右两边布尔值都是true时，结果才能为true。否则，为false。
- | 和 || ：表示"或"关系，当符号两边布尔值有一边为true时，结果为true。当两边都为false时，结果为false
- ! ：表示"非"关系，当变量布尔值为true时，结果为false。当变量布尔值为false时，结果为true。
- ^ ：当符号左右两边布尔值不同时，结果为true。当两边布尔值相同时，结果为false。
  - 理解：异或，追求的是“异”！
逻辑运算符用于连接布尔型表达式，在Java中不可以写成 3 < x < 6，应该写成x > 3 & x < 6 。
**区分“&”和“&&”：**逻辑且短路且
- 相同点：如果符号左边是true，则二者都执行符号右边的操作
- 不同点：& ：如果符号左边是false,则继续执行符号右边的操作
&& ：如果符号左边是false,则不再继续执行符号右边的操作
- 建议：开发中，推荐使用 &&
区分“|”和“||”：
- 相同点：如果符号左边是false，则二者都执行符号右边的操作
- 不同点：| ：如果符号左边是true，则继续执行符号右边的操作
  
  || ：如果符号左边是true，则不再继续执行符号右边的操作
- 建议：开发中，推荐使用 ||

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


int a = 3;
int b = 4;
int c = 5;

System.out.println((a > b) & (a++ > c));  //false
System.out.println("a = " + a); //4
System.out.println((a > b) && (a++ > c)); //false
System.out.println("a = " + a); //4(上次判读加的，不是这次)
System.out.println((a == b) && (a++ > c)); //false
System.out.println("a = " + a);//5

位运算符

非重点

针对数值类型的变量或常量就行运算，运算的结果也是数值

位运算符的运算过程都是基于二进制的补码运算

（1）左移：«

运算规则：在一定范围内，数据每向左移动一位，相当于原数据*2。（正数、负数都适用）

【注意】当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位

1
2
3


3<<4  类似于  3*2的4次幂 => 3*16 => 48
    
-3<<4  类似于  -3*2的4次幂 => -3*16 => -48

**案例1：**高效的方式计算2 * 8的值（经典面试题）

答案：2 « 3 、 8 « 1

（2）右移：»

运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。（正数、负数都适用）

【注意】如果不能整除，向下取整。

1
2
3


69>>4  类似于  69/2的4次 = 69/16 =4

-69>>4  类似于  -69/2的4次 = -69/16 = -5

（3）无符号右移：»>

运算规则：往右移动后，左边空出来的位直接补0。（正数、负数都适用）

1
2
3


69>>>4  类似于  69/2的4次 = 69/16 =4

-69>>>4   结果：268435451 负数移一位就是正数了

（4）按位与：&

运算规则：对应位都是1才为1，否则为0。

（5）按位或：|

运算规则：对应位只要有1即为1，否则为0。

1
2
3


9 | 7  //结果： 15

-9 | 7 //结果： -9

6）按位异或：^

运算规则：对应位一个为1一个为0，才为1，否则为0。

（7）按位取反：~

运算规则：对应位为1，则结果为0；对应位为0，则结果为1。

**案例2：**如何交换两个int型变量的值？String呢？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


public class BitExer {
    public static void main(String[] args) {
        int m = 10;
		int n = 5;

		System.out.println("m = " + m + ", n = " + n);

		//（推荐）实现方式1：优点：容易理解，适用于不同数据类型    缺点：需要额外定义变量
		//int temp = m;
		//m = n;
		//n = temp;

		//实现方式2：优点：没有额外定义变量    缺点：可能超出int的范围；只能适用于数值类型
		//m = m + n; //15 = 10 + 5先到一起
		//n = m - n;//10 = 15 - 5去掉本身就是另一个
		//m = m - n;//5 = 15 - 10
	
		//实现方式3：优点：没有额外定义变量    缺点：不易理解；只能适用于数值类型
		m = m ^ n; 
		n = m ^ n; //(m ^ n) ^ n
		m = m ^ n;

		System.out.println("m = " + m + ", n = " + n);
    }
}

条件运算符

三元运算符

1
2
3
4


(条件表达式)? 表达式1:表达式2

条件表达式是boolean类型的结果，根据boolean的值选择表达式1或表达式2
如果运算后的结果赋给新的变量，要求表达式1和表达式2为同种或兼容的类型

获取两数的较大值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public class ConditionExer1 {
    public static void main(String[] args) {
        //获取两个数的较大值
        int m1 = 10;
        int m2 = 20;

        int max1 = (m1 > m2)? m1 : m2;
        System.out.println("m1和m2中的较大值为" + max1);
    }
}

今天是周2，10天以后是周几？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public class ConditionExer3 {

    public static void main(String[] args) {
        int week = 2;
        week += 10;
        week %= 7;
        System.out.println("今天是周2,10天以后是周" + (week == 0 ? "日" : week));
    }

}

与if-else的转换关系

凡是可以使用条件运算符的地方，都可以改写为if-else结构。反之，不成立。

开发中，如果既可以使用条件运算符，又可以使用if-else，推荐使用条件运算符。因为执行效率稍高。

运算符优先级

运算符有不同的优先级，所谓优先级就是在表达式运算中的运算符顺序。

上一行中的运算符总是优先于下一行的。

优先级	运算符说明	Java运算符
1	括号	`()`、`[]`、`{}`
2	正负号	`+`、`-`
3	单元运算符	`++`、`--`、`~`、`！`
4	乘法、除法、求余	`*`、`/`、`%`
5	加法、减法	`+`、`-`
6	移位运算符	`<<`、`>>`、`>>>`
7	关系运算符	`<`、`<=`、`>=`、`>`、`instanceof`
8	等价运算符	`==`、`!=`
9	按位与	`&`
10	按位异或	`^`
11	按位或	`
12	条件与	`&&`
13	条件或	`
14	三元运算符	`? :`
15	赋值运算符	`=`、`+=`、`-=`、`*=`、`/=`、`%=`
16	位赋值运算符	`&=`、`

开发建议：

不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，尽量使用()来控制表达式的执行顺序。

不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它分成几步来完成。例如： (num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;

Java变量与运算符

Contents

关键字（keyword）

标识符( identifier)

变量

基本数据类型

`整数类型`:int

`浮点类型`:double

`字符类型`：char

`布尔类型`：boolean

基本数据类型变量间运算规则

自动类型提升

强制类型转换

基本数据类型与String的运算

字符串类型：String

运算规则

计算机底层如何存储数据

进制转换(未看)

运算符（Operator）

算术运算符

赋值运算符

比较(关系)运算符

逻辑运算符

位运算符

条件运算符

运算符优先级

字符集

Contents

关键字（keyword）

标识符( identifier)

变量

基本数据类型

整数类型:int

浮点类型:double

字符类型：char

布尔类型：boolean

基本数据类型变量间运算规则

自动类型提升

强制类型转换

基本数据类型与String的运算

字符串类型：String

运算规则

计算机底层如何存储数据

进制转换(未看)

运算符（Operator）

算术运算符

赋值运算符

比较(关系)运算符

逻辑运算符

位运算符

条件运算符

运算符优先级

字符集

`整数类型`:int

`浮点类型`:double

`字符类型`：char

`布尔类型`：boolean