内部资料，请勿外传

                                                              目录

一、         Java基础部分... 11

1、           一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？.. 11

2、           说说&和&&的区别。.. 11

3、           Java中的“短路”是指什么.. 11

4、           在JAVA中如何跳出当前的多重嵌套循环？.. 11

5、           switch语句能否作用在byte上，能否作用在long上?. 12

6、           short s= 1; s = s + 1;有什么错? short s = 1; s += 1;有什么错?. 12

7、           char型变量中能不能存贮一个中文汉字?为什么?. 13

8、           用最有效率的方法算出2乘以8等于几?. 13

9、           冒泡排序实现... 13

10、         "=="和equals方法究竟有什么区别？... 13

11、         两个对象值相同(x.equals(y)== true)，但却可有不同的hash code，这句话对不对?  14

12、         写出Object类中定义的方法。.. 15

13、         hashCode方法的作用？.. 15

14、         写clone()方法时，通常都有一行代码，是什么？... 16

15、         静态变量和实例变量的区别？... 16

16、         谈谈你对static关键词的理解... 17

17、         是否可以从一个static方法内部发出对非static方法的调用？... 17

18、         Integer与int的区别... 17

19、         Math.round(11.5)等於多少?Math.round(-11.5)等于多少?18

20、         请说出作用域public，private，protected，以及不写时的区别.. 18

21、         public、protected和private这些访问权限修饰词的作用.. 18

22、         Overload和Override的区别。Overload的方法是否可以改变返回值的类型?18

23、         什么是override？... 19

24、         什么是overload？... 20

25、         说说has a与is a的区别。... 20

26、         一个房子里有椅子，椅子有腿和背，房子与椅子是什么关系，椅子与腿和背是什么关系？... 20

27、         什么是参数?和参数化的意义?. 20

28、         构造器Constructor（构造方法）是否可被override(重写)?20

29、         接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法？.. 21

30、         面向对象的特征有哪些方面.. 21

31、         说出一些常用的类，包，接口，请各举5个.. 23

32、         写出JDK中至少5个以上的包名。.. 23

33、         java中实现多态的机制是什么？.. 24

34、         abstract class和interface有什么区别?. 24

35、         java的接口和C++虚类的相同和不同之处.. 25

36、         abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?. 26

37、         什么是内部类？StaticNested Class 和 Inner Class的不同。... 26

38、         内部类可以引用它的包含类的成员吗？有没有什么限制？... 28

39、         Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?. 29

40、         jdk中哪些类是不能继承的？.. 29

41、         Java是否有过程和函数?. 29

42、         String是最基本的数据类型吗?. 29

43、         String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？.. 29

44、         String类是否可以继承?30

45、    String s = new String("xyz");创建了几个String Object? 二者之间有什么区别？.. 30

46、         String 和StringBuffer的区别.. 31

47、         StringBuffer与StringBuilder的区别.. 31

48、         数组有没有length()这个方法? String有没有length()这个方法？.. 32

49、    使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？.. 32

50、         final关键词有哪些应用.. 32

51、         final, finally, finalize的区别。... 32

52、         运行时异常（RuntimeException）与一般异常有何异同？... 32

53、         程序中try{}里有一个return语句，那么紧跟在这个try后的finally{}里的代码会不会被 执行？在什么时候被执行？.. 33

54、         error和exception有什么区别?. 33

55、         Java中的异常处理机制的简单原理和应用。... 33

56、         java语言如何进行异常处理，关键字：throws、throw、try、catch、finally分别代表什么意义？在try块中可以抛出异常吗?. 34

57、         请写出你最常见到的5个runtime exception(运行时异常)。.. 34

58、         介绍Collection框架的结构... 34

59、         Collection（集合）框架中实现比较要实现什么接口... 34

60、         ArrayList和Vector的区别... 34

61、         ArrayList和LinkedList有什么异同之处？.. 35

62、         HashMap和Hashtable的区别.. 35

63、         List 和Map 区别?. 36

64、         List, Set, Map是否继承自Collection接口?36

65、         List、Map、Set三个接口，存取元素时，各有什么特点？... 36

66、         说出ArrayList,Vector,LinkedList的存储性能和特性... 37

67、         如何去掉一个Vector集合中重复的元素，有几种方法.. 37

68、         Collection 和Collections的区别。... 37

69、         Set里的元素是不能重复的，那么用什么方法来区分重复与否呢?是用==还是equals()? 它们有何区别?. 37

70、         你所知道的集合类都有哪些？主要方法？.. 38

71、         列出你知道的容器类(就是指集合类)，简单说明其功能.. 38

72、         Set和List的区别?. 39

73、         集合框架中Collections和Arrays类的作用... 39

74、         TreeSet里面放对象，如果同时放入了父类和子类的实例对象，那比较时使用的是父类的compareTo方法，还是使用的子类的compareTo方法，还是抛异常！.. 39

75、         数据结构中，数组与链表有哪些区别？为什么？... 39

76、    java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？.. 39

77、         字节流与字符流的区别.. 40

78、         什么是java序列化，如何实现java序列化？或者请解释Serializable接口的作用。    40

79、         序列化的概念和序列化ID的作用？.. 40

80、         描述一下JVM（JAVA虚拟机）加载class文件的原理机制?. 41

81、         ClassLoader（类加载器）如何加载class 。... 41

82、         能不能自己写个类，也叫java.lang.String？.. 41

83、         heap和stack有什么区别。.. 41

84、         GC是什么? 为什么要有GC?. 41

85、         Java内存动态管理机制.. 41

86、         垃圾回收的优点和原理。并考虑2种回收机制。.. 42

87、         垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？.. 42

88、         java中会存在内存泄漏吗，请简单描述。.. 42

89、         如何使用log4j记录日志？.. 43

90、         什么是DAO模式，使用该模式有哪些好处？.. 43

91、         DAO模式由哪几部分组成？.. 43

92、         单一职能原则... 43

93、         开闭原则... 44

94、         里氏替代原则... 44

95、         Java反射机制... 45

96、         线程的基本概念、线程的基本状态以及状态之间的关系.. 45

97、         同步和异步有何异同，在什么情况下分别使用他们？举例说明。.. 45

98、         Java中有几种实现方法多线程，都是什么？用什么方法启动该线程... 45

99、         多线程有几种实现方法?同步有几种实现方法?. 46

100、      启动一个线程是用run()还是start()? .46

101、      java中有几种方法可以实现一个线程？用什么关键字修饰同步方法?. 46

102、      当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的该方法?. 46

103、      请说出你所知道的线程同步的方法。.. 46

104、      sleep() 和wait() 有什么区别?. 47

105、      线程类中的stop()和suspend()方法为何不推荐使用？... 47

二、         Javaweb部分... 47

1、           什么是Servlet47

2、           说一说Servlet的生命周期?. 47

3、           Servlet的基本架构.. 48

4、           服务器如何响应Web客户请求？.. 48

5、           Servlet API中forward() 与sendRedirect ()的区别？（就是请求转发和重定向的区别） ？... 48

6、           什么情况下调用doGet()和doPost()？... 49

7、           request对象的几个常用方法:49

8、           什么是Jsp. 49

9、           JSP的执行过程?. 50

10、         JSP页面由哪几部分组成？... 50

11、         JSP指令有几种？... 50

12、         page指令常用属性？... 50

13、         JSP有哪些内置对象?作用分别是什么? 分别有什么方法？... 50

14、         JSP有哪些标准动作?作用分别是什么?. 51

15、         JSP中动态Include与静态Include的区别？... 51

16、         JSP和Servlet有哪些相同点和不同点，他们之间的联系是什么？.. 51

17、         如何实现servlet的单线程模式.. 52

18、         在JSP中如何实现页面跳转？... 52

19、         在servlets和JSP之间能共享session对象吗？... 52

20、         什么是Cookie？... 52

21、         如何设置cookie在某一时间后过期？... 52

22、         在JSP中如何设置Cookie？.. 52

23、         Cookie的应用场景？... 52

24、         cookie与session有什么区别?. 53

25、         什么是MVC设计模式.. 53

26、         MVC设计模式的优缺点：... 53

27、         Web应用的目录结构:54

28、         Tomcat的目录结构:54

29、         Tomcat工作原理？.. 54

30、         什么是URL：... 55

31、         什么是Session机制... 55

32、         四种会话跟踪技术.. 55

33、         Web应用中的四大作用域（注意不要和四种会话跟踪技术搞混淆了）... 56

34、         B/S与C/S的联系与区别.. 56

35、         http协议有几种提交方式.. 56

36、         什么是EL表达式... 56

37、         EL隐式对象有哪些？... 56

38、         什么是JSTL. 57

39、         JSTL迭代标签使用？... 57

40、         Filter 基本工作原理... 57

三、         JavaScript和Ajax部分.. 58

1、           JavaScript变量有哪些数据类型？... 58

2、           JavaScript中常用的系统函数其作用？... 58

3、           js中的3种弹出式消息提醒(警告窗口，确认窗口，信息输入窗口)的命令是什么？    58

4、           Javascript中定时执行如何实现，JavaScript如何实现一段代码在执行时间后运行？如何指定一段代码每隔指定时间就运行？... 59

5、           javaScript的变量能复制到JSP的session中吗？... 59

6、           什么是BOM？... 59

7、           什么是DOM?. 59

8、           DOM模型中的常用对象及其方法？.. 59

9、           如何设置页面元素的显示和隐藏？... 60

10、         使用什么事件可以实现当鼠标移动某文本上时，文本样式改变，当鼠标离开时文本样式恢复为原来的样式？... 60

11、         DOM如何操作文档的标准节点？... 60

12、         CSS样式表有哪几种？... 60

13、         Javascript中String对象常用方法？.. 61

14、         文本框对象常用的方法和事件... 61

15、         正则表达式的概念.. 61

16、         正则表达式有几种构造方式，分别是什么？... 61

17、         RegExp对象使用什么方法匹配正则表达式？... 62

18、         用正则表达式写出HTTP的url格式.. 62

19、         你是怎么理解Ajax的，什么是Ajax？.. 62

20、         实现AJAX异步调用需要哪些步骤... 62

21、         原生（native）Ajax使用实例... 62

22、         XMLHttpRequest对象简介？.. 63

23、         怎么处理Ajax中的缓存... 64

24、         为什么使用Ajax框架？... 64

25、         常用的Ajax框架有哪些？.. 64

26、         什么是jQuery. 64

27、         你为什么要使用jQuery？... 65

28、         你在公司是怎么用jQuery的？.. 65

29、         jQuery 能做什么？... 65

30、         $(document).ready()方法和window.onload有什么区别？.. 66

31、         什么是jQuery选择器.. 66

32、         jQuery选择器的种类... 66

33、         jQuery中的选择器 和css中的选择器有区别吗？... 66

34、         siblings() 方法 和$('prev~div')选择器是一样的嘛？... 67

35、         jQuery中的hover()和toggle()有什么区别？.. 67

36、    $("#msg").text()和$("#msg").text("<b>new content</b>")有什么区别？$("#msg").html()及$("#msg").html("<b>newcontent</b>")的区别呢？.. 67

37、         Jquery对象和dom对象的区别... 67

38、         jQuery对象和dom对象是怎样转换的？... 67

39、         你是如何使用jQuery中的ajax的？... 67

40、         jQuery中$.get()提交和$.post()提交有区别吗？... 68

41、         jQuery中的load方法一般怎么用的？.. 68

42、         你在ajax中使用过JSON吗，你是如何用的？... 68

43、         你使用过哪些数据格式，它们各有什么特点？.. 68

44、         在jQuery执行ajax中，提交的data（数据）主要有几种方式？.. 68

45、         jQuery是如何处理缓存的？.. 68

46、         你读过有关于jQuery的书吗？.. 69

47、         你知道jQuery中的事件冒泡吗，它是怎么执行的，何如来停止冒泡事件？.. 69

48、         例如 单击超链接后会自动跳转，单击"提交"按钮后表单会提交等，有时候我想阻止这些默认的行为，该怎么办？... 69

49、         你使用过jQuery中的动画吗，是怎样用的？.. 69

50、         你使用过jQuery中的插件吗？.. 69

51、         怎样给jQuery动态附加新的元素?那么怎样给新生成的元素绑定事件呢？... 69

52、         jQuery中有几种方法可以来设置和获取样式... 69

53、         jQuery中如何来获取或和设置属性？.. 69

54、         解决jQuery和其它库的冲突... 69

四、         项目开发经验... 70

1、           在eclipse中调试时，怎样查看一个变量的值？... 70

2、           你们公司使用的代码配置管理工具是什么？... 70

3、           你们的项目总金额多少，多少人开发，总共花了多少个月？.. 70

4、           对表单输入的数据应该作哪些验证？.. 70

5、           防止SQL 注入有哪些方法？... 70

6、           DDoS攻击的主要攻击方式包括？.. 70

7、           为什么需要单元测试？.. 71

8、           你在项目开发过程中遇到的最大的问题是什么？... 71

9、           分层设计的好处... 71

10、         你们公司的开发流程是什么？... 72

11、         你们项目成员组成？... 73

五、         数据库部分... 73

1、           设计数据库的三大范式是什么?73

2、           说出一些数据库优化方面的经验?. 74

3、           Oracle数据库如何提高访问性能？... 74

4、           你有优化SQL查询数据经验吗？如有能说一下你一般用那些什么方式进行优化？    78

5、           什么是事务，事务的四个特性是什么？有哪些隔离级别？... 78

6、           怎样建索引及索引的分类，索引有什么好处，要注意一些什么问题,如会不会影响其他表？... 78

7、           数据库中，数据类型char与varchar2有什么区别？性能方面各有什么优势？.. 79

8、           你怎么知道查询SQL的性能高还是低？.. 79

9、           在开发过程中遇到过数据库锁吗？怎样解锁？.. 79

10、         怎样处理并发数据?. 80

11、         能写出oracle中你常用到的sqlplus命令吗？.. 80

12、         delete from  table  与  truncate table的区别？drop table呢... 80

13、         union和unionall有什么不同?81

14、         一个用户表中有一个积分字段，假如数据库中有100多万个用户，若要在每年第一天凌晨将积分清零，你将考虑什么，你将想什么办法解决?81

15、         用JDBC如何调用存储过程.. 81

16、         JDBC访问数据库的步骤？... 82

17、         写一个用jdbc连接并访问oracle数据的程序代码.. 82

18、         Class.forName的作用?为什么要用?83

19、         大数据量下的分页解决方法。... 83

20、         这段代码有什么不足之处?83

21、         简述建立索引的作用和索引的分类?. 84

22、         什么是存储过程，有什么优缺点.. 84

23、         Oracle存储过程的基本语法是什么？.. 84

24、         存储过程与SQL的区别？.. 85

25、         什么是视图？它的作用？... 85

26、         视图给用户和开发人员带来的好处... 85

27、         如何创建视图？... 85

28、         如何删除视图？... 85

29、         Oracle数据库的主要特点如下：.. 85

30、         Oracle 基本概念... 86

31、         数据库、数据库实例的含义及区别？.. 86

32、         Oracle使用PL/SQL Developer导出数据的三种方式及区别？.. 86

33、        游标（CURSOR）的概念... 86

34、         表分区的特点及实现方式... 87

35、         SYS和SYSTEM中，哪个用户权限更大？.. 87

36、         Oracle中用什么函数按字符串截取字段？.. 87

37、         Oracle有哪些常用的函数？.. 87

六、         XML部分... 88

1、           Java解析XML有哪几种方法？并简述各自的优缺点(重复题个人觉得比较好)88

2、           你在项目中用到了xml技术的哪些方面?如何实现的?88

3、           XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？... 88

4、           如何使用DOM模式解析XML文档？... 89

七、         Mybatis常见面试题.. 89

1、           #{}和${}的区别是什么？.. 89

2、           Xml映射文件中，除了常见的select|insert|updae|delete标签之外，还有哪些标签？    89

3、           最佳实践中，通常一个Xml映射文件，都会写一个Dao接口与之对应，请问，这个Dao接口的工作原理是什么？Dao接口里的方法，参数不同时，方法能重载吗？    89

4、           Mybatis是如何进行分页的？分页插件的原理是什么？... 90

5、           简述Mybatis的插件运行原理，以及如何编写一个插件。... 90

6、           Mybatis执行批量插入，能返回数据库主键列表吗？.. 91

7、           Mybatis动态sql是做什么的？都有哪些动态sql？能简述一下动态sql的执行原理不？... 91

8、           Mybatis是如何将sql执行结果封装为目标对象并返回的？都有哪些映射形式？    91

9、           Mybatis能执行一对一、一对多的关联查询吗？都有哪些实现方式，以及它们之间的区别。... 91

10、         Mybatis是否支持延迟加载？如果支持，它的实现原理是什么？... 92

11、         Mybatis的Xml映射文件中，不同的Xml映射文件，id是否可以重复？.. 93

12、         Mybatis中如何执行批处理？.. 93

13、         Mybatis都有哪些Executor执行器？它们之间的区别是什么？... 93

14、         Mybatis中如何指定使用哪一种Executor执行器？.. 93

15、         Mybatis是否可以映射Enum枚举类？.. 94

16、    Mybatis映射文件中，如果A标签通过include引用了B标签的内容，请问，B标签能否定义在A标签的后面，还是说必须定义在A标签的前面？.. 94

17、         简述Mybatis的Xml映射文件和Mybatis内部数据结构之间的映射关系？... 94

18、         为什么说Mybatis是半自动ORM映射工具？它与全自动的区别在哪里？.. 94

19、         要使用LIKE语句该怎么写?. 95

20、         如何执行批量插入?. 95

21、         如何获取自动生成的(主)键值?96

22、         在mapper中如何传递多个参数?. 96

八、         Hibernate框架技术.. 97

1、           为什么需要使用Hibernate？.. 97

2、           Hibernate使用步骤.. 97

3、           谈谈你对Hibernate的理解。... 98

4、           iBatis与Hibernate有什么不同?98

5、           Hibernate中实体对象的三种状态。... 99

6、           介绍一下Hibernate的二级缓存.. 99

7、           Hibernate的数据加载方式... 100

8、           Hibernate如何延迟加载？... 100

9、           Hibernate中怎样实现类之间的关系？（如：一对多、多对多关系）... 100

10、         如何优化Hibernate？... 101

11、         说下Hibernate缓存机制... 101

12、         hibernate进行多表查询每个表中各取几个字段，也就是说查询出来的结果集没有一个实体类与之对应如何解决.. 101

13、         hibernate的工作原理... 101

14、         hibernate的inverse属性的作用?102

15、         cascade属性和inverse属性的作用和区别？... 102

16、         为什么要用ORM?  和 JDBC 有何不一样?. 102

17、         hibernate中get()与load()区别... 102

18、         Hiberane中Query对象的list()方法和iterate()方法的区别：.. 103

19、         Hibernate支持两种查询方式：... 103

20、         为什么使用HQL查询？... 103

21、         使用HQL步骤... 103

22、         HQL优化... 103

23、         HQL联接查询有几种方式？.. 104

九、         Struts框架技术... 104

1、           什么是设计模式模式？.. 104

2、           什么是框架？... 104

3、           Java领域中的主流框架有哪些？.. 104

4、           如何实现自定义MVC框架？... 105

5、           谈谈你对Struts 1.x的理解。... 105

6、           Struts1.x的工作机制？.. 106

7、           Struts1.x优缺点... 106

8、           说说struts1与struts2的区别。.. 107

9、           Struts 1有哪些核心组件？.. 108

10、         Struts 2中如何解决中文乱码问题？.. 108

11、         Struts2配置文件中的package元素与Java中的包有什么异同之处？... 108

12、         Struts2开发Action有几种模式，Action的作用是什么？... 108

13、         Struts 2结构体系的运行原理（重点）... 109

14、         Struts 2核心接口和类... 110

15、         说说对Struts 2拦截器的理解？... 110

16、         拦截器工作原理... 111

17、         为什么要用拦截器？... 111

18、         Struts2内置的拦截器... 111

19、         Struts2自定义拦截器？.. 112

20、         拦截器和拦截器栈有什么异同？.. 112

21、         Struts 2 表单标签和普通HTML表单标签有什么不同之处？... 112

22、         Struts 2中自定义类型转换器... 113

23、         为什么要进行类型转换？... 113

24、         国际化、本地化的含义是什么？.. 113

25、         Struts2国际化资源文件的范围... 113

26、         Struts2的配置文件介绍.. 114

27、         什么是OGNL. 115

28、         OGNL和EL有什么异同？... 115

29、         OGNL中访问根元素和非根元素有什么区别？... 115

30、         OGNL在Struts2中的作用... 116

十、         Spring框架... 116

1、           什么是依赖，什么是依赖注入？.. 116

2、           Spring依赖检查机制.. 116

3、           SpringMVC工作机制？.. 116

4、           Spring是什么？... 117

5、           为什么要使用Spring框架?. 117

6、           Spring主要包含哪些模块?. 117

7、           Spring的自动装配机制？.. 118

8、           Spring自动装配的优缺点.. 119

9、           Spring如何实现IOC容器功能... 119

10、         Spring如何与Struts 2集成？... 120

11、         什么是声明式事务。... 120

12、         Spring如何使用声明式事务管理Hibernate的事务... 120

13、         AOP核心概念... 120

14、         什么是AOP(Aspect-oriented programming面向方面编程)121

15、         SpringAOP原理... 121

16、         Spring中的通知类型？... 121

17、         Spring对持久层的支持：.. 122

18、         Spring的事务机制... 122

19、         数据库并发操作存在的异常情况？... 122

20、         事务隔离级别... 123

21、         数据库锁概念... 124

22、         关于Spring与EJB. 124

23、         在Tomcat 上配置 https 协议有哪些主要的步骤：.. 124

24、         实际开发过程中为什么拆分Spring配置文件？... 125

25、         采用何种策略拆分Spring配置文件？... 125

十一、             软件工程与设计模式... 125

1、           UML方面... 125

2、           JavaEE常用的设计模式？... 125

3、           常用的设计模式分类... 125

4、           单例模式的优点... 126

5、           什么是工厂模式？.. 126

6、           开发中都用到了那些设计模式?用在什么场合?. 126

十二、             JAVAEE部分... 127

1、           JNDI是什么？... 127

2、           说出数据连接池的工作机制是什么?127

3、           B/S与C/S的联系与区别。... 127

十三、             WebService部分.. 128

1、           什么是Web服务（web service）... 128

2、           Web服务的优点有哪些？.. 129

3、           XFire框架如何创建和发布Web服务？.. 129

4、           XFire框架如何调用Web服务？... 129

5、           Web Service名词解释。JSWDL开发包的介绍。JAXP、JAXM的解释。SOAP、UDDI,WSDL解释。.. 129

6、           什么是SOA?. 130

一、  Java基础部分

1、           一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。

2、           说说&和&&的区别。

&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。

&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于if(str != null && !str.equals(“”))表达式，当str为null时，后面的表达式不会执行，所以不会出现NullPointerException如果将&&改为&，则会抛出NullPointerException异常。If(x==33 &++y>0) y会增长，If(x==33 && ++y>0)不会增长

&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如，0x31 & 0x0f的结果为0x01。

备注：这道题先说两者的共同点，再说出&&和&的特殊之处，并列举一些经典的例子来表明自己理解透彻深入、实际经验丰富。

3、           Java中的“短路”是指什么

在java逻辑运算中使用逻辑运算符||与&&时将采取“短路”运算。举一个例子

上面一段代码的执行过程是当a满足大于0的时候将不会再执行后面的a<1代码，这就是“短路”。

4、           在JAVA中如何跳出当前的多重嵌套循环？

在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的break 语句，即可跳出外层循环。例如，

ok://定义的标号

for(int i=0;i<10;i++){

        for(intj=0;j<10;j++){

            System.out.println(“i=” + i + “,j=” + j);

            if(j== 5) {

                breakok;//跳出到指定的标号

            }

        }

    }

另外，我个人通常并不使用标号这种方式，而是让外层的循环条件表达式的结果可以受到里层循环体代码的控制，例如，要在二维数组中查找到某个数字。

int arr[][] = { {1,2,3},{4,5,6,7},{9}};

boolean found = false;

for(int i=0;i<arr.length && !found;i++){

        for(intj=0;j<arr[i].length;j++){

            System.out.println(“i=” + i + “,j=” + j);

            if(arr[i][j]  == 5){

                found= true;

                break;

            }

        }

    }

5、           switch语句能否作用在byte上，能否作用在long上?

在switch（expression）中，expression只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich语句中。

6、           short s = 1; s = s + 1;有什么错? short s = 1; s += 1;有什么错?

对于short s = 1;s = s + 1; 由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。

对于short s1 =1; s1 += 1;由于 += 是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。

7、           char型变量中能不能存贮一个中文汉字?为什么?

char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。

备注：后面一部分回答虽然不是在正面回答题目，但是，为了展现自己的学识和表现自己对问题理解的透彻深入，可以回答一些相关的知识，做到知无不言，言无不尽。

8、           用最有效率的方法算出2乘以8等于几?

最有效率的计算方式：intresult = 2 << 3;

因为将一个数左移n位(二进制移位运算)，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，而位运算是cpu直接支持的，效率最高，所以，2乘以8等於几的最效率的方法是2<< 3。

9、           冒泡排序实现

口诀：n个数字来比较，外层循环N-1，内层循环N-1-i，两两相比小靠前。

代码示例：

10、        "=="和equals方法究竟有什么区别？

（单独把一个东西说清楚，然后再说清楚另一个，这样，它们的区别自然就出来了，混在一起说，则很难说清楚）

==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。

如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();引用变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。

equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：

String a=new String("foo");

String b=new String("foo");

两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。

在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String input = new String(“quit”); input.equals(“quit”)，许多人稍不注意就使用==进行比较了，这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用equals方法。

如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：

boolean equals(Object o){

        return this==o;

}

这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object 类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须重写equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

11、        两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?

对。

如果对象要保存在HashSet或HashMap中，它们的equals相等，那么，它们的hashcode值就必须相等。

如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode不等是可以的，例如arrayList存储的对象就不用实现hashcode，当然，我们没有理由不实现，通常都会去实现的。

12、        写出Object类中定义的方法。

1)     clone()：创建并返回此对象的一个副本。

2)     equeals(Object obj)：指示某个其他对象是否与此对象“相等”。

3)     finalize()：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

4)     getClass()：返回一个对象的运行时类。

5)     hashCode()：返回该对象的哈希码值。

6)     notify()：唤醒在此对象监视器上等待的单个线程。

7)     notifyAll： 唤醒在此对象监视器上等待的所有线程。

8)     toString()：返回该对象的字符串表示。

9)     wait()：导致当前的线程等待，直到其他线程调用此对象的notify方法或notifyAll()方法

10)   wait(long timeout):wait方法的overload方法。

11)   wait(long timeout,int nanos):wait方法的overload方法。

13、        hashCode方法的作用？

    hashcode这个方法是用来鉴定2个对象是否相等的。那你会说，不是还有equals这个方法吗？

不错，这2个方法都是用来判断2个对象是否相等的。但是他们是有区别的。

一般来讲，equals这个方法是给程序员编码时调用的，如果你想判断2个对象是否相等，你可以重写equals方法，然后在代码中调用，就可以判断他们是否相等了。简单来讲，equals方法主要是用来判断从表面上看或者从内容上看，2个对象是不是相等。举个例子，有个学生类，属性只有姓名和性别，那么我们可以认为只要姓名和性别相等，那么就说这2个对象是相等的。

    hashcode方法一般程序员编码时不会去调用，比如在hashmap中，由于key是不可以重复的，它在判断key是不是重复的时候就判断了hashcode这个方法，而且也用到了equals方法。这里不可以重复是说equals和hashcode只要有一个不等就可以了！所以简单来讲，hashcode相当于是一个对象的编码，就好像文件中的MD5（一种唯一标识文件的加密代码），它和equals不同就在于他返回的是int型的，比较起来不直观。我们一般在重写equals的同时也要重写hashcode，让它们的逻辑一致。举个例子，还是刚刚的例子，如果姓名和性别相等就算2个对象相等的话，那么hashcode的方法也要返回姓名的hashcode值加上性别的hashcode值，这样从逻辑上，它们就一致了。

要从物理上判断2个对象是否相等，用==就可以了。

1)       

14、        写clone()方法时，通常都有一行代码，是什么？

clone方法就是克隆，用于复制对象。clone 有缺省行为，super.clone();因为首先要把父类中的成员复制到位，然后才是复制自己的成员。

15、        静态变量和实例变量的区别？

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个staticVar变量，并且每创建一个实例对象，这个staticVar就会加1；但是，每创建一个实例对象，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。

public class VariantTest{

        public static intstaticVar = 0;

        public int instanceVar= 0;

        public VariantTest()    {

            staticVar++;

            instanceVar++;

            System.out.println(“staticVar=” + staticVar+ ”,instanceVar=” +instanceVar);

        }

}

备注：这个解答除了说清楚两者的区别外，最后还用一个具体的应用例子来说明两者的差异，体现了自己有很好的解说问题和设计案例的能力，思维敏捷，超过一般程序员，有写作能力！

16、        谈谈你对static关键词的理解

通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法，声明为static的方法有以下几条限制：

1)   它们仅能调用其他的static 方法。

2)   它们只能访问static数据。

3)   它们不能以任何方式引用this 或super。

声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间。

17、        是否可以从一个static方法内部发出对非static方法的调用？

不可以。

因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。也就是说，当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个static方法内部发出对非static方法的调用。

18、        Integer与int的区别

int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况。

例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer。在JSP开发中，Integer的默认为null，所以用el表达式在文本框中显示时，值为空白字符串，而int默认的默认值为0，所以用el表达式在文本框中显示时，结果为0，所以，int不适合作为web层的表单数据的类型。

在Hibernate中，如果将OID定义为Integer类型，那么Hibernate就可以根据其值是否为null而判断一个对象是否是临时的，如果将OID定义为了int类型，还需要在hbm映射文件中设置其unsaved-value属性为0。

另外，Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数Integer.parseInt(“数字字符串”);

Integer中还定义了表示整数的最大值和最小值的常量。

19、        Math.round(11.5)等於多少?Math.round(-11.5)等于多少?

Math类中提供了三个与取整有关的方法：ceil、floor、round，这些方法的作用与它们的英文名称的含义相对应，例如，ceil的英文意义是天花板，该方法就表示向上取整(就是往大值靠拢)，所以，Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11；floor的英文意义是地板，该方法就表示向下取整，所以，Math.floor(11.6)的结果为11,Math.floor(-11.6)的结果是-12；最难掌握的是round方法，它表示“四舍五入”，算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。

20、        请说出作用域public，private，protected，以及不写时的区别

这四个作用域的可见范围如下表所示。

说明：如果在修饰的元素上面没有写任何访问修饰符，则表示default(friendly)。

备注：只要记住了有4种访问权限，4个访问范围，然后将全选和范围在水平和垂直方向上分别按排从小到大或从大到小的顺序排列，就很容易画出上面的图了。

21、        public、protected和private这些访问权限修饰词的作用

1)   public修饰的字段、属性可被所有的访问。

2)   protected修饰的字段、属性只能被本类、本包以及其子类的访问。

3)   private修饰的字段、属性只可以被本类访问。

22、        Overload和Override的区别。Overload的方法是否可以改变返回值的类型?

Overload是重载的意思，Override是覆盖的意思，也就是重写。

重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）,与方法的作用域和返回类型无关。

重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。

子类重写父类的方法时，不能扩大方法的异常范围，即只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。

子类重写父类的方法时，不能缩小作用范围，子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么，此时根本不属于重写方法的概念，相当于子类中增加了一个全新的方法。

扩展性回答：(请理解这些概念)

至于Overloaded的方法是否可以改变返回值的类型这个问题，要看你倒底想问什么呢？这个题目很模糊。如果几个Overloaded的方法的参数列表不一样，它们的返回者类型当然也可以不一样。但我估计你想问的问题是：如果两个方法的参数列表完全一样，是否可以让它们的返回值不同来实现重载Overload。这是不行的，我们可以用反证法来说明这个问题，因为我们有时候调用一个方法时也可以不定义返回结果变量，即不要关心其返回结果，例如，我们调用map.remove(key)方法时，虽然remove方法有返回值，但是我们通常都不会定义接收返回结果的变量，这时候假设该类中有两个名称和参数列表完全相同的方法，仅仅是返回类型不同，java就无法确定编程者倒底是想调用哪个方法了，因为它无法通过返回结果类型来判断。

23、        什么是override？

override也可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类重写父类中的方法。重写方法时要注意以下的几点：

1、重写的方法的标志必须要和被重写的方法的标志完全匹配，才能达到重写的效果；

2、重写的方法的返回值必须和被重写的方法的返回一致

3、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类

4、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。

24、        什么是overload？

overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：

1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；

2、不能通过访问权限、返回类型、抛出的异常进行重载；

3、方法的异常类型和数目不会对重载造成影响；

4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

25、        说说has a与is a的区别。

答：is-a表示的是属于的关系。比如兔子属于一种动物（继承关系）。

    has-a表示组合，包含关系。比如兔子包含有腿，头等组件（关联关系或聚集和聚合关系）；

26、        一个房子里有椅子，椅子有腿和背，房子与椅子是什么关系，椅子与腿和背是什么关系？

如果房子有多个椅子，就是聚集关系，否则是一种关联关系，当然，聚集是一种特殊的关联。椅子与腿和背是组合（聚合）关系。

27、        什么是参数?和参数化的意义?

参数:就是用来代替一个数的未知数，参数就是一个符号，没有实际意义，要让它有实际意义，就给参数赋一个值就可以了，例如定义一个方法来计算两个数字的和，那么该方法就必须定义2个参数表示用来计算的数字，但是只有当调用该方法时，给该方法的两个参数赋值后才能真正执行该方法，例如定义了int add(int a,int b)方法，只有调用时用具体的数字代替掉参数后，才能真正执行并获得结果，例如int result = add(2,3),最终得到结果为5.

参数化的意义：在数据库调用中，参数化能有效的防止注入式攻击 ，在程序方法中，参数化能避免泄露程序运行的机制与原理，也降低了方法冗余，提高代码的可读性！

28、        构造器Constructor（构造方法）是否可被override(重写)?

构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。

29、        接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法？

接口可以继承接口。抽象类可以实现(implements)接口，抽象类可以继承具体类。抽象类中可以有静态的main方法。

备注：只要明白了接口和抽象类的本质和作用，这些问题都很好回答，你想想，如果你是java语言的设计者，你是否会提供这样的支持，如果不提供的话，有什么理由吗？如果你没有道理不提供，那答案就是肯定的了。

 只有记住抽象类与普通类的唯一区别就是不能创建实例对象和允许有abstract方法。

30、        面向对象的特征有哪些方面

计算机软件系统是现实生活中的业务在计算机中的映射，而现实生活中的业务其实就是一个个对象协作的过程。面向对象编程就是按现实业务一样的方式将程序代码按一个个对象进行组织和编写，让计算机系统能够识别和理解用对象方式组织和编写的程序代码，这样就可以把现实生活中的业务对象映射到计算机系统中。

面向对象的编程语言有封装、继承、多态等3个基本特征。

1封装：

封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。在面向对象的编程语言中，对象是封装的最基本单位，面向对象的封装比传统语言的封装更为清晰、更为有力。面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，方法可以直接访问同一个对象中的属性。通常情况下，只要记住让变量和访问这个变量的方法放在一起，将一个类中的成员变量全部定义成私有的，只有这个类自己的方法才可以访问到这些成员变量，这就基本上实现对象的封装，就很容易找出要分配到这个类上的方法了，就基本上算是会面向对象的编程了。把握一个原则：把对同一事物进行操作的方法和相关的方法放在同一个类中，把方法和它操作的数据放在同一个类中。

例如，人要在黑板上画圆，这一共涉及三个对象：人、黑板、圆，画圆的方法要分配给哪个对象呢？由于画圆需要使用到圆心和半径，圆心和半径显然是圆的属性，如果将它们在类中定义成了私有的成员变量，那么，画圆的方法必须分配给圆，它才能访问到圆心和半径这两个属性，人以后只是调用圆的画圆方法、表示给圆发给消息而已，画圆这个方法不应该分配在人这个对象上，这就是面向对象的封装性，即将对象封装成一个高度自治和相对封闭的个体，对象状态（属性）由这个对象自己的行为（方法）来读取和改变。一个更便于理解的例子就是，司机将火车刹住了，刹车的动作是分配给司机，还是分配给火车，显然，应该分配给火车，因为司机自身是不可能有那么大的力气将一个火车给停下来的，只有火车自己才能完成这一动作，火车需要调用内部的离合器和刹车片等多个器件协作才能完成刹车这个动作，司机刹车的过程只是给火车发了一个消息，通知火车要执行刹车动作而已。

此外设计类的过程就是抽象。抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与当前目标有关的方面。例如，看到一只蚂蚁和大象，你能够想象出它们的相同之处，那就是抽象。抽象包括行为抽象和状态抽象两个方面。例如，定义一个Person类，如下：

class Person{

              String name;

              int age;

}

人本来是很复杂的事物，有很多方面，但因为当前系统只需要了解人的姓名和年龄，所以上面定义的类中只包含姓名和年龄这两个属性，这就是一种抽像，使用抽象可以避免考虑一些与目标无关的细节。我对抽象的理解就是不要用显微镜去看一个事物的所有方面，这样涉及的内容就太多了，而是要善于划分问题的边界，当前系统需要什么，就只考虑什么。

2继承：

在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。

3多态：

多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性。例如，下面代码中的UserDao是一个接口，它定义引用变量userDao指向的实例对象由daofactory.getDao()在执行的时候返回，有时候指向的是UserJdbcDao这个实现，有时候指向的是UserHibernateDao这个实现，这样，不用修改源代码，就可以改变userDao指向的具体类实现，从而导致userDao.insertUser()方法调用的具体代码也随之改变，即有时候调用的是UserJdbcDao的insertUser方法，有时候调用的是UserHibernateDao的insertUser方法：

UserDao userDao = daofactory.getDao(); 

userDao.insertUser(user);

31、        说出一些常用的类，包，接口，请各举5个

类:

1.java.lang.Object

              2.java.lang.String

              3.java.lang.System

              4.java.io.file

              5.java.io.FileInputStream

包:

1.java.lang

              2.java.io

              3.java.swt

              4.java.util

              5.java.sql

接口:

1.java.util.List<E>

            2.java.util.Map<E>

            3.java.util.Iterator<E>

            4.java.sql.CallableStatement

            5.java.lang.Comparable<T>

32、        写出JDK中至少5个以上的包名。

1)     java.lang包：java的核心类库，包含了运行java程序必不可少的系统类，如基本数据类型、基本数学函数、字符串处理、线程、异常处理类等，系统缺省加载 这个包

2)     java.io包：java语言的标准输入/输出类库，如基本输入/输出流、文件输入/输出、过滤输入/输出流等等

3)     java.util包：包含如处理时间的date类，处理变成数组的Vector类，以及stack和HashTable类

4)     java.lang.reflect包：提供用于反射对象的工具

5)     java.net包：实现网络功能的类库有Socket类、ServerSocket类

6)     java.sql包：提供使用JAVA编程语言访问并处理存储在数据源（通常是一个关系数据库）中的数据的API

7)     java.awt包：构建图形用户界面(GUI)的类库，低级绘图操作Graphics类，图   形界面组件和布局管理如Checkbox类、Container类、LayoutManger接口等，以及界面用户交互控制和事件响应，如Event类

33、        java中实现多态的机制是什么？

靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

34、        abstract class和interface有什么区别?    

含有abstract修饰符的class即为抽象类，abstract 类不能创建的实例对象。含有abstract方法的类必须定义为abstractclass，abstractclass类中的方法不必是抽象的。abstractclass类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。

接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。

下面比较一下两者的语法区别：

1)     抽象类可以有构造方法，接口中不能有构造方法。

2)     抽象类中可以有普通成员变量，接口中没有普通成员变量

3)     抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4)     抽象类中的抽象方法的访问类型可以是public，protected和默认作用域（不建议使用，因为默认作用域不能被其它包中的子类集成），但接口中的抽象方法只能是public类型的，并且默认即为publicabstract类型。

5)     抽象类中可以包含静态方法，接口中不能包含静态方法

6)     抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public staticfinal类型，并且默认即为public static final类型。

7)     一个类可以实现多个接口，但只能继承一个抽象类。

下面接着再说说两者在应用上的区别：

接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码，伪代码如下：

public abstract class BaseServlet extends HttpServlet{

        public final voidservice(HttpServletRequest request, HttpServletResponse response) throws                  IOExcetion,ServletException{

               //记录访问日志

               //进行权限判断

if(具有权限){

       try{

              doService(request,response);

}

       catch(Excetpione){

              //记录异常信息

       }

}

        }

        protected abstract voiddoService(HttpServletRequest request, HttpServletResponse                             response) throws IOExcetion,ServletException; 

              //注意访问权限定义成protected，显得既专业，又严谨，因为是专门给子类用的

        }

}

public class MyServlet1 extends BaseServlet{

protected void doService(HttpServletRequest request,HttpServletResponse response) throws                   IOExcetion,ServletException{

               //本Servlet处理具体业务逻辑代码

        }

}

父类方法中间的某段代码不确定，留给子类去实现，就用模板方法设计模式。

备注：这道题的思路是先从总体解释抽象类和接口的基本概念，然后再比较两者的语法细节，最后再说两者的应用区别。比较两者语法细节区别的条理是：先从一个类中的构造方法、普通成员变量和方法（包括抽象方法），静态变量和方法，继承性等6个方面逐一去比较回答，接着从第三者继承的角度的回答，特别是最后用了一个典型的例子来展现自己深厚的技术功底。

35、        java的接口和C++虚类的相同和不同之处

C++虚类相当于java中的抽象类，与接口的不同之处是：

1.一个子类只能继承一个抽象类（虚类），但能实现多个接口

2.一个抽象类可以有构造方法，接口没有构造方法

3.一个抽象类中的方法不一定是抽象方法，即其中的方法可以有实现（有方法体），接口中的方法都是抽象方法，不能有方法体，只有方法声明

4.一个抽象类可以是public、private、protected、default，接口只有public

5.一个抽象类中的方法可以是public、private、protected、default，接口中的方法只能是public和default修饰，实际上都是public的abstract方法

 相同之处是：都不能实例化。

 补充说明：接口是一类特殊的抽象类，是更抽象的抽象类，你可能这样理解。抽象类是一个不完整的类，接口只是定义了一些功能。

36、        abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?

abstract的method 不可以是static的，因为抽象的方法是要被子类实现的，而static与子类扯不上关系！

native方法表示该方法要用另外一种依赖平台的编程语言实现的，不存在着被子类实现的问题，所以，它也不能是抽象的，不能与abstract混用。例如，FileOutputSteam类要硬件打交道，底层的实现用的是操作系统相关的api实现，例如，在windows用c语言实现的，所以，查看jdk 的源代码，可以发现FileOutputStream的open方法的定义如下：

private native void open(String name) throws FileNotFoundException;

如果我们要用java调用别人写的c语言函数，我们是无法直接调用的，我们需要按照java的要求写一个c语言的函数，又我们的这个c语言函数去调用别人的c语言函数。由于我们的c语言函数是按java的要求来写的，我们这个c语言函数就可以与java对接上，java那边的对接方式就是定义出与我们这个c函数相对应的方法，java中对应的方法不需要写具体的代码，但需要在前面声明native。

关于synchronized与abstract合用的问题，我觉得也不行，因为在我几年的学习和开发中，从来没见到过这种情况，并且我觉得synchronized应该是作用在一个具体的方法上才有意义。而且，方法上的synchronized同步所使用的同步锁对象是this，而抽象方法上无法确定this是什么。

37、        什么是内部类？Static Nested Class 和 Inner Class的不同。

内部类就是在一个类的内部定义的类，内部类中不能定义静态成员（静态成员不是对象的特性，只是为了找一个容身之处，所以需要放到一个类中而已，这么一点小事，你还要把它放到类内部的一个类中，过分了啊！提供内部类，不是为让你干这种事情，无聊，不让你干。我想可能是既然静态成员类似c语言的全局变量，而内部类通常是用于创建内部对象用的，所以，把“全局变量”放在内部类中就是毫无意义的事情，既然是毫无意义的事情，就应该被禁止），内部类可以直接访问外部类中的成员变量，内部类可以定义在外部类的方法外面，也可以定义在外部类的方法体中，如下所示：

public class Outer{

        int out_x  = 0;

        public void method(){

               Inner1 inner1 = newInner1();

               public classInner2   //在方法体内部定义的内部类

               {

                      publicmethod(){

                             out_x =3;

                      }

               }

               Inner2 inner2 = newInner2();

        }

        public class Inner1   //在方法体外面定义的内部类

        {

       }

}

在方法体外面定义的内部类的访问类型可以是public,protecte,默认的，private等4种类型，这就好像类中定义的成员变量有4种访问类型一样，它们决定这个内部类的定义对其它类是否可见；对于这种情况，我们也可以在外面创建内部类的实例对象，创建内部类的实例对象时，一定要先创建外部类的实例对象，然后用这个外部类的实例对象去创建内部类的实例对象，代码如下：

Outer outer = new Outer();

Outer.Inner1 inner1 = outer.new Innner1();

在方法内部定义的内部类前面不能有访问类型修饰符，就好像方法中定义的局部变量一样，但这种内部类的前面可以使用final或abstract修饰符。这种内部类对其它类是不可见的其它类无法引用这种内部类，但是这种内部类创建的实例对象可