记第一次面经

记第一次面经

1. String str=new String("abc"); 创建了几个对象?

   这是个极简单极常规的问题：答案是：2个

   面试的时候不知道是第一次面试紧张还是觉得问题简单太自信，张口就说了1个。回来的路上猛地想起来，差点找个地缝钻进去。

   例：String str="abc";                             毫无疑问，这行代码创建了一个String对象。
   例：String a="abc"; String b="abc";       那这里呢？答案还是一个。
   例：String a="ab"+"cd";                         再看看这里呢？答案是三个。

   String对象的声明

   

   原来写过==与equals的区别时也提到过    equals与==的区分

2. 写一段冒泡排序

   /冒泡排序：
   冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。
   即在第一趟：首先比较第1个和第2个数，将小数放前，大数 放后。
   然后比较第2个数和第3个数，将小数放前，大数放后，
   如此继续，直至比较最后两个数，将小数放前，大数放后。
   至此第一趟结束，将最大的数放到了最后。
   在第二趟：仍从第一对数开始比较
   （因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前中，大数放后.
   一直比较到倒数第二个数（倒数第一的位置上已经是最大的）.
   第二趟 结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。
   如此下去，重复以上过程，直至最终完成排序。/

   public class SortTest {
   public static void main(String[] args) {
   //定义数组
   int arr[] = { 24, 13, 48, 25, 88, 66, 20, 14, 45, 360, 65, 77 };
   int k = 0;
   // 冒泡排序
   for (int i = 0; i < arr.length - 1; i++) { //设定i为第i行
   for (int j = 0; j < arr.length - 1; j++) { //设定j为第j个数
   if (arr[j] < arr[j + 1]) { //如果前边的数小于后边的数
   int t = arr[j];
   arr[j] = arr[j + 1];
   arr[j + 1] = t; //进行交换，把大的放在前面
   k++; //交换的总次数
   }

   System.out.print("第" + (i+1) + "行的第j=" + (j+1) + "次交换\t");
   for (int d = 0; d < arr.length; d++) {
   System.out.print(arr[d] + "\t"); //输出
   }

   System.out.println();
   }
   }

   System.out.println("交换的次数为" + k);

   }
   }

   写一段选择排序

   public class Sort2Test {

   /选择排序
   第一次从下标为0的开始下标为0的这个数与后面的n-1个进行比较；
   找出最小或者最大的放在下标为0的这个位置；
   第二次从下标为1的开始比较；查询剩下的最大或者最小值；放在
   下标为1的位置；以此类推；直到排序完成./

   public static void main(String[] args) {
   //定义数组
   int arr[] = { 24, 13, 48, 25, 88, 66, 20, 14, 45, 360, 65, 77 };
   // 选择排序
   int l = 0;
   for (int i = 0; i < arr.length - 1; i++) {
   for (int j = i + 1; j < arr.length - 1; j++) {
   if (arr[i] < arr[j]) {
   int t = arr[i];
   arr[i] = arr[j];
   arr[j] = t;
   l++;
   }
   System.out.print("第" + (i+1) + "趟的第j=" + j + "次交换\t");

   for (int d = 0; d < arr.length; d++) {
   System.out.print(arr[d] + "\t");
   }
   System.out.println();
   }
   }
   /for (int i = 0; i < arr.length; i++) {
   System.out.print(arr[i] + "\t");
   }/
   System.out.println("交换的次数为" + l);
   }
   }

3. Oracle、Mysql的分页程序

   Oracle：

   SELECT * FROM
   (
   SELECT A.*, ROWNUM RN
   FROM (SELECT * FROM TABLE_NAME) A
   WHERE ROWNUM <= 40
   )
   WHERE RN >= 21
   Mysql：

   取前5条数据
   select * from table_name limit 0,5

   查询第11到第15条数据
   select * from table_name limit 10,5

4. 单例模式

   百度百科

   Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”

   显然单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

5. 说一下Servlet执行流程和生命周期

   执行流程：

   1. 客户端发出请求，通过表单或者超链接，找到相对应的servlet（@WebServlet(“”)）

      WEB3.1之后注解开发不需要再去web.xml中配置了，但是二者不能同时有

   2. servlet接收客户端传来的数据，对客户端的请求进行处理，根据请求方式确定调用doGet()方法或者doPost()方法、操纵数据库等

   3. 通过redirect方法或者forward方法将数据返回到客户端

   生命周期

   1. 客户端发送请求后首先判断是否存在Servlet实例，如果没有存在创建Servlet实例（Servlet的构造方法）。（Servlet引擎载入servlet）

   2. 如果存在Servlet实例，则开始其初始化阶段，执行器初始化方法（init()方法）。

   3. 第三阶段是响应客户端请求阶段，调用service()方法，根据提交方式选择执行doGet()方法或者doPost()方法。

   4. 最后是销毁阶段，程序结束或者是服务器停止，调用其销毁方法（destroy()方法）

6. Spring的核心是什么？

   IOC和AOP

   IOC：一个bean容器，其中的bean可实现控制反转（依赖注入）

   依赖注入（控制反转）的意思就是你不用显示的在一个类里用new关键字来生成你想要的对象而只需在xml配置文件里添加相应节点即可，这样就让你整个程序的组成变得灵活多样。

   AOP：面向切面编程

   Spring中AOP代理由Spring的IOC容器负责生成、管理，其依赖关系也由IOC容器负责管理。

   参考网址

   2018.06.27.保定