本篇文章将详细介绍顺序表的基本搭建过程。
我们都知道顺序表的底层其实就是数组，但是既然有了数组为什么还要有顺序表呢？

其实相比如数组，顺序表还是有很多优势的。比如动态扩容、增删查改效率高、支持动态元素类型、停供更多的操作方法等。顺序表相对于数组具有更高的灵活性和功能性，可以更方便地对数据进行操作和管理。

数据结构

数据结构是由“数据”和“结构”两词组成。
什么是数据？数据是记录事实、观察结果或描述信息的集合，通常以数字、文字、图像或声音的形式存在。
什么是结构？简单来说结构就是组织数据的方式。

数据结构是指计算机存储、组织和管理数据的方式。

线性表

线性表是n个具有相同特性的数据元素的有限序列，线性表是一种在实际中广泛使用的数据结构，常见的线性表有：==顺序表、链表、栈、队列、字符串==……

线性表在逻辑上是线性结构，也就是连续的一条直线，但物理上并不一定连续，线性表在物理上存储时， 通常以数组和链式结构的形式存储。

顺序表

为什么要有顺序表？

==顺序表的底层其实就是数组==。

顺序表是线性表的一种，并且顺序表在逻辑上和物理上都是线性的。

数组就可以管理数据，为什么还要有顺序表呢？数组也可以实现一些增删查改的操作，但是实现起来比较麻烦，于是顺序表就把这些比较麻烦的操作封装好，使我们使用起来更加方便。

概念及结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

顺序表也分静态顺序表和动态顺序表。

1. 静态顺序表：使用定长数组存储。

2. 动态顺序表：使用动态开辟的数组存储。

静态顺序表底层是定长数组，==空间给大了浪费，给小了不够，有缺陷==。

动态顺序表的空间大小是可变的，是由动态内存函数realloc对开辟的动态内存空间进行调整。

我们通常使用动态顺序表。

接口实现：

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

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

// 顺序表的动态存储
typedef int sl_data_type
{
    sl_data_type* arr;  // 指向动态开辟的数组     
    int size;       // 表示数组中存储了多少个数据
    int capacity;   // 数组实际能存数据的空间容量是多大
}SL;

//顺序表初始化
void sl_init(SL* ps);
//头插
void sl_push_front(SL* ps, sl_data_type x);
//尾插
void sl_push_back(SL* ps, sl_data_type x);
//在指定位置之前插入数据
void sl_insert(SL* ps, int pos, sl_data_type x);
//头删
void sl_pop_front(SL* ps);
//尾删
void sl_pop_back(SL* ps);
//删除指定位置的数据
void sl_erase(SL* ps, int pos);
//顺序表的查找
int sl_find(SL* ps, sl_data_type x);
//顺序表打印
void sl_print(const SL sl);
//顺序表销毁
void sl_destroy(SL* ps);

创建和初始化

首先我们需要一个指针来接收由动态内存函数开辟的空间，还需要一个变量记录当前顺序表内数据个数，因为我们创建的是动态顺序表，大小经常变化，所以我们还需要一个变量来记录当前空间的大小。最后我们再把这些值封装到一个结构体中，这个结构体就是我们要创建的动态顺序表。

1
2
3
4
5
6
7
8
9

//顺序表管理数据的类型
typedef int sl_data_type;

typedef struct seqlist
{
sl_data_type* arr;
int size;//表示数组中存储了多少个数据
int capacity;//空间大小
}SL;

我们希望创建的顺序表能管理多种类型的数据，所以使用类型重定义标识符typedef。
创建好顺序表后，为了以后使用方便我们将它的初始化步骤也分装成一个函数：

1
2
3
4
5
6

void sl_init(SL* ps)
{
ps->arr = NULL;
ps->size = 0;
ps->capacity = 0;
}

注意指针要赋NULL。

头插

创建和初始化顺序表后，我们来实现在顺序表头部插入数据。

插入数据是直接插吗？不是的，我们还需要判断当前顺序表中是否有足够的空间让我们插入数据，因为不管是哪种插入的方式都要进行判断，所以我们干脆把这一步骤分装成一个函数，方便后续使用。

如何判断当前顺序表是否有足够的空间呢？是ps->capacity>0吗？
不是的，因为有一种特殊情况是当前顺序表的空间刚好被使用完，合理的判断条件是当ps->size == ps->capacity时，我们申请空间。
但是申请空间又有一个问题摆在我们面前：申请多大？仿佛又回到了定长数组的问题。
不过不要慌，由数学推理得出，一次申请空间大小是原空间大小2倍最合理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//检查是否有空间允许插入数据
void check_capacity(SL* ps)
{
if (ps->size == ps->capacity)
{
int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;//为了处理capacity为0的问题
sl_data_type* tmp = (sl_data_type*)realloc(ps->arr, newcapacity * sizeof(sl_data_type));
if (tmp == NULL)
{
perror("realloc fail!");
exit(1);
}
ps->arr = tmp;
tmp = NULL;
ps->capacity = newcapacity;//及时更新空间大小
}
}

空间大小需要乘以相应类型的大小。
在使用realloc函数时不要忘了其返回值也有为NULL的可能，所以需要一个临时指针过渡，这个临时指针使用完也不要忘了赋NULL，以防止其成为野指针。
顺序表的空间大小最后也不要忘了及时更新。
判断是否有足够的空间后，接下来就是在顺序表的头部插入数据。
我们先要将原先的数据向后挪动一位，将顺序表的第一位空出来，插入我们想插入的数据。

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

void sl_push_front(SL* ps, sl_data_type x)
{
assert(ps != NULL);
check_capacity(ps);
int i = 0;
for (i = ps->size; i > 0; i--)
{
ps->arr[i] = ps->arr[i - 1];
}
ps->arr[0] = x;
ps->size++;
}

开始插入操作之前，为了防止意外我们先判断一下传过来的顺序表的指针是否为空。
最后不要忘了给顺序表内记录数据个数的变量++。

尾插

相比于头插，尾插没有挪动原有数据的操作，在判断完空间大小和数据个数后直接在数据末尾插入就行，同样也不要忘了让记录数据个数的变量++

1
2
3
4
5
6

void sl_push_back(SL* ps, sl_data_type x)
{
assert(ps != NULL);
check_capacity(ps);
ps->arr[ps->size++] = x;
}

在指定位置前插入

顺序表中不止在头部和尾部插入数据，也可在指定的任意有效位置插入数据，所以我们的函数就要多一个指定位置的参数。
指定的位置还必须要有效，因为顺序表中的数据一定是连续的。
插入之前，我们需要将指定位置后面的数据往后挪动一位，给要插入的数据留出空间。

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

void sl_insert(SL* ps, int pos, sl_data_type x)
{
assert(ps != NULL);
assert(pos >= 0 && pos <= ps->size);//确保指定的位置是有效的
check_capacity(ps);
int i = 0;
for (i = ps->size; i > pos; i--)
{
ps->arr[i] = ps->arr[i - 1];
}
ps->arr[pos] = x;
ps->size++;
}

插入数据后，记录数据个数的变量不要忘了++。

头删

在删除完顺序表的第一个数据后，也需要将剩余的数据向前挪动一位，以确保数据是在下标为0处开始。
在删除数据之前，我们还要考虑到一种特殊情况，就是当前顺序表中没有数据，那没有数据肯定是不能进行删除操作的。

1
2
3
4
5
6
7
8
9
10
11

void sl_pop_front(SL* ps)
{
assert(ps != NULL);
assert(ps->size != 0);//顺序表为空不能删除
int i = 0;
for (i = 0; i < ps->size - 1; i++)
{
ps->arr[i] = ps->arr[i + 1];
}
ps->size--;
}

删除操作完成后，数据个数–；

尾删

尾删则比较简单，因为我们只需要让记录数据个数的变量-1，在访问顺序表的时候访问不到这个数据，就相当于删除了这个数据
同样的，尾删也需要考虑当前数据个数是否为0的情况。

1
2
3
4
5
6

void sl_pop_back(SL* ps)
{
assert(ps != NULL);
assert(ps->size != 0);//顺序表为空不能删除
ps->size--;
}

删除指定位置的数据

这个指定的位置也必须是有效的。
同时也要保证当前顺序表中的数据个数不为0。

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

void sl_erase(SL* ps, int pos)
{
assert(ps != NULL);
assert(ps->size != 0);//实际下面的断言侧面完成了这句代码
assert(pos >= 0 && pos < ps->size);//确保指定的位置是有效的
int i = 0;
for (i = pos; i < ps->size - 1; i++)
{
ps->arr[i] = ps->arr[i + 1];
}
ps->size--;
}

顺序表的查找

想要在顺序表中查找一个数据，只需要像遍历数组一样遍历顺序表就行。
找到则返回数据对应的下标，找不到则返回-1。

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

int sl_find(SL* ps, sl_data_type x)
{
assert(ps != NULL);
int i = 0;
for (i = 0; i < ps->size; i++)
{
if (ps->arr[i] == x)
{
return i;
}
}
return -1;
}

顺序表销毁

我们向内存申请了一块空间使用完成后，还要归还给操作系统
在上面调整顺序表大小的操作中，我们使用的是动态内存函数realloc，因此还要使用函数free释放掉动态开辟的空间，也不要忘了给指针赋NULL

1
2
3
4
5
6
7
8
9
10
11

void sl_destroy(SL* ps)
{
assert(ps != NULL);
if (ps->arr != NULL)//动态内存函数开辟了空间
{
free(ps->arr);
}
ps->arr = NULL;
ps->size = 0;
ps->capacity = 0;
}

测试

为了对我们创建的顺序表进行测试，方便起见再写一个打印函数。

1
2
3
4
5
6
7
8
9

void sl_print(const SL sl)
{
int i = 0;
for (i = 0; i < sl.size; i++)
{
printf("%d ", sl.arr[i]);
}
printf("\n");
}

测试代码如下：

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

void test()
{
SL sl;
sl_init(&sl);
sl_push_front(&sl, 1);
sl_push_front(&sl, 2);
sl_push_front(&sl, 3);
sl_print(sl);

sl_push_back(&sl, 4);
sl_push_back(&sl, 5);
sl_push_back(&sl, 6);
sl_print(sl);

sl_pop_front(&sl);
sl_print(sl);

sl_pop_back(&sl);
sl_print(sl);

sl_pop_front(&sl);
sl_print(sl);

sl_pop_back(&sl);
sl_print(sl);

sl_pop_front(&sl);
sl_print(sl);

sl_pop_back(&sl);
sl_print(sl);

sl_destroy(&sl);
}

运行结果：

结果和我们预期的效果一致。
整个程序的原码如下：

seqlist.h:

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

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//顺序表管理数据的类型
typedef int sl_data_type;

typedef struct seqlist
{
sl_data_type* arr;
int size;//数据个数
int capacity;//空间大小
}SL;

//顺序表初始化
void sl_init(SL* ps);
//头插
void sl_push_front(SL* ps, sl_data_type x);
//尾插
void sl_push_back(SL* ps, sl_data_type x);
//在指定位置之前插入数据
void sl_insert(SL* ps, int pos, sl_data_type x);
//头删
void sl_pop_front(SL* ps);
//尾删
void sl_pop_back(SL* ps);
//删除指定位置的数据
void sl_erase(SL* ps, int pos);
//顺序表的查找
int sl_find(SL* ps, sl_data_type x);
//顺序表打印
void sl_print(const SL sl);
//顺序表销毁
void sl_destroy(SL* ps);

seqlist.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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#define  _CRT_SECURE_NO_WARNINGS

#include "seqlist.h"

void sl_init(SL* ps)
{
ps->arr = NULL;
ps->size = 0;
ps->capacity = 0;
}

//检查是否有空间允许插入数据
void check_capacity(SL* ps)
{
if (ps->size == ps->capacity)
{
int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;//为了处理capacity为0的问题
sl_data_type* tmp = (sl_data_type*)realloc(ps->arr, newcapacity * sizeof(sl_data_type));
if (tmp == NULL)
{
perror("realloc fail!");
exit(1);
}
ps->arr = tmp;
tmp = NULL;
ps->capacity = newcapacity;//及时更新空间大小
}
}

void sl_push_front(SL* ps, sl_data_type x)
{
assert(ps != NULL);
check_capacity(ps);
int i = 0;
for (i = ps->size; i > 0; i--)
{
ps->arr[i] = ps->arr[i - 1];
}
ps->arr[0] = x;
ps->size++;
}

void sl_push_back(SL* ps, sl_data_type x)
{
assert(ps != NULL);
check_capacity(ps);
ps->arr[ps->size++] = x;
}

void sl_insert(SL* ps, int pos, sl_data_type x)
{
assert(ps != NULL);
assert(pos >= 0 && pos <= ps->size);//确保指定的位置是有效的
check_capacity(ps);
int i = 0;
for (i = ps->size; i > pos; i--)
{
ps->arr[i] = ps->arr[i - 1];
}
ps->arr[pos] = x;
ps->size++;
}

void sl_pop_front(SL* ps)
{
assert(ps != NULL);
assert(ps->size != 0);//顺序表为空不能删除
int i = 0;
for (i = 0; i < ps->size - 1; i++)
{
ps->arr[i] = ps->arr[i + 1];
}
ps->size--;
}

void sl_pop_back(SL* ps)
{
assert(ps != NULL);
assert(ps->size != 0);//顺序表为空不能删除
ps->size--;
}

void sl_erase(SL* ps, int pos)
{
assert(ps != NULL);
assert(ps->size != 0);
assert(pos >= 0 && pos < ps->size);//确保指定的位置是有效的
int i = 0;
for (i = pos; i < ps->size - 1; i++)
{
ps->arr[i] = ps->arr[i + 1];
}
ps->size--;
}

int sl_find(SL* ps, sl_data_type x)
{
assert(ps != NULL);
int i = 0;
for (i = 0; i < ps->size; i++)
{
if (ps->arr[i] == x)
{
return i;
}
}
return -1;
}

void sl_print(const SL sl)
{
int i = 0;
for (i = 0; i < sl.size; i++)
{
printf("%d ", sl.arr[i]);
}
printf("\n");
}

void sl_destroy(SL* ps)
{
assert(ps != NULL);
if (ps->arr != NULL)//动态内存函数开辟了空间
{
free(ps->arr);
}
ps->arr = NULL;
ps->size = 0;
ps->capacity = 0;
}

test.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

#define  _CRT_SECURE_NO_WARNINGS

#include "seqlist.h"

void test()
{
SL sl;
sl_init(&sl);
sl_push_front(&sl, 1);
sl_push_front(&sl, 2);
sl_push_front(&sl, 3);
sl_print(sl);

sl_push_back(&sl, 4);
sl_push_back(&sl, 5);
sl_push_back(&sl, 6);
sl_print(sl);

sl_pop_front(&sl);
sl_print(sl);

sl_pop_back(&sl);
sl_print(sl);

sl_pop_front(&sl);
sl_print(sl);

sl_pop_back(&sl);
sl_print(sl);

sl_pop_front(&sl);
sl_print(sl);

sl_pop_back(&sl);
sl_print(sl);

sl_insert(&sl, 0, 4);
sl_print(sl);

sl_erase(&sl, 1);
sl_print(sl);

int ret = sl_find(&sl, 3);
if (ret >= 0)
{
printf("%d\n", sl.arr[ret]);
}
else
{
printf("没找到");
}

sl_destroy(&sl);
}

int main()
{
test();
return 0;
}

总结

• 我们常用的是动态顺序表，通过realloc函数来对空间大小适当的扩容

• 顺序表中的元素在内存中是连续存储的，可以通过下标直接访问元素，提高了查找效率

• 适合： 频繁访问、很少插入和删除的数据集合。由于顺序表支持通过下标直接访问元素，适合频繁读取和遍历元素的场景

• 不适合： 频繁插入和删除的场景。由于插入和删除操作需要移动数据，频繁插入和删除会影响性能，不适合该类场景

变量是程序的基本组成单位

1
2
3
4
5
6
7
8
9

class Test{
    public static void main(String[] args){
    int a = 1; //定义一个变量，类型为int，变量名为a，并赋值为1
    int b = 3; //定义另一个变量，类型为int，变量名为b，并赋值为3
    b = 89; //把89赋值给b变量
    System.out.println(a); //输出a变量的值
    System.out.println(b); //输出b变量的值
    }
}

简单的原理示意图

变(变化)量(值)的介绍

概念

变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量(值)。

变量使用的基本步骤

• 声明变量

int a;

• 赋值

a = 60; //应该这么说: 把 60 赋给 a 使用 System.out.println(a);

变量快速入门

看演示并对代码进行说明， 演示记录 人的信息的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class Var02 { 

//编写一个main方法
public static void main(String[] args) {
//记录人的信息
int age = 30;
double score = 88.9;
char gender = '男';
String name = "king";
//输出信息, 快捷键
System.out.println("人的信息如下:");
System.out.println(name);
System.out.println(age);
System.out.println(score);
System.out.println(gender);
}
}

变量使用注意事项

举例:

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

public class VarDetail { 

//编写一个main方法
public static void main(String[] args) {
//变量必须先声明，后使用, 即有顺序
int a = 50;//int
System.out.println(a);//50
//该区域的数据/值可以在同一类型范围内不断变化
//a = "jack"; //×
a = 88; //对
System.out.println(a);//88

//变量在同一个作用域内不能重名
//int a = 77;//错误
}
}

//另外一个类
class Dog {
public static void main(String[] args) {
int a = 666;//对
}
}

程序中的 + 号的使用

1. 当 + 号两边都是数值类型时，则做加法运算

2. 当 + 号两边有一个是字符串类型，则做字符串拼接

1
2
3
4
5

System.out.println(100 + 98); ——> 198
System.out.println("100" + 98); ——> 10098

System.out.println(100 + 3 + "hello"); ——> 103hello
System.out.println("hello" + 100 + 3); ——> hello1003

数据，数据元素，数据项，数据对象

• 数据(Data):是客观事物的符号化表示，在计算机科学中指的是所有能输入到计算机程序中并被计算机程序处理的符号的总称。

• 数据元素(Data Element):是数据的基本单位，在程序中通常作为一个整体来进行考虑和处理。

• 数据项(Data Item):是指数据元素的组成部分，如整数、实数、字符、字符串等。数据项对客观事物某一方面特性的数据描述。

• 数据对象(Data Object):是指数据元素的集合，如数组、链表、树、图等。

数据元素与数据对象的关系：

数据结构(Data Structure)

概念：数据结构(Data Structure)是相互之间存在一种或多种特定关系的数据元素的集合，换句话说，数据结构是带”结构”的数据元素的集合，**”结构”就是指数据元素之间的相互关系**。

数据结构包括以下三个方面的内容：

数据结构的两个层次

逻辑结构

概念：逻辑结构(Logical Structure)是从逻辑关系上描述数据，它与物理结构无关，是独立于计算机的。

• 以线性结构和非线性结构划分

• 以集合、线性结构、树形结构、图形结构划分

存储结构

概念：存储结构(Storage Structure)是指数据对象在计算机中的存储结构，也称为物理结构。

• 以顺序存储结构和链式存储结构划分

顺序存储结构:数据元素按先后顺序存储在计算机的连续存储区中。

链式存储结构:我们在存储没有元素的本身的时候也存储了下一个元素的首地址。

• 以索引存储结构和散列存储结构划分

索引存储结构:在存储结点信息的同时，还建立附加的索引表。

散列存储结构:根据结点的关键字直接计算出该结点的存储地址。

编写hello world程序[Homework01.java]

1
2
3
4
5
6
7
8

public class Homework01 { 

    //编写一个main方法
    public static void main(String[] args) {
        //编写hello, world程序
        System.out.println("hello,world"); 
    }
}

将个人的基本信息（姓名、性别、籍贯、住址）打印到控制台上输出。各条信息分别占一行[Homework02.java]

1
2
3
4
5
6
7
8
9

//将个人的基本信息（姓名、性别、籍贯、住址）打印到控制台上输出。各条信息分别占一行
public class Homework02 { 

//编写一个main方法
public static void main(String[] args) {
//考察队转义字符
System.out.println("姓名\t性别\t籍贯\t住址\n顺平\t男\t四川\t北京"); 
}
}

JDK,JRE,JVM的关系[Homework03.java]

1
2
3

答：
1. JDK = JRE + java开发工具
2. JRE = JVM + 核心类库

环境变量path配置及其作用[Homework04.java]

1
2
3

1. 环境变量的作用是为了在dos的任意目录，可以去使用java 和 javac命令
2. 先配置 JAVA_HOME = 指向jdk安装的主目录
3. 编辑path环境变量，增加 %JAVA_HOME%\bin 

Java编写步骤[Homework05.java]

1
2
3

1. 编写java的源代码
2. javac 编译 ,得到对应的 .class 字节码文件
3. java 运行, 本质就是把 .class 加载到jvm  运行

Java编写7个规范[Homework06.java]

1
2
3
4
5
6
7

1. 类,方法的注释，使用javadoc的方式，即文档注释
2. 非javadoc注释，往往是对代码的说明(给程序的维护者),说明如何修改，注意事项
3. 使用tab ，整体将代码右移, 使用 shift+tab 整体左移
4. 运算符和 = 的两边，给空格，代码看上去清楚 int n = 1 + 4;
5. 源码文件使用 utf-8编码
6. 行宽字符不要超过 80
7. 代码编程风格有两种 次行风格，行尾风格(推荐)

初学者java易犯错误[Homework07.java]

1
2
3
4

1. 编译或者运行时，找不到文件 javac Hell0.java, 把文件名或者目录找对
2. 主类名和文件名不一致 , 修改时保持一致即可
3. 缺少;
4. 拼写错误，比如 1 -> l 0->0, void -> viod , 要求写代码时，一定要小心

Java 常用的转义字符

在控制台，输入 tab 键，可以实现命令补全

Java 转义字符的使用

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

//演示转义字符的使用
public class 转义字符的使用 {
    //编写一个main方法
    public static void main(String[] args) {

        //\t ：一个制表位，实现对齐的功能
        System.out.println("北京\t天津\t上海");

        // \n  ：换行符
        System.out.println("jack\nsmith\nmary");

        // \\  ：一个\  \\ ——> 第一个斜杠代表转义，第二个斜杠代表反斜杠本身
        System.out.println("C:\\Windows\\System32\\cmd.exe");

        // \"  :一个"
        System.out.println("老韩说:\"要好好学习java,有前途\"");

        // \'  ：一个'
        System.out.println("老韩说:\'要好好学习java,有前途\'");

        // \r  :一个回车  System.out.println("韩顺平教育\r北京");
        // 解读
        // 1. 输出  韩顺平教育
        // 2. \r表示回车
        System.out.println("韩顺平教育\r北京"); // \r会将自己前面的字符替换为后面的字符，即将“韩顺平教育”替换为“北京”
    }
}

输出结果：

课堂练习

题目

代码呈现

1
2
3
4
5
6
7
8

public class 转义字符课堂练习 {

    //编写一个main方法
    public static void main(String[] args) {
        //完成代码
        System.out.println("书名\t作者\t价格\t销量\n三国\t罗贯中\t120\t1000");
    }
}

输出结果：

初学Java易犯错误

• 找不到文件

解决方法:源文件名不存在或者写错，或者当前路径错误

• 主类名和文件名不一致

解决方法:声明为public的主类应与文件名一致，否则编译失败

• 缺少分号

解决方法：编译失败，注意错误出现的行数，再到源代码中指定位置改错

• 常见错误总结

学习编程最容易犯的错是语法错误(初学者)。Java要求你必须按照语法规则编写代码。如果你的程序违反了语法规则，例如:忘记了分号、大括号、引号，或者拼错了单词java编译器都会报语法错误。尝试着去看懂编译器会报告的错误信息。

举例:

• 1->1

• 0->o

• 英文符号写中文符号

• void ->viod 拼写错误

• 不好修改的错误其实是 业务错误,环境错误

注释

介绍：

用于注解说明解释程序的文字就是注释，注释提高了代码的阅读性(可读性);注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。

Java中的注释类型

1. 单行注释 //

2. 多行注释 /* */

3. 文档注释 /** */

单行注释：

基本格式

格式: //注释文字

多行注释:

基本格式

格式: /* 注释文字 */

使用细节

1. 被注释的文字，不会被JVM(java 虚拟机)解释执行

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

//演示注释使用

public class Comment01 {

//编写一个main方法
public static void main(String[] args) {

//单行注释

//多行注释
/* 示意 => 可读性很好
下面代码完成 两个数相加
定义变量 

注释
注释
int n1 = 10;... 
System.out.println("ok~~");
*/
int n1 = 10;
int n2 = 30;
//求和
int sum = n1 + n2;
//输出结果
System.out.println("结果=" + sum);
}
}

文档注释

快捷键：

1.//选中，然后输入 tab 整体右移

2.//选中，然后输入 shift+tab 整体左移

Java代码规范

• 类、方法的注释，要以javadoc的方式来写。

• 非Java Doc的注释(包括单行注释和多行注释)，往往是给代码的维护者看的，着重告述读者为什么这样写，如何修改，注意什么问题等

• 使用tab操作，实现缩进，默认整体向右边移动，时候用shift+tab整体向左移

• 运算符和 = 两边习惯性各加一个空格。比如:2 + 4 * 5 + 345 - 89

• 源文件使用utf-8编码

• 行宽度不要超过80字符

• 代码编写次行风格和**行尾风格(推荐)**。

DOS命令(了解)

DOS介绍

Dos: Disk Operating System 磁盘操作系统,简单说一下 windows 的目录结构。[原理图如下]

• md: make directory 创建目录

• rd: remove directory 删除目录

相关的知识补充:相对路径，绝对路径

• 相对路径: 从当前目录开始定位，形成的一个路径。

• 绝对路径: 从顶级目录d开始定位，形成的一个路径。

常用的dos命令

• 查看当前目录是有什么内容 dir

dir dir d:\abc2\test200

• 切换到其他盘下 : 盘符号 cd : change directory

案例演示: 切换到c盘 cd /D c:

• 切换到当前盘的其他目录下(使用相对路径和绝对路径演示)，..\表示上一级目录

案例演示: cd d:\abc2\test200 cd ....\abc2\test200

• 切换到上一级:

案例演示: cd ..

• 切换到根目录: cd \

案例演示: cd \

• 查看指定的目录下所有的子级目录: tree

• 清屏 cls

• 退出 DOS (exit)

说明:因为小伙伴后面使用DOS 非常少，所以对下面的几个指令，了解即可

• md[创建目录]

• rd[删除目录]

• copy[拷贝文件]

• del[删除文件]

• echo[输入内容到文件]

• type,move[剪切], =>Linux

需求说明

要求开发一个 Hello.java 程序，可以输出 “hello,world!”

开发步骤

1. 将 Java 代码编写到扩展名为 Hello.java 的文件中。[代码说明]

2. 通过 javac 命令对该 java 文件进行编译，生成 .class 文件。

3. 通过 java 命令对生成的 class 文件进行运行。

运行原理示意图

Java 开发快速入门

Java执行流程分析

什么是编译

javac Hello.java

1. 有了java源文件，通过编译器将其编译成JVM可以识别的字节码文件（.class文件）。

2. 在该源文件目录下，通过javac编译工具对Hello.java文件进行编译。

3. 如果程序没有错误，没有任何提示，但在当前目录下生成了Hello.class文件，该文件称为字节码文件，也是可以执行java的程序。

什么是运行

java Hello

1. 有了可执行的java程序（Hello.class字节码文件）

2. 通过运行工具java.exe对字节码文件进行执行，本质就是 .class

Java 开发注意事项和细节说明

对修改后的Hello.java源文件需要重新编译，生成新的class文件后，再进行执行，才能生效。

• 想要运行修改后的Java文件，需要对源文件进行重新编译，生成新的字节码文件后，再执行，才能运行出修改后的。否则运行出的只能是修改之前的。

• Java应用程序的执行入口是main（）方法。

• Java语言严格区分大小写。

• 每条语句以;结束。

• {}成对出现，缺一不可。

• 一个源文件中只能有一个public修饰的类，其它类的个数不限。

• 每一个类编译后，都对应一个.class文件。

• 如果源文件包含一个public类，则文件名必须按该类命名。

• 可以将main（）方法写在非public类中，然后指定运行该类，这样入口方法就是非public的main方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//一个源文件中最多只能有一个 public 类。其它类的个数不限。[演示] 
//Dog 是一个类
//编译后，每一个类，都对于一个.class

class Dog {
//一个源文件中最多只能有一个 public 类。其它类的个数不限，也可以将 main 方法写在非 public 类中，//然后指定运行非 public 类，这样入口方法就是非 public 的 main 方法
public static void main(String[] args) {
   System.out.println("hello, 小狗狗~");
   }
}


class Tiger {

public static void main(String[] args) { 
    System.out.println("hello, 小老虎~");
    }
}

如何快速掌握技术或知识点

• Java历史

• Java重要特点

• Java的开发工具

• Java的工具选择

• Java运行机制及运行过程

• 什么是 JDK，JRE

Java历史

什么是程序

程序：计算机执行某些操作或解决某个问题而**编写的一系列有序指令的集合**

举例说明：

编写一个简单的Java程序：

1
2
3
4
5
6
7
8

public class test {
        
    public static void main(String[] args) {
        int res = 1 + 1;
        //显示
        System.out.println("结果=" + res);
    }
}

运行该程序，输出结果为：

1

结果=2

Java诞生的小故事

Java背景知识

• Java是美国 sun 公司（Stanford University Network）在1995年推出的一门计算机高级编程语言。

• Java 早期称为Oak(橡树)，后期改名为Java。

• Java 之父：**詹姆斯·高斯林(James Gosling)**。

• 2009年 sun公司被Oracle公司收购。

Java技术体系平台

Java重要特点

• Java 语言是面向对象的(oop)

• Java 语言是健壮的。Java 的强类型机制、异常处理、垃圾的自动收集等是 Java 程序健壮性的重要保证

• Java 语言是跨平台性的。[即: 一个编译好的.class 文件可以在多个系统下运行，这种特性称为跨平台]

• Java 语言是解释型的[了解]

解释性语言：javascript,PHP, java 编译性语言: c / c++

区别是：解释性语言，编译后的代码，不能直接被机器执行,需要解释器来执行, 编译性语言, 编译后的代码, 可以直接被机器执行, c /c++

Java 的开发工具

前期使用Sublime Text + Java插件进行Java开发，后期转向IntelliJ IDEA + Java插件进行Java开发。

Sublime Text 官方网址：https://www.sublimetext.com/

IntelliJ IDEA 官方网址：https://www.jetbrains.com/idea/

• Sublime Text：一个跨平台的文本编辑器，支持Java开发，有丰富的插件，语法高亮，代码自动完成等功能。

• editplus.com：一个免费的文本编辑器，支持Java开发，有丰富的插件，语法高亮，代码自动完成等功能。

• NetBeans++：一个商业Java开发环境，支持Java开发，有丰富的插件，语法高亮，代码自动完成等功能。

• Eclipse：一个开源的Java开发环境，支持Java开发，有丰富的插件，语法高亮，代码自动完成等功能。

• IntelliJ IDEA：一个商业Java开发环境，支持Java开发，有丰富的插件，语法高亮，代码自动完成等功能。

Java 工具选择

如何选择开发工具

• 我们先选择用文本编辑器本 sublime，到大家对 java 有一定了解后，我们再使用 IDEA 和 Eclipse 开发工具。

这是为什么呢

• 更深刻的理解 java 技术,培养代码感。【面试时，往往程序员手写代码】

• 有利于公司面试。

Java运行机制及运行过程

Java 语言的特点：跨平台性

Java 核心机制-Java 虚拟机 [JVM java virtual machine]

基本介绍

1. JVM 是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令，管理数据、内存、寄存器，包含在JDK 中.

2. 对于不同的平台，有不同的虚拟机。

3. Java 虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，到处运行” [说明]

Java 程序运行过程示意图:

什么是 JDK，JRE

JDK 基本介绍

1. JDK 的全称(Java Development Kit Java 开发工具包)

JDK = JRE + java 的开发工具 [java, javac,javadoc,javap 等]

2. JDK 是提供给 Java 开发人员使用的，其中包含了 java 的开发工具，也包括了 JRE。所以安装了 JDK，就不用在单独安装 JRE 了。

JRE 基本介绍

1. JRE(Java Runtime Environment Java 运行环境)

JRE = JVM + Java 的核心类库[类]

2. 包括 Java 虚拟机(JVM Java Virtual Machine)和 Java 程序所需的核心类库等，如果想要运行一个开发好的 Java 程序，计算机中只需要安装 JRE 即可。

JDK、JRE 和 JVM 的包含关系

1. JDK = JRE + 开发工具集（例如 Javac,java 编译工具等)

2. JRE = JVM + Java SE 标准类库（java 核心类库）

3. 如果只想运行开发好的 .class 文件 只需要 JRE

这篇博客介绍Java环境的配置，主要是下载JDK，安装JDK，以及path、JAVA_hOME、CLASSPAT的配置，还会介绍配置这些的原因。

JDK的安装

下载JDK

首先，你需要到Oracle官网下载Java Development Kit (JDK)安装包。

下载JDK的步骤如下

第1步: 进入网站 ——>

第2步: 选择你需要的JDK版本，比如我这里选择的是JDK 8u411(简称JDK 8)，JDK 17。下面分别演示两个版本的下载过程。

JDK 17

JDK 8u411

注意：官网下载JDK 8u411，可能会提示你需要注册登录Oracle账号，这里注册Oracle账号比较麻烦，接下来我给大家提供一个网址，里面有免注册的共用Oracle账号。

Oracle免注册账号

安装JDK

安装JDK，点击下载好的安装包，运行setup.exe文件，按照提示一步步安装即可。

建议：安装路径不要有中文或者空格等特殊符号，否则可能会导致配置环境变量失败。

安装步骤(以JDK 17为例，安装JDK 8u411的步骤类似)：

（1）双击jdk-17-windows-x64.exe文件，并单击下一步

（2）修改安装路径，自定义

（3）将安装路径修改为D:\0-ProgrammingSoftware\Java\jdk-17并单击下一步 ——> 这里根据自己的实际情况修改安装路径

（4）稍后几秒，安装完成

配置环境变量 ———> JAVA_HOME、path、CLASSPAT

安装完成后，你需要配置环境变量，让系统能够识别到JDK。

打开环境变量编辑器

你可以在开始菜单中搜索环境变量或者在控制面板中搜索系统，然后点击高级系统设置->环境变量。

配置JAVA_HOME环境变量

配置原因

JAVA_HOME环境变量是JDK的安装目录，它告诉系统到哪里去找Java的运行时环境。

配置方法

首先找到我的电脑图标（就是一个电脑似的图标），然后点击鼠标右键，再点击属性，找到高级系统设置，点击环境变量。弹出下图所示的窗口。

在系统变量里新建一个JAVA_HOME，并赋值为JDK的安装目录，如下图所示：

注意：这里的路径要根据自己的实际情况修改，比如我这里安装的JDK 17的安装路径是D:\0-ProgrammingSoftware\Java\jdk-17，所以JAVA_HOME的值就是D:\0-ProgrammingSoftware\Java\jdk-17。

配置Path环境变量

配置原因

因为JDK装好后的两个重要执行文件javac.exe(代码编译文件)和java.exe(代码执行文件)存在于所装的JDK的bin目录下，而我们写的Java或者跑的别人的程序一般是放在一个新的目录，主要是方便管理，如果都放在这里，会很混乱，更何况编译还有class文件生成。

但是，当我们要运行Java程序时，我们需要编译（需要使用javac.exe）和执行（需要使用java.exe）,而系统默认的是在当前程序所在的文件夹目录下去寻找这两个执行文件，而不会去其他地方找，此时我们就需要配置Path环境变量，使得每次程序运行就自动到安装JDK的bin目录下去搜索javac.exe和java.exe文件。

点击新建，找到 JDK 的安装目录中javac.exe和java.exe所在的目录，把目录复制到这里，点击确认即可，Path路径就设置完毕了。

配置方法

在下面的系统变量框中（Path变量是系统本身就有的），选中Path那一行点击编辑，出现如下界面：

由于JAVA_HOME配置的是JDK的安装目录，所以Path有另一种配置方式，配置jdk和jre的bin目录即可，如下所示：

1
2
3
4
5
6
7
8

%JAVA_HOME%\bin
%JAVA_HOME%\jre\bin

1.其中% %表示引用JAVA_HOME的值
2.这样的好处在于，如果Java安装目录发生变话，
需要修改JAVA_HOME的值，不用再修改Path变量的值
3.部分Windows10的系统在重启之后%JAVA_HOME%\bin配置的失效，
这里解决方法是按上面的那种方法配置全路径即可

注意：Windows 8 ， 10的Path变量配置要友好一些，直接配置一条记录即可，如果是Windows7的话，需要在Path变量的值中使用 ;(英文分号)分割，然后追加Java的安装目录下的bin目录路径即可。

配置CLASSPATH环境变量

配置原因

CLASSPATH顾名思义为包路径，告诉Java在执行的时候，去哪里找到需要的包和类供程序使用。所以配置时应把包的路径赋值给CLASSPATH。

配置方法

我们在系统变量里新建一个CLASSPATH，赋值如下：

1

.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar

注意前面的 . 这个点号不能省略掉

此时赋值的路径有三个，以分号为间隔隔开 ，第一个英文的句号表示当前目录路径，第二个目录为lib库中的tools工具包路径，第三个为lib库中的dt包路径。

验证JDK安装

安装完成JDK以及相应的配置之后，需要验证是否安装成功，是否配置正常。

• 第一步：打开cmd命令行窗口，键盘win+r；输入 cmd 打开命令行

• 第二步：验证JDK安装是否成功，你可以在命令行中输入java -version命令，如果出现以下输出，说明JDK安装成功：

• 第三步：输入java，回车可以出现如下的提示：

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
85
86
87
88
89
90
91
92
93
94
95

C:\Users\LenovoHZB>java
用法：java [options] <主类> [args...]
           （执行类）
   或  java [options] -jar <jar 文件> [args...]
           （执行 jar 文件）
   或  java [options] -m <模块>[/<主类>] [args...]
       java [options] --module <模块>[/<主类>] [args...]
           （执行模块中的主类）
   或  java [options] <源文件> [args]
           （执行单个源文件程序）

 将主类、源文件、-jar <jar 文件>、-m 或
 --module <模块>/<主类> 后的参数作为参数
 传递到主类。

 其中，选项包括：

    -cp <目录和 zip/jar 文件的类搜索路径>
    -classpath <目录和 zip/jar 文件的类搜索路径>
    --class-path <目录和 zip/jar 文件的类搜索路径>
                  使用 ; 分隔的, 用于搜索类文件的目录, JAR 档案
                  和 ZIP 档案列表。
    -p <模块路径>
    --module-path <模块路径>...
                  用 ; 分隔的目录列表, 每个目录
                  都是一个包含模块的目录。
    --upgrade-module-path <模块路径>...
                  用 ; 分隔的目录列表, 每个目录
                  都是一个包含模块的目录, 这些模块
                  用于替换运行时映像中的可升级模块
    --add-modules <模块名称>[,<模块名称>...]
                  除了初始模块之外要解析的根模块。
                  <模块名称> 还可以为 ALL-DEFAULT, ALL-SYSTEM,
                  ALL-MODULE-PATH.
    --list-modules
                  列出可观察模块并退出
    -d <module name>
    --describe-module <模块名称>
                  描述模块并退出
    --dry-run     创建 VM 并加载主类, 但不执行 main 方法。
                  此 --dry-run 选项对于验证诸如
                  模块系统配置这样的命令行选项可能非常有用。
    --validate-modules
                  验证所有模块并退出
                  --validate-modules 选项对于查找
                  模块路径中模块的冲突及其他错误可能非常有用。
    -D<名称>=<值>
                  设置系统属性
    -verbose:[class|module|gc|jni]
                  为给定子系统启用详细输出
    -version      将产品版本输出到错误流并退出
    --version     将产品版本输出到输出流并退出
    -showversion  将产品版本输出到错误流并继续
    --show-version
                  将产品版本输出到输出流并继续
    --show-module-resolution
                  在启动过程中显示模块解析输出
    -? -h -help
                  将此帮助消息输出到错误流
    --help        将此帮助消息输出到输出流
    -X            将额外选项的帮助输出到错误流
    --help-extra  将额外选项的帮助输出到输出流
    -ea[:<程序包名称>...|:<类名>]
    -enableassertions[:<程序包名称>...|:<类名>]
                  按指定的粒度启用断言
    -da[:<程序包名称>...|:<类名>]
    -disableassertions[:<程序包名称>...|:<类名>]
                  按指定的粒度禁用断言
    -esa | -enablesystemassertions
                  启用系统断言
    -dsa | -disablesystemassertions
                  禁用系统断言
    -agentlib:<库名>[=<选项>]
                  加载本机代理库 <库名>, 例如 -agentlib:jdwp
                  另请参阅 -agentlib:jdwp=help
    -agentpath:<路径名>[=<选项>]
                  按完整路径名加载本机代理库
    -javaagent:<jar 路径>[=<选项>]
                  加载 Java 编程语言代理, 请参阅 java.lang.instrument
    -splash:<图像路径>
                  使用指定的图像显示启动屏幕
                  自动支持和使用 HiDPI 缩放图像
                  (如果可用)。应始终将未缩放的图像文件名 (例如, image.ext)
                  作为参数传递给 -splash 选项。
                  将自动选取提供的最合适的缩放
                  图像。
                  有关详细信息, 请参阅 SplashScreen API 文档
    @argument 文件
                  一个或多个包含选项的参数文件
    -disable-@files
                  阻止进一步扩展参数文件
    --enable-preview
                  允许类依赖于此发行版的预览功能
要为长选项指定参数, 可以使用 --<名称>=<值> 或
--<名称> <值>。

• 第四步：输入javac，（javac是用来编译.java文件的）：

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

C:\Users\LenovoHZB>javac
用法: javac <options> <source files>
其中, 可能的选项包括:
  @<filename>                  从文件读取选项和文件名
  -Akey[=value]                传递给注释处理程序的选项
  --add-modules <模块>(,<模块>)*
        除了初始模块之外要解析的根模块; 如果 <module>
                为 ALL-MODULE-PATH, 则为模块路径中的所有模块。
  --boot-class-path <path>, -bootclasspath <path>
        覆盖引导类文件的位置
  --class-path <path>, -classpath <path>, -cp <path>
        指定查找用户类文件和注释处理程序的位置
  -d <directory>               指定放置生成的类文件的位置
  -deprecation                 输出使用已过时的 API 的源位置
  --enable-preview             启用预览语言功能。要与 -source 或 --release 一起使用。
  -encoding <encoding>         指定源文件使用的字符编码
  -endorseddirs <dirs>         覆盖签名的标准路径的位置
  -extdirs <dirs>              覆盖所安装扩展的位置
  -g                           生成所有调试信息
  -g:{lines,vars,source}       只生成某些调试信息
  -g:none                      不生成任何调试信息
  -h <directory>               指定放置生成的本机标头文件的位置
  --help, -help, -?            输出此帮助消息
  --help-extra, -X             输出额外选项的帮助
  -implicit:{none,class}       指定是否为隐式引用文件生成类文件
  -J<flag>                     直接将 <标记> 传递给运行时系统
  --limit-modules <模块>(,<模块>)*
        限制可观察模块的领域
  --module <模块>(,<模块>)*, -m <模块>(,<模块>)*
        只编译指定的模块，请检查时间戳
  --module-path <path>, -p <path>
        指定查找应用程序模块的位置
  --module-source-path <module-source-path>
        指定查找多个模块的输入源文件的位置
  --module-version <版本>        指定正在编译的模块版本
  -nowarn                      不生成任何警告
  -parameters                  生成元数据以用于方法参数的反射
  -proc:{none,only,full}       控制是否执行注释处理和/或编译。
  -processor <class1>[,<class2>,<class3>...]
        要运行的注释处理程序的名称; 绕过默认的搜索进程
  --processor-module-path <path>
        指定查找注释处理程序的模块路径
  --processor-path <path>, -processorpath <path>
        指定查找注释处理程序的位置
  -profile <profile>           请确保使用的 API 在指定的配置文件中可用
  --release <release>
        为指定的 Java SE 发行版编译。支持的发行版：7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17
  -s <directory>               指定放置生成的源文件的位置
  --source <release>, -source <release>
        提供与指定的 Java SE 发行版的源兼容性。支持的发行版：7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17
  --source-path <path>, -sourcepath <path>
        指定查找输入源文件的位置
  --system <jdk>|none          覆盖系统模块位置
  --target <release>, -target <release>
        生成适合指定的 Java SE 发行版的类文件。支持的发行版：7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17
  --upgrade-module-path <path>
        覆盖可升级模块位置
  -verbose                     输出有关编译器正在执行的操作的消息
  --version, -version          版本信息
  -Werror                      出现警告时终止编译

结语

以上就是Windows下Java环境的配置教程，希望对你有所帮助。感谢每一位走到这里的小伙伴，我们可以一起学习交流，一起进步😉！！！加油🏃！！！

Pr项目工程文件的后缀

注意:

工程文件兼容性：

(1) PR工程文件后缀为.prproj，请勿修改。

(2) 工程文件中，向下兼容 不向上兼容。即，新版本的PR软件可以打开旧版本的工程文件，但旧版本的PR软件不能打开新版本的工程文件。

等价无穷小点的替换:

例题-1:

例题-2:(了解)

如何求**二重极限**

求**偏导数**和二阶偏导数

求导公式:

一阶偏导数例题:

二阶偏导数例题:

技巧:

例题:

求全微分

全微分计算公式:

全微分求解:

例题:

求复合函数的偏导

复合函数求偏导:

例题:

隐函数求偏导数

隐函数求偏导数:

例题:

求多元函数极值

极值定理:

例题:

方向导数与梯度

求方向导数:

例题:

求梯度:

例题:

求在点处的最大方向导数:

连续，可偏导，可微分，方向导数的关系

关系金字塔(强能推弱-平级之间也不能相互推导):

例题:

隐函数存在定理(了解)

隐函数存在定理:

例题:

当拿到我们拿到一个无穷级数的题目时，下面就来总结一下无穷级数的判别方法。

用定义判定级数收敛性

数项级数敛散性判定

收敛级数的基本性质

使用常用结论判别敛散性

正项级数敛散性判别法

技巧:

例题:

使用比值判别法和根值判别法判别收敛性

技巧:

例题:

交错级数敛散性判别法

技巧:

例题:

绝对收敛和条件收敛判别法

技巧:

例题:

幂级数

总结:

幂级数求收敛域(收敛区间)

题型1:

技巧:

例题:

题型2:

技巧:

例题:

题型3:

题库例题

题目一 ——> P级数的收敛性判别法，P > 1 ——> 收敛 ，P =< 1 ——> 发散

P级数的收敛性判别法 ——>

题目二 ——> 收 + 发 = 发 ，补充: 收 + 收 = 收，发 + 发 = 不确定

题目三 ——> 限定在某一个范围内，级数收敛

题目四 ——> 带入级数式子直接求解

题目五 ——> 级数收敛的必要条件

题目六 ——> 幂级数的收敛区间

技巧:

例题:

题目七 ——> 等比级数的收敛性判别法

空间向量

向量的模

向量积

利用向量积求图形面积

空间平面方程

平面的点法式方程

两平面的夹角

点到平面的距离

空间直线方程

直线的一般方程

空间直线对称式方程，空间直线的参数方程

旋转曲面方程

空间曲线在平面的投影

解题方法:

例题:

空间曲面的切平面和法线

题型1:

题型2:

空间曲线的切线和法平面

题目拿到手，首先要对题目类型进行分类，根据题目类型，我们可以将题目分为以下几类：

• 变量可分离型
• 齐次微分方程
• 一阶线性微分方程
• 积分方程(了解)
• x(y)型方程(了解)

题型辨别：

题型总结：

变量可分离型

**解题步骤**：

例题：

练习题:

1.

2.

齐次微分方程

**解题步骤**：

例题：

练习题:

1.

一阶线性微分方程

公式推导:

解题步骤：

例题：

练习题:

1.

1.

积分方程(了解)

解题步骤：

例题：

x(y)型方程

**解题步骤**：

例题：

二阶微分方程

题目拿到手，首先要对题目类型进行分类，根据题目类型，我们可以将题目分为以下几类：

• 可降阶的二阶微分方程(了解)
• 二阶常系数齐次线性微分方程
• n阶常系数齐次线性微分方程(了解)
• 二阶常系数非齐次线性微分方程(了解)

题型总结：

可降阶的二阶微分方程(了解)

题型1:

例题：

练习题:

题型2:

例题：

练习题:

题型3:

例题：

练习题:

二阶常系数齐次线性微分方程

**解题步骤**：

例题：

n阶常系数齐次线性微分方程(了解)

**解题步骤**：

例题：

二阶常系数非齐次线性微分方程(了解)

题型1:

解题步骤：

例题：

题型2:

解题步骤：

例题：

1. if语句

2. 关系操作符

3. 条件操作符

4. 逻辑操作符：&& , || , ！

5. switch语句

6. while循环

7. for循环

8. do-while循环

9. break和continue语句

10. 循环的嵌套

11. goto语句

正文开始

C语言是结构化的程序设计语言，这里的结构指的是 顺序结构、选择结构、循环结构 ，C语言是能够实
现这三种结构的，其实我们如果仔细分析，我们日常所⻅的事情都可以拆分为这三种结构或者这三种
结构的组合。
我们可以使用if、switch实现分支结构，使用for、while、do while实现循环结构。

1. if语句

1.1 if

if语句的语法形式如下:

1
2

if ( 表达式 )
语句

表达式成立（为真），则语句执行，表达式不成立（为假），则语句不执行

在C语言中， 0 为假，非 0 表示真 ，也就是表达式的结果如果是 0 ，则语句不执行，表达式的结果如果不是 0 ，则语句执行。

**例子**： 输入一个整数，判断是否为奇数

1
2
3
4
5
6
7
8
9

#include <stdio.h>
int main()
{
    int num = 0 ;
    scanf("%d", &num);
    if(num % 2 == 1 )
       printf("%d 是奇数\n", num);
    return 0 ;
}

1.2 else

如果一个数不是奇数，那就是偶数了，如果任意一个整数，我们要清楚的判断是奇数还是偶数怎么表示呢？

这里就需要 **if...else...**语句了，语法形式如下：

1
2
3
4

if ( 表达式 )
    语句 1
else
语句 2

例子： 输入一个整数，判断是否为奇数，如果是奇数打印是奇数，否则打印偶数。

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
int main()
{
    int num = 0 ;
    scanf("%d", &num);
    if(num % 2 == 1 )
    printf("%d 是奇数\n", num);
    else
    printf("%d 是偶数\n", num);
    return 0 ;
}

练习： 输入一个年龄，>=18岁就输出：成年，否则就输出：未成年

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
int main()
{
    int age = 0 ;
    scanf("%d", &age);
    if(age>= 18 )
    printf("成年\n");
    else
    printf("未成年\n");
    return 0 ;
}

1.3 分支中包含多条语句

默认在if和else语句中默认都只控制一条语句，比如：

1
2
3
4
5
6
7
8
9
10

#include <stdio.h>
int main()
{
    int age = 0 ;
    scanf("%d", &age);
    if(age >= 18 )
       printf("成年了\n");
       printf("可以谈恋爱了\n");
    return 0 ;
}

上面的代码，你会发现输入的值不管是>=18还是<18，”可以谈恋爱了”都会打印在屏幕上。

这是因为if语句只能控制一条语句，就是printf(“成年了\n”);，if语句为真，则打印成年了，
if语句为假，则不打印，对于printf(“可以谈恋爱了\n”);是独立存在的，不管if语句的条件的真
假，都会被执行。那如果我们要if语句同时控制 2 条语句，怎么办呢？那就要使用{}将代码括起来，
else后也可以跟上大括号。如下：

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

#include <stdio.h>
int main()
{
int age = 0 ;
scanf("%d", &age);
if(age >= 18 ) //if 后使用{} 控制多条语句-这个块也叫：程序块，或者复合语句
{
printf("成年了\n");
printf("可以谈恋爱了\n");
}
return 0 ;
}

1
2
3
4
5
6
7

#include <stdio.h>
int main()
{
int age = 0 ;
scanf("%d", &age);
if(age >= 18 ) //if 后使用{} 控制多条语句-这个块也叫：程序块，或者复合语句
{

1

1 2 3 4 5 6 7 8 9

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

10
11
12
13
14
15
16
17
18
19
20
21

1
2
3
4
5
6
7
8
9
10

printf("成年了\n");
printf("可以谈恋爱了\n");
}
else //else 后使用{}控制多条语句-这个块也叫：程序块，或者复合语句
{
printf("未成年\n");
printf("不可以早恋哦\n");
}
return 0 ;
}

1
2
3
4
5
6
7
8
9
10

22
23
24
25
26
27
28
29
30
31

1.4 嵌套if

在if else语句中，else可以与另一个if语句连用，构成多重判断。
比如：要求输入一个整数，判断输入的整数是 0 ，还是正数或者负数。请看如下代码：

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

#include <stdio.h>
int main()
{
int num = 0 ;
scanf("%d", &num);
if(num == 0 )
printf("输入的数字是0\n");
else if(num > 0 ) //这里的if 相当于嵌套在else语句中，形成了嵌套结构
printf("输入的数字是正数\n");
else
printf("输入的数字是负数\n");
return 0 ;
}

1

1 2 3 4 5 6 7 8 9

1
2
3
4
5
6

10
11
12
13
14
15

上图中橙色背景的代码就是嵌套在前面的else子句中的，构成了嵌套的if语句。
再比如：
输入一个整数，如果是正数，再判断是奇数还是偶数，并输出；如果不是正数则输出：非正数。

1
2
3
4
5

#include <stdio.h>
int main()
{
int num = 0 ;
scanf("%d", &num);

1

1 2 3 4 5 6

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

if(num> 0 )
{
if(num% 2 == 0 )
printf("偶数\n");
else
printf("奇数\n");
}
else
{
printf("非正数\n");
}
return 0 ;
}

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

7
8
9
10
11
12
13
14
15
16
17
18
19

上面的代码中橙色背景的代码也是嵌套在if语句中的，构成了嵌套的if语句。

以上就是嵌套if语句的语法，有了嵌套if语句，就可以完成更多复杂逻辑的判断。

练习：

1
2
3
4
5
6

输入一个人的年龄
如果年龄< 18 岁，打印"少年"
如果年龄在 18 岁至 44 岁打印"⻘年"
如果年龄在 45 岁至 59 岁打印"中老年"
如果年龄在 60 岁至 89 岁打印"老年"
如果 90 岁及以上打印"老寿星"

1

1 2 3 4 5 6

参考代码：

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

//方法 1
#include <stdio.h>
int main()
{
int age = 0 ;
scanf("%d", &age);
if(age< 18 )
printf("少年\n");
else if(age<= 44 )
printf("⻘年\n");
else if(age<= 59 )
printf("中老年\n");

1

1 2 3 4 5 6 7 8 9

1
2
3

10
11
12

1
2
3
4
5
6

else if(age<= 89 )
printf("老年\n");
else
printf("老寿星\n");
return 0 ;
}

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

//带上大括号更容易看明白
#include <stdio.h>
int main()
{
int age = 0 ;
scanf("%d", &age);
if(age< 18 )
{
printf("少年\n");
}
else
{
if(age<= 44 )
{
printf("⻘年\n");
}
else
{
if(age<= 59 )
{
printf("中老年\n");
}
else
{
if(age<= 89 )
printf("老年\n");
else
printf("老寿星\n");
}
}
}
return 0 ;
}

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

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

1.5 悬空else问题

如果有多个if和else，可以记住这样一条规则，else总是跟最接近的if匹配。
我们首先从下面代码开始

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

#include <stdio.h>
int main()
{
int a = 0 ;
int b = 2 ;
if(a == 1 )
if(b == 2 )
printf("hehe\n");
else
printf("haha\n");
return 0 ;
}

1

1 2 3 4 5 6 7 8 9

1
2
3

10
11
12

程序运行的结果是啥？
很多初学者，上来以判断a是0，不等于1，那就执行else子句，打印haha
但是当你去运行代码，输出的结果是：啥都不输出。

为什么呢？

这就是悬空else的问题，如果有多个if和else，可以记住这样一条规则，else总是跟最接近
的if匹配。
上面的代码排版，让else和第一个if语句对⻬，让我们以为else是和第一个if匹配的，当if
语句不成立的时候，自然想到的就是执行else子句，打印haha，但实际上else是和第二个if
进行匹配的，这样后边的if…else语句是嵌套在第一个if语句中的，如果第一个if语句就不
成立，嵌套if和else就没机会执行了，最终啥都不打印。
如果代码改成下面这样就更加容易理解了

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

#include <stdio.h>
int main()
{
int a = 0 ;
int b = 2 ;
if(a == 1 )
{
if(b == 2 )
printf("hehe\n");
else
printf("haha\n");
}
return 0 ;
}

1

1 2 3 4 5 6 7 8 9

1
2
3
4
5

10
11
12
13
14

或者如果我们希望else确实和第一个if匹配，可以这样修改代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <stdio.h>
int main()
{
int a = 0 ;
int b = 2 ;
if(a == 1 )
{
if(b == 2 )
printf("hehe\n");
}
else
{
printf("haha\n");
}
return 0 ;
}

1

1 2 3 4 5 6 7 8 9

1
2
3
4
5
6
7

10
11
12
13
14
15
16

只要带上适当的大括号，代码的逻辑就会更加的清晰，所以大家以后在写代码的时候要注意括号的使
用，让代码的可读性更高。

2. 关系操作符

C语言用于比较的表达式，称为“ 关系表达式 ”（relationalexpression），里面使用的运算符就称
为“关系运算符”（relationaloperator），主要有下面 6 个。

• 大于运算符

• <小于运算符

• =大于等于运算符

• <=小于等于运算符

• ==相等运算符

• !=不相等运算符
  下面是一些例子。

1
2
3
4
5
6