Java学习总结

7月9号 学习的整体框架

​

1. Java 定义了 4 种整数类型变量：字节型（byte）、短整型（short）、整型（int）和长整型（long）。

   常量：final 数据类型 常量名

2. 重要规范:

   • {}大括号里要有四个空格的缩进

   • 函数和函数中间应该有一个空行 空一行

   • if和else即使只有一句话，也要加上{}

   • 类名首个单词的首字母大写StudentManager，一般是名词

   • 函数首个单词的首字母小写printStudentInfo()，一般以动词开头 驼峰命名法

3. 强制类型转换：

   ​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5GbHsIrO-1660804798093)(C:\Users\xuezihan123\AppData\Roaming\Typora\typora-user-images\image-20220711105935597.png)]

   1个字节=8位

   byte: 1个字节，不考虑负数能表示范围是：0_{255(2的八次方=256)，考虑正负表示范围：==-128}127==

   short:2个字节，16位 65536 0~65535

   int: 4个字节，考虑正负：-21亿~+21亿

   long:8个字节

   float: 4个字节

   double:8个字节

   char字符型：2个字节，采用的是Unicode编码每个字符在编码表里面都对应一个int整数

   Boolean: 只有true和false两种情况

4. 数据类型转换：

   1、从小到大自动类型转换

   2、从大到小需要强制类型转换，可能会丢失精度

   byte->short(char)->int->long->float->double

5. &&：两边的结果都是true，结果才是true

   ||：两边只要有一个是true，结果就是true

6. 在程序运行前进行判断，若有非法输入，则使用：System.exit();

7. **三目运算符号：**语法：boolean ? 数1 ： 数2。

7月11号 快捷键

1. 数组：int[] array = new int[4];

2. java.lang.Array Index OutOf Bounds Exception: 4

   数组下标越界异常(Index：bounds:边界 OutOf：超出 Exception：异常)

3. 数组的排序：冒泡排序 （双重For循环）

4. 快捷键集合笔记链接：D:\思途笔记\笔记\快捷键集合.md

5. instanceof：是二元运算符

   instanceof是Java中的二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。

7月12号：

OOP: Object Oriented Programming 面对对象编程

数据类型的默认值：

​ int类型默认值是：0

​ double类型默认值是：0.0

​ boolean类型默认值是：false

​ String类型默认值是：null

​ int[]类型默认值是：null

​ Student[]类型默认值是：null

​ boolean[]类型默认值是：null

1. 属性私有，通过get、set方法访问。

2. 构造方法：

   特点：1、方法名和类名一样 2、没有返回值 3、也不是void类型

   //无参构造方法

   //如果不写，Java默认提供这样一个无参构造方法.

   //如果你写了，Java就不会再提供这个无参构造方法

3. this代表当前对象，把通过构造方法传递过来的值，赋值给当前对象的id。

4. super代表继承的父类构造方法

7月13号继承，重载，重写，抽象，多态

1. 你继承谁你就是谁，继承是一种严格的父子关系（在父类里面抽取的属性和方法一定是所有子类所共有）

2. 单继承

3. private:只在当前类里面可以访问（子类也不能访问）

   public：任何地方都可以访问

   protected：提高代码复用性。

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9ob2SpZl-1660804798094)(C:\Users\xuezihan123\AppData\Local\Temp\707_0 (1)].png)

4. **super();**调用父类的构造对象，必须先写在子类第一行

5. 重载（overload）:

   在同一个类里面，允许存在一个以上同名方法，只要他们参数类型和参数个数不同即可。

   同一个类中看同名方法的参数列表。（构造方法重载）

6. 重写/覆盖（@Override）:

1、子类覆盖父类，必须保证子类权限大于父类权限才可以覆盖，否则会编译失败。

2、如果父类是private的方法，子类是默认方法，那么子类是不知道这个方 法的，不是覆盖。

Java重写有如下标准：

1. 参数列表必须与被重写方法的相同。

2. 重写方法不能限制比被重写方法更严格的访问级别

3. 重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常

4. 返回类型必须与被重写方法的返回类型相同。仅当返回值为类类型时，重写的方法才可以修改返回值类型，且必须是父类方法返回值的子类。

5. 多态：

   在子类中重写父类方法，在测试类中创建方法时，声明写父类 如Cal cal；

   ​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OZpXEspv-1660804798095)(C:\Users\xuezihan123\AppData\Roaming\Typora\typora-user-images\image-20220713161349596.png)]

6. 抽象类：

   1、抽象方法是没有方法体（method），如果这个类里面有抽象方法，这个类必须变成抽象类。

   2、如果这个类是抽象类，并不要求这个类一定要有抽象方法

   3、抽象类里面可以有普通方法，也可以有抽象方法。

   4、如果一个类是抽象类，那么这个类就不能被new实例化，只能被其他类继承。

   5、抽象方法可以理解为父类（抽象类）定义的一个模板或者规范（自己本身不实现），子类必须实现这个抽象方法，如果子类不想实现这个方法，那么这个子类也必须要变成抽象类。

7. 接口interface：

1.接口是一个纯粹的抽象类（接口里面所有的方法都是抽象方法）,接口里面的方法都是抽象方法 public abstract。

2.接口里面所有的属性public static final

11. 接口与抽象类的区别：🤕

接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。另外，接口和抽象类在方法上有区别：

​ 1.抽象类可以有构造方法，接口中不能有构造方法。

​ 2.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

​ 3.抽象类中可以有普通成员变量，接口中没有普通成员变量

4. 抽象类中的抽象方法的访问类型可以是public，protected和默认类型

5. 抽象类中可以包含静态方法，接口中不能包含静态方法

6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型

7. 一个类可以实现多个接口，但只能继承一个抽象类。

8. final:(最终的意思)

final变量：这个变量就不能被修改，常量 ，接口里面： public static final double PI = 3.1415;

final类：这个类就不能被继承

final方法：这个方法就不能被重写

7月14号：静态 String

1. static静态属性、静态方法：（经常被写成静态类Math，ArrayUtil）

   1、静态方法：如果一个static方法则最好使用【 类名 点 方法 】Student.print()，此静态方法属于这个类。静态方法中没有实例时，不能调用this super 。

   2、静态属性：

   3、静态的方法只能访问静态的方法和静态的属性（因为当前对象的实例可以没有创建，所以静态的方法是没办法调用非静态的方法和属性的）

   4、静态的方法中不能写this、super关键字(因为当前的对象实例可能还没有创建，代表当前类对象的this还有代表父类对象的super可能都还没有创建)

   5、非静态的属性和方法（实例属性和方法)必须通过new对象访问，而静态的属性和方法是属于类的，在类加载到内存中就可以访问，被所有对象所共享。

2. String：

   • == 比较的是地址 equals 比较的是内容

   • s1 = “aBC”;

   • s1 = “AbC”;

   • s1.equals(s2); // false 不忽略大小写

   • s1.equalsIgnorecase(s2); // true 忽略大小写

3. 常量池问题：new在堆中。如果直接赋值字符串则先去常量池找，如果有就不用新建，如果没有需要新建。

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L9uiVL0q-1660804798096)(D:\思途笔记\笔记\图片存放\Image.png)]

4. String API：

   startswith(String prefix/suffix) 以······开头 prefix 前缀 suffix 后缀

   检测是否是以XXX前缀开头的/XXX后缀开头的

5. String、StringBuffer、StringBuilder异同点：

   相同点：都是final类，都不能被继承。

   不同点：1、String长度是不可改变的，StringBuffer、StringBuilder长度是可变的。

   ​ 2、StringBuffer是线程安全（需要加锁，效率低)、StringBuilder是线程不安全（没有加锁，效率高）。

6. 包装数据类型：

   Java是纯面向对象语言，int、double都是基本数据类型。

   int Integer

   char Character

   double Double

   long Long

   short Short

   boolean Boolean

   byte Byte

   定义全局的变量是用Integer ,局部方面的话用int

7. 🆘Static静态代码块知识点笔记 ⭐️

   链接：https://app.yinxiang.com/fx/31dc0cd8-c357-4674-b331-c77128ebd79e

7月15号 MySql

1. 主键：关系型数据库中的一条记录中有若干个属性，若其中某一个属性组(注意是组)能唯一

   标识一条记录，该属性组就可以成为一个主键 。

2. 外键：如果公共关键字在一个关系中是主关键字，那么这个公共关键字被称为另一个关系的外

   键。由此可见，外键表示了两个关系之间的相关联系。以另一个关系的外键作主关键字的表被

   称为主表，具有此外键的表被称为主表的从表。外键又称作外关键字。

3. 字段属性设置:

   1、not null： 不为空，表示该字段不能放“null”这个值。不写，则默认是可以为空

   2、auto_increment: 设定int类型字段的值可以“自增长”，即其值无需“写入”，而会自动获得并增加

   此属性必须随同 primary key 或 unique key 一起使用。primary key = unique key + not null

   3、primary key： 设定为主键。

   是唯一键“加强”：不能重复并且不能使用null，并且可以作为确定任意一行数据的“关键值”，

   最常见的类似：where id= 8; 或 where user_name=‘zhangsan’;

   通常，每个表都应该有个主键，而且大多数表，喜欢使用一个id并自增长类型作为主键。

   但：一个表只能设定一个主键。

   4、unique [key] : 设定为唯一键：表示该字段的所有行的值不可以重复（唯一性）。Duplicate entry ‘zhangsan’ for key ‘name’

   5、default ‘默认值’： 设定一个字段在没有插入数据的时候自动使用的值。

   6、comment ‘字段注释’

4. PRIMARY KEY 主键，不能重复，唯一确定一条记录 （unique+not null）

   AUTO_INCREMENT 自动增长

   varchar(10) char(10)区别：

   同点：都可以最大放10个字符

   不同点：char(10)不管输入的是多少都会占10个字符，例如输入名字“张三”只有两个字符，

   但是使用char(10)在数据库里面还是占10个字符的空间。

   使用varchar(10)最大支持是10个字符，但是实际长度就是输入字符长度，例如输入名字“张三”只有两个字符，

   那么在varchar(10)里面就只占两个字符。

5. 联合主键：

   PRIMARY KEY(banji_id,course_id), -- 联合主键  
   
   FOREIGN KEY(banji_id) REFERENCES banji(id), -- banji_id既是联合主键又是外键  
   FOREIGN KEY(course_id) REFERENCES course(id) -- course_id既是联合主键又是外键);
   

6. 多表查询：

   SELECT * FROM student WHERE banji_id=2;
   SELECT id FROM banji WHERE `name`='java1812';
   SELECT * FROM student WHERE banji_id=(SELECT id FROM banji WHERE `name`='java1812');
   

7. inner join(关联查询)：

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jj5EXjba-1660804798096)(D:\思途笔记\笔记\图片存放\Image [9].png)]

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XiPdH2yq-1660804798097)(D:\思途笔记\笔记\图片存放\Image [10].png)]

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7hQ73dbQ-1660804798098)(D:\思途笔记\笔记\图片存放\Image [11].png)]

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IjbU2ETd-1660804798099)(D:\思途笔记\笔记\图片存放\Image [12].png)]

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B2LOXFG9-1660804798099)(D:\思途笔记\笔记\图片存放\Image [13].png)]

   – inner join on 只有左右两个表有关联的才查询出来

   – left join on 左表中都显示出来，右表没有显示空

   – right join on 右表都显示，左表没有显示空

8. **select查询：**group by之后使用having

   -- 4、查询该店每个栏目下挤压的货款 > 20000
   SELECT cat_id,SUM(goods_number*shop_price) AS total_price
   FROM goods GROUP BY cat_id HAVING total_price>20000;-- having
   

9. 模糊查找：like

   1、like模糊查找用于对字符类型的字段进行字符匹配查找。

   2、要查找的字符中，有两个特殊含义的字符：% , _:

   ​ 2.1: %含义是：代表0或多个的任意字符

   ​ 2.2: _含义是：代表1个任意字符

   ​ 2.3: 这里的字符都是指现实中可见的一个“符号”，而不是字节。

   3、语法：like ‘%关键字%’

   SELECT * FROM student WHERE `name` LIKE '张%'; -- 以张开头
   SELECT * FROM student WHERE `name` LIKE '张_'; -- 以张开头，而且名字是两个字
   SELECT * FROM student WHERE `name` LIKE '%张%'; -- 名字里面只要有张就可以
   

10. 分组查询：

    – 分组查询后筛选

    – 需求：address大于1

    – group by之后的条件查询使用having

    SELECT address AS ‘地址’,COUNT(id) AS ‘人数’ FROM student GROUP BY address HAVING COUNT(id)>1;

    order by 与 limit：

    LIMIT 子句可以被用于强制 SELECT 语句返回指定的记录数。LIMIT 接受一个或两个数字参数。参数必须是一个整数常量。如果给定两个参数，第一个参数指定第一个返回记录行的偏移量，第二个参数指定返回记录行的最大数目。初始记录行的偏移量是 0(而不是 1)

    -- 1、按照栏目由低到高排序，栏目内部按照价格由高到低排序
    SELECT goods_id,cat_id,goods_name,shop_priceFROM goods ORDER BY cat_id ASC,shop_price DESC;
    -- 2、取出价格最高的前三名商品
    -- limit offset,rowcount
    -- limit 偏移到哪个位置,往下数几个
    SELECT goods_id,cat_id,goods_name,shop_priceFROM goodsORDER BY shop_price DESC LIMIT 0,3;
    -- limit 3
    -- 3、取出点击量第三名到第五名的商品
    SELECT goods_id,cat_id,goods_name,click_countFROM goodsORDER BY click_count DESC LIMIT 2,3;
    

    • 范式：

    第一范式：原子性

    第二范式：唯一性(消除非主键依赖联合主键中的部分字段)

    第三范式：独立性，消除传递依赖(非主键值不依赖于另一个非主键值，都应该依赖于主键)

11. 异常：

    • ArrayIndexOutofBoundsException 数组下标越界异常

    • NullPointerException 空指针异常

    • StringIndexOutofBoundsException 字符串下标越界异常

    • ArithmeticException 算数异常

    • ClassCastException 类型转换异常

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TfWkxcZG-1660804798100)(C:\Users\xuezihan123\AppData\Roaming\Typora\typora-user-images\image-20220719091038345.png)]

    多重捕获块（多个catch）

    try {

    ​ 需要检测的代码(可能会抛出异常，也可能不会抛出异常)

    } catch (异常的类型1 异常类型的变量1) {

    ​ 捕获异常后处理异常

    } catch (异常的类型2 异常类型的变量2) {

    ​ 捕获异常后处理异常

    } catch (异常的类型3 异常类型的变量3) {

    ​ 捕获异常后处理异常

    } finally {

    ​ 一定会被执行的代码(不管异常抛不抛出都会执行，例如数据库释放连接)

    }

    自定义异常：

    1、所有的异常的都是Throwable的子类

    2、如果写一个运行时异常，需要继承RuntimeException

    3、如果要写一个编译时异常，继承Exception

    案例：模拟银行转账，可以实现存钱和取钱的功能取钱时候如果余额不够就抛出异常

    MeiQianException

12. JDBC：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OlP8GwZF-1660804798101)(C:\Users\xuezihan123\AppData\Roaming\Typora\typora-user-images\image-20220718160638014.png)]

13. JDBC开发步骤：😵

    1、加载驱动Class.forName(“”);

    2、获得连接对象Connection

    3、写sql语句

    4、创建Statement(一艘船)

    5、执行sql语句

    ​ (1) 更新类（更改了表里面数据）：delete/update/insert executeUpdate()

    ​ 返回值：int，表示你影响的行数

    ​ (2)查询（没有改变表里面数据）: select executeQuery()

    ​ 返回值：结果集ResultSet

    6、关闭连接

7月19日 前端

• HTML:超文本标记语言 定义页面结构

• CSS：层叠样式表 页面显示的样式

• BootStrapJS: JavaScript 界面交互(动态交互) JQuery

1. HTML:

   标题。

   段落。 图片。 链接。

   ---

   定义一条水平线。

   • 标签定义无序列表（·）这种标签可用在有序列表。
   • 标签可用在有序列表。(
     1. ) 和无序列表 (
        • ) 中。
          1. 有序表（1、2、3、）。
             是一个块级元素。 标签，可以有id class的属性。 输入框。 标签支持定义下划线。是文本斜体。 加粗文本。  表示一个空格。
             换行

              &lt ； less than <  &gt great than > &copy &copy; 
                  &lt; h1 &gt; 在HTML页面输出：<h1>
             

             table：

             th:table head

             tr:table row

             td:table data 单元格

             1. form表单：创建一个表

             2. Css:

                语法：选择器 { 属性名1:属性值1; 属性名2:属性值2; 属性名3:属性值3; 属性名4:属性值4;}

                **CSS使用：**1、通过选择器选择上标签2、在选择的标签上设置样式

                **选择器分类：**标签选择器： p{}类选择器： .className{}id选择器： #id{}

             一些常见的样式：

             color:red; 文字颜色 font-size:40px; background-color:blue;

             text-decoration:underline;//下划线 text-decoration:none; //去掉下划线

             1. CSS高级选择器：（直接看代码）前三个重要

                s1 s2 后代选择器

                s1,s2 并集选择器(选择器组)

                s1s2 交集选择器（既满足选择器1也满足选择器2）

                s1>s2 直接儿子选择器，和后代选择器不一样

                s1+s2 下一个兄弟选择器,后面紧挨着的第一个兄弟

   • 盒模型：

     盒子中主要的属性就5个：width、height、padding、border、margin。

     padding:内边距 margin：外边距

   • **border:**就是边框。

     边框有三个要素：粗细、线型、颜色。

     实线：solid 点：dotted 虚线： dashed

     颜色如果不写，默认是黑色。另外两个属性不写，显示不出来边框。

     border是一个大综合属性:border:1px solid red;

     border属性能够被拆开，有两大种拆开的方式：

     1） 按3要素:border-width、border-style、border-color

     2） 按方向：border-top、border-right、border-bottom、border-left

   • 什么是Bootstrap？ 简洁、直观、强悍的前端开发框架，让web开发更迅速、简单。

7月20号：JS

1. JS：解释型语言 JavaScript

   • 变量都用var；

   • console.log();用来输出值。

   • 使用网页端的F12查看

   • DOM：

     元素节点的获取：document.getElementById( id属性值);document.getElementsByTagName(“标签名”)；

   • 关系运算符：

     全等：===

     不全等：!==

     判断值是不是相等 ，还有类型是不是相等。

     ​

   • String和java一样使用：String常用的方法：

     1、大小写转换

     str.toLowerCase();

     str.toUpperCase();

     var str = “Hello jS!”;

     console.log(str.toLowerCase());//hello js!

     console.log(str.toUpperCase());//HELLO JS！

     2、获取指定字符：

     str.charAt(index)

     返回指定位置的字符index：字符位置

     console.log(str.charAt(6));//j

     3、查询指定字符串出现索引

     str.indexOf(findstr, [index]);

     str.indexOf(findstr);

     findstr:查找的字符串index:开始查找的位置索引，可以省略

     返回findstr在x中出现的首字符位置索引，如果没有找到则返回-1

     lastIndexOf:从后面找起
     4、split() 方法用于把一个字符串分割成字符串数组。

     x.split(separator,howmany)

     separator : 字符串或正则表达式，从该参数指定的地方分割 stringObject

     howmany:指定返回数组的最大长度，可以省略返回分割后的字符串数组

   • Boolean

     Java中条件表达式必须返回布尔类型

     JS中表达式可以是任意表达式.

     ​

     ​

     1不是0，就是非空值，表示true。

     在JS里面一切表示空的值都是false，非空的值都是true。

   • eval:

     console.log(eval(‘2+3’)); //5

     eval(‘var x=10;var y=20;console.log(x*y);’); //200

   • innerText 直接当成一个字符串展示

     innerHtml 将内容当成html来解析

   • 数组：

     push pop 输入输出数据

2. Servlet:

   • ​ 实现步骤：1、创建类继承HttpServlet 2、覆盖未实现的方法–service方法[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OqoiD1i9-1660804798102)(C:\Users\xuezihan123\AppData\Local\Temp\1146_0.png)]

   • JSP：

     Servlet的作用： 用java语言开发动态资源的技术！！！

     JSP的作用：用java语言（+html语言）开发动态资源的技术！！！

     JSP就是servlet！！！

     JSP的脚本:（脚本就是一段代码）

     语法：<%java代码 %>

     作用： 执行java代码

     JSP表达式:

     语法：<%=变量或表达式%>

     作用： 向浏览器输出变量的值或表达式计算的结果

7月21号（servlet连接jsp 可以页面显示了）

1. Servlet生命周期使用的方法：(面试会问)

   构造方法：创建servlet对象的时候被调用。默认情况下，第一次访问这个servlet的时候调用构造方法创建对象。

   构造方法只被调用一次，servlet对象在tomcat是单实例的。

   init方法：initial 创建完servlet对象时候调用。只调用1次。

   service：每次浏览器发出请求时候调用这个方法。调用n次。

   destroy：销毁servlet对象的时候调用。停止服务器或者重新部署web应用时候会销毁servlet对象。只调用1次。

2. 给超链接添加点击事件并触发：

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HsiGma1p-1660804798103)(C:\Users\xuezihan123\AppData\Local\Temp\1148_0.png)]

3. Servlet中的Get和Post对比：

   1. Get：

      1、采用URL请求路径传输参数。参数拼接在URL后面。

      2、参数传输过程中隐私性较差，直接在URL后面。

      3、路径可以容纳的数据有限，只能传递少量参数。

      4、所有请求默认就是get。

   2. POST：

      1、采用实体内容传参数。

      2、参数在传输过程中不可见，隐私性好。

      3、实体内容专门用来传输数据，大小没有限制。

      4、使用：在form上加method=“post”

   不管是Get方式还是POST方式传参数，后台代码获取参数的方式都是一样的。

   req.getParameter(“name”);

4. 乱码问题解决：去网上搜

5. 转发：(用于SelectAll的servlet)

   req.setAttribute(“list”, list);

   req.getRequestDispatcher(“student_list.jsp”).forward(req, resp);

6. 重定向：(操作完成后返回之前的页面)

   一般添加、删除、修改之后重定向到：查找所有

   resp.sendRedirect(req.getContextPath() + “/student?method=selectAll”);

   重定向的地址最终是由浏览器发送这个请求，浏览器只能定位到服务器上的tomcat，tomcat下面可能会有多个项目，无法确定是哪个项目，所以需要加上项目名。

   重定向：是服务器把这个请求地址告诉浏览器，然后浏览发送这个请求/JavaWeb/student?method=selectAll

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zVW6zHS5-1660804798104)(C:\Users\XUEZIH~1\AppData\Local\Temp\chrome_drag2028_12940\Image.png)]

7. 前台往后台发请求方式：

   1、form表单

   2、超链接

   <a href="/JavaWeb/student?method=delete&id=1">删除</a>
   

   3、location.href

   4、ajax！

8. 总结以下：

   1. 建表，明确属性；

   2. Mysql可以使用工具类JDBCUtil。（包含连接数据库的静态方法，异常抓取和关闭全部链接connection之类的）

   3. 创建pojo文件，写清私有属性（和数据库对应好），set get方法写全；

   4. 明确对数据的操作，具体是什么如何实现，创建servlet文件，对应操作写方法。

      • 先创建值为空的connection，statement

   5. 写出对应的jsp，传值取值要注意。

      跳转到一个JSP页面有两种方式：

      1、浏览器直接请求这个JSP页面，一般这个页面不需要数据（查询页面等不需要输入的页面）

      2、先访问Servlet，然后转发到这个JSP页面，访问Servlet可以可以查询数据，放到req中，转发到JSP页面展示（最常用的方法）

7月22日 分页

1. 使用到的SQL语句：select * from student LIMIT 0,5;(LIMIT offset, rows:分别表示偏移到哪个位置，rows表示往下数多少个数。)

   pageNo,pageSize 2,5 3,5

   *limit (pageNo-1)pageSize ,pageSize

   示例图：

2. 需要封装一个方法类PageInfo，作用是存储用到的数据，如：pageNo，pageSize，totalCount, totalPage

3. 测试main函数：

   public static void main(String[] args) {
       int totalCount = 12;
       int pageSize = 5;
       int totalPage = (int)Math.ceil((double)totalCount / pageSize);
       System.out.println(totalPage);// 2
   }
   

7月25日MVC 过滤器

1. Cookie、Session、ServletContext

   Session技术用到Cookie技术，SessionID是保存到浏览器的Cookie。

   request.setAttribute(“list”, list); requst的范围只在转发中有效。session.setAttribute(“list”, list); session的范围是当前这个用户的所有操作都有效。servletContext.setAttribute(“list”, list);servletContext的范围整个项目都有效。

   范围：ServletContext>Session>Request

   使用原则：小的范围能完成功能就放到小的里面。

2. 四个域对象： Request、ServletContext、Session、Page

   都可以通过setAttribute(“key”, value) getAttribute(“key”)存取数据

   区别就是范围不同

3. 过滤器filter与登陆：

   为什么要用过滤器？

   项目开发中，经常会用到重复代码的实现。

   1、请求每个servlet都要设置编码 2、判断用户是否登录，只有登录了才有操作权限。

   MVC

   Controller：完成接收的数据的封装（就是之前的servlet，不过少了数据库的那一部分）

   在此之前需要new一个service：

   private IStudentService studentService = new StudentServiceImpl();//类型是接口 new的是接口的实现
   

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5O3WgRPm-1660804798105)(C:\Users\xuezihan123\AppData\Roaming\Typora\typora-user-images\image-20220725170926717.png)]

   Service和ServiceImpl：实现业务逻辑(举例分页的实现)

   public interface IStudentService {
       List<Student> selectAll();
       void deleteById(Integer id);
       void add(Student student);
       Student selectById(Integer id);
       void update(Student student);
   }
   

   public class StudentServiceImpl implements IStudentService {
       private IStudentDao studentDao = new StudentDaoImpl();
   
       @Override
       public List<Student> selectAll() {
           return studentDao.selectAll();
       }
   
       @Override
       public void deleteById(Integer id) {
           studentDao.deleteById(id);
       }
   
       @Override
       public void add(Student student) {
           studentDao.add(student);
       }
   
       @Override
       public Student selectById(Integer id) {
           return studentDao.selectById(id);
       }
   
       @Override
       public void update(Student student) {
           studentDao.update(student);
       }
   }
   

   Dao和DaoImpl:最基本的增删改查

   public interface IStudentDao {
       List<Student> selectAll();
       void deleteById(Integer id);
       void add(Student student);
       Student selectById(Integer id);
       void update(Student student);
   }
   

    @Override
       public void add(Student student) {
           Connection connection = null;
           PreparedStatement statement = null;
           try {
               connection = JDBCUtil.getConnection();
               String sql = "insert into student(name,age,gender) values(?,?,?)";
               statement = connection.prepareStatement(sql);
               statement.setString(1, student.getName());
               statement.setInt(2, student.getAge());
               statement.setString(3, student.getGender());
               System.out.println(statement);
               int count = statement.executeUpdate();
               System.out.println(count);
           } catch (SQLException throwables) {
               throwables.printStackTrace();
           } finally {
               JDBCUtil.close(connection, statement, null);
           }
       }
   

7月26日 Day13 JQuery

1. JS DOM

   dom:用JS对html标签进行增删改查

2. JQuery

   toggle开关；若开则关，若关则开。

7月27号 Day14 Json Ajax

1. JSON 是一种数据格式
2. Ajax $.post({78});
3. Jackson包
4. Ajax异步更新典型案例：用户名已被占，城市选项三级联动，Echarts图表

7月28号 EL JSTL

1. EL:${“”, “”, []}
2. JSTL：可完成循环输出就不需要再写<%=%>，items begin end var

7月29日 layer

1. 登录页面：
2. layer弹窗：layer.js mylayer.js
3. 验证码：verifyUtil工具类
4. MD5加密：MD5工具类

8月1日 数据展示页面使用LayUI 和 登录页面

1. LayUI应用
2. 登录界面的实现

8月2号 反射 IO

IO流Input Output

1. 字节流的都有Stream这个单词

2. 字符流的都是Reader Writer

   Java序列化是指把Java对象转换为字节序列的过程；

   而Java反序列化是指把字节序列恢复为Java对象的过程。

   序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。

   反序列化就是打开字节流并重构对象。

反射reflect

8月3号 泛型 注解 多线程

1. 泛型<K,T>

   • 泛型类型必须是引用数据类型 即new ArrayList<>();

2. 注解@:Annotation

3. 进程:系统进行**资源（内存）**分配和调度的最小单位。

   线程Thread:线程进程的一个实体，是CPU调度和分派的基本单位。

   • 线程的方法：run() 、wait() 、join() 、sleep() 、start() 、yield()

     两种创建线程的方法：

     1、实现Runnable接口，重写Runnable接口中的run()方法

     2、从Java.lang.Thread类派生一个新的线程类，重写它的run()方法

4. 一共十二个属于Object类的方法：registerNatives()、getClass()、hashCode()、equals()、clone()、toString()、==notify()、==notifyAll()、wait(long)、wait(long,int)、wait()、finalize()

5. 多线程的编程步骤：（匿名内部类）

   1、第一步：创建资源类,在资源类创建属性和操作方法（在这类Panzi就是资源类）

   2、第二步：在资源类中操作方法 （Panzi里面有getCake()方法）

   ​ 1、判断

   ​ 2、业务代码（干活）

   ​ 3、通知

   3、第三步：创建多个线程，调用资源类的操作方法。

   (生产者线程和消费者线程生产了蛋糕放到盘子panzi.putCake(),吃蛋糕panzi.getCake())

//匿名内部类
Interface01 interface01 = new Interface01() {
        @Override
        public void show() {
            System.out.println("这里使用了匿名内部类");
        }
    };
//基本格式
new 接口/类名(参数1, 参数2...){
    实现方法1(){
        
    }
    实现方法2(){
        
    }
    ......
};

1. 同步:synchronized 异步:asynchronized

8月4号 线程池

1. Thread线程池:

   1. 四种线程池：Executors

      • newCachedThreadPool按需创建线程，可扩容，遇强则强
      • newSingleThreadExecutor一个任务一个任务执行，一池一线程
      • newFixedThreadPool(int)一池N线程
      • newScheduledThreadPool（）

   2. 创建线程池的七个参数：

      • corePoolSize核心线程数
      • maximumPoolSize最大线程数
      • keepAliveTime线程闲置时的超时时长
      • unit时间单位
      • workQueue任务队列（阻塞队列）
      • threadFactory线程工厂
      • handler拒绝策略
      • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SAkcROAp-1660804798106)(D:\思途笔记\笔记\图片存放\Image [2].png)]

   3. JDK拒绝策略：共四个

      第一个AbortPolicy:直接抛出异常阻止正常运行

      第三个DiscardOldestPolicy:抛弃队伍中等待最久的，然后把当前任务加入队列，尝试再次提交当前任务

      自定义线程池：ThreadPoolExecutor

2. JUC：java Util Concurrent（并发）

3. 乐观锁、悲观锁思想

4. Callable：

5. Runable：

6. Lock锁：

   Lock使用：// 1、创建锁

   private Lock lock = new ReentrantLock();

   // 2、加锁

   lock.lock();try { // 3、access the resource protected by the lock // 业务代码} finally { // 4、解锁 lock.unlock();}

7. 可重入锁：ReentrantLock

   • 公平锁：十分公平，可以先来后到 NonfairSync()
   • 非公平锁：十分不公平，可以插队 FairSync()

8. synchronized和lock（ReentrantLock）锁的区别

   1、synchronized内置的java关键字,Lock是一个java类

   2、synchronized无法判断获取锁的状态, Lock可以判断是否获取到了锁 boolean isLocked()

   3、synchronized会自动释放锁,Lock必须要手动释放锁!如果不是释放锁,会产生死锁

   4、synchronized 线程1(获得锁),线程2(等待); Lock锁就不一定会等待下去，lock.tryLock()可以尝试去获取锁，不会一直等待，等不到就结束。

   5、synchronized 和Lock锁都是 可重入锁,悲观锁，synchronized 非公平的锁，Lock默认是非公平锁，可以设置为公平锁， synchronized不可以中断(interrupt和stop都不可中断)。

   6、synchronized 适合锁少量的代码同步问题,Lock 适合锁大量的同步代码

9. 读写锁ReadWriteLock：

   ReadWriteLock 接口

   所有已知实现类： ReentrantReadWriteLock

   1、读：可多条线程同时获取数据

   2、写：只能单条线程写入
   独占锁（写锁） 一次只能被一个线程占用

   共享锁（读锁） 多个线程可以同时占用

   ReadWriteLock:

   读-读 可以共存

   读-写 不能共存

   写-写 不能共存

10. volatile：

    1 保证可见性 2 不保证原子性3 禁止指令重排

11. 理解CAS （比较并交换）

8月5号 两种设计模式

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

1. 单例模式：（单例：单个实例）Singleton

   单例模式保证只有一个实例，要保证外界不能随便的new这个对象，所以要私有化构造方法。

   私有化构造方法后就是把new这个对象控制权收回了，只能在类内部去实例化这个对象，让类自身负责保存他的唯一实例。

   1. 饿汉式 以空间换时间提前new

   2. 懒汉式 以时间换空间 将new放在方法里判断是否为空后再new

      • 懒汉式优化：双重检查机制 （使用了volatile,）先判断是否为空如果为空就加锁（synchronized）

   3. 举饿汉式 enum 能够防止反射、反序列化，破坏

   4. 内部饿汉式（最优）内部类必须是静态的 JVM保证了安全

      在类中再写一个类，但内部类在用到外部类时不会被加载

2. 简单工厂

3. 代理模式

4. 递归

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UNEbauT6-1660804798107)(D:\思途笔记\笔记\图片存放\Image [3].png)]

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r7a5peuL-1660804798107)(D:\思途笔记\笔记\图片存放\Image [4].png)]

   二分查找

8月8号 JVM obj:对象 Object：目的

1. 数据结构：查找 排序 二叉树遍历问题 链表插入删除

2. Collection 下的 List Set 的区别：

   List：有序的可重复 -> ArrayList LinkedList

   Set：无序的不可重复 -> HashSet TreeSet

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X6fNUZGP-1660804798108)(D:\思途笔记\笔记\图片存放\17200016-b868ad987c4947ceb76c42b44887c783.png)]

3. Map：

4. JVM（Java Virtual Machine即Java虚拟机）：

   ​ 类加载器ClassLoader作用：

   1. class file，可以理解为设计师画在纸上的模板，而最终这个模板在执行的时候是要加载到JVM当中来根据这个文件实例化出n个一模一样的实例。
   2. class file加载到JVM中，被称为DNA元数据模板，放在方法区。
   3. 在.class文件–>JVM–>最终成为元数据模板，此过程就要一个运输工具（类装载器Class Loader），扮演一个快递员的角色。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ha2qlhYz-1660804798109)(D:\思途笔记\笔记\图片存放\Image [5].png)]

   完整的流程图如下所示： 加载 --> 链接（验证 --> 准备 --> 解析） --> 初始化

   ​

5. 类加载器的双亲委派机制

   ​

   引导类加载器（Bootstrap ClassLoader:都为C、C++编写）、扩展类加载器（Extension ClassLoader）、应用类加载器（AppClassLoader）

7. 程序计数器

8. 垃圾回收机制🌠

9. 虚拟机的堆

   分为新生代+老年代+元空间

   新生代内有 伊甸园区、S0区、S1区。

8月11号 SpringMVC MyBatis

springMVC

注解

@Controller：扫描带有controller的类里的注释

@RequestMapping：value method

@Responsebody：返回JSON格式数据

@RequestParma（放在括号里用来给引用变量设定限制）：value required规定必须有值不能是null defaultvalue默认值

1. XML：springMVC.XML

2. 拦截器 interceptor（属于springMVC，在过滤器之后实现） 实现HandlerInterceptor接口，实现preHandle，postHandle方法。

Mybatis

mybatis.xml StudentMapper.xml(实现SQL语句，)

1. mybatis.xml是最重要的，是最基础的设置。

   	<settings>
   		<!-- 下划线字段对应实体类驼峰命名 数据库表：banji_id 映射到类里面：banjiId -->
   		<setting name="mapUnderscoreToCamelCase" value="true"/>
   	</settings>
   
   	<typeAliases>
   		<!--别名即为类名
           <typeAlias alias="Student" type="com.situ.mybatis.pojo.Student"/>
           <typeAlias alias="Banji" type="com.situ.mybatis.pojo.Banji"/> -->
   		<!-- 扫描包里面的类，批量起别名，别名即类名，不区分大小写 -->
   		<package name="com.situ.mybatis.pojo"/>
   	</typeAliases>
   <!--注意前两个的顺序-->
   	<environments default="development">
   		<environment id="development">
   			<!-- 使用JDBC的事物管理 -->
   			<transactionManager type="JDBC"/>
   			<!-- 配饰数据库连接池 -->
   			<dataSource type="POOLED">
   				<property name="driver" value="com.mysql.jdbc.Driver"/>
   				<property name="url" value="jdbc:mysql://localhost:3306/java2207?characterEncoding=UTF-8"/>
   				<property name="username" value="root"/>
   				<property name="password" value="5130550"/>
   			</dataSource>
   		</environment>
   	</environments>
   	
   	<!-- 加载映射文件 在映射文件中写SQL语句-->
   	<mappers>
   		<mapper resource="com/situ/mybatis/StudentMapper.xml"/>
   	</mappers>
   

   用来加载数据库，加载映射文件（里面有SQL语句）

2. 每一个pojo类都有对应的xml,如StudentMapper.xml，到使用springMVC时，代替dao包的实现层。里面的方法不能重名。

   < set >标签

   <?xml version="1.0" encoding="UTF-8"?>
   <!DOCTYPE mapper
           PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   
   <mapper namespace="student">
       <!--使用了SQL片段 将重复的SQL语句作成一个 其他的有需要的可以调用它-->
       <sql id="studentColumns">
           id,name,age,gender,banji_id
       </sql>
       
       <!-- 通过id查找学生 refid reference-->
       <select id="selectById2" parameterType="Integer" resultType="Student">
           SELECT
           <include refid="studentColumns"/>
           FROM student
           WHERE id=#{id}
       </select>
   
       <!-- 通过id查找学生 --><!--id parameter:输入的参数类型 resultType：返回的值类型 写完整的包名类名-->
       <select id="selectById" parameterType="Integer" resultType="com.situ.mybatis.pojo.Student">
           SELECT id, name, age, gender, banji_id
           FROM student
           WHERE id = #{id}
       </select>
   
       <select id="selectAll" resultType="Student">/*返回的是列表就只写list中的类型 即student*/
       SELECT id, name, age, gender, banji_id
       FROM student
       </select>
   
       <!--更新类不写返回值类型也可以得到影响的行数-->
       <delete id="deleteById" parameterType="Integer">
           DELETE
           FROM student
           WHERE id = #{id}
       </delete>
   
       <insert id="add" parameterType="Student">
           INSERT INTO student(name, age, gender, banji_id)
           VALUES (#{name}, #{age}, #{gender}, #{banjiId})/*注意这里要写大写的ID*/
       </insert>
   
       <update id="update" parameterType="Student">/*带着ID的student*/
       UPDATE
           `student`
       SET `name`=#{name},
           `age`=#{age},
           `gender`=#{gender},
           `banji_id`=#{banjiId}
       WHERE `id` = #{id}
       </update>
       
       <select id="selectTotalCount" resultType="Integer">
           SELECT count(*)
           FROM student
       </select>
       
       <select id="selectByPage" parameterType="Map" resultType="Student">
           SELECT
           <include refid="studentColumns"/>
           FROM `student` LIMIT #{offset},#{pageSize}
       </select>
   
   	
       <!-- resultMap最终是要将结果映射到Student上
       当实体类的属性名和表的字段名不一致的时候，必须要写这个映射 -->
       <resultMap id="studentMap" type="Student">
           <!-- 映射主键属性：如果有多个主键字段，则定义多个id -->
           <!-- property:类的属性名 -->
           <!-- column:表的字段名 -->
           <id  column="id" property="id"/>
           <!-- result定义普通属性 -->
           <result column="name" property="name" />
           <result column="age" property="age" />
           <result column="gender" property="gender" />
           <result column="banji_id" property="banjiId" />
       </resultMap>
   
       <!-- public Student selectById(Integer id) {}
           parameterType="java.lang.Integer"
           resultType="com.situ.mybatis.pojo.Student"
           public List<Student> selectAll();-->
       <select id="selectAll" resultMap="studentMap">
           select id, student_name, age, gender
           from student
       </select>
   
   
   </mapper>
   

8月12号 整合SpringMVC和MyBatis

整合SpringMVC和MyBatis：

SpringIOC：

将controller类名路径放在applicationContext.xml中，可以将其中的变量提前实例化（即实现new）

使用注解的方法！（一）

1. Controller Resource
2. Service Resource
3. Repository

（二）

1. Controller Autowired 如果有多个serviceImpl需要些这个（@Qualifier(value = “banjiServiceImpl2”)）
2. Service Autowired 不需要写名字
3. Repository 不需要写其他的

SpringAOP：

代理工厂proxyfactory

8月17号

PageHelper:

原理：执行查询的时候通过拦截器在sql语句中添加分页参数

Lombok:

在pojo包中的类里，添加@Data则可以自动生成getter、setter和tostring、有参无参构造函数

也可以单独实现则不用添加@Data，需要什么就写什么，如@Getter

AOP记录:

日志 Log4j---->Logback:

高级SQL:视图、索引、存储过程、触发器。（后两者不常使用）

数据库引擎区别:

事务:如转账

8月18号

事务的四个特性：

1. ACID

2. 原子性、一致性、隔离性、持久性

事务的并发：

1. 脏读

2. 不可重复读

3. 幻读

隔离级别：isolate

1. 读未提交

2. 读已提交

3. 可重复读

4. 串行化

二叉树：

遍历

B+树

平衡二叉树

自平衡二叉树

红黑树

数据库索引及优化:

y=“age” />

   <!-- public Student selectById(Integer id) {}
       parameterType="java.lang.Integer"
       resultType="com.situ.mybatis.pojo.Student"
       public List<Student> selectAll();-->
   <select id="selectAll" resultMap="studentMap">
       select id, student_name, age, gender
       from student
   </select>

```

8月12号 整合SpringMVC和MyBatis

整合SpringMVC和MyBatis：

SpringIOC：

将controller类名路径放在applicationContext.xml中，可以将其中的变量提前实例化（即实现new）

使用注解的方法！（一）

1. Controller Resource
2. Service Resource
3. Repository

（二）

1. Controller Autowired 如果有多个serviceImpl需要些这个（@Qualifier(value = “banjiServiceImpl2”)）
2. Service Autowired 不需要写名字
3. Repository 不需要写其他的

SpringAOP：

代理工厂proxyfactory

8月17号

PageHelper:

原理：执行查询的时候通过拦截器在sql语句中添加分页参数

Lombok:

在pojo包中的类里，添加@Data则可以自动生成getter、setter和tostring、有参无参构造函数

也可以单独实现则不用添加@Data，需要什么就写什么，如@Getter

AOP记录:

日志 Log4j---->Logback:

高级SQL:视图、索引、存储过程、触发器。（后两者不常使用）

数据库引擎区别:

事务:如转账

8月18号

事务的四个特性：

1. ACID

2. 原子性、一致性、隔离性、持久性

事务的并发：

1. 脏读

2. 不可重复读

3. 幻读

隔离级别：isolate

1. 读未提交

2. 读已提交

3. 可重复读

4. 串行化

二叉树：

遍历

B+树

平衡二叉树

自平衡二叉树

红黑树

数据库索引及优化: