Java基础
# 关键字
| 关键字 | 用途 |
|---|---|
| class | 定义类 |
| extends | 继承 Activity/Service |
| implements | 实现接口 |
| public | 公开方法 |
| private | 隐藏变量 |
| static | 工具方法 |
| final | 常量 |
| new | 创建对象 |
| this | 当前对象 |
| super | 调用父类 |
| override | 重写方法 |
| interface | 回调接口 |
| synchronized | 线程安全 |
# 语法
# 字面量
| 类型 | 示例 | 说明 |
|---|---|---|
| 整数 | 100 | 默认int |
| 小数 | 3.14 | 默认double |
| 字符 | 'A' | 单个字符 |
| 字符串 | "Java" | 多个字符 |
| 布尔 | true | 真 |
| 空 | null | 无对象引用 |
# 变量
| 内容 | 说明 |
|---|---|
| 变量 | 存储数据的空间 |
| 数据类型 | 决定存储什么数据 |
| 变量名 | 标识数据 |
| 数据值 | 实际保存内容 |
# 计算机存储规则
8 bit = 1 字节
1024 字节 = 1 KB
int 4字节
int a = 10(1010)
0000 0000 0000 0000 0000 0000 0000 1010
1
2
2
# 数据类型
# 基本类型
取值范围 double > float > long > int > short > byte
| 类型 | 大小 | 示例 |
|---|---|---|
| byte | 1字节 | byte a=10 |
| short | 2字节 | short a=10 |
| int | 4字节 | int age=18 |
| long | 8字节 | long num=100L |
| float | 4字节 | float f=1.2F |
| double | 8字节 | double d=1.2 |
| char | 2字节 | 'A' |
| boolean | - | true |
# 引用类型
# 标识符规则
| 正确 | 错误 |
|---|---|
userName | 1name |
_age | class |
$price | a-b |
# Scanner键盘输入
import java.util.Scanner;
// 1. 找到Scanner 这个打工人
Scanner sc = new Scanner(System.in);
// 2. 让Scanner干活
// 接收键盘录入的整数
/*int num = sc.nextInt();
System.out.println(num);*/
// 接收键盘录入的小数
/* double num2 = sc.nextDouble();
System.out.println(num2);*/
// 接收键盘录入的文本（字符串）
String str = sc.next();
System.out.println(str);
-----------------------------------------------------------------------------------------
/*
定义两个整数类型的变量num1和num2，键盘录入数据分别为两个变量赋值。
求两个数的和并进行打印。
*/
// 1.找到Scanner这个打工人
Scanner sc = new Scanner(System.in);
// 2.让Scanner干活
System.out.println("请键盘录入第一个整数:");
int num1 = sc.nextInt();
System.out.println(num1);
// 3. 让Scanner再次接收第二个整数
System.out.println("请键盘录入第二个整数");
int num2 = sc.nextInt();
System.out.println(num2);
// 4.求和
int result = num1 + num2;
System.out.println(result);
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
| 方法 | 输入 |
|---|---|
nextInt() | 整数 |
nextDouble() | 小数 |
next() | 字符串 |
# 算数运算符
| 运算符 | 作用 | 示例 |
|---|---|---|
| + | 加 | a+b |
| - | 减 | a-b |
| * | 乘 | a*b |
| / | 除 | a/b |
| % | 取余 | a%2 |
Java 小说明（整数除法）公式总结：
个位：数值 % 10
十位：数值 / 10 % 10
百位：数值 / 100 % 10
千位：数值 / 1000 % 10;
时间转换
// 1. 定义变量记录秒数
int seconds = 7242;
// 2. 获取小时数
int hours = seconds / 3600; //3661 / 3600 = 1 .... 61
System.out.println(hours);
// 3. 获取分钟数
// 总秒数 - 小时数 3661 - 3600 = 61
// 61 / 60 = 1分钟 ... 1秒钟
// 3661 % 3600 = 1 ... 61
// 7220 % 3600 = 2 ... 20
int min = seconds % 3600 / 60;
System.out.println(min);
// 4. 获取秒数
int second = seconds % 3600 % 60;
System.out.println(second);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 类型转换
数字运算：类型不一样不能运算，需要转成同类型的才能计算。
隐式转换的规则
- 触发时机：不同类型的数据进行计算，默认采取隐式转换，Java 自动转换，无需我们写代码
- 转换步骤 1：如有 byte short 类型的数据，先提升为 int 类型
- 转换步骤 2：把取值范围小的提升为取值范围大的，再进行运算
类型从小到大顺序：
byte → short → int → long → float → double
1
自动转换 小范围 → 大范围
int a=10;
double b=a;
1
2
2
强制转换 大范围 → 小范围
弊端：有可能导致精度丢失
double a=10.5;
int b=(int)a;
/* 练习二：
检查下面代码，程序运行的时候是否会报错，如果会，请说明错误原因*/
short s1 = 100;
short s2 = 200;
// int + int = int
// 修改方案1：
// 300 ：二进制 00000000 00000000 00000001 00101100
// 强制转换byte：00101100(44)
byte result1 = (byte)(s1 + s2);
System.out.println(result1);
// 修改方案2：
int result2 = s1 + s2;
System.out.println(result2); // 300
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 字符运算
# char底层对应数字编码：
char c='A';
System.out.println(c+1);
// 实现字母的大小写转换，将大写字母转化为小写字母
// A ---> a
// 1. 定义变量记录大写的字符
char c = 'A';
// ASCII 码：'A'是 65，'a'是 97，大小写字母相差 32。
// 2. 转成小写
// 65 + 32 -- 97
char cc = (char)(c + 32);
System.out.println(cc);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 字符串拼接
| 操作 | 示例 |
|---|---|
| 字符串+数字 | "年龄"+18 |
| 字符串+变量 | "name="+name |
# 自增自减
| 运算 | 含义 |
|---|---|
++i | 先加后用 |
i++ | 先用后加 |
--i | 先减后用 |
i-- | 先用后减 |
# 赋值运算符
| 运算符 | 等价 |
|---|---|
+= | a=a+b |
-= | a=a-b |
*= | a=a*b |
/= | a=a/b |
# 关系运算符
| 符号 | 说明 |
|---|---|
| > | 大于 |
| < | 小于 |
| >= | 大于等于 |
| <= | 小于等于 |
| == | 等于 |
| != | 不等于 |
# 逻辑运算符
| 符号 | 名称 | 示例 |
|---|---|---|
| & | 与 | 年龄>=18 & 年龄<60 |
| | | 或 | 年龄>=18 | 年龄<60 |
| ! | 非 | !true |
# 短路逻辑
| 运算 | 特点 |
|---|---|
| && | 左边false，右边不执行 |
| || | 左边为 true，右边不执行 |
// 1. 键盘录入一个四位整数
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个四位整数：");
int number = sc.nextInt();
// 2. 数字拆分
int ge = number % 10;
int shi = number / 10 % 10;
int bai = number / 100 % 10;
int qian = number / 1000 % 10;
System.out.println(ge);
System.out.println(shi);
System.out.println(bai);
System.out.println(qian);
// 3. 判断是否为回文数
// qian == ge && bai == shi
System.out.println(qian == ge && bai == shi);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 三元运算符
条件 ? 结果1 : 结果2
int max=a>b?a:b;
1
2
3
2
3
# 运算符优先级
| 优先级 | 运算 |
|---|---|
| 1 | () |
| 2 | ++ -- |
| 3 | * / % |
| 4 | + - |
| 5 | > < >= <= |
| 6 | == != |
| 7 | && |
| 8 | |
| 9 | ?: |
| 10 | = |
# 判断
if
if(布尔条件){
条件成立执行的代码;
}
1
2
3
2
3
# 选择
switch
switch(表达式){
case 值1:
代码;
break;
case 值2:
代码;
break;
default:
都不匹配执行;
}
public static void main(String[] args) {
/*
switch的注意点：
1. 表达式：结果（字符/整数byte short int/枚举/字符串）--- 跳转表，索引不支持小数，也不支持大的整数long
2. case：被匹配的值，只能是真实的数据 --- 不能写变量的
3. case：值不允许重复
4. break：表示中断，结束的意思，结束switch语句 --- break关键字，作用结束switch语句 -- 没有berak会穿透
5. default：所有情况都不匹配，执行该处的内容 --- if里面的else是非常类似的
*/
int number = 1;
switch (number) {
case 1:
System.out.println("一");
break;
case 2:
System.out.println("二");
break;
case 3:
System.out.println("三");
break;
default:
System.out.println("没有这个数字");
break;
}
}
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
28
29
30
31
32
33
34
35
36
37
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
28
29
30
31
32
33
34
35
36
37
新特性
public static void main(String[] args) {
/*
3. switch新特性：JDK12预览版 JDK14正式版
一、箭头标签
二、case后面可以写多个值
三、switch可以有运行结果
四、yield关键字
*/
int number = 8;
String name = switch (number) {
case 1, 2, 3, 4, 5 -> {
yield "一";
}
case 6, 7, 8 -> {
yield "二";
}
case 9, 10, 11 -> {
yield "三";
}
default -> {
yield "没有这个星期";
}
};
// 如果下面，我要继续使用switch的结果，就无法操作
System.out.println(name);
}
String name = switch (number) {
case 1, 2, 3, 4, 5 -> "一";
case 6, 7, 8 -> "二";
case 9, 10, 11 -> "三";
default -> "没有这个星期";
};
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
28
29
30
31
32
33
34
35
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
28
29
30
31
32
33
34
35
# 循环
for
for(初始化;循环条件;增量){
循环体代码;
}
初始化语句条件判断语句
不成立 → 其他语句
成立 → 循环体语句 → 条件控制语句 →（回到条件判断语句）其他语句
// 例子
// 1. 定义求和变量
int sum = 0;
// 2.获取1-5这个范围中的每一个数字，累加到sum当中
// 第一次循环：i = 1 判断 i <= 5
// 1 + 0 = 1 ---> sum
// i++ i = 2 第一次循环结束
// 第二次循环：i <= 5
// 2 + 1 = 3 ---> sum
// i++ i = 3 第二次循环结束
// 第三次循环：i <= 5
// 3 + 3 = 6 ---> sum
// i++ i = 4 第三次循环结束
// 第四次循环：i <= 5
// 4 + 6 = 10 ---> sum
// i++ i = 5 第四次循环结束
// 第五次循环：i <= 5
// 5 + 10 = 15 ---> sum
// i++ i = 6 第五次循环结束
// 第六次循环：i <= 5 --- 6 <= 5 false -- 循环结束
for (int i = 1; i <= 5; i++){
// 把当前获取到的数字加到sum当中
sum = i + sum;
}
// 3. 输出
System.out.println("1 - 5之间的数字和为: " + sum);
// 定义一个变量用于求和
int sum = 0;
// 1. 利用循环获取1‑100之间的每一个数据
for(int i = 1; i <= 100; i++){
// 2. 利用if语句进行判断
if(i % 2 == 0){
// sum = i + sum;
sum += i;
}
}
public static void main(String[] args) {
/*
有一组特殊的数字，从第三项开始，每一项都是前两项的数字和，请问第10项的数字是多少？
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89...
*/
// 1. 定义两个变量，去记录前两项的值
int a = 0;
int b = 1;
// 2. 定义一个变量，赋值为0，表示a和b后面那一项的值
int c = 0;
// 3. 利用循环不断获取这些特殊数字每一项的值
// 开始条件：3
// 结束条件：10
// 循环体：① 求c的值 ② 不断的修改a和b记录的值
for (int i = 3; i <= 10; i++) {
// 求c的值（求前一组最后一个值）
c = a + b;
// 不断的修改a和b记录的值（求下一组前两个值）
a = b;
b = c;
}
System.out.println(c);
}
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
while
初始化;
while(条件判断语句){
循环体;
条件控制;
}
初始化语句 → 条件判断语句
条件不成立：直接到其他语句，循环结束
条件成立：循环体语句 → 条件控制语句 → 返回条件判断语句继续循环
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
for 和 while 的区别：
➢ for 循环中：知道循环次数或者循环的范围
➢ while 循环：不知道循环的次数和范围，只知道循环的结束条件。
dowhile
初始化;
do{
循环体;
增量;
}while(条件);
1
2
3
4
5
2
3
4
5
无限循环
for(;;){}
while(true){}
1
2
2
break
跳出所在整个循环，循环直接结束。
continue
跳过本次循环剩下代码，直接进入下一轮循环，循环不会结束。
循环嵌套
外层循环控制行数，内层循环控制每行输出内容。
# 数组
初始化（静态、动态）
//静态初始化
//完整格式：
//数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，…，元素n};
//简写格式：
//数据类型[] 数组名 = {元素1，元素2，元素3，…，元素n};
// 1.定义数组存储3位同学的年龄
int[] ageArr1 = new int[]{18, 19, 20};
int[] ageArr2 = {18, 19, 20};
// 2.定义数组存储5位同学的身高
double[] heightArr1 = new double[]{1.93, 1.92, 1.21, 1.70, 1.75};
double[] heightArr2 = {1.93, 1.92, 1.21, 1.70, 1.75};
// 3.定义数组存储3位同学的名字
// zhangsan String
String[] nameArr1 = new String[]{"zhangsan", "lisi", "wangwu"};
String[] nameArr2 = {"zhangsan", "lisi", "wangwu"};
// 动态初始化
/*
需求：键盘录入5个的整数，存入数组当中，并进行遍历
动态初始化的格式：
数据类型[] 数组名 = new 数据类型[数组的长度];
*/
// 键盘录入5个的整数，存入数组当中，并进行遍历
// 1. 创建数组
int[] arr = new int[5];
// 2.键盘录入
Scanner sc = new Scanner(System.in);
for (int i = 0; i < arr.length; i++) {
System.out.println("请输入一个整数:");
int num = sc.nextInt(); // 2
// 把接收到的数据赋值给数组
arr[i] = num;//2
}
// 3. 遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
访问元素
int[] ageArr2 = {18, 19, 20};
ageArr2[0]
1
2
2
遍历元素
// 长度
ageArr2.length
1
2
2
数组算法（找最大值、查找、去重等）
# 方法
把一段重复代码封装起来，需要的时候调用，提高复用。
public static void 方法名(){
方法体;
}
1
2
3
2
3
上次更新: 2026/08/21, 09:59:48