复习要点:
一、题型及分值分布
二、重点内容
CH1 Java入门（5分）
- JDK平台提供的java.exe是Java解释器、javac.exe是Java编译器；
- java文件编译成功后会在当前目录中生成的文件名和后缀；
字节码文件（.class）
- Java技术平台一般划分为三个系列：Java SE，Java EE和Java ME
JavaSE：Java标准版
JavaEE：Java企业版
JavaME：Java微型版
- Java跨平台的含义，作用；
含义：在一个计算机编译得到的字节码文件可以复制到任何一个安装了Java运行环境的计算机上直接使用。字节码由Java虚拟机负责解释运行。
作用：一次编译，多次运行
- JAVA执行过程的理解；
编写源文件（.java），编译源文件生成字节码（.class），加载运行字节码
- JAVA的程序结构；
class 类名{
属性；
构造方法{方法体}；
普通方法{方法体}；
}
Ch2 Java的基本数据类型与数组（7分）
- Java是大小写敏感语言
- 标识符的规则，中文问题；
标识符由字母，下划线，美元符号和数字组成，长度不受限制
标识符的第一个字符不能是数字
标识符不能是关键字
标识符不能是true，false和nell
- 关键字是否大小写的问题；
- 基本的数据类型，及其字节范围；
- 整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
① byte范围：-128 ~ 127，short范围：-2^15~2^15-1, int范围:-2^31~2^31-1, long范围:-2^63~2^63-1
② 声明long型变量，必须以”l”或”L”结尾
③ 通常，定义整型变量时，使用int型。
④ 整型的常量，默认类型是：int型 - 浮点型：float(4字节) \ double(8字节)
① 浮点型，表示带小数点的数值
② float表示数值的范围比long还大
③ 定义float类型变量时，变量要以”f”或”F”结尾
④ 通常，定义浮点型变量时，使用double型。
⑤ 浮点型的常量，默认类型为：double - 字符型：char (1字符=2字节)取值范围：0~65535
① 定义char型变量，通常使用一对’’,内部只能写一个字符
② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
③转义字符\
- 布尔型：boolean
① 只能取两个值之一：true 、 false
② 常常在条件判断、循环结构中使用- 基本数据类型间的隐式转换、显示转换问题，比如int a=10/3的整除问题；
涉及到的基本数据类型：除了boolean之外的其他7种
2. 隐式转换(自动类型转换，只涉及7种基本数据类型）
结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
byte 、char 、short —> int —> long —> float —> double
特别的：当byte、char、short三种类型的变量做运算时，结果为int型
说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
3. 显示转（换强制类型转换，只涉及7种基本数据类型）：自动类型提升运算的逆运算。
1. 需要使用强转符：( )
2. 注意点：强制类型转换，可能导致精度损失。
4. String与8种基本数据类型间的运算
String属于引用数据类型,翻译为：字符串
声明String类型变量时，使用一对“ “
String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
运算的结果仍然是String类型
避免：
String s = 123;//编译错误
String s1 = “123”;
int i = (int)s1;//编译错误数组的定义、声明、内存对象模型、引用及遍历；遍历数组时注意a[i] % 4==0和i% 3==4的区别；
数组的定义：一些类型相同的变量组成的集合
声明：
元素类型 数组名[];
元素类型 [] 数组名;
静态初始化:数组的初始化和数组元素的赋值操作同时进行
int[] ids= new int[]{1001,1002,1003,1004};
动态初始化:数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
内存对象模型： 
引用：下标
遍历：for循环，加强for循环
一维数组元素的默认初始化值
● 数组元素是整型：0
● 数组元素是浮点型：0.0
● 数组元素是char型：0或'\u0000'，而非'0'
● 数组元素是boolean型：false
● 数组元素是引用数据类型：null
- 三种注释；
单行注释：\注释内容
多行注释：*注释内容\
文档注释：**注释内容\
CH3 运算符、表达式和语句（7分）
循环语句，for/while/do…while/foreach的用法、特点；
for
while
do…while
foreach:for(声明循环变量：数组名){}基本语句的用法：赋值、条件、逻辑、比较、打印等；
赋值:=
条件:if语句，if-else语句，if-else if-else语句；switch语句
逻辑:&&,||,!
比较:>,<,>=,<=,==,!=
打印:println（）运算符，尤其是==、三目运算符等；尤其要注意逻辑运算是短路运算。
算术运算符：+，-，*,/,%
自增，自减运算符：++x（—x）先加（减）再用，x++（x—）先用再加（减）
关系运算符：>,<,>=,<=,==,!=
赋值运算符：=
位运算符：&按位与运算符，|按位或运算符，~按位非运算符，^按位异或运算符
- 每个表达式对应的值，如赋值表达式的值、逗号表达式的值、三元运算符的值；
- 选择语句的概念，使用；
CH4 类与对象（11分）
- 成员变量的定义：类中方法外定义的变量；
成员变量的特点：在整个类体有效，与其声明的位置无关，在定义时有默认值。每个类型变量的默认值都不一样，书上有一张表，要牢记；
- 局部变量的定义：在方法体中定义的变量和方法的参数；
局部变量的特点：只在定义它的方法内有效，与其声明的位置有关，局部变量在定义时没有默认值。
- 如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏,如果想在该方法中使用被隐藏的成员变量，则必须使用关键字this；
- 成员常变量的定义（final的用法）；成员变量的定义；
5）构造方法的概念和理解；构造方法的定义格式要牢记；构造方法也是一种方法，也可以重载；构造方法的特点是创建一个类实例后调用的第一个方法；
6）函数签名的概念，函数重载的概念；函数重载的使用；
7）函数传参的使用及理解；用内存对象模型好好分析（Java总是在传值，引用型传的是变量的地址，而基本型传的是变量的值）；要注意跟方法返回值一起考虑，如：
public class E {
public static void main (String[]args) {
String str = new String (“aa”);
str=modify(str);
System.out.println(str);
}
public static String modify (String s) { //若没有返回类型呢？
s = s + “bb”;
return s;
}
}
- 实例成员、类成员的区别和联系；
- 四种访问权限及其范围大小排序；
权限从小到大顺序为：private < 缺省 < protected < public
- 包的概念，用法，跟文件的关系；
CH5 子类与继承（9分）
- abstract的用法：
（1）修饰类，让类变成抽象类，其特点是：抽象类不能实例化对象。一个类是不是抽象类，主要看他有没有abstract修饰，若有则是抽象类，若没有就不是抽象类；
（2）修饰方法：让方法变成抽象方法，其特点是，抽象方法不需要写类体。一个方法是不是抽象方法，只需要看他有没有被abstract修饰，若有则是抽象方法，若没有就不是抽象方法；
（3）一个类若有抽象方法，则该类一定是抽象类，因为抽象方法没有实体，没有具体的功能，不能实例化，就只能是抽象类，反之，若不是抽象类，那么实例化后，该示例对象的该方法有什么功能，就无法确定，因此Java有这么个规定；反之，抽象类可以没有抽象方法，即该类中所有的方法都是非抽象方法，都没有被abstract修饰，此时，若该类没有被abstract修饰，此类就是非抽象类，若被abstract修饰，此类就是抽象类。
- final的用法：
（1）修饰类，说明此类不能被继承；
（2）修饰方法，说明此方法不能被子类重写；
（3）修饰变量（不管是成员变量还是局部变量），说明此变量不能被改写，即它是一个常变量；
（4）问题思考：由abstract和final含义可知，两个单词能不能同时修饰同一个类或方法？
- super的用法：
- 子类的构造方法中且第一条语句上使用super调用父类的构造方法，根据具体情况，可带参数，也可不带参数；
- 若子类成员（可以是属性，也可以是方法）隐藏了对应父类重名的成员，用super操作被隐藏的父类的成员变量和方法；
- this的用法：
- 局部变量隐藏时，用它可以访问成员变量；
- 多个构造方法间的访问，注意必须在构造方法的第一行；
- 修饰成员方法；
- 方法重写的概念，重写的规则（尤其是重写父类的方法时，不允许提高方法的访问权限，但可以降低访问权限）；注意跟另一个概念【方法重载】对比（同一个类中，不同签名）；
- 成员（包括成员方法和成员属性）隐藏的概念，成员隐藏在代码中的应用；特别是，当它跟多态结合起来考虑时要紧扣概念；
public Demo{
public static void main(String args[]) {
A fu = new A();
System.out.println(fu.f());
B zi = new B();
System.out.println(zi.f());
}
}
class A {
int x = 222, y = 3333;
int f() {….}
}
class B extends A {
int x = 4444, y = 555;
int f() {…..}
}
- 方法的可变参数，实际上是一个数组，这个知识点可以跟数组一起考核，比如，求所有参数的和或乘积等等应用；
- 利用父类是一个抽象类或者一个接口，子类实现求解不同图形的周长或面积；试着自己写下代码；
CH6 接口与实现（2分）
- 接口的概念；存在的价值，即引入接口解决的问题；
- 接口的定义格式；接口中方法默认被public abstract修饰；接口中的变量自动都是public、static，final；接口中也可以有非抽象的方法；接口也产生class文件；接口中的方法不能被final修饰，因为要重写所有接口中的方法；
- 如果一个类实现了某个接口，那么这个类必须重写该接口的所有抽象方法，否则编译出错。
- 接口回调；接口与多态；
CH7 内部类与异常类（8分）
- 内部类的概念和定义；内部类有四种类型；每一种内部类的书写格式，尤其是匿名内部类的书写格式；
成员内部类（静态内部类，非静态内部类）
成员内部类就是一般我们说的非静态内部类和静态内部类，即在类中定义的。
匿名内部类
匿名内部类一般用于函数参数，作用是实现某个接口
在方法参数中新建一个接口对象 / 类对象，并且实现这个接口声明 / 类中原有的方法
局部内部类
如果一个内部类只在一个方法中使用到了，那么我们可以将这个类定义在方法内部，这种内部类被称为局部内部类。其作用域仅限于该方法。内部类编译后如何取名？给你一段代码，你能不能判断有几个class文件及其对应的名称；
格式：
成员内部类：外部类$内部类名.class
局部内部类：外部类$数字 内部类名.class
- 内部类直接访问的是外部类变量的值,尤其是跟方法、构造方法、变量初始化等知识点一起考核时，注意理解；
class A{
int a=7555;
A(){ a=8888; }
int getA(){ return a; }
void ff(){ a=999; }
class B{
B(){ a=11111; }
void f(){
ff();
System.out.println(a);
}
}
public static void main(String[] args) {
A o=new A();
System.out.println(o.getA());
B i=o.new B();
i.f();
}
}
- 异常的概念，异常的定义；异常体系有3大类；理解程序员处理异常的2种方式；
概念：程序运行时可能出现的一些错误
定义：
1. 继承于现的异常结构
2. 提供全局常量
3. 提供重载的构造器
异常的执行流程；
过程一：”抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象。
并将此对象抛出。
一旦抛出对象以后，其后的代码就不再执行。
关于异常对象的产生：
① 系统自动生成的异常对象
② 手动的生成一个异常对象，并抛出（throw）
过程二：”抓”：可以理解为异常的处理方式：① try-catch-finally ② throws
异常体系有3大类：
编译时异常(checked)
运行时异常(unchecked,RuntimeException)
- 异常处理的5个关键字：try…catch、finally、throws 、throw的用法、意义和注意事项；
try…catch：
1.使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中行匹配
2.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构（在没写finally的情况。继续执行其后的代码
3.catch中的异常类型如果没子父类关系，则谁声明在上，谁声明在下无所谓。catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错
finally：finally是一定执行的
throws：throws 属于异常处理的一种方式，声明在方法的声明处。
throw：throw 表示抛出一个异常类的对象，生成异常对象的过程。声明在方法体内。
7）Throwable类中定义了3个异常处理的方法；
1.public void printStackTrace():打印异常的详细信息。
包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
2.public String getMessage():获取发生异常的原因。
提示给用户的时候,就提示错误原因。
3.public String toString():获取异常的类型和异常描述信息(不用)。
CH8 常用实用类（7分）
- String类概念；定义和构造；
概念：处理字符序列
定义：
构造：String 对象名=new String（字符串）；
String s = new String(“abc”);方式创建对象，在内存中创建了几个对象？
两个:一个是堆空间中new结构（存的是常量池的地址），另一个是char[ ]对应的常量池中的数据：”abc”
- String类函数的用法，尤其是indexOf；compareTo、getBytes()和length()的用法；当length()跟ASCII编码表及转义字符结合起来使用时，要能理解字符串的长度；
indexOf()：返回指定子字符串在此字符串中第一次出现处的索引
compareTo：按字典顺序比较两个字符串。
getBytes()：使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
length()：字符序列长度
- 常量池的概念，编译器对字符串常量构造时的优化；
编译器对字符串常量构造时的优化：
给一个变量赋值，如果等于号的右边是常量的表达式并且没有一个变量，那么就会在编译阶段计算该表达式的结果，然后判断该表达式的结果是否在左边类型所表示范围内，如果在，那么就赋值成功，如果不在，那么就赋值失败。但是注意如果一旦有变量参与表达式，那么就不会有编译期间的常量优化机制
- 字符串内容相等、地址相等的判断方法；字符串的内存对象模型；String和StringBuffer内存分配问题对比解析；
字符串内容相等：equals()
字符串地址相等：==
字符串的内存对象模型：
String和StringBuffer内存分配问题对比解析：
String:不可变的字符序列；底层使用char[]存储
StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储
String内存分配情况：
String Str = “jack”这个语句会先检查字符串常量池是否存放这个”jack”这个字符串对象，如果没有存在，那么就会在字符串常量池中创建这个字符串对象，如果存在直接返回该字符串的内存地址值。
String str3 = new String(“jack”) 该语句会创建两个对象,首先会先检查字符串常量池中存不存在jack这个字符串对象，如果不存在就会创建，如果存在就返回内存地址值。创建了出来之后，new String这个语句就会在堆内存中开辟一个字符串对象。总共两个对象
String、StringBuffer和StringBuilder在本质上都是字符数组，不同的是，在进行连接操作时，String每次返回一个新的String实例，而StringBuffer和StringBuilder的append方法直接返回this，所以这就是为什么在进行大量字符串连接运算时，不推荐使用String，而推荐StringBuffer和StringBuilder。
- 输入输出，尤其要注意：System.out.print和System.out.println的区别；
输入：Scanner 变量名=new Scanner(System.in)
CH9 组件及事件处理（10分）
- 常见的组件（课程上讲解的，点到的）的使用，事件源、事件监听器；
组件：
事件源：
| 组件名 | 功能 |
|---|---|
| Button | Button（按钮） |
| Canvas | 用于绘图的画布 |
| Checkbox | 复选框组件（也可当做单选框组件使用） |
| CheckboxGroup | 用于将多个Checkbox 组件组合成一组， 一组 Checkbox 组件将只有一个可以 被选中 ， 即全部变成单选框组件 |
| Choice | 下拉选择框 |
| Frame | 窗口 ， 在 GUI 程序里通过该类创建窗口 |
| Label | 标签类，用于放置提示性文本 |
| List | JU表框组件，可以添加多项条目 |
| Panel | 不能单独存在基本容器类，必须放到其他容器中 |
| Scrollbar | 滑动条组件。如果需要用户输入位于某个范围的值 ， 就可以使用滑动条组件 ，比如调 色板中设置 RGB 的三个值所用的滑动条。当创建一个滑动条时，必须指定它的方向、初始值、 滑块的大小、最小值和最大值。 |
| ScrollPane | 带水平及垂直滚动条的容器组件 |
| TextArea | 多行文本域 |
| TextField | 单行文本框 |
事件监听器：
| 事件类别 | 描述信息 | 监听器接口名 |
|---|---|---|
| ActionEvent | 激活组件 | ActionListener |
| ItemEvent | 选择了某些项目 | ItemListener |
| MouseEvent | 鼠标移动 | MouseMotionListener |
| MouseEvent | 鼠标点击等 | MouseListener |
| KeyEvent | 键盘输入 | KeyListener |
| FocusEvent | 组件收到或失去焦点 | FocusListener |
| AdjustmentEvent | 移动了滚动条等组件 | AdjustmentListener |
| ComponentEvent | 对象移动缩放显示隐藏等 | ComponentListener |
| WindowEvent | 窗口收到窗口级事件 | WindowListener |
| ContainerEvent | 容器中增加删除了组件 | ContainerListener |
| TextEvent | 文本字段或文本区发生改变 | TextListener |
组件和事件、事件监听器的一对一、一对多关系的理解；
布局的概念，意义和使用；
概念：布局管理器可以将组件进行统一管理
意义：Java提供了LayoutManager布局管理器，可以根据运行平台来自动调整组件大小，程序员不用再手动设置组件的大小和位置了，只需要为容器选择合适的布局管理器即可
使用：
FlowLayout：流式布局管理器
BorderLayout：边框布局管理器
CardLayout：卡片布局管理器
GridLayout：网格布局管理器
GridBagLayout：网格包布局管理器
BoxLayout：盒布局管理器
- 课设中的相关组件知识；
见上面事件源
- 事件监听器添加的几种写法：
https://blog.csdn.net/jasonCSH/article/details/108730324
通过内部类实现
通过匿名内部类实现
外部类实现
通过事件源所在类实现
通过onClick属性实现
CH10 输入、输出流（9分）
- 一切皆字节流的含义；
一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。
- File类的几种构造方式；
File(String Pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
参数：
string pathname:字符串的路径名称
路径可以是以文件结尾,也可以是以文件夹结尾
路径可以是相对路径,也可以是绝对路径
路径可以是存在,也可以是不存在
创建FiLe对象,只是把字符串路径封装为FiLe对象，只是把字符串路径封装为文件对象，不考虑路径的真假情况
File(String parentPath,String childPath)从父路径名字符串和子路径名字符串创建新的 File实例。
参数：把路径分成两部分
String parentPath：父路径
String childPath：子路径
File(File parentFile,String childPath)从父抽象路径名和子路径名字符串创建新的 File实例。
- GBK编码的特点；UTF-8编码的特点；尤其是汉字的表达；
ASCII：美国标准信息交换码。
用一个字节的7位可以表示。
ISO8859-1：拉丁码表。欧洲码表
用一个字节的8位表示。
GB2312：中国的中文编码表。最多两个字节编码所有字符
GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
Unicode：国际标准码，融合了目前人类使用的所字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。
GBK编码的特点：
文件输出流FileOutputStream都继承于OutputStream，而文件输入流FileInputStream都继承于InputStream类；
字节流、字符流的概念，应用背景和意义、使用步骤；尤其是数据追加写的代码；
字节流：
字符流：
数据追加续写
每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？
● public FileOutputStream(File file, boolean append)： 创建文件输出流以写入由指定的 File对象表示的文件。
● public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件。
这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了
- 常见的输入输出流（课堂上重点讲解的字节、字符、缓冲、转换）定义，来自那个包，使用步骤；
字节:
字节输出流【OutputStream】
java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。
字节输出流【OutputStream】
java.io.InputStream抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。
字符：
字符输入流【Reader】
java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。
字符输出流【Writer】
java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。
缓冲：
缓冲流涉及到的类：
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
转换：
转换流涉及到的类：属于字符流
InputStreamReader：将一个字节的输入流转换为字符的输入流
解码：字节、字节数组 —->字符数组、字符串
OutputStreamWriter：将一个字符的输出流转换为字节的输出流
编码：字符数组、字符串 —-> 字节、字节数组
- Java中文件路径分隔符的写法；
转义字符:\
- 随机流的作用
随机存取文件流（读文件，存文件）
- 对象序列化必须具备的条件；
1.需要实现接口：Serializable
2.当前类提供一个全局常量：serialVersionUID
3.除了当前Person类需要实现Serializable接口之外，还必须保证其内部所属性,也必须是可序列化的。（默认情况下，基本数据类型可序列化）
补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
CH11 JDBC与MySQL数据库（13分）
import java.sql.;
public class Example11_1 {
public static void main(String args[]) {
Connection con=null;
Statement sql;
ResultSet rs;
try{ Class.forName(“com.mysql.jdbc.Driver”); //加载JDBC_MySQL驱动
}
catch(Exception e){}
String uri = “jdbc:mysql://localhost:3306/students?useSSL=true”;
String user =”root”;
String password =””;
try{
con = DriverManager.getConnection(uri,user,password); //连接代码
}
catch(SQLException e){ }
try {
sql=con.createStatement();
rs=sql.executeQuery(“SELECT FROM mess”); //查询mess表
while(rs.next()) {
String number=rs.getString(1);
String name=rs.getString(2);
Date date=rs.getDate(3);
float height=rs.getFloat(4);
System.out.printf(“%s\t”,number);
System.out.printf(“%s\t”,name);
System.out.printf(“%s\t”,date);
System.out.printf(“%.2f\n”,height);
}
con.close();
}
catch(SQLException e) {
System.out.println(e);
}
}
}
- ResultSet对象自动维护指向当前数据行的游标，每调用一次next()方法，游标向下移动一行
ResultSet：结果集对象,封装查询结果
- JDBC的概念：是一种用于执行SQL语句的Java API，为多种关系数据库提供统一访问。它由一组用Java语言编写的类和接口组成；
- JDBC的使用步骤，编码；
步骤：
1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
1.复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下
2.右键—>Add As Library
2. 注册驱动
Class.forName(“com.mysql.jdbc.Driver”)
3. 获取数据库连接对象 Connection
Connection con = DriverManager.getConnection(uri,user,password)
4. 定义sql
Statement sql
5. 获取执行sql语句的对象 Statement
sql=con.createStatement()
6. 执行sql，接受返回结果
rs=sql.executeQuery(“SELECT * FROM mess”)
7. 处理结果
8. 释放资源
con.close()
JDBC中常用的几个类；上课讲解的几个实例；
DriverManager：驱动管理对象
* 功能：
1. 注册驱动：告诉程序该使用哪一个数据库驱动jar
static void registerDriver(Driver driver) :注册与给定的驱动程序 DriverManager 。
写代码使用： Class.forName(“com.mysql.jdbc.Driver”);
通过查看源码发现：在com.mysql.jdbc.Driver类中存在静态代码块
static {
try {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException(“Can’t register driver!”);
}
}注意：mysql5之后的驱动jar包可以省略注册驱动的步骤。<br /> 2. 获取数据库连接：<br /> * 方法：static Connection getConnection(String url, String user, String password) <br /> * 参数：<br /> * url：指定连接的路径<br /> * 语法：jdbc:mysql://ip地址(域名):端口号/数据库名称<br /> * 例子：jdbc:mysql://localhost:3306/db3<br /> * 细节：如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称<br /> * user：用户名<br /> * password：密码 <br /> 2. Connection：数据库连接对象<br /> 1. 功能：<br /> 1. 获取执行sql 的对象<br /> * Statement createStatement()<br /> * PreparedStatement prepareStatement(String sql) <br /> 2. 管理事务：<br /> * 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务<br /> * 提交事务：commit() <br /> * 回滚事务：rollback() <br /> 3. Statement：执行sql的对象<br /> 1. 执行sql<br /> 1. boolean execute(String sql) ：可以执行任意的sql 了解 <br /> 2. int executeUpdate(String sql) ：执行DML（insert、update、delete）语句、DDL(create，alter、drop)语句<br /> * 返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功 返回值>0的则执行成功，反之，则失败。<br /> 3. ResultSet executeQuery(String sql) ：执行DQL（select)语句<br /> 2. 练习：<br /> 1. account表 添加一条记录<br /> 2. account表 修改记录<br /> 3. account表 删除一条记录代码：<br /> Statement stmt = null;<br /> Connection conn = null;<br /> try {<br /> //1. 注册驱动<br /> Class.forName("com.mysql.jdbc.Driver");<br /> //2. 定义sql<br /> String sql = "insert into account values(null,'王五',3000)";<br /> //3.获取Connection对象<br /> conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");<br /> //4.获取执行sql的对象 Statement<br /> stmt = conn.createStatement();<br /> //5.执行sql<br /> int count = stmt.executeUpdate(sql);//影响的行数<br /> //6.处理结果<br /> System.out.println(count);<br /> if(count > 0){<br /> System.out.println("添加成功！");<br /> }else{<br /> System.out.println("添加失败！");<br /> }<br /> <br /> } catch (ClassNotFoundException e) {<br /> e.printStackTrace();<br /> } catch (SQLException e) {<br /> e.printStackTrace();<br /> }finally {<br /> //stmt.close();<br /> //7. 释放资源<br /> //避免空指针异常<br /> if(stmt != null){<br /> try {<br /> stmt.close();<br /> } catch (SQLException e) {<br /> e.printStackTrace();<br /> }<br /> }<br /> <br /> if(conn != null){<br /> try {<br /> conn.close();<br /> } catch (SQLException e) {<br /> e.printStackTrace();<br /> }<br /> }<br /> }<br /> <br /> 4. ResultSet：结果集对象,封装查询结果<br /> * boolean next(): 游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，如果是，则返回false，如果不是则返回true<br /> * getXxx(参数):获取数据<br /> * Xxx：代表数据类型 如： int getInt() , String getString()<br /> * 参数：<br /> 1. int：代表列的编号,从1开始 如： getString(1)<br /> 2. String：代表列名称。 如： getDouble("balance")<br /> <br /> * 注意：<br /> * 使用步骤：<br /> 1. 游标向下移动一行<br /> 2. 判断是否有数据<br /> 3. 获取数据//循环判断游标是否是最后一行末尾。<br /> while(rs.next()){<br /> //获取数据<br /> //6.2 获取数据<br /> int id = rs.getInt(1);<br /> String name = rs.getString("name");<br /> double balance = rs.getDouble(3);<br /> <br /> System.out.println(id + "---" + name + "---" + balance);<br /> }* 练习：<br /> * 定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，返回。<br /> 1. 定义Emp类<br /> 2. 定义方法 public List<Emp> findAll(){}<br /> 3. 实现方法 select * from emp;<br /> <br /> 5. PreparedStatement：执行sql的对象<br /> 1. SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题<br /> 1. 输入用户随便，输入密码：a' or 'a' = 'a<br /> 2. sql：select * from user where username = 'fhdsjkf' and password = 'a' or 'a' = 'a'2. 解决sql注入问题：使用PreparedStatement对象来解决<br /> 3. 预编译的SQL：参数使用?作为占位符<br /> 4. 步骤：<br /> 1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar<br /> 2. 注册驱动<br /> 3. 获取数据库连接对象 Connection<br /> 4. 定义sql<br /> * 注意：sql的参数使用？作为占位符。 如：select * from user where username = ? and password = ?;<br /> 5. 获取执行sql语句的对象 PreparedStatement Connection.prepareStatement(String sql) <br /> 6. 给？赋值：<br /> * 方法： setXxx(参数1,参数2)<br /> * 参数1：？的位置编号 从1 开始<br /> * 参数2：？的值<br /> 7. 执行sql，接受返回结果，不需要传递sql语句<br /> 8. 处理结果<br /> 9. 释放资源5. 注意：后期都会使用PreparedStatement来完成增删改查的所有操作<br /> 1. 可以防止SQL注入<br /> 2. 效率更高
UPDATE SET =?,=?,=? WHERE *=?，如何为预编译的sql语句赋值；
使用 PreparedStatement 的步骤：
1.编写 SQL 语句，未知内容使用?占位：”SELECT * FROM user WHERE name=? AND password=?”;
2.获得 PreparedStatement 对象
3.设置实际参数：setXxx(占位符的位置, 真实的值)
4.执行参数化 SQL 语句
5.关闭资源
- 数据库的连接使用，尤其是下述代码，注意每个部分的含义；
Connection conn = DriverManager.getConnection(“jdbc:mysql://localhost/students?user=root&password=root&serverTimezone=UTC”);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(“SELECT * FROM students.mess”);
int i=1;
while(rs.next()) {
System.out.print(i+”: “+rs.getString(1));
System.out.print(rs.getString(“name”));
System.out.print(rs.getDate(“birthday”));
System.out.println(rs.getDouble(“height”));
i++;
}
CH12 Java多线程机制（11分）
- 线程的概念、理解；
● 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
● 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
线程的创建（两种方式）；
定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
2. 创建Thread子类的实例，即创建了线程对象
3. 调用线程对象的start()方法来启动该线程定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正
的线程对象。
3. 调用线程对象的start()方法来启动线程。线程的生命周期及几个状态，这几个状态如何进行切换；尤其是在调用start()方法后、调用sleep(100)后；线程中断的几种原因；
start()方法来运行多线程代码
start()、wait(有参数)、wait()无参数、notify()、notifyAll()、sleep的用法及意义；
wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
2. notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先入座。
3. notifyAll：则释放所通知对象的 wait set 上的全部线程。多窗口卖票的实例代码，要研究透彻；
CH15 泛型与集合框架（1分）
- 代码【class People
】中，E是泛型，它可以是那些类型(obj)； - 数组和链表这两种数据存储结构的优缺点；
- 我在上课时讲解的那个求体积时的解决思路，不用泛型时怎么解决的，用泛型时怎么解决的，好好想想。
若有收获，就点个赞吧
0 人点赞
