给自己定一个小目标，先会100道面试

一、你的项目是干什么的 ？（ 什么ERP ？）

ERP 是企业资源管理系统，是企业的物料、人力、业务、财务等信息集成一体化的管理软件。（供应链的流程，就是公司需要什么物料、物料的采购、能制造出什么成品等方面管理软件）。

二、你用的框架是什么，SSM 是什么 ？

SSM=Spring + Springmvc + MyBatis

三、SpringBoot 和 SpringMVC 的区别？

Spring 开始使用的 Aop（代理模式） 和 DI（工厂模式）模式解耦的组件，因为大家都觉得好用，就搞了一个 Springmvc 的框架，但是 Spring 家族的成员的每一个技术都需要一个一个搞配置特别麻烦，影响开发的进度所以 springboot 就出来了解决这个问题，大大减少了配置。

四、Springboot 常用的注解有哪些 ？

Controller 层：@RestController @Controller @RequestMapping @Api @Autowired @ApiOperation @RequestBody @RequestAttribute 

Service 层 ：@Autowired @Service

五、SpringMVC 是什么 ？

前端控制器：1、不用我们写。

                  2、接受 view 层的数据传递给后端控制器。

后端控制器：1、就是 controller

                  2、对前端控制器传来的数据进行逻辑处理发送给 model 层。

                  3、接受 model 层返回的数据进行逻辑处理返回给 view 层。

六、什么是 IOC 什么是 DI  ？

 A 类需要 B 类的方法:

 正常的方法：是在 A 类中创建 B 类的实例使用 b 的实例调用 b 的方法。

 控制反转：就是 A 不用主动创建 B 类，而是被动的等待 IOC / DI 容器获取 B 的方法注入到 A 方法里面。

七、什么是反射 ？

反射就是把 java 类里面的各个成分映射成一个个的 java 的对象（一个 java 的属性、方法、构造方法每一个都可以变成一个对象。）

八、一体化好好的，为什么要写前后分离？

1.前端可以不用了解后端技术，也不关心后端具体用什么技术来实现，只需要会 HTML/CSS/JavaScript ，而后端只需要关心后端开发技术，省去学习前端技术的麻烦,  可以更专注后端的技术，提升工作效率。

2.随着移动端的崛起 ios , android , web  等不同的前端页面，如果不前后分离那么需要写三遍后端的代码，为了节约开发成本提高工作效率，可以让不同的前段页面调用同一套后台的逻辑。

九、Restful协议 是什么？

restful是一种架构风格，建立API时要遵守的一种规则，rest 就是选择 http 协议和 url 通过 client / server model（c s 模式）对资源进行（put delete post get）增删改查的操作。

十、抽象类和接口的区别什么？

1、接口里面的没有方法体，抽象类的方法可以写方法体。

2、接口的属性都是public static final 公共静态的常量 。

3、接口多实现，类单继承。

十一、String,StringBuffer与StringBuilder的区别??

1、String 字符串常量

2、StringBuffer 字符串变量（线程安全）（可变字符串）

3、StringBuilder 字符串变量（线程不安全）

十二、什么是冗余字段？

数据库中相关联的表存在重复的信息就是冗余字段

优点：适合多表联查时，但是有效的信息比较少，使用冗余字段，只查询一个表，提升效率。

缺点：1、占用的空间比较大。

         2、当修改表的信息时难度比较大，需要改动多个表。

         3插入同上。

十三、为什么数据库要加索引

1、提要检索的效率。

2、#primary 主键的索引 key 普通的索引 unique 唯一索引。

3、缺点占用内存（添加的索引的原理是往内存中写，拖慢写入的速度）。

4、优点：10-100 倍的提升检索的效率。

十四、什么是 opp、oop、aop？

opp 面向过程的编程 ：把所有解决方法的函数都写出来，使用时调用即可。

oop 面向对象的编程：创建问题中需要的类，里面添加方法和属性，调用时必须要添加主语谁的属性，谁的方法。

aop 面向切面的编程：把问题一个分成不同的层面，解决问题时，动态的将需要的代码写入到指定的类的方法和指定的位置。

十五、equals 和 hashocde ，== 的区别？

== 

1、当 java 的基础数据类型之间用==时 比较的是他们的数值。

2、当 java 的引用类型类型用的时候比较的事他们的地址，看他们是不是同一个 new 出来的对象。

equals

1、默认的情况下 object 类里面的 equals 比较的就是地址和 == 是等价的。

2、当 equals 的方法在子类中重写一就是通过对象的内容时候相等来比较的

hashcode 

1.hashcode 是什么？ 在 java 虚拟机中每 new 出来一个对象就会自动的出现的一个 hashcode 。

“如果两个对象相同，那么他们的hashcode应该相等

“如果两个对象不相同，他们的hashcode可能相同

十六、堆和栈

1、栈里面存储的是局部变量，而堆里面存储的事实体。

2、栈内存的更新速度快于堆的更新速度，因为局部变量声明周期很短。

3、栈内存的声明周期当方法结束时就会被释放，而堆中定义的实体会被垃圾回收机制不定时的清理。

4、先给 变量在栈分配空间 ->给 new 的对象在堆中分配空间并初始化->走构造函数格外赋值->给变量和 new 对象关联

十七、JVM

JVM 就是 java 的虚拟机。-未完待续

十八、list 的区别

1、arrayList 和 vector 都是已数组的形式存储的 ，都是插入相对比较慢，查询的比较快的，查询只需要提供所查询的下标即可。

2、arrayList 和 vector 相比较 vector 的会添加 synchronized 线程安全。

3、linkedList 是双向链表的结构存储的 插入比较快，插入时只需要记住插入的前一项和后一项即可 ，查询相对比较慢查询需要查询所有的元素。

十九、hashMap 和 hashTable 和 ConcurrentHashMap

1、提到 hashMap 就得提到 hashTable , HashMap几乎可以等价于Hashtable，除了HashMap是非synchronized的，并可以接受null(HashMap可以接受为null的键值(key)和值(value)，而Hashtable则不行)。

2、提到Hashtable就得提到ConcurrentHashMap，他们都可以用于多线程的环境里，但是当hashtable 的大小达到一定量时迭代器被锁定时间会很长而 ConcurrentHashMap添加了segmentation分割后仅仅需要锁定map 的部分其他线程不需要等迭代器全部加载完才可以访问 map ，简单的说就是 hashtable 锁定的事整个 map 而 concurrentHashMap 锁定的知识 map 的某个部分

二十、什么叫线程共享数据，线程安全问题

就是同步代码块和同步方法中的数据（ synchronized 修饰的）

什么是线程安全?为什么会出现线程安全的问题

线程安全就是多线程的情况下数据保持一致性

出现非线程安全的原因是存在多个的线程对象共享同一资源 ，多线程操作共享的代码段有多个语句

解决非线程安全的方法有同步代码块 和同步函数（使用synchronized修饰的方法）推荐使用的是同步代码块也就是类似分割的意思就是同步函数锁的是整个函数而同步代码块锁的知识方法的一部分。

一致性 无论是单线程操作还是多线程操作结果是一致的

独立性 多线程之间互不影响

二十一、静态变量和实例变量的区别

静态变量属于类所有不需要创建实例对象就会被分配空间，已经可以使用了。

实例变量是某个对象的属性只有实例化对象后才会被分配空间，才可以被使用

静态变量共同类所有，值改变后，在之后的实例对象中也改变！！！！

实例变量属于当前对象所有

二十二、以2014年中国内地幸存的22位“慰安妇”的遭遇作为大背景，以个别老人和长期关爱她们的个体人员的口述，串联展现出她们的生活现状。全片无解说、无历史画面，音乐仅片尾响起，旨在尽量客观记

二十三、final、finally、finalize 区别是什么?

1、final 修饰的类是不可以被继承的（比如String StringBuffer StringBuilder math）所有的方法都不可以被重写（abstract 修饰的类是抽象类正好与 final 修饰的类相反）fianl修饰的方法子类可以被继承但是不可以被重写，final 修饰的属性是变量是不可变的。

2、finally 是try 和 catch 配合使用保证无论发不发生异常都会运行 finally 一般都是（资源释放关闭 io 流什么的）。

3、finalize 是 object 的一个方法子类可以重写finalze（）方法实现对资源的回收。垃圾回收只负责回收内存不负责回收资源，资源回收要程序猿完成。java 虚拟机在垃圾回收前会先调用垃圾对象的 finalize 方法用于释放资源（关闭连接，关闭文件）之后才进行垃圾回收这个方法不会显示调用，一般会在垃圾回收的时候自动调用。

二十四、java每个版本都添加了什么?（不用答的特别全显得比较刻意挑会的答 别你说有枚举。人问你枚举是什么能干什么答不上来就尴尬了）

1.5、自动装箱拆箱

         枚举（用来设计单例模式）

         静态导入

         可变参数

          内省

1.6、Web服务元数据

         脚本语言支持

         JTable的排序和过滤

        更简单,更强大的JAX-WS

        轻量级Http Server

        嵌入式数据库 Derby

1.7、switch中可以使用字串了

        运用List<String> tempList = new ArrayList<>(); 即泛型实例化类型自动推断

        语法上支持集合，而不一定是数组

        新增一些取环境信息的工具方法

        Boolean类型反转，空指针安全,参与位运算

        两个char间的equals 

        安全的加减乘除 

        map集合支持并发请求，且可以写成 Map map = {name:"xxx",age:18};

        注解

1.8、允许在接口中有默认方法实现

        Lambda表达式

        函数式接口

        方法和构造函数引用

        Lambda的范围

        内置函数式接口

        Streams

        Parallel Stream

        Map

        时间日期API

        Annotations
1.9、Jigsaw 项目;模块化源码

        简化进程API 

        轻量级 JSON API 

        钱和货币的API 

        改善锁争用机制

        代码分段缓存

        智能Java编译, 第二阶段

        HTTP 2.0客户端

        Kulla计划: Java的REPL实现

二十五、JavaSE JavaEE JavaME

1、Java SE 是做电脑上运行的软件。

2、Java EE 是用来做网站的-（我们常见的JSP技术）

3、Java ME 是做手机软件的。

二十六、map遍历怎么写?

1、entrySet 遍历 

Map<String,String> map=new HashMap<String, String>();

Iterator<Map.Entry<String,String>> iterator=map.entrySet().iterator();

if (iterator.hasNext()){ 

    Map.Entry<String,String> entry=iterator.next();  

   String key=entry.getKey();

String value=entry.getValue();  

}

2、keySet 遍历

Map<String,String> map=new HashMap<String, String>();

Iterator<String> iterator=map.keySet().iterator();

if (iterator.hasNext()){ 

    String key=iterator.next();  

String value=map.get(key);  

}

二十七、枚举类是什么？有什么特点？

1、枚举类和正常的类一样也有构造方法、成员变量、普通方法和抽象方法 什么的。

2、默认私有的构造方法，即使不写访问权限也是 private。

3、每个实例都用一个全局常量表示，枚举类型的对象是固定的，实例个数有限，不能使用new关键字。

4、枚举实例必须位于枚举中最开始部分的，枚举实例列表的后面要有分号与其他成员相分隔 。

5、枚举实例后有花括号时，该实例是枚举的匿名内部类对象。

实际应用 可以写在switch里增强可读性、设置错误码+错误信息、常量

二十八、多态的好处是什么？ 

派生类的功能可以被基类调用，后向引用，提高拓展性和维护性

大概就是客户想用一个 list 然后就参数都是 list 后来需求改了要 set 参数都改成 set 直接写 collection 改动就小了许多。

二十九、继承的优缺点？是否可以多继承？

1、实现简化了 不用写冗余的属性和方法 。提高了拓展性和复用性

2、如果父类添加属性和方法，这样降低了子类的独立性，父类的隐私问题。

3、java 单继承的 好处是如果多继承的话多个父类的属性名相同的话不知道继承的是哪一个父类的属性。

三十、java的封装和访问控制是什么意思，如何实现对象的关联（听上去高大上和贾跃亭的生态化反有点类似）

1、防止该类的代码和数据被外部类定义的代码随机访问 隐藏实现功能的细节。

2、就访问的权限 public protected default private

3、就是在 A 类中的属性有 B 类

三十一、math 常用的方法

1、Math.sqrt() 平方根

2、Math.cbrt() 立方根

3、Math.pow(a,b)计算 a 的 b 次方

4、Math.random() 随机数

5、Math.max() 最大

6、Math.min() 最小

三十二、重写equals需要注意什么

两个对象重写 equals 方法，其相等条件是属性相等就是 false 如果不重写

三十三、拆箱装箱是什么，如何实现简单的拆箱装箱，程序例子

装箱:就是把基础数据类型转化为它们相应的引用类型包装起来使其具有对象的性质。int->integer 

拆箱：和装箱相反，将引用类型的对象简化为基础数据类型

Integer I = 10 //装箱

int a =new Integer(10)//拆箱

三十四、对象中的属性比较，排序。eg. userList 按照user中的 age大小排序如果相同再根据 name 比较

让 user 类实现comparable重写 compareTo方法 

public int compareTo(Object o) {
    Student student=(Student)o;
    int num = this.getAge()- student.getAge();
    return num==0 ? this.getName().compareTo(student.getName()):num ;
}

三十五、冒泡，选择，快排，递归调用是什么

冒泡排序

for (int i=0;i<array.length-1;i++)
{
    for (int j=0;j<array.length-i-1;j++)
    {
        if (array[j]>array[j+1])
        {
            int max=array[j];
            array[j]=array[j+1];
            array[j+1]=max;
        }
    }
}

选择排序

for (int i=0 ;i<array.length-1;i++)
{
    for (int j=i+1;j<array.length;j++)
    {
        if (array[i]>array[j])
        {
            int c = array[i];

            array[i] = array[j];

            array[j] = c;

        }
    }

}

快速排序

public static void quickSort(int array[], int low, int high) {// 传入low=0，high=array.length-1;
    int pivot, p_pos, i, t;// pivot->位索引;p_pos->轴值。
    
    if (low < high) {
        p_pos = low;
        pivot = array[p_pos];
        for (i = low + 1; i <= high; i++)
            if (array[i] > pivot) {
                p_pos++;
                t = array[p_pos];
                array[p_pos] = array[i];
                array[i] = t;
            }
        t = array[low];
        array[low] = array[p_pos];
        array[p_pos] = t;
        // 分而治之
        quickSort(array, low, p_pos - 1);// 排序左半部分
        quickSort(array, p_pos + 1, high);// 排序右半部分
    }
}

递归调用

自己调用自己（应用场景复制文件夹下的所有文件，求1-100的和）

public static void add(int max,int sum)
{
    sum+=max;
    if (max==0)
    {
        System.out.println(sum);
    }
    else
    {
       add(max-1,sum);
    }
}

三十六、 无序线性查找，和二分查找什么意思。

三十七、所有异常的父类是 throwable

三十八、JAVA语言如何进行异常处理：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？

1、throws 获取异常 throws表示出现异常的一种可能性并不一定会发生这些异常。

2、throw 抛出异常 throw则是抛出了异常，执行throw则一定抛出了某种异常。

3、try 将可能发生异常的语句括起来从而进行异常处理

4、catch 如果异常的执行 catch 当中的语句

5、finally不论是否有异常都会进行执行的语句。

6、可以在try块中可以抛出异常但是在 try 里面 throw 出异常多此一举 

三十九、创建线程的两种做法是什么，优点各是什么

1、创建自定义类继承 Thread 类  重写 run 方法

代码简洁    

2、自定义类实现 runnable 接口

可以避免 java 单继承带来的局限性 

适合多个相同程序的线程去处理统一资源的情况保持数据一致性

四十、线程的同步、如何实现线程的同步

线程同步就是多线程保持共享数据的一致性

添加 Synchronized volatile atomic wait join sleep yield 等修饰符

四十一、sleep() 和 wait() 有什么区别? Join和sleep有什么区别 ？

1、sleep 和 wait 相同点1）都可以使线程进入阻塞

2) 唤醒方式 计时阻塞时间到即醒来 

2、sleep 和 wait不同点

1）因sleep方法进入阻塞的线程，不会释放自己持有的锁，而wait方法进入阻塞的线程，会释放自己持有的锁

2）sleep方法是Thread类提供的静态方法，而wait方法是Object提供的实例方法 

3）调用wait方法必须是在同步代码块之中，否则会报异常

3、join  和 sleep相同点 

1) 都可以使线程进入阻塞

2) 唤醒方式 计时阻塞时间到即醒来 被其他线程调用当前线程对象的interrupt方法 

4、join  和 sleep不同点 

1）sleep ( ) 是静态方法 join 是实例方法。

2）调用t1.join方法可以使当前线程进入阻塞状态，当t1线程运行结束时立即唤醒当前线程。

5、yield （谦让）

1) 它仅能使一个线程从运行状态转到可运行状态，而不是等待或阻塞状

2) Yield告诉当前正在执行的线程把运行机会交给线程池中拥有相同优先级的线程。

4) Yield不能保证使得当前正在运行的线程迅速转换到可运行的状态

四十二、volatile（单词）是什么意思，有什么作用，volatile是jdk几加入的 和Atomic的区别是什么?

volatile（不稳定的）

volatile 变量可以被看作是一种 “程度较轻的 synchronized”；对于一写多读的情况下可以解决同步的问题，但是多写的情况下无

法解决线程安全的问题。

atomic （原子的）

atomic  对于多线程写入的情况可以解决同步的问题

四十三、多态的问题 类似于 Person person = new Student() 

父类的调用不了子类的方法和属性的问题

开始在栈空间中创建了 person 有在空间里new Student() 然后相互关联了一波，对象 person 是 Person 类型的 Student 的需要向上转型需要把 Student 类型的转化成 person 类型的 ，person 没有的属性和方法不可调用 ，student 重写 person 的方法调用 Student 里面

四十四、http 的构成，请求的方式有那几种

http 协议有3部分构成的请求的方法，请求体（requeat content）、请求头（request header）。

请求的方式、url 和 http 的协议的版本 请求方式有多种主要是 get post put delete 四种。

请求头（request header）：主要包含客户端的环境和正文的有用信息 请求头可以声明浏览器的类型用的语言请求正文的类型正文的长度。

请求体（request content）: 主要是用户 post 方式请求提交的表单数据，根据 http协议请求头和请求体之间有空行 很关键表示头和体的分割。

四十五、servlet 的生命周期

1、 客户端向web 服务器发起请求 

2、web 服务器将该请求转发给 servlet 容器

3、servlet 容器 把请求转发给 servlet 调用 init（）初始化

4、servlet 调用 service（）方法处理请求 产生输入发送给容器

5、servlet 方法 destroy（）方法终止

6、servlet 容器将输出转为 http 响应 发送为 web服务器

7、web 服务器将 htttp 响应转发给客户端

8、浏览器显示响应页面

四十六、get 和 post 的区别

post 比较 get 相对安全 post 的请求数据都方法在请求体里 而 get 的数据在 url 中所有人都可见

post 相比 get  没有数据的长度限制 get 最大只有2048个字节

post 点击 回退和刷新 数据会被重新提交  get 是无害的

四十七、servlet九大内置对象和四大作用域是什么

1、request                    请求对象                    ServletRequest                Request

2、response                  响应对象                    ServletResponse             Page

3、session                    会话对象                    HttpSession                    Session

4、application              应用程序对象            ServletContext               Application

5、out                           输出对象                    JspWriter                        Page

6、pagecontext            上下文对象                 PageContext                   Page

7、page                        页面对象                    Object                             Page

8、config                      配置对象                    ServletConfig                 Page

9、exception                异常对象                     Throwable                     Page

四十八、preparedStatement 和statement的区别是什么，哪种更好，为什么

四十九、事务特征是什么，jdbc事务处理的步骤（理解）

1、原子性 共同进退

2、隔离性 相互独立

3、持久性 永久生效

4、一致性 数据变化一致

1）jdbc对事务的管理交由 Connection 对象实现

2）首先关闭提交，开启事务：connection.setAutoCommit(false);//false 表示关闭自动提交

3）然后就是事务中包含 sql 的语句

4）提交事务 connection.commit();// 显式提交

5）回滚：如果在事务执行的过程中出错用（try catch 捕捉）则在错误处理语句中显示回滚 connection.rollback()

6) 中间点：一般事务的回滚到事务开始之前，但是也可以只回滚到事务中间的某个中间点。

设置中间点

1、Savepoint Connection.setSavepoint();  // 在事务的某个位置设置一个中间点，该中间点没有命名，使用系统默认的命名

2、Savepoint setSavepoint(String name);  // 给中间点命名

3、回滚到指定的中间点：connection.rollback(Savepoint savepoint);  // 回滚到指定的中间

五十、事物并发相关知识点：1. 脏读，2. 不可重复读，3. 幻读--> 事物隔离级别

1、脏读 dirty read :事务1更新了记录，但是没有提交，事务2读取了更新后的行然后事务1回滚了 ，事务2的就做了一次脏读

比如：张三的工资为50,事务A中把他的工资改为80,但事务A尚未提交。事务B正在读取张三的工资，读取到张三的工资为80。事务A发生异常，而回滚了事务。张三的工资又回滚为50。事务B读取到的张三工资为80的数据即为脏数据，事务B做了一次脏读。

2、不可重复读 unrepeatable read :事务1读取记录时，事务2更新可并提交 事务1再次读取时看到事务2修改后的记录，一次事务2两次前后读取结果不一致导致了不可重复读。

在事务A中，读取到张三的工资为50，操作没有完成，事务还没提交。事务B把张三的工资改为80，并提交了事务。在事务A中，再次读取张三的工资，此时工资变为80。在一个事务中前后两次读取的结果并不致，导致了不可重复读

3、幻读 phantom read : 事务1读取记录时事务2添加记录 biang 提交 ，事务1再次读取时可以看到事务新增的记录。

目前工资为5000的员工有10人，事务A读取所有工资为5000的人数为10人。这是，事务A再次读取工资为5000的员工，记录为11人。此时产生了幻读。

4、事务的隔离级别

1）READ UNCOMMITTED：幻读，不可重复读和脏读均允许；

2）READ COMMITTED：允许幻读和不可重复读，但不允许脏读；

3）REPEATABLE READ：允许幻读，但不允许不可重复读和脏读；

4）SERIALIZABLE:幻读，不可重复读和脏读都不允许； 

5）ORACLE默认的是 READ COMMITTED。

五十一、空格 大于号 小于号 的实体名称是什么？

五十二、换行标签，超链接标签，下划线标签，有序列表，无序列表 分别是什么？

br 换行

a 跳转 

text-decoration:none 去下划线

u下划线

ol li 有序列表

ul li 无序列表  

五十三、Img 的alt 属性有什么作用 如果页面没加载出来时会显示 alt 里面的文字 

五十四、<Th>标题行   <tr>行    <td>列 文本域标签<textarea>

五十五、表单提交 get 方式 参数位置

五十八、Css 的引入方式

1、行间样式表

2、内联样式表

3、外部样式表

 <!--链接式:推荐使用-->
  <link rel="stylesheet" type="text/css" href="css/style.css" /> 
  <!--导入式-->
  <style type="text/css">
    @import url("css/style.css");
  </style>

五十九、盒子模型由什么组成

margin+border+padding+content=box

六十、影响元素总大小的因素有哪些

六十一、写出css语句 上外边距10 下外边距20 左外边距 30 右外边距40 的语句

margin :10 30 20 40;

六十二、Div table span p a 这些标签哪些是行级标签，哪些是块级标签

行标签 span a b strong

块标签 div p table h1-h6

六十三、hidden、auto、visible、scroll 的区别

1、hidden 当 将超出对象尺寸的内容进行裁剪，将不出现滚动条。

2、visible： 不剪切内容。

3、scroll： 将超出对象尺寸的内容进行裁剪，并以滚动条的方式显示超出的内容。

4、auto： 在需要时剪切内容并添加滚动条，此为body对象和textarea的默认值

六十四、z-index作用

默认的情况下当页面的元素重叠以后，后出现的元素在上面 ，当用户有特殊需求的情况下可以通过增加前一个元素的 z-index 使前一个元素在上面。

六十五、position：absolute  position：relative  position：fixed 

1、absolute 绝对 相对于父级的位置比较

2、relative 相对  定位是和原来的位置比较

3、fixed  固定 是和浏览器的位置比较

六十六、sql查询语句的执行顺序六十七、DDL，DML，DCL 语句

1、DDL  数据库定义语言 create alert drop 对数据库 或者表 操作的

2、DML 数据库操纵语言 select update insert delete  对数据库 操作 改变表间关系、表结构和数据类型

3、DCL 数据库控制语言 设置或更改数据库用户或角色权限的语句，包括（grant,deny,revoke等）语句

六十八、高精度数据类型（单词），时间戳

六十九、外连接，内连接，交叉连接，自连接是什么

1、外连接 

1）左连接 left join

2）右连接 right join

3）全连接 full join

2、内连接

1）等值连接：在连接条件中使用等于号(=)运算符比较被连接列的列值，其查询结果中列出被连接表中的所有列，包括其中的重复列。

2）不等值连接：在连接条件使用除等于运算符以外的其它比较运算符比较被连接的列的列值。这些运算符包括>、>=、<=、<、!>、!<和<>。

3）自然连接：在连接条件中使用等于(=)运算符比较被连接列的列值，但它使用选择列表指出查询结果集合中所包括的列，并删除连接表中的重复列。

3、交叉连接 返回左表中的所有行，左表中的每一行与右表中的所有行组合。交叉联接也称作笛卡尔积。

4、自连接 就是自己连自己 把自己看成两个表遇到需要表内的数据比较的时候会用到

七十、索引的优缺点 常用索引有哪些，unique和primary key区别

1、优点：10-100的提高了查询效率

2、缺点：占用资源（添加索引相当于往内存里面添加占用资源）

3、常用索引

1）key 主要普通索引

2）unique 主要是唯一约束

3）primary key 主键约束

4、unique和primary key区别 

1）unique 可以有多个 primary key只有一个

2）unique 可以有一个为空 primary key 不可以为空

七十一、 实现索引的数据结构有哪些，优缺点有哪些（理解，选作）

七十二、in和exist的区别

1、IN适合于外表大而内表小的情况；EXISTS适合于外表小而内表大的情况

2、In确定给定的值是否与子查询或列表中的值相匹配

3、Exists指定一个子查询，检测行的存在

七十三、 跳过索引进行全表扫描的情况有哪些

1、在where子句中对null值进行判断 可对null值使用一个特定值进行填充，避免null值

2、在where子句中使用!=、<、> 操作符

3、在where子句中使用or来连接条件

4、在where子句中对字段进行表达式操作，如where num/2=100

5、在where子句中使用in或not in 对连续的数值可使用between

6、索引列中的数据存在大量重复，如性别列

7、对索引字段进行LIKE查询时‘%abc%’不能使用索引，’abc%’将能够使 用索引

七十四、 view是什么，有什么优点

1、虚拟表优点

1）简化数据操作。(在经常用到多表查询是可以使用查询 view 替换)

2）安全性（用户对视图，不可以随意的更改和删除，可以保证数据的安全性）

3）合并分离的数据（大公司旗下的各个小公司分别看各个分公司的数据不方便没有对比性使用视图可以方便的查看）

2、缺点                                                                                                                                                                                                   

1）性能差 视图查询需要转化成多表的查询 （如果视图是有超多表复杂查询定义的 及时是一个简单的查询也需要查询）

3）当用户试图修改试图的某些信息时，数据库必须把它转化为对基本表的某些信息的修改，对于简单的试图来说，这是很方便的，但是，对于比较复杂的试图，可能是不可修改的。

七十五、什么是ORM？

(object relational mapping) 对象关系映射 ORM是通过使用描述对象和数据库之间映射的元数据，将程序中的对象自动持久化到关系数据库中。 

七十六、 Mybatis 与 hibernate区别？

1、mybatis 的ORM 的机制，在业务逻辑实现上是纯 Java 对象，这与机遇 hibernate 的 ORM 是一致的。

2、对于数据库的操作 hibernate 主要是和 entity 联系比较紧密一般都是对对象进行操作

3、对于数据库操作的map 一般都是写一个 mapper 层和直接写 SQL语句于 数据库联系比较紧密

4、作为对全自动ORM 实现的一种补充，mybatis 有着特殊的存在价值和空间

七十七、  Mybatis 发送sql的两种方式，并比较优劣？

1、通过 SqlSession 直接执行 sql 语句

2、通过SqlSession获取Mapper的方式

3、优缺点

1）Mapper接口编程可以消除SqlSession带来的功能性代码提高可读性；mapper 的方式更可以体现出面向对象的思想更可以提现出业务逻辑

2）基于Mapper实现类的方式，在调用方法时 ide 会提示错误信息而 SqlSession.selectOne()语法错误时,只有在程序运行时才能知道是否会产生错误。

3）直接执行 sql 语句的方式减少了 mapper 减少了 sql 语句，只需要对对象操作即可

七十八、#{}和${}区别？

1、能用到#{}的地方最好可以使用不要使用${}防止sql注入的问题

2、#{} 的后要加双引号和${}不加双引号

3、#{} 传的参数都是固定的比如id 

4、${}传入的参数是动态的比如offset 表名

七十九、 Mybatis动态sql是什么意思，怎么用？

动态 SQL 元素和 JSTL 或基于类似 XML 的文本处理器相似

1、if

2、choose (when, otherwise)

3、trim (where, set)

4、foreach

八十、Spirng 的优缺点有哪些？

1、优点

1）使用Spring的IOC容器，将对象之间的依赖关系交给Spring，降低组件之间的耦合性，让我们更专注于应用逻辑

2）可以提供众多服务，事务管理，WS等。

3）AOP的很好支持，方便面向切面编程。

4）对主流的框架提供了很好的集成支持，如 mybatis hibernate,Struts2,JPA等

5）Spring DI机制降低了业务对象替换的复杂性。

6）Spring属于低侵入，代码污染极低。

7）Spring的高度可开放性，并不强制依赖于Spring，开发者可以*选择Spring部分或全部

2、缺点

1）jsp中要写很多代码、控制器过于灵活，缺少一个公用控制器

2）Spring不支持分布式，这也是EJB仍然在用的原因之一。

具体查看：https://blog.csdn.net/xingxiupaioxue/article/details/68943036

八十一、Spring的IOC 是什么意思，如何使用？

DI:称作依赖注入(Dependency Injection),和控制反转一个概念，具体的讲，当一个角色需要另外一个角色协助的时候，在传统的程序设计中，通常有调用者来创建被调用者的实例。但是在spring中创建被调用者将不再有调用者完成，因此叫控制反转。创建被调用对象有Spring来完成，在容器实例化对象的时候主动的将被调用者（或者说它的依赖对象）注入给调用对象，因此又叫依赖注入。

八十二、Spring 创建bean的原理。

具体查看：https://blog.csdn.net/vipmao/article/details/51584571

八十三、 Spring常用注解有哪些？

1、Component（肯剖嫩特） 组成的

2、Controller 控制器controller层

3、Service 服务 Service 层

4、Repository （瑞跑死特瑞）仓库 dao 层 

5、mapper map 层的

6、Scope（斯购普）  范围 参数可指定为singleton或prototype  其默认值为singleton。

7、Value 值 直接赋值

8、Resource （锐扫斯）资源 引用Bean对象就是在 A类创建一个B 类

9、PostConstruct （啃死抓克特）构造函数

10、PreDestroy  （普瑞得斯昭爱）销毁  初始化之后和销毁之前的生命周期回调方法

11、autowired

12、Aspect 方向 aop 的注解

13、RequestMapping

14、RequestAttribute

15、RequestBody

16、Requestparam

17、Restcontroller

18、ApiOperation

19、bean

20、api 

21、Transactional  （踹宰客神 No）

22、EnableTransactionManagement（in内保踹宰客神买内值门特）

八十四、 springMVC 软件架构图以及工作原理  71 常用的注解有哪些。

点击链接：https://blog.csdn.net/qq_40763761/article/details/80079196

八十五、Spring AOP 原理

AOP是从运行程序的角度去考虑程序的结构，提取业务处理过程的切面，OOP是静态的抽象，AOP是动态的抽象，是对应用执行过程的步骤进行抽象，从而获得步骤之间的逻辑划分。

八十六、 Spring AOP 事务注解原理，如何使用事务。

Transactional  （踹宰客神 No）

EnableTransactionManagement（in内保踹宰客神买内值门特）

1、原理

1）自动提交 默认的情况下数据库处于自动提交的模式每条语句都是一个小事务，成功就是自动提交 失败就是回滚，因此必须关闭数据库的自动提交模式。这点，spring会在org/springframework/jdbc/datasource/DataSourceTransactionManager.java中将底层连接的自动提交特性设置为false。

2）指示spring事务管理器回滚一个事务的推荐方法是在当前事务的上下文内抛出异常。spring事务管理器会捕捉任何未处理的异常，然后依据规则决定是否回滚抛出异常的事务。spring只有在抛出的异常为运行时unchecked异常时才回滚该事务，也就是抛出的异常为RuntimeException的子类(Errors也会导致事务回滚)，而抛出checked异常则不会导致事务回滚。

2、实现方法