记第一次面经

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

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

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

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

String对象的声明

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

写一段冒泡排序

/*冒泡排序：
 冒泡排序（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);
    }
}

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

单例模式

百度百科

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

显然单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。
说一下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()方法）
Spring的核心是什么？

IOC和AOP

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

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

AOP：面向切面编程

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

参考网址
```
        2018.06.27.保定
```

记第一次面经

记第一次面经

猜你喜欢