变量的声明和使用
变量的声明方式
举例:
1
2
3
4
5
6
7
| public class VarTest {
public static void main(String[] args) {
int age = 18;
System.out.println("age = " + age);
}
|
使用变量的注意事项
- 使用变量之前需要声明
- 使用变量之前需要初始化
- 变量不能重复声明
标识符的命令法则
- 由数字、字母、下划线以及$等组成，其中不能以数字开头
- 不能使用java语言的关键字。
- 区分大小写，长度没有限制但不宜过长
- 尽量做到见名知意，支持中文但不推荐使用
- 标识符可以给类/变量/属性/方法/包 起名
数据类型分类
- 基本数据类型
- byte、short、int、long、float、double、boolean、char
- 引用数据类型
整数类型
- Java语言中描述整数数据的类型有：byte、short、int、long
- 其中byte类型在内存空间中占1个字节，表示的范围是: -2^7 ~ 2^7-1
- 其中short类型在内存空间中占2个字节，表示范围是：-2^15 ~ 2^15-1
- 其中int类型在内存空间中占4个字节，表示范围是：-2^31 ~ 2^31-1
- 其中long类型在内存空间中占8个字节，表示范围是：-2^63 ~ 2^63-1
浮点类型
- Java语言中用于描述小数数据的类型：float 和 double，推荐double类型
- 其中float类型在内存空间占4个字节，叫做单精度浮点数，可以表示7位 有效数字，范围：-3.403E38~3.403E38
- 其中double类型在内存空间占8个字节，叫做双精度浮点数，可以表示15 位有效数字，范围：-1.798E308~1.798E308
布尔类型
- Java语言中用于描述真假信息类型有：boolean，数值只有：true 和 false
- 布尔类型在内存空间中所占大小没有明确的规定，可以认为是1个字节
字符类型
- Java语言中用于描述单个字符的数据类型：char类型。如：’a’、 ‘中’等
- 其中char类型在内存空间中占2个字节并且没有符号位，表示的范围是： 0 ~ 65535，由于现实生活中很少有数据能够被单个字符描述，因此以后 的开发中更多的使用由多个字符串起来组成的字符串，使用String类型加 以描述，如：“hello”等。
基本数据类型之间的转换
- Java语言中基本数据类型之间的转换方式：自动类型转换和强制类型转换
- 其中自动类型转换主要指从小类型到大类型之间的转换
- 其中强制类型转换主要指从大类型到小类型之间的转换，语法格式如下： 目标类型 变量名 = (目标类型)源类型变量名;
运算符
算术运算符
- +表示加法运算符
- -表示减法运算符
- *表示乘法运算符
- /表示除法运算符
- %表示取余运算符
例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
System.out.println("请输入一个正整数的秒数：");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
int hour = num / 3600;
int min = num % 3600 / 60;
int sec = num % 60;
System.out.println(num + "秒转换为" + hour + "小时" + min + "分钟" + sec + "秒钟");
}
}
|
关系运算符
>，>=，<，<=，==，!=- 所有以关系运算符作为最终运算的表达式结果一定是boolean类型
例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
import java.util.Scanner;
public class RelationJudgeTest {
public static void main(String[] args) {
System.out.println("请输入一个整数：");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
boolean b1 = num < 0;
System.out.println("b1 = " + b1);
System.out.println(num < 0);
}
}
|
自增减运算符
- ++表示自增，用于使得当前变量自身的数值加1
- —表示自减，用于使得当前变量自身的数值减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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
public class SelfTest {
public static void main(String[] args) {
int ia = 10;
System.out.println("ia = " + ia);
ia++;
System.out.println("ia = " + ia);
++ia;
System.out.println("ia = " + ia);
--ia;
System.out.println("ia = " + ia);
ia--;
System.out.println("ia = " + ia);
System.out.println(ia++);
System.out.println("ia = " + ia);
System.out.println(++ia);
System.out.println("ia = " + ia);
int ib = ia++;
System.out.println("ib = " + ib);
System.out.println("ia = " + ia);
int ic = ++ia;
System.out.println("ic = " + ic);
System.out.println("ia = " + ia);
System.out.println(ia++ + ++ia);
System.out.println("ia = " + ia);
}
}
|
逻辑运算符
&& 表示逻辑与运算符，“并且”，同真为真，一假为假||表示逻辑或运算符，“或者”，一真为真，同假为假!表示逻辑非运算符，“取反”，真为假，假为真- 逻辑运算符的操作数均为boolean表达式
- 对于逻辑与运算符来说，若第一个表达式为假则结果为假，此时跳过第 二个表达式
- 对于逻辑或运算符来说，若第一个表达式为真则结果为真，此时跳过第 二个表达式
例子：
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
| public class LogicTest {
public static void main(String[] args) {
boolean b1 = true;
boolean b2 = false;
System.out.println("b1 = " + b1);
System.out.println("b2 = " + b2);
System.out.println("---------------------------------------------");
boolean b3 = b1 && b2;
System.out.println("b3 = " + b3);
System.out.println(b1 && b2);
System.out.println(b1 || b2);
System.out.println(!b1);
System.out.println(!b2);
System.out.println("---------------------------------------------");
int ia = 3;
int ib = 5;
boolean b4 = (++ia == 3) && (++ib == 5);
System.out.println("b4 = " + b4);
System.out.println("ia = " + ia);
System.out.println("ib = " + ib);
boolean b5 = (++ia == 5) || (++ib == 5);
System.out.println("b5 = " + b5);
System.out.println("ia = " + ia);
System.out.println("ib = " + ib);
}
}
|
三目运算符
- 条件表达式? 表达式1: 表达式2
- 判断条件表达式是否成立，若成立则执行表达式1，否则执行表达式2
赋值运算符
- = 表示赋值运算符，用于将=右边的数据赋值给=左边的变量，覆盖变量 原来的数值
移位运算符
- << 左移运算符，用于将数据的二进制位向左移动，右边使用0补充
- >> 右移运算符，用于将数据的二进制位向右移动，左边使用符号位补充
- >>> 表示逻辑右移运算符，用于将数据的二进制位向右移动，左边使用0 补充
位运算符
- & 表示按位与运算符，按照二进制位进行与运算，同1为1，有一个为0就为0
- |表示按位或运算符，按照二进制位进行或运算，有一个为1就为1，同0为0
- ~ 表示按位取反运算符，按照二进制位进行取反，1为0，0为1
- ^ 表示按位异或运算符，按照二进制位进行异或运算，同为0，不同为1
例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| public class BitTest {
public static void main(String[] args) {
byte b1 = 11;
byte b2 = 13;
System.out.println("b1 = " + b1);
System.out.println("b2 = " + b2);
System.out.println("---------------------------------------------------");
System.out.println( b1 & b2);
System.out.println( b1 | b2);
System.out.println( b1 ^ b2);
System.out.println( ~ b1);
}
}
|
流程控制
if…else…
例子：
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
|
import java.util.Scanner;
public class IfElseTest {
public static void main(String[] args) {
System.out.println("请输入一个整数：");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
if(num < 0) {
System.out.println(num + "是负数！");
} else {
if(num > 0) {
System.out.println(num + "是正数!");
} else {
System.out.println(num + "是零！");
}
}
}
}
|
switch case分支结构
1
2
3
4
5
6
| switch(变量/表达式){
case 值1: 语句块1;break;
case 值2: 语句块2;break;
……
default:语句块n
}
|
- switch()中支持的数据类型有：byte、short、char以及int类型，从jdk1.5 开始支持枚举类型，从jdk1.7开始支持String类型。
循环结构
for循环
1
2
3
| for(初始化表达式; 条件表达式; 修改初始值表达式){
循环体;
}
|
例1: for循环打印1-100的所有奇数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| public class ForNumTest {
public static void main(String[] args) {
for(int i = 1; i <= 100; i++) {
if(i % 2 != 0) {
System.out.println("i = " + i);
}
}
for(int i = 1; i <= 100; i += 2) {
System.out.println("i = " + i);
}
}
|
例2：for循环实现1 ~ 10000之间所有整数的累加和
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| public class ForSumTest {
public static void main(String[] args) {
int sum = 0;
for(int i = 1; i <= 10000; i++) {
sum += i;
}
System.out.println("sum = " + sum);
}
}
|
continue关键字
- continue语句用在循环体中，用于结束本次循环而开始下一次循环
break关键字
- break用于退出当前语句块，break用在循环体中用于退出循环
- for(;;) - 这种没有循环条件的循环叫做 无限循环，俗称“死循环”
双重for循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public class TableTest {
public static void main(String[] args) {
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + "x" + i + "=" + j * i + " ");
}
System.out.println();
}
}
}
|
while循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| while(条件表达式){
循环体;
}
public class WhileTest {
public static void main(String[] args) {
int i = 1;
while (i <= 10) {
System.out.println("i = " + i);
i++;
}
}
}
|
while循环和for循环区别
- while循环和for循环完全可以互换，当然推荐使用for循环
- while循环更适合于明确循环条件但不明确循环次数的场合中
- for循环更适合于明确循环次数或范围的场合中
- while(true) 等价于 for(;;) 都表示无限循环
do while循环
- do-while循环主要用于至少执行一次循环体的场合中
1
2
3
| do{
循环体;
}while(条件表达式);
|
数组
一维数组的基本概念
- 当需要在Java程序中记录单个数据内容时，则声明一个变量即可。
- 当需要在Java程序中记录多个类型相同的数据内容时，则声明一个一维数 组即可，一维数组本质上就是在内存空间中申请一段连续的存储单元
- 数组是相同数据类型的多个元素的容器，元素按线性顺序排列，在Java语 言中体现为一种引用数据类型。
一维数组的声明方式
- 数据类型[] 数组名称 = new 数据类型[数组的长度];
- 调用数组的length属性可以获取数组的长度
一维数组的初始化方式
- 基本类型的数组（数据元素为基本类型）创建后，其元素的初始值：byte、 short、char、int、long为0；float和double为0.0；boolean为false
- 可以在数组声明的同时进行初始化，具体如下： 数据类型[] 数组名称 = {初始值1, 初始值2, …};
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
|
public class ArrayTest {
public static void main(String[] args) {
int[] arr1 = new int[2];
System.out.println("数组的长度是：" + arr1.length);
System.out.println("下标为0的元素是：" + arr1[0]);
System.out.println("下标为1的元素是：" + arr1[1]);
System.out.println("------------------------------------------------");
for(int i = 0; i < arr1.length; i++) {
System.out.println("下标为" + i + "的元素是：" + arr1[i]);
}
System.out.println("arr1 = " + arr1);
System.out.println("------------------------------------------------");
double[] arr2 = new double[5];
for(int i = 0; i < arr2.length; i++) {
System.out.println("下标为" + i + "的元素是：" + arr2[i]);
}
System.out.println("------------------------------------------------");
char[] arr3 = {'a', 'b', 'c', 'd'};
for(int i = 0; i < arr3.length; i++) {
System.out.println("下标为" + i + "的元素是：" + arr3[i]);
}
System.out.println("------------------------------------------------");
boolean[] arr4 = new boolean[]{true, true, false, false};
for(int i = 0; i < arr4.length; i++) {
System.out.println("下标为" + i + "的元素是：" + arr4[i]);
}
}
}
|
内存结构
- 栈用于存放程序运行过程当中所有的局部变量。一个运行的Java程序从开 始到结束会有多次变量的声明
- JVM会在其内存空间中开辟一个称为“堆”的存储空间，这部分空间用于存 储使用new关键字创建的数组和对象
数组的优缺点
- 可以直接通过下标(或索引)的方式访问指定位置的元素，速度很快。
- 数组要求所有元素的类型相同。
- 数组要求内存空间连续，并且长度一旦确定就不能修改。
- 增加和删除元素时可能移动大量元素，效率低。
一维数组的拷贝
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
| public class ArrayCopyTest {
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55};
System.out.print("第一个数组中的元素有：");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("----------------------------------------------------------");
int[] brr = new int[3];
System.out.print("第二个数组中的元素有：");
for(int i = 0; i < brr.length; i++) {
System.out.print(brr[i] + " ");
}
System.out.println();
System.out.println("----------------------------------------------------------");
System.arraycopy(arr, 1, brr, 0, 3);
System.out.print("第二个数组中的元素有：");
for(int i = 0; i < brr.length; i++) {
System.out.print(brr[i] + " ");
}
System.out.println();
System.out.println("----------------------------------------------------------");
brr = arr;
System.out.print("第二个数组中的元素有：");
for(int i = 0; i < brr.length; i++) {
System.out.print(brr[i] + " ");
}
System.out.println();
}
}
|
例子：
- 编程统计用户输入任意一个正整数中每个数字出现次数的统计并打印
- 如：123123 => 1出现2次，2出现2次，3出现2次
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
| import java.util.Scanner;
public class ArrayCountTest {
public static void main(String[] args) {
System.out.println("请输入一个正整数：");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
int[] arr = new int[10];
int temp = num;
while(temp > 0) {
arr[temp%10]++;
temp /= 10;
}
for(int i = 0; i < arr.length; i++) {
if(arr[i] > 0) {
System.out.println("数字" + i + "出现了" + arr[i] + "次！");
}
}
}
}
|
数组工具类
- java.util.Arrays类可以实现对数组中元素的遍历、查找、排序等操作。
常用方法：
二维数组
- 二维数组本质上就是由多个一维数组摞在一起组成的数组，二维数组中 的每个元素都是一维数组，而一维数组中的每个元素才是数据内容
- 数据类型
[][] 数组名称 = new 数据类型[行数][列数];
- 数据类型
[][]数组名称 =
