1.基本数据类型
数据类型分为基本数据类型和引用数据类型，基本数据类型又可分为 4 类共8种，即整数类型（包括 byte、short，int 和 long）、浮点类型（包括 float 和 double）、字符类型（char）和布尔类型（boolean），下面分别介绍这 4 大类数据类型。
| 序号 |
数据类型 |
位数 |
默认值 |
取值范围 |
举例说明 |
| 1 |
byte(位) |
8 |
0 |
-2^7 - 2^7-1 |
byte b = 10; |
| 2 |
short(短整数) |
16 |
0 |
-2^15 - 2^15-1 |
short s = 10; |
| 3 |
int(整数) |
32 |
0 |
-2^31 - 2^31-1 |
int i = 10; |
| 4 |
long(长整数) |
64 |
0 |
-2^63 - 2^63-1 |
long l = 10l; |
| 5 |
float(单精度) |
32 |
0.0 |
-2^31 - 2^31-1 |
float f = 10.0f; |
| 6 |
double(双精度) |
64 |
0.0 |
-2^63 - 2^63-1 |
double d = 10.0d; |
| 7 |
char(字符) |
16 |
空 |
0 - 2^16-1 |
char c = ‘c’; |
| 8 |
boolean(布尔值) |
8 |
false |
true、false |
boolean b = true; |
long型常量用后缀L表示
float常量后面必须有后缀f或F
double常量后面可以有后缀d或D,允许省略
char类型 Unicode码 范围（\u0000到\uffff）
整型和布尔值之间不能转换
2.强制类型转换
数据类型的转换是在所赋值的数值类型和被变量接收的数据类型不一致时发生的，它需要从一种数据类型转换成另一种数据类型。数据类型的转换可以分为隐式转换（自动类型转换）和显式转换（强制类型转换）两种。
1.隐式转换（自动类型转换）
如果以下 2 个条件都满足，那么将一种类型的数据赋给另外一种类型变量的时，将执行自动类型转换（automatic type conversion）:
- 两种数据类型彼此兼容
- 目标类型的取值范围大于源数据类型（低级类型数据转换成高级类型数据）
在运算过程中，由于不同的数据类型会转换成同一种数据类型，所以整型、浮点型以及字符型都可以参与混合运算。自动转换的规则是从低级类型数据转换成高级类型数据。转换规则如下：
数值型数据的转换：byte→short→int→long→float→double。
字符型转换为整型：char→int。
2.显式转换（强制类型转换）
当两种数据类型不兼容，或目标类型的取值范围小于源类型时，自动转换将无法进行，这时就需要进行强制类型转换。
其中，type 为 variableName 要转换成的数据类型，而 variableName 是指要进行类型转换的变量名称
1
2
3
| int a = 3;
double b = 5.0;
a = (int)b;
|
3.运算符
1.算术运算符
表格中的实例假设整数变量A的值为10，变量B的值为20：
| 操作符 |
描述 |
例子 |
| + |
加法 - 相加运算符两侧的值 |
A + B 等于 30 |
| - |
减法 - 左操作数减去右操作数 |
A – B 等于 -10 |
| * |
乘法 - 相乘操作符两侧的值 |
A * B等于200 |
| / |
除法 - 左操作数除以右操作数 |
B / A等于2 |
| ％ |
取余 - 左操作数除以右操作数的余数 |
B%A等于0 |
| ++ |
自增: 操作数的值增加1 |
B++ 或 ++B 等于 21 |
| – |
自减: 操作数的值减少1 |
B-- 或 --B 等于 19 |
- 自增（++）自减（–）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。
- 前缀自增自减法(++a,–a): 先进行自增或者自减运算，再进行表达式运算
- 后缀自增自减法(a++,a–): 先进行表达式运算，再进行自增或者自减运算
2.关系运算符
表格中的实例整数变量A的值为10，变量B的值为20：
| 运算符 |
描述 |
例子 |
| == |
检查如果两个操作数的值是否相等，如果相等则条件为真。 |
（A == B）为假。 |
| != |
检查如果两个操作数的值是否相等，如果值不相等则条件为真。 |
(A != B) 为真。 |
| > |
检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 |
（A> B）为假。 |
| < |
检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 |
（A < B）为真。 |
| >= |
检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 |
（A> = B）为假。 |
| <= |
检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 |
（A <= B）为真。 |
3.位运算符
Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。
位运算符作用在所有的位上，并且按位运算。假设a = 60，b = 13;它们的二进制格式表示将如下：
1
2
3
4
5
6
7
| A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A = 1100 0011
|
下表列出了位运算符的基本运算，假设整数变量 A 的值为 60 和变量 B 的值为 13：
| 操作符 |
描述 |
例子 |
| ＆ |
如果相对应位都是1，则结果为1，否则为0 |
（A＆B），得到12，即0000 1100 |
| ``` |
``` |
如果相对应位都是 0，则结果为 0，否则为 1 |
| ^ |
如果相对应位值相同，则结果为0，否则为1 |
（A ^ B）得到49，即 0011 0001 |
| 〜 |
按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 |
（〜A）得到-61，即1100 0011 |
| << |
按位左移运算符。左操作数按位左移右操作数指定的位数。 |
A << 2得到240，即 1111 0000 |
| >> |
按位右移运算符。左操作数按位右移右操作数指定的位数。 |
A >> 2得到15即 1111 |
| >>> |
按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 |
A>>>2得到15即0000 1111 |
4.逻辑运算符
下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假
| 操作符 |
描述 |
例子 |
| && |
称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。 |
（A && B）为假。 |
| ``` |
|
``` |
| ！ |
称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 |
！（A && B）为真。 |
5.赋值运算符
| 操作符 |
描述 |
例子 |
| = |
简单的赋值运算符，将右操作数的值赋给左侧操作数 |
C = A + B将把A + B得到的值赋给C |
| + = |
加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 |
C + = A等价于C = C + A |
| - = |
减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 |
C - = A等价于C = C - A |
| * = |
乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 |
C * = A等价于C = C * A |
| / = |
除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 |
C / = A，C 与 A 同类型时等价于 C = C / A |
| （％）= |
取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 |
C％= A等价于C = C％A |
| << = |
左移位赋值运算符 |
C << = 2等价于C = C << 2 |
| >> = |
右移位赋值运算符 |
C >> = 2等价于C = C >> 2 |
| ＆= |
按位与赋值运算符 |
C＆= 2等价于C = C＆2 |
| ^ = |
按位异或赋值操作符 |
C ^ = 2等价于C = C ^ 2 |
| ``` |
=``` |
按位或赋值操作符 |
6.条件运算符（?:）
条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。
1
| variable x = (expression) ? value if true : value if false
|
expression 是一个布尔表达式。当 expression 为真时，执行 statement1， 否则就执行 statement3。此三元运算符要求返回一个结果，因此要实现简单的二分支程序，即可使用该条件运算符
1
2
3
| int x,y,z;
x = 6,y = 2;
z = x>y ? x-y : x+y;
|
7.Java运算符优先级
下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。
| 类别 |
操作符 |
关联性 |
| 后缀 |
() [] {} . (点操作符) |
左到右 |
| 一元 |
expr++ expr– |
从左到右 |
| 一元 |
++expr --expr + - ～ ！ |
从右到左 |
| 乘性 |
* /％ |
左到右 |
| 加性 |
+ - |
左到右 |
| 移位 |
>> >>> << |
左到右 |
| 关系 |
> >= < <= |
左到右 |
| 相等 |
== != |
左到右 |
| 按位与 |
＆ |
左到右 |
| 按位异或 |
^ |
左到右 |
| 按位或 |
``` |
``` |
| 逻辑与 |
&& |
左到右 |
| 逻辑或 |
``` |
|
| 条件 |
？： |
从右到左 |
| 赋值 |
= + = - = * = / =％= >> = << =＆= ^ = ``` |
``` = |
| 逗号 |
， |
左到右 |
4.流程控制
1.判断语句
if 结构
if-else 结构
1
2
3
4
5
6
| if (表达式) {
语句块1;
}
else {
语句块2;
}
|
多条件 if-else-if 结构
1
2
3
4
5
6
7
8
9
10
11
12
| if(表达式1) {
语句块1;
}
else if(表达式2) {
语句块2;
}
else if(表达式n) {
语句块n;
}
else {
语句块n+1;
}
|
switch 语句
1
2
3
4
5
6
7
8
9
10
11
| switch(表达式) {
case 值1:
语句块1;break;
case 值2:
语句块2;break;
…
case 值n:
语句块n;break;
default:
语句块n+1;break;
}
|
switch关键字后面小括号里的值，小括号里要放一个整型变量或字符型变量。表达式必须为 byte，short，int，char类型。
case标签可以是：
- 类型为 char、byte、 short 或 int 的常量表达式。
- 枚举常量。
- 从 Java SE 7 开始， case 标签还可以是字符串字面量。
2.循环语句
while 语句
do-while 语句
1
2
3
| do {
语句块;
}while(条件表达式);
|
for 语句
for 语句通常使用在知道循环次数的循环中。
1
2
3
| for(条件表达式1;条件表达式2;条件表达式3) {
语句块;
}
|
| 表达式 |
形式 |
功能 |
举例 |
| 条件表达式 1 |
赋值语句 |
循环结构的初始部分，为循环变量赋初值 |
int i=1 |
| 条件表达式 2 |
条件语句 |
循环结构的循环条件 |
i>40 |
| 条件表达式 3 |
迭代语句，通常使用++ 或 – 运算符 |
循环结构的迭代部分，通常用来修改循环变量的值 |
i++ |
for 关键字后面括号中的 3 个条件表达式必须用“;”隔开。
for 循环语句执行的过程为：首先执行条件表达式 1 进行初始化，然后判断条件表达式 2 的值是否为 true，如果为 true，则执行循环体语句块；否则直接退出循环。最后执行表达式 3，改变循环变量的值，至此完成一次循环。
foreach语句
foreach 循环语句是 for 语句的特殊简化版本，主要用于执行遍历功能的循环。
1
2
3
| for(类型 变量名:集合) {
语句块;
}
|
其中，“类型”为集合元素的类型，“变量名”表示集合中的每一个元素，“集合”是被遍历的集合对象或数组。每执行一次循环语句，循环变量就读取集合中的一个元素。
当使用 foreach 来迭代访问数组元素时，foreach 中的循环变量相当于一个临时变量，系统会把数组元素依次赋给这个临时变量，而这个临时变量并不是数组元素，它只是保存了数组元素的值。因此，如果希望改变数组元素的值，则不能使用这种 foreach 循环。
1
2
3
4
5
6
7
|
int[] numbers = { 43, 32, 53, 54, 75, 7, 10 };
System.out.println("----for each----");
for (int item : numbers) {
System.out.println("Count is:" + item);
}
|
