2023年开发人员面试宝典Java版.docx

开发人员面试宝典
（Java版）

八维云计算学院
2023-3-24

目录
1 基础篇 6
1.1 Java介绍 6
1.2 J2SE、J2EE、J2ME三者区别 6
1.3 JDK、JRE、JVM区别 6
1.4 JDK常用的包 7
1.5 Java中的基本数据类型 7
1.6 Java中switch接受的几种数据类型 8
1.7 String、StringBuffer、StringBuilder区别 8
1.8 Char型变量能不能存储一个汉字？ 8
1.9 ==和equals方法的区别 8
1.10 静态变量和实例变量的区别 9
1.11 Integer和int的区别 9
1.12 Math.round()的使用 9
1.13 构造器是否可以被重写 9
1.14 抽象类和接口的区别 9
1.15 新建对象有几种方式 10
1.16 &和&&的区别 10
1.17 面向对象什么特性 11
1.18 面向对象中多态特性 11
1.19 List,set,Collection,Collections 11
1.20 线程和进程的区别 11
1.21 Jvm内存结构 12
1.22 内存泄露和内存溢出 12
1.23 解析xml文献的几种技术 12
1.24 Dom4j与sax之间的对比 13
1.25 java Exception体系结构 13
1.26 抽象类和接口的区别 14
1.27 修饰符的作用 14
1.28 HashMap和Hashtable的区别 14
1.29 字节流和字符流的区别 15
1.30 运营异常和检查异常有何不同 15
1.31 error和exception的区别 15
1.32 举例最常用的五个运营时异常 15
1.33 Sleep和wait的区别 15
1.34 多线程有几种实现方式 16
1.35 启动一个线程用run还是start 16
1.36 List和Map的区别 16
1.37 说出ArrayList,Vector, LinkedList的存储性能和特性 17
1.38 Java序列化 17
1.39 堆和栈的区别 17
1.40 什么时候用断言 17
1.41 Java中会有内存泄露吗 18
1.42 简述反射的作用 18
2 Servlet篇 19
2.1 Servlet概述 19
2.2 九大隐式对象 20
2.3 page和pageContext的区别 20
2.4 GET和POST的区别 20
2.5 转发与重定向的区别 20
2.6 四大作用域介绍 21
2.7 session和cookie的区别 21
2.8 request和session的区别 21
2.9 报错状态码 22
2.10 常见协议及默认的端标语 22
2.11 对过滤器的理解 22
3 脚本篇 23
3.1 onready和onload的区别 23
3.2 对jQuery简朴介绍 23
3.3 XML和Json的特点 23
3.4 对JQuery中Ajax介绍 24
3.5 对Ajax介绍 24
4 框架篇 25
4.1 Struts1运营原理 25
4.2 Struts2运营原理 25
4.3 Hibernate运营原理 26
4.4 Spring运营原理 27
4.5 SpringMVC运营原理 27
4.6 Struts1和Struts2区别 28
4.7 SpringMVC、Struts1和Struts2区别 29
4.8 Struts2在的type类型 29
4.9 Struts2的常用标签 29
4.10 Hibernate可get和load的区别 30
4.11 Hibernate、Ibatis、JDBC区别 30
4.12 Hibernate与JDBC区别 30
4.13 Hibernate两大配置文献 30
4.14 Hibernate中的事务解决 31
4.15 Hibernate三种状态及如何转换 31
4.16 Hibernate中的五大核心接口 31
4.17 Hibernate缓存概述 32
4.18 SSH概述 32
4.19 分页环节 33
4.20 如何防止表单反复提交 33
4.21 通过Struts2来解决表单反复提交 33
4.22 拦截器 33
5 数据库篇 35
5.1 JDBC连接数据库环节 35
5.2 数据库连接池 35
5.3 jdbc分段批量提交的时候出现异常怎么解决? 35
5.4 JDBC批量解决数据 36
5.5 Oracle分页语句 36
5.6 MySQL分页语句 36
5.7 Oracle基本数据类型 37
5.8 id、rowid、rownum的区别 37
5.9 主键和唯一索引的区别？ 37
5.10 Preparedstatement和statement的区别 38
5.11 数据库三范氏 38
5.12 视图概述 38
5.13 存储过程概述 38
5.14 索引概述 39
5.15 Ibatis批量 40
6 业务场景篇 42
6.1 Spring的概述 42
6.2 事务概述 43
6.3 权限概述 44
6.4 OSCache业务场景 44
6.5 线程概述 44
6.6 Ajax请求Session超时问题 45
6.7 Java线程池概述 46
6.8 OSCache概述 47
6.9 OSCache+autocomplete+单例业务场景 47
6.10 缓存概述 47
6.11 实现页面静态化业务场景 48
6.12 servlet线程安全描述 48
6.13 (jbpm4)工作流引擎描述: 49
6.14 JPBM业务场景 50
6.15 Ant描述 50
6.16 FreeMarker描述 51
6.17 webService描述 51
6.18 oracle索引概述 52
6.19 oracle存储过程 53
6.20 Junit 业务场景 53
6.21 Apache+Tomcat 实现负载均衡及seesion复制 53
6.22 Ant业务场景 54
6.23 maven业务场景 55
6.24 bugfree的操作环节 55
6.25 Axis2 的配置 56
6.26 spring定期器 56
6.27 Ext概述 57
6.28 lucene的概述 57
6.29 线程池作用 58
6.30 jbpm是如何和spring进行整合 58
6.31 Tomcat优化 58
6.32 memcached的介绍 60
7 优化篇 60
7.1 代码优化 60
7.2 业务优化 61
7.3 sql优化 61
7.4 防sql注入 63
7.5 数据库中常用术语 65
7.6 进一步java虚拟机以及大数据 65

1 基础篇
1.1 Java介绍
Java是面向对象的，跨平台的，它通过java虚拟机来进行跨平台操作，它可以进行自动垃圾回收的（c语言是通过人工进行垃圾回收）。
java还会进行自动分派内存。（c语言是通过指定进行分派内存的），只需要new一个对象，这个对象占用了多少空间，不需要我们来管，java虚拟机负责管这些，用完之后也不需要我们来释放，java虚拟机会自动释放。
1.2 J2SE、J2EE、J2ME三者区别
Java SE = Java Standard Edition=j2se = java 标准版
Java EE = Java Enterprise Edition=j2ee= java 公司版
Java ME = Java Mobile Edition=j2me = java 移动版

三者特点：
J2SE重要用于桌面程序（swing），控制台开发（main程序）。
J2EE公司级开发（JSP,EJB,Spring MVC,Struts,hibernate,ibatis等），用于公司级软件开发，网络开发，web开发。
J2ME嵌入式开发(手机，小家电，PDA)。[苹果的ios，黑莓]。

三者之间的关系：
Java SE（Java Platform，Standard Edition，Java标准版）就是基于JDK和JRE的。Java SE为Java EE提供了基础。Java EE除了基于我们这个所谓的Java SE外，还新加了公司应用所需的类库。
1.3 JDK、JRE、JVM区别
Jdk【Java Development ToolKit】就是java开发工具箱， JDK是整个JAVA的核心里边包含了jre，它除了包含jre之外还包含了一些javac的工具类，把java源文献编译成class文献，java文献是用来运营这个程序的，除此之外，里边还包含了java源生的API，java.lang.integer在rt的jar包里边【可以在项目中看到】，通过rt这个jar包来调用我们的这些io流写入写出等。

JDK有以下三种版本：
J2SE，standard edition，标准版，是我们通常用的一个版本
J2EE，enterpsise edtion，公司版，使用这种JDK开发J2EE应用程序
J2ME，micro edtion，重要用于移动设备、嵌入式设备上的java应用程序

Jre【Java Runtime Enviromental】是java运营时环境，那么所谓的java运营时环境，就是为了保证java程序可以运营时，所必备的一基础环境，也就是它只是保证java程序运营的，不能用来开发，而jdk才是用来开发的，所有的Java程序都要在JRE下才干运营。
涉及JVM和JAVA核心类库和支持文献。与JDK相比，它不包含开发工具——编译器、调试器和其它工具。Jre里边包含jvm。

Jvm：【Java Virtual Mechinal】由于jre是java运营时环境，java运营靠什么运营，而底层就是依赖于jvm，即java虚拟机，java虚拟机用来加载类文献，java中之所以有跨平台的作用，就是由于我们的jvm。

三者关系：J2se是基于jdk和jre，JDK是整个JAVA的核心里边包含了jre，Jre里边包含jvm。
1.4 JDK常用的包
java.lang: 这个是系统的基础类，比如String、Math、Integer、System和Thread，提供常用功能。
java.io: 这里面是所有输入输出有关的类，比如文献操作等。
: 这里面是与网络有关的类，比如URL,URLConnection等。
java.util : 这个是系统辅助类，特别是集合类Collection,List,Map等。
java.sql: 这个是数据库操作的类，Connection，Statememt，ResultSet等。
1.5 Java中的基本数据类型
数据类型
大小
byte(字节)
1(8位)
shot(短整型)
2(16位)
int(整型)
4(32位)
long(长整型)
8(32位)
float(浮点型)
4(32位)
double(双精度)
8(64位)
char(字符型)
2(16位)
boolean(布尔型)
1位

附加：
String是基本数据类型吗?(String不是基本数据类型)
String的长度是多少，有限制?(长度受内存大小的影响)
1.6 Java中switch接受的几种数据类型
short， int， byte，char
enum（JDK1.5以后支持）
String（JDK1.7以后支持）
1.7 String、StringBuffer、StringBuilder区别
String
字符串常量
不可变
使用字符串拼接时是不同的2个空间。
StringBuffer
字符串变量
可变
线程安全，字符串拼接直接在字符串后追加。
StringBuilder
字符串变量
可变
非线程安全，字符串拼接直接在字符串后追加。

1、 StringBuilder执行效率高于StringBuffer高于String。
2、 String是一个常量，是不可变的，所以对于每一次+=赋值都会创建一个新的对象，StringBuffer和StringBuilder都是可变的，当进行字符串拼接时采用append方法，在本来的基础上进行追加，所以性能比String要高，又由于StringBuffer是线程安全的而StringBuilder是线程非安全的，所以StringBuilder的效率高于StringBuffer。
3、 对于大数据量的字符串的拼接，采用StringBuffer,StringBuilder。
4、 另一种说法，JDK1.6做了优化，通过String声明的字符串在进行用“+”进行拼接时，底层调用的是StringBuffer，所以性能上基本和后两者没有什么区别。
1.8 Char型变量能不能存储一个汉字？
char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。
1.9 ==和equals方法的区别
“==”假如前后比较的是对象，则比较的是对象的地址，假如前后是数字，则比较的数值。
“equals”假如前后是对象，比较的是对象的地址。假如比较的对象重写了equals方法，则有也许比较的是“值”。像八个基本数据类型的封装类、String、File、Date都比较的是值。
1.10 静态变量和实例变量的区别
在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
在程序运营时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分派空间，才干使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分派空间，静态变量就可以被使用了。
总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
1.11 Integer和int的区别
int是java提供的8种原始数据类型之一，意思整型，占用4字节。
Integer是java为int提供的封装类，是引用数据类型。
int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况。
1.12 Math.round()的使用
Math类中提供了三个与取整有关的方法：ceil、floor、round，这些方法的作用与它们的英文名称的含义相相应，例如，ceil的英文意义是天花板，该方法就表达向上取整，Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11；floor的英文意义是地板，该方法就表达向下取整，Math.ceil(11.6)的结果为11,Math.ceil(-11.6)的结果是-12；最难掌握的是round方法，它表达“四舍五入”，算法为Math.floor(x+0.5)，即将本来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。
1.13 构造器是否可以被重写
构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。
1.14 抽象类和接口的区别
具有abstract修饰符的class即为抽象类，abstract类不能创建的实例对象。具有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。假如的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。
接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。
下面比较一下两者的语法区别：
1. 抽象类可以有构造方法，接口中不能有构造方法。
2. 抽象类中可以有普通成员变量，接口中没有普通成员变量
3. 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和默认类型，但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7. 一个类可以实现多个接口，但只能继承一个抽象类。
下面接着再说说两者在应用上的区别：
接口更多的是在系统架构设计方法发挥作用，重要用于定义模块之间的通信契约；
而抽象类在代码实现方面发挥作用，可以实现代码的重用。
1.15 新建对象有几种方式
1. 使用new关键字
2. 使用反射，调用newInstance
3. 使用clone方法
4. 使用序列化与反序列化
5. 动态代理(Proxy类和CGLIB)
1.16 &和&&的区别
&和&&都可以用作逻辑与的运算符，&&为短路与，&不是短路与。
此外&可以做为整数的位运算符

例1：对于if(str != null&& !str.equals(“”))表达式，当str为null时，后面的表达式不会执行，所以不会出现NullPointerException假如将&&改为&，则会抛出NullPointerException异常。
例2：If(x==33 &++y>0) y会增长，if(x==33 && ++y>0)不会增长。

备注：这道题先说两者的共同点，再说出&&和&的特殊之处，并列举一些经典的例子来表白自己理解透彻进一步、实际经验丰富。
1.17 面向对象什么特性
对于面向对象的特性，一般有两种说法：一种是有三大特性，分别是封装，继承，多态，一种说法是有四大特性，封装，继承，多态，抽象。讲三大特性的时候更多一些，注意，这里的提问方式是面向对象的特性，而不是Java的特性。
1.18 面向对象中多态特性
多态是面向对象很重要的一个特性，转型是多态的具体体现。多态还涉及重载和重写。

转型：转型分为向上转型和向下转型。向上转型是子类对象转换成父类对象，直接转就可以，向下转型是父类对象转换成子类对象，这需要强转，在转换过程中要保证此父类对象“本体”是由子类对象实例化的。

重载：重载发生在同一个类中，在该类中假如存在多个同名方法，但是方法的参数类型和个数不同样，那么说明该方法被重载了。

重写：重写发生在子类继承父类的关系中，父类中的方法被子类继承，方法名，返回值类型，参数完全同样，但是方法体不同样，那么说明父类中的该方法被子类重写了。
1.19 List,set,Collection,Collections
1、 List和Set都是接口，他们都继承于接口Collection,List是一个有序的可反复的集合，而Set的无序的不可反复的集合。Collection是集合的顶层接口，Collections是一个封装了众多关于集合操作的静态方法的工具类,由于构造方法是私有的，所以不能实例化。

2、 List接口实现类有ArrayList,LinkedList,Vector。ArrayList和Vector是基于数组实现的,所以查询的时候速度快，而在进行增长和删除的时候速度较慢LinkedList是基于链式存储结构，所以在进行查询的时候速度较慢但在进行增长和删除的时候速度较快。又由于Vector是线程安全的，所以他和ArrayList相比而言，查询效率要低。
1.20 线程和进程的区别
1、 进程定义的是应用程序与应用程序之间的边界，通常来说一个进程就代表一个与之相应的应用程序。不同的进程之间不能共享代码和数据空间，而同一进程的不同线程可以共享代码和数据空间。

2、 一个进程可以涉及若干个线程，同时创建多个线程来完毕某项任务，便是多线程。实现线程的两种方式：继承Thread类，实现Runable接口。
1.21 Jvm内存结构
Java虚拟机的内存结构分为堆(heap)和栈(stack)，堆里面存放是对象实例也就是new出来的对象。栈里面存放的是基本数据类型以及引用数据类型的地址。对于所谓的常量是存储在方法区的常量池里面。
堆是先进先出
栈是先进后出
1.22 内存泄露和内存溢出
内存泄露 (memory leak)，是指应用程序在申请内存后，无法释放已经申请的内存空间。一次内存泄露危害可以忽略，但假如任其发展最终会导致内存溢出（out of memory）。如读取文献后流要进行及时的关闭以及对数据库连接的释放。

内存溢出（out of memory）是指应用程序在申请内存时，没有足够的内存空间供其使用。如我们在项目中对于大批量数据的导入，采用分段批量提交的方式。
1.23 解析xml文献的几种技术
解析xml的几种技术
1. dom4j 、2.sax、3.jaxb、4.jdom、5.dom

1、 dom4j
dom4j是一个Java的XML API，类似于jdom，用来读写XML文献的。dom4j是一个非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。

2、 sax
SAX（simple API for XML）是一种XML解析的替代方法。相比于DOM，SAX是一种速度更快，更有效的方法。它逐行扫描文档，一边扫描一边解析。并且相比于DOM，SAX可以在解析文档的任意时刻停止解析，但任何事物都有其相反的一面，对于SAX来说就是操作复杂。

3、 Jaxb
JAXB（Java Architecture for XML Binding) 是一个业界的标准，是一项可以根据XML Schema产生Java类的技术。该过程中，JAXB也提供了将XML实例文档反向生成Java对象树的方法，并能将Java对象树的内容重新写到XML实例文档。从另一方面来讲，JAXB提供了快速而简便的方法将XML模式绑定到Java表达，从而使得Java开发者在Java应用程序中能方便地结合XML数据和解决函数。
1.24 Dom4j与sax之间的对比
dom4j不适合大文献的解析，由于它是一下子将文献加载到内存中，所以有也许出现内存溢出，sax是基于事件来对xml进行解析的，所以他可以解析大文献的xml，也正是由于如此，所以dom4j可以对xml进行灵活的增删改查和导航，而sax没有这么强的灵活性，所以sax经常是用来解析大型xml文献，而要对xml文献进行一些灵活（crud）操作就用dom4j。
1.25 java Exception体系结构
java 异常是程序运营过程中出现的错误。Java把异常当作对象来解决，并定义一个基类java.lang.Throwable作为所有异常的超类。在Java API中定义了许多异常类,分为两大类，错误Error和异常Exception。其中异常类Exception又分为运营时异常(RuntimeException)和非运营时异常(非runtimeException)，也称之为不检查异常（Unchecked Exception）和检查异常（Checked Exception）。

1、 Error与Exception
Error是程序无法解决的错误，比如OutOfMemoryError、ThreadDeath等。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

Exception是程序自身可以解决的异常，这种异常分两大类运营时异常和非运营时异常。程序中应当尽也许去解决这些异常。

2、 运营时异常和非运营时异常
a) 运营时异常: 都是RuntimeException类及其子类异常：
i. IndexOutOfBoundsException 索引越界异常
ii. ArithmeticException：数学计算异常
iii. NullPointerException：空指针异常
iv. ArrayOutOfBoundsException：数组索引越界异常
v. ClassNotFoundException：类文献未找到异常
vi. ClassCastException：造型异常（类型转换异常）

这些异常是不检查异常（Unchecked Exception），程序中可以选择捕获解决，也可以不解决。这些异常一般是由程序逻辑错误引起的。

非运营时异常:是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行解决的异常，假如不解决，程序就不能编译通过。如：
IOException、文献读写异常
FileNotFoundException：文献未找到异常
EOFException：读写文献尾异常
MalformedURLException：URL格式错误异常
SocketException：Socket异常
SQLException：SQL数据库异常
1.26 抽象类和接口的区别
1. 抽象类由public abstract修饰，接口由public interface修饰。
2. 类（抽象类也是类）只支持单继承，但接口可以实现多个接口。接口不是类，接口和类同属于Java中的一个类型。
3. 抽象类里由构造器、常量、变量、抽象方法、普通方法构成，接口里只涉及常量和抽象方法，没有构造器和普通方法。
4. 是否是使用抽象类还是接口，重要看想要实现什么样的事情，假如侧重于描述事务，应当选择抽象类，假如侧重于定义功能，建议选择使用接口。
1.27 修饰符的作用
修饰符
同一个类中
同一个包中
子类中
全局
private
Yes

Default
Yes
Yes

protected
Yes
Yes
Yes

public
Yes
Yes
Yes
Yes
1.28 HashMap和Hashtable的区别
1、 HashMap和Hashtable是Map接口下的两个实现类，由于Map对象是键值对的，所以此两类也是键值对的。
2、 HashMap是线程非安全的，Hashtable是线程安全的，所以HashMap的效率高于Hashtable。
3、 HashMap允许键或值为null，键最多只可以有一个为null，值不受限制。而Hashtable键或值都不许为null。

注意：Hashtable中的“t”是小写的。
1.29 字节流和字符流的区别
以stream结尾都是字节流，以reader和writer结尾都是字符流，两者的区别就是读写的时候一个是按字节读写，一个是按字符。在实际使用时差不多。

在读写文献需要对内容按行解决，比如比较特定字符，解决某一行数据的时候一般会选择字符流。只是读写文献，和文献内容无关的，一般选择字节流。
1.30 运营异常和检查异常有何不同
异常表达程序运营过程中也许出现的非正常状态，运营时异常表达虚拟机的通常操作中也许碰到的异常，是一种常见运营错误。java编译器规定方法必须声明抛出也许发生的非运营时异常，但是并不规定必须声明抛出未被捕获的运营时异常。
1.31 error和exception的区别
error 表达恢复不是不也许但很困难的情况下的一种严重问题。比如说内存溢出，不也许指望程序能解决这样的情况。exception表达一种设计或实现问题，也就是说，它表达假如程序运营正常，从不会发生的情况。
1.32 举例最常用的五个运营时异常
NullPointerException空指针、ArrayIndexOutOfBoundsException数组越界、ClassCastException 类转换异常、IllegelArgumentException输入输出异常、SecurityException 权限不够。
1.33 Sleep和wait的区别
（网上的答案：sleep是线程类（Thread）的方法，导致此线程暂停执行指定期间，给执行机会给其他线程，但是监控状态仍然保持，届时后会自动恢复。调用sleep不会释放对象锁。 wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运营状态。）

sleep就是正在执行的线程积极让出cpu，cpu去执行其他线程，在sleep指定的时间过后，cpu才会回到这个线程上继续往下执行，假如当前线程进入了同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运营，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是立即得到锁，由于锁还在别人手里，别人还没释放。假如notify方法后面的代码尚有很多，需要这些代码执行完后才会释放锁，可以在notfiy方法后增长一个等待和一些代码，看看效果），调用wait方法的线程就会解除wait状态和程序可以再次得到锁后继续向下运营。对于wait的讲解一定要配合例子代码来说明，才显得自己真明白。
1.34 多线程有几种实现方式
多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有五种，分别是synchronized、wait与notify、sleep、suspend、join
synchronized: 一直持有锁，直至执行结束
wait():使一个线程处在等待状态，并且释放所持有的对象的lock，需捕获异常。
sleep():使一个正在运营的线程处在睡眠状态，是一个静态方法，需捕获异常，不释放锁。
notify():唤醒一个处在等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM拟定唤醒哪个线程，并且不是按优先级。
notityAll():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
1.35 启动一个线程用run还是start
启动一个线程是调用start()方法，使线程就绪状态，以后可以被调度为运营状态，一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码。
1.36 List和Map的区别
一个是存储单列数据的集合，另一个是存储键和值的双列数据的集合，List中存储的数据是有顺序，并且允许反复；Map中存储的数据是
没有顺序的，其键是不能反复的，它的值是可以有反复的。
1、 List有反复值，Map没有反复key，但可以有反复值
2、 List有序，Map不一定有序
3、 List只能存单列值，Map可以存双列值
1.37 说出ArrayList,Vector, LinkedList的存储性能和特性
1. ArrayList和Vector使用数组存储元素；LinkedList使用链表存储元素
2. ArrayList和Vector插入删除数据时，需要搬运数据，效率较差；LinkedList使用链表，不需要搬运数据，效率高
3. ArrayList和Vectory查询时，按数组下标查询，不需要遍历，效率高；LinkedList需要遍历，查询效率底
1.38 Java序列化
序列化是把内存Java对象保存到存储介质中，反序列化就是把存储介质中的数据转化为Java对象。Java通过ObjectInputStream和ObjectOutputStream实现序列化和反序列化。需要进行序列化的对象的类必须实现Serializable接口，通常情况下需要满足以下条件：
1. 强烈建议手动生成serialVersionUID常量
2. 假如需要加解密的话，需要实现两个方法readObject和writeObject方法
3. 假如使用Hibernate二级缓存或其它缓存服务器的话，对象必须是可序列化的
4. 假如需要远程调用对象或传值的话，则对像需要序列化
5. 序列化类的可序列化成员必须也是可序列化的，不需要序列化的属性用transient修饰
1.39 堆和栈的区别
Java的内存分为两类，一类是栈内存，一类是堆内存。
栈中存储的是当前线程的方法调用、基本数据类型和对象的引用，栈是有序的。
堆中存储的是对象的值，堆是无序的。
方法中的局部变量使用final修饰后，放在堆中，而不是栈中。
1.40 什么时候用断言
assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个对的程序必须保证这个boolean表达式的值为true；假如该值为false，说明程序已经处在不对的的状态下，assert将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的对的性。assertion检查通常在开发和测试时启动。为了提高性能，在软件发布后，assertion检查通常是关闭的。

1.41 Java中会有内存泄露吗
会，因素：
假如对象被集合类引用时，假如只是添加，而不删除，会引起内存泄漏，严重时会发出内存溢出。
Java中的内存泄露的情况：长生命周期的对象持有短生命周期对象的引用就很也许发生内存泄露。
内存泄露的此外一种情况：当一个对象被存储进HashSet或HashMap中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，否则，对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，导致内存泄露。
1.42 简述反射的作用
假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完毕他所写的类。那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。运用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完毕自身代码的编译。
Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的