java基础汇总

来源：互联网发布：网络教育学什么专业好编辑：程序博客网时间：2024/05/19 13:10

@是重点可以写在笔记本上
椎与栈总结：

1，定义的位置不同。
成员变量定义在类，作用于整个类。
局部变量定义函数，作用于整个函数，或者定义在语句，作用于语句内。
2，内存出现的时间和位置不同。
成员变量：当对象创建时，出现在堆内存的对象当中。
局部变量：所属区间被运算时，出现在栈内存中。
3，生命周期不同。
成员变量：随着对象的出现而出现，随着对象的消失而消失。
局部变量：随着所属区间运算结束，立刻被释放。
4，初始化值。
成员变量：因为在堆内存中，都有默认初始化。
局部变量：没有默认初始化。

2堆：

a) 也是树，但是它是完全二叉树（除了树的最后一层的节点不需要是满的，其它的每一层从左到右都完全是满的）

b) 它是用一个数组实现的

c) 每一个节点的关键字都大于或等于这个节点的子节点的关键字

3
3，栈内存：存储的都是局部变量。变量运算区域一结束，就释放。
局部变量：在方法上的参数，方法内的变量，语句中的变量。
4，堆内存：存储的是数组和对象，简单说，堆内存中存储都是实体。
实体就是可以存储多个数据地方。记住，只要是用new建立都存储在堆内存中。
特点：
1，任何实体都有内存地址值。
2，堆内存中的变量都有默认初始化值。
3，数据的回收是靠java的垃圾回收机制。
5，方法区：存储函数的地方，存储共享数据的地方，如class和static。
总结：基本数据类型，都是放在栈空间中的，基本的对象则是将创建的对象的引用在栈中分配空间，而对象的实例化则是在堆中为成员变量分配空间并赋

值，并返回对象的引用给栈。
4基本数据类型，都是放在栈空间中的，基本的对象则是将创建的对象的引用在栈中分配空间，而对象的实例化则是在堆中为成员变量分配空间并赋值，并返回对象

的引用给栈。
5

64 栈与堆的区别
68 .成员变量存储在堆，局部变量存储在栈

Java把内存划分成两种：一种是栈内存，一种是堆内存。
@在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。
@堆内存用来存放由new创建的对象和数组。
4
1.Object sobj = new Object();
2.Object sobj = null;
3.Object sobj = new Object();
4.sobj = new Object()
在上面的代码中，第一行和第三行都为sobj分配了内存空间，而第二行第四行又对它们进行了重新的赋值，这样就使得原本的对象不再被引用，符合了GC的回收机

制，会被收回收。

5

1。在函数中定义的基本类型变量和对象的引用变量都在函数的栈内存中分配；

2。堆内存用来存放由new创建的对象和数组

在函数（代码块）中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量所分配的内存空间；在堆中分

配的内存由java虚拟机的自动垃圾回收器来管理

@堆的优势是可以动态分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的。缺点就是要在运行时动态分配内存，存取速度较慢；

@栈的优势是存取速度比堆要快，缺点是存在栈中的数据大小与生存期必须是确定的无灵活性。

java堆分为三个区：New、Old和Permanent

GC有两个线程：

新创建的对象被分配到New区，当该区被填满时会被GC辅助线程移到Old区，当Old区也填满了会触发GC主线程遍历堆内存里的所有对象。Old区的大小等于Xmx减去-

Xmn

java栈存放

栈调整：参数有+UseDefaultStackSize -Xss256K，表示每个线程可申请256k的栈空间

每个线程都有他自己的Stack

@内存溢出与内存泄漏区别：

1.内存溢出：内存溢出是指程序要求的内存，超出了系统所能分配的范围，从而发生溢出。比如定义了一个int却当double使用
2.内存泄漏：内存泄漏是指分配出去的内存无法回收了。一般是设计失误造成的，malloc却没有free
3.栈是有大小的，不过可以通过编译器选项来调整栈的大小

@JVM栈内存：对于JVM而言，其可用总内存是固定的（是多少呢？），减掉方法区的内存大小和堆内存大小，就可以大概认为剩下的是JVM的栈内存大小
栈内存从概念上分 “线程的栈内存” （会抛出StackOverFlowError。）和 “JVM的栈内存”（vm就会报OOME 即out of merray）两种。
单线程下，xss设置太小，或者定义太多的本地变量（递归）都会导致stackoverflow。多线程下，通过不断创建新的线程就会导致oom。
写个不结束的递归函数很快就会栈益出。不断的去new新对象，堆也很快益出

@37 :成员变量和局部变量的区别(理解)
(1)在类中的位置不同
成员变量：类中方法外
局部变量：方法定义中或者方法声明上
(2)在内存中的位置不同
成员变量：在堆中
局部变量：在栈中
(3)生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
(4)初始化值不同
成员变量：有默认值
局部变量：没有默认值，必须定义，赋值，然后才能使用

1 验证业务编号是否重复的效验

如果是增加直接从数据库中查，查得到就是重复
修改，出去自身的id查得到就是重复

核心代码

var yhbhsfcz = "";
$.ajax({
type: "POST",
url: "ywdy_bhvalida.jsp",
cache: false,
async:false,
data: {yhbh:yhbhv,wid:swid},
dataType:'text',
success:function(result){
yhbhsfcz = result;
}
});
if(yhbhsfcz!="-1"){
document.getElementById('ywbh').focus();
document.getElementById('ywbh').value="";
alert("您输入的业务编号已经注册，请重新输入！");
return false;
}

String yhbh = StringUtils.defaultIfEmpty(request.getParameter("yhbh"),"").trim();
String wid = StringUtils.defaultIfEmpty(request.getParameter("wid"),"").trim();
SQLDirect sd = new SQLDirect();
String returnVal="-1";
String sql = "";
if("".equals(wid)||"null".equals(wid)){
sql = "select wid from ZC_YW where ywbh = '"+yhbh+"' ";
}else{
sql = "select wid from ZC_YW where ywbh = '"+yhbh+"' and wid <>'"+wid+"'";
}
//System.out.println(sql);
CachedRowSet crs = sd.exeQuery(sql);
if(crs.next()){
returnVal="1";
}

2 wid字符串的转换

//将wid字符串格式更换
String wids[];
if(wid.indexOf(",")!=-1){
wids=wid.split(",");


wid="";
for(int q =0;q<wids.length;q++){
wid+="'"+wids[q]+"',";（顿号）
}
wid=wid.substring(0,wid.length()-1);
}

con+= " and wid in ("+wid+")";

3 传值

var url="../../xxtzgl/userTree.jsp?BMBH="+bmbh+"&hidcode="+bh+"&hidcode="+name+"&selectYh="+document.all(bh).value+",";

7 // 定义一个字符串
String s = "dacgebf";

// 把字符串转换为字符数组
char[] chs = s.toCharArray();

// 把字符数组进行排序
bubbleSort(chs);

//把排序后的字符数组转成字符串
String result = String.valueOf(chs);

把字符数组转成字符串
char[] chs = { 'a', 'b', 'c', 'd', 'e', '爱', '林', '亲' };
String s4 = new String(chs);
System.out.println("s4:" + s4);
s4:abcde爱林亲
s4.length():8

7 数组是length
字符串是length() 记忆方法：字符串的长度是最长的
泛型集合 size()
@8*
* int类型和String类型的相互转换
*
* int -- String
* String.valueOf(number)
*
* String -- int
* Integer.parseInt(s)
*/

6StringBuffer：同步的，数据安全，效率低。
9* StringBuffer和String的区别?
@4 StringBuffer的结果是一个字符串

* 前者长度和内容可变，后者不可变。
* 如果使用前者做字符串的拼接，不会浪费太多的资源。

10 为什么我们要讲解类之间的转换：
* A -- B的转换
* 我们把A转换为B，其实是为了使用B的功能。
* B -- A的转换
* 我们可能要的结果是A类型，所以还得转回来。

11
注：也就是说：形式参数就是方法中的抽象的公用的参数，实际参数就是具体赋值的参数

42 Java中的参数传递问题：
基本类型：形式参数的改变对实际参数没有影响。
引用类型：形式参数的改变直接影响实际参数。
*/
class ArgsDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a:"+a+",b:"+b); //a:10,b:20
change(a,b);
System.out.println("a:"+a+",b:"+b); //???a:10,b:20

int[] arr = {1,2,3,4,5};
change(arr);
System.out.println(arr[1]); //???4
}

public static void change(int a,int b) { //a=10,b=20
System.out.println("a:"+a+",b:"+b); //a:10,b:20
a = b; //a=20
b = a + b; //b=40
System.out.println("a:"+a+",b:"+b); //a:20,b:40
}

public static void change(int[] arr) { //arr={1,2,3,4,5};
for(int x=0; x<arr.length; x++) {
if(arr[x]%2==0) {
arr[x]*=2;
}
}
//arr={1,4,3,8,5};
}
}
*
* 注意：
* String作为参数传递，效果和基本类型作为参数传递是一样的。

12 * 1：String,StringBuffer,StringBuilder的区别?
* A:String是内容不可变的，而StringBuffer,StringBuilder都是内容可变的。
* B:StringBuffer是同步的，数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高
*
* 2：StringBuffer和数组的区别?
* 二者都可以看出是一个容器，装其他的数据。
* 但是呢,StringBuffer的数据最终是一个字符串数据。
* 而数组可以放置多种数据，但必须是同一种数据类型的。

14非空判断

bbmss==""||bbmss==null|| bbmss.equals("null") || bbmss.length()<=0

15 * String s = new String(“hello”)和String s = “hello”;的区别?
* 有。前者会创建2个对象，后者创建1个对象。
*
* ==:比较引用类型比较的是地址值是否相同
* equals:比较引用类型默认也是比较地址值是否相同，而String类重写了equals()方法，比较的是内容是否相同。

16 String s1 = "hello";
String s2 = "world";
String s3 = "helloworld";

System.out.println(s3 == "hello" + "world");（true）

17 String s3 = new String("hello");
String s4 = "hello";
System.out.println(s3.equals(s4));// true

18 字符串反转

/*
* 字符串反转
* 举例：键盘录入”abc”
* 输出结果：”cba”
*
* 分析：
* A:键盘录入一个字符串
* B:定义一个新字符串
* C:倒着遍历字符串，得到每一个字符
* a:length()和charAt()结合
* b:把字符串转成字符数组
* D:用新字符串把每一个字符拼接起来
* E:输出新串
*/
public class StringTest3 {
public static void main(String[] args) {
// 键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();

/*
// 定义一个新字符串
String result = "";

// 把字符串转成字符数组
char[] chs = line.toCharArray();

// 倒着遍历字符串，得到每一个字符
for (int x = chs.length - 1; x >= 0; x--) {
// 用新字符串把每一个字符拼接起来
result += chs[x];
}

// 输出新串
System.out.println("反转后的结果是：" + result);
*/

// 改进为功能实现
String s = myReverse(line);
System.out.println("实现功能后的结果是：" + s);
}

/*
* 两个明确：返回值类型：String 参数列表：String
*/
public static String myReverse(String s) {
// 定义一个新字符串
String result = "";

// 把字符串转成字符数组
char[] chs = s.toCharArray();

// 倒着遍历字符串，得到每一个字符
for (int x = chs.length - 1; x >= 0; x--) {
// 用新字符串把每一个字符拼接起来
result += chs[x];
}
return result;
}
}

19 // 去除字符串两空格
String s4 = " hello world ";
String s5 = s4.trim();
System.out.println("s4:" + s4 + "---");
System.out.println("s5:" + s5 + "---");
s4: hello world ---
s5:hello world---

22
// 定义一个字符串对象
String s = "helloworld";

// int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
System.out.println("indexOf:" + s.indexOf('l', 4)); 结果是8

23

25
注：自己的理解：原先有这个类(接口)了，通过new的方式把他搞成内部类

匿名内部类(掌握)
A:是局部内部类的简化形式
B:前提
存在一个类或者接口
C:格式:
new 类名或者接口名() {
重写方法;
}
D:本质：
其实是继承该类或者实现接口的子类匿名对象

(8)匿名内部类在开发中的使用
我们在开发的时候，会看到抽象类，或者接口作为参数。
而这个时候，我们知道实际需要的是一个子类对象。
如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

interface Person {
public abstract void study();
}

class PersonDemo {
public void method(Person p) {
p.study();
}
}

class PersonTest {
public static void main(String[] args) {
PersonDemo pd = new PersonDemo();
pd.method(new Person() {
public void study() {
System.out.println("好好学习，天天向上");
}
});
}
}

26 内部类与外部类的区别
/*
内部类概述:
把类定义在其他类的内部，这个类就被称为内部类。
举例：在类A中定义了一个类B，类B就是内部类。

内部的访问特点：
A:内部类可以直接访问外部类的成员，包括私有。
B:外部类要访问内部类的成员，必须创建对象。

*/
class Outer {
private int num = 10;

class Inner {
public void show() {
System.out.println(num);
}
}

public void method() {
//找不到符号
//show();

Inner i = new Inner();
i.show();
}

}

class InnerClassDemo {
public static void main(String[] args) {

}
}

27 内部类位置
/*
内部类位置
成员位置:在成员位置定义的类，被称为成员内部类。
局部位置:在局部位置定义的类，被称为局部内部类。

成员位置:在成员位置定义的类，被称为成员内部类。

*/
class Outer {
private int num = 10;

//成员位置
/*
class Inner {

}
*/

public void method() {
//局部位置
class Inner {

}
}
}

class InnerClassDemo2 {
public static void main(String[] args) {

}
}

28 java中，局部变量，成员变量，类变量，怎么区分呢？

解释一：
局部变量和成员变量主要看作用域，而作用域就是看花括号。作用于整个类的，就是只被类的花括号包含的，就是全局变量（成员变量）。相对而言被方法或者其

他域包含的就是局部变量。
而类变量就是被static修饰的变量，也叫做静态变量。

解释二：
成员变量包括实例变量和类变量，在方法体中定义的变量叫做局部变量,局部变量只在定义它的方法中有效，局部变量是在函数或方法中的变量，实例变量指的是类

的一个实例，就是一个对象, 成员变量就是类中的变量(不是方法中的变量!), 类变量是类中的静态变量。局部、实例、成员变量的作用域和生存周期同局部变量一

样，而类变量如果用public声明则作用域同全局变量，如果是private则作用域只在类的内部。

29 java中，接口与类和方法有什么区别？

接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而类是可以有私有方法或私有变量的，

另外，实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口

，最后才到具体类实现。

30 为什么需要有接口呢？

java是单继承的

为什么需要有接口呢？

答案一：在java中不允许一个类继承多个多个父类，但是要实现“一个类继承多个类的功能”就可以用接口，一个类实现多个多个接口从而间接实现多重继承。
@从本质上讲，接口也是是一种抽象类。这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
@多个无关的类可以实现同一个接口。一个类可以实现多个无关的接口。与继承关系类似，接口与实现类之间存在多态性。
java提供的接口都在相应的包中，通过引入包可以使用java提供的接口。也可以自己定义接口，一个java源文件就是由类和接口做成的。

答案二：
拿Thread类和Runnable接口为例：
Java中实现线程有两种方法，一种是继承Thread类，一种是实现Runnable接口
那么，对于某类A，其已经继承了某一父类B，有要求其实现线程相关功能，由于Java的单继承机制，A是无法继承Thread类的，此时就需要实现Runnable接口。

31一个类如果没有抽象方法,却定义为了抽象类，有什么用?
为了不让创建对象

32 抽象类：is a，抽象类中定义的是共性功能。
接口：like a，接口中定义的是扩展功能。

33 :如何产生一个1-100之间的随机数
int number = (int)(Math.random()*100)+1;

34 继承详解：
(1)继承的好处：
A:提高了代码的复用性
B:提高了代码的维护性
C:让类与类产生了一个关系，是多态的前提
(2)继承的弊端：
A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。
原则：低耦合，高内聚。
耦合：类与类的关系
内聚：自己完成某件事情的能力
B:打破了封装性
(3)继承的注意事项：
A:子类不能继承父类的私有成员
B:子类不能继承父类的构造方法，但是可以通过super去访问
C:不要为了部分功能而去继承
注：super

35 方法重写和方法重载的区别?方法重载能改变返回值类型吗?

方法重写：
在子类中，出现和父类中一模一样的方法声明的现象。

方法重载：
同一个类中，出现的方法名相同，参数列表不同的现象。

方法重载能改变返回值类型，因为它和返回值类型无关。

36：this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

this:代表当前类的对象引用
super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员)

场景：
成员变量：
this.成员变量
super.成员变量
构造方法：
this(...)
super(...)
成员方法：
this.成员方

43 int ge = number%10

int shi = number/10%10
int bai = number/10/10%10

44 面向对象开发
就是不断的创建对象，使用对象，指挥对象做事情。

45 在java中函数就被称为方法

46 九九乘法表

for(int x=1; x<=n; x++) {
for(int y=1; y<=x; y++) {
System.out.print(y+"*"+x+"="+y*x+"\t");
}

6

48 &&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。
||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。
49 3%4 余数是3

50

int a = 10;
int b = 10;
int c = 10;

a = b++; //a=10,b=11,c=10

51 s += 1;
不是等价于 s = s + 1;
而是等价于 s = (s的数据类型)(s + 1);
52 ^逻辑异或:
举例：情侣关系。男男,男女,女男,女女
^的特点：一个数据对另一个数据位异或两次，该数本身不变。

60 过滤器你传入的request,response提前过滤掉一些信息，继承Filter 写一个java实现类，配置在web.xml(聊天室经常用到的，一些骂人的话)中
监听器监听器对数据库连接池写一个java实现类（里面写上链接数据库的基本信息），配置在web.xml

监听器的用途：
1、统计在线人数和在线用户
2、系统加载时进行信息的初始化工作
3、统计网站的访问量
4、跟Spring结合

拦截器是在面向切面编程中应用的，就是在你的service或者一个方法前调用一个方法，或者在方法后调用一个方法。

61 另外，Java中的String类就是一个final类

63 Abstract和static不能放在一起，否则便会出现错误。（这是因为static不可被覆盖，而abstract为了生效必须被覆盖。
所以子类的方法必须覆盖父类的抽象方法。方法才能够起作用。

65 truncate 不能删除行数据,要删就要把表清空，而且删除后的数据不能rollback

66 javascript:void（0） void是无返回值的操作，点击这个时候没有任何反应。而且如果在a标签中，如果href="#"，点击后会回到网页顶部，

javascript:void(0)会没有任何反应

67 总结：aop就是写代码的时候把各个模块中需要重复写的抽取出来，弄成一个切面。例如日志，权限。
切面的具体表现就是实现公共方法的类
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

。。。。。。。。。。。
2016年12月19日看到此
69 java的设计模式
1 装饰着模式汉堡包
2 观察者模式被观察者有变化，需要同时提醒观察者运钞车
3 模板模式盖楼自己装修
4 桥模式（交通工具火车汽车拉货拉人火车拉货拉人汽车拉货拉人）
70 String filter =new String(StringUtils.defaultIfEmpty(request.getParameter("filter"),"").getBytes("ISO8859_1"),"UTF-8");
var condi = SetUniCode(document.all.hzcondition_1.value);
71传值
var url="sjzdbm_ExcelEduce.jsp?FieldName="+strName+"&filter="+condi+"&strId="+strId+"&wid=<%=wid%>&filter=<%=filter%>";
var url="sjzd_ExcelEduce.jsp?FieldName="+strName+"&filter="+condi+"&strId="+strId+"&wid=<%=wid%>";

72 replace与replaceAll的区别

相同点：都是全部替换，即把源字符串中的某一字符或字符串全部换成指定的字符或字符串；

不同点：replaceAll支持正则表达式，因此会对参数进行解析（两个参数均是），如replaceAll("\\d", "*")，而replace则不会，replace("\\d","*")就是替

换"\\d"的字符串，而不会解析为正则。

73 判断空：
String str1 = null; str引用为空

String str2 = ""; str引用一个空串

也就是null没有分配空间，""分配了空间，因此str1还不是一个实例化的对象，而str2已经实例化。

注意因为null不是对象，""是对象。所以比较的时候必须是 if(str1==null){...}和if(str2.equals("")){...}。
正确的写法是 if(str1==null||str1.equals("")){ //先判断是不是对象，如果是，再判断是不是空字符串
74 StringBUffer的效率比加号高很多
.。。。。。。。。。。。。。。。。。。。20170119
75
int rdGet = Math.abs(rdm.nextInt())%26+97;//产生97到122的随机数a-z值

public Set getChar(){

Set numberSet01 = new HashSet();
Random rdm = new Random();
char ch;
while(numberSet01.size()<20){
int rdGet = Math.abs(rdm.nextInt())%26+97;//产生97到122的随机数a-z值
ch=(char)rdGet;
numberSet01.add(ch);
//Set中是不能放进重复的值的，当它有20个时，就满足你的条件了
}
return numberSet01;
}

76 1，反射机制获取类有三种方法，我们来获取Employee类型

//第一种方式：
Classc1 = Class.forName("Employee");
//第二种方式：
//java中每个类型都有class 属性.
Classc2 = Employee.class;

//第三种方式：
//java语言中任何一个java对象都有getClass 方法
Employeee = new Employee();
Classc3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee)

77 TreeSet 是用来进行集合排序的，请注意他和LinkedHashSet的区别?
TreeSet是按照一定的规则，将加入到集合里面的数据进行排序，
而LinkedHashSet是严格按照你放入集合的顺序进行使用　

79 Buffered缓冲流：是带缓冲区的处理流，缓冲区的作用的主要目的是：避免每次和硬盘打交道，提高数据访问的效率。
.。。。。。。。。。。。20170118
80 .格式化输出日期时间
Date date=new Date();
SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
System.out.println(df.format(date));
81 　注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...)); 还有ArrayList
82 请注意，Map没有继承Collection接口，Map提供key到value的映射。
83 sql基础
IN在ORACLE中默认会将IN转换成OR，它们就好比是同义词，那如果IN的值有n个，就意味着要发生n次全表扫描，不允许超过1000 超过了就要改写成exists 或者其

他方案了
<> 　！=　^=都是不等于的意思
而union all 并不会排序和过滤

我们要是like 查询关键词怎么办，比如查询名称中带_的？
like "%/_%" escape '/'
84 js截取字符串 wid = wid.substring(0,wid.length-1);

85 遍历文件下的文件并删除
File folder = new File(filePath,fileName);
if(folder.exists()){
File files[] = folder.listFiles();
for(int i=0;i<files.length;i++){ //遍历目录下所有的文件
files[i].delete(); //把每个文件用这个方法进行迭代
}
}
86 类的多态体现在两个方面：一是方法的重载上，包括成员方法和构造方法的重载；二是在继承过程中，方法的重写。

*88int a =2 ; 和String s ="d";这两个在jvm中有什么不同，他们创建的值是放在那里的，然后是怎么调用的
常量池字符串池通过地址值调用
Sting s = "ddd"+"gggg";
这个运算 jvm做了点啥
引号声明的会在字符串池。字符串池只增不会减。你这个编译完久合并好了。运行什么到不
做

89 js中将小数点两位保留一位
var a =1.11
a = parseFloat(a.toFixed(2));

90 1bit等于多少字节

1比特(bit)=0.125字节(b)

1B就是1个字节。

Byte、KB、B、MB、GB之间的关系是：
Bit——比特
B ——字节
KB——千字节
MB——兆字节
GB——吉字节
TB——太字节

1B=8 Bit
1KB＝1024B
1MB＝1024KB
1GB＝1024MB
1TB=1024GB

91 throws和 throw的区别
throws用在函数上，用于功能声明异常，后面抛出的是异常类可以抛出多个，只要用逗号隔开即可。
throw 只能用在函数内，用于抛出异常对象，额外特点，一旦执行，就可以结束功能。

92 js自带的函数（界面显示确定取消）
if(confirm("是否确定清除家具编号为“"+wid+"”的“家具图片”？")){}
如果点确定，才会执行下面的代码

93 内部类与外部类
内部类可以直接访问外部类中的成员。
外部类要访问内部类中的成员必须创建内部类的对象。
内部类访问外部类：外部类名.this
访问内部类: 外部类名.内部类名变量名 = new 外部类对象.new 内部类对象;
匿名内部类其实就是一个匿名子类对象 new 父类名或接口名().成员。

94 在继承中其实在子类的所有构造函数中的第一行，默认有一条隐式的语句：
就是 super()，也就说子类的构造函数默认都会访问父类中空参数的构造函数。
class X {
Y b = new Y();
X() {
System.out.print("X");
}
}
class Z extends X

默认会访问X中空的构造函数

JVM执行流程：
（流程1）先初始化静态：先父静态，再子静态；
（流程2）先父后子，先父的全部，然后子的全部；
（3）优先级：父类大于子类。静态代码块>非静态代码块>构造函数（与位置的前后无关）。

默认调用super()的原因：
因为子类继承了父类，可以访问父类中的已有的一些属性。
在子类进行实例化的时候必须要为父类中的属性分配空间。
并要进行初始化，所以必须要访问一次父类的构造函数，
看看父类是如何对其属性进行初始化的。
所以子类要实例化对象时，必须要先看父类的初始化过程。

注意：如果父类中没有空参数的构造函数，
a、子类的构造函数中必须手动用super来指定要访问的父类中的构造函数。
b、或者用this来指定访问本类中的构造函数。
this和super调用构造函数只能定义构造函数的第一行，因为初始化的动作要先执行。它们不能同时出现。
继承弊端：打破了封装性。
解决方式：关键字final 最终的。

95 什么是面向对象

特点： 1、面向对象是一种思想，是符合现在人们思考习惯的一种思想；
2、面向对象的出现将复杂的问题简单化。
3、面向对象将过程中的执行者，抓换成了指挥者。
总结：面向对象是基于面向过程，将过程进行封装（这是面向对象的第一大特点），封装到了对象中，使对象具备了这些功能。以茶杯作为例子滤芯封装多态

由杯子变成茶杯继承了被子的盛水的功能并重载了泡茶的功能

96 1、使用泛型时，泛型类型必须为引用类型，不能是基本数据类型。
泛型时提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码的级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛型的java程序

后，生成的class文件中将不再带有泛型信息，以此使程序运行效率不受影响，这个过程称之为“擦除”。
.。。。。。。。。。。。。。20170117
97 装饰者设计模式

其实就是写了一个子类，在子类覆盖的父类的要装饰的方法中调用父类的该方法，并在子类的该方法中添加要增加的方法，以此来达到扩展对象的功能。IO流就是

使用的这种设计模式。

Io 包括字符流 :Reader writer 扩展的子类就是io流

字节流：InputStream outPutStream

1.字节流读取的时候，读到一个字节就返回一个字节；字符流使用了字节流读到一个或多个字节（中文对应的字节数是两个，在UTF-8码表中是3个字节）时。先

去查指定的编码表，将查到的字符返回。
2.字节流可以处理所有类型数据，如：图片，MP3，AVI视频文件，而字符流只能处理字符数据。只要是处理纯文本数据，就要优先考虑使用字符流，除此之外都用

字节流。

98 List是线程不安全的
线程不安全，要实现同步可以通过List list = Collections.synchronizedList(new ArrayList(...));

99 详解hashSet的存储过程
HashSet底层依赖的是hashCode()和equals()方法。如果两个字符串相同（那么hashCode也相同），但是如果都是new出来的他们的
hashcode不同
/*
* HashSet:存储字符串并遍历
* 问题：为什么存储字符串的时候，字符串内容相同的只存储了一个呢?
* 通过查看add方法的源码，我们知道这个方法底层依赖两个方法：hashCode()和equals()。
* 步骤：
* 首先比较哈希值
* 如果相同，继续走，比较地址值或者走equals()
* 如果不同,就直接添加到集合中
* 按照方法的步骤来说：
* 先看hashCode()值是否相同
* 相同:继续走equals()方法
* 返回true：说明元素重复，就不添加
* 返回false：说明元素不重复，就添加到集合
* 不同：就直接把元素添加到集合
* 如果类没有重写这两个方法，默认使用的Object()。一般来说不同相同。
* 而String类重写了hashCode()和equals()方法，所以，它就可以把内容相同的字符串去掉。只留下一个。
*/
如何保证hashSet的唯一性用LinkedHashSet

101 select b.merchant_id,b.merchant_name,b.merchant_type,b.merchant_big_type,t.*
from echinacard.air_merchant b,echinacard.test_merchant t
where b.merchant_id = t.merchant_id
and t.merchant_type = '110' for update
用这样的语句修改.为何出现无效的rowid错误呢

1. rowid可以说是实际纪录存储的物理地址
2. 当需要连表更新数据的时候，ORACLE的写法就是
update table_a
set ...
where ... and exists(select 1 from table_b where table_a.col = table_b.col and ...)
通过转换成exists来实现

3. 当使用for update锁住数据的时候，如果是单表更新，那么直接在查询出来的数据上进行修改是没有问题的，因为很容易根据操作的数据转换成update的SQL语

句进行更新；如果是多表连接，查询出来的数据更新，就无法判断到底操作的哪个表或者哪几个表进行更新

解决方案：因为不确定你更新的到底是哪个表的数据，直接添加 b.rowid即可

11 // 创建集合对象
Set<String> set = new HashSet<String>();
。。。。。。。。。。。。。。。。。20170116
102 构造函数为什么要使用super（如果只有一个类那么代表当前实例的父类，没有继承，就是默认的：Object）
1 每个子类的构造函数都会默认调用父类的无参构造函数, super()写与不写一样；

想调用父类的有参构造函数就比需加super了并且得加上参数比如父类有个public A（String name）{ this.name = name}
子类写成super(new String("lilei"));
不管哪一种 super必须在子类构造函数的第一行

2 :如果你本类也实现了test方法,为了区别,this.test()表示本类,super()表示父类
如果本类没有实现test.则直接使用test()也行.

3其实在java里，super关键字有主要的两种用法：
1、用在子类的构造方法里，主要是调用父类的默认构造方法。
2、在子类里调用隐藏或重写的属性或行为。
要理解用法第一，涉及到java的对象的初始化，要明白第二用法，不难但要先有继承多态的基础，

4super表示当前类的父类，super()调用的是父类默认的构造方法，即这样可以对父类进行初始化。如何没有对父类进行初始化，当子类调用父类的方法时，便会从

逻辑上出现错误，因为没对父类初始化，父类的方法和属性便没有内存空间。

103 为什么要有构造函数

不存在构造方法那也就创建不了类的实例。你就不能 A a =new A(参数1，参数2，参数3);只有初始化了才能new

104 treeset 自然排序

// TreeSet<Student> ts = new TreeSet<Student>(); //自然排序（从小到大）重写compare方法
public class Student implements Comparable<Student> 实体类继承comparable接口
排序：

TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {重写compare方法

107 方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多

态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义

，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载

(Overloading)。Overloaded的方法是可以改变返回值的类型。

108 内存溢出怎么办
一、内存溢出类型

1、java.lang.OutOfMemoryError: PermGen space
一个最佳的配置例子：(经过本人验证，自从用此配置之后，再未出现过tomcat死掉的情况)

set JAVA_OPTS=-Xms800m -Xmx800m -XX:PermSize=128M -XX:MaxNewSize=256m
-XX:MaxPermSize=256m

2、java.lang.OutOfMemoryError: Java heap space
、。。。。。。。。。。。。。。。。。。。。。。。20170113

五、不健壮代码的特征及解决办法
1、尽早释放无用对象的引用。好的办法是使用临时变量的时候，让引用变量在退出活动域后，自动设置为null，暗示垃圾收集器来收集该对象，防止发生内存泄露

。

对于仍然有指针指向的实例，jvm就不会回收该资源,因为垃圾回收会将值为null的对象作为垃圾，提高GC回收机制效率；

2、我们的程序里不可避免大量使用字符串处理，避免使用String，应大量使用StringBuffer，每一个String对象都得独立占用内存一块区域；

String str = "aaa";

String str2 = "bbb";

String str3 = str + str2;//假如执行此次之后str
,str2以后再不被调用,那它就会被放在内存中等待Java的gc去回收,程序内过多的出现这样的情况就会报上面的那个错误,建议在使用字符串时能使用StringBuffer

就不要用String,这样可以省不少开销；

3、尽量少用静态变量，因为静态变量是全局的，GC不会回收的；

4、避免集中创建对象尤其是大对象，JVM会突然需要大量内存，这时必然会触发GC优化系统内存环境；显示的声明数组空间，而且申请数量还极大。

这是一个案例想定供大家警戒

使用jspsmartUpload作文件上传,运行过程中经常出现java.outofMemoryError的错误，

检查之后发现问题：组件里的代码

m_totalBytes = m_request.getContentLength();

m_binArray = new byte[m_totalBytes];

问题原因是totalBytes这个变量得到的数极大，导致该数组分配了很多内存空间，而且该数组不能及时释放。解决办法只能换一种更合适的办法，至少是不会引发

outofMemoryError的方式解决。参考：http://bbs.xml.org.cn/blog/more.asp?name=hongrui&id=3747

5、尽量运用对象池技术以提高系统性能；生命周期长的对象拥有生命周期短的对象时容易引发内存泄漏，例如大集合对象拥有大数据量的业务对象的时候，可以考

虑分块进行处理，然后解决一块释放一块的策略。

6、不要在经常调用的方法中创建对象，尤其是忌讳在循环中创建对象。可以适当的使用hashtable，vector
创建一组对象容器，然后从容器中去取那些对象，而不用每次new之后又丢弃

7、一般都是发生在开启大型文件或跟数据库一次拿了太多的数据，造成 Out Of Memory Error
的状况，这时就大概要计算一下数据量的最大值是多少，并且设定所需最小及最大的内存空间值。

109 索引
我们在看书的时候，如果想要迅速的找到某个特定主题，是不是都先去看下它的目录，找到对应的页码。
先在索引中找到对应的值，然后根据匹配的索引记录找到对应的记录行。
110
二分查找法的优点是比较次数少，查找速度快，平均性能好。缺点是要求待查数据为有序数据，且插入删除困难。
二分查找法适用于不经常变动而查找频繁的有序的数据。
111 左右深度一致的叫做平衡二叉树
左右深度不一致，就会导致搜索不同的数时，会搜不同的层级，所以搜索均摊复杂度会上升
平衡二叉树
⊕ 它是一棵空树或其左右两个子树的高度差的绝对值不超过1，且左右两个子树也是平衡二叉树。
⊕ 不平衡树会通过旋转，变成平衡树。
⊕ 平衡树和二叉查找树最大的区别：前者是平衡的，后者未必。
B树，其实是平衡的的多叉树，不仅是二叉树

3阶的B树。

这个阶，可以简单的理解为高度、深度、LEVEL
一般来说，B树的高度都是3-4阶
大部分情况是3层，数据量很大的时候B树可能会分裂为4层，一般是亿级数据以上，才会为4层
B树（B-TREE）和B+树是有的，但不存在什么B减树，这是因为很多资料把B树书写搞为了B-Tree，这个不是减号，是横杠。
B+的搜索与B树基本相同，但是存在两点关键区别：
◎ B+树只有达到叶子结点才命中（B树可以在非叶子结点命中），其性能也等价于在关键字全集做一次二分查找
◎ B+树每个叶子节点都有双向指针，方便实现各个叶子节点之间的快速检索。
112 同义词就类似别名
同义词就是在别的用户上建立一个别名,关联到原用户对象表中。这样就不用输入用户名.btree
注意，公共同义词要加PUBLIC 默认是私有的

113 1.Data concurrency （数据并发） :数据在同一时刻有多个用户访问
悲观锁：你在修改数据的时候总认为别人也会修改该数据乐观锁相反
ORACLE锁基本上不怎么耗费资源
幻想读其实也是一种不可重复读
死锁是怎么产生的呀？
我们知道当两个用户分别占有彼此希望对方持有的资源时,
而且自己获取的（别人想要的）资源不释放，就会发生死锁
阻塞就是 A 锁定了一个资源 B 也要锁定这个资源就是阻塞其实就是等待
死锁是 A 锁定了资源 A1 B 锁定了资源B1
这时候A 又锁定资源B1 这个时候A产生等待
然后B 没有释放B1的资源又要去锁定A1的资源
这个时候产生了交叉了对吧

表锁与行锁
表锁相当于珠宝店大门的锁行锁相当于锁宝石的锁（你是老板）

你要想拿出宝石看看必须有大门的要是进去吧
是为了在做DML操作时，防止对表进行DDL操作
比如UPDATE表时，别人不允许DROP表
表锁
UPDATE，INSERT，DELETE，SELECT FOR UPDATE。。。。

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。20170111
oracle的七级锁详解
0 号锁：那就是纯粹的SELECT语句 ◎ 顾客目的：免费参观（不买）
1好锁那既然1号锁只起到通知的作用，根本阻止不了DDL （只是拆店的时候通知快点跑）
隐式产生表级锁,是由ORACLE自动加锁
比如,SELECT FOR UPDATE,隐式产生一个SS表级锁
锁本来就是为了控制并发的
120 HashMap的数据结构（允许空值，空建，null值相同，空建就覆盖）

数据结构中有数组和链表来实现对数据的存储，但这两者基本上是两个极端。
数组

数组存储区间是连续的，占用内存严重，故空间复杂的很大。但数组的二分查找时间复杂度小，为O(1)；数组的特点是：寻址容易，插入和删除困难；
链表

链表存储区间离散，占用内存比较宽松，故空间复杂度很小，但时间复杂度很大，达O（N）。链表的特点是：寻址困难，插入和删除容易。

122 游标是什么

游标（cursor）是系统为用户开设的一个数据缓冲区，存放SQL语句的执行结果。每个游标区都有一个名字。用户可以用SQL语句逐一从游标中获取记录，并赋给主

变量，交由主语言进一步处理。
123 hashMap
Map map = new HashMap();
Iterator iter = map.entrySet().iterator();
while (iter.hasNext()) {
　　Map.Entry entry = (Map.Entry) iter.next();
　　Object key = entry.getKey();
　　Object val = entry.getValue();
}

125 多线程中的静态同步方法和非静态同步方法有什么区别

同步静态方法是对对应类的Class类加锁，这样的话，所有被synchronized修饰的静态方法同一时刻只能有一个被调用。同步非静态方法的话，它锁的是对应的示例

，并不影响其他示例(高度概括) 下面的是详解

所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待

获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁

的非静态同步方法释放锁就可以获取他们自己的锁。
而所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦

一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的

静态同步方法之间，只要它们同一个类的实例对象！
126 如何格式化时间
SimpleDateFormat timeDF=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String curTime=timeDF.format(new Date());
jsp中用<%=curTime %>
127 sql语句的优化
1SELECT子句中避免使用’*’
2 　当在SQL语句中连接多个表时, 请使用表的别名并把别名前缀于每个Column上.这样一来,就可以减少解析的时间并减少那些由Column歧义引起的语法错误.
3 分页的话不要查询所有的页
4

select id from t where num=10 or Name = 'admin'

替换成select id from t where num = 10
union all
select id from t where Name = 'admin'避免全表烧苗
5 不用“<>”或者“!=”操作符。对不等于操作符的处理会造成全表扫描，a<>0 改为a>0 or a<0
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。20170110
128 删除一个表中的重复记录
DELETE FROM EMP E WHERE E.ROWID > (SELECT MIN(X.ROWID)
FROM EMP X WHERE X.EMP_NO = E.EMP_NO);
129 CHAR的最大长度是2000，ORACLE最小的块大小通常是2K，这就保证不会有char类型超过2K的块大小。

131 temp=0
i = --temp;
i=-1

130
money=1245
int j = 1245%10;
运行的结果 j 分别为 5,4,2,1 数字倒叙一个个的输出
money /= 10;//第二个money运行的结果分别为 124,12,1

1 如果将一个类设置为abstract，则此类必须被继承使用。 Final和abstract永远不会同时出现。如果一个类中有一个抽象方法，那么这个类一定为一个抽象类

。反之，如果一个类为抽象类，那么其中可能有非抽象的方法。 Abstract和static不能放在一起，否则便会出现错误。（这是因为static不可被覆盖，而

abstract为了生效必须被覆盖。）

2 一个方法定义成静态的话，类名可以直接调用。

eg:
class MyClass
{
public static OracleDataReader getcom(string strSQL)

若采用如上写法，在程序中可以直接调用，不用进行实例化，即：MyClass.getcom(...) 可正常使用。

若在上述语句中，不写static, 则在程序中必须首先进行类的实例化，才能调用，而不能直接使用……

3 桥模式（Bridge）是为了解决将抽象部分与实现部分分离，好让他们都在自己的维度上有多维度地变化。这句话是好理解的.
适用性：一个构件有多于一个的抽象化角色和实现化角色，系统需要它们之间进行动态耦合。

4 oracle给一张表添加主键
alter table its_choice_relationship constraint pk_its_choice_relationship primary key (id_)

5 复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流。

6
static表示全局，final表示不可修改

7

装个firebug就什么都看得出来了，e只是一个常用的表示事件的形参，就像循环里面喜欢用i

12 什么是回调函数：打个比方我要用刀切西瓜，我没有自己切，而是把刀和切西瓜的方法给了别人，让别人切，

13 super就是子类调用父类的方法

14 　如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。

15 throws和throw的区别(面试题)
throws
用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常
throw
用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理
throw则是抛出了异常，执行throw则一定抛出了某种异常

public static void method2() throws Exception {
int a = 10;
int b = 0;
if (b == 0) {
throw new Exception();
} else {
System.out.println(a / b);
}
}

13
finally:被finally控制的语句体一定会执行
* 注意：如果在执行到finally之前jvm退出了，就不能执行了。catch{System.exit(0);}
try {
// System.out.println(10 / 0);
d = sdf.parse(s);
} catch (ParseException e) {
e.printStackTrace();
System.exit(0);
} finally {
System.out.println("这里的代码是可以执行的");
}

14
Union因为要进行重复值扫描，所以效率低。如果合并没有刻意要删除重复行，那么就使用Union All
两个要联合的SQL语句字段个数必须一样，而且字段类型要“相容”（一致）；
UNION去重且排序
UNION ALL不去重不排序

15 == 与equals的区别
equals是String类中的方法，表示两个字符串的内容相同。
==表示两个对象是同一个对象的引用，==null表示这个对象不是任何实例对象的引用，该对象为空。

16
./ 当前目录
../ 父级目录
/ 根目录

17
JS中的“&&”与“&”和“||”“|”有什么区别？

&&和||是逻辑运算的，返回的是boolean值，&和|是位运算的
他们最大的区别是，&& 和|| 是短路的，&和|不是短路的。
var a = 1;
var b = 1;
如if（a>2 && b<2) 和if(a>2 & b<2)
前者只会执行到a>2而b<2是不会执行的，返回false
后者执行a>2还会继续执行b<2,最终返回0
18
在js中'与"的区别

在js中单引号和双引号没有区别，都可以表示字符或字符串。
但是它们必须成对出现，不能前面用一个单引号，后面用一个双引号，这样会报错。
一般情况下，建议优先使用单引号包含字符串，这样做有几个好处：
html中标签的属性是用双引号包裹，在js中如果要动态输出html内容，则用单引号将整体html代码包裹起来，而标签中的属性刚好用双引号，避免了转义
编写代码时，双引号需要按shift才可以输入，无形之中降低了敲代码的速度
虽然在语法上，单引号和双引号没有区别，建议优先选用单引号，如何字符串内还有引号，再用双引号，必要的时候还需要用\进行转义

20
JS里的innerHTML怎么用

js的innerHTML和innerText比较相似，innerHTML指的是目标标签元素中所包含的html标签及内容，而innerText指的是目标标签中包含的文本内容。举例：

<div><a>百度</a></div>。以div为目标标签的话，那么取得的innerHTML则是：<a>百度</a>,而其innerText则是:百度。

21 路径的问题
绝对路径：是从盘符开始的路径，形如
C:\windows\system32\cmd.exe
相对路径：是从当前路径开始的路径，假如当前路径为C:\windows
要描述上述路径，只需输入
system32\cmd.exe
实际上，严格的相对路径写法应为
.\system32\cmd.exe
其中，.表示当前路径，在通道情况下可以省略，只有在特殊的情况下不能省略。
假如当前路径为c:\program files
要调用上述命令，则需要输入
..\windows\system32\cmd.exe
其中，..为父目录。
当前路径如果为c:\program files\common files
则需要输入
..\..\windows\system32\cmd.exe

另外，还有一种不包含盘符的特殊绝对路径，形如
\windows\system32\cmd.exe
无论当前路径是什么，会自动地从当前盘的根目录开始查找指定的程序。
。。。。。。。。。。。。。。。。。。
相对index.html所有的目录而言：
“../”表示上一级目录开始
“./”表示当前同级目录开始
“/”表示根目录开始。
参照app中的addressAddSingle.html

延：

当前文件的路径退两层可以找到pub
22 要想使用存储过程和函数，需要有存储过程和函数的所有者的授权，只有被授权的用户或创建者本身才能执行存储过程或调用函数。

23
months_between（两个日期之间相差了多少个月份）

months_between函数返回两个日期之间的月份数。如果两个日期月份内天数相同，或者都是某个月的最后一天，返回一个整数，否则，返回数值带小数，以每天

1/31月来计算月中剩余天数。
MONTHS_BETWEEN (x, y)用于计算x和y之间有几个月。如果x在日历中比y早，那么MONTHS_BETWEEN()就返回一个负数。
当x 和 y 之间的月份之差不是整月的时候，可以采用小数表示，例如
SELECT MONTHS_BETWEEN('25-MAY-2008', '15-JAN-2008')
FROM dual;
MONTHS_BETWEEN('25-MAY-2008','15-JAN-2008')
4.3型，不然会出现错误。须用to_date(‘’,'') 来转换为日期格式，才能参加计算。

24 什么是递归？
递归就是有一个方法，方法的实现还是调用这个方法例如求阶层的时候
public static int jieCheng(int n){
if(n==1){
return 1;
}else {
return n*jieCheng(n-1);
}
}

25
字节流：一次读入或读出是8位二进制。
字符流：一次读入或读出是16位二进制。
字节流和字符流的原理是相同的，只不过处理的单位不同而已。后缀是Stream是字节流，而后缀是Reader，Writer是字符流。

34 "" 与null的区别
1 ""是创建字符串对象，但是内容是空的，在内存中已经分配内存空间了。
而null是，未初始化，在内存中并没有分配内存空间。
另外你可以试一试，这个代码就清楚了！
String str1 = "";
String str2 = null;
Console.WriteLine(str1.Length);
Console.WriteLine(str2.Length);
2
NULL代表声明了一个空对象，根本就不是一个字符串。
""代表声明了一个对象实例，这个对象实例的值是一个长度为0的空字符串。

12 NULL代表声明了一个空对象,对空对象做任何操作都不行的,除了=和==
13 ""是一个字符串了,只是这个字符串里面没有内容了
14 15 String s=null;只是定义了一个句柄，也就是说你有了个引用，但是这个引用未指向任何内存空间
16 String s="";这个引用已经指向了一块是空字符串的内存空间，是一个实际的东东了，所以你可以对它操作，而不用担心什么了

26 哦,我明白了,意思就是String string = null 跟String string;是一回事儿
27 28 null是空对象 ""是空字符串
29 String s=null;//null是未分配堆内存空间 30 String a;//分配了一个内存空间,没存入任何对象 31 String a="";//分配了一个内存空间,存了一

个字符串对象 32
“”.equauals

正确的写法：if(condition==null || "".equals(condition)){

35Throwable中的方法
lprintStackTrace()
?获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

36
HTML DOM setInterval() 方法

setInterval() 方法可按照指定的周期（以毫秒计）来调用函数或计算表达式。
setInterval() 方法会不停地调用函数，直到 clearInterval() 被调用或窗口被关闭。由 setInterval() 返回的 ID 值可用作 clearInterval() 方法的参数。

以上内容以摘抄
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

150 spring aop的理解面向切面（与核心关系不大的，例如日志权限）是对面向对象（专注于核心功能）的补充与完善，aop就是讲各个模块需要重复写的部分

单独处理（单独写一个类）通过配置文件织入导各个模块
控制反转的理解：
1、其控制不反转：就是当A需要B时，A就要去new出B来，然后加入到A中。就是说这种本来应由自己实例化的工作交给Spring容器（xml）去控制了，也就是说控制

反转了,然后注入调用者，因此也称为依赖注入,这样就解耦了
依赖注入常用的包括两种：一种赋值注入（使用getter和setter方法）；另一种使用构造器注入。
2、控制反转：就是系统知道A需要B，会提前将B给A，不需要A再要了。

12月22日（以下的未抄）

151 索引的实现通常使用B树及其变种B+树（B+树每个叶子节点都有双向指针，方便实现各个叶子节点之间的快速检索。）。 B树其实是平衡（左右深度（它是一

棵空树或其左右两个子树的高度差的绝对值不超过1）近乎一致）的的多叉树，不仅是二叉树
152 什么是多态

不同类的对象对同一消息作出不同的响应就叫做多态。就像上课铃响了，上体育课的学生跑到操场上站好，上语文课的学生在教室里坐好一样。
3、父类引用指向子类对象，子类重写了父类的方法，调用父类的方法，实际调用的是子类重写了的父类的该方法。即Father f = new Children()，f.toString()

实际上调用的是Children中的toString()方法

153 @override 这个标记的作用
解释一：@override,表示此方法是实现或重写了父类的方法，不加也是可以的。

此注解的作用在于标记这个方法肯定是实现或重写父类的方法，在编译时，如果编译器发现此方法不是实现或重写，则会编译失败。

如父类中有个方法为 abc
而子类写了个方法为 abcd，而且加了overide注解，那么编译时就会提示错误信息
解释二：那个是注解，是给编译器看的，告诉编译器我下面写的代码是重写方法，让编译器检查，执行的时候不会执行注解代码

单引号与双引号的妙用
<jsp:param name="dqbmbh" value='<%=pshsdMaps.get(zdm)==null?"":pshsdMaps.get(zdm)%>' />

154 String 转double double 保留两位小数再转成String
double d=Double.parseDouble(fieldValue)*100;
DecimalFormat df = new DecimalFormat("#.00");
fieldValue=df.format(d)+"";
155 select 与opintion的用法
<select name="y_yhlx" style="width:50%">//这个有兼容性
<option value=""></option>
<%
//字典编码ZCYHLX
String yhlxSql = "select t1.sjbh t1sjbh,t1.sjmc t1sjmc from zc_sjzd t,zc_sjzdbm t1 where t1.zdbh =

'ZCYHLX' and t.zdbh = t1.zdbh order by t1.sjbh";
CachedRowSet rs = sdj.exeQuery(yhlxSql);
while(rs.next()){
String flbh = rs.getString("t1sjbh"); //分类编号
String flmc = rs.getString("t1sjmc"); //分类名称
if(yhlx.equals(flbh)){

%>
<option value='<%=flbh%>' selected><%=flmc%></option>
<%
}else {
%>
<option value='<%=flbh%>'><%=flmc%></option>
<%}}
%>
</select>

156 js

var a=document.all.LBBH.value.split("|");
if (a.length > 1){
document.all(""+LBBH).value = a[0];
document.all(""+LBBH).value = a[1];
}

157 String a[]=str.split(",");是什么意思

降str这个字符串用逗号“，”进行分割
分割后的字符串数组放在a[]中
比如 111,222,333
那么a[0]=111 a[1]=222 a[2]=333

158 i = --temp;// 先减去后在赋值

3/5 = 0 余（%） 3

159 Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。

注：主要是参数个数，与参数类型与返回值无关

160
String wids[];
if(wid.indexOf(",")!=-1){
wids=wid.split(",");
wid="";
for(int q =0;q<wids.length;q++){
wid+="'"+wids[q]+"',";
}
wid=wid.substring(0,wid.length()-1);
}

161 String sql = "select parent_msgid from zc_xxtz where msgid ='"+param+"' and parent_msgid <> ''";
CachedRowSet rs = sdj.exeQuery(sql);
if(rs.next()){
上面的这个东西如果查出来是空串就执行，如果是空就不会执行了

162 oracle dos登录 sqlplus scott/tiger@jiuhua
dos查看字符集 select userenv('language') from dual;
163 结构化程序设计所规定的三种基本控制结构是顺序、选择、循环

164 Java语言规定构造方法只能通过new自动调用

165 ．while循环判断条件一般是程序结果，for循环判断条件一般是非程序结果

166 double与float的区别

* java当中默认声明的小数是double类型的；
* double d=4.0
* 如果声明：
* float x = 4.0则会报错，需要如下写法：
* float x = 4.0f或者float x = (float)4.0
* 其中4.0f后面的f只是为了区别double，并不代表任何数字上的意义
*
* float 内存分配4个字节,占32位，有效小数位6-7位
* double 型内存分配8个字节，有效小数位15位
167 Java编程所必须的默认引用包为java.lang包搜索提供java语言编程核

168 . Boolean b=null; 这个写法是可以的

169 一个线程可以由就绪状态直接到达运行状态

170 ．Java是从（c++）语言改进重新设计。

171 Java程序经编译后会产生byte code

172 constructor在一个对象被new时执行

173 <>是SQL中的写法,JAVA用!=

174 声明抽象方法不可写出大括号 abstract不能修饰字段,抽象方法不用实现,不能用{}.

175 形式参数可被视为local variable 真正被传递的是实参,形参可以是对象,是对象的时候传递引用.

176 ．实例方法可直接调用本类的类方法

177 Java程序的种类有（bcd）
　　A．类（Class） B．Applet C．Application D．Servlet

178 在编译程序时，所能指定的环境变量不包括class path

179 JAVA命名规则:以大小写英文字母、数字、下划线“_”和美元符号“$”组成,且第一位不能为数字.

180 数组是一种对象原生类指未被实例化的类,数组一般指实例化,被分配空间的类,不属于原生类.

181 call by value数值拷贝不会改变实参内容, call by reference引用拷贝可以改变实参内容,但不会改变实参的引用地址.

182 【强制】POJO类中的任何布尔类型的变量，都不要加is，否则部分框架解析会引起序列化错误。反例：定义为基本数据类型boolean isSuccess；的属性，它

的方法也是isSuccess()，RPC框架在反向解析的时候，“以为”对应的属性名称是success，导致属性获取不到，进而抛出异常。
183 18.【推荐】final可提高程序响应效率，声明成final的情况： 1）不需要重新赋值的变量，包括类属性、局部变量。 2）对象参数前加final，表示不允许

修改引用的指向。 3）类方法确定不允许被重写。

184 10.【推荐】使用entrySet遍历Map类集合KV，而不是keySet方式进行遍历。说明：keySet其实是遍历了2次，一次是转为Iterator对象，另一次是从hashMap中

取出key所对应的value。而entrySet只是遍历了一次就把key和value都放到了entry中，效率更高。如果是JDK8，使用Map.foreach方法。正例：values()返回的是

V值集合，是一个list集合对象；keySet()返回的是K值集合，是一个Set集合对象；entrySet()返回的是K-V值组合集合。

185 11.【推荐】高度注意Map类集合K/V能不能存储null值的情况，如下表格：
集合类 Key Value Super 说明
Hashtable 不允许为null 不允许为null Dictionary 线程安全
ConcurrentHashMap 不允许为null 不允许为null AbstractMap 线程局部安全
TreeMap 不允许为null 允许为null AbstractMap 线程不安全
HashMap 允许为null 允许为null AbstractMap 线程不安全
反例：很多同学认为ConcurrentHashMap是可以置入null值。在批量翻译场景中，子线程分发时，出现置入null值的情况，但主线程没有捕获到此异常，导致排查

困难。

186

12.【参考】合理利用好集合的有序性(sort)和稳定性(order)，避免集合的无序性(unsort)和不稳定性(unorder)带来的负面影响。
阿里巴巴 JAVA 开发手册
12 / 32
说明：稳定性指集合每次遍历的元素次序是一定的。有序性是指遍历的结果是按某种比较规则依次排列的。如：ArrayList是order/unsort；HashMap是

unorder/unsort；TreeSet是order/sort。

187 13.【参考】利用Set元素唯一的特性，可以快速对另一个集合进行去重操作，避免使用List的contains方法进行遍历去重操作。

188 3. 【强制】SimpleDateFormat 是线程不安全的类，一般不要定义为static变量，如果定义为static，必须加锁，或者使用DateUtils工具类。正例：注意线

程安全，使用DateUtils。亦推荐如下处理： private static final ThreadLocal<DateFormat> df = new ThreadLocal<DateFormat>() { @Override protected

DateFormat initialValue() { return new SimpleDateFormat("yyyy-MM-dd"); } }; 说明：如果是JDK8的应用，可以使用instant代替Date，Localdatetime代替

Calendar，Datetimeformatter代替Simpledateformatter，官方给出的解释：simple beautiful strong immutable thread-safe。

189【强制】注意 Math.random() 这个方法返回是double类型，注意取值范围 0≤x<1（能够取到零值，注意除零异常），如果想获取整数类型的随机数，不要将x

放大10的若干倍然后取整，直接使用Random对象的nextInt或者nextLong方法。

190 说明：count(*)会统计值为NULL的行，而count(列名)不会统计此列为NULL值的行。

191 4. 【强制】使用ISNULL()来判断是否为NULL值。注意：NULL与任何值的直接比较都为NULL。

192 7. 【强制】禁止使用存储过程，存储过程难以调试和扩展，更没有移植性。

193 java的新生代与老生代（）

堆大小 = 新生代 + 老年代。默认下，新生代 ( Young ) = 1/3 的堆空间大小，老年代 ( Old ) = 2/3 的堆空间大小；

新生代 ( Young ) 被细分为 Eden 和两个 Survivor 区域，这两个 Survivor 区域分别被命名为 from 和 to，以示区分。默认的，Edem : from : to = 8 : 1 :

1；

JVM 每次只会使用 Eden 和其中的一块 Survivor 区域来为对象服务，所以无论什么时候，总是有一块 Survivor 区域是空闲着的。?因此，新生代实际可用的内存

空间为 9/10 ( 即90% )的新生代空间；

GC 分为两种：老生代中采用标记-清除算法的Full GC ( 或称为 Major GC )和新生代中采用复制算法的Minor GC。新生代是 GC 收集垃圾的频繁区域；

-Xms2000m -Xmx2000m -Xmn800m -XX:PermSize=64m -XX:MaxPermSize=256m
Xms，即为jvm启动时得JVM初始堆大小,Xmx为jvm的最大堆大小，xmn为新生代的大小，permsize为永久代的初始大小，MaxPermSize为永久代的最大空间。

194 java多线程都有几种方式实现？？

有三种：
(1)继承Thread类，重写run函数
创建：
class xx extends Thread{
public void run(){
Thread.sleep(1000)//线程休眠1000毫秒，sleep使线程进入Block状态，并释放资源
}}
开启线程：
对象.start() //启动线程，run函数运行
(2)实现Runnable接口，重写run函数
开启线程：
Thread t = new Thread(对象)//创建线程对象
t.start()
(3)实现Callable接口，重写call函数
Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。
Callable和Runnable有几点不同:
①Callable规定的方法是call()，而Runnable规定的方法是run().
②Callable的任务执行后可返回值，而Runnable的任务是不能返回值的
③call()方法可抛出异常，而run()方法是不能抛出异常的。
④运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。它提供了检查计算是否完成的方法,以等
待计算的完成,并检索计算的结果.通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果

195 原因是Oracle查询语句的执行顺序是：
FROM WHERE GROUP BY SELECT ORDER BY

196 having的作用是限制oracle 分组的条件

197 1 springmvc的配Location</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
用于配置spring mvc的配置文件的位置和名称，这里说明会新建一个springmvc.xml的配置文件，我们也可以不新建springmvc.xml，而是用默认的，默认的配置文

件格式为/WEB-INF/[servlet-name]-servlet.xml，对应这里的就是springDispatcherServlet-servlet.xml

2 这里的servlet-mapping表示拦截的模式，这里是“/”，表示对于所有的请求的拦截，包括静态资源如html, js, jpg等。这时候对于静态资源的访问就会报404

的错误。关于如何解决后面会介绍
<servlet-mapping>
20 <servlet-name>springDispatcherServlet</servlet-name>
21 <url-pattern>/</url-pattern>
22 </servlet-mapping>

而对于类似html/css/jpg等资源的访问就会得不到，所以需要在web.xml中加入以下类型的支持

复制代码
1 <servlet-mapping>
2 <servlet-name>default</servlet-name>
3 <url-pattern>*.css</url-pattern>
4 </servlet-mapping> 或者

在springDispatcherServlet-servlet.xml 加入


<mvc:resources location="/resources/" mapping="/resources/**"/>（resources包含 css等包）

198 拦截器：1 还可以用来转码过滤一些特殊字检测一个账号不能重复登录。看自己需求啊你只要明白你的每一个请求都会先进你写的拦截器在进入你写的方法
2 可作事还是挺多的，只要作的事跟请求和响应有关。例如：访问日志(记录访客的ip,来源),在线统计人数，字符集转换，身份验证
3 不破坏你的业务逻辑在你的业务之外做一些其他事情
4拦截器：是在面向切面编程的就是在你的service或者一个方法，前调用一个方法，或者在方法后调用一个方法比如动态代理就是拦截器的简单实现

，在你调用方法前打印出字符串（或者做其它业务逻辑的操作），也可以在你调用方法后打印出字符串，甚至在你抛出异常的时候做业务逻辑的操作。

199 代码块：在Java中，使用{}括起来的代码被称为代码块。
根据其位置和声明的不同，可以分为

局部代码块:局部位置（方法内）,用于限定变量的生命周期。
构造代码块:在类中的成员位置,用{}括起来的代码。每次调用构造方法执行前，都会先执行构造代码块。
作用：可以把多个构造方法中的共同代码放到一起，对对象进行初始化。
静态代码块:在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。
作用：一般是对类进行初始化。

首先执行静态代码块接着执行构造代码块最后指向构造方法兼顾父子（注意：父静态之后就是子静态）

200 js: var str="Visit Microsoft!"
document.write(str.replace(/Microsoft/, "W3School"))

</script>
输出：
Visit W3School!

201
mysql中varchar(6)代表可以存放6个汉字，6个字母，或6个数字。
oracle中varchar2(6)代表可以中存放6个字节。即oracle中varchar2的长度代表字节数而不是字符数。
mysql中一个汉字占三个字节，Oracle中一个汉字占两个字节。

202 double和float什么区别
对编程人员来说，double 和 float 的区别是double精度高，有效数字16位，float精度7位。但double消耗内存是float的两倍，double的运算速度比float慢得多

，C语言中数学函数名称double 和 float不同，不要写错，能用单精度时不要用双精度（以省内存，加快运算速度）

203 e1.printStackTrace(); 可以打印报错记录

204 rowNum 是行

205 服务器端包含客户端的功能，
客户端必须连接服务器才能使用
但是服务器可以连接自己使用

206 空值

207 redirect重定向特点：浏览器地址栏中的url会变化。修改提交的request数据无法传到重定向的地址。因为重定向后重新进行request（request无法共享）

通过forward进行页面转发，浏览器地址栏url不变，request可以共享。

在controller方法形参上可以定义request和response，使用request或response指定响应结果：
1、使用request转向页面，如下：
request.getRequestDispatcher("页面路径").forward(request, response);

2、也可以通过response页面重定向：
response.sendRedirect("url")

3、也可以通过response指定响应结果，例如响应json数据如下：
response.setCharacterEncoding("utf-8");
response.setContentType("application/json;charset=utf-8");
response.getWriter().write("json串");
208 spring将各层进行整合

第一步：整合dao层
mybatis和spring整合，通过spring管理mapper接口。
使用mapper的扫描器自动扫描mapper接口在spring中进行注册。

第二步：整合service层
通过spring管理 service接口。
使用配置方式将service接口配置在spring配置文件中。
实现事务控制。

第三步：整合springmvc
由于springmvc是spring的模块，不需要整合。

每层分别需要一个xml 进行管理

208 什么是sql注入

sql注入就是传入的wid的值不正确也能正确的下载

例如 http://localhost:8080/website/ywsp/lcpz/fjgl_downLoad.jsp?

Operation_Code=NET_WZ@XZ&Operation_Wid=201401030004447692&wid=201703310004450162'and'1'='1

这个例子中 wid的值是 201703310004450162'and'1'='1 wid不正确也能正常下载解决方案传？

209 imp WEB_TJCHSYS/WEB_TJCHSYS@jiuhua_zc full=y file=d:\net2017-03-31.dmp ignore=y

imp (数据库中的不是表中的)用户名/密码@数据库 full=y file=d:\net2017-03-31.dmp ignore=y
210 增加表字段

alter table （用户名）WEB_TJCHSYS.zc_ywfj add ljdz varchar2(100);

211 异常：is quoted with " which must be escaped when used within the value

在 D:\apache\Tomcat6\conf\catalina.properties 下面添加一句话即可 org.apache.jasper.compiler.Parser.STRICT_QUOTE_ESCAPING=false

或者 String eee="inverseFun('"+tableName+"_table','listFrame');"; 单独写出来赋值

212 搞一个 null 与 ‘’ 的区别

string 类型可以是null 或者 ‘’

但是 map 之类的只能是 null 因为 '' 是String类型的

213 字符串.length() 数组.length
214 oracle中Blob和Clob类型的区别与用法

。但是为了更好的管理ORACLE数据库，通常像图片、文件、音乐等信息就用BLOB字段来存储，先将文件转为二进制再存储进去。而像文章或者是较长的文字，就用

CLOB存储，这样对以后的查询更新存储等操作都提供很大的方便。

215 为什么打印一个对象是输出地址值，打印字符串是输出字符串

因为所有类都是继承object object里面的tostring方法是打印的地址值，string 类继承object 重写他的tostring

216 constructor在一个对象被new时执行，它本身就是一个构造方法

219 在编译程序时，所能指定的环境变量不包括class path ;javac一次可同时编译数个Java源文件;javac.exe能指定编译结果要置于哪个目录（directory）

220 下列运算符合法的是 &&

221 实例方法可直接调用本类的类方法

222 ，forward更加高效，在前者可以满足需要时，尽量使用forward()方法，并且，这样也有助于隐藏实际的链接。在有些情况下，比如，需要跳转到一个其它服

务器上的资源，则必须使用sendRedirect()方法

223 jsp有哪些内置对象?作用分别是什么?
JSP共有以下9种基本内置组件（可与ASP的6种内部组件相对应）：
　request 该对象代表了客户端的请求信息，，此请求会包含来自GET/POST请求的参数
response response代表的是对客户端的响应它只在JSP页面内有效。
pageContext 网页的属性是在这里管理
session 与请求有关的会话期 session对象内部使用Map类来保存数据
application application对象可将信息保存在服务器中，直到服务器关闭
out 用来传送回应的输出
config 对象的主要作用是取得服务器的配置信息。开发者可以在web.xml 文件中为应用程序环境中的Servlet程序和JSP页面提供初始化参数。
page JSP网页本身
exception ，只有在包含 isErrorPage="true"的页面中才可以被使用

224说一说Servlet的生命周期

Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服

务器决定将实例销毁的时候调用其destroy方法。

执行servlet的过程，它首先会编译成.class文件，由jvm加载到web容器中（如tomcat，resin）
当有人调用它的时候，首先会执行它自己的构造方法，接着初始化调用init（）方法，之后根据页面的请求方式
（get or post）调用它的doGet（）或者 doPost（）方法。（当Servlet中有doGet（）或者doPost（）
方法时，那么service（）方法就可以省略，默认为调用这两个方法）最后当servlet终止的时候调用它的destory（

225实例就是对象

226JSP和Servlet有哪些相同点和不同点，他们之间的联系是什么？
JSP是Servlet技术的扩展，本质上是Servlet的简易方式 JSP侧重于视图，Servlet主要用于控制逻辑。

227 简述你对Statement,PreparedStatement,CallableStatement的理解
statement用于执行静态 SQL 语句并返回它所生成结果的对象，在执行时确定sql。

PreparedStatement表示预编译的 SQL 语句的对象。 SQL 语句被预编译并且存储在 PreparedStatement 对象中。然后可以使用此对象高效地多次执行该语句，可

以传参数，在得到PreparedStatement对象时确定sql.
CallableStatement用于执行 SQL 存储过程的接口。如果有输出参数要注册说明是输出参数。

228 xml有哪些解析技术?区别是什么?
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适

合对XML的随机访问
SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时

，它会触发一个事件，用户通过在其回

调事件中写入处理代码来处理XML文件，适合对XML的顺序访问
STAX:Streaming API for XML (StAX)

229 Socket基本函数

socket()、bind()、listen()、connect()（客户端）、accept()（服务器端）

230[ UNSIGNED ] 无符号的 SMALLINT 值范围是 0 到 2^16 – 1，即 0 到 65535。

ceate table user{user_id int unsigned}
当中的unsigned表示，数据项user_id恒为正整数。

231 .string类的常用方法有哪些？

length（） index of(查找该字符创第一次出现的位置) subString split trim()去除了前后空格的字符创 equals

232 String,StringBuffer,StringBuilder的区别。
String 字符串常量线程安全操作少量数据
StringBuffer 字符串变量线程安全操作大量数据速度慢多线程适合用
StringBuilder 字符串变量线程不安全操作大量数据速度快单线程适合用

233 String str = new String(“xyz”);创建了几个对象。

如果String常量池中，已经创建了"xyz",则不会继续创建，此时直创建了一个对象new String("xyz");
如果String常量池中没有创建"xyz",则会创建两个对象，一个对象的值是"xyz",一个对象是new String("xyz");

234 .说几个你常见到的异常。

Throwable是所有异常的根，java.lang.Throwable
Error是错误，java.lang.Error
Exception是异常，java.lang.Exception
一般分为Checked异常和Runtime异常，所有RuntimeException类及其子类的实例被称为Runtime异常，不属于该范畴的异常则被称为CheckedException。
NullPointerException 空指针异常
ArithmeticException 除0异常
ClassCastException 类型转换
ArrayIndexOutOfBoundsException 数组越界异常

235 hashtable和hashmap的区别是什么？

hashmap 线程不安全效率高允许空建和空值是hashtable的轻量级实现方法不是synchronized的要提供外同步有contiansvalue 和containskey方法

hashmap是java1.2引进的Map interface的一个实现

hashTable 线程安全不允许有null的建和值效率稍低方法是Syschronize的有contains方法 hashTable继承与Dictionary类比hashmap要先出现

236 Vector 和 ArrayList 的区别都是顺序存储底层数组实现

2379.说一下list，set，map的区别。

Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的
HashCode决定的，其位置其实是固定的）
LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身内存地址的同时还存储下一个元素的
地址
Set接口有两个实

现类：HashSet(底层由HashMap实现)，LinkedHashSet
SortedSet接口有一个实现类：TreeSet（底层由平衡二叉树实现）

238 用多线程只有一个目的，那就是更好的利用cpu的资源

239多线程会遇到那些问题？怎么解决死锁？

并发，死锁
可以通过加同步、上锁解决死锁问题。

240 .至少说六点interface和abstract的区别。

1.相同点
A. 两者都是抽象类，都不能实例化。
B. interface实现类及abstrctclass的子类都必须要实现已经声明的抽象方法。

2. 不同点
A. interface需要实现，要用implements，而abstract class需要继承，要用extends。
B. 一个类可以实现多个interface，但一个类只能继承一个abstract class。
C. interface强调特定功能的实现，而abstractclass强调所属关系。
D. 尽管interface实现类及abstrct class的子类都必须要实现相应的抽象方法，但实现的形式不同。
interface中的每一个方法都是抽象方法，都只是声明的(declaration,没有方法体)，实现类必须要实
现。而abstractclass的子类可以有选择地实现。
这个选择有两点含义：
一是Abastract class中并非所有的方法都是抽象的，只有那些冠有abstract的方法才是抽象的，子类
必须实现。那些没有abstract的方法，在Abstrct class中必须定义方法体。
二是abstract class的子类在继承它时，对非抽象方法既可以直接继承，也可以覆盖；而对抽象方法，
可以选择实现，也可以通过再次声明其方法为抽象的方式，无需实现，留给其子类来实现，但此类必须
也声明为抽象类。既是抽象类，当然也不能实例化。
E. abstract class是interface与Class的中介。
interface是完全抽象的，只能声明方法，而且只能声明pulic的方法，不能声明private及protected的方
法，不能定义方法体，也不能声明实例变量。然而，interface却可以声明常量变量，并且在JDK中不难找
出这种例子。但将常量变量放在interface中违背了其作为接口的作用而存在的宗旨，也混淆了interface与
类的不同价值。如果的确需要，可以将其放在相应的abstractclass或Class中。
abstract class在interface及Class中起到了承上启下的作用。一方面，abstract class是抽象的，可以声明
抽象方法，以规范子类必须实现的功能；另一方面，它又可以定义缺省的方法体，供子类直接使用或覆
盖。另外，它还可以定义自己的实例变量，以供子类通过继承来使用。

3. interface的应用场合
A. 类与类之前需要特定的接口进行协调，而不在乎其如何实现。
B. 作为能够实现特定功能的标识存在，也可以是什么接口方法都没有的纯粹标识。
C. 需要将一组类视为单一的

241 查找出字符串中的数字
zifuchuang.charAt(i)>48&&zifuchuang.charAt(i)<57

242 <div><span>1</span><span>2</span><span>3</span></div>如何获取第二个span的值？

alert($("div span:nth-child(2)").html())

243 get和post有什么区别？
(1)GET通常用于从服务器上获取数据，POST用于向服务器传送数据。

(2)GET请求提交的数据放置在URL中，而POST提交的数据则放在BODY体中。

(3)GET传送的数据量较小，POST传送的数据量较大，主要受限于服务器的处理能力。

(在FORM提交的时候，如果不指定Method，则默认为GET请求(.net默认是POST)，Form中提交的数据将会附加
在url之后，以?分开与url分开。字母数字字符原样发送，但空格转换为“+”号，其它符号转换为%XX,其中XX为

243 请使用jQuery将页面上的所有元素边框设置为2px宽的虚线。

$ ("*").css ("border", "2px dashed");

244 如何用jQuery禁用浏览器的前进后退按钮？
/*原理：用户点击后退时产生一个前进的动作，然后就能抵消啦*/
window.history.forward(1); 或者 window.history.forward(-1);

245 请写出手机号的正则表达式。

js Demo:
var reg = /^[1][3-8]\\d{9}$/;
boolean b = reg.test(str);

Java Demo:
String str = "13945678956";
String regEx = "^[1][3-8]\\d{9}$";
// 编译正则表达式
Pattern pattern = Pattern.compile(regEx);
Matcher matcher = pattern.matcher(str);
// 字符串是否与正则表达式相匹配
boolean rs = matcher.matches();
System.out.println(rs);

246 ajax是如何传递数据的？他是同步的还是异步的？怎么实现同步？

常见的可以选择以纯文本和XML作为数据格式（您可以参考jquery下的ajax）,现在还有一种比较流行的方式：
JSON（JavaScript Object Notation）
默认是异步
可以通过修改async属性设置为false实现同步

247 webservice

httpservice通过post和get得到你想要的东西
webservice就是使用soap协议得到你想要的东西，相比httpservice能处理些更加复杂的数据类型 http协议传输的都是字符串了，webservice则是包装成了更复杂

的对象。

248 在SSM框架中，用什么处理事务。
在Spring中庸注解配置事务，xml中配置transactionManager，需要处理事务的方法上加上注解@Transactional

249 spring是怎么链接数据

1 使用apache的dbcp插件连接数据库需要下载的jar包：commons-dbcp.jar，commons-pool.jar,commons-col public和privatelection.jar

2 c3p0

250 一个大文件，上传到一半的时候网断了，想在接下来继续从断点开始上传，怎么做？
]

断点续传指的是在下载或上传时，将下载或上传任务（一个文件或一个压缩包）人为的划分为几个部分，每一个部
分采用一个线程进行上传或下载，如果碰到网络故障，可以从已经上传或下载的部分开始继续上传下载以后未上传
下载的部分

250 对扩展开放，对修改关闭，开闭原则 public和private

251 jvm何时对类进行初始化及创建类实例的几种方法

初始化必须发生在装载、连接以后，Java虚拟机一般会在每个类或接口主动使用时才会对类型进行初始
化。下面六中情形符合主动使用的要求：
1.当创建某个类的新实例时。注：包括创建的所有方式，如new、反射、克隆以及反序列化等
2.当调用某个类的静态方法时
3.当使用某个类或接口的静态字段，或对该静态非常量字段进行赋值时。注意：用final修饰的静态
字段除外，因为在编译阶段时，它就被替换成一个常量表达式
4.调用Java API中的某些反射方法时，比如类Class中的方法或java.lang.reflect包中的方法
5.初始化某个类的子类时（某个类初始化时，要求它的超类已经被初始化了）
6.虚拟机启动时，包含有main方法的类

补充：创建类的新实例的方式主要有四种：
1.明确使用new操作符
2.调用Class或Constructor对象的newInstance()方法
3.调用现有对象的clone()方法
4.通过java.io.ObjectInputStream类的getObject()方法反序列化?

252 java基础知识 if 中break 与continue的用法

if的break与continue

break 跳出 if循环

continue 跳出i执行 i+1

253 集合不见得都是设置为空好

List wordList = new ArrayList();

List wordList =null; 如果这样调用就没分配内存空间用的时候可能报null异常

254 String 的==与 equals

1 String既可以作为一个对象来使用，又可以作为一个基本来使用
基本类型: String s = "Hello"，它的使用方法如同基本类型int一样，比如int i = 1;其动作就是new String("Hello");。只会写入到常量池，独立的
对象: 比如String s = new String("Hello")。则是指通过new关键字来创建一个新对象，但是它的内部动作其实还是创建了一个对象，即为此对象分配一块新

的内存堆，并且它并不是String缓冲池所拥有的，即它是独立的。

final的值在编译是就确定了
所以此时 a+b 对编译器来说就是“ab”

2 比较

：一种是用"=="来比较，这种比较是针对两个String类型的变量的引用，也就是说如果两个String类型的变量，它们所引用同一个String对象(即指向同一块内存堆

)，则"=="比较的结果是true。

针对String作为一个基本类型来使用：
1。如果String作为一个基本类型来使用，那么我们视此String对象是String缓冲池所拥有的。
2。如果String作为一个基本类型来使用，并且此时String缓冲池内不存在与其指定值相同的String对象，那么此时虚拟机将为此创建新的String对象，并存放在

String缓冲池内。
针对String作为一个对象来使用：
1。如果String作为一个对象来使用，那么虚拟机将为此创建一个新的String对象，即为此对象分配一块新的内存堆，并且它并不是String缓冲池所拥有的，即它是

独立的。

255 多态的定义：
同一事件在不同对象上会产生不同的结果。比方说按下 F1 键这个动作，

256 建立文件 "file.txt" 的字节输入流的语句是：（ A ）

InputStream in=new FileInputStream("file.txt");

257 1 col-md-10 div的宽度

2 页面数据加载前需要先把样式引进来，这就是自己样式不对的原因

258 21 下面的都不能强制回收垃圾
1 null 当一个对象为null时垃圾回收线程会不定期的进行回收。
2 System.gc() 等于告诉他我这里有垃圾仅此而已。 Runtime.getRuntime().gc()
3 需要注意的是：垃圾回收回收的是无任何引用的对象占据的内存空间而不是对象本身

259 spring
Bean有两种基本行为：
Singleton：单态（默认）
non-Singleton 或ProtoType原型

260 hasnMap 线程不安全

concurrenthashmap 线程安全从ConcurrentHashMap代码中可以看出，它引入了一个“分段锁”的概念，具体可以理解为把一个大的Map拆分成N个小的

HashTable，根据key.hashCode()来决定把key放到哪个HashTable中。

LinkedHashMap有序

261
sql 语句中的 (+) 是什么意思？

在select语句中（+）指的是外连接，是连接查询的一种方法。
例：select t1.*,t2.* from dept t1,emp t2 where t1.deptno=t2.deptno(+);
其中：t1.deptno=t2.deptno(+)代表意思是，即使t2(emp表)中不存在匹配的记录，在t1(dept表)也查询出来。

(+)就是连接
譬如
SELECT a.*, b.* from a(+) = b就是一个右连接，等同于select a.*, b.* from a right join b
SELECT a.*, b.* from a = b(+)就是一个左连接，等同于select a.*, b.* from a left join b

262 mysqls的缓存

1 resultMap可以实现延迟加载，resultType无法实现延迟加载。

2 resultMap定义
<resultMap type="cn.itcast.mybatis.po.Orders" id="OrdersAndOrderDetailResultMap" extends="OrdersUserResultMap">
 也就是说不用重复写了

3 <collection property="orderdetails" ofType="cn.itcast.mybatis.po.Orderdetail">
collection：对关联查询到多条记录映射到集合对象中（list类型的）
property：将关联查询到多条记录映射到cn.itcast.mybatis.po.Orders哪个属性（某个属性值）
ofType：指定映射到list集合属性中pojo的类型（哪个pojo）

4 字段起别名的目的是因为很多字段都可能是id

5 使用association和collection完成一对一和一对多高级映射（对结果有特殊的映射要求）。

association：
作用：
将关联查询信息映射到一个pojo对象中。
collection：
作用：
将关联查询信息映射到一个list集合中。
association、collection具备延迟加载功能。

延迟加载详解：传一个关联的列 column="user_id" 即可


<resultMap type="cn.itcast.mybatis.po.Orders" id="OrdersUserLazyLoadingResultMap">

<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>

<association property="user" javaType="cn.itcast.mybatis.po.User"
select="cn.itcast.mybatis.mapper.UserMapper.findUserById" column="user_id">


</association>

</resultMap>


<select id="findOrdersUserLazyLoading" resultMap="OrdersUserLazyLoadingResultMap">
SELECT * FROM orders
</select>

SqlMapConfig.xml
<settings>

<setting name="lazyLoadingEnabled" value="true"/>

<setting name="aggressiveLazyLoading" value="false"/>

<setting name="cacheEnabled" value="true"/>
</settings>

6 缓存在对象中有一个数据结构（HashMap）用于存储缓存数据

一级缓存是SqlSession级别的缓存。默认开启

如果sqlSession去执行commit操作（执行插入、更新、删除），清空SqlSession中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。

二级缓存是mapper级别的缓存。需要设置多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。
UserMapper有一个二级缓存区域（按namespace分）
，两个mapper的namespace如果相同，这两个mapper执行sql查询到数据将存在相同的二级缓存区域中。

除了在SqlMapConfig.xml设置二级缓存的总开关，还要在具体的mapper.xml中开启二级缓存。
userMapper3.updateUser(user);
//执行提交，清空UserMapper下边的二级缓存

<select id="findOrderListResultMap" resultMap="ordersUserMap" useCache="false">

总结：针对每次查询都需要最新的数据sql，要设置成useCache=false，禁用二级缓存。

<insert id="insertUser" parameterType="cn.itcast.mybatis.po.User" flushCache="true">

总结：一般下执行完commit操作都需要刷新缓存，flushCache=true表示刷新缓存，这样可以避免数据库脏读。

7.5 二级应用场景

对于访问多的查询请求且用户对查询结果实时性要求不高，此时可采用mybatis二级缓存技术降低数据库访问量，提高访问速度，业务场景比如：耗时较高的统计分

析sql、电话账单查询sql等。

263
sql 语句的执行顺序 from->table->join->on->where-group by->having>select

264 ajax 的底层实现

ajax 的全称是AsynchronousJavaScript and XML，其中，Asynchronous 是异步的意思，它有别于传统web开发中采用的同步的方式。

如果是异步通信方式(true)，客户机就不等待服务器的响应；如果是同步方式(false)，客户机就要等到服务器返回消息后才去执行其他操作。

实现了客户端与服务器进行数据交流过程。使用技术的好处是：不用页面刷新，并且在等待页面传输数据的同时可以进行其他操作。

那Ajax是如何从浏览器发送Http请求到服务器呢？

这就得使用一个重要的对象XMLHttpRequest。

那首先了解一下XMLHttpRequest对象的属性和方法。

主要的属性：

readyState属性有五个状态值。

0：是uninitialized，未初始化。已经创建了XMLHttpRequest对象但是未初始化。
1：是loading，send for request but not called .已经开始准备好要发送了。
2：是loaded, send called,headers and status are available。已经发送，但是还没有收到响应。
3：是interactive，downloading response,but responseText only partial set.正在接受响应，但是还不完整。
4：是completed，finish downloading.接受响应完毕。

265 SpringMVC与Struts2区别与比较总结

1 Struts2是类级别的拦截， SpringMVC是方法级别的拦截，

2 拦截器实现机制上，Struts2有以自己的interceptor机制，SpringMVC用的是独立的AOP方式，这样导致Struts2的配置文件量还是比SpringMVC大。

3 SpringMVC的入口是servlet，而Struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这就导致了二者的机制不

同，这里就牵涉到servlet和filter的区别了。

4 SpringMVC集成了Ajax，使用非常方便，只需一个注解@ResponseBody就可以实现，然后直接返回响应文本即可，而Struts2拦截器集成了Ajax，在Action中处理时

一般必须安装插件或者自己写代码集成进去，使用起来也相对不方便。

5 SpringMVC验证支持JSR303，处理起来相对更加灵活方便，而Struts2验证比较繁琐，感觉太烦乱。

6 SpringMVC支持单例或多例,默认单例,Struts2只能多例,

1、Struts2是类级别的拦截，一个类对应一个request上下文，SpringMVC是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应,所

以说从架构本身上SpringMVC就容易实现restful url,而struts2的架构实现起来要费劲，因为Struts2中Action的一个方法可以对应一个url，而其类属性却被所有

方法共享，这也就无法用注解或其他方式标识其所属方法了。
2、由上边原因，SpringMVC的方法之间基本上独立的，独享request response数据，请求数据通过参数获取，处理结果通过ModelMap交回给框架，方法之间不共享

变量，而Struts2搞的就比较乱，虽然方法之间也是独立的，但其所有Action变量是共享的，这不会影响程序运行，却给我们编码读程序时带来麻烦，每次来了请

求就创建一个Action，一个Action对象对应一个request上下文。
3、由于Struts2需要针对每个request进行封装，把request，session等servlet生命周期的变量封装成一个一个Map，供给每个Action使用，并保证线程安全，所以

在原则上，是比较耗费内存的。
4、拦截器实现机制上，Struts2有以自己的interceptor机制，SpringMVC用的是独立的AOP方式，这样导致Struts2的配置文件量还是比SpringMVC大。
5、SpringMVC的入口是servlet，而Struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这就导致了二者的机制

不同，这里就牵涉到servlet和filter的区别了。
6、SpringMVC集成了Ajax，使用非常方便，只需一个注解@ResponseBody就可以实现，然后直接返回响应文本即可，而Struts2拦截器集成了Ajax，在Action中处理

时一般必须安装插件或者自己写代码集成进去，使用起来也相对不方便。
7、SpringMVC验证支持JSR303，处理起来相对更加灵活方便，而Struts2验证比

较繁琐，感觉太烦乱。
8、spring MVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高（当然Struts2也可以通过不同的目录结构和相关配置做到SpringMVC一样的效果，但

是需要xml配置的地方不少）。
9、设计思想上，Struts2更加符合OOP的编程思想， SpringMVC就比较谨慎，在servlet上扩展。
10、SpringMVC开发效率和性能高于Struts2。
11、SpringMVC可以认为已经100%零配置。

7 说说对redis的理解

1 内存 Redis以内存作为数据存储介质，所以读写数据的效率极高，远远超过数据库。

2 持久化因为Redis的存储分为内存存储、磁盘存储和log文件三部分，重启后，Redis可以从磁盘重新将数据加载到内存中，这些可以通过配置文件对其进行配置

，正因为这样，Redis才能实现持久化。

3 频繁调取的因为Redis交换数据快，所以在服务器中常用来存储一些需要频繁调取的数据，这样可以大大节省系统直接读取磁盘来获得数据的I/O开销，更重要的

是可以极大提升速度。

拿大型网站来举个例子，比如a网站首页一天有100万人访问，其中有一个板块为推荐新闻。要是直接从数据库查询，那么一天就要多消耗100万次数据库请求。上面

已经说过，Redis支持丰富的数据类型，所以这完全可以用Redis来完成，将这种热点数据存到Redis（内存）中，要用的时候，直接从内存取，极大的提高了速度和

节约了服务器的开销。

265 TIMESTAMP和DATETIME的区别（年限的范围；时区；insert;update）
1. 存储空间不同
a) TIMESTAMP占用4个字节

b) DATETIME占用8个字节

2. 受时区影响
c) TIMESTAMP实际记录的是1970-01-01 00:00:01到现在的数数，受时区影响

d) DATETIME不受时区影响

3. 时间范围不同
e) TIMESTAMP的时间范围是：'1970-01-01 00:00:01' UTC ~ '2038-01-19 03:14:07' UTC

f) DATETIME的时间范围是：'1000-01-01 00:00:00' ~ '9999-12-31 23:59:59'

4. 自动更新
g) TIMESTAMP类型在默认情况下，insert、update 数据时，TIMESTAMP列会自动以当前时间（CURRENT_TIMESTAMP）填充/更新。

5. Mysql中，TIMESTAMP和long之间的转换函数：
h) TIMESTAMP转long：UNIX_TIMESTAMP

i) long转TIMESTAMP：FROM_UNIXTIME

266 mysql用 unsigned int 存储ip地址

当前很多应用都适用字符串char(15)来存储IP地址（占用16个字节），利用inet_aton()和inet_ntoa()函数，来存储IP地址效率很高，适用unsigned int 就可以满

足需求，不需要使用bigint，只需要4个字节，节省存储空间，同时效率也高很多
insert into jackbillow values(inet_aton('192.168.1.200'), 'A'), (inet_aton('200.100.30.241'), 'B');

mysql> select inet_ntoa(ip) from jackbillow;
+----------------+
| inet_ntoa(ip) |
+----------------+
| 192.168.1.200 |
| 200.100.30.241 |
| 24.89.35.27 |
| 100.200.30.22 |

267 构造方法：

Java语言规定构造方法没有返回值，但不用void声明
Java语言规定构造方法只能通过new自动调用
Java语言规定构造方法可以重载

268 ．Java Application与Applet所用编译命令相同
．通常情况下，Java Application只能有一个main()方法
Java Applet必须有HTML文件才能运行
Java Applet程序的.class文件可用Java命令运行（这句话事错误的）

269 Swing的选项面板是 JtabbedPane

270 用鼠标点击菜单项（MenuItem）产生的事件是 ActionEvent

271 单精度数的是 0.2f

272 Java类库中，将信息写入内存的类是 java.io.ByteArrayOutPutStream

273 >>> 无符号右移 4>>>2 结果1

274 运算符优先级 ++ 的仅次于 .( )[ ]+-

275 线程从运行状态进入阻塞状态 wait

276 新建的线程调用start()方法不能立即进入运行状态。

277 当 run 方法终止时，能使线程进入死亡状态。

278 . 线程通过 yield 方法可以使具有相同优先级线程获得处理器

279 1 NoSQL，泛指非关系型的数据库，NoSQL即Not-Only SQL，它可以作为关系型数据库的良好补充。

2 Nosql数据库分类
键值(Key-Value)存储数据库
相关产品： Tokyo Cabinet/Tyrant、Redis、Voldemort、Berkeley DB
典型应用：内容缓存，主要用于处理大量数据的高访问负载。
数据模型：一系列键值对
优势：快速查询
劣势：存储的数据缺少结构化

列存储数据库
相关产品：Cassandra, HBase, Riak
典型应用：分布式的文件系统
数据模型：以列簇式存储，将同一列数据存在一起
优势：查找速度快，可扩展性强，更容易进行分布式扩展
劣势：功能相对局限
文档型数据库
相关产品：CouchDB、MongoDB
典型应用：Web应用（与Key-Value类似，Value是结构化的）
数据模型：一系列键值对
优势：数据结构要求不严格
劣势：查询性能不高，而且缺乏统一的查询语法
图形(Graph)数据库
相关数据库：Neo4J、InfoGrid、Infinite Graph
典型应用：社交网络
数据模型：图结构
优势：利用图结构相关算法。
劣势：需要对整个图做计算才能得出结果，不容易做分布式的集群方案。
3 redis的应用场景
缓存（数据查询、短连接、新闻内容、商品内容等等）。（最多使用）

280 jvm何时对类进行初始化及创建类实例的几种方法

初始化必须发生在装载、连接以后，Java虚拟机一般会在每个类或接口主动使用时才会对类型进行初始
化。下面六中情形符合主动使用的要求：
1.当创建某个类的新实例时。注：包括创建的所有方式，如new、反射、克隆以及反序列化等
2.当调用某个类的静态方法时
3.当使用某个类或接口的静态字段，或对该静态非常量字段进行赋值时。注意：用final修饰的静态
字段除外，因为在编译阶段时，它就被替换成一个常量表达式
4.调用Java API中的某些反射方法时，比如类Class中的方法或Java.lang.reflect包中的方法
5.初始化某个类的子类时（某个类初始化时，要求它的超类已经被初始化了）
6.虚拟机启动时，包含有main方法的类

补充：创建类的新实例的方式主要有四种：
1.明确使用new操作符
2.调用Class或Constructor对象的newInstance()方法
3.调用现有对象的clone()方法
4.通过java.io.ObjectInputStream类的getObject()方法反序列化?
281 单例模式就像一个黑板公用的而且只有一个

281 回调函数其实就是委托自己能自己实现确把引用给别人让别人实现，自己可以干别的事

JAVA中，回调方法是这么实现的：
（1）A先写一个方法
（2）A把自己的实例传给B
（3）B写一个方法，该方法利用传进来的A的实例调用A之前写的方法

此时，（1）中A写的方法，就可以叫做回调方法了。

281 过滤器与拦截器的区别
　①拦截器是基于Java的反射机制的，而过滤器是基于函数回调。
　　②拦截器依赖spring容器，过滤器依赖与servlet容器。
3action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。

282 .try+finally 遇到异常就不会执行finally了
运行流程：运行到try块中,如果有异常抛出的话，程序转向执行finally块的代码。那末finally块后面的代码还会被执行吗？不会！因为你没有处理异常，所以遇

到异常后，执行完finally后，方法就以抛出异常的方式退出。
这种方式中要注意的是，由于你没有捕获异常，所以要在方法后面声明抛出异常。

283 禁止表单重复提交

阅读全文

0 0