基础基础知识

1、标识符即名字其规则：由字母，数字，下划线和$组成，不能以数字开头 ，不能用关键字

业内规定：

类：首字母大写，驼峰命名法

包：小写字母组成，域名倒置

变量/方法：首字母小写，驼峰命名法，需要语义化，见名知意

常量：全部大写字母，单词之间下划线隔开 要加个 final 修饰，不可改变

关键字：Java 官方用掉的名字

数据类型分为基本数据类型和复合数据类型或引用数据类型

2、一个字节（byte）=8 个位（bit） 数据库里面的单位是字节

MySql 里长度仅指定使用 MySql 命令行客户端选择数据时要显示多少字符

里面 int 永远是 4 字节也就是 32 位 TINYINT 是 1 字节

varchar 里的长度是字节也是最大字节，会自适应实际的长度

正常一个汉字占 2 个字节可能是 4，一个字母占 1 字节不分大小写

int 存储数值的范围是：-2 的 32 次方–2 的 32 次方减 1，（也就是-247483648 至 147483647 之间的所有正负整数），所以说 int 是不需要指定长度为多少的。

字节与位的区别：数据存储是以字节为单位，数据传输是大多是以位为单位

3、基本数据类型（四类八型):

整数类型: byte 8 short 16 int(默认) 32 long 64 数字是位数

浮点类型: float 32 double(默认) 64 单精度 双精度 float 范围比 long 大因为它是小数的

字符型: char 只有这用单引号，其他基本都是双引号

布尔型 Boolean: true false

4、随机数

1
2
3
4
Random random = new Random(); //new出这个对象
int r=random.nextInt(2);  //调用这个对象的方法 范围是0~1的整数
int rr=random.nextInt(90)+10;//范围是10-99的整数
random.nextInt(1000)-500;//范围-500~500,500取不到

5、区别

break 主要用于停止整个循环语句，循环语句后面的代码还会运行

continue 用于循环里面让程序跳过当前循环，立刻进入下一次的循环

return 用于返回方法类型指定的值也可以是对象，还能可以结束后面代码的执行

6、Scanner

1
2
Scanner sc=new Scanner(System.in);//new出这个对象
String s=sc.nextLine();//调用这个方法，从输入流获取你需要的输入

7、数据类型转换

短的变成，是自动转换；长的变短必须强转，会精度损失

浮点转整需要舍弃小数位

byte 到 double 从低到高

8、运算符

算数运算符+、关系运算符>=、逻辑运算符&、赋值运算符+=、三元运算符、

位运算符：操作二进制 & | >>

7 0111 7/2 =3 1 3/2=1 1 1/2= 1 7 的二进制结果倒着余数 111

9 1001 9/2=4 1 4/2=2 0 2/2=1 0 1/2= 1 结果倒着余数 1001

0001 7&9 结果 1 &必须 2 个是 1 才是 1

&&与 二真才真也叫短路逻辑运算符 ||或 一真则真

&&和&区别就是第一个要是假就不判断另一个，也就是短路了，直接就是假的

1
2
3
int a = 10;
int b = 20;
int max = a < b ? b : a;  //10<20所以将b的值给max否则a，就是三元运算符

9、复合数据类型有无数种，自带方法和属性，如 String、Scanner、Random 等

10、Java 基础运行流程，代码从上到下，从左往右，只运行一次

11、变量作用域：方法内声明的变量，方法外不可用。

12、区别

for 和 while 都被称为前置判断循环 do..while 是后置判断循环

while 和 do while 都属于不确定次数的循环语句

for 是属于确定次数的循环语句

13、数组的创建

1
2
3
dataType[] arrayRefVar = new dataType[arraySize];  //动态声明
dataType[] arrayRefVar = new dataType[ ]{value0, value1, ..., valuek};//用的少，使用1、3
dataType[] arrayRefVar = {value0, value1, ..., valuek}; //静态声明方式

14、for each 的使用

1
2
3
4
5
6
7
for（元素类型type  元素变量value  ：遍历对象obj）{
                                                 引用x的java语句
                                      }
比如一个数组 int arr[]={1,2,3,4,5};
for(int x:arr){  //这里x只是变量名
	System.out.println(x);//如果里面还有一个循环int y ：x
}

15、二维数组的遍历

1
2
3
4
5
6
7
8
9
10
11
String[] stu1 = {"张三", "Jx202211", "男", "22"};
String[] stu2 = {"李四", "Jx202212", "女", "21"};
String[] stu3 = {"王五", "Jx202213", "男", "25"};
String[] stu4 = {"小六", "Jx202214", "女", "20"};
String[][] stu = {stu1, stu2, stu3, stu4};
for (int i = 0; i < stu.length; i++) {
    for (int j = 0; j < stu[i].length; j++) {
        System.out.print(stu[i][j]+"\t");
    }
    System.out.println();
}

16、函数：一段具备特定功能的、高度封装的代码块

函数声明:

1
2
3
4
5
1、修饰符 public static  公开的 静态的
2、返回值类  void  表返回值为null
3、函数名    小驼峰命名
4、参数列表
5、方法体  要执行的代码块

函数的调用：函数名();即可，也可以传参

17、形参与实参

比如函数声明里就是形参，而调用那里输入则是实参

18、返回值，看声明里返回值类，void 则没有返回值，如 int 则返回整型 n，如果是类，返回一个对象类

19、函数的递归即函数里调用函数自己

20、对象：世界万物皆对象，对象的特点是属性、对象的行为是方法，对象的行为必须是自发的

21、对象 3 大特征，封装、继承、多态

封装：私有化属性并设置公有的 get、set 方法，get 有返回值，set 没有

1
2
3
4
5
6
7
private String name;
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}

22、修饰符的使用

1
2
3
4
5
6
7
//private：私有的 能且仅能在本类中使用

//protect：本类、子类、同一包的类可见

//default（无修饰）：本类、同一包的类可见

//public:公有的 所有类 所有地方都可以访问

23、面向对象与面向过程区别

面向过程：只关注事情本身的完成，不关注谁去做，就像大象塞进冰箱，不管是谁把冰箱打开，谁把大象弄进去

面向对象：更多关注 谁去做事情 各有各的好处

24、构造函数

是一个没有返回值，并且函数名和类型相同的函数，在对象实例化的一瞬间就会执行，利用构造函数的参数，对属性进行赋值。

25、函数/方法的重载：同一类中方法名相同，参数数量和类型不同，构造函数就可以用重载

26、static 方法

​ static 方法就是没有 this 的方法。在 static 方法内部不能调用非静态方法，反过来可以。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用 static 方法。这实际上正是 static 方法的主要用途。
​ static 关键字还有一个比较关键的作用就是用来形成静态代码块以优化程序性能。它的特性:只会在类加载的时候执行一次。

27、final 关键词

（1）final 修饰类中的属性或者变量
无论属性是基本类型还是引用类型，final 所起的作用都是变量里面存放的“值”不能变，这个值，对于基本类型来说，变量里面放的就是实实在在的值，而引用类型变量里面放的是个地址，所以用 final 修饰引用类型变量指的是它里面的地址不能变，并不是说这个地址所指向的对象或数组的内容不可以变，这个一定要注意。

final 修饰属性，声明变量时可以不赋值，而且一旦赋值就不能被修改了。对 final 属性可以在三个地方赋值：声明时、初始化块中、构造方法中。总之一定要赋值。

（2）final 修饰类中的方法
作用：可以被继承，但继承后不能被重写。

（3）final 修饰类
作用：类不可以被继承。
28、对象的生命周期

对象的出生：一旦被声明被赋值之后 对象即出现

对象的销毁：当该对象没有被指向 就会被自动销毁

String a；这是空，没有对象，所以没有出生和销毁

29、堆与栈

寄存器：最快的存储区，由编译器根据需求进行分配，我们在程序中无法控制

栈：存放基本类型的变量数据和对象打的引用，对象本身不存放在栈中，而存放在堆(new 出来的对象)或者常量池中(字符串常量存放在常量池中)

堆:存放所有 new 出来的对象

普通数据类型里的变量名放在栈里面，数据放堆里面

静态域(属于方法区):存放静态成员（static 定义的）

常量池(属于方法区):存放字符串常量和基本类型常量(public static final)

非 RAM 存储：硬盘等永久存储空间

30、继承与 super

继承就是子类继承父类的属性和方法 苹果是水果可以继承水果类 食草动物是动物可以继承动物类 必须满足 is-a 关系 父类更通用 子类更具体

关键字是 extends 写在类名后面

一个类只能继承 1 个 继承不可滥用，牵一发而动全身，父类改变一次，其他全部受到影响，即耦合性过高，现在继承通常用于我们写的类继承 Java 官方的类

继承关系下 父类和子类构造函数的运行

​ 首先父的构造函数先执行 然后子的构造函数后执行 main 方法里 new 的是子类，可以使用子类的构造函数的参数，父类想传参必须在子类里面加 super 再加需要传的值。因为没 new 父所以不能传参，必须靠子类

关键字 super ：放在代码里 用来子类给父类的构造函数的参数传参 ，找爹

31、多态

多态指同一个事物能呈现出多种形态的能力 多态是继承的一种体现

例子

比如创建狮子、老虎类，它们的方法都是吃和睡，方向需要传参那种类名和参数名小写，再创建饲养员类用来测试狮子和老虎类，正常需要创建 2 个 test 方法，传入老虎类和狮子类的类名和参数名小写，再创建 Main 类里弄 main 方法，new 狮子和老虎和饲养员对象，饲养员.test（这是 new 的狮子）再饲养员.test（new 的老虎对象），结果显示老虎和狮子吃睡 ！！！

多态的使用，需要再创建一个新的动物类，写入空的吃和睡的方法，啥参数都没，狮子类和老虎类去继承这个动物类。再去测试类那先将方法体注释，重新写一个方法，传入动物类的类名和参数名，直接调用动物的吃和睡方法。再去 main 运行结果一样。不过比前面更方便。这就是多态使用

32、重写

父类的方法，子类写的一模一样，最终执行的是子类的方法

重写规则：修饰符不能强于父类，返回值类型、方法名、参数列表必须一样

33、接口：没有方法体的方法的集合

新建接口 new Java class 里的 interface

好处 1：规定好整体项目的开发的规范

好处 2：规定项目骨架 方便内容填充

实现接口的要在类中 implements

实现接口的类 需要全部实现 接口中的方法

有方法体的方法 被称为 实例方法

没方法体的方法 被称为 抽象方法

一个类可以实现多个接口 ，继承不能多继承。

34、常量：声明之后 不能改变的量就是常量 名称全部大写 关键字 final 最终的意思

JavaSe 进阶

数据库

1、CRUD

（创建 Create、检索 Retrieve、更改 Update、删除 Delete）

1
2
3
4
查：select * from 表名 where 条件
删：delect from 表名 where 条件
改：update 表名 set 字段1=对应值1，..  where 条件
增：insert into 表名(字段1,字段2..) values(对应值1,对应值2...)

查和删不加条件，则全部查找、删除；

增也可以不加字段 1、…，直接 values 对应上值也行，而且也可以插入多条，直接 values 后面再逗号继续插入值

多表查的时候有共同的字段，需要声明一下是哪个表里面的

mysql 里运行不区分大小写，尽量都大写

– (默认升序 asc 数据条从上到下递增 降序 desc)

HAVING 是分组之后加的条件

2、六大范式

英文 Normal form

第一范式（1NF）、第二范式（2NF）、第三范式（3NF）、巴斯-科德范式（BCNF）、第四范式(4NF）和第五范式（5NF，又称完美范式）。满足最低要求的范式是第一范式（1NF）。在第一范式的基础上进一步满足更多规范要求的称为第二范式（2NF），其余范式以次类推。一般数据库只需满足第三范式(3NF）。

第一范式（1NF）：强调属性的原子性。即属性不可再分。

比如：学生表中

id 学生姓名 学生学号 学生人数 手机号 符合

id 学生姓名 学生（学生学号 学生人数） 手机号 不符合

再比如一个字段家庭地址，那肯定有省市区这些值，这些值也可以看出一张表，所以不满足，不允许表中还有表，一个字段只存储一项信息

第二范式（2NF）：第二范式就是在第一范式的基础上属性完全依赖于主键。也可以说是在第一范式的基础上，消除了非主属性对码的部分函数依赖。

比如：学生表中

1
2
3
4
5
学号 姓名  课程  班级 分数
1    小嗯  语文  1班  99
1    小嗯  数学  1班  98
2    小维  语文  2班  97
2    小维  科学  2班  100

可以看出(课程) → (分数)
(学号) → (姓名, 班级)

1.元组：表中的一行就是一个元组。

2.码:一个表中,可以唯一决定一个元组的属性”集合”。假设 k 为表中的某个属性,在 k 确定的情况下,这个表中的其他属性都可以确定,那么 k 就叫做候选码，也叫码。

(学号，课程)这个属性组就叫做码。

3.主属性:码里面的属性就是主属性。

4.部分函数依赖：比如上表中学号和课程组成主键已经不满足 2NF，那么你必须知道这 2 个的值才能知道后面列对应的值，就像 Z=X+Y 一样，你输入一个 X 不知道 Y 无法得到 Z，而 Z=X，Z=Y 就是部分函数依赖。而且这张表数据冗余，可以分成 2 张表

1
2
3
4
5
学号 课程 分数                  学号  姓名  班级
1    语文  99                   1    小嗯  1班
1    数学  98                   2    小维  2班
2    语文  97
2    科学  100

上面 2 张表属性都完全依赖于主键学号，这就是第二范式

第三范式（3NF）： 在 2NF 的基础上，消除了非主属性对于码的传递函数依赖。即，如果存在非主属性对于码的传递函数依赖,则不符合 3NF。

1
2
订单id  商品id  商品尺寸
1        1      22

可以看出主键订单 id，满足第二范式，商品 id 依赖订单 id，商品尺寸依赖商品 id，所以不满足第三范式，分成下面 2 张表即可满足

1
2
订单id  商品id            商品id   商品尺寸
1        1                 1        22

再比如有字段 学号 学生 系名称 系主任 ，可以看出系名称依赖学号，系主任依赖系名称，像上面拆成 2 表即可

Mybatis

SpringMVC

Spring

Spring 是轻量级企业应用开发框架 IoC 和 AOP 的容器框架 全能具备 MVC 三层功能，不替换任何框架是来整合 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
@Component  配合  类似于给需要注解这个的类new了一下，可以给('变量名')默认小驼峰，比如给LuckyA类添加了这个注解
<!--    使用扫描包扫描@-->
<context:component-scan base-package="com.nwa.aop"/>
<property name="target" ref="luckyA"/> 这里就对应上

@Controller:收发功能  @Component+        都是有实例

@Service   @Component+

@interface  public @interface A 形式  没有@的时候是接口，有@时候只能裸这种形式，自动继承了java.lang.annotation.Annotation接口，这是自定义了一个注解A

@Target 说明了Annotation所修饰的对象范围  取值(ElementType)有：CONSTRUCTOR:用于描述构造器；FIELD:用于描述域；LOCAL_VARIABLE:用于描述局部变量；METHOD:用于描述方法；PACKAGE:用于描述包；6.PARAMETER:用于描述参数；7.TYPE:用于描述类、接口(包括注解类型) 或enum声明

@Documented修饰的比如上面的注解A  生成文档时，会显示@A  生成文档指的JavaDoc文档！

@Retention(RetentionPolicy.RUNTIME)注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在；
生命周期长度 SOURCE < CLASS < RUNTIME

@Aspect – 标识为一个切面供容器读取，作用于类

@Pointcut – (切入点):就是带有通知的连接点

@Before – 前置

@AfterThrowing – 异常抛出

@After – 后置

@AfterReturning – 后置增强，执行顺序在@After之后

@Around – 环绕

AOP 思想

AOP 的使用场景
异常、安全、日志、权限、事物
位置：前置、后置、环绕、异常、最终

/**
 * 这里我们使用注解的形式
 * 当然，我们也可以通过切点表达式直接指定需要拦截的package,需要拦截的class 以及 method
 * 切点表达式:   execution(...)
 *
 * execution(public * *(..)) 任意的公共方法
 * execution（* set*（..）） 以set开头的所有的方法
 * execution（* com.LoggerApply.*（..））com.LoggerApply这个类里的所有的方法
 * execution（* com.annotation.*.*（..））com.annotation包下的所有的类的所有的方法
 * execution（* com.annotation..*.*（..））com.annotation包及子包下所有的类的所有的方法
 * execution(* com.annotation..*.*(String,?,Long)) com.annotation包及子包下所有的类的有三个参数，第一个参数为String类型，第二个参数为任意类型，第三个参数为Long类型的方法
 * execution(@annotation(com.lingyejun.annotation.Lingyejun))
 */

SpringBoot

1