记第一次面经

记第一次面经

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.保定