1.JDBC

• 作用：连接数据库并发送SQL语句，本身不具备操作数据库的能力。

• 流程：

  • 1）注册驱动； Class.forName("com.mysql.jdbc.Driver");
  • 2）建立连接； DriverManager.getConnection(url, user, password);
  • 3）创建Statement；
  • 4）执行sql 语句；
  • 5）处理结果集`
  • 6）关闭连接。

• 以添加数据作为例子

    package com.ajiatech.common.utils;
    
    import java.sql.*;
    
    public class JDBCTest {
    
        public static void main(String[] args) throws Exception {
            String className = "com.mysql.jdbc.Driver";
            String url = "jdbc:mysql://localhost:3306/store?useSSL=true&characterEncoding=UTF8";
            String root = "root";
            String password = "password";
            try {
                Class.forName(className);//加载驱动
    
            } catch (Exception e) {
                
            }
            
                Connection conn = DriverManager.getConnection(url, root, password);//建立连接
                PreparedStatement pstm = null;//执行sql语句
                String sql = "INSERT INTO student VALUES (?, ?, ?, ?)";
                pstm = conn.prepareStatement(sql);
    
                pstm.setInt(1,1 );//user.getId()
                pstm.setString(2,"天火" );//user.getName()
                pstm.setString(3, "男");//user.getGender()
                pstm.setInt(4, 12);//user.getAge()
                // 执行sql语句
                pstm.executeUpdate();
    
            
     
            if (pstm != null) {
                try {
                    pstm.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                pstm = null;
            }
     
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                conn = null;
            }
    
            
        }
    }
  

2.生命周期

1. servlet的生命周期
   • 默认是第一次访问时创建(Servlet中init方法就会执行), 每次访问Servlet, 服务器都会开启一个新的线程并进行分发, 根据请求的方式的不同调用doGet/doPost的方法。服务 器关闭或者项目移除的时候销毁(执行destroy方法交代遗言)。
   • 注：如何在服务器启动时创建servlet ? --- Servlet: <load-on-startup>2</load-on-startup> 在配置文件中设置优先级。
2. 过滤器生命周期
   • 创建:服务器启动的时候创建Filter的对象；
   • 销毁:服务器关闭的时候或者是项目移除!
3. Session的生命周期
   • 创建： 访问jsp时，会自动创建session；访问servlet时，只会手动调用request.getSession()时才会创建;
   • 销毁： tomcat默认30分钟销毁。 手动调用invalidate方法也可以销毁

3.final,finally和finalize的区别

• final:修饰符，修饰类不能被继承，修饰方法不能被重写，修饰变量只能被赋值一次（注意：基本数据类型只能赋值一次，引用数据类型的地址只能复制一次，但是具体的值可以变化。eg: StringBuffer对象创建之后再拼接其他参数）。

• finally:异常处理。一定会执行。atch中的return是先建立返回通道，将返回数据缓存，然后执行finally，finally中即使对该数据进行了修改也是没用的，因为没有重新缓存，finally执行结束后才真正返回

    try{
    int x = 12/0;
    }catch(Exception e){
    int y = 3;
    return y;
    }finally{
    y = 5;
    }
    结果：3
  

• finalize()方法是object的方法，所以每个类都有这个方法。当对象没有引用指向时，垃圾回收器就会不定时的清除，在清除之前，本对象会调用该方法（可以交代遗言或进行对象复活---只需要指定一个变量指向this即可）。

4.转发和重定向区别

• 转发：一次请求一次相应，服务器内部跳转；重定向：多次请求，多次响应。
• 转发：浏览器访问服务器的controller1,转发到controller2，再转发到controller3,最后相应到浏览器。中间请求链中使用同一个request对象，参数共享。
• 重定向：浏览器访问A服务器，响应回浏览器；浏览器再重定向到A服务器或者其他服务器。然后响应浏览器。这是两个请求链，不是同一个request对象，参数不能共享。

5.Hashtable和HashMap的区别：

底层都是哈希算法。

• Hashtable是线程安全的，效率低，jdk1.0版本的，不能存储null键和null值。
• HashMap是线程不安全的。效率高，jdk1.2版本的，可以存贮null键和null值。

(ArrayList比Vector高效，HashMap比HashTable高效，StringBuilder比StringBuffer高效)

6.http协议对cookie规定：

• cookie携带数据最大为4kb；
• 一个服务器最多向一个浏览器保存20个cookie；
• 一般浏览器最多可以保存300个cookie.

7.创建线程的方法

Thread类，Runnable接口，Callable接口，线程池。

8.struts默认是多例多线程的，那为什么还要在controller中要使用@Scope("prototype")？

• struts默认是多例多线程的，线程安全；但spring创建的实例默认都是单例的，所以 struts2和spring整合之后，struts受到spring管理，变成单例的了，这样线程不安全， 所以要在struts的controller中要使用@Scope("prototype")再改成多例的。

9.面向对象

答：面向对象的特征主要有以下几个方面：

• 1)抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象,二是数据抽象。
• 2)继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
• 3)封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象,这些对象通过一个受保护的接口访问其他对象。
• 4)多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

10.重载和重写

• 重载：同一个类中的同名方法，与返回值类型无关，至于参数列表有关（个数，类型，顺序）。另外，子类集成父类后（父类中的非构造方法出现在子类中），出现了同名方法，但是参数列表不同，也是重载。
• 重写：子类继承父类后，定义了一个和父类一模一样的方法

11.jvm,jre,jdk的区别

• jvm保证java语言跨平台的一个虚拟机；
• JRE = JVM + java核心类库；
• JDK = jre + tools工具包

12.控制反转和依赖注入

• 控制反转和依赖注入：是对同一个事物的不同描述，是一个“主从换位”思想。

• 控制反转（IOC）：spring控制应用程序，反向注入他所需要的外部资源

  • 谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

  • 为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

  • 其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。

  • oC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

• 依赖注入（DI）：应用程序依赖spring注入他所需要的外部资源。

  • DI—Dependency Injection，即“依赖注入”：是组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。
  • 谁依赖于谁：当然是应用程序依赖于IoC容器；
  • 为什么需要依赖：应用程序需要IoC容器来提供对象需要的外部资源；
  • 谁注入谁：很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；
  • 注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。

• IoC和DI由什么关系呢？其实它们是同一个概念的不同角度描述，由于控制反转概念比较含糊（可能只是理解为容器控制对象这一个层面，很难让人想到谁来维护对象关系）

13.jsp的九大内置对象及作用

• a) page：page 对象代表JSP本身，只有在JSP页面内才是合法的，类似于Java编程中的 this 指针。
• b) pageContext：通过它可以获取 JSP页面的out、request、reponse、session、application、config等对象
• c) request：封装请求参数（业务参数，请求路径，IP，端口，请求头等）
• d) response：设置contentType，响应方式等
• e) session：服务器为每用户都创建一个session对象，保存用户信息
• f) application：服务器启动时创建，关闭时销毁。类似session，但它的生命域和声明周期比session更长，所有客户共享这个内置的Application对象。JSP中叫application，servlet中叫servletContext。
• g) out：给浏览器输出信息，并管理应用服务器上的输出缓冲区
• h) exception：显示异常信息，只有在包含 isErrorPage="true" 的页面才可以被使用，在一般的JSP页面中使用该对象将无法编译JSP文件。
• i) config：获取服务器的配置信息。当一个Servlet 初始化时，容器把某些信息通过config对象传递给这个 Servlet，可以在web.xml中提供初始化参数。

14.常见的数据结构特点

• A:栈 先进后出
• B:队列 先进先出
• C:ArrayList 查询快，增删慢
• D:LinkedList 查询慢，增删快
  • ArrayList ：一般情况下，数组在内存中是连续存储的（这就是为啥创建数组时必须要指定长度，因为它要去内存中预留一块足够大的空间），通过指针去找到一个数组下标是非常快的；但是，福兮祸所伏，数组需要去维护下标，导致增删就比较慢。
  • LinkedList ：链表数据存储是不连续的，比如：内存中，A空间指向B空间，B空间指向C空 间，C空间指向D空间。我要查D空间的数据，每次都要从A空间顺着找过去，跳来跳去导致查询效率很低；但是，祸兮福所倚，链表不需要维护每个数据的地址，增删时，只需要修改该数据前后两个数据的关联地址即可。

15.事物

• 并发事务(同一时间进行的另一个事务)引起的3个安全问题(按顺序记忆)：
  • 1)脏读：A事务读取了B事务未提交的数据（一旦B事务回滚，可能会导致A事务读取的数据无效）。
  • 2)不可重复读：一个事务方法中连续查询多次，却得到不同的结果（原因：并发事务在两次查询的中间对数据进行了修改）。
  • 3)虚读/幻读：一个事务方法中连续查询多次，却得到不同的结果（原因：并发事务在两次查询的瞬间对数据进行了增删）。
• 数据库4个隔离级别（为了解决并发事务的安全问题）：
  安全性从低到高：唯一可穿
  • 1)未提交读：安全级别最低，3个安全问题都解决不了。
  • 2)已提交读（Oracle默认）：可以解决第一个问题（脏读）。
  • 3)可重复读（mysql默认）：可以前两个问题（脏读和不可重复读）。
  • 4)串行[又叫可序列化]：全部解决。
  • 注意1：安全级别越来越高，那么效率就越来越低。比如串行，虽然把3个问题全解决了，但是有代价，它在执行A事务的时候，把整张表锁定，不论是读事物还是写事物，全都串行排队。
  • 注意2：数据库的隔离级别可以修改，但一般采用默认，不过有人为了提高mysql的性能，将其隔离级别改为第二级（已提交读），由于间隙锁等优化策略的存在，解决了不可重复读和虚读/幻读。
• 事务的传播：一个事务方法调用另一个事务方法，必须指定事务如何传播（比如：一个service方法调用另一个service方法）。
  • 注：事务的传播行为看的是被调用的方法，方法被调用的时候，就会触发事务的传播。
  • (1) REQUIRED（spring默认）：调用方有事务就用它的，没事务就用自己的
  • (2) REQUIRED_NEW：在事务方法调用过程中，把调用方的事务挂起，使用自己的事务。
  • (3) SUPPORTS：当前有事务就用，没事务就拉倒（不用）
  • (4) NOT_SUPPORTED：不支持事务，当前有事务就挂起
  • (5) NESTED

16.泛型的作用

• 将运行期异常提到编译期，提高安全性；而且泛型还可以帮我们对一些方法和类进行抽取，减少代码量。
• 问题1：不用泛型行不行？
  • 当然可以，jdk1.5以前没有泛型，集合存东西全部使用Object，但这样不安全。eg:用户存数据时凭感觉存储，他以为存的全是String，所以集合遍历之后就直接把他们当成字符串处理，结果存储的时候，疏忽了，存进去一个Integer类型，这样运行时不就报错了。
• 问题2：ArrayList<String>，我怎么向里边存Integer类型?
  • 通过反射，泛型检查只存在于编译期，编译之后，泛型就被擦除了，反编译.class文件发现，泛型没有了，所以通过反射操作class文件，来躲过泛型检查

17.接口为什么可以使用object的方法？

• object是超类(跳出三界外，不在五行中，不能当成普通类理解)，所以接口也继承了；
• 接口中暗含了一套跟object同名的方法。
• 如果问到了，两种都告诉他，然后说“我更倾向于第X种”，没必要话太多时间去弄清楚，因为没意义。

18.ajix

• Ajax 全称是异步的 JavaScript 和 XML 。 通过在后台与服务器进行少量数据交换，AJAX 可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。传统的网页（不使用 AJAX）如果需要更新内容，必须重载整个网页页面。

Ajax 具有以下优点和缺点：

• 优点

  • 无需刷新页面，用户体验好；
  • 异步与服务器通信，不影响主进程，响应更迅速；
  • 可以把部分服务器的工作放在客户端的浏览器完成，减轻服务器压力，减少冗余请求和响应；
  • Ajax 是前端开发的标准化技术，无需插件支持，跨平台性能好；

• 缺点

  • Ajax 请求不修改浏览器历史记录，因此不支持前进后退功能；
  • Ajax 暴露了过多和服务器交互的细节；
  • 破坏了程序的异常机制，容易调试；
  • 不利于搜索引擎抓取信息；

19.http状态码

• 200 OK；
• 302：重定向
• 304：表示所请求的文件没有被修改（那么浏览器就会从缓存中取之前的数据，从而节省带宽）；
• 400：请求参数漏了
• 404文件访问不到（路径不对）；
• 405：HTTP method GET is not supported by this URL，一般是get请求方式不对，换成post/put/delete等请求方式即可。
• 500服务器内部错误（路径对了，但是服务器内部的代码报错）

20.成员变量和局部变量区别

• 在类中的位置：成员变量出现在类中方法外，局部变量出现在方法内部或者方法的形参上。
• 在内存中的位置：成员变量随对象的创建而出现在堆中，局部变量随方法的调用而出现在栈中。
• 生命周期：成员变量随着对象的创建而创建，随着对象的销毁而销毁；局部变量是随着方法的调用而产生，随着方法的调用的结束而销毁。
• 初始值：成员变量有默认初始值（eg：int类型的成员变量是0），局部变量没有默认值，必须手动赋值。

31. 静态变量和成员变量的区别

21.静态变量和成员变量的区别

• 所属不同：静态变量属于类（.class字节码文件），成员变量属于对象（new出来的东西）。
• 在内存中的位置：静态变量位于方法区的静态区，成员变量位于堆内存。
• 生命周期：静态变量随类的加载而加载，随类的消失而消失；成员变量随对象的创建而创建，随对象的销毁而销毁。
• 调用方式：静态变量可以类名调用（推荐），也可以通过对象调用；成员只能通过对象调用。

22.switch表达式变量格式

• byte
• short
• int
• char
• JDK5可以用枚举
• JDK7可以用字符串
• 八种基本数据类型中 int字节最大

23.sql语句的优先级

• from > where > group by > having > select(标准sql语句) > order by
  注：where后面的条件不能使用聚集函数，having:用于分组后的条件过滤

24.mybatis中#{}和${}区别:

• {}：占位符，能防止sql注入；

• ${}：拼接符，用于字符串拼接，不能防止sql注入。
• 所以，要用#{}代替${}的使用。
• eg：模糊查询时，传入参数”%张%”，使用#{value}接收；而不要传入”张”，再用”%${value}%”接收并拼接。

25.session和cookie的生命周期：

session：

• 创建：
  • 第一次访问jsp时，jsp会被转成servlet，在转换过程中，底层会自动调用 request.getSession()方法，去创建一个session，作为jsp九大内置对象之一和 该jsp绑定；
  • 而访问servlet时，如果内部没有使用request.getSession()方法，是不会创建 session的；只有手动调用该方法，才会创建。
  • 注：访问HTML，js，图片，css等静态资源是不会创建session的，因为访问 这些静态资源用不到session，跟session没有半毛钱关系，死板的创建session 和cookie 是浪费资源的。
• 销毁：
  • Tomcat默认30分钟后销毁，或者手动调用invalidate()方法，使之失效。
  • 注：服务器关闭时，如果30分钟不到，session可以持久化到本地磁盘，服务器启动会再次加载进内存（注：session的序列化需要特殊设置，否则不生效）。

cookie：

• 创建：
  • session创建之后，服务器会自动创建一个cookie，把session的id存入cookie （Set-cookie:JSESSIONID=session的id），并响应给浏览器。当然，代码中可以手动new Cookie(“key”,”value”)并响应给浏览器。
• 销毁：
  • 默认是浏览器关闭就销毁（cookie存储于浏览器内存，浏览器关闭，内存即释放，因而销毁），可以进行持久化，持久化之后即使浏览器关闭也不会销毁（存到硬盘上，再次打开浏览器又会被加载）。

25.创建对象的方式(除new之外)

1. 反射：
   • Class.forName(“全类名”).newInstance();
   • User.class.newInstance(); 或 User.class.getConstructor.newInstance();
2. clone：
   • 先让实体类实现Cloneable空接口
   • 在实体类中重写Object中的native方法clone();
3. 反序列化：
   • 实体类实现Serializable接口
   • 使用ObjectOutputStream和ObjectInputStream实现对象序列化和反序列化

26.HashMap底层原理