课堂笔记 2025年9月4日

1.计算机

1.1计算机的五大部件

• 运算器,控制器(CPU-中央处理器)

• 存储器

• 输入设备

• 输出设备

1.2计算机制造的三个基本原则

1. 采用二进制逻辑

2. 程序存储执行

3. 计算机由五个部分注册

2.Word

点击打开Word

2.1文件属性

DOCX

• .DOCX是微软Word的文件扩展名， Microsoft Office2007之后版本使用， 其基于Office Open XML标准的压缩文件格式取代了其以前专有的默认文件格式， 在传统的文件名扩展名后面添加了字母“x”（即“.docx”取代“.doc”、“.xlsx”取代“.xls”、“.pptx”取代“.ppt”）。 任何能够打开DOC文件的文字处理软件都可以将该文档转换为DOCX文件，docx文件比doc文件所占用空间更小， docx格式的文件本质上是一个XML文件也是一个压缩文件。

DOC

• .DOC是电脑文件常见文件扩展名的一种， 亦是Word2003以前版本的文本文档。 自Word 2007之后为docx。 该格式原是纯文本文件使用的， 多见于不同的操作系统中， 软硬件的使用说明。

3.程序

3.1程序是什么?

• 程序就是指令的集合(指令集)

• 编写程序就是写流程步骤

3.2编写程序的步骤

现在要编写一个能进行简单的算数运算的程序

1. 通过输入设备接受用户输入的两个操作数

2. 将用户输入的信息通过存储器保存在电脑

3. 根据用户输入的信息进行运算

4. 通过输出设备将运算的结果显示出来

Python

# 输入第一个操作数
while True:
    try:
        num1 = float(input("请输入第一个数字："))
        break
    except ValueError:
        print("错误：请输入有效的数字。")

# 输入运算符
while True:
    op = input("请输入运算符（+、-、*、/）：")
    if op in ['+', '-', '*', '/']:
        break
    else:
        print("错误：无效的运算符，请重新输入。")

# 输入第二个操作数（针对除法检查是否为零）
while True:
    try:
        num2 = float(input("请输入第二个数字："))
        if op == '/' and num2 == 0:
            print("错误：除数不能为零，请重新输入。")
        else:
            break
    except ValueError:
        print("错误：请输入有效的数字。")

# 执行算术运算
if op == '+':
    result = num1 + num2
elif op == '-':
    result = num1 - num2
elif op == '*':
    result = num1 * num2
elif op == '/':
    result = num1 / num2

# 输出结果
print(f"运算结果：{num1} {op} {num2} = {result}")

4.内存

4.1内存跟外存的区别

内存

1. 属于易失性存储器（如RAM），断电后数据会丢失，需要持续供电维持数据

2. 直接与CPU相连，访问速度极快（纳秒级），适合频繁读写操作

3. 容量较小（通常以GB为单位）

4. 支持实时运算，临时存储当前处理的程序指令和数据，直接影响多任务处理效率

5. 单位容量成本较高，扩展受主板插槽限制

外存

1. 属于非易失性存储器（如硬盘、SSD），断电后数据仍可长期保存

2. 速度较慢（毫秒级），数据需通过内存中转才能被CPU处理

3. 容量更大（可达TB级）

4. 成本低且支持灵活扩展（如外接硬盘、云存储）

5. 存储操作系统、应用程序文件及用户数据

5.存储

5.1存储单位

• b(bit)

• B(Byte)

• KB

• MB

• GB

• TB

5.2单位换算

• 8b=1B

• 1024B=1KB

• 1024kB=1MB

• 1024MB=1GB

• 1024GB=1TB

---

课堂笔记 2025年9月9日

1.进制转换

1.1其他进制转为十进制

• 使用位权表示法

1.2十进制转为其他进制

• 整数部分:除以R取余数,倒序

• 小数部分:乘以R取整数,顺序

1.3二进制与八进制之间的相互转换

• 先从小数点开始按3位进行划分,在使用421法则

1.4二进制与十六进制之间的相互转换

• 从小数点开始先按4位进行划分,在使用8421法则

1.5八进制与十六进制之间的相互转换

2.路经

2.1相对路径

• 相对路径表示从当前文件位置出发,指向目标文件的路径,他是目标文件与当前文件的相对位置,会随着当前文件位置的不同而是使与同一文件的相对位置发生改变

---

课堂笔记 2025年9月11日

1.为什么要学习编程语言？

• 程序是指令的集合，用来告诉计算机做什么。

• 学习编程语言就像学习外语：为了与计算机“沟通”，让它执行任务。

• 常见的编程语言有：C#、Java、Python、C++、JavaScript 等。

2.C# 是什么？

• C#（读作“C Sharp”）是一种面向对象的编程语言。

• 由微软开发，常用于开发 Windows 应用程序、游戏（Unity）、Web 服务等。

• 与 Java 类似，是当前企业开发中主流的语言之一。

3.开发工具：Visual Studio (VS)

• VS 是一个集成开发环境（IDE），用于编写、调试和运行代码。

• 类似于“厨房里的刀具和案板”，提供便捷的编码环境。

• 不用 VS 也可以写代码（如用记事本），但效率低。

点我打开编译程序目录

4..NET Framework 是什么？

• .NET（读作“dot net”）是一个开发框架，包含两个核心部分：

  • CLR（通用语言运行时）：程序的运行环境。

  • 类库（Class Library）：预先写好的代码工具集合，可直接使用。

类比：类库就像“工具箱”，里面有现成的工具（如输出文字、数学计算等），无需从头造轮子。

5.面向过程 vs 面向对象

• 面向过程（如 C 语言）：关注“步骤”，一步一步执行。

• 面向对象（如 C#、Java）：关注“对象”，对象之间交互完成任务。

• 面向对象更贴近现实世界，易于理解和维护。

6. C# 与 Java 的区别与联系

• 都是面向对象的高级语言。

• C# 多用于微软生态，Java 跨平台性更强。

• 下学期会学 Java，本学期先学 C#。

7. 框架是什么?

• 框架（Framework）是一组可重用的代码库、工具和约定的集合，用于帮助开发者更高效地构建应用程序。

• 框架通常定义了应用程序的结构、基本流程和常用功能，开发者只需专注于实现具体的业务逻辑，而无需从零开始搭建所有基础设施。

---

课堂笔记 2025年9月15日

1.数据类型

数据类型	关键字	大小
短整型	short	2字节
整型	int	4字节
长整型	long	8字节
单精度浮点型	float	4字节
双精度浮点型	double	8字节
高精度浮点型	decimal	16字节
布尔类型	bool	1字节
单字符列席	char	2字节
字符串类型	string

2.变量的使用目的

• 存取数据：变量的主要目的是用来存储和取出数据。比如在程序中，如果需要保存用户输入的名字、年龄等信息，就可以使用变量来存储这些数据，之后在需要的时候再通过变量把数据取出来使用。

3.计算机存储数据的方式

• 内存存储：计算机使用内存来存储数据。内存就像一个很大的空间，可以存放各种数据。

• 开辟空间：在内存中存储数据时，需要先开辟一个合适大小的空间来存放数据。这个空间的大小取决于数据的类型。比如，存储一个整数（如年龄）需要的空间大小和存储一个字符串（如名字）需要的空间大小是不同的。

4.数据存储的类比

• 现实生活中的存储：可以把计算机存储数据的过程类比为现实生活中的存储物品。 比如家里要存放鞋子、衣服、食物等物品，需要先找到合适的地方（如鞋柜、衣柜、冰箱）来存放 并且根据物品的种类和大小来决定存放的空间大小。同样，在程序中存储数据也需要根据数据的类型来决定在内存中开辟的空间大小。

5.二进制存储

• 二进制的基本概念：计算机使用二进制来存储和处理数据，二进制只有两个数字：0 和 1。

• 位置与数值：每个位置可以存储一个二进制位（bit），一个位置上只能放一个数字，要么是 0，要么是 1。

• 多个位置的组合：如果有多个位置（如3个位置），可以存储更大的数值。例如，3个位置可以表示的最大值是 111（二进制），转换为十进制是 7。

6.内存空间的开辟

• 根据数据类型开辟空间：在内存中存储数据时，需要根据数据的类型来决定开辟多大的空间。

• 数据类型与空间大小：不同的数据类型占用的内存空间大小不同。例如：

  • 整型（int）：通常占用 4 个字节（32 位），可以表示的最大值是 231−1（约 21 亿）。

  • 长整型（long）：通常占用 8 个字节（64 位），可以表示的最大值是 263−1（约 9.22 亿亿）。

7.变量的定义与使用

• 定义变量的目的：在程序中使用变量之前，需要先定义变量。定义变量的目的是在内存中开辟一个合适大小的空间，并给这个空间一个名字（变量名），方便后续的使用。

• 定义变量的语法：定义变量时需要指定数据类型和变量名。例如：

  int age; // 定义一个整型变量，名为 age

• 数据类型：告诉计算机需要开辟多大的空间。

• 变量名：给这个空间一个名字，方便后续的存取操作。

8.内存空间的合理利用

• 合理选择数据类型：根据需要存储的数据的大小选择合适的数据类型，避免浪费内存空间。

• 超出范围的处理：如果数据超出了某种数据类型能表示的范围，需要选择更大的数据类型。例如，如果需要存储一个超过 21 亿的整数，就不能使用 int 类型，而需要使用 long 类型。

9.变量的使用

• 存取数据：定义变量后，可以通过变量名将数据存储到变量中，也可以从变量中取出数据。

• 示例：

  int age = 18; // 定义一个整型变量 age，并存储值 18
  printf("%d", age); // 从变量 age 中取出值并打印

10.变量的命名规则与规范

10.1 命名规则

1. 变量只能由数字,下划线,字母组成

2. 开头只能是字母或下划线

3. 不能使用关键字

4. 区分大小写

10.2 规范

1. 有意义的名字

2. 使用帕斯卡命名法,驼峰命名法

帕斯卡骆驼法:名字中所有单词都大写

string BookName;

驼峰命名法:除了第一个单词全部小写,其他所有单词的首字母都大写

string bookName;

总结

• 二进制存储：计算机使用二进制存储数据，每个位置可以存储一个二进制位。

• 内存空间的开辟：根据数据类型在内存中开辟合适大小的空间。

• 变量的定义：在程序中使用变量前需要定义变量，指定数据类型和变量名。

• 合理利用内存：根据数据的大小选择合适的数据类型，避免浪费内存。

• 变量的使用：通过变量名存取数据。

• 变量：用来存储和取出数据。

• 内存：计算机存储数据的地方。

• 开辟空间：根据数据的类型在内存中找到合适大小的空间来存储数据。

---

课堂笔记 2025年9月17日

1.类型转换

1.1 隐式转换

1. 又叫系统自动类型转换

2. 不用写代码 啥也不干 系统自动完成

3. 系统能进行自动类型转换有个条件: 必须小转大 不能大转小

1.2 显试转换

1. 又叫强制类转换

2. 需要自己写代码来完成

3. 大转小的情况就需要用到强制类型转换

1.3 强制类型转换的方式

1. 非字符串类型的转换,可以使用小括号进行转换

2. 字符串转为其他类型,可以使用Parse()方法

3. 其他类型转为字符串,可以使用ToString方法

4. 使用Convert类进行转换(称之为万能转换)

---

课堂笔记 2025年9月18日

1.运算符

1.1 运算符的四大类

• 算术运算符：用于执行基本的数学运算。

  • +：加法
  • -：减法
  • *：乘法
  • /：除法
  • %：取模（求余数）
  • ++：自增（将变量的值加1）
  • --：自减（将变量的值减1）

• 关系运算符：用于比较两个值，结果为布尔值（true 或 false）。

  • >：大于
  • <：小于
  • >=：大于等于
  • <=：小于等于
  • ==：等于（在某些语言中，=== 表示严格等于，用于比较值和类型）
  • !=：不等于（在某些语言中，!== 表示严格不等于，用于比较值和类型）

• 逻辑运算符：用于组合多个条件，结果为布尔值。

  • &&：逻辑与（AND），当且仅当所有条件都为 true 时，结果为 true
  • ||：逻辑或（OR），当至少有一个条件为 true 时，结果为 true
  • !：逻辑非（NOT），用于取反，将 true 变为 false，将 false 变为 true

• 赋值运算符：用于将值赋给变量。

  • =：简单赋值
  • +=：加法赋值（x += y 等同于 x = x + y）
  • -=：减法赋值（x -= y 等同于 x = x - y）
  • *=：乘法赋值（x *= y 等同于 x = x * y）
  • /=：除法赋值（x /= y 等同于 x = x / y）
  • %=：取模赋值（x %= y 等同于 x = x % y）

---

课堂笔记 2025年10月11日

1. 循环

1.1 for循环

for循环的三个表达式都是对循环变量进行操作

---

课堂笔记 2025年10月30日

1.约束:

1.1约束有哪些

1. 主键

2. 外键

3. 标识列

4. 非空

5. 唯一

6. 检查

7. 默认

约束名	英文名	作用
主键约束	primary key	非空且唯一
标识列约束	identity	自动增长
非空约束	not null	不能为空
唯一约束	unique	唯一
检查约束	check	检查是否符合条件
默认约束	default	默认值

课堂笔记 2025年11月10日

1.数据类型

整型	小数类型	字符类型	货币类型	日期时间类型
int	real	char(长度)	money	date
smallint	float	varchar(长度)		time
bigint	deciaml	nchar(长度)		datetime
tinyint		nvarchar(长度)
bit		te

2.运算符

算术	关系	逻辑	赋值
+	>	and	=
-	<	or
*	>=	not
/	<=
	=
	!=

课堂笔记 2026年3月12日

1.面向对象编程基础 —— 类与对象

一、核心概念对比

表格

概念	类比	定义	本质
类 (Class)	模具/蓝图/模板	对具有相同特征和行为的对象的抽象描述	抽象概念
对象 (Object)	铸件/房子/实例	根据类创建出来的真实存在的实体	具体实体

关系：类是对象的抽象，对象是类的实例。一个类可以创建多个对象。

---

二、对象的描述维度

表格

维度	对应术语	代码实现	词性	示例
特征	属性 (Attribute)	变量 (Variable)	名词	姓名、年龄、颜色
行为	方法 (Method)	函数 (Function)	动词	跑步、说话、计算

---

三、语法规范

1. 定义类

public class 类名 {
    // 1. 定义属性（描述对象的特征）
    数据类型 属性名;
// 2. 定义方法（描述对象的行为） 
返回值类型 方法名(参数列表) { // 方法体 
    } 
}

2. 创建对象

类名 对象名 = new 类名();

3. 使用对象

表格

操作	语法	适用场景
访问属性	对象名.属性名	存取对象的信息/状态
调用方法	对象名.方法名()	让对象执行某个功能/行为

---

四、记忆口诀

"类是模，对象是样；属性存信息，方法干事情"

---

五、易错点

1. 类 ≠ 对象：类是抽象概念，不能直接操作；必须先实例化为对象才能使用

2. 属性 vs 方法：属性是"名词"（是什么），方法是"动词"（做什么）

3. 访问符号：统一使用点号 . 访问成员

课堂笔记 2026年3月18日

1.构造方法的特点

1. 构造方法一般用于简化对象初始化数据

2. 构造方法在创建对象是由系统自动调用执行

3. 构造方法没有类型,void都不用写

4. 构造方法的名称必须与类名相同

5. 没有定义构造方法,系统会添加一个不带参的构造方法

6. 如果定义了构造方法,则系统不会再自动添加不带参的构造方法

7. 构造方法可以由多个(重载)

2.重载

1. 同一个类里有多个方法,方法名相同,参数不同就是重载

2. 参数不同体现在三个方面:类型,个数,顺序

3. 是不是重载与访问修饰符,静态关键字,方法的类型都无关

课堂笔记 2026年3月19日

继承的特点:

1. 子类继承父类,子类就拥有了父亲所有的属性和方法

2. 继承要满足is a 的条件,就是要满足是一个的条件

3. 使用extends关键字实现继承

4. 继承是单继承,不能是多继承

5. 子类除了拥有父类的属性和方法,很可疑拥有自己独有的

6. 子类还可以重写父类的方法

重写的特点:

1. 子类继承父类

2. 子类方法的名称,类型,参数都要与父类的方法相同

3. 子类方法的访问修饰符要大于等于父类的访问修饰符

课堂笔记 2026年3月23日

1.调用父类（super 关键字）

1.1 super 是什么？

super 是 Java 中的关键字，用于引用父类（超类）的对象，主要作用：

用法	作用
super.方法()	调用父类的成员方法
super.属性	访问父类的成员变量（当子类有同名变量时）
super()	调用父类的构造方法

---

1.2 调用父类方法

class Animal {
    void explore() {
        System.out.println("动物在探索环境");
    }
}

class Dog extends Animal {
    // 子类重写 explore 方法
    @Override
    void explore() {
        // 先执行父类的探索行为
        super.explore();  // 输出：动物在探索环境

        // 再添加子类特有的行为
        System.out.println("狗狗用鼻子闻了闻"); 
    }
}

// 使用
Dog dog = new Dog();
dog.explore();
// 输出：
// 动物在探索环境
// 狗狗用鼻子闻了闻

---

1.3 调用父类构造方法

class Person {
    String name;

    // 父类构造方法
    Person(String name) {
        this.name = name;
        System.out.println("Person 构造方法被调用");
    }
}

class Student extends Person {
    int grade;

    // 子类构造方法
    Student(String name, int grade) {
        super(name);        // 必须放在第一行！调用父类构造
        this.grade = grade;
        System.out.println("Student 构造方法被调用");
    }
}

// 使用
Student s = new Student("张三", 3);
// 输出：
// Person 构造方法被调用
// Student 构造方法被调用

⚠️ 注意：super() 必须是子类构造方法中的第一条语句！

---

1.4 访问父类被隐藏的变量

class Parent {
    int num = 100;
}

class Child extends Parent {
    int num = 200;  // 子类定义了同名变量，隐藏了父类的 num

    void print() {
        System.out.println(num);       // 200（子类的）
        System.out.println(super.num); // 100（父类的）
    }
}

---

1.5 super vs this 对比

关键字	1指向	用途
this	当前对象	访问当前类的成员；调用当前类其他构造方法
super	父类对象	访问父类的成员；调用父类构造方法

void example() {
    this.method();   // 调用当前类的方法
    super.method();  // 调用父类的方法
}

---

2.递归详解

2.1 递归的核心思想

递归（Recursion）是指方法在执行过程中调用自身的编程技巧。它通常包含两个关键要素：

要素	说明
递归条件（终止条件）	停止递归的条件，防止无限循环
递归体	方法调用自身的逻辑

---

2.1.1 示例

1.阶乘计算

// 计算 n 的阶乘：n! = n × (n-1) × (n-2) × ... × 1
public int factorial(int n) {
    // 递归终止条件
    if (n <= 1) {
        return 1;
    }
    // 递归调用：n! = n × (n-1)!
    return n * factorial(n - 1);
}

执行过程（以 factorial(5) 为例）：

factorial(5)
= 5 × factorial(4)
= 5 × (4 × factorial(3))
= 5 × (4 × (3 × factorial(2)))
= 5 × (4 × (3 × (2 × factorial(1))))
= 5 × (4 × (3 × (2 × 1)))
= 120

---

2.斐波那契数列

// 斐波那契数列：1, 1, 2, 3, 5, 8, 13...
// F(n) = F(n-1) + F(n-2)
public int fibonacci(int n) {
    // 终止条件
    if (n <= 2) {
        return 1;
    }
    // 递归调用
    return fibonacci(n - 1) + fibonacci(n - 2);
}

---

3.打印数字

// 从 n 倒数打印到 1
public void countdown(int n) {
    System.out.println(n);  // 先打印当前数字

    // 终止条件
    if (n > 1) {
        countdown(n - 1);  // 调用自己，参数递减
    }
}

// 调用：countdown(5)
// 输出：5 4 3 2 1

---

2.2. 递归 vs 循环对比

特性	递归	循环（for/while）
代码可读性	简洁，贴近数学定义	相对冗长
内存占用	每次调用占用栈空间	固定内存
适用场景	树形结构、分治算法	简单重复操作
风险	栈溢出（StackOverflow）	无限循环

⚠️ 常见错误：忘记写终止条件

// ❌ 错误示例：无限递归
void wrong() {
    wrong();  // 没有终止条件！会导致栈溢出
}

// ✅ 正确示例
void right(int n) {
    if (n <= 0) return;  // 终止条件
    right(n - 1);
}

---

2.3 递归的实际应用场景

• 文件遍历：遍历文件夹及其所有子文件夹
• 树的遍历：二叉树的前序/中序/后序遍历
• 分治算法：快速排序、归并排序
• 回溯算法：迷宫求解、八皇后问题

---

Java 访问修饰符详解

四种访问级别

修饰符	含义	访问范围
public	公共的	所有类都可以访问
private	私有的	只有当前类内部可以访问
protected	受保护的	同包类 和 所有子类（包括不同包的子类）可以访问
default（不写）	默认的/包私有	只有同包类可以访问

---

⚠️ 重要提示

default 不是关键字！
表示默认访问权限时，什么都不写，不能写 default 这个单词。

// ❌ 错误：不能写 default
default void method() { }

// ✅ 正确：直接不写修饰符
void method() { }  // 这就是默认访问权限

---

访问权限对比图

访问场景	public	protected	default	private
同一个类	✅	✅	✅	✅
同一个包	✅	✅	✅	❌
不同包的子类	✅	✅	❌	❌
不同包的非子类	✅	❌	❌	❌

---

使用建议

场景	推荐修饰符
工具类/常量	public
需要被子类继承的方法	protected
仅本类内部使用	private
同包协作使用	default（不写）

---

课堂笔记 2026年3月25日

final

final关键字可以添加在变量,属性,方法,类上

变量,属性添加了final关键字,则变成常量

方法添加final关键字,则不能被重写

类添加了final关键字,则会被继承

多态

同一个引用,给不同的实例则去做不同的事情

用继承来实现多态

1. 子类继承父类

2. 子类重写父类的方法

3. 定义父类类型的引用

4. 给父类类型的引用保存不同的子类实例

5. 调用方法时,如果子类重写了父类的方法,则实际上调用子类的方法

6. 如果没有重写,则调用的是父类的方法