香港乖乖六合图库|潮京图库六合图库|

北京 切换校区

全国24小时免费热线

400-009-1906

第一篇:面试题汇总

Java基础、语法
1.Java跨平台原理(字节码文件、虚拟机) 2.Java的安全性 3.Java三大版本 4.什么是JVM?什么是JDK? 什么是JRE? 5.Java三种注释类型 6.8种基本数据类型及其字节数 7.i++和++i的异同之处 8.&和&&的区别和联系,|和||的区别和联系 9.用最有效率的方法算出2乘以8等于多少 10.基本数据类型的类型转换规则 11.if多分支语句和switch多分支语句的异同之处 12.while和do-while循环的区别 13.break和continue的作用 14.请使用递归算法计算n! 15.递归的定义和优缺点 16.数组的特征 17.请写出冒泡排序代码 18.请写出选择排序的代码 19.请写出插入排序的代码 20.可变参数的作用和特点 21.类和对象的关系 22.面向过程和面向对象的区别 23.this和super关键字的作用 24.static关键字的作用 25.final和abstract关键字的作用 26.final、finally、finalize的区别 27.写出java.lang.Object类的六个常用方法 28.private/默认/protected/public权限修饰符的区别 29.继承条件下构造方法的执行过程 30.==和equals的区别和联系 31.谈谈Java的多态 32.简述Java的垃圾回收机制 33.基本数据类型和包装类 34.Integer与int的区别 35.java.sql.Date和java.util.Date的联系和区别 36.使用递归算法输出某个目录下所有文件和子目录列表 37.关于Java编译,下面哪一个正确()(选择一项) 38.下列说法正确的有()(选择一项) 39.Java?#34218;?#21475;的修饰符可以为()(选择一项) 40.给定以下代码,程序将输出 ()(选择一项) 41.下列关于关键字的使用说法错误的是()(选择一项) 42.下列哪些语句关于内存回收的说法是正确的()(选择一项) 43.选出合理的标识符()(选择两项) 44.下列说法正确的是()(选择多项) 45.定义一个类名为”MyClass.java”的类,并且该类可被一个工程中的所有类访问,那么该类的正确声明为()(选择两项) 46.面向对象的特征有哪些方面?请用生活中的例子来描述。 47.说明内存泄漏和内存溢出的区别和联系,结合项目经验描述Java程序中如何检测?如何解决? 48.什么是Java的序列化,如?#38382;?#29616;Java的序列化?列举在哪些程序中见过Java序列化? 49.不通过构造函数也能创建对象吗? 50.匿名内部类可不可以继承或实现接口。为什么? 在Java?#26657;?#20026;什么基本类型不能做为HashMap的键值,而只能是引用类型,把引用类型做为HashMap的健值,需要注意哪些地方。 52.简述Java中如?#38382;?#29616;多态 53.以下对继承的描述锚误的是 () 54.Java 中 Math.random()/Math.random()值为? 55.Java?#26657;?#22914;果Manager是Employee的子类,那么Pair< Manager>是Pair< Employee>的子类吗? 56.接口和抽象类的区别 57.同步代码块和同步方法有什么区别 58.静态内部类和内部类有什么区别 59.反射的概念与作用 60.提供Java存取数据库能力的包是() 61.下?#24615;?#31639;符合法的是()(多选) 62.执行如下程序代码,c的值打印出来是() 63.下列哪一种叙述是正确的() 64.下列语句正确的是() 65.下列哪种说法是正确的() 66.Java程序的种类有()(多选) 67.下列说法正确的有()(多选) 68.下列标识符不合法的有()(多选) 69.下列说法错误的有()(多选) 70.不能用来修饰interface的有()(多选) 71.下列正确的有()(多选) 72.下列说法错误的有()(多选) 73.下列说法错误的有()(多选) 74.下列说法错误的有()(多选) 75.请问0.3332的数据类型是() 76.Java接口的修饰符可以为() 77.不通过构造函数也能创建对象么() 78.存在使i+1< i的数么? 79.接口可否继?#34218;?#21475;?抽象类是否可实现接口?抽象类是否可继承实体类? 80.int与Integer有什么区别? 81.?#23578;?#21015;化对象为什么要定义serialversionUID值? 82.写一个Java正则,能过滤出html中的 < a href=”url” >title< /a>?#38382;?#20013;的链接地址和标题. 83.十进制数72转换成八进制数是多少? 85.Class类的getDeclaredFields()方法与getFields()的区别? 88.使用final关键字修饰符一个变量时,是引用不能变,?#25925;且?#29992;的对象不能变? 88.使用final关键字修饰符一个变量时,是引用不能变,?#25925;且?#29992;的对象不能变? 89.请解释以下常用正则含义:\d,\D,\s,.,*,?,|,[0-9]{6},\d+ 90.已知表达式int m[] = {0,1,2,3,4,5,6}; 下面那个表达式的值与数组的长?#35748;?#31561;() 91.下面?#20999;?#22768;明是合法的?() 92.以下选项中选择正确的java表达式() 93.下?#20889;?#30721;的输出结果是 95.下面哪个函数是public void example(){....}的重载函数?() 96.给定某java程序片段,该程序运行后,j的输出结果为() 97.在java?#26657;?#26080;论测试条件是什么,下?#26657;ǎ?#24490;?#26041;?#33267;少执行一次。 98.打印结果: 99.指出下列程序的运?#34218;?#26524; 100.解释继?#23567;?#37325;载、覆盖。 102.简述操作符(&,|)与操作符(&&,||)的区别 &和&&的联系(共同点) 103.try{}里面有一个return语句,那么紧跟在这个try后的finally, 里面的语句在异常出现后,都会执行么?为什么? 104.有一段java应用程序,它的主类名是al,那么保存它的源文件可以是?() 105.Java类可以作为() 106.在调用方法时,若要使方法改变实参的值,可以?() 108.下关于构造函数的描述错误是() 109.若需要定义一个类域或类方法,应使用哪种修饰符?() 110.下面代码执行后的输出是什么() 111.给出如下代码,如何使成?#21271;?#37327;m被函数fun()直接访问() 112.下面哪几个函数是public void example(){….}的重载函数() 113.请问以下代码执行会打印出什么? 114.如果有两个类A、B(注意不是接口),你想同时使用这两个类的功能,那么你会如何编写这个C类呢? 115.一个类的构造方法是否可?#21592;?#37325;载(overloading),是否可?#21592;?#23376;类重写(overrding)? 116.Java中byte表示的数值?#27573;?#26159;什么? 117.如何将日期类型格式化为:2013-02-18 10:53:10? 118.不通过构造函数也能创建对象吗() 119.下面哪些是对称?#29992;?#31639;法() 120.下面的代码段,当输入为2的时候返回值是() 121.以下Java代码段会产生几个对象 122.Math.round(-11.2)的运?#34218;?#26524;是。 123.十进制数278的对应十六进制数 124.Java中int.long占用的字节数分别是 125.System.out.println(‘a’+1);的结果是 126.下列语句那一个正确() 127.下列说法正确的有() 128.执行如下程序代码() 129.下列哪一种叙述是正确的() 130.下列语句正确的是() 131.成?#21271;?#37327;用static修饰和不用static修饰有什么区别? 132.如果变量用final修饰,则怎样?如果方法final修饰,则怎样? 133.在二进制数据?#26657;?#23567;数点向右移一位,则数据() 134.面向对象的特征有哪些方面? 135.float f=3.4;是否正确? 136.short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗? 137.Java 有没有goto? 138.int 和Integer 有什么区别? 139.&和&&的区别? 140.Math.round(11.5) 等于多少? Math.round(-11.5)等于多少? 141.swtich 是否能作用在byte 上,是否能作用在long 上,是否能作用在String上? 142.用最有效率的方法计算2乘以8? 143.在Java ?#26657;?#22914;何跳出当前的多重?#30701;?#24490;环? 144.构造器(constructor)是否可被重写(override)? 145.两个对象值相同(x.equals(y) == true),但却可有不同的hash code,这句话对不对? 146.当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里到?#36164;?#20540;传递?#25925;且么?#36882;? 147.重载(Overload)和重写(Override)的区别。重载的方法能否根据返回类型进行区分? 148.华为的面试题?#24615;?#32463;?#20351;?#36825;样一个问题:为什么不能根据返回类型来区分重载,为什么? 149.静态?#30701;?#31867;(Static Nested Class)和内部类(Inner Class)的不同? 150.抽象的(abstract)方法是否可同时是静态的(static),是否可同时是本地方法(native),是否可同?#21271;籹ynchronized修饰? 151.静态变量和实例变量的区别? 152.是否可以从一个静态(static)方法内部发出对非静态(non-static)方法的调用? 153.如?#38382;?#29616;对象克隆? 154.接口是否可继?#26657;╡xtends)接口? 抽象类是否可实?#37073;╥mplements)接口? 抽象类是否可继承具体类(concrete class)? 155.一个“.java”源文件中是否可以包含多个类(不是内部类)?有什么限制? 156.Anonymous Inner Class(匿名内部类)是否可以继承其它类?是否可以实现接口? 157.内部类可以引用它的包含类(外部类)的成员吗?有没有什么限制? 158.Java 中的final关键字有哪些用法? 159.指出下面程序的运?#34218;?#26524;: 160.说说数据类型之间的转换: 161.如?#38382;?#29616;字符串的反转及替换? 162.怎样将GB2312编码的字符串转换为ISO-8859-1编码的字符串? 163.Java中的日期和时间: 164.打印昨天的当前时刻。 165.Java反射技术主要实现类有哪些,作用分别是什么? 166.Class类的作用?#21487;?#25104;Class对象的方法有哪些? 167.反射的使用场合和作用、及其优缺点 168.面向对象设计原则有哪些
String相关
169.下面程序的运?#34218;?#26524;是()(选择一项) 170.Java语言?#26657;琒tring类中的indexOf()方法返回值的类型是() 171.给定以下代码,程序的运?#34218;?#26524;是 ()(选择一项) 172.执行下?#20889;?#30721;后,哪个结论是正确的()(选择两项) 173.实现String类的replaceAll方法 174.在“=”后填写?#23454;?#30340;内容: 175.是否可以继承String类? 176.给定两个字符串s和t, 写一个函数来决定是否t是s的重组词。你可以假设字符串只包含小写字母。 177.String s=new String(“abc”);创建了几个String对象。 178.输出结果? 179.下列程序的输出结果是什么? 180.关于java.lang.String类,以下描述正确的一项是() 181.下面哪个是正确的() 182.已知如下代码:执?#34218;?#26524;是什么() 183.字符串如何转换为int类型 184.写一个方法,实现字符串的反转,如:输入abc,输出cba 185.编写java,将“I follow Bill Gate.Tom Gate.John Gate”中的“Gate”全部替换为“Gates” 186.String 是最基本的数据类型吗? 187.String 和StringBuilder、StringBuffer 的区别? 188.String类为什么是final的 189.String类型是基本数据类型吗?基本数据类型有哪些 190.String?s="Hello";s=s+"world!";执行后,是否是对前面s指向空间内容的修改? 191.String s = new String("xyz");创建几个String Object? 192.下面这条语句一共创建了多少个对象:String s="a"+"b"+"c"+"d";
集合
193.Java集合体系结构(List、Set、Collection、Map的区别和联系) 194.Vector和ArrayList的区别和联系 195.ArrayList和LinkedList的区别和联系 196.HashMap和Hashtable的区别和联系 197.HashSet的使用和原理(hashCode()和equals()) 198.TreeSet的原理和使用(Comparable和comparator) 199.集合和数组的比较(为什么引入集合) 200.Collection和Collections的区别 201.下列说法正确的有()(选择一项) 202.Java的HashMap和Hashtable有什么区别HashSet和HashMap有什么区别?使用这些结构保存的数需要重载的方法是哪些? 203.列出Java中的集合类层次结构? 204.List,Set,Map各有什么特点 205.ArrayList list=new ArrayList(20);中的list扩充几次() 206.List、Set、Map哪个继承自Collection接口,一下说法正确的是() 207.合并两个有序的链表 208.用递归方式实现链表的转置。 209.给定一个不包含相同元素的整数集合,nums,返回所有可能的子集集合。解答中集合不能包含重复的子集。 210.以下结构?#26657;?#21738;个具有同步功能() 211.以下结构?#26657;?#25554;入性能最高的是() 212.以下结构?#26657;?#21738;个最适?#31995;?#20316;stack使用() 213.Map的实现类?#26657;?#21738;些是有序的,哪些是无序的,有序的是如何保证其有序性,你觉得哪个有序性性能更高,你有没有更好或者更高效的实现方式? 214.下面的代码在绝大部分时间内都运行得很正常,请问什么情况下会出现问题?根源在哪里? 215.TreeMap和TreeSet在排序时如何比较元素?Collections工具类中的sort()方法如何比较元素? 216.List里面如何剔除相同的对象?请简单?#20040;?#30721;实现一种方法 217.Java.util.Map的实现类有 218.下?#34892;?#36848;中正确的是() 219.List、Set、Map 是否继承自Collection 接口? 220.说出ArrayList、Vector、LinkedList 的存储性能和特性? 221.List、Map、Set 三个接口,存取元素时,各有什么特点? 222.TreeMap和TreeSet在排序时如何比较元素?Collections工具类中的sort()方法如何比较元素?
多线程
223.下面程序的运?#34218;?#26524;()(选择一项) 224.下列哪个方法可用于创建一个可运行的类() 225.说明类java.lang.ThreadLocal的作用和原理。列举在哪些程序中见过ThreadLocal的使用? 226.说说乐观锁与悲观锁 227.在Java?#24615;?#20040;实现多线程?描述线程状态的变化过程。 228.请写出多线程代码使用Thread或者Runnable,并说出两种的区别。 229.在多线程编程里,wait方法的调用方式是怎样的? 230.Java线程的几种状态 231.在Java多线程?#26657;?#35831;用下面哪种方?#35762;换?#20351;线程进入阻塞状态() 232.volatile关键字是否能保证线程安全? 233.请写出常用的Java多线程启动方式,Executors线程池有几种常用类型? 234.关于sleep()和wait(),以下描述错误的一项是() 235.进程和线程的区别是什么? 236.以下锁机机制?#26657;?#19981;能保证线程安全的是() 237.创建n多个线程,如何保证这些线程同时启动?看清,是“同时”。 238.同步和异步有?#25105;?#21516;,在什么情况下分别使用它们? 239.Java线程?#26657;瑂leep()和wait()区别 240.下面所述步骤?#26657;?#26159;创建进程做必须的步骤是() 241.无锁化编程有哪些常见方法?() 242.sleep()和yield()有什么区别? 243.当一个线程进入一个对象的synchronized方法A之后,其它线程是否?#23665;?#20837;此对象的synchronized方法? 244.请说出与线程同步相关的方法。 245.编写多线程程序有几种实现方式? 246.synchronized关键字的用法? 247.启动一个线程是用run()?#25925;莝tart()方法? 248.什么是线程池(thread pool)? 249.线程的基本状态以及状态之间的关系? 250.简述synchronized 和java.util.concurrent.locks.Lock的异同? 251.创建线程的两种方式分别是什么,优缺点是什么? 252.Java创建线程后,调用start()方法和run()的区别 253.线程的生命周期 254.如?#38382;?#29616;线程同步? 255.说说关于同步锁的更多细节 256.Java中实现线程通信的三个方法的作用是什么?
Web方面相关
291.WEB应用中如果有.class和.jar类型的文件一般分别应该放在什么位置? 292.元素中有一个输入框(< input type=‘text’ name=’username‘id=’username”value=‘’"/>,请用JavaScript语言写一?#20889;?#30721;,取得这个输入框中的值。 293.简单描述一下Servlet与JSP的的相同点和区别点。 294.请简单描述?#24405;?#20010;您熟悉JavaScript库,它们有哪些作用和特点? 295.简单描述HTML,CSS,Javascript在Web开发中分别起什么作用? 296.当DOM加载完成后要执行的函数,下面哪个是正确的() 297.举例说明JAVA中如何解析xml,不同方式有和优缺点? 299.一个类可以实现多个接口,但只能继承一个抽象类。 300.比较一下Java 和JavaSciprt 301.什么时候用assert? 302.UML是什么?UML中有哪些图? 303.XML 文档定义有几种?#38382;剑?#23427;们之间有何本质区别?解析XML 文档有哪几种方式? 304.你在项目中哪些地方用到了XML? 305.用JavaScript实现用正则表达式验证,某个字符串是合法的6位数字的?#26102;?#30340;函数 306.请使用JQuery将页面上的所有元素边框设置为2pix宽的虚线? 307.如何设定JQuery异步调用?#25925;?#21516;步调用? 308.说出3条以上firefox和IE的浏览器兼容问题? 309.请用Jquery语言写出ajax请求或者post请求代码 310.body中的onload ()函数和jQuery中document.ready()有什么区别? 311.jQuery中有哪几种类型的选择器? 312.EasyUI中datagrid刷新当前数据的方法? 313.分别写出一个div居中和其中的内容居中的css属性设置 314.概述一下session与cookie的区别 315.JavaScript 中 null和 undefined 是否有区别?有哪些区别? 316.Servlet中的doPost和doGet方法有什么区别?它们在传递和获取参数上有什么区别? 317.请写出一段jQuery代码,实现?#35757;?#21069;页面中所有的a元索中class 属性为“view-link”的链接都改为在新窗口?#20889;?#24320; 318.如下JavaScript代码的输出为: 319.Jquery?#23567;?get()’与’.eq()’的区别 320.如何给weblogic定内存的大小? 321.TCP为何采用三次握手来建立连接,若釆用二次握手可以吗,请说明理由? 322.以下HTTP相应状态码的含义描述正确的是() 323.JSP页面包括哪些元素?() 324.Ajax有四种技术组成:DOM,CSS,JavaScript,XmlHttpRequest,其中控制文档结构的是() 325.下面关于session的用法哪些是错误的?() 326.Jsp九大内置对象 327.如何配置一个servlet? 328.JavaScript,如何定义含有数值1至8的数组? 329.以下JavaScipt语句会产生运?#20889;?#35823;的是_() 330.在JSP?#26657;?#19979;面__()__块中可以定义一个新类: 331.HTML含义和版本变化 332.什么是锚链接 333.HTML字符实体的作用及其常用字符实体 334.HTML表单的作用和常用表单项类型 335.表格、框架、div三种HTML布局方式的特点 336.form中input设置为readonly和disabled的区别 337.CSS的定义和作用 338.CSS2常用选择器类型及其含义 339.引入样式的三种方式及其优先级别 340.盒子模型 341.JavaScript语言及其特点 342.JavaScript常用数据类型有哪些 343.html语法中哪条命令用于使一行文本折?#26657;?#32780;不是插入一个新的段落? (B) 344.Ajax的优点和缺点 345.怎样?#20048;?#34920;单刷新重复提交问题?(说出思路即可) 346.JQuery.get()和JQuery.ajax()方法之间的区别是什么? 347.Jquery里的缓存问题如何解决?例如($.ajax()以及$.get()) 348.Javascript是面向对象的,怎么体现Javascript的继承关系? 349.Javascript的有几种种变量。变量?#27573;?#26377;什么不同? 350.Js如何获取页面的dom对象 351.Servlet API中forward() 与redirect()的区别? 352.Session域和request域什么区别? 353.页面中有一个命名为bankNo的下拉列表,写js脚本获取当前选项的索引值,如果用jquery如何获取 354.写出要求11位数字的正则表达式 355.分别获取指定name、Id的javascript对象,如果用jquey如何获取 356.一个页面有两个form,如何获取第一个form 357.如何设置一个层?#30446;?#35265;/隐藏 358.描述JSP中动态INCLUDE与静态INCLUDE的区别? 359.列举JSP的内置对象及方法 360.列举jsp的四大作用域 361.html和xhtml的区别是什么? 362.你做的页面用哪些浏览器测试过?这些测试的内核分别是什么? 363.你遇到了哪些浏览器的兼容性问题?怎么解决的? 364.你知道的常用的js库有哪些? 365.Js中的三种弹出式消息提醒(警告窗口、确认窗口、信息输入窗口)的命令是什么? 366.谈谈js的闭包 367.写一段js,遍历所有的li,将每个li的内容逐个alert出来 368.页面上如何用JavaScript对多个checkbox全选 369.写一个简单的JQuery的ajax 370.Js截取字符串abcdefg的efg 371.http的请求头信息包含了什么? 372.http的响应码200,404,302,500表示的含义分别是? 373.Servlet中request对象的方法有? 374.Javascript的常用对象有哪些 375.DOM和BOM及其关系 376.JavaScript中获取某个元素的三种方式JavaScript中的三种弹出式消息提醒命令是什么? 377.JavaScript操作CSS的两种方式 378.静态网页和动态网页的联系和区别 379.JSP/ASP/PHP的比较 380.CGI/Servlet/JSP的比较 381.HTTP协议工作原理及其特点 382.get和post的区别 383.如何解决表单提交的中文乱码问题 384.绝对路径、根路径、相对路径的含义及其区别 385.如实现servlet的单线程模式 386.Servlet的生命周期 387.转发和重定向的区别 388.JSP的执行过程 389.JSP动作有哪些,简述作用? 390.page/request/session/application作用域区别 391.JSP和Servlet的区别和联系 392.谈谈过滤器原理及其作用? 393.jQuery相比JavaScript的优势在哪里 394.DOM对象和jQuery对象的区别及其转换 395.jQuery中$的作用主要有哪些 396.Ajax含义及其主要技术 397.Ajax的工作原理 398.JSON及其作用 399.文件上传组件Common-fileUpload的常用类及其作用? 400.说出Servlet的生命周期,并说出Servlet和CGI的区别? 401.JSP 和Servlet 有有什么关系? 402.JSP中的四种作用域? 403.如?#38382;?#29616;JSP或Servlet的单线程模式? 404.实现会?#26696;?#36394;的技术有哪些? 405.过滤器有哪些作用和用法? 406.监听器有哪些作用和用法? 407.你的项目中使用过哪些JSTL标签? 408.使用标签库有什么?#20040;Γ?#22914;何自定义JSP标签? 409.表达式语言(EL)的隐式对象及其作用? 410.表达式语言(EL)支持哪些运算符? 411.Servlet 3中的异步处理指的是什么? 412.如何在基于Java的Web项目中实现文件上传和下载? 413.简述值栈(Value-Stack)的原理和生命周期 414.阐述Session加载实体对象的过程。 415.怎么?#20048;?#37325;复提交 416.$(document).ready(function(){}) jQuery(document).ready(function(){}); 有什么区别? 417.写出输出结果 418.web项目从浏览器发起交易响应缓慢,请简述从哪些方面如数分析
高级框架
431.什么是Maven? 432.Maven和ANT的区别 433.Maven仓库是什么 434.Maven的工程类型有哪些? 435.Maven常用命令有哪些? 436.ZooKeeper的作用是什么? 437.什么是Znode? 438.Znode节点类型有哪些? 439.什么是Dubbo? 440.什么是RPC远程过程调用? 441.Dubbo中有哪些角色? 442.Dubbo执行流程什么是? 443.说说Dubbo支持的协议有哪些? 444.Dubbo支持的注册?#34892;?#26377;哪些? 445.SessionFactory是线程安全的吗?Session是线程安全的吗,两个线程能?#36824;?#20139;同一个Session吗? 446.Session的load和get方法的区别是什么? 447.Session的save()、update()、merge()、lock()、saveOrUpdate()和persist()方法有什么区别? 448.什么是VSFTPD? 449.什么是Nginx? 450.Nginx有哪些作用? 451.什么是正向代理? 452.什么是反向代理? 453.什么是Redis? 454.Redis的特点什么是? 455.Redis数据类型有哪些? 456.Redis中的常用命令哪些? 458.什么是RDB方式? 459.什么是AOF方式? 460.什么是全文检索? 461.什么是Lucene? 462.什么是Solr? 463.Solr是由哪两个部分构成? 464.什么是正排索引? 465.什么是倒排索引? 466.什么是ActiveMQ? 467.消息服务的应用场景有哪些? 468.什么是JMS? 469.JMS有哪些模型? 470.什么是JsonP? 471.什么是跨域? 472.什么是同源策略? 473.什么是MyCat? 474.什么是纵向切分/垂直切分? 475.简述Tomcat,Apache,JBoss和WebLogic的区别和联系 476.以下可以实现负载均衡的是() 477.Tomcat/ WebSphere/WebLogic的作用和特点 478.B/S和C/S的含义及其区别 479.说?#30340;?#23545;容器的理解 480.为什么要使用连接池? 481.数据库连接池的原理 482.MVC模式及其优缺点 483.MVC模式完成分页功能的基本思路是什么? 484.常用的Web容器 485.Java Web开发的Model 1和Model 2分别指的是什么? 486.说说什么是框架: 487.简单说一下MVC框架? 488.简单讲一下struts2的执行流程 489.Struts2中的拦截器,你都用它干什么? 490.简单讲一下SpringMVC的执行流程? 491.简单说一下struts2和springMVC有什么不同 492.说一下Spring中的两大核心 493.讲一下Spring的事务的传播特性 494.什么是ORM 495.Hibernate对象的状态 496.介绍一下Hibernate的缓存 497.简单讲一下webservice使用的场景 498.简单介绍一下activity? 499.什么是MyBatis? 500.Mybatis是如何进行分页的?分页插件的原理是什么? 501.MyBatis与Hibernate有哪些不同? 502.简述Mybatis的Xml映射文件和Mybatis内部数据结构之间的映射关系? 504.Mybatis能执行一对一、一对多的关联查询吗?都有哪些实现方式,以及它们之间的区别? 505.MyBatis里面的动态Sql是怎么设定的?用什么语法? 506.使用MyBatis的mapper接口调用时有哪些要求? 508.MyBatis接口绑定有几种实现方式,分别是怎么实现的? 509.MyBatis实现一对一有几种方式?具体怎么操作的? 510.什么情况下用注解绑定,什么情况下用xml绑定? 511.MyBatis的?#20040;?#26159;什么?
数据库
538.下列属于关系型数据库的是()(选择两项) 539.请列出Java常见?#30446;?#28304;数据连接池,并对参数做出简单的说明 540.储蓄所有多个储户,储户在多个储户所存取款,储蓄所与储户之间是() 541.视图是一个“虚表?#20445;?#35270;图的构造基于() 542.设有关系R(A,B,C,D)及其上的函数相关性集合F={B→A,BC→D},那么关系R最高是() 543.什么是DAO模式? 544.数据库MySQL,Oracle,SqlServer分页时用的语句 545.Oracle完成分页功能的三层子查询语句及其含义? 546.问SQL怎么优化执行效率更高 547.谈谈数据库去空格的情况 548.根据你以往的经验简单叙述一下MYSQL的优化 549.以Oracle11R为例简述数据库集群部署 550.说一下数据库的存储过程? 551.数据库创建索引的缺点? 552.有两张表;请用SQL查询,所有?#30446;?#25143;订单日期最新的前五条订单记录。(分别注明MySQL. Oracle写法) 553.关于HQL与SQL,以下哪些说法正确?() 554.下面是学生表(student)的结构说明 555.为管理岗位业务培训信息,有如下3个表: 556.用Java怎么实现有每天有1亿条记录的DB储存?MySQL上亿记录数据量的数据库如何设计? 557.Mysql的引擎有哪些?支持事物么?DB储存引擎有哪些? 558.以?#29575;?#23398;生考试结果表 559.库中已经存在雇用表表名: 560.如下表1中的数据,表名为:t_test,记录某场?#28909;?#30340;结果。 561.请将如下数据库语句进行优化,使其执行效率更高(提示:…不需要更改) 562.请简述如何将Oracle中的数据库转至DB2?#26657;?#38656;要保证表结构和数据不变 563.学生成绩表 564.Oracl数据库中有两张表Stu(学生表)和Grade(分数表),如下图所示: 565.下面是学生表(Student)的结构说明: 566.取出sql表中低31到40的记录(以自动增长ID为主键) 567.下列两个表,需要用一条sql语句把b表中的ID和NAME 字段的数值复?#39057;紸表中 568.什么是基本表,什么是视图,两者的区别和联系是什么? 569.什么是事务?什么是锁? 570.Student学生表(学号,姓名、?#21592;稹?#24180;龄、组织部门),Course 课程表(编号,课?#22530;?#31216;),Sc选课表(学号,课程编号,成绩) 571.sql查询
Linux操作
580.请写出常用的linux指令不低于10个,请写出linux tomcat启动。 581.当使用RMI技术实现远程方法调用时,能为远程对象生成Sub和Skeleton命令的是() 582.以下哪个是服务() 583.下面的网络协议?#26657;?#38754;向连接的的协议是: () 584.在/etc/fstab 文件中指定的文件系统加载参数?#26657;?() 参数一般用于CD-ROM 等移动设备。 585.Linux 文件权限一共10 位长度,分成四段,第三段表示的内容是 () 586.终止一个前台进程可能用到的命令和操作 () 587.在使用mkdir 命令创建新的目录时,在其父目录不存在时先创建父目录的选项是 () 588.下面关于i 节点描述错误的是 () 589.一个文件名字为rr.Z,可以用来解压缩的命令是: () 590.具有很多C 语言的功能,又称过滤器的是 () 591.一台主机要实现通过局域网与另一个局域网通信,需要做的工作是 () 592.建立动态路?#23578;?#35201;用到的文件有 () 593.局域网的网络地址192.168.1.0/24,局域网络连接其它网络的网关地址是192.168.1.1。主机192.168.1.20 访问172.16.1.0/24 网络时,其路由设置正确的是 () 594.下列提法?#26657;?#19981;属于ifconfig 命令作用?#27573;?#30340;是 () 595.下列关于链?#29992;?#36848;,错误的是() 596.在局域网络内的?#31243;?#20027;机用ping 命令测试网络连接时发现网络内部的主机都可以连同,而不能与公网连通,问题可能是() 597.下列文件?#26657;?#21253;含了主机名到IP 地址的映射关系的文件是: 598.不需要编译内核的情况是() 599.在shell 中变量的赋值有四种方法,其?#26657;?#37319;用name=12 的方法称 () 600.()命令可以从文本文件的每一行?#34218;?#21462;指定内容的数据。 601.下列不是Linux 系统进程类型的是() 602.在日常管理?#26657;?#36890;常CPU 会影响系统性能的情况是: () 603.若一台计算机的内存为128MB,则?#25442;?#20998;区的大小通常是 604.在安装Linux 的过程中的第五步是让用户选择安装方式,如果用户希望安装部分组件(软件程序),并在选择好后让系统自动安装,应该选择的选项是() 605.Linux 有三个查看文件的命令,若希望在查看文件内容过程中可以用光标上下移动来查看文件内容,应使用()命令 606.下?#34892;?#24687;是某系统用ps –ef 命令列出的正在运行的进程 ()进程是运行Internet 超级服务器,它负责监听Internet sockets 上的连接,并调用合适的服务器?#21019;?#29702;接收的信息。 607.在TCP/IP 模型?#26657;?#24212;用层包含了所有的高层协议,在下列的一些应用协议?#26657;?()是能够实现本地与远程主机之间的文件传输工作 608.当我们与某远程网络连接不上时,就需要跟踪路由查看,?#21592;?#20102;解在网络的什么位置出现了问题,满足该目的的命令是() 609.对名为fido 的文件用chmod 551 fido 进行了修改,则它的许可权是() 610.用ls –al 命令列出下面的文件列表,()文件是符号连接文件 611.DNS 域名系统主要负责主机名和()之间的解析。 612.WWW 服务器是在Internet 上使用最为广?#28023;?#23427;采用的是()结构 613.Linux 系统通过()命令给其他用户发消息。 615.()命令可以在Linux 的安全系统?#22411;?#25104;文件向磁带备份的工作 616.Linux 文件系统的文件?#21450;?#20854;作用分门别类地放在相关的目录?#26657;?#23545;于外部设备文件,一般应将其放在()目录中 617.在重新启动Linux 系统的同时把内存中的信息写入硬盘,应使用()命令实现 618.网络管理具备以?#24405;?#22823;功能?#21495;?#32622;管理、()、性能管理、安全管理和?#21697;?#31649;理等 619.关闭linux 系?#24120;?#19981;重新启动)可使用命令() 620.实?#25191;覫P 地址到以太网MAC 地址转换的命令为: () 621.在vi 编辑器中的命令模式下,键入()可在光标当前所在行下添加一新行 622.在vi 编辑器中的命令模式下,删除当前光标处的字符使用()命令 623.在vi 编辑器中的命令模式下,重复上一次?#21592;?#36753;的文本进行的操作,可使用()命令 624.删除文件命令为: () 625.退出交互模式的shell,应键入()
算法分析及?#20013;创?#30721;
626.判断身份证:要么是15位,要么是18位,最后一位可以为字母,并写出程序提出其中年月日。要求: 627.对于一个字符串,请设计一个高效算法,?#19994;?#31532;一次重复出现的字符保证字符串中有重复的字符,字符串的长度小于等于500. 628.写一个完整函数,实现拷贝数组 629.写一排序算法,输入10个数?#37073;?#20197;?#27721;?#20998;开,可根据参数选择升序或者降序排序,须注明是何种排序算法。 630.判断字符串是否是这样的组成的,第一个字母,后面可以是字母、数字、下划线、总长度为5-20。 633.请用递归的方法计算斐波那契数列的同项F(n),已知F0=0,F1=1,F(n)=F(n-1)+F(n-2)(n>=2,n∈N*). 634.现在有整数数组{11,66,22,0,55,32},请?#25105;?#36873;择一种排序算法,用Java程序实现 635.请根据注释,编码实现下面类的方法 637.编写一段Java程序,把一句英语中的每个单词中的字母次序倒转,单词次序保持不变,例入输入为“There is a dog.”,输出结果应该是“erehT si a god.”要求不使用Java的库函数,例如String类的split,reverse方法。 638.手写9x9乘法表,冒泡排序 639.题目: 给定一个整数数组,?#19994;?#26159;否该数组包含任何重复数字。你的函数应该返回true只要有任何数字 在该数组中重复出?#37073;?#21542;则返回false。 640.给定一个数组nums, 写一个函数来移动所有0元素到数组末尾,同时维持数组中非0元素的相对顺序不变。要求不能申请额外的内存空间,并且最小化操作次数。 641.给定一颗二叉树,返回节点值得先序遍历,请使用迭代(非递归)方式实现。 642.验证一棵树是否为有效的二叉搜索树BST 643.从一个链表中删除节点 644.二叉搜索树BST中第Kth小的元素 题目:给定?个BST,写一个函数kthSmallest来?#19994;?#31532;kth小的元素 645.题目:给定含有n个整数的数组S,S中是否存在三个元素a,b,c使得a + b + c = 0? ?#19994;?#25152;有这样的三元 组,并且结果集中不包含重复的三元组。 646.子集问题 647.迭代方法实现二叉树的先序遍历:题目: 给定一颗?叉树,返回节点值得先序遍历,请使用迭代(非递归)方式实现。 648.验证二叉搜索树BST:题目: 验证一棵树是否为有效的二叉搜索树BST?#28909;紓?#20108;叉树[2, 1, 3],返回true二叉树[1, 2, 3], 返回false 649.编辑距离题目: 给定两个单词word1和word2,?#19994;?#26368;小的操作步骤使得word1转换成word2,每次操作算作一 ?#20581;?#20320;可以对单?#24335;?#34892;以下三种操作:1)插入一个字符2)删除一个字符3)替换一个字符 650.买卖股票问题:题目: 你有一个数组,第i个元素表示第i天某个股票的价格,设计一个算法?#19994;?#26368;大的利润,并且你只能最多完成两次交易。 651.[编程]任给n个整数和一个整数x。请计算n个整数中有多少对整数之和等于x。 652.[编程]请说明快速排序算法的设计思想和时间复杂度,并用高级语言写出对整数数组进行一趟快排的函数实现。 653.对于一段形如:1,-1~3,1~15×3的输入 654.有两个字符串:目标串S=“s1s2.......sn?#20445;?#27169;式串T="t1t2.......tm"。若存在T的每个字符一次和S中的一个连续字符序列相等,则匹配成功,返回T中第一个字符在S中的位置。否则匹配不成功,返回0。写出你的算法,要求线性时间复杂度 655.如何生成一个0-100的随机整数? 656.请编写一段Java程序将两个有序数组合并成一个有序数组 657.在最佳情况下,以下哪个时间复杂度最高(D) 658.一个数组,元素为从0到m的整数,判断其中是否有重复元素,使用java语?#21592;?#20889;一个方法 659.某二叉树的先序遍历是12453,中序遍历是42513,那么其后序遍历是(A) 660.设一颗二叉树中有3个叶子节点,有八个度为1的节点,则该二叉树中总的节点数为() 662.你知道的排序算法都哪些?用Java写一个排序系统 663.写一个二分查找(折半搜索)的算法。 664.统计一篇英文文章单词个数。 665.输入年月日,计算该日期是这一年的第几天。 666.回文素数:所谓回文数就是顺着读和倒着读一样的数(例如:11,121,1991…),回文素数就是既是回文数又是素数(只能被1和自身整除的数)的数。编程?#39029;?1~9999之间的回文素数。 668.对于一个有N个整数元素的一维数组,?#39029;?#23427;的子数组(数组中下标连续的元素组成的数组)之和的最大值。 669.用递归实现字符串倒转 670.输入一个正整数,将其分解为素数的乘积。 671.一个有n级的台阶,一次可以走1级、2级或3级,?#39318;?#23436;n级台阶有多少种走法。 672.写一个算法判断一个英文单词的所有字母是否全都不同(不区分大小写) 673.有一个已经排好序的整数数组,其?#20889;?#22312;重复元素,请将重复元素删除掉,例如,A= [1, 1, 2, 2, 3],处理之后的数组应当为A= [1, 2, 3]。 674.给一个数组,其中有一个重复元素?#21450;?#25968;以上,?#39029;?#36825;个元素。 675.编写一个方法求一个字符串的字节长度?
第三篇:热门专业学习之路
?#25226;?/div>

本题集由尚学堂学员整理,列举了众多IT公司面试真题,对应聘Java程序员职位的常见考点和知识体系都进行的分类和归纳整理。

本题集适合应聘Java和JavaEE职位的程序员作为面试复习、学习和强化的资料,也适合其他程序员作为拓展读物进?#24615;?#35835;。

本题集包含了常见的算法、面试题,也包含了新的高?#37117;?#26415;,?#28909;紓何?#26381;务架构等技术的面试题目。本题集非常全面,对于工作1-5年左?#19994;膉ava程序员面试有非常好的指导作用。

大家?#37096;?#20197;访问(直接在线观看最新版的面试题):www.vhdwzj.tw/javamianshiti.html

卓越班(年薪18万起)

国内还有比这更高?#35828;目?#21527;?

1.大学生高端复合人才成长方案,年薪18万起。
1.JAVA专业,1000课 3.大数据专业,500课
2.Python专业,500课    4.人工智能专业,500课

四个专业都要学,从零开始2000小时,成为高端人才,打下一生技术基础,不再是低端码农。

2.扫一扫,咨询详情:

访?#20351;?#32593; www.itbaizhan.cn

Java基础、语法:

1.Java跨平台原理(字节码文件、虚拟机)

C/C++语言都直接编译成针对特定平台机器码。如果要跨平台,需要使用相应的编译器重新编译。

Java源程序(.java)要?#32570;?#35793;成与平台无关的字节码文件(.class),然后字节码文件再解释成机器码运?#23567;?#35299;释是通过Java虚拟机来执行的。

字节码文件不面向任何具体平台,只面向虚拟机。

Java虚拟机是可运行Java字节码文件的虚拟计算机。不同平台的虚拟机是不同的,但它们都提供了相同的接口。

Java语言具有一次编译,到处运行的特点。就是说编译后的.class可以跨平台运?#26657;?#21069;提是该平台具有相应的Java虚拟机。但?#20999;?#33021;比C/C++要低。

Java?#30446;?#24179;台原理决定了其性能没有C/C++高

2.Java的安全性

语言层次的安全性主要体现在:

Java取消了强大但又危险的指针,而代之以引用。由于指针?#23665;?#34892;移动运算,指针可随便指向一个内存区域,而不管这个区域是否可用,这样做是危险的,因为原来这个内存地址可能存储着重要数据或者是其他程序运行所占用的,并且使用指针也容易数组越界。

垃圾回收机制:不需要程序员直接控制内存回收,由垃圾回收器在后台自动回收不再使用的内存。避免程序忘记及时回收,导致内存泄露。避免程序错误回收程序核心类库的内存,导致系统?#35272;!?/p>

异常处理机制:Java异常机制主要?#35272;?#20110;try、catch、finally、throw、throws五个关键字。

强?#35780;?#22411;转换:只有在满足强制转换规则的情况下才能强转成功。

底层的安全性可以从以下方面来说明

Java在字节码的传输过程中使用了公开密?#32771;用?#26426;制(PKC)。

在运行环?#31243;?#20379;了四级安全?#21592;?#38556;机制:

字节码校验器 -类装载器 -运行时内存布局 -文件访问限制

3.Java三大版本

Java2平台包括标准版(J2SE)、企业版(J2EE)和微缩版(J2ME)三个版本:

Standard Edition(标准版) J2SE 包含?#20999;?#26500;成Java语?#38498;?#24515;的类。

?#28909;紓?#25968;据库连接、接口定义、输入/输出、网络编程

Enterprise Edition(企业版) J2EE 包含J2SE 中的类,并?#19968;?#21253;含用于开发企业级应用的类。

?#28909;鐂ervlet、JSP、XML、事务控制

Micro Edition(微缩版) J2ME 包含J2SE中一部分类,用于消费类电子产品的软件开发。

?#28909;紓汉?#26426;、智能卡、手机、PDA、机顶盒

他们的?#27573;?#26159;:J2SE包含于J2EE?#26657;琂2ME包含了J2SE的核心类,但新添加了一些专有类

应用场合,API的覆盖?#27573;?#21508;不相同。

4.什么是JVM?什么是JDK? 什么是JRE?

JVM :JVM是Java Virtual Machine(Java虚拟机)的缩写,它是整个java实现跨平台的最核心的部分,所有的java程序会首?#32570;?#32534;译为.class的类文件,这种类文件可以在虚拟机上执?#26657;?#20063;就是说class并不直接与机器的操作系统相对应,而是经过虚拟机间接与操作系统交互,?#23578;?#25311;机将程序解释给本地系统执?#23567;VM是Java平台的基础,和实际的机器一样,它也有自己的指令集,并?#20197;?#36816;行时操作不同的内存区域。?JVM通过抽象操作系统和CPU结构,提供了一种与平台无关的代码执行方法,即与特殊的实现方法、主机硬件、主机操作系统无关。JVM的主要工作是解释自己的指令集(即字节码)到CPU的指令集或对应的系统调用,保护用户免被恶意程序骚扰。?JVM对上层的Java源文件是不关心的,它关注的只是由源文件生成的类文件(.class文件)。

JRE:JRE是java runtime environment(java运行环?#24120;?#30340;缩?#30784;?#20809;有JVM还不能让class文件执?#26657;?#22240;为在解释class的时候JVM需要调用解释所需要的类库lib。在JDK的安装目录里你可以?#19994;絡re目录,里面有两个文件夹bin和lib,在这里可以认为bin里的就是jvm,lib?#24615;?#26159;jvm工作所需要的类库,而jvm和lib和起来就称为jre。所以,在你写完java程序编译成.class之后,你可以把这个.class文件和jre一起打包发给朋友,这样你的朋友就可以运行你写程序了(jre里有运行.class的java.exe)。JRE是Sun公司发布的一个更大的系?#24120;?#23427;里面就有一个JVM。JRE就与具体的CPU结构和操作系统有关,是运行Java程序必不可少的(除非用其他一些编译环境编译成.exe可执行文件……),JRE的地位就象一台PC机一样,我?#20999;?#22909;的Win32应用程序需要操作系统帮我们运?#26657;?#21516;样的,我们编写的Java程序也必须要JRE才能运?#23567;?

JDK:JDK是java development kit(java开发工具包)的缩?#30784;?#27599;个学java的人都会先在机器上装一个JDK,那 让我们看一下JDK的安装目录。在目录下面有六个文件?#23567;?#19968;个src类库源码压缩包、和其他几个声明文件。其?#26657;?#30495;正在运行java时起作用的是以下四个文件?#26657;篵in、include、lib、jre。现在我们可以看出这样一个关系,JDK包含JRE,而JRE包含JVM。

bin:最主要的是编译器(javac.exe)

include:java和JVM交互用的头文件

lib:类库??????

jre:java运行环境?

(注意:这里的bin、lib文件夹和jre里的bin、lib是不同的)总的来说JDK是用于java程序?#30446;?#21457;,而jre则是只能运行class而没有编译的功能。eclipse、idea等其他IDE有自己的编译器而不是用JDK?bin目录中?#28304;?#30340;,所以在安装时你会发现他们只要求你选jre路径就ok了。

JDK,JRE,JVM三者关系概括如下:

jdk是JAVA程序开发时用?#30446;?#21457;工具包,其内部也有JRE运行环境JRE。JRE是JAVA程序运行时需要的运行环?#24120;?#23601;是?#31561;?#26524;你光是运行JAVA程序而不是去搞开发的话,只安装JRE就能运行已经存在的JAVA程序了。JDk、JRE内部?#21450;?#21547;JAVA虚拟机JVM,JAVA虚拟机内部包含许多应用程序的类的解释器和类加载器等?#21462;?/p>

5.Java三种注释类型

共有单行注释、多行注释、文档注释3种注释类型。使用如下:

单行注释,采用“//”方式.只能注释一?#20889;?#30721;。如://类成?#21271;?#37327;

多行注释,采用“/*...*/”方式,可注释多?#20889;?#30721;,其中不允许出现?#30701;住?#22914;:

/*System.out.println("a");

System.out.println("b");

System.out.println("c");*/

文档注释,采用“/**...*/”方?#20581;?#22914;:

/**

* 子类 Dog

* @author Administrator

**/

public class Dog extends Animal{}

6.8种基本数据类型及其字节数
数据类型 关键字 字节数
数值型 整数型 byte 1
short 2
int 4
long 8
浮点型 float 4
double 8
布尔型 boolean 1(位)
字符型 char 2
7.i++和++i的异同之处

共同点:

1、i++和++i都是变量自增1,都等价于i=i+1

2、如果i++,++i是一条单独的语句,两者没有任何区别

3、i++和++i的使用仅仅针?#21592;?#37327;。 5++和++5会报错,因为5不是变量。

不同点:

如果i++,++i不是一条单独的语句,他们就有区别i++ ?#21512;?#36816;算后增1。如:

int x=5;
int y=x++;
System.out.println("x="+x+", y="+y);
    //以上代码运行后输出结果为:x=6, y=5

++i : 先增1后运算。如:

int x=5;
int y=++x;
System.out.println("x="+x+", y="+y);
    //以上代码运行后输出结果为:x=6, y=6
8.&和&&的区别和联系,|和||的区别和联系

&和&&的联系(共同点):

&和&&都可以用作逻辑与运算符,但是要看使用时的具体条件来决定。

操作数1&操作数2,操作数1&&操作数2,

表达式1&表达式2,表达式1&&表达式2,

情况1:当上述的操作数是boolean类型变量时,&和&&都可以用作逻辑与运算符。

情况2:当上述的表达式结果是boolean类型变量时,&和&&都可以用作逻辑与运算符。

表示逻辑与(and),当运算符两边的表达式的结果或操作数都为true时,整个运算结果才为true,否则,只要有一方为false,结果都为false。

&和&&的区别(不同点):

(1)、&逻辑运算符称为逻辑与运算符,&&逻辑运算符称为短路与运算符,?#37096;山新?#36753;与运算符。

对于&?#20309;?#35770;任何情况,&两边的操作数或表达式都会参与计算。

对于&&:当&&左边的操作数为false或左边表达式结果为false时,&&右边的操作数或表达式将不参与计算,此时最?#25112;?#26524;都为false。

综上所述,如果逻辑与运算的第一个操作数是false或第一个表达式的结果为false时,对于第二个操作数或表达式是否进?#24615;?#31639;,对最终的结果没有影响,结果肯定是false。?#24179;?#24179;时多使用&&,因为它效率更高些。

、&还可以用作位运算符。当&两边操作数或两边表达式的结果不是boolean类型时,&用于?#27425;?#19982;运算符的操作。

|和||的区别和联系与&和&&的区别和联系类似

9.用最有效率的方法算出2乘以8等于多少

使用位运算来实现效率最高。位运算符是对操作数以二进制比特位为单位进行操作和运算,操作数和结果都是整型数。对于位运算符“<<”, 是将一个数左移n位,就相当于乘以了2的n次方,那么,一个数乘以8只要将其左移3位即可,位运算cpu直接支持的,效率最高。所以,2乘以8等于几的最效率的方法是2 << 3

10.基本数据类型的类型转换规则

基本类型转换分为自动转换和强制转换。

自动转换规则:容量小的数据类型可以自动转换成容量大的数据类型,?#37096;?/p>

以说?#22270;?#33258;动向高级转换。这儿的容量指的不是字节数,而是指类型表述的?#27573;А?/p>

强制转换规则:高级变为?#22270;?#38656;要强制转换。

如何转换:

(1)赋值运算符“=”右边的转换,先自动转换成表达式中级别最高的数据类型,再进?#24615;?#31639;。

(2)赋值运算符“=”?#35762;?#30340;转换,若左边级别>右边级别,会自动转换;若左边级别 == 右边级别,不用转换;若左边级别 < 右边级别,需强制转换。

(3)可?#36234;?#25972;型常量直接赋值给byte, short, char等类型变量,而不需要进行强?#35780;?#22411;转换,前提是不超出其表述?#27573;В?#21542;则必须进行强制转换。

11.if多分支语句和switch多分支语句的异同之处

相同之处:都是分支语句,多超过一种的情况进行判断处理。

不同之处:

switch更适合用于多分支情况,就是有很多种情况需要判断处理,判断条件类型单一,只有一个入口,在分支执?#22411;?#21518;(如果没有break跳出),不?#20248;卸系?#25191;行下去;而if—elseif---else多分枝主要?#35270;?#20110;分支较少的分支结构,判断类型不是单一,只要一个分支被执行后,后边的分支不再执?#23567;witch为等值判?#24076;?#19981;允许?#28909;?= <=),而if为等值和区间都可以,if的使用?#27573;?#22823;。

12.while和do-while循环的区别

while先判断后执?#26657;?#31532;一次判断为false,循环体一次都不执行

do while先执行 后判?#24076;?#26368;少执行1次。

如果while循环第一次判断为true, 则两种循?#35775;?#26377;区别。

13.break和continue的作用

break: 结束当前循环并退出当前循环体。

break还可以退出switch语句

continue: 循环体中后续的语句不执?#26657;?#20294;是循?#35775;挥薪?#26463;,继续进行循环条件的判?#24076;╢or循环还会i++)。continue只是结束本次循环。

14.请使用递归算法计算n!
package com.bjsxt;
import java.io.File;
public class $ {
public static void main(String[] args) {
        String path = "D:/301SXT";
        test(path);
    }
    private static void test(String path) {
        File f = new File(path);
        File[] fs = f.listFiles();
        if (fs == null) {
            return;
        }
        for (File file : fs) {
            if (file.isFile()) {
                System.out.println(file.getPath());
            } else {
                test(file.getPath());
            }
        }
    }
15.递归的定义和优缺点

递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序?#26657;?#36882;归算法?#36234;?#20915;一大类问题是十分有效的,它往往使算法的描述简洁而且易于理解。

递归算法解决问题的特点:

(1) 递归就是在过程或函数里调用自身。

(2) 在使用递归策略时,必须有一个明确的递归结束条件,称为递归出口。

(3) 递归算法解题通常显得很简洁,但运行效率?#31995;汀?#25152;以一般不提倡用递归算法设计程序。

(4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈?#21019;?#20648;。递归次数过多容易造成栈溢出?#21462;?#25152;以一般不提倡用递归算法设计程序。

16.数组的特征

数组是(相同类型数据)的(有序)(集合)

数组会在内存中开辟一块连续?#30446;?#38388;,每个空间相当于之前的一个变量,称为数组的元素element

元素的表示 数组名[下标或者索引] scores[7] scores[0] scores[9]

索引从0开始

每个数组元素有默认值 double 0.0 boolean false int 0

数组元素有序的,不是大小顺序,是索引 的顺序

数组中可以存储基本数据类型,可以存储引用数据类型;但是对于一个数组而言,数组的类型是固定的,只能是一个

length:数组的长度

数组的长度是固定的,一经定义,不能再发生变化(数组的扩容)

17.请写出冒泡排序代码
package com.bjsxt;

public class TestBubbleSort {
public static void sort(int[] a) {
int temp = 0;
// 外层循环,它决定一共走几趟
for (int i = 0; i <a.length-1; ++i) {
//内层循环,它决定?#21051;?#36208;一次
for (int j = 0; j <a.length-i-1 ; ++j) {
//如果后一个大于前一个
if (a[j + 1] < a[j]) {
//换位
temp = a[j];a[j] = a[j + 1];a[j + 1] = temp;
}
}
}

public static void sort2(int[] a) {
int temp = 0;
for (int i = 0; i <a.length-1; ++i) {
//通过符号位可以减少无谓的比较,如果已经有序了,就退出循环
int flag = 0;
for (int j = 0; j <a.length-1-i ; ++j) {
if (a[j + 1] < a[j]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
flag = 1;
}
}
if(flag == 0){
break;
}
}
}
}
18.请写出选择排序的代码
package com.bjsxt;

public class TestSelectSort {
public static void sort(int arr[]) {
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
// 认为目前的数就是最小的, 记录最小数的下标
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[minIndex] > arr[j]) {
// 修改最小值的下标
minIndex = j;
}
}
// 当退出for就?#19994;?#36825;次的最小值
if (i != minIndex) {
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
}
19.请写出插入排序的代码
package com.bjsxt;

public class TestInsertSort {
public static void sort(int arr[]) {
int i, j;
for (i = 1; i < arr.length; i++) {
int temp = arr[i];
for (j = i; j > 0 && temp < arr[j - 1]; j--) {
arr[j] = arr[j - 1];
}
arr[j] = temp;
}
}
}
20.可变参数的作用和特点

总结1:可变参数

1.可变参数的?#38382;? ...

2.可变参数只能是方法的形参

3.可变参数对应的实参可以0,1,2.....个,?#37096;?#20197;是一个数组

4.在可变参数的方法?#26657;?#23558;可变参数当做数组?#21019;?#29702;

5.可变参数最多有一个,只能是最后一个

6.可变参数?#20040;Γ?#26041;便 简单 减少重载方法的数量

7.如果定义了可变参数的方法,不允许同时定义相同类型数组参数的方法

总结2:数组做形参和可变参数做形参联系和区别

联系:

1.实参都可以是数组;2.方法体?#26657;?#21487;变参数当做数组?#21019;?#29702;

区别:

1.个数不同 可变参数只能有一个数组参数可以多个

2.位置不同 可变参数只能是最后一个 数组参数位置?#25105;?/p>

3.实参不同 可变参数实参可以0,1,2.....个,?#37096;?#20197;是一个数组,数组的实参只能是数组

21.类和对象的关系

类是对象的抽象,而对象是类的具体实例。类是抽象的,不占用内存,而对象是具体的,?#21152;么?#20648;空间。类是用于创建对象的蓝图,它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

类和对象好比图纸和实物的关系,模具和铸件的关系。

?#28909;?#20154;类就是一个概念,人类具有身高,体重等属性。人类可以做吃饭、说话等方法。

小明就是一个具体的人,也就是实例,他的属性是具体的身高200cm,体重180kg,他做的方法是具体的吃了一碗白米饭,说了“12345”这样一句话。

22.面向过程和面向对象的区别

两者都是软件开发思想,先有面向过程,后有面向对象。在大型项目?#26657;?#38024;对面向过程的不足推出了面向对象开发思想。

比喻

蒋介石和毛泽东分别是面向过程和面向对象的杰出代表,这样充分说明,在解决复制问题时,面向对象有更大的优越性。

面向过程是蛋炒饭,面向对象是盖浇饭。盖浇饭的?#20040;?#23601;是?#23433;恕薄?#39277;”分离,从而提高了制作盖浇饭的灵活性。饭不满意就换饭,菜不满意换菜。用软件工程的专业术语就是“可维护性?#21271;?#36739;好,“饭” 和?#23433;恕?#30340;耦合?#32570;冉系汀?/p>

区别

编程思路不同: 面向过程以实现功能的函数开发为主,而面向对象要首先抽象出类、属性及其方法,然后通过实例化类、执行方法来完成功能。

封装性:都具有封装性,但是面向过程是封装的是功能,而面向对象封装的是数据和功能。

面向对象具有继承性和多态性,而面向过?#22530;?#26377;继承性和多态性,所以面向对象优势是明显。

方法重载和方法重写(覆盖)的区别

英文 位置不同 作用不同
重载 overload 同一个类中 在一个类里面为一种行为提供多种实现方?#35762;?#25552;高可读性
重写 override 子类和父类间 父类方法无法满足子类的要求,子类通过方法重写满足要求
修饰符 返回值 方法名 参数 抛出异常
重载 无关 无关 相同 不同 无关
重写 大于等于 小于等于 相同 相同 小于等于
23.this和super关键字的作用

this是对象内部指代自身的引用,同时也是解决成?#21271;?#37327;和局部变量同名问题;this可以调用成?#21271;?#37327;,不能调用局部变量;this?#37096;?#20197;调用成员方法,但是在普通方法中可以省略this,在构造方法中不允许省略,必须是构造方法的第一条语句。,而?#20197;?#38745;态方法当中不允许出现this关键字。

super代表对当前对象的直接父类对象的引用,super可以调用直接父类的成?#21271;?#37327;(注意权限修饰符的影响,?#28909;?#19981;能访问private成员)

super可以调用直接父类的成员方法(注意权限修饰符的影响,?#28909;?#19981;能访问private成员);super可以调用直接父类的构造方法,只限构造方法中使用,且必须是第一条语句。

24.static关键字的作用

static可以修饰变量、方法、代码块和内部类

static属性属于这个类所有,?#20174;?#35813;类创建的所有对象共享同一个static属性。可以对象创建后通过对象名.属性名和类名.属性名两种方式来访问。?#37096;?#20197;在没有创建任何对象之前通过类名.属性名的方式来访问。

static变量和非static变量的区别(都是成?#21271;?#37327;,不是局部变量)

1.在内存中份数不同

不管有多少个对象,static变量只有1份。对于每个对象,实例变量都会有单独的一份

static变量是属于整个类的,也称为类变量。而非静态变量是属于对象的,也称为实例变量

2.在内存?#20889;?#25918;的位置不同

2.在内存?#20889;?#25918;的位置不同

3.访问的方?#35762;?#21516;

实例变量: 对象名.变量名 stu1.name="小明明";

静态变量:对象名.变量名 stu1.schoolName="西二旗小学"; 不推荐如此使用

类名.变量名 Student.schoolName="东三旗小学"; 推荐使用

4.在内存中分配空间的时间不同

Student.schoolName="东三旗小学";或者Student stu1 = new Student("小明","男",20,98);

static方法?#37096;?#20197;通过对象名.方法名和类名.方法名两种方式来访问

static代码块。当类被第一次使用时(可能是调用static属性和方法,或者创建其对象)执行静态代码块,且只被执行一次,主要作用是实现static属性的初始化。

static内部类:属于整个外部类,而不是属于外部类的每个对象。不能访?#37322;?#37096;类的非静态成员(变量或者方法),.可以访?#37322;?#37096;类的静态成员

25.final和abstract关键字的作用

final和abstract是功能相反的两个关键?#37073;?#21487;以?#21592;燃且?/p>

abstract可以用来修饰类和方法,不能用来修饰属性和构造方法;使用abstract修饰的类是抽象类,需要被继?#26657;?#20351;用abstract修饰的方法是抽象方法,需要子类被重?#30784;?/p>

final可以用来修饰类、方法和属性,不能修饰构造方法。使用final修饰的类不能被继?#26657;?#20351;用final修饰的方法不能被重写,使用final修饰的变量的值不能被修改,所以就成了常量。

特别注意:final修饰基本类型变量,其值不能改变,由原来的变量变为常量;但是final修?#25105;?#29992;类型变量,栈内存中的引用不能改变,但是所指向的堆内存中的对象的属性?#31561;?#26087;可以改变。例如

package com.bjsxt;

class Test {
    public static void main(String[] args) {
        final Dog dog = new Dog("?#25918;?quot;);
        dog.name = "美美";//正确
        dog = new Dog("亚亚");//错误
    }
}
26.final、finally、finalize的区别

final修饰符(关键?#37073;?#22914;果一个类被声明为final,意味着它不能再派生出新的子类,不能作为父类被继承例如:String类、Math类?#21462;?#23558;变量或方法声明为final,可?#21592;?#35777;它们在使用中不被改变。被声明为final的变量必须在声明时给定初值,而在以后的引用中只能读取,不?#23578;?#25913;。被声明为final的方法也同样只能使用,不能重写,但是能够重载。 使用final修饰的对象,对象的引用地址不能变,但是对象的值可?#21592;洌?/p>

finally在异常处理时提供 finally 块来执行任何清除操作。如果有finally的话,则不管是否发生异常,finally语句都会被执?#23567;?#19968;般情况下,?#21450;?#20851;闭物理连接(IO流、数据库连接、Socket连接)等相关操作,放入到此代码块?#23567;?/p>

finalize方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要清理工作。finalize() 方法是在垃圾收集器删除对象之前被调用的。它是在 Object 类中定义的,因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统?#35797;?#25110;者执行其他清理工作。 一般情况下,此方法由JVM调用,程序员不要去调用!

27.写出java.lang.Object类的六个常用方法

(1)public boolean equals(java.lang.Object)

比较对象的地?#20998;?#26159;否相等,如果子类重写,则比较对象的内容是否相等;

(2)public native int hashCode() 获取哈希码

(3)public java.lang.String toString() 把数据转变成字符串

(4)public final native java.lang.Class getClass() 获取类结构信息

(5)protected void finalize() throws java.lang.Throwable

垃圾回收前执行的方法

(6)protected native Object clone() throws

java.lang.CloneNotSupportedException 克隆

(7)public final void wait() throws java.lang.InterruptedException

多线程中等待功能

(8)public final native void notify() 多线程中唤醒功能

(9)public final native void notifyAll() 多线程中唤醒所有等待线程的功能

28.private/默认/protected/public权限修饰符的区别
同一个类 同一个包 子类 所有类
private *
defailt * *
protected * * *
public * * * *

类的访问权限只有两种

public公共的 可被同一项目中所有的类访问。 (必须与文件名同名)

default默认的 可被同一个包中的类访问。

成员(成?#21271;?#37327;或成员方法)访问权限共有四?#37073;?/span>

public 公共的 可?#21592;?#39033;目中所有的类访问。(项目可见性)

protected 受保护的 可?#21592;?#36825;个类本身访问;同一个包中的所有其他的类访问;被它的子类(同一个包以及不同包中的子类)访问。(子类可见性)

default 默认的被这个类本身访问;被同一个包中的类访问。(包可见性)

private 私有的 只能被这个类本身访问。(类可见性)

29.继承条件下构造方法的执行过程

继承条件下构造方法的调用规则如下:

情况1:如果子类的构造方法中没有通过super显式调用父类的有参构造方法,也没有通过this显式调用自身的其他构造方法,则系统会默认先调用父类的无参构造方法。在这种情况下,写不?#30784;皊uper();”语句,效果是一样的。

情况2:如果子类的构造方法?#22411;?#36807;super显式调用父类的有参构造方法,那将执行父类相应构造方法,而不执行父类无参构造方法。

情况3:如果子类的构造方法?#22411;?#36807;this显式调用自身的其他构造方法,在相应构造方法中应用以上两条规则。

特别注意的是,如果存在多级继承关系,在创建一个子类对象时,以上规则会多次向更高一级父类应用,一直到执行顶级父类Object类的无参构造方法为止。

30.==和equals的区别和联系

“==”是关系运算符,equals()是方法,同时他们的结果都返回布尔值;

“==”使?#20204;?#20917;如下:

a) 基本类型,比较的是值

b) 引用类型,比较的是地址

c) 不能比较没有父子关系的两个对象

equals()方法使用如下:

a) 系统类一般已经覆盖了equals(),比较的是内容。

b) 用户自定义类如果没有覆盖equals(),将调用父类的equals (?#28909;?#26159;Object),而Object的equals的比较是地址(return (this == obj);)

c) 用户自定义类需要覆盖父类的equals()

注意:Object的==和equals比较的都是地址,作用相同

31.谈谈Java的多态

实现多态的三个条件(前提条件,向上转型、向下转型)

1、继承的存在;(继承是多态的基础,没有继承就没有多态)

2、子类重写父类的方法。(多态下会调用子类重写后的方法)

3、父类引用变量指向子类对象。(涉及子类到父类的类型转换)

向上转型 Student person = new Student()

将一个父类的引用指向一个子类对象,成为向上转型,自动进行类型转换。此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法,而不是父类的方法此时通过父类引用变?#35838;?#27861;调用子类特有的方法。

向下转型 Student stu = (Student)person;

将一个指向子类对象的引用赋给一个子类的引用,成为向下转型,此?#21271;?#39035;进行强?#35780;?#22411;转换。向下转型必须转换为父类引用指向的真实子类类型,,否则将出现ClassCastException,不是?#25105;?#30340;强制转换

向下转型时可?#36234;?#21512;使用instanceof运算符进行强?#35780;?#22411;转换,?#28909;?#20986;现转换异常---ClassCastException

32.简述Java的垃圾回收机制

传统的C/C++语言,需要程序员负责回收已经分配内存。

显式回收垃圾回收的缺点:

1)程序忘记及时回收,从而导致内存泄露,?#26723;?#31995;统性能。

2)程序错误回收程序核心类库的内存,导致系统?#35272;!?/p>

Java语言不需要程序员直接控制内存回收,是由JRE在后台自动回收不再使用的内存,称为垃圾回收机制,简称GC;

1)可以提高编程效率。

2)保护程序的完整性。

3)其开销影响性能。Java虚拟机必须跟踪程序中有用的对象,确定哪些是无用的。

垃圾回收机?#39057;?特点

1)垃圾回收机制回收JVM堆内存里的对象空间,不负责回收栈内存数据。

2)对其他物理连接,?#28909;?#25968;据库连接、输入流输出流、Socket连接无能为力。

3)垃圾回收发生具有不可预知性,程序无法精确控?#35780;?#22334;回收机制执?#23567;?/p>

4)可?#36234;?#23545;象的引用变量设置为null,暗示垃圾回收机制可以回收该对象。

现在的JVM有多种垃圾回收 实现算法,表现各异。

垃圾回收机制回收任何对象之前,总会先调用它的finalize方法(如果覆盖该方法,让一个新的引用变量重新引用该对象,则会重?#24405;?#27963;对象)。

程序员可以通过System.gc()或者Runtime.getRuntime().gc()来通知系统进行垃圾回收,会有一些效果,但是系统是否进行垃圾回收依然不确定。

永远不要主动调用某个对象的finalize方法,应该交给垃圾回收机?#39057;?#29992;。

33.基本数据类型和包装类

1) 八个基本数据类型的包装类

基本数据类型 包装类
byte Byte
boolean Boolean
short Short
char Character
int Integer
long Long
float Float
double Double

2)为什么为基本类型引入包装类

2.1基本数据类型有方便之处,简单、高效。

2.2但是Java中的基本数据类型却是不面向对象的(没有属性、方法),这在实际使用时存在很多的不便(?#28909;?#38598;合的元素只能是Object)。

为了解决这个不足,在设?#35780;?#26102;为每个基本数据类型设计了一个对应的类进行包装,这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。

3) 包装类和基本数据类型之间的转换

3.1包装类------ wrapperInstance.xxxValue() ------>基本数据类型

3.2包装类-------new WrapperClass(primitive)

3.2包装类-------new WrapperClass(primitive)

4) 自动装箱和自动拆箱

JDK1.5提供了自动装箱(autoboxing)和自动拆箱(autounboxing)功能, 从而实现了包装类和基本数据类型之间的自动转换

5) 包装类还可以实现基本类型变量和字符串之间的转换

基本类型变量--->String.valueof()--->字符串 基本类型变量<---WrapperClass.parseXxx(string)---字符串

34.Integer与int的区别

int是java提供的8种原始数据类型之一,Java为每个原始类型提供了封装类,Integer是java为int提供的封装类。

int是java提供的8种原始数据类型之一,Java为每个原始类型提供了封装类,Integer是java为int提供的封装类。

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

另外,Integer提供了多个与整数相关的操作方法,例如,将一个字符串转换成整数,Integer中还定义了表示整数的最大值和最小值的常量。

35.java.sql.Date和java.util.Date的联系和区别

1) java.sql.Date是java.util.Date的子类,是一个包装了毫秒值的瘦包装器,允许 JDBC 将毫秒值标识为 SQL DATE 值。毫秒值表示自 1970 年 1 月 1 日 00:00:00 GMT 以来经过的毫秒数。 为了与 SQL DATE 的定义一致,由 java.sql.Date 实例包装的毫秒值必须通过将时间、分?#21360;?#31186;和毫秒设置为与该实例相关的特定时区中的零来“规范化”。 说白了,java.sql.Date就是与数据库Date相对应的一个类型,而java.util.Date是纯java的Date。

2)JAVA里提供的日期和时间类,java.sql.Date和java.sql.Time,?#25442;?#20174;数据库里读取某部分值,这有时会导致丢失数据。例如一个包含2002/05/22 5:00:57 PM的字段,读取日期时得到的是2002/05/22,而读取时间时得到的是5:00:57 PM. 你需要了解数据库里存储时间的精?#21462;?#26377;些数据库,?#28909;鏜ySQL,精度为毫秒,然而另一些数据库,包括Oracle,存储SQL DATE类型数据时,毫秒部分的数据是不保存的。以下操作中容易出现不易?#29615;?#29616;的BUG:获得一个JAVA里的日期对象。 从数据库里读取日期 试图比较两个日期对象是否相?#21462;?#22914;果毫秒部分丢失,本来认为相等的两个日期对象用Equals方法可能返回false。.sql.Timestamp类比java.util.Date类精确度要高。这个类包了一个getTime()方法,但是它?#25442;?#36820;回额外精度部分的数据,因此必须使用...

总之,java.util.Date 就是Java的日期对象,而java.sql.Date 是针对SQL语句使用的,只包含日期而没有时间部分。

36.使用递归算法输出某个目录下所有文件和子目录列表
package com.bjsxt;
import java.io.File;
public class $ {
public static void main(String[] args) {
        String path = "D:/301SXT";
        test(path);
    }
    private static void test(String path) {
        File f = new File(path);
        File[] fs = f.listFiles();
        if (fs == null) {
            return;
        }
        for (File file : fs) {
            if (file.isFile()) {
                System.out.println(file.getPath());
            } else {
                test(file.getPath());
            }
        }
    }
37.关于Java编译,下面哪一个正确()(选择一项)
A Java程序经编译后产生machine code
B. Java程序经编译后会生产byte code
C. Java程序经编译后会产生DLL
D. 以上都不正确
答案:B
分析: Java是解释型语言,编译出来的是字节码; 因此A不正确,C是C/C++语?#21592;?#35793;动态链接库的文件为.DLL; 正确答案为B
38.下列说法正确的有()(选择一项)
A class中的construtor不可省略
B. construtor与class同名,但方法不能与class同名
C. construtor在一个对象被new时执行
D. 一个class只能定义一个construtor
答案:C
分析:A:如果class中的construtor省略不写,系统会默认提供一个无参构造
B:方法名可以与类名同名,只是?#29615;?#21512;命名规范
D:一个class中可以定义N多个construtor,这些construtor构成构造方法的重载
39.Java?#34218;?#21475;的修饰符可以为()(选择一项)
A private
B. protected
C. final
D. abstract
答案:D
分析:接口中的访问权限修饰符只可以是public或default
接口中的所有的方法必须要实现类实?#37073;?#25152;以不能使用final
接口中所有的方法默认都是abstract的,所?#36234;?#21475;可以使用abstract修饰,但通常abstract可以省略不写
40.给定以下代码,程序将输出 ()(选择一项)
class A {
public A(){
System.out.println("A");
}
}
class B extends A{
public B(){
System.out.println("B");
}
public static void main(String[] args) {
B b=new B();
}
}
A 不能通过编译
B. 通过编译,输出AB
C. 通过编译,输出B
D. 通过编译,输出A
答案:B
分析:在继承关系下,创建子类对象,先执行父类的构造方法,再执行子类的构造方法。
41.下列关于关键字的使用说法错误的是()(选择一项)
A abstract不能与final并列修饰同一个类
B. abstract类中可以有private的成员
C. abstract方法必须在abstract类中
D. static方法能处理非static的属性
答案:D
分析:因为static得方法在装载class得时候首先完成,比 构造方法早,此时非static得属性和方法还没有完?#27801;?#22987;化所以不能调用。
42.下列哪些语句关于内存回收的说法是正确的()(选择一项)
A 程序?#21271;?#39035;创建一个线程来释放内存
B. 内存回收程序负责释放无用内存
C. 内存回收程序允许程序员直接释放内存
D. 内存回收程序可以在指定的时间释放内存对象
答案:B
分析: A. 程序员不需要创建线程来释放内存.
C. 也不允许程序员直接释放内存.
D. 不一定在什么时刻执行垃圾回收.
43.选出合理的标识符()(选择两项)
A _sysl_111
B. 2 mail
C. $change
D. class
答案:AC
分析: 标识符的命令规范,可以包含字母、数字、下划线、$,不能以数字开头,不能是Java关键字
44.下列说法正确的是()(选择多项)
A java.lang.Cloneable是类
B. java.langRunnable是接口
C. Double对象在java.lang包中
D. Double a=1.0是正确的java语句
Double a=1.0是正确的java语句
分析:java.lang.Cloneable是接口
45.定义一个类名为”MyClass.java”的类,并且该类可被一个工程中的所有类访问,那么该类的正确声明为()(选择两项)
A 45.定义一个类名为”MyClass.java”的类,并且该类可被一个工程中的所有类访问,那么该类的正确声明为()(选择两项)
B. class MyClass extends Object
C. public class MyClass
D. public class MyClass extends Object
答案:CD
分析: A 类的访问权限只能是public或default
B使用默认访问权限的类,只能在本包中访问
46.面向对象的特征有哪些方面?请用生活中的例子来描述。

答: 面向对象的三大特征:封装、继?#23567;?#22810;态。

举例?#28023;ū热?#35774;计一个游戏)我现在创建了一个对象,名叫战士。

战士的属性是—?#21592;穡?#24180;龄,职业,等级,战斗力,血量。

它的方法—战斗,?#20248;埽?#21507;饭,睡觉,死。

后来,我又建了一个对象,叫人。

属性:?#21592;穡?#24180;龄,职业,等级,血量

方法:?#20248;埽?#21507;饭,睡觉,死。

我让人,成为战士的父类,战士可以直接继承人的属性和方法。

战士修?#26576;傘?/p>

属性:战斗力。

方法:战斗。

看上去战士的资料变少了,实际上没有,我们仍然可以调用方法—战士.死。

而且我们还可以重载战士.死的方法,简称重载死法。

?#19968;?#24314;了一个对象—法师,父类也是人。

属性:法力值

方法:施法,泡妞。

你看,用了继?#26657;?#21019;建对象变得更方便了。

再后来,我又建立了一个对象,?#27844;?#29289;。

属性:等级,战力,血量。

方法:战斗,死。

建了个对象,叫白兔?#37073;?#29238;类怪物,可继承怪物所有的属性和方法。

属性:毛色。

方法:卖萌,?#38498;?#33821;卜。

47.说明内存泄漏和内存溢出的区别和联系,结合项目经验描述Java程序中如何检测?如何解决?

答:

内存溢出 out of memory,是指程序在申请内存时,没有足够的内存空间供其使用,出现out of memory;?#28909;?#30003;请了一个integer,但给它存了long才能存下的数,那就是内存溢出。

内存泄露 memory leak,是指程序在申请内存后,无法释放已申请的内存空间,一?#25991;?#23384;泄?#27573;?#23475;可以忽略,但内存泄露堆积后果很?#29616;兀?#26080;论多少内存,迟早会被占光。

memory leak会最终会导致out of memory!

48.什么是Java的序列化,如?#38382;?#29616;Java的序列化?列举在哪些程序中见过Java序列化?

答:Java中的序列化机制能够将一个实例对象(只序列化对象的属性值,而?#25442;?#21435;序列化什么所谓的方法。)的状态信息写入到一个字节流中使其可以通过socket进?#20889;?#36755;、或者持久化到存储数据库或文件系统?#26657;?#28982;后在需要的时候通过字节流中的信息来重构一个相同的对象。一般而言,要使得一个类可以序列化,只需简单实现java.io.Serializable接口即可。

对象的序列化主要有两种用途:

1) 把对象的字节序列永久地保存?#25509;?#30424;上,通常存放在一个文件?#26657;?/p>

2) 在网络上传送对象的字节序?#23567;?/p>

在很多应用?#26657;?#38656;要对?#25215;?#23545;象进行序列化,让它们离开内存空间,入住物理硬盘,?#21592;?#38271;期保存。?#28909;?#26368;常见的是Web服务器中的Session对象,当有 10万用户并发访问,就有可能出现10万个Session对象,内存可能吃不消,于是Web容器就会把一些seesion先序列化?#25509;?#30424;?#26657;?#31561;要用了,再把保存在硬盘中的对象还原到内存?#23567;?/p>

当两个进程在进?#24615;?#31243;通信时,彼此可以发送各种类型的数据。无论是何种类型的数据,都会以二进制序列的?#38382;?#22312;网络上传送。发送方需要把这个Java对象转换为字节序?#26657;?#25165;能在网络上传送;接收方则需要把字节序?#24615;倩指?#20026;Java对象。

49.不通过构造函数也能创建对象吗?

答:Java创建对象的几种方式(重要):

1、 用new语句创建对象,这是最常见的创建对象的方法。

2、 运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。

3、 调用对象的clone()方法。

4、运用反序列化手段,调用java.io.ObjectInputStream对象的 readObject()方法。

(1)和(2)都会明确的显式的调用构造函数 ;(3)是在内存上对已有对象的影印,所以?#25442;?#35843;用构造函数 ;(4)是从文件中还原类的对象,也?#25442;?#35843;用构造函数。

50.匿名内部类可不可以继承或实现接口。为什么?

答:匿名内部类是没有名字的内部类,不能继承其它类,但一个内部类可以作为一个接口,由另一个内部类实现.

1、由于匿名内部类没有名?#37073;?#25152;以它没有构造函数。因为没有构造函数,所以它必须完全借用父类的构造函数来实例化,换言之:匿名内部类完全把创建对象的任务交给了父类去完成。

2、在匿名内部类里创建新的方法没有太大意义,但它可以通过覆盖父类的方法达到神奇效果,如上例所示。这是多态性的体现。

3、因为匿名内部类没有名?#37073;?#25152;以无法进行向下的强?#35780;?#22411;转换,持有对一个匿名内部类对象引用的变量类型一定是它的直接或间接父类类型。

51.在Java?#26657;?#20026;什么基本类型不能做为HashMap的键值,而只能是引用类型,把引用类型做为HashMap的健值,需要注意哪些地方。

(1) 在Java中是使用泛型来?#38469;鳫ashMap中的key和value的类型的,即HashMap< K, V>;而泛型在Java的规定中必须是对象Object类型的,也就是说HashMap< K, V>可以理解为HashMap< Object, Object>,很显?#25442;?#26412;数据类型不是Object类型的,因此不能作为键值,只能是引用类型。虽然我们在HashMap中可以这样添加数据:“map.put(1, “Java”);?#20445;?#20294;实际上是将其中的key值1进行了自动装箱操作,变为了Integer类型。

(1) 在Java中是使用泛型来?#38469;鳫ashMap中的key和value的类型的,即HashMap< K, V>;而泛型在Java的规定中必须是对象Object类型的,也就是说HashMap< K, V>可以理解为HashMap< Object, Object>,很显?#25442;?#26412;数据类型不是Object类型的,因此不能作为键值,只能是引用类型。虽然我们在HashMap中可以这样添加数据:“map.put(1, “Java”);?#20445;?#20294;实际上是将其中的key值1进行了自动装箱操作,变为了Integer类型。

52.简述Java中如?#38382;?#29616;多态

实现多态有三个前提条件:

1、 继承的存在;(继承是多态的基础,没有继承就没有多态)。

2、子类重写父类的方法。(多态下会调用子类重写后的方法)。

3、父类引用变量指向子类对象。(涉及子类到父类的类型转换)。

最后使用父类的引用变量调用子类重写的方法即可实现多态。

53.以下对继承的描述锚误的是 ()
A Java中的继?#24615;?#35768;一个子类继承多个父类
B. 父类更具有通用性,子类更具体
C. Java中的继?#20889;?#22312;着传递性
D. 当实例化子类时会递归调用父类中的构造方法
答案:A
分析:Java是单继承的,一个类只能继承一个父类。
54.Java 中 Math.random()/Math.random()值为?

54.Java 中 Math.random()/Math.random()值为?

如果除数与被除数均为0.0的话,则运?#34218;?#26524;为NaN(Not a Number的简写),计算错误。

55.Java?#26657;?#22914;果Manager是Employee的子类,那么Pair是Pair的子类吗?

不是,两者没有任何关联;

Pair是单独的类,只不过用不同类型的参数(泛型)进行了相应的实例化而已;所以,Pair< Manager>和Pair< Employee>不是子类的关系。

56.接口和抽象类的区别

56.接口和抽象类的区别

抽象类和接口均包含抽象方法,类必须实现所有的抽象方法,否则是抽象类

抽象类和接口都不能实例化,他们位于继承树的顶端,用来被其他类继承和实现

两者的区别主要体现在两方面:语法方面和设计理念方面

语法方面的区别是比?#31995;?#23618;次的,非本质的,主要表现在:

接口中只能定义全局静态常量,不能定义变量。抽象类中可以定义常量和变量。

接口中所有的方法都是全局抽象方法。抽象类中可以有0个、1个或多个,甚至全部都是抽象方法。

抽象类中可以有构造方法,但不能用来实例化,而在子类实例化是执?#26657;?#23436;成属于抽象类的初始化操作。接口中不能定义构造方法。

一个类只能有一个直接父类(可以是抽象类),但可以充实实现多个接口。一个类使用extends来继承抽象类,使用implements来实现接口。

一个类只能有一个直接父类(可以是抽象类),但可以充实实现多个接口。一个类使用extends来继承抽象类,使用implements来实现接口。

抽象类体现了一种继承关系,目的是?#20174;么?#30721;,抽象类中定义了各个子类的相同代码,可以认为父类是一个实现了部分功能的“中间产品?#20445;?#32780;子类是“最终产品”。父类和子类之间必须存在“is-a”的关系,即父类和子类在概念本质上应该是相同的。

接口并不要求实现类和接口在概念本质上一致的,仅仅是实现了接口定义的约定或者能力而?#36873;?#25509;口定义了“做什?#30784;保?#32780;实现类负责完成“怎么做?#20445;?#20307;现了功能(规范)和实现分离的原则。接口和实?#31181;?#38388;可以认为是一种“has-a的关系”

57.同步代码块和同步方法有什么区别

相同点:

同步方法就是在方法前加关键字synchronized,然后被同步的方法一次只能有一个线程进入,其他线程等待。而同步代码块则是在方法内部使用大括号使得一个代码块得到同?#20581;?#21516;步代码块会有一个同步的“目标?#20445;?#20351;得同步块更加灵活一些(同步代码块可以通过“目标?#26412;?#23450;需要锁定的对象)。

一般情况下,如果此“目标”为this,同步方法和代码块没有太大的区别。

区别:

同步方法直接在方法上加synchronized实现加锁,同步代码块则在方法内部加锁。很明显,同步方法锁的?#27573;?#27604;较大,而同步代码块?#27573;?#35201;小点。一般同步的?#27573;?#36234;大,性能就越差。所以一般需要加锁进?#22411;?#27493;的时候,?#27573;?#36234;小越好,这样性能更好。

58.静态内部类和内部类有什么区别

静态内部类不需要有指向外部类的引用。但非静态内部类需要持有对外部类的引用。

静态内部类可以有静态成员(方法,属性),而非静态内部类则不能有静态成员(方法,属性)。

非静态内部类能够访?#37322;?#37096;类的静态和非静态成员。静态内部类不能访?#37322;?#37096;类的非静态成员,只能访?#37322;?#37096;类的静态成员。

实例化方?#35762;?#21516;:

1) 静态内部类:不?#35272;?#20110;外部类的实例,直接实例化内部类对象

2) 非静态内部类?#21644;?#36807;外部类的对象实例生成内部类对象

59.反射的概念与作用

反射的概念:

反射,一种计算机处理方?#20581;?#26159;程序可以访问、检测和修改它本身状态或行为的一种能力。

Java反射可以于运行时加载,探知和使用编译期间完全未知的类.

程序在运行状态中, 可以动态加载一个只有名?#39057;?#31867;, 对于?#25105;?#19968;个已经加载的类,都能够知道这个类的所有属性和方法; 对于?#25105;?#19968;个对象,都能调用他的?#25105;?#19968;个方法和属性;

加载完类之后, 在堆内存中会产生一个Class类型的对象(一个类只有一个Class对象), 这个对象包含了完整的类的结构信息,而且这个Class对象就像一面镜子,透过这个镜子看到类的结构,所?#21592;?#31216;之为:反射.

java反射使得我们可以在程序运行时动态加载一个类,动态获取类的基本信息和定义的方法,构造函数,域?#21462;?/p>

除了检阅类信息外,还可以动态创建类的实例,执行类实例的方法,获取类实例的域值。反射使java这种静态语言有了动态的特性。

反射的作用:

通过反射可以使程序代码访?#39318;?#36733;到JVM 中的类的内部信息

1) 获取已装载类的属性信息

2) 获取已装载类的方法

3) 获取已装载类的构造方法信息

反射的优点:

增加程序的灵活性。

如struts?#23567;?#35831;求的派发控制。

当请求来到时。struts通过查询配置文件。?#19994;礁们?#27714;对应的action。已经方法。

然后通过反射实例化action。并调用响应method。

如果不?#35270;?#21453;射,那么你就只能写?#36182;?#20195;码里了。

所以说,一个灵活,一个不灵活。

很少情况?#29575;?#38750;用反射不可的。大多数情况下反射是为了提高程序的灵活性。因此一般框架中使用较多。因为框架要?#35270;?#26356;多的情况。对灵活性要求较高。

60.提供Java存取数据库能力的包是()
A java.sql
B. java.awt
C. java.lang
D. java.swing
答案:A
分析:
java.awt和javax.swing两个包是图形用户界面编程所需要的包;
java.lang包则提供了Java编程中用到的基础类。
61.下?#24615;?#31639;符合法的是()(多选)
A &&
B. <>
C. if
D. =
答案:AD
分析:
&&是逻辑运算符中的短路与;
<>表示不等于,但是Java中不能这么使用,应该是!=;
if不是运算符;
=是赋值运算符。

62.执行如下程序代码,c的值打印出来是()
public class Test1 {
public static void main(String[] args) {
int a = 0;
int c = 0;
do{
--c;
a = a - 1;
} while (a > 0);
System.out.println(c);
}
}
A 0
B. 1
C. -1
D. 死循环
答案:C
分析:
do-while循环的特点是先执行后判?#24076;?#25152;以代码先执行--c操作,得到c为-1,之后执行a=a-1的操作,得到a为-1,然后判断a是否大于0,判断条件不成立,退出循环,输出c为-1。
63.下列哪一种叙述是正确的()
A abstract修饰符?#23578;?#39280;字段,方法和类
B. 抽象方法的body部分必须用一对大括号{}包住
C. 声明抽象方法,大括号可有可无
D. 声明抽象方法不?#23578;?#20986;大括号
答案:D
分析:
abstract只能修饰方法和类,不能修饰字段;
抽象方法不能有方法体,即没有{};
同B。
64.下列语句正确的是()
A ?#38382;讲?#25968;可被视为local Variable
B. ?#38382;讲?#25968;可被视为local Variable
C. ?#38382;讲?#25968;可被所有的字段修饰符修饰
D. ?#38382;讲?#25968;为方法被调用时,真正被传递的参数
答案:A
分析:
local Variable为局部变量,形参和局部变量一样都只有在方法内才会发生作用,也只能在方法中使用,?#25442;?#22312;方法外可见;
对于?#38382;讲?#25968;只能用final修饰符,其它任何修饰符都会引起编译器错误;
真正被传递的参数是实参;
?#38382;讲?#25968;可是基本数据类型?#37096;?#20197;是引用类型(对象)。
65.下列哪种说法是正确的()
A 实例方法可直接调用超类的实例方法
B. 实例方法可直接调用超类的类方法
C. 实例方法可直接调用其他类的实例方法
D. 实例方法可直接调用本类的类方法
答案:D
分析:
实例方法不可直接调用超类的私有实例方法;
实例方法不可直接调用超类的私有的类方法;
要看访问权限。
66.Java程序的种类有()(多选)
A 类 (Class)
B. Applet
C. Application
D. Servlet
答案:BCD
分析:
是Java中的类,不是程序;
内嵌于Web文件?#26657;射?#35272;器来观看的Applet;
可独立运行的 Application;
服务器端的 Servlet。
67.下列说法正确的有()(多选)
A 环境变量可在编译source code时指定
B. 在編译程序时,所指定的环境变置不包括class path
C. javac —次可同?#21271;?#35793;数个Java 源文件
D. javac.exe能指定编译结果要置于哪个目录(directory)
答案:BCD
分析:
环境变量一般都是先配置好再编译源文件。
68.下列标识符不合法的有()(多选)
A new
B. $Usdollars
C. 1234
D. car.taxi
答案:ACD
分析:
new是Java的关键?#37073;?/div>
C. 数字不能开头;
D. 不能有“.”。
69.下列说法错误的有()(多选)
A 数组是—种对象
B. 数组属于一种原生类
C. int number[]=(31,23,33,43,35,63)
D. 数组的大小可以?#25105;?#25913;变
答案:BCD
分析:
B. Java中的原生类(即基本数据类型)有8?#37073;?#20294;不包括数组;
C. 语法错误,应该“{···}?#20445;?#32780;不是“(···)?#20445;?/div>
D. 数组的长度一旦确定就不能修改。
70.不能用来修饰interface的有()(多选)
A private
B. public
C. protected
D. static
答案:ACD
分析:
能够修饰interface的只有public、abstract以及默认的三种修饰符。
71.下列正确的有()(多选)
A call by value?#25442;?#25913;变实?#20160;?#25968;的数值
B. call by reference能改变实?#20160;?#25968;的参考地址
C. call by reference 不能改变实?#20160;?#25968;的参考地址
D. call by reference 能改变实?#20160;?#25968;的内容
答案:ACD
分析:
Java中参数的传递有两?#37073;?#19968;种是按值传递(call by value:传递的是具体的值,如基础数据类型),另一种是按引?#20040;?#36882;(call by reference:传递的是对象的引用,即对象的存储地址)。前者不能改变实参的数值,后者虽然不能改变实参的参考地址,但可以通过该地址访问地?#20998;?#30340;内容从而实现内容的改变。
72.下列说法错误的有()(多选)
A 在类方法中可用this来调用本类的类办法
B. 在类方法中调用本类的类方法时可以直接调用
C. 在类方法中只能调用本类中的类方法
D. 在类方法中绝对不能调用实例方法
答案:ACD
分析:
类方法是在类加载?#21271;?#21152;载到方法区存储的,此时还没有创建对象,所以不能使用this或者super关键?#37073;?/div>
C. 在类方法中还可以调用其他类的类方法;
D. 在类方法可以通过创建对象来调用实例方法。
73.下列说法错误的有()(多选)
A Java面向对象语言容许单独的过栈与函数存在
B. Java面向对象语言容许单独的方法存在
C. Java语言中的方法属于类中的成员(member)
D. Java语言中的方法必定隶属于某一类(对象),调用方法与过程或函数相同
答案:ABC
分析:
B. Java不允许单独的方法,过程或函数存在,需要隶属于某一类?#26657;?/div>
C. 静态方法属于类的成员,非静态方法属于对象的成员。
74.下列说法错误的有()(多选)
A 能被java.exe成功运行的java class文件必须有main()方法
B. J2SDK就是Java API
C. Appletviewer.exe可利用jar选项运行.jar文件
D. 能被Appletviewer成功运行的java class文件必须有main()方法
答案:BCD
分析:
B. J2SDK是sun公司编程工具,API是指的应用程序编程接口;
C. Appletviewer.exe就是用来解释执行java applet应用程序的,一种执行HTML文件上的Java小程序类的Java浏览器;
D. 能被Appletviewer成功运行的java class文件可以没有main()方法。
75.请问0.3332的数据类型是()
A float
B. double
C. Float
D. Double
答案:B
分析:
小数默认是双精度浮点型即double类型的。
76.Java接口的修饰符可以为()
A private
B. protected
C. final
D. abstract
答案:D
分析:
能够修饰interface的只有public、abstract以及默认的三种修饰符。
77.不通过构造函数也能创建对象么()
A
B.
答案:A
分析:
Java创建对象的几种方式:
(1) 用new语句创建对象,这是最常见的创建对象的方法。
(2) 运用反射手段,调用java.lang.Class或者
java.lang.reflect.Constructor类的newInstance()实例方法。
(3) 调用对象的clone()方法。
(4) 运用反序列化手段,调用java.io.ObjectInputStream对象的readObject()方法。
(1)和(2)都会明确的显式的调用构造函数;(3)是在内存上对已有对象的影印,所以?#25442;?#35843;用构造函数;(4)是从文件中还原类的对象,也?#25442;?#35843;用构造函数。
78.存在使i+1< i的数么?

78.存在使i+1< i的数么?

79.接口可否继?#34218;?#21475;?抽象类是否可实现接口?抽象类是否可继承实体类?

接口可以继?#34218;?#21475;,抽象类可以实现接口,抽象类可以继承实体类。

80.int与Integer有什么区别?

int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装类,Integer是java为int提供的封装类。int的默认值为0,而Integer的默认值为null,即Integer可以区分出未赋值和值为0的区别,int则无法表达出未赋值的情况,例如,要想表达出没有参加考试和考试成绩为0的区别,则只能使用Integer。在JSP开发?#26657;琁nteger的默认为null,所以用el表达式在文本框中显示时,值为空白字符串,而int默认的默认值为0,所以用el表达式在文本框中显示时,结果为0,所以,int不适合作为web层的表单数据的类型。

在Hibernate?#26657;?#22914;果将OID定义为Integer类型,那么Hibernate就可以根据其值是否为null而判断一个对象是否是临时的,如果将OID定义为了int类型,还需要在hbm映射文件中设置其unsaved-value属性为0。另外,Integer提供了多个与整数相关的操作方法,例如,将一个字符串转换成整数,Integer中还定义了表示整数的最大值和最小值的常量。

81.?#23578;?#21015;化对象为什么要定义serialversionUID值?

SerialVersionUid,简言之,其目的是序列化对象版本控制,有关各版本反序列化时是否兼容。如果在新版本中这个值修改了,新版本就不兼容旧版本,反序列化时会抛出InvalidClassException异常。如果修改较小,?#28909;?#20165;仅是增加了一个属性,我们希望向?#24405;?#23481;,老版本的数据都能保留,那就不用修改;如果我们删除了一个属性,或者更改了类的继承关系,必然不兼容旧数据,这?#26412;?#24212;该手动更新版本号,即SerialVersionUid。

82.写一个Java正则,能过滤出html中的< a href=”url”>title< /a>?#38382;?#20013;的链接地址和标题.

< a\b[^>]+\bhref="([^"]*)"[^>]*>([\s\S]*?)< /a>

< a\b[^>]+\bhref="([^"]*)"[^>]*>([\s\S]*?)< /a>

83.十进制数72转换成八进制数是多少?

答: 110

84.Java程序中创建新的类对象,使用关键字new,回收无用的类对象使用关键字free正?#35775;矗?/div>

答:Java程序中创建新的类对象,使用关键字new是正确的; 回收无用的类对象使用关键字free是错误的.

85.Class类的getDeclaredFields()方法与getFields()的区别?

答:getDeclaredFields(): 可以获取所有本类自己声明的方法, 不能获取继承的方法

getFields(): 只能获取所有public声明的方法, 包括继承的方法

86.在switch和if-else语句之间进行选取,当控制选择的条件不仅仅?#35272;?#20110;一个x时,应该使用switch结构;正?#35775;矗?/div>

答:不正确。

通常情况下,进行比较判断的处理,switch 和if-else可以互相转换来写;if-else作用的?#27573;?#27604;switch-case作用?#27573;?#35201;大,但是当switch-case和if-else都可以用的情况下,通常推荐使用switch-case。

?#28909;紓?/p>

switch (ch) {
case 'a':
System.out.println("A");
break;
case 'b':
System.out.println("B");
break;
case 'c':
System.out.println("C");
break;
case 'd':
System.out.println("D");
break;
case 'e':
System.out.println("E");
break;
default:
System.out.println("other");
break;
}

换为if-else

if (ch == 'a') {
System.out.println("A");
} else if (ch == 'b') {
System.out.println('B');
} else if (ch == 'c') {
System.out.println("C");
} else if (ch == 'd') {
System.out.println("D");
} else if (ch == 'e') {
System.out.println("E");
} else {
System.out.println("Other");
}
87.描述&和&&的区别。

&和&&的联系(共同点):

&和&&都可以用作逻辑与运算符,但是要看使用时的具体条件来决定。

操作数1&操作数2,操作数1&&操作数2,

操作数1&操作数2,操作数1&&操作数2,

情况1:当上述的操作数是boolean类型变量时,&和&&都可以用作逻辑与运算符。

情况2:当上述的表达式结果是boolean类型变量时,&和&&都可以用作逻辑与运算符。

表示逻辑与(and),当运算符两边的表达式的结果或操作数都为true时,整个运算结果才为true,否则,只要有一方为false,结果都为false。

表示逻辑与(and),当运算符两边的表达式的结果或操作数都为true时,整个运算结果才为true,否则,只要有一方为false,结果都为false。

(1)、&逻辑运算符称为逻辑与运算符,&&逻辑运算符称为短路与运算符,?#37096;山新?#36753;与运算符。

对于&?#20309;?#35770;任何情况,&两边的操作数或表达式都会参与计算。

对于&&:当&&左边的操作数为false或左边表达式结果为false时,&&右边的操作数或表达式将不参与计算,此时最?#25112;?#26524;都为false。

综上所述,如果逻辑与运算的第一个操作数是false或第一个表达式的结果为false时,对于第二个操作数或表达式是否进?#24615;?#31639;,对最终的结果没有影响,结果肯定是false。?#24179;?#24179;时多使用&&,因为它效率更高些。

(2)、&还可以用作位运算符。当&两边操作数或两边表达式的结果不是boolean类型时,&用于?#27425;?#19982;运算符的操作。

88.使用final关键字修饰符一个变量时,是引用不能变,?#25925;且?#29992;的对象不能变?

final修饰基本类型变量,其值不能改变。

但是final修?#25105;?#29992;类型变量,栈内存中的引用不能改变,但是所指向的堆内存中的对象的属性?#31561;?#26087;可以改变。

例如:

class Test {
    public static void main(String[] args) {
        final Dog dog = new Dog("?#25918;?quot;);
        dog.name = "美美";//正确
        dog = new Dog("亚亚");//错误
    }
}
89.请解释以下常用正则含义:\d,\D,\s,.,*,?,|,[0-9]{6},\d+

\d: 匹配一个数字字符。等价于[0-9]

\D: 匹配一个非数字字符。等价于[^0-9]

\s: 匹配任何空白字符,包括空格、制表符、换页符等?#21462;?#31561;价于 [ \f\n\r\t\v]

. :匹配除换行符 \n 之外的任何单字符。要匹配 . ,请使用 \. 。

*:匹配前面的子表达式零次或多次。要匹配 * 字符,请使用 \*。

+:匹配前面的子表达式一次或多次。要匹配 + 字符,请使用 \+。

|:将两个匹配条件进行逻辑“或?#20445;∣r)运算

[0-9]{6}:匹配连续6个0-9之间的数字

\d+:匹配至少一个0-9之间的数字

90.已知表达式int m[] = {0,1,2,3,4,5,6}; 下面那个表达式的值与数组的长?#35748;?#31561;()
A m.length()
B. m.length
C. m.length()+1
D. m.length+1
答案:B
分析:数组的长度是.length
91.下面?#20999;?#22768;明是合法的?()
A long l = 4990
B. int i = 4L
C. float f = 1.1
D. double d = 34.4
答案:AD
分析:B int属于整数型应该是int=4 C应该是float f=1.1f
92.以下选项中选择正确的java表达式()
A int k=new String(“aa”)
B. String str = String(“bb”)
C. char c=74;
D. long j=8888;
答案:CD
分析:A需要强?#35780;?#22411;转换 B String str =new String(“bb”)
93.下?#20889;?#30721;的输出结果是
System.out.println(""+("12"=="12"&&"12".equals("12")));
(“12”==”12”&&”12”.equals(“12”))
“12”==”12”&&”12”.equals(“12”)

true

false

94.以下哪些运算符是含有短路运算机?#39057;模?#35831;选择?#28023;ǎ?/div>
A &
B. &&
C. |
D. ||
答案:BD
分析:A C是逻辑与计算
95.下面哪个函数是public void example(){....}的重载函数?()
A private void example(int m){...}
B. public int example(){...}
C. public void example2(){...}
D. public int example(int m.float f){...}
答案:AD
分析:BC定义的?#20999;?#20989;数
96.给定某java程序片段,该程序运行后,j的输出结果为()
int  i=1;
 Int  j=i++;
 If((j>++j)&&(i++==j)){j+=i:}
 System.out.println(j);
A 1
B. 2
C. 3
D. 4
答案:B
分析: i++先引用后。++i 先增加后引用
97.在java?#26657;?#26080;论测试条件是什么,下?#26657;ǎ?#24490;?#26041;?#33267;少执行一次。
A for
B. do...while
C. while
D. while...do
答案:B
分析: ACD都不一定进行循环
98.打印结果:
package com.bjsxt;

public class smaillT{
public static void main(String args[]){
smaillT t=new smaillT();
int b = t.get();
System.out.println(b);
}

public int get()
{
try {
return 1;
}finally{
return 2;
}
}
}

输出结果:2

99.指出下列程序的运?#34218;?#26524;
int i=9;
switch (i) {
default:
System.out.println("default");
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
}

打印结果:

打印结果:

zero

100.解释继?#23567;?#37325;载、覆盖。

继?#26657;?#33521;语:inheritance)是面向对象软件技术当中的一个概念。如果一个类别A“继承自”另一个类别B,就把这个A称为“B的子类别?#20445;?#32780;把B称为“A的父类别?#24065;部?#20197;称“B是A的超类”。继承可以使得子类别具有父类别的各种属性和方法,而不需要再次编写相同的代码。在令子类别继承父类别的同时,可以重新定义?#25215;?#23646;性,并重写?#25215;?#26041;法,即覆盖父类别的原有属性和方法,使其获得与父类别不同的功能。另外,为子类别追?#26377;?#30340;属性和方法也是常见的做法。 一般静态的面向对象编程语言,继承属于静态的,意即在子类别的行为在编译期就已经决定,无法在执行期扩充。

那么如何使用继承呢?用extends关键字来继承父类。

如上面A类与B类,当写继承语句时, class A类 extends B类{ } 其中A类是子类,B类是父类。

英文 位置不同 作用不同
重载 overload 同一个类中
在一个类里面为一种行为提供多种实现方?#35762;?#25552;高可读性
现方?#35762;?#25552;高可读性
重写 override 子类和父类间
父类方法无法满足子类的要求,子类通
过方法重写满足要求
101.什么是编译型语言,什么是解释型语言?java可以归类到那?#37073;?/div>

计算机不能直接理解高级语言,只能理解和运行机器语言,所?#21592;?#39035;要把高级语言翻译成机器语言,计算机才能运行高级语言所编写的程序。翻译的方式有两?#37073;?#19968;个是编译,一个是解释。

用编译型语言写的程序执行之前,需要一个专门的编译过程,通过编译系统把高级语言翻译成机器语言,把源高级程序编译成为机器语言文件,?#28909;鐆indows下的exe文件。以后就可以直接运行而不需要编译了,因为翻译只做了一次,运行时不需要翻译,所以一般而言,编译型语言的程序执行效率高。

解释型语言在运行的时候才翻译,?#28909;鏥B语言,在执行的时候,专门有一个解释器能够将VB语言翻译成机器语言,每个语句都是执行时才翻译。这样解释型语言每执行一次就要翻译一次,效率比?#31995;汀?/p>

编译型与解释型,两者各有利?#20303;?#21069;者由于程序执行速度快,同等条件下对系统要求?#31995;停?#22240;此像开发操作系?#22330;?#22823;型应用程序、数据库系统等时都采用它,像C/C++、Pascal/Object Pascal(Delphi)等都是编译语言,而一些网页脚本、服务器脚本?#26696;?#21161;开发接口这样的对速度要求不高、对不同系统平台间的兼容性有一定要求的程序则通常使用解释性语言,如JavaScript、VBScript、Perl、Python、Ruby、MATLAB 等?#21462;?/p>

JAVA语言是一种编译型-解释型语言,同?#26412;?#22791;编译特性和解释特性(其实,确切的说java就是解释型语言,其所谓的编译过程只是将.java文件编程成平台无关的字节码.class文件,并不是向C一样编译成可执行的机器语言,在此请读者注意Java中所谓的“编译”和传统的“编译”的区别)。作为编译型语言,JAVA程序要被统一编译成字节码文件——文件后缀是class。此种文件在java中又称为类文件。java类文件不能再计算机上直接执?#26657;?#23427;需要被java虚拟机翻译成本地的机器码后才能执?#26657;?#32780;java虚拟机的翻译过程则是解释性的。java字节码文件首?#32570;?#21152;载到计算机内存?#26657;?#28982;后读出一条指令,翻译一条指令,执行一条指令,该过程被称为java语言的解释执?#26657;?#26159;由java虚拟机完成的。

102.简述操作符(&,|)与操作符(&&,||)的区别&和&&的联系(共同点)

&和&&都可以用作逻辑与运算符,但是要看使用时的具体条件来决定。

操作数1&操作数2 操作数1&&操作数2
表达式1&表达式2 表达式1&&表达式2

情况1:当上述的操作数是boolean类型变量时,&和&&都可以用作逻辑与运算符。

情况2:当上述的表达式结果是boolean类型变量时,&和&&都可以用作逻辑与运算符。

表示逻辑与(and),当运算符两边的表达式的结果或操作数都为true时,整个运算结果才为true,否则,只要有一方为false,结果都为false。

&和&&的区别(不同点):

(1)、&逻辑运算符称为逻辑与运算符,&&逻辑运算符称为短路与运算符,?#37096;山新?#36753;与运算符。

对于&?#20309;?#35770;任何情况,&两边的操作数或表达式都会参与计算。

对于&&:当&&左边的操作数为false或左边表达式结果为false时,&&右边的操作数或表达式将不参与计算,此时最?#25112;?#26524;都为false。

综上所述,如果逻辑与运算的第一个操作数是false或第一个表达式的结果为false时,对于第二个操作数或表达式是否进?#24615;?#31639;,对最终的结果没有影响,结果肯定是false。?#24179;?#24179;时多使用&&,因为它效率更高些。

(2)、&还可以用作位运算符。当&两边操作数或两边表达式的结果不是boolean类型时,&用于?#27425;?#19982;运算符的操作。

|和||的区别和联系与&和&&的区别和联系类似

103.try{}里面有一个return语句,那么紧跟在这个try后的finally, 里面的语句在异常出现后,都会执行么?为什么?

在异常处理时提供 finally 块来执行任何清除操作。

如果有finally的话,则不管是否发生异常,finally语句都会被执?#26657;?#21253;括遇到return语句。

finally中语句不执行的唯一情况中执行了System.exit(0)语句。

104.有一段java应用程序,它的主类名是al,那么保存它的源文件可以是?()
A al.java
B. al.class
C. al
D. 都对
答案:A
分析:.class是java的解析文件
105.Java类可以作为()
A 类型定义机制
B. 数据封装机制
C. 类型定义机制和数据封装机制
D. 上述都不对
答案:C
106.在调用方法时,若要使方法改变实参的值,可以?()
A 用基本数据类型作为参数
B. 用对象作为参数
C. A和B都对
D. A和B都不对
答案:B
分析:基本数据类型不能改变实参的值
107.Java语言具有许多优点和特点,哪个反映了java程序并行机?#39057;模ǎ?/div>
A 安全性
B. 多线性
C. 跨平台
D. 可移植
可移植
108.下关于构造函数的描述错误是()
A 构造函数的返回类型只能是void型
B. 构造函数是类的一种特殊函数,它的方法名必须与类名相同
C. 构造函数的主要作用是完成对类的对象的初始化工作
D. 一般在创建新对象时,系统会自动调用构造函数
答案:A
分析:构造函数的名字与类的名字相同,并且不能指定返回类型。
109.若需要定义一个类域或类方法,应使用哪种修饰符?()
A static
B. package
C. private
D. public
答案:A
110.下面代码执行后的输出是什么()
package com.bjsxt;
public class Test {
public static void main(String[] args) {
outer: for (int i = 0; i < 3; i++)
inner: for (int j = 0; j < 2; j++) {
if (j == 1)
continue outer;
System.out.println(j + " and " + i);
}
}
}
A
0 and 0
0 and 1
0 and 2
B.
1 and 0
1 and 1
1 and 2
C.
2 and 0
2 and 1
2 and 2
答案:A
111.给出如下代码,如何使成?#21271;?#37327;m被函数fun()直接访问()
package com.bjsxt;
public class Test {
private int m;

public static void fun() {
// some code…
}
}
A 将private int m 改为 protected int m
B. 将private int m 改为 public int m
C. 将private int m 改为 static int m
D. 将private int m 改为int m
答案:C
112.下面哪几个函数是public void example(){….}的重载函数()

A public void example(int m){…}
B. public int example(int m){…}
C. public void example2(){…}
D. public int example(int m,float f){…}
答案:ABD
113.请问以下代码执行会打印出什么?

父类:

package com.bjsxt;

public class FatherClass {
public FatherClass() {
System.out.println("FatherClassCreate");
}
}

子类:

package com.bjsxt;

import com.bjsxt.FatherClass;
public class ChildClass extends FatherClass {
public ChildClass() {
System.out.println("ChildClass Create");
}
public static void main(String[] args) {
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass();
}
}

执?#26657;篊:\>java com.bjsxt.ChildClass

输出结果?#28023;?/p>

答:

FatherClassCreate

FatherClassCreate

ChildClass Create

114.如果有两个类A、B(注意不是接口),你想同时使用这两个类的功能,那么你会如何编写这个C类呢?

答:因为类A、B不是接口,所以是不可以直接实现的,但可?#36234;獳、B类定义成父子类,那么C类就能实现A、B类的功能了。假如A为B的父类,B为C的父类,此时C就能使用A、B的功能。

115.一个类的构造方法是否可?#21592;?#37325;载(overloading),是否可?#21592;?#23376;类重写(overrding)?

答:构造方法可?#21592;?#37325;载,但是构造方法不能被重写,子类也不能继承到父类的构造方法

116.Java中byte表示的数值?#27573;?#26159;什么?

答:?#27573;?#26159;-128至127

117.如何将日期类型格式化为:2013-02-18 10:53:10?
public class TestDateFormat2 {
public static void main(String[] args) throws Exception {
//第一步:将字符串(2013-02-18 10:53:10)转换成日期Date
DateFormat  sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String sdate="2013-02-18 10:53:10";
Date date=sdf.parse(sdate);
System.out.println(date);

//第二步:将日期Date转换成字符串String
DateFormat  sdf2=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String sdate2=sdf2.format(date);
System.out.println(sdate2);
}
}
118.不通过构造函数也能创建对象吗()
A.
B.
分析:答案:A
Java创建对象的几种方式(重要):
(1) 用new语句创建对象,这是最常见的创建对象的方法。
(2) 运用反射手段,调用java.lang.Class或者
java.lang.reflect.Constructor类的newInstance()实例方法。
(3) 调用对象的clone()方法
(4) 运用反序列化手段,调用java.io.ObjectInputStream对象的 readObject()方法。
(1)和(2)都会明确的显式的调用构造函数 ;(3)是在内存上对已有对象的影印,所以?#25442;?#35843;用构造函数 ;(4)是从文件中还原类的对象,也?#25442;?#35843;用构造函数。
(1)和(2)都会明确的显式的调用构造函数 ;(3)是在内存上对已有对象的影印,所以?#25442;?#35843;用构造函数 ;(4)是从文件中还原类的对象,也?#25442;?#35843;用构造函数。
119.下面哪些是对称?#29992;?#31639;法()

A. DES
B. MD5
C. DSA
D. RSA
分析:答案:A
分析:常用的对称?#29992;?#31639;法有:DES、3DES、RC2、RC4、AES
常用的非对称?#29992;?#31639;法有:RSA、DSA、ECC
使用单向散列函数的?#29992;?#31639;法:MD5、SHA
120.下面的代码段,当输入为2的时候返回值是()
publicstaticint get Value(int i){
int result=0;
switch(i){
case 1:
result=result +i
case 2:
result=result+i*2
case 3:
result=result+i*3
}
return result;
}
A. 0
B. 2
C. 4
D. 10
答案:C
分析:result = 0 + 2 * 2;
121.以下Java代码段会产生几个对象
publicvoid test(){
String a="a";
String b="b";
String c="c";
c=a+""+b+""+c;
System.out.print(c);
}

分析:答案: 一个对象,因为编译期进行了优化,3个字符串常量直接折叠为一个

122.Math.round(-11.2)的运?#34218;?#26524;是。

答案: -11

分析:小数点后第一位=5

正数:Math.round(11.5)=12

负数:Math.round(-11.5)=-11

小数点后第一位<5

正数:Math.round(11.46)=11

负数:Math.round(-11.46)=-11

小数点后第一位>5

正数:Math.round(11.68)=12

负数:Math.round(-11.68)=-12

根据上面例子的运?#34218;?#26524;,我们还可以按照如下方式总结,或许更加容易?#19988;洌?/p>

参数的小数点后第一位<5,运算结果为参数整数部分。

参数的小数点后第一位>5,运算结果为参数整数部分绝对值+1,符号(即正?#28023;?#19981;变。

参数的小数点后第一位=5,正数运算结果为整数部分+1,负数运算结果为整数部分。

?#25112;幔?#22823;于五全部加,等于五正数加,小于五全不?#21360;?/p>

123.十进制数278的对应十六进制数

分析:十进制数278的对应十六进制数是116

124.Java中int.long占用的字节数分别是

分析:

1:“字节”是byte,“位”是bit ;

2: 1 byte = 8 bit ;

char 在Java中是2个字节。java采用unicode,2个字节(16位)来表示一个字符。

short 2个字节

int 4个字节

long 8个字节

125.System.out.println(‘a’+1);的结果是

分析:'a'是char型,1 是int?#26657;琲nt与char相加,char会被强转为int?#26657;琧har的ASCII码对应的值是97,所以加一起打印98

126.下列语句那一个正确()
A. java程序经编译后会产生machine code
B. java程序经编译后会产生 byte code
C. java程序经编译后会产生DLL
D. 以上都不正确
答案:B
分析:java程序编译后会生成字节码文件,就是.class文件
127.下列说法正确的有()
A. class中的constructor不可省略
B. constructor必须与class同名,但方法不能与class同名
C. constructor在一个对象被new时执行
D. 一个class只能定义一个constructor
答案:C
128.执行如下程序代码()
a=0;c=0;
do{
——c;
a=a-1;
}while(a>0);
后,c的值是()
A. 0
B. 1
C. -1
D. 死循环
答案:C
do{...}while(...);语句至少执行一次
129.下列哪一种叙述是正确的()
A. abstract修饰符?#23578;?#39280;字段、方法和类
B. 抽象方法的body部分必须用一对大括号{}包住
C. 声明抽象方法,大括号可有可无
D. 声明抽象方法不?#23578;?#20986;大括号
答案:D
分析: abstract不能修饰字段。?#28909;?#26159;抽象方法,当然是没有实现的方法,根本就没有body部分。
130.下列语句正确的是()
A. ?#38382;讲?#25968;可被视为local variable
B. ?#38382;讲?#25968;可被字段修饰符修饰
C. ?#38382;讲?#25968;为方法被调用时,真正被传递的参数
D. ?#38382;讲?#25968;不可以是对象
答案A:
分析:
A?#30418;问讲?#25968;可被视为local variable。形参和局部变量一样都不能离开方法。都只有在方法内才会发生作用,也只有在方法中使用,?#25442;?#22312;方法外可见。
B:对于?#38382;讲?#25968;只能用final修饰符,其它任何修饰符都会引起编译器错误。但是用这个修饰符也有一定的限制,就是在方法中不能对参数做任何修改。 不过一般情况下,一个方法的形参不用final修饰。只有在特殊情况下,那就是:方法内部类。? 一个方法内的内部类如果使用了这个方法的参数或者局部变量的话,这个参数或局部变量应该是final。?
C:形参的值在调用时根据调用者更改,实参则用自身的值更改形参的值(指针、引用皆在此?#26657;?#20063;就是说真正被传递的是实参。
D:方法的参数列表指定要传递给方法什么样的信息,采用的都是对象的?#38382;健?#22240;此,在参数列表中必须指定每个所传递对象的类型及名字。想JAVA中任何传递对象的场合一样,这里传递的实际上也是引用,并且引用的类型必须正确。--《Thinking in JAVA》
131.成?#21271;?#37327;用static修饰和不用static修饰有什么区别?

1、两个变量的生命周期不同。

成?#21271;?#37327;随着对象的创建而存在,随着对象的?#25442;?#25910;而释放。

静态变量随着类的加载而存在,随着类的消失而消失。

2、调用方?#35762;?#21516;。

成?#21271;?#37327;只能被对象调用。

成?#21271;?#37327;只能被对象调用。

成?#21271;?#37327;只能被对象调用。

类名调用 :Person.country

3、别名不同。

成?#21271;?#37327;也称为实例变量。

静态变量称为类变量。?

4、数据存储位置不同。

成?#21271;?#37327;数据存储在堆内存的对象?#26657;?#25152;以也叫对象的特有数据.

静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据.

132.如果变量用final修饰,则怎样?如果方法final修饰,则怎样?

1、用final修饰的类不能被扩展,也就是说不可能有子类;

2、用final修饰的方法不能被替换或隐藏:

① 使用final修饰的实例方法在其所属类的子类中不能被替换(overridden);

② 使用final修饰的静态方法在其所属类的子类中不能被重定义(redefined)而隐藏(hidden);

3、用final修饰的变量最多只能赋值一次,在赋值方式上不同类型的变量或稍有不同:

① 静态变量必须明确赋值一次(不能只使用类型缺省值);作为类成员的静态变量,赋值可以在其声明?#22411;?#36807;初始化表达式完成,?#37096;?#20197;在静态初始化块?#34218;校?#20316;为接口成员的静态变量,赋值只能在其声明?#22411;?#36807;初始化表达式完成;

② 实例变量同样必须明确赋值一次(不能只使用类型缺省值);赋值可以在其声明?#22411;?#36807;初始化表达式完成,?#37096;?#20197;在实例初始化块或构造器?#34218;校?/p>

③ 方法参数变量在方法被调用时创建,同?#21271;?#21021;始化为对应实参值,终止于方法体 (body)结束,在此期间其值不能改变;

④ 构造器参数变量在构造器被调用(通过实例创建表达式或显示的构造器调用)时创建,同?#21271;?#21021;始化,为对应实参值,终止于构造器体结束,在此期间其值不能改变;

⑤ 异常处理器参数变量在有异常被try语句的catch子句捕捉到时创建,同?#21271;?#21021;始化为实际的异常对象,终止于catch语句块结束,在此期间其值不能改变;

⑥ 局部变量在其值被访问之前必须被明确赋值;

133.在二进制数据?#26657;?#23567;数点向右移一位,则数据()
A. 除以10
B. 除以2
C. 乘以2
D. 乘以10
乘以10
分析:可以看个例子
101.1 对应的十进制为 2^2*1 + 2^1*0 + 2^0*1 + 2^-1*1 = 5.5小数点右移一位
1011 对应的十进制为 2^3*1 + 2^2*0 + 2^1*1 + 2^0*1 = 11所以是扩大到原来的2倍
134.面向对象的特征有哪些方面?

答:面向对象的特征主要有以?#24405;?#20010;方面:

1、抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什?#30784;?/p>

2、继?#26657;?#32487;承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类(超类、基类);得到继承信息的类被称为子类(派生类)。继承让变化中的软件系统有了一定的?#26377;?#24615;,同时继承也是封装程序中可变因素的重要手段(如果不能理解请阅读阎宏博士的《Java与模?#20581;?#25110;《设计模式精解?#20998;?#20851;于桥梁模式的部分)。

3、封装?#21644;?#24120;认为封装是把数据和操作数据的方法绑定起来,对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系?#22411;?#20840;自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装;我们编写一个类就是对数据和数据操作的封装。可以说,封装就是隐藏一切可隐藏的东西,只向外界提供最简单的编程接口(可以想想普通洗衣机和全自动洗衣机的差别,明显全自动洗衣机封?#26696;?#22909;因此操作起来更简单;我们现在使用的智能手机也是封装得足够好的,因为几个按键就搞定了所有的事情)。

4、多态性:多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务,那么运行时的多态性可?#36234;?#37322;为:当A系统访问B系?#31243;?#20379;的服务时,B系统有多种提供服务的方式,但一切对A系统来说都是?#35813;?#30340;(就像电动剃须刀是A系?#24120;?#23427;的供电系统是B系?#24120;珺系统可以使用电池供电或者用交流电,甚至还有可能是太阳能,A系统?#25442;?#36890;过B类对象调用供电的方法,但并不知道供电系统的底层实现是什么,究竟通过何种方式获得了动力)。方法重载(overload)实现的是编译时的多态性(也称为前绑定),而方法重写(override)实现的是运行时的多态性(也称为后绑定)。运行时的多态是面向对象最精髓的东西,要实现多态需要做两件事:1. 方法重写(子类继承父类并重写父类中已有的或抽象的方法);2. 对象造型(用父类型引用引用子类型对象,这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为)。

135.float f=3.4;是否正确?

答:不正确。3.4是双精度数,将双精度型(double)赋值给浮点型(float)属于下转型(down-casting,也称为窄化)会造成精度损失,因此需要强?#35780;?#22411;转换float f =(float)3.4; 或者写成float f =3.4F;。

136.short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗?

答:对于short s1 = 1; s1 = s1 + 1;由于1是int类型,因此s1+1运算结果也是int 型,需要强制转换类型才能赋值给short型。而short s1 = 1; s1 += 1;可以正确编译,因为s1+= 1;相当于s1 = (short)(s1 + 1);其中有隐含的强?#35780;?#22411;转换。

137.Java 有没有goto?

答: goto 是Java中的保留?#37073;?#22312;目前版本的Java中没有使用。(根据James Gosling(Java之父)编写的《The Java Programming Language》一书的附录中给出了一个Java关键字列表,其中有goto和const,但是这两个是目前无法使用的关键?#37073;?#22240;此有些地方将其称之为保留?#37073;?#20854;实保留字这个?#35270;?#35813;有更广泛的意义,因为熟悉C语言的程序员都知道,在系统类库中使用过的有特殊意义的单词或单词的组合都被视为保留?#37073;?/p>

138.int 和Integer 有什么区别?

答:Java是一个近乎?#25335;?#30340;面向对象编程语言,但是为了编程的方便?#25925;且?#20837;不是对象的基本数据类型,但是为了能够将这些基本数据类型当成对象操作,Java为每一个基本数据类型都引入了对应的包装类型(wrapper class),int的包装类就是Integer,从JDK 1.5开始引入了自动装箱/拆箱机制,使得二者可以相互转换。

Java 为每个原始类型提供了包装类型:

原始类型: boolean,char,byte,short,int,long,float,double

包装类型:Boolean,Character,Byte,Short,Integer,Long,Float,Double

package com.bjsxt;

public class AutoUnboxingTest {

    public static void main(String[] args) {
        Integer a = new Integer(3);
        Integer b = 3;              // 将3自动装箱成Integer类型
        int c = 3;
        System.out.println(a == b); // false 两个引用没有引用同一对象
        System.out.println(a == c); // true a自动拆箱成int类型再和c比较
    }
}

补充:最近还遇到一个面试题,也是和自动装箱和拆箱相关的,代码如下所示:

public class Test03 {

   public static void main(String[] args) {
       Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
        System.out.println(f1 == f2);
        System.out.println(f3 == f4);
    }
}

如果不明就里很容易认为两个输出要么都是true要么都是false。首先需要注意的是f1、f2、f3、f4四个变量都是Integer对象,所以下面的==运算比较的不是值而是引用。装箱的本质是什么呢?当我们给一个Integer对象赋一个int值的时候,会调用Integer类的静态方法valueOf,如果看看valueOf的?#21019;?#30721;就知道发生了什?#30784;?/p>

public static Integer valueOf(int i) {
       if (i >= IntegerCache.low && i <= IntegerCache.high)
          return IntegerCache.cache[i + (-IntegerCache.low)];
       return new Integer(i);
   }

IntegerCache是Integer的内部类,其代码如下所示:

/* Cache to support the object identity semantics of autoboxing for values between
     * -128 and 127 (inclusive) as required by JLS.
     *
     * The cache is initialized on first usage.  The size of the cache
     * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
     * During VM initialization, java.lang.Integer.IntegerCache.high property
     * may be set and saved in the private system properties in the
     * sun.misc.VM class.
     */

    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
}

简单的说,如果字面量的值在-128到127之间,那么?#25442;醤ew新的Integer对象,而是直接引用常量池中的Integer对象,所以上面的面试题中f1==f2的结果是true,而f3==f4的结果是false。越是貌似简单的面试题其中的玄机就越多,需要面试者有相当深厚的功力。

139.&和&&的区别?

答:&运算符有两种用法:(1)?#27425;?#19982;;(2)逻辑与。&&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的,虽然二者都要求运算符左右两端的布尔值都是true整个表达式的值才是true。&&之所以称为短路运算是因为,如果&&左边的表达式的值是false,右边的表达式会被直接短路掉,?#25442;?#36827;?#24615;?#31639;。很多时候我们可能都需要用&&而不是&,例如在验证用户登录时判定用户名不是null而且不是空字符串,应当写为:username != null &&!username.equals(?#21834;?,二者的顺序不能?#25442;唬?#26356;不能用&运算符,因为第一个条件如果不成立,根本不能进行字符串的equals比较,否则会产生NullPointerException异常。注意:逻辑或运算符(|)和短路或运算符(||)的差别也是如此。

补充:如果你熟悉JavaScript,那你可能更能感受到短路运算的强大,想成为 JavaScript的高手就?#21364;?#29609;转短路运算开?#21450;傘?/p>

140.Math.round(11.5) 等于多少? Math.round(-11.5)等于多少?

答:Math.round(11.5)的返回值是12,Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加0.5然后进行下取整。

141.swtich 是否能作用在byte 上,是否能作用在long 上,是否能作用在String上?

答:早期的JDK?#26657;瑂witch(expr)?#26657;琫xpr可以是byte、short、char、int。从1.5版开始,Java中引入了枚举类型(enum),expr?#37096;?#20197;是枚举,从JDK 1.7版开始,还可以是字符串(String)。长整型(long)是不可以的。

142.用最有效率的方法计算2乘以8?

答: 2 << 3(左移3位相当于乘以2的3次方,右移3位相当于除以2的3次方)。

补充: 我们为编写的类重写hashCode方法时,可能会看到如下所示的代码,其实我们不太理解为什么要使用这样的乘法运算来产生哈希码(散列码),而且为什么这个数是个素数,为什么通常选择31这个数?前两个问题的答案你可以自己百度一下,选择31是因为可以用移位和减法运算?#21019;?#26367;乘法,从而得到更好的性能。说到这里你可能已经想到了:31 * num <==> (num << 5) - num,左移5位相当于乘以2的5次方(32)再减去自身就相当于乘以31。现在的VM都能自动完成这个优化。

package com.bjsxt;

public class PhoneNumber {
    private int areaCode;
    private String prefix;
    private String lineNumber;

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + areaCode;
        result = prime * result
                + ((lineNumber == null) ? 0 : lineNumber.hashCode());
        result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        PhoneNumber other = (PhoneNumber) obj;
        if (areaCode != other.areaCode)
            return false;
        if (lineNumber == null) {
            if (other.lineNumber != null)
                return false;
        } else if (!lineNumber.equals(other.lineNumber))
            return false;
        if (prefix == null) {
            if (other.prefix != null)
                return false;
        } else if (!prefix.equals(other.prefix))
            return false;
        return true;
    }

}
143.在Java ?#26657;?#22914;何跳出当前的多重?#30701;?#24490;环?

答:在最外层循环前加一个标记如A,然后用break A;可以跳出多重循环。(Java中支?#25191;?#26631;签的break和continue语句,作用有点类似于C和C++中的goto语句,但是就像要避免使用goto一样,应该避免使?#20040;?#26631;签的break和continue,因为它?#25442;?#35753;你的程序变得更优雅,很多时候甚至有相反的作用,所以这种语法其实不知道更好)

144.构造器(constructor)是否可被重写(override)?

答:构造器不能被继?#26657;?#22240;此不能被重写,但可?#21592;?#37325;载。

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

答:不对,如果两个对象x和y满足x.equals(y) == true,它们的哈希码(hash code)应?#27605;?#21516;。Java对于eqauls方法和hashCode方法是这样规定的:(1)如果两个对象相同(equals方法返回true),那么它们的hashCode值一定要相同;(2)如果两个对象的hashCode相同,它们并不一定相同。当然,你未必要按照要求去做,但是如果你违背了上述原则就会发现在使用容器时,相同的对象可以出现在Set集合?#26657;?#21516;时增?#26377;?#20803;素的效率会大大下降(对于使用哈希存储的系?#24120;?#22914;果哈希码频繁的冲突将会造成存取性能?#26412;?#19979;降)。

补充:关于equals和hashCode方法,很多Java程序都知道,但很多人也就是仅仅知道而已,在Joshua Bloch的大作《Effective Java》(很多软件公司,《Effective Java》、《Java编程思想》以及《重构:改善既有代码质量》是Java程序?#21271;乜词?#31821;,如果你还没看过,那就赶紧去亚马逊买一本吧)中是这样介绍equals方法的:首先equals方法必须满足自反性(x.equals(x)必须返回true)、对称性(x.equals(y)返回true时,y.equals(x)也必须返回true)、传递性(x.equals(y)和y.equals(z)都返回true时,x.equals(z)也必须返回true)和一致性(当x和y引用的对象信息没有被修改时,多次调用x.equals(y)应该得到同样的返回值),而且对于任何非null值的引用x,x.equals(null)必须返回false。实现高质量的equals方法的诀?#20064;?#25324;:1. 使用==操作符检查?#23433;?#25968;是否为这个对象的引用?#20445;?. 使用instanceof操作符检查?#23433;?#25968;是否为正确的类型?#20445;?. 对于类中的关键属性,检查参数传入对象的属性是否与之相匹配;4. 编写完equals方法后,?#39318;?#24049;它是否满足对称性、传递性、一致性;5. 重写equals时总是要重写hashCode;6. 不要将equals方法参数中的Object对象替换为其他的类型,在重写时不要忘掉@Override注解。

146.当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里到?#36164;?#20540;传递?#25925;且么?#36882;?

答:是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时,参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变,但对象的引用是永远?#25442;?#25913;变的。C++和C#中可以通过传引用或传输出参数来改变传入的参数的值。

补充:Java中没有传引用实在是非常的不方便,这一点在Java 8中仍然没有得到改进,正是如此在Java编写的代码中才会出现大量的Wrapper类(将需要通过方法调用修改的引用置于一个Wrapper类?#26657;?#20877;将Wrapper对象传入方法),这样的做法?#25442;崛么?#30721;变得?#20998;祝?#23588;其是?#20040;覥和C++转型为Java程序员?#30446;?#21457;者无法容忍。

147.重载(Overload)和重写(Override)的区别。重载的方法能否根据返回类型进行区分?

答:Java的三大特征之一,多态机制,包括方法的多态和对象的多态;方法的重载和重写都是实现多态的方式,区别在于前者实现的是编译时的多态性,而后者实现的是运行时的多态性。重载(overload)发生在同一个类?#26657;?#30456;同的方法,如果有不同的参数列表(参数类型不同、参数个数不同或者二者都不同)则视为重载;重写(override)发生在子类与父类之间也就是继承机?#39057;敝校?#24403;父类的方法不能满足子类的要求,此时子类重写父类的方法;要求:方法名、形参列表相同?#29615;?#22238;值类型和异常类型,子类小于等于父类;访问权限,子类大于等于父类,切记父类的私有方法以及被final修饰的方法不能被子类重写;重载对返回类型没有特殊的要求。

148.华为的面试题?#24615;?#32463;?#20351;?#36825;样一个问题:为什么不能根据返回类型来区分重载,为什么?

答:方法的重载,即使返回值类型不同,也不能改变实现功能相同或类似这一既定?#29575;担?#21516;时方法的重载只是要求两同三不同,即在同一个类?#26657;?#30456;同的方法名称,参数列表当中的参数类型、个数、顺序不同;跟权限修饰符和返回值类无关

149.静态?#30701;?#31867;(Static Nested Class)和内部类(Inner Class)的不同?

答:内部类就是在一个类的内部定义的类,内部类中不能定义静态成员(静态成员不是对象的特性,只是为了找一个容身之处,所以需要放到一个类中而已,这么一点小事,你还要把它放到类内部的一个类?#26657;?#36807;分了啊!提供内部类,不是为让你干这种事情,无?#27169;?#19981;让你干。我想可能是?#28909;?#38745;态成员类似c语言的全局变量,而内部类通常是用于创建内部对象用的,所以,?#36873;?#20840;局变量”放在内部类中就是毫无意义的事情,?#28909;?#26159;毫无意义的事情,就应该被禁止),内部类可以直接访?#37322;?#37096;类中的成?#21271;?#37327;,内部类可以定义在外部类的方法外面,?#37096;?#20197;定义在外部类的方法体?#26657;?#22914;下所示:

public class Outer
{
        int out_x  = 0;
        public void method()
              {
               Inner1 inner1 = new Inner1();
               public class Inner2  //在方法体内部定义的内部类
               {
                      public method()
                      {
                             out_x = 3;
                      }
               }
               Inner2 inner2 = new Inner2();
        }

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

}

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

Outer outer = new Outer();

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

在方法内部定义的内部类前面不能有访问类型修饰符,就好像方法中定义的局部变量一样,但这种内部类的前面可以使用final或abstract修饰符。这种内部类对其他类是不可见的其他类无法引用这种内部类,但是这种内部类创建的实例对象可以传递给其他类访问。这种内部类必须是先定义,后使用,即内部类的定义代码必须出现在使用该类之前,这与方法中的局部变量必须先定义后使用的道理也是一样的。这种内部类可以访问方法体中的局部变量,但是,该局部变量前必须加final修饰符。

对于这些细节,只要在eclipse?#21019;?#30721;试试,根据开发工具提示的各类错误信息就可以马上了解?#20581;?/p>

在方法体内部还可以采用如下语法?#21019;?#24314;一种匿名内部类,即定义某一接口或类的子类的同时,还创建了该子类的实例对象,无需为该子类定义名称:

public class Outer
{
        public void start()
        {
               new Thread(
new Runable(){
         public void run(){};
}
).start();
        }
}

最后,在方法外部定义的内部类前面可以加上static关键?#37073;?#20174;而成为Static Nested Class,它不再具有内部类的特性,所有,从狭义上讲,它不是内部类。Static Nested Class与普通类在运行时的行为和功能上没有什么区别,只是在编程引用时的语法上有一些差别,它可以定义成public、protected、默认的、private等多种类型,而普通类只能定义成public和默认的这两种类型。在外面引用Static Nested Class类的名称为“外部类名.内部类名”。在外面不需要创建外部类的实例对象,就可以直接创建Static Nested Class,例如,假设Inner是定义在Outer类中的Static Nested Class,那么可以使用如下语句创建Inner类:

Outer.Inner inner = newOuter.Inner();

由于static Nested Class不?#35272;?#20110;外部类的实例对象,所以,static Nested Class能访?#37322;?#37096;类的非static成?#21271;?#37327;(不能直接访问,需要创建外部类实例才能访问非静态变量)。当在外部类中访问Static Nested Class时,可以直接使用Static Nested Class的名?#37073;?#32780;不需要加上外部类的名字了,在Static Nested Class中?#37096;?#20197;直接引用外部类的static的成?#21271;?#37327;,不需要加上外部类的名字。

在静态方法中定义的内部类也是Static Nested Class,这时候不能在类前面加static关键?#37073;?#38745;态方法中的Static Nested Class与普通方法中的内部类的应用方式很相似,它除了可以直接访?#37322;?#37096;类中的static的成?#21271;?#37327;,还可以访?#31034;?#24577;方法中的局部变量,但是,该局部变量前必须加final修饰符。

备注:首先根据你的印象说出你对内部类的总体方面的特点:例如,在两个地方可以定义,可以访?#37322;?#37096;类的成?#21271;?#37327;,不能定义静态成员,这是大的特点。然后再说一些细节方面的知识,例如,几种定义方式的语法区别,静态内部类,以及匿名内部类。

Static Nested Class是被声明为静态(static)的内部类,它可以不?#35272;?#20110;外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化,其语法看起来挺诡异的,如下所示。

package com.bjsxt;
/**
* 扑克类(一副扑克)
  * @author sxt
  *
 */
public class Poker {
    private static String[] suites = {"黑桃", "红桃", "草花", "方块"};
    private static int[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
          private Card[] cards;
    /**
      * 构造器
     */
    public Poker() {
        cards = new Card[52];
        for(int i = 0; i < suites.length; i++) {
              for(int j = 0; j < faces.length; j++) {
                cards[i * 13 + j] = new Card(suites[i], faces[j]);
            }
        }
    }

    /**
          * 洗牌 (随机乱序)
          */
    public void shuffle() {
        for(int i = 0, len = cards.length; i < len; i++) {
            int index = (int) (Math.random() * len);
                   Card temp = cards[index];
            cards[index] = cards[i];
            cards[i] = temp;
        }
    }
     /**
     * 发牌
     * @param index 发牌的位置
     */
    public Card deal(int index) {
        return cards[index];
    }

    /**
     * 卡片类(一?#29260;?#20811;)
     * [内部类]
     * @author sxt
     */
    public class Card {
  private String suite;   // 花色
        private int face;       // 点数
  public Card(String suite, int face) {
            this.suite = suite;
            this.face = face;
       }
        @Override
        public String toString() {
            String faceStr = "";
            switch(face) {
                  case 1: faceStr = "A"; break;
            case 11: faceStr = "J"; break;
            case 12: faceStr = "Q"; break;
            case 13: faceStr = "K"; break;
            default: faceStr = String.valueOf(face);
            }
            return suite + faceStr;
        }
    }
}

测试类:

package com.bjsxt;

class PokerTest {
   public static void main(String[] args) {
        Poker poker = new Poker();
        poker.shuffle();            // 洗牌
        Poker.Card c1 = poker.deal(0);  // 发第一张牌
              // 对于非静态内部类Card
        // 只有通过其外部类Poker对象才能创建Card对象
        Poker.Card c2 = poker.new Card("红心", 1);    // 自己创建一张牌
        System.out.println(c1);     // 洗牌后的第一张
        System.out.println(c2);     // 打印: 红心A
    }
}
150.抽象的(abstract)方法是否可同时是静态的(static),是否可同时是本地方法(native),是否可同?#21271;籹ynchronized修饰?

答:都不能。抽象方法需要子类重写,而静态的方法是无法被重写的,因此二者是矛盾的。本地方法是由本地代码(如C代码)实现的方法,而抽象方法是没有实现的,也是矛盾的。synchronized和方法的实现细节有关,抽象方法不涉及实现细节,因此也是相互矛盾的。

151.静态变量和实例变量的区别?

答:静态变量是被static修饰符修饰的变量,也称为类变量,它属于类,不属于类的任何一个对象,一个类不管创建多少个对象,静态变量在内存中有且仅有一个拷贝;实例变量必须?#26469;?#20110;某一实例,需要先创建对象然后通过对象才能访问到它,静态变量可以实现让多个对象共享内存。两者的相同点:都有默认值而?#20197;?#31867;的任何地方都可以调用。在Java开发?#26657;?#19978;下文类和工具类?#22411;?#24120;会有大量的静态成员。?

152.是否可以从一个静态(static)方法内部发出对非静态(non-static)方法的调用?

答:不可以,静态方法只能访?#31034;?#24577;成员,因为非静态方法的调用要先创建对象,因此在调用静态方法时可能对象并没有被初始化。?

153.如?#38382;?#29616;对象克隆?
package com.bjsxt;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class MyUtil {
      private MyUtil() {
        throw new AssertionError();
    }
      public static <T> T clone(T obj) throws Exception {
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bout);
        oos.writeObject(obj);
        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bin);
        return (T) ois.readObject();
        // 说明:调用ByteArrayInputStream或ByteArrayOutputStream对象的close方法没有任?#25105;?#20041;
        // 这两个基于内存的流只要垃圾回收器清理对象就能够释放?#35797;?
}
}

答:有两种方式:

1.实现Cloneable接口并重写Object类中的clone()方法;

2.实现Serializable接口,通过对象的序列化和反序列化实现克隆,可以实现真正的深度克隆,代码如下。

下面是测试代码:

package com.bjsxt;
import java.io.Serializable;
/**
 * 人类
 * @author sxt
*/
class Person implements Serializable {
    private static final long serialVersionUID = -9102017020286042305L;
    private String name;    // 姓名
    private int age;        // 年龄
    private Car car;        // 座驾

    public Person(String name, int age, Car car) {
        this.name = name;
        this.age = age;
        this.car = car;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Car getCar() {
        return car;
    }
    public void setCar(Car car) {
        this.car = car;
    }
    @Override
    public String toString() {
     return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
    }
  }
  /**
 * 小汽车类
 * @author sxt
*/
class Car implements Serializable {
    private static final long serialVersionUID = -5713945027627603702L;
    private String brand;       // 品牌
    private int maxSpeed;       // 最高时速

    public Car(String brand, int maxSpeed) {
        this.brand = brand;
        this.maxSpeed = maxSpeed;
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public int getMaxSpeed() {
        return maxSpeed;
    }

    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }

    @Override
    public String toString() {
        return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
    }
  }

class CloneTest {
  public static void main(String[] args) {
        try {
            Person p1 = new Person("Hao LUO", 33, new Car("Benz", 300));
            Person p2 = MyUtil.clone(p1);   // 深度克隆
            p2.getCar().setBrand("BYD");
            // 修?#30446;?#38534;的Person对象p2关联的汽车对象的品牌属性
            // 原来的Person对象p1关联的汽车?#25442;?#21463;到任何影响
            // 因为在克隆Person对象时其关联的汽车对象也被克隆了
            System.out.println(p1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意:基于序列化和反序列化实现?#30446;?#38534;不仅仅是深度克隆,更重要的是通过泛型限定,可以检查出要克隆的对象是否支持序列化,这项检查是编译器完成的,不是在运行时抛出异常,这种是方案明显优于使用Object类的clone方法克隆对象。

154.接口是否可继?#26657;╡xtends)接口? 抽象类是否可实?#37073;╥mplements)接口? 抽象类是否可继承具体类(concrete class)?

答:接口可以继?#34218;?#21475;。抽象类可以实现(implements)接口,抽象类可以继承具体类。抽象类中可以有静态的main方法。

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

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

155.一个“.java”源文件中是否可以包含多个类(不是内部类)?有什么限制?

答:可以,但一个源文件中最多只能有一个公开类(public class)而且文件名必须和公开类的类名完全保持一?#38534;?

156.Anonymous Inner Class(匿名内部类)是否可以继承其它类?是否可以实现接口?

答:可以继承其他类或实现其他接口,在Swing编程中常?#20040;?#26041;式来实现?#24405;?#30417;听和回调。?但是有一点需要注意,它只能继承一个类或一个接口。

157.内部类可以引用它的包含类(外部类)的成员吗?有没有什么限制?

答:一个内部类对象可以访问创建它的外部类对象的成员,包括私有成员。如果要访?#37322;?#37096;类的局部变量,此?#26412;?#37096;变量必须使用final修饰,否则无法访问。

158.Java 中的final关键字有哪些用法?

(1) 修饰类:表示该类不能被继?#26657;?/p>

(2) 修饰方法:表示方法不能被重写但是允许重载;

(3) 修饰变量:表示变量只能一次赋值以后值不能被修改(常量);

(4) 修饰对象:对象的引用地址不能变,但是对象的初始化值可?#21592;洹?/p>

159.指出下面程序的运?#34218;?#26524;:
package com.bjsxt;
class A{
  static{
        System.out.print("1");
    }
  public A(){
        System.out.print("2");
    }
}
class B extends A{
  static{
        System.out.print("a");
    }
    public B(){
        System.out.print("b");
    }
}

public class Hello{
  public static void main(String[] args){
        A ab = new B();
        ab = new B();
    }
}

答:执?#34218;?#26524;:1a2b2b。创建对象时构造器的调用顺序是?#21512;?#21021;始化静态成员,然后调用父类构造器,再初始化非静态成员,最后调用自身构造器。?

考点:静态代码块优先级 > 构造方法的优先级如果再加一个普通代码块,优先顺序如下:静态代码块>普通代码块>构造方法

160.说说数据类型之间的转换:

1 ) 如何将字符串转换为基本数据类型?

2 ) 如何将基本数据类型转换为字符串?

答:

1 ) 调用基本数据类型对应的包装类中的方法parseXXX(String)或valueOf(String)即可返回相应基本类型;

2 ) 一种方法是将基本数据类型与空字符串(”?#20445;?#36830;接(+)即可获得其所对应的字符串;另一种方法是调用String 类中的valueOf(…)方法返回相应字符串?

161.如?#38382;?#29616;字符串的反转及替换?

答:方法很多,可以自己写实现?#37096;?#20197;使用String或StringBuffer / StringBuilder中的方法。有一道很常见的面试题是用递归实现字符串反转,代码如下所示:

package com.bjsxt;
public class A{
    public static String reverse(String originStr) {
 if(originStr == null || originStr.length() <= 1)
     return originStr;
       return reverse(originStr.substring(1)) + originStr.charAt(0);
     }
}
162.怎样将GB2312编码的字符串转换为ISO-8859-1编码的字符串?

答:代码如下所示:

String s1 = "你好";

String s2 = newString(s1.getBytes("GB2312"), "ISO-8859-1");?

在String类的构造方法当?#26657;?#23384;在一个字符集设置的方法,具体如下:

163.Java中的日期和时间:

1 ) 如何取得年月日、小时分?#29992;耄?/p>

2 ) 如何取?#20040;?970年1月1日0时0分0秒到现在的毫秒数?

3 ) 如何取得某月的最后一天?

4 ) 如何格式化日期?

答:操作方法如下所示:

1 ) 创建java.util.Calendar 实例,调用其get()方法传入不同的参数即可获得参数所对应的值

2 ) 以下方法均可获得该毫秒数:

Calendar.getInstance().getTimeInMillis();

time.getActualMaximum(Calendar.DAY_OF_MONTH);

4 ) 利用java.text.DataFormat 的子类(如SimpleDateFormat类)中的format(Date)方法?#23665;?#26085;期格式化。

164.打印昨天的当前时刻。
package com.bjsxt;
import java.util.Calendar;
public class YesterdayCurrent {
 public static void main(String[] args){
 Calendar cal = Calendar.getInstance();
 cal.add(Calendar.DATE, -1);
 System.out.println(cal.getTime());
 }
}
165.Java反射技术主要实现类有哪些,作用分别是什么?

在JDK?#26657;?#20027;要由以下类来实现Java反射机制,这些类都位于java.lang.reflect包中

1)Class类:代表一个类

2)Field 类:代表类的成?#21271;?#37327;(属性)

3)Method类:代表类的成员方法

4)Constructor 类:代表类的构造方法

5)Array类:提供了动态创建数组,以及访问数组的元素的静态方法

166.Class类的作用?#21487;?#25104;Class对象的方法有哪些?

Class类是Java 反射机?#39057;?#36215;源和入口,用于获取与类相关的各种信息,提供了获取类信息的相关方法。Class类继承自Object类

Class类是所有类的共同的图?#20581;?#27599;个类有自己的对象,好比图纸和实物的关系;每个类?#37096;?#30475;做是一个对象,有共同的图纸Class,存放类的 结构信息,能够通过相应方法取出相应信息:类的名字、属性、方法、构造方法、父类和接口

方 法
示 例
对象名
.getClass()
String str="bdqn";
Class clazz = str.getClass();
对象名
.getSuperClass()
Student stu = new Student();
Class c1 = stu.getClass();
Class c2 = stu.getSuperClass();
Class.forName()
Class clazz = Class.forName("java.lang.Object");
Class.forName("oracle.jdbc.driver.OracleDriver");
类名.class
类名.class
Class c2 = Student.class;
Class c2 = int.class
包装类.TYPE
包装类.TYPE
Class c2 = Boolean.TYPE;
167.反射的使用场合和作用、及其优缺点

1)使用场合

在编译时根本无法知道该对象或类可能属于哪些类,程序只依靠运行时信息来发现该对象和类的真实信息。

2)主要作用

通过反射可以使程序代码访?#39318;?#36733;到JVM 中的类的内部信息,获取已装载类的属性信息,获取已装载类的方法,获取已装载类的构造方法信息

3)反射的优点

反射提高了Java程序的灵活性和扩展性,?#26723;?#32806;合性,提高自?#35270;?#33021;力。它允许程序创建和控制任何类的对象,无需提前硬编码目标类?#29615;?#23556;是其它一些常用语言,如C、C++、Fortran 或者Pascal等都不具备的

4) Java反射技术应用领域很广,如软件测试等;许多流行?#30446;?#28304;框架例如Struts、Hibernate、Spring在实现过程中都采用了该技术

5)反射的缺点

性能问题:使用反射基本上是一种解释操作,用于字段和方法接入时要远慢于直接代码。因此Java反射机制主要应用在对灵活性和扩展性要求很高的系统框架上,普通程序不建议使用。

使用反射会模糊程序内部逻辑:程序人员希望在?#21019;?#30721;中看到程序的逻辑,反射?#28909;?#36807;了?#21019;?#30721;的技术,因而会带来维护问题。反射代码?#35748;?#24212;的直接代码更复?#21360;?/p>

168.面向对象设计原则有哪些

面向对象设计原则是面向对象设?#39057;?#22522;石,面向对象设计质量的依据和保?#24076;?#35774;计模式是面向对象设计原则的经典应用

1)单一职责原则SRP

2)开闭原则OCP

3)里氏替代原则LSP

4)?#35272;?#27880;入原则DIP

5)接口分离原则ISP

6)迪米特原则LOD

7)组合/聚合复用原则CARP

8)开闭原则具有理想主义的色彩,它是面向对象设?#39057;鬧占?#30446;标。其他设计原则都可以看作是开闭原则的实现手段或方法

String相关:

169.下面程序的运?#34218;?#26524;是()(选择一项)
String str1="hello";

String str2=new String("hello");

System.out.println(str1==str2);
A. true
B. false
C. hello
D. he
答案:B
分析:str1没有使用new关键?#37073;?#22312;堆中没有开辟空间,其值”hello”在常量池?#26657;瑂tr2使用new关键字创建了一个对象,在堆中开辟了空间,”==?#21271;?#36739;的是对象的引用,即内存地址,所以str1与str2两个对象的内存地址是不相同的
170.Java语言?#26657;琒tring类中的indexOf()方法返回值的类型是()
A. int16
B. int32
C. int
D. long
答案:C
171.给定以下代码,程序的运?#34218;?#26524;是 ()(选择一项)
public class Example {
String str=new String("good");
char [] ch={'a','b','c'};

public static void main(String[] args) {
Example ex=new Example();
ex.change(ex.str, ex.ch);
System.out.print(ex.str+"and");
System.out.print(ex.ch);
}

public void change(String  str,char ch[]){
str="test ok";
ch[0]='g';
}
}
A. goodandabc
B. goodandgbc
C. test okandabc
D. test okandgbc
答案:B
分析:在方法调用时,在change方法中对str的值进行修改,是将str指向了常量江池中的”test ok?#20445;?#32780;主方法中的ex.str仍然指向的是常量池中的”good”。字符型数组在方法调用时,将主方法中ex.ch的引?#20040;?#36882;给change方法中的ch,指向是堆中的同一堆空间,所以修改ch[0]的时候,ex.ch可以看到相同的修改后的结果。
172.执行下?#20889;?#30721;后,哪个结论是正确的()(选择两项)

String[] s=new String[10];

A. s[10]为””
B. s[9]为null
C. s[0]为未定义
D. s.length为10
答案:BD
分析: 引用数据类型的默认值均为null
s.length数组的长度
173.实现String类的replaceAll方法

思路说明:replaceAll方法的本质是使用正则表达式进行匹配,最终调用的其实是Matcher对象的replaceAll方法。

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TestStringReplaceAll {
public static void main(String[] args) {
String str = "a1s2d3f4h5j6k7";
// 将字符串中的数字全部替换为0
System.out.println(replaceAll(str, "\\d", "0"));
}

/**
 * @param str:源字符串
 * @param regex:正则表达式
 * @param newStr:替换后的子字符串
 * @return 返回替换成功后的字符串
 */
public static String replaceAll(String str, String regex, String newStr) {
Pattern pattern = Pattern.compile(regex);
Matcher mathcer = pattern.matcher(str);
String reslut = mathcer.replaceAll(newStr);
return reslut;
}
}
174.在“=”后填写?#23454;?#30340;内容:

String []a=new String[10];

则:a[0]~a[9]=null;

a.length=10;

如果是int[]a=new int[10];

则:a[0]~a[9]= (0)

a.length= (10)

175.是否可以继承String类?

答:不可以,因为String类有final修饰符,而final修饰的类是不能被继承的,实现细节不允许改变。

public final class String implements java.io.Serializable,

Comparable< String>, CharSequence

176.给定两个字符串s和t, 写一个函数来决定是否t是s的重组词。你可以假设字符串只包含小写字母。
public class Solution {
    public boolean isAnagram(String s, String t) {
        if(s.length()!=t.length())
            return false;
        int bit[] = new int[26];
        for(int i=0;i<s.length();i++){
            bit[s.charAt(i)-'a']++;
        }

        for(int i=0;i<s.length();i++){
            if(--bit[t.charAt(i)-'a']<0)
                return false;
        }
        return true;
    }

}
177.String s=new String(“abc”);创建了几个String对象。

两个或一个,”abc”对应一个对象,这个对象放在字符串常量缓冲区,常量”abc”不管出现多少遍,都是缓冲区中的那一个。New String每写一遍,就创建一个新的对象,它一句那个常量”abc”对象的内容?#21019;?#24314;出一个新String对象。如果以前就用过’abc’,这句代表就?#25442;?#21019;建”abc”自己了,直接从缓冲区拿。

178.输出结果?
String str1=“hello?#20445;?
Sring str2=“he”+new String(“llo”);
Sysem.out.println(str1==str2));
Sysem.out.println(str.equal(str2));

false

true

179.下列程序的输出结果是什么?
import java.util.*;
public class Test 6{
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
Integer k=new Integer(i);
System.out.println(k+" Hello world");
}
}
}

0 Hello world

1 Hello world

2 Hello world

3 Hello world

4 Hello world

5 Hello world

6 Hello world

7 Hello world

8 Hello world

9 Hello world

180.关于java.lang.String类,以下描述正确的一项是()
A. String类是final类故不可继承
B. String类final类故可以继承
C. String类不是final类故不可继承
D. String;类不是final类故可以继承
答案:A
181.下面哪个是正确的()
A. String temp[ ] = new String{“a”,”b”,”c”};
B. String temp[ ] = {“a”,”b”,”c”};
C. String temp= {“a”,”b”,”c”};
D. String[ ] temp = {“a”,”b”,”c”};
答案:BD
182.已知如下代码:执?#34218;?#26524;是什么()
package com.bjsxt;
public class Test {
public static void main(String[] args) {
String s1 = new String("Hello");
String s2 = new String("Hello");
System.out.print(s1 == s2);
String s3 = "Hello";
String s4 = "Hello";
System.out.print(s3 == s4);
s1 = s3;
s2 = s4;
System.out.print(s1 == s2);
}
}
A. false true true
B. true false true
C. true true false
D. true true false
答案:A
183.字符串如何转换为int类型
public class Test {
public static void main(String[] args) {
 //方式一
 int num=Integer.parseInt("123");
 //方式二
 int num2=Integer.valueOf("123");
 System.out.println(num+"  "+num2);
}
}
184.写一个方法,实现字符串的反转,如:输入abc,输出cba
public class Test {
public static void main(String[] args) {
String result=reverse("abc");
System.out.println(result);
}
public static String reverse(String str){
StringBuilder result=new StringBuilder("");
char[] chArra=str.toCharArray();
for(int i=chArra.length-1;i>=0;i--){
char ch=chArra[i];
result.append(ch);
}
return result.toString();
}
}
185.编写java,将“I follow Bill Gate.Tom Gate.John Gate”中的“Gate”全部替换为“Gates”
public classDemo1 {
publicstaticvoid main(String[] args) {
String s="I follow Bill Gate.Tom Gate.John Gate";
System.out.println(s);
s=s.replaceAll("Gate","Gates");
System.out.println(s);
}
}
186.String 是最基本的数据类型吗?

答: 不是 。Java中的基本数据类型只有8个:byte、short、int、long、float、double、char、boolean;除了基本类型(primitive type)和枚举类型(enumeration type),剩下的都是引用类型(reference type)。

187.String 和StringBuilder、StringBuffer 的区别?

答: Java 平台提供了两种类型的字符串:String和StringBuffer / StringBuilder

相同点:

它们都可以储存和操作字符串,同时三者都使用final修饰,都属于?#25112;?#31867;不能派生子类,操作的相关方法也类?#35780;?#22914;获取字符串长度等;

不同点:

其中String是只读字符串,也就意味着String引用的字符串内容是不能被改变的,而StringBuffer和StringBuilder类表示的字符串对象可以直接进行修改,在修改的同时地?#20998;挡换?#21457;生改变。StringBuilder是JDK 1.5中引入的,它和StringBuffer的方法完全相同,区别在于它是在单线程环境?#29575;?#29992;的,因为它的所有方面都没有被synchronized修饰,因此它的效率也比StringBuffer略高。在此重点说明一下,String、StringBuffer、StringBuilder三者类型不一样,无法使用equals()方法比较其字符串内容是否一样!

补充1:有一个面试题问:有没有哪种情况用+做字符串连接比调用StringBuffer / StringBuilder对象的append方法性能更好?如果连接后得到的字符串在静态存储区中是早已存在的,那么用+做字符串连接是优于StringBuffer / StringBuilder的append方法的。

补充2:下面也是一个面试题,问程序的输出,看看自己能不能说出正确答案。

package com.bjsxt;
public class smallT {
public static void main(String[] args) {
        String a = "Programming";
        String b = new String("Programming");
        String c = "Program" + "ming";
              System.out.println(a == b);
              System.out.println(a == c);
               System.out.println(a.equals(b));
               System.out.println(a.equals(c));
               System.out.println(a.intern() == b.intern());
}
}

解析:

String类存在intern()方法,含义如下:返回字符串对象的规范化表示?#38382;健?#23427;遵循以下规则:对于?#25105;?#20004;个字符串 s 和 t,当且仅当 s.equals(t) 为 true 时,s.intern()?==?t.intern() 才为 true。

字符串比较分为两种?#38382;剑?#19968;种使用比较运算符”==?#21271;?#36739;,他们比较的是各自的字符串在内存当中的地?#20998;?#26159;否相同;一种是使用equals()方法进行比较,比较的是两个字符串的内容是否相同!

结果如下:

a == b-->false

a == c-->true

a.equals(b)-->true

a.equals(c)-->true

a.intern() == b.intern()-->true

188.String类为什么是final的

答:1) 为了效率。若允许被继?#26657;?#21017;其高度的被使用率可能会?#26723;?#31243;序的性能。

2)为了安全。JDK中提供的好多核心类?#28909;鏢tring,这类的类的内部好多方法的实现都不是java编程语言本身编写的,好多方法都是调用的操作系统本地的API,这就是著名的“本地方法调用?#20445;?#20063;只有这样才能做事,这种类是非常底层的,和操作系统交流频繁的,那么如果这种类可?#21592;?#32487;承的话,如果我们再把它的方法重写了,往操作系统内部写入一段具有恶意攻击性质的代码什么的,这不就成了核心病毒了么?不希望别人改,这个类就像一个工具一样,类的提供者给我们提供了, 就希望我们直接用就完了,不想让我们随便能改,其实说白了?#25925;?#23433;全性,如果随便能改了,那么java编写的程序肯定就很不稳定,你可?#21592;?#35777;自己不乱改, 但是将来一个项目好多人来做,管不了别人,再说有时候万一疏忽了呢?#20811;?#20063;不是估?#39057;模?所以这个安全性是很重要的,java和C++相比,优点之一就包括这一点。

189.String类型是基本数据类型吗?基本数据类型有哪些

1) 基本数据类型包括byte、short/char、int、long、float、double、boolean

2 ) java.lang.String类是引用数据类型,并且是final类型的,因此不可以继承这个类、不能修改这个类。为了提高效率节省空间,我们应该用StringBuffer类

190.String?s="Hello";s=s+"world!";执行后,是否是对前面s指向空间内容的修改?

答:不是对前面s指向空间内容的直?#26377;?#25913;。

因为String被设计成不可变(immutable)类,所以它的所有对象都是不可变对象。在这段代码?#26657;瑂原先指向一个String对象,内容是 "Hello",然后我们对s进行了+操作,那么s所指向的那个对象是否发生了改变呢?答案是没有。这时,s不指向原来那个对象了,而指向了另一个 String对象,内容为"Hello?world!",原来那个对象还存在于内存之?#26657;?#21482;是s这个引用变量不再指向它了。

通过上面的说明,我们很容易导出另一个结论,如果经常对字符串进行各种各样的修改,或者说,不可预见的修改,那么使用String?#21019;?#34920;字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变,所以对于每一个不同的字符串,都需要一个String对象来表示。这时,应该考虑使用StringBuffer类,它允许修改,而不是每个不同的字符串都要生成一个新的对象。并且,这两种类的对象转换十分容易。

同时,我们还可以知道,如果要使用内容相同的字符串,不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化,把它设置为初始值,应当这样做:

public class Demo {
private String s;
...
public Demo {
s = "Initial Value";
}
...
}

而非

s?=?new?String("Initial?Value");

后者每次都会调用构造器,生?#23578;?#23545;象,性能低下且内存开销大,并且没有意义,因为String对象不可改变,所以对于内容相同的字符串,只要一个String对象来表示就可以了。也就说,多次调用上面的构造器创建多个对象,他们的String类型属性s都指向同一个对象。

上面的结论还基于这样一个?#29575;担?#23545;于字符串常量,如果内容相同,Java认为它们代表同一个String对象。而用关键字new调用构造器,总是会创建一个新的对象,无论内容是否相同。

至于为什么要把String类设计成不可变类,是它的用途决定的。其实不只String,很多Java标准类库中的类都是不可变的。在开发一个系统的时候,我们有时候也需要设计不可变类,?#21019;?#36882;一组相关的值,这也是面向对象思想的体现。不可变类有一些优点,?#28909;?#22240;为它的对象是只读的,所以多线程并发访问也?#25442;?#26377;任何问题。当然也有一些缺点,?#28909;?#27599;个不同的状态都要一个对象?#21019;?#34920;,可能会造?#23578;?#33021;上的问题。所以Java标准类库还提供了一个可变版本,即 StringBuffer。

191.String s = new String("xyz");创建几个String Object?

答:两个或一个,”xyz”对应一个对象,这个对象放在字符串常量缓冲区,常量”xyz”不管出现多少遍,都是缓冲区中的那一个。New String每写一遍,就创建一个新的对象,它一句那个常量”xyz”对象的内容?#21019;?#24314;出一个新String对象。如果以前就用过’xyz’,这句代表就?#25442;?#21019;建”xyz”自己了,直接从缓冲区拿。

192.下面这条语句一共创建了多少个对象:String s="a"+"b"+"c"+"d";

答:对于如下代码:

String s1 = "a";

String s2 = s1 + "b";

String s3 = "a" + "b";

System.out.println(s2 == "ab");

System.out.println(s3 == "ab");

第一条语句打印的结果为false,第二条语句打印的结果为true,这说明javac编译可以对字符串常量直接相加的表达式进行优化,不必要等到运行期去进行加法运算处理,而是在编译时去掉其中的加号,直接将其编译成一个这些常量相连的结果。

题目中的第一?#20889;?#30721;被编译器在编译时优化后,相当于直接定义一个”abcd”的字符串,所以,上面的代码应该只创建了一个String对象。

写如下两?#20889;?#30721;,

String s = "a" + "b" + "c" + "d";

System.out.println(s == "abcd");

最终打印的结果应该为true。

集合:

193.Java集合体系结构(List、Set、Collection、Map的区别和联系)

1、Collection 接口存储一组不唯一,无序的对象

2、List 接口存储一组不唯一,有序(插入顺序)的对象

3、Set 接口存储一组唯一,无序的对象

4、Map接口存储一组键值对象,提供key到value的映射。Key无序,唯一。value不要求有序,允许重?#30784;#?#22914;果只使用key存储,而不使用value,那就是Set)

194.Vector和ArrayList的区别和联系

相同点:

1)实现原理相同---底层都使用数组

2)功能相同---实现增删改查等操作的方法相似

3)都是长度可变的数组结构,很多情况下可以互用

不同点:

1)Vector是早期JDK版本提供,ArrayList?#20999;?#29256;本替代Vector的

2)Vector线程安全,ArrayList重速度轻安全,线程非安全长度需增长时,Vector默认增长一倍,ArrayList增长50%

195.ArrayList和LinkedList的区别和联系

相同点:

两者都实现了List接口,都具有List?#24615;?#32032;有序、不唯一的特点。

不同点:

ArrayList实现了长度可变的数组,在内存中分配连续空间。遍历元素和随机访?#35797;?#32032;的效率比较高;

LinkedList采用链表存储方?#20581;?#25554;入、删除元素时效率比较高

196.HashMap和Hashtable的区别和联系

相同点:

实现原理相同,功能相同,底层都是哈希表结构,查询速度快,在很多情况下可以互用

不同点:

1、Hashtable是早期提供的接口,HashMap?#20999;?#29256;JDK提供的接口

2、Hashtable继承Dictionary类,HashMap实现Map接口

3、Hashtable线程安全,HashMap线程非安全

4、Hashtable不允许null值,HashMap允许null值

197.HashSet的使用和原理(hashCode()和equals())

1)哈希表的查询速度特别快,时间复杂度为O(1)。

2)HashMap、Hashtable、HashSet这些集合采用的是哈希表结构,需要用到hashCode哈希码,hashCode是一个整数值。

3)系统类已经覆盖了hashCode方法 自定义类如果要放入hash类集合,必须重写hashcode。如果不重写,调用的是Object的hashcode,而Object的hashCode实际上是地址。

4)向哈希表中添加数据的原理:?#27605;?#38598;合Set?#24615;?#21152;对象时,首先集合计算要增加对象的hashCode码,根据该值来得到一个位置用?#21019;?#25918;当前对象,如在该位置没有一个对象存在的话,那么集合Set认为该对象在集合中不存在,直接增加进去。如果在该位置有一个对象存在的话,接着将准备增加到集合中的对象与该位置上的对象进行equals方法比较,如果该equals方法返回false,那么集合认为集合中不存在该对象,在进行一次散?#26657;?#23558;该对象放到散列后计算出的新地址里。如果equals方法返回true,那么集合认为集合中已经存在该对象了,?#25442;?#20877;将该对象增加到集合中了。

5)在哈希表中判断两个元素是否重复要使用到hashCode()和equals()。hashCode决定数据在表中的存储位置,而equals判断是否存在相同数据。

6) Y=K(X) :K是函数,X是哈希码,Y是地址

198.TreeSet的原理和使用(Comparable和comparator)

1)TreeSet集合,元素不允许重复且有序(自然顺序)

2)TreeSet采用树结构存储数据,存入元素时需要和树?#24615;?#32032;进行?#21592;齲?#38656;要指定比较策略。

3)可以通过Comparable(外部比较器)和Comparator(内部比较器)来指定比较策略,实现了Comparable的系统类可以顺利存入TreeSet。自定义类可以实现Comparable接口来指定比较策略。

4)可创建Comparator接口实现类来指定比较策略,并通过TreeSet构造方法参数传入。这种方?#25509;?#20854;对系统类非常?#35270;謾?/p>

199.集合和数组的比较(为什么引入集合)

数组不是面向对象的,存在明显的?#27605;藎?#38598;合完全?#26893;?#20102;数组的一些缺点,比数组更灵活更实用,可大大提高软件?#30446;?#21457;效率而且不同的集合框架类可?#35270;?#20110;不同场合。具体如下:

1)数组的效率高于集合类.

2)数组能存放基本数据类型和对象,而集合类中只能放对象。

3)数组容量固定且无法动态改变,集合类容量动态改变。

4)数组无法判断其中实际存有多少元素,length只告诉了array的容量。

5)集合有多种实现方式和不同的?#35270;?#22330;合,而不像数组仅采用顺序表方?#20581;?/p>

6)集合以类的?#38382;?#23384;在,具有封装、继?#23567;?#22810;态等类的特性,通过简单的方法和属性调用即可实现各种复杂操作,大大提高软件?#30446;?#21457;效率。

200.Collection和Collections的区别

1)Collection是Java提供的集合接口,存储一组不唯一,无序的对象。它有两个子接口List和Set。

2)Java中还有一个Collections类,专门用来操作集合类 ,它提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

201.下列说法正确的有()(选择一项)
A. LinkedList继承自List
B. AbstractSet继承自Set
C. HashSet继承自AbstractSet
D. TreeMap继承自HashMap
答案: C
分析:A:LinkedList实现List接口
B:AbstractSet实现Set接口
D:TreeMap继承AbstractMap
202.Java的HashMap和Hashtable有什么区别HashSet和HashMap有什么区别?使用这些结构保存的数需要重载的方法是哪些?

答:HashMap与Hashtable实现原理相同,功能相同,底层都是哈希表结构,查询速度快,在很多情况下可以互用

两者的主要区别如下

1、Hashtable是早期JDK提供的接口,HashMap?#20999;?#29256;JDK提供的接口

2、Hashtable继承Dictionary类,HashMap实现Map接口

3、Hashtable线程安全,HashMap线程非安全

4、Hashtable不允许null值,HashMap允许null值

HashSet与HashMap的区别

1、HashSet底层是采用HashMap实现的。HashSet 的实现比较简单,HashSet 的绝大部分方法都是通过调用 HashMap 的方法来实现的,因此 HashSet 和 HashMap 两个集合在实现本质上是相同的。

2、HashMap的key就是放进HashSet中对象,value是Object类型的。

3、当调用HashSet的add方法时,实际上是向HashMap?#24615;?#21152;了一行(key-value对),该行的key就是向HashSet增加的那个对象,该行的value就是一个Object类型的常量

203.列出Java中的集合类层次结构?

答:Java中集合主要分为两?#37073;篊ollection和Map。Collection是List和Set接口的父接口;ArrayList和LinkedList是List的实现类;HashSet和TreeSet是Set的实现类;LinkedHashSet是HashSet的子类。HashMap和TreeMap是Map的实现类;LinkedHashMap是HashMap的子类。

图?#26657;?#34394;线框中为接口,实线框中为类。

204.List,Set,Map各有什么特点

答:List 接口存储一组不唯一,有序(插入顺序)的对象。

Set 接口存储一组唯一,无序的对象。

Map接口存储一组键值对象,提供key到value的映射。key无序,唯一。value不要求有序,允许重?#30784;#?#22914;果只使用key存储,而不使用value,那就是Set)。

205.ArrayList list=new ArrayList(20);中的list扩充几次()
A. 0
B. 1
C. 2
D. 3
答案:A
分析:已经指定了长度, 所以不扩容
206.List、Set、Map哪个继承自Collection接口,一下说法正确的是()
A. List Map
B. Set Map
C. List Set
D. List Map Set
答案:C
分析:Map接口继承了java.lang.Object类,但没有实现任何接口.
207.合并两个有序的链表
public class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
if (l1 == null || l2 == null) {
            return l1 != null ? l1 : l2;
        }
        ListNode head = l1.val < l2.val ? l1 : l2;
        ListNode other = l1.val >= l2.val ? l1 : l2;
        ListNode prevHead = head;
        ListNode prevOther = other;
        while (prevHead != null) {
            ListNode next = prevHead.next;
            if (next != null && next.val > prevOther.val) {
                prevHead.next = prevOther;
                prevOther = next;
            }
            if(prevHead.next==null){
                prevHead.next=prevOther;
                break;
            }
            prevHead=prevHead.next;
        }
        return head;
}
}
208.用递归方式实现链表的转置。
/**
Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
* }
*/
public class Solution {
public ListNode reverseList(ListNode head) {
if(head==null||head.next ==null)
            return head;
        ListNode prev = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return prev;
}
}
209.给定一个不包含相同元素的整数集合,nums,返回所有可能的子集集合。解答中集合不能包含重复的子集。
public class Solution {
    public List<List<Integer>> subsets (int[] nums) {
        List<List<Integer>> res = new ArrayList<ArrayList<Integer>>();
        List<Integer> item = new ArrayList<Integer>();
        if(nums.length == 0 || nums == null)
            return res;
        Arrays.sort(nums); //排序
        dfs(nums, 0, item, res);  //递归调用
        res.add(new ArrayList<Integer>());  //最后加上一个空集
        return res;
    }
    public static void dfs(int[] nums, int start, List<Integer> item, List<List<Integer>> res){
        for(int i = start; i < nums.length; i ++){
            item.add(nums[i]);
            //item是以整数为元素的动态数组,而res是以数组为元素的数组,在这一步,当item增加完元素后,item所有元素构成一个完整的子串,再由res纳入
            res.add(new ArrayList<Integer>(item));
            dfs(nums, i + 1, item, res);
            item.remove(item.size() - 1);
        }
    }
}
210.以下结构?#26657;?#21738;个具有同步功能()
A. HashMap
B. ConcurrentHashMap
C. WeakHashMap
D. TreeMap
答案:B
分析:
A,C,D都线程不安全,B线程安全,具有同步功能
211.以下结构?#26657;?#25554;入性能最高的是()
A. ArrayList
B. Linkedlist
C. tor
D. Collection
答案:B
分析:
数组插入、删除效率差,排除A
tor不是java里面的数据结构,是一种网络路由技术;因此排除C
Collection 是集合的接口,不是某种数据结构;因此排除D
212.以下结构?#26657;?#21738;个最适?#31995;?#20316;stack使用()
A. LinkedHashMap
B. LinkedHashSet
C. LinkedList
LinkedList
分析:
Stack是先进后出的线?#36234;?#26500;;所以链表比较合适;不需要散列表的数据结构
213.Map的实现类?#26657;?#21738;些是有序的,哪些是无序的,有序的是如何保证其有序性,你觉得哪个有序性性能更高,你有没有更好或者更高效的实现方式?

答:1. Map的实现类有HashMap,LinkedHashMap,TreeMap

2. HashMap是有无序的,LinkedHashMap和TreeMap都是有序的(LinkedHashMap记录了添加数据的顺序;TreeMap默认是自然升序)

3. LinkedHashMap底层存储结?#25925;?#21704;希表+链表,链表记录了添加数据的顺序

4. TreeMap底层存储结?#25925;?#20108;叉树,二叉树的中序遍历保证了数据的有序性

5. LinkedHashMap有序性能比较高,因为底层数据存储结构采用的哈希表

214.下面的代码在绝大部分时间内都运行得很正常,请问什么情况下会出现问题?根源在哪里?
package com.bjsxt;
import java.util.LinkedList;
public class Stack {
LinkedList list = new LinkedList();
public synchronized void push(Object x) {
synchronized (list) {
list.addLast(x);
notify();
}
}
public  synchronized Object pop() throws  Exception{
synchronized(list){
if(list.size()<=0){
wait();
}
return list.removeLast( );
}
}
}

答:将if( list.size() <= 0 )?#26576;桑簑hile( list.size() <= 0 )

215.TreeMap和TreeSet在排序时如何比较元素?Collections工具类中的sort()方法如何比较元素?

答:TreeSet要求存放的对象所属的类必须实现Comparable接口,该接口提供了比较元素的compareTo()方法,当插入元素时会 回调该方法比较元素的大小。TreeMap要求存放的键值对映射的键必须实现Comparable接口从而根据键对元素进行排序。Collections 工具类的sort方法有两种重载的?#38382;剑?#31532;一种要求传入的待排序容器?#20889;?#25918;的对象比较实现Comparable接口以实现元素的比较;第二种不强制性的要求容器中的元素必须可比较,但是要求传入第二个参数,参数是Comparator接口的子类型(需要重写compare方法实现元素的比较),相当于一个临时定义的排序规则,其实就是是通过接口注入比较元素大小的算法,也是对回调模式的应用。

216.List里面如何剔除相同的对象?请简单?#20040;?#30721;实现一种方法
public class Test {
public static void main(String[] args) {
  List<String> li1 = new ArrayList<String>();
  li1.add("8");
  li1.add("8");
  li1.add("9");
  li1.add("9");
  li1.add("0");
  System.out.println(li1);
  //方法:将List中数据取出来?#21019;?#21040;Set中
  HashSet<String> set = new HashSet<String>();
  for(int i=0;i<li1.size();i++){
  set.add(li1.get(i));
  }
  System.out.println(set);
}
}
217.Java.util.Map的实现类有

分析:Java中的java.util.Map的实现类

1、HashMap

2、Hashtable

3、LinkedHashMap

4、TreeMap

218.下?#34892;?#36848;中正确的是()
A. 循环队列有队头和队尾两个指针,因此,循环队列是非线?#36234;?#26500;
B. 在循环队列?#26657;?#21482;需要队?#20998;?#38024;就能反映队列?#24615;?#32032;的动态变化情况
C. 在循环队列?#26657;?#21482;需要队尾指针就能反映队列?#24615;?#32032;的动态变化情况
D. 在循环队列?#24615;?#32032;的个数是由队?#20998;?#38024;和队尾指针共同决定的
答案:D
分析:循环队列?#24615;?#32032;的个数是由队首指针和队尾指针共同决定的,元素的动态变化也是通过队首指针和队尾指针来反映的,当队首等于队尾时,队列为空。
219.List、Set、Map 是否继承自Collection 接口?

答:List、Set 的父接口是Collection,Map 不是其子接口,而是与Collection接口是平行关系,互不包含。

Map是键值对映射容器,与List和Set有明显的区别,而Set存储的零散的元素且不允许有重复元素(数学中的集合也是如此),List是线?#36234;?#26500;的容器,?#35270;?#20110;按数值索引访?#35797;?#32032;的情形。?

220.说出ArrayList、Vector、LinkedList 的存储性能和特性?

答:ArrayList 和Vector都是使用数组方式存储数据,此数组元素数大于实际存储的数据?#21592;?#22686;加和插入元素,它们都允许直接按序号索引元素,但是插入元素要涉及数组元素移动等内存操作,所以索引数据快而插入数据慢,Vector由于使用了synchronized 方法(线程安全),通常性能上较ArrayList 差,而LinkedList 使用双向链表实?#25191;?#20648;(将内存中零散的内存单元通过附加的引用关联起来,形成一个可以按序号索引的线?#36234;?#26500;,这种链式存储方式与数组的连续存储方式相比,其实对内存的利用率更高),按序号索引数据需要进行前向或后向遍历,但是插入数据时只需要记录本项的前后项即可,所以插入速度较快。Vector属于遗留容器(早期的JDK中使用的容器,除此之外Hashtable、Dictionary、BitSet、Stack、Properties都是遗留容器),现在已经不推荐使用,但是由于ArrayList和LinkedListed都是非线程安全的,如果需要多个线程操作同一个容器,那么可以通过工具类Collections中的synchronizedList方法将其转换成线程安全的容器后再使用(这其实是装潢模式最好的例子,将已有对象传入另一个类的构造器中创建新的对象来增?#26377;?#21151;能)。

补充:遗留容器中的Properties类和Stack类在设计上有?#29616;?#30340;问题,Properties是一个键和值都是字符串的特殊的键值对映射,在设计上应该是关联一个Hashtable并将其两个泛型参数设置为String类型,但是Java API中的Properties直接继承了Hashtable,这很明显是对继承的滥用。这里?#20174;么?#30721;的方?#25509;?#35813;是HAS-A关系而不是IS-A关系,另一方面容器都属于工具类,继承工具类本身就是一个错误的做法,使用工具类最好的方式是HAS-A关系(关联)或USE-A关系(?#35272;担?。同理,Stack类继承Vector也是不正确的。?

221.List、Map、Set 三个接口,存取元素时,各有什么特点?

答:List以特定索引?#21019;?#21462;元素,可有重复元素。

Set不能存放重复元素(用对象的equals()方法来区分元素是否重复) 。Map保存键值对(key-value pair)映射,映射关系可以是一对一或多对一。Set和Map容器都有基于哈希存储和排序树(红黑树)的两种实现版本,基于哈希存储的版本理论存取时间复杂度为O(1),而基于排序树版本的实现在插入或删除元素时会按照元素或元素的键(key)构成排序树从而达到排序和去重的效果。?

222.TreeMap和TreeSet在排序时如何比较元素?Collections工具类中的sort()方法如何比较元素?

答:TreeSet要求存放的对象所属的类必须实现Comparable接口,该接口提供了比较元素的compareTo()方法,当插入元素时会回调该方法比较元素的大小。

TreeMap要求存放的键值对映射的键必须实现Comparable接口从而根据键对元素进行排序。

Collections工具类的sort方法有两种重载的?#38382;剑?#31532;一种要求传入的待排序容器?#20889;?#25918;的对象比较实现Comparable接口以实现元素的比较;第二种不强制性的要求容器中的元素必须可比较,但是要求传入第二个参数,参数是Comparator接口的子类型 (需要重写compare方法实现元素的比较),相当于一个临时定义的排序规则,其实就是是通过接口注入比较元素大小的算法,也是对回调模式的应用。

例子1:

Student.java

package com.bjsxt;

public class Student implements Comparable<Student> {
    private String name;        // 姓名
    private int age;            // 年龄
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int compareTo(Student o) {
        return this.age - o.age; // 比较年龄(年龄的升序)
    }
  }

Test01.java

package com.bjsxt;
import java.util.Set;
import java.util.TreeSet;

class Test01 {
  public static void main(String[] args) {
        Set<Student> set = new TreeSet<>();     // Java 7的钻石语法(构造器后面的尖括号中不需要写类型)
        set.add(new Student("Hao LUO", 33));
        set.add(new Student("XJ WANG", 32));
        set.add(new Student("Bruce LEE", 60));
        set.add(new Student("Bob YANG", 22));
          for(Student stu : set) {
            System.out.println(stu);
        }
//      输出结果:
//      Student [name=Bob YANG, age=22]
//      Student [name=XJ WANG, age=32]
//      Student [name=Hao LUO, age=33]
//      Student [name=Bruce LEE, age=60]
    }
}

例子2:

Student.java

package com.bjsxt;

public class Student {
    private String name;    // 姓名
    private int age;        // 年龄
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    /**
     * 获取学生姓名
     */
    public String getName() {
        return name;
    }
    /**
     * 获取学生年龄
     */
    public int getAge() {
        return age;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
  }

Test02.java

package com.bjsxt;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

  class Test02 {
   public static void main(String[] args) {
        List<Student> list = new ArrayList<>();     // Java 7的钻石语法(构造器后面的尖括号中不需要写类型)
        list.add(new Student("Hao LUO", 33));
        list.add(new Student("XJ WANG", 32));
        list.add(new Student("Bruce LEE", 60));
        list.add(new Student("Bob YANG", 22));

        // 通过sort方法的第二个参数传入一个Comparator接口对象
        // 相当于是传入一个比较对象大小的算法到sort方法中
        // 由于Java中没有函数指针、仿函数、委托这样的概念
        // 因此要将一个算法传入一个方法中唯一的选择就是通过接口回调
        Collections.sort(list, new Comparator<Student> () {
         @Override
            public int compare(Student o1, Student o2) {
                return o1.getName().compareTo(o2.getName());    // 比较学生姓名
            }
        });

        for(Student stu : list) {
            System.out.println(stu);
        }
//      输出结果:
//      Student [name=Bob YANG, age=22]
//      Student [name=Bruce LEE, age=60]
//      Student [name=Hao LUO, age=33]
//      Student [name=XJ WANG, age=32]
    }
}

多线程:

223.下面程序的运?#34218;?#26524;()(选择一项)
public static void main(String[] args) {
Thread t=new Thread(){
public void run(){
pong();
}
};
t.run();
System.out.println("ping");
}
static void pong(){
System.out.println("pong");
}
A. pingpong
B. pongping
C. pingpong和pongping都有可能
D. 都不输出
答案:B
分析:启动线程需要调用start()方法,而t.run()方法,则是使用对象名.分析:启动线程需要调用start()方法,而t.run()方法,则是使用对象名.
224.下列哪个方法可用于创建一个可运行的类()
A. public class X implements Runnable{public void run() {……}}
B. public class X extends Thread{public void run() {……}}
C. public class X extends Thread{public int run() {……}}
D. public class X implements Runnable{protected void run() {……}}
答案:AB
分析: 继承Thread和实现Runable接口
225.说明类java.lang.ThreadLocal的作用和原理。列举在哪些程序中见过ThreadLocal的使用?

作用:

要编写一个多线程安全(Thread-safe)的程序是困?#35757;模?#20026;了让线程共享?#35797;矗?#24517;须小心地对共享?#35797;?#36827;?#22411;?#27493;,同步带来一定的效能?#26144;伲?#32780;另一方面,在处理同步的时候,又要注意对象的锁定与释放,避免产生死结,种种因素都使得编写多线程程序变得困?#36873;?/p>

尝试从另一个角度来思考多线程共享?#35797;?#30340;问题,?#28909;还?#20139;?#35797;?#36825;么困难,那么就干脆不要共享,何不为每个线程创造一个?#35797;?#30340;复本。将每一个线程存取数据的行为加以隔离,实现的方法就是给予每个线程一个特定空间来保管该线程所独享的?#35797;础?/p>

?#28909;紓?#22312;Hibernate中的Session就有使用。

ThreadLocal的原理

ThreadLocal是如何做到为每一个线程维护变量的?#21271;?#30340;呢?其实实现的思路很简单,在ThreadLocal类中有一个Map,用于存储每一个线程的变量的?#21271;尽?/p>

226.说说乐观锁与悲观锁

答:悲观锁(Pessimistic Lock), 顾名思义,就是很悲观,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制,?#28909;?#34892;锁,表锁等,?#20102;?#20889;锁等,都是在做操作之前先上锁。

乐观锁(Optimistic Lock), 顾名思义,就是很乐观,每次去拿数据的时候都认为别人?#25442;?#20462;改,所以?#25442;?#19978;锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号等机制。乐观锁?#35270;?#20110;多读的应用类型,这样可以提高吞吐量,像数据库如果提供类似于write_condition机?#39057;?#20854;实都是提供的乐观锁。

两种锁各有优缺点,不可认为一种好于另一?#37073;?#20687;乐观锁?#35270;?#20110;写比较少的情况下,即冲突真的很少发生的时候,这样可以省去了锁?#30446;?#38144;,加大了系统的整个吞吐量。但如果经常产生冲突,上层应用会不断的进行retry,这样反?#25925;墙档?#20102;性能,所以这种情况下用悲观锁就比较合适。

227.在Java?#24615;?#20040;实现多线程?描述线程状态的变化过程。

答:当多个线程访?#37322;?#19968;个数据时,容易出现线程安全问题,需要某种方式来确保?#35797;?#22312;某一时刻只被一个线程使用。需要让线程同步,保证数据安全线程同步的实现方案: 同步代码块和同步方法,均需要使用synchronized关键字

同步代码块:public void makeWithdrawal(int amt) {

synchronized (acct) { }

}

同步方法:public synchronized void makeWithdrawal(int amt) { }

线程同步的?#20040;Γ?#35299;决了线程安全问题

线程同步的缺点:性能下降,可能会带来死锁

228.请写出多线程代码使用Thread或者Runnable,并说出两种的区别。

方式1:继承Java.lang.Thread类,并覆盖run() 方法。优势:编写简单;?#37038;疲何?#27861;继承其它父类

public class ThreadDemo1 {
public static void main(String args[]) {
MyThread1 t = new MyThread1();
t.start();
while (true) {
System.out.println("兔子领先了,别?#26223;?quot;);
}
}
}
class MyThread1 extends Thread {
public void run() {
while (true) {
System.out.println("乌龟领先了,加油");
}
}
}

方式2:实现Java.lang.Runnable接口,并实现run()方法。优势:可继承其它类,多线程可共享同一个Thread对象;?#37038;疲?#32534;程方式稍微复杂,如需访问当前线程,需调用Thread.currentThread()方法

public class ThreadDemo2 {
public static void main(String args[]) {
MyThread2 mt = new MyThread2();
Thread t = new Thread(mt);
t.start();
while (true) {
System.out.println("兔子领先了,加油");
}
}
}
class MyThread2 implements Runnable {
public void run() {
while (true) {
System.out.println("乌龟超过了,再接再厉");
}
}
}
229.在多线程编程里,wait方法的调用方式是怎样的?

答:wait方法是线程通信的方法之一,必须用在 synchronized方法或者synchronized代码块?#26657;?#21542;则会抛出异常,这就涉及到一个?#20843;?#30340;概念,而wait方法必须使用上锁的对象来调用,从而持有该对象的锁进入线程等待状态,直到使用该上锁的对象调用notify或者notifyAll方法来唤醒之前进入等待的线程,以释放持有的锁。

230.Java线程的几种状态

答:线程是一个动态执行的过程,它有一个从产生到死亡的过程,?#21442;?#31181;状态:

新建(new Thread)

当创建Thread类的一个实例(对象)时,此线程进入新建状态(未被启动)

例如:Thread t1=new Thread();

就绪(runnable)

线程已经被启动,正在等待被分配给CPU时间片,也就是说此时线程正在就绪队列中排队等候得到CPU?#35797;础?#20363;如:t1.start();

运?#26657;╮unning)

线程获得CPU?#35797;?#27491;在执行任务(run()方法),此时除非此线程自动?#29260;鶦PU?#35797;?#25110;者有优先级更高的线程进入,线程将一直运行到结束。

死亡(dead)

当线程执?#22411;?#27605;或被其它线程杀?#28291;?#32447;程就进入死亡状态,这时线程不可能再进入就绪状态等待执?#23567;?/p>

自然终止:正常运行run()方法后终止

异常终止:调用stop()方法让一个线程终止运行

堵塞(blocked)

由于某种原因导致正在运行的线程让出CPU并暂停自己的执?#26657;?#21363;进入堵塞状态。

正在睡眠:用sleep(long t) 方法可使线程进入睡眠方?#20581;?#19968;个睡眠着的线程在指定的时间过去?#23665;?#20837;就绪状态。

正在等待:调用wait()方法。(调用motify()方法回到就绪状态)

被另一个线程所阻塞:调用suspend()方法。(调用resume()方法?#25351;矗?/p>

231.在Java多线程?#26657;?#35831;用下面哪种方?#35762;换?#20351;线程进入阻塞状态()
A. sleep()
B. Suspend()
C. wait()
D. yield()
答案:D
分析:yield会是线程进入就绪状态
232.volatile关键字是否能保证线程安全?

答:不能。虽然volatile提供了同步的机制,但是知识一种弱的同步机制,如需要强线程安全,还需要使用synchronized。

Java语言提供了一种稍弱的同步机制,即volatile变量,用来确保将变量的更新操作通知到其他线程。当把变?#21487;?#26126;为volatile类型后,编译器与运行时都会注意到这个变量是共享的,因此?#25442;?#23558;该变量上的操作与其他内存操作一起重排序。volatile变量?#25442;岜换?#23384;在寄存器或者对其他处理器不可见的地方,因此在读取volatile类型的变量时总会返回最新写入的值。

一、volatile的内存语义是:

当写一个volatile变量时,JMM会把该线程对应的本地内存中的共享变量值立?#27492;?#26032;到主内存?#23567;?

当读一个volatile变量时,JMM会把该线程对应的本地内存设置为无效,直接从主内存中读取共享变量。

二、volatile底层的实现机制

如果把加入volatile关键字的代码和未加入volatile关键字的代码都生成汇编代码,会发现加入volatile关键字的代码会多出一个lock前缀指令。

1 、重排序时不能把后面的指令重排序到内存屏障之前的位置

2、使得本CPU的Cache写入内存

3、写入动作?#19981;?#24341;起别的CPU或者别的内核无效化其Cache,相当于让新写入的值?#21592;?#30340;线程可见。

233.请写出常用的Java多线程启动方式,Executors线程池有几种常用类型?

(1) 继承Thread类

public class java_thread extends Thread{
    public static void main(String args[]) {
        new java_thread().run();
        System.out.println("main thread run ");
    }
    public synchronized  void run() {
        System.out.println("sub thread run ");
    }
}

(2) 实现Runnable接口

public class java_thread implements Runnable{
    public static void main(String args[]) {
        new Thread(new java_thread()).start();
        System.out.println("main thread run ");
    }
    public void run() {
        System.out.println("sub thread run ");
    }
}

在Executor框架下,利用Executors的静态方法可以创建三种类型的常用线程池:

1)FixedThreadPool这个线程池可以创建固定线程数的线程池。

2)SingleThreadExecutor是使用单个worker线程的Executor。

3)CachedThreadPool是一个”无限“容量的线程池,它会根据需要创建新线程。

234.关于sleep()和wait(),以下描述错误的一项是()
A. sleep是线程类(Thread)的方法,wait是Object类的方法
B. Sleep不释放对象锁,wait?#29260;?#23545;象锁
C. Sleep暂停线程、但监控状态任然保?#37073;?#32467;束后会自动?#25351;?/td>
D. Wait后进入等待锁定池,只针对此对象发出notify方法后获取对象锁进入运行状态。
答案:D
分析:针对此对象的notify方法后获取对象锁并进入就绪状态,而不是运行状态。另外针对此对象的notifyAll方法后?#37096;?#33021;获取对象锁并进入就绪状态,而不是运行状态
235.进程和线程的区别是什么?

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行?#35797;?#20998;配和调度的一个独立单位.

线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统?#35797;?只拥有一点在运行中必不可少的?#35797;?如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部?#35797;?

区别 进程 线程
根本区别? 作为?#35797;?#20998;配的单位? 调度和执行的单位
开销? 每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会?#34218;?#22823;?#30446;?#38144;。? 线程可以看成时轻量级的进程,同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换?#30446;?#38144;小。?
所处环境? 系统在运行的时候会为每个进程分配不同的内存区域? 除了CPU之外,?#25442;?#20026;线程分配内存(线程所使用的?#35797;?#26159;它所属的进程的?#35797;矗?#32447;程组只能共享?#35797;?
分配内存? 系统在运行的时候会为每个进程分配不同的内存区域? 除了CPU之外,?#25442;?#20026;线程分配内存(线程所使用的?#35797;?#26159;它所属的进程的?#35797;矗?#32447;程组只能共享?#35797;?
包含关系? 没有线程的进程是可?#21592;?#30475;作单线程的,如果一个进程内拥有多个线程,则执行过程不是一条线的,而是多条线(线程)共同完成的。? 线程是进程的一部分,所以线程有的时候被称为是轻权进程或者轻量级进程。?
236.以下锁机机制?#26657;?#19981;能保证线程安全的是()
A. Lock
B. Synchronized
C. Volatile
答案:C
237.创建n多个线程,如何保证这些线程同时启动?看清,是“同时”。

答:用一个for循环创建线程对象,同时调用wait()方法,让所有线程等待;直到最后一个线程也准备就绪后,调用notifyAll(), 同时启动所有线程。

?#28909;紓?#32473;你n个赛车,让他们都在起跑线上就绪后,同时出发,Java多线程如何?#21019;?#30721;?

思路是,来一辆赛车就加上一把锁,并修改对应的操作数,如果没有全部就绪就等待,并释放锁,直到最后一辆赛车到场后唤醒所有的赛车线程。代码参考如下:

public class CarCompetion {
    // 参赛赛车的数量
    protected final int totalCarNum = 10;
    // 当前在起跑线的赛车数量
    protected int nowCarNum = 0;
}
public class Car implements Runnable{
    private int carNum;
    private CarCompetion competion = null;
    public Car(int carNum, CarCompetion competion) {
        this.carNum = carNum;
        this.competion = competion;
    }
    @Override
    public void run() {
        synchronized (competion) {
            competion.nowCarNum++;
            while (competion.nowCarNum < competion.totalCarNum) {
                try {
                    competion.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            competion.notifyAll();
        }
        startCar();
    }
    private void startCar() {
        System.out.println("Car num " + this.carNum + " start to run.");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Car num " + this.carNum + " get to the finish line.");
    }
}
public static void main(String[] args) {
    CarCompetion carCompetion = new CarCompetion();
    final ExecutorService carPool =
        Executors.newFixedThreadPool(carCompetion.totalCarNum);
    for (int i = 0; i < carCompetion.totalCarNum; i++) {
        carPool.execute(new Car(i, carCompetion));

}
238.同步和异步有?#25105;?#21516;,在什么情况下分别使用它们?

答:1.如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到,或者正在读的数据可能已经被另一个线程写过了,那么这些数据就是共享数据,必须进?#22411;?#27493;存取。

2.当应用程序在对象上调用了一个需要花费很长时间来执行的方法,并且不希望让程序等待方法的返回时,就应该使用异步编程,在很多情况下采用异步途径往往更有效率。

3.举个例子: 打电话是同步 发消息是异步

239.Java线程?#26657;瑂leep()和wait()区别

答:sleep是线程类(Thread)的方法;作用是导致此线程暂停执行指定时间,给执行机会给其他线程,但是监控状态依然保?#37073;?#21040;时后会自动?#25351;矗?#35843;用sleep()?#25442;?#37322;放对象锁。

wait是Object类的方法;对此对象调用wait方法导致本线程?#29260;?#23545;象锁,进入等 待此对象的等待锁定池。只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池,准备获得对象锁进?#24615;?#34892;状态。

240.下面所述步骤?#26657;?#26159;创建进程做必须的步骤是()
A. 由调度程序为进程分配CPU
B. 建立一个进程控制块
C. 为进程分配内存
D. 为进程分配文件描述符
答案:BC
241.无锁化编程有哪些常见方法?()
A. 针对计数器,可以使用原子加
B. 只有一个生产者和一个消费者,那么就可以做到免锁访问环形缓冲区(Ring Buffer)
C. RCU(Read-Copy-Update),新旧?#21271;?#20999;换机制,对于旧?#21271;?#21487;以采用?#26144;?#37322;放的做法
D. CAS(Compare-and-Swap),如无锁栈,无锁队列等待
答案:D
分析:A 这方法虽然不太好,但是常见
B ProducerConsumerQueue就是这个,到处都是
C linux kernel里面大量使用
D 本质上其实就是乐观锁,操作起来很困?#36873;!?#21333;生产者多消费者或者多生产者单消费者的情况下比较常见,也不容?#23376;?#21040;ABA问题。
242.sleep()和yield()有什么区别?

答?#23401;?sleep()方法给其他线程运行机会时不考虑线程的优先级,因此会给低优先级的线程以运行的机会;yield()方法?#25442;?#32473;相同优先级或更高优先级的线程以运行的机会;

② 线程执行sleep()方法后转入阻塞(blocked)状态,而执行yield()方法后转入就绪(ready)状态;

③ sleep()方法声明抛出InterruptedException,而yield()方法没有声明任?#25105;?#24120;;

④ sleep()方法比yield()方法(跟操作系统相关)具有更好?#30446;?#31227;植性。?

243.当一个线程进入一个对象的synchronized方法A之后,其它线程是否?#23665;?#20837;此对象的synchronized方法?

答:不能。其它线程只能访问该对象的非同步方法,同步方法则不能进入。?只有等待当前线程执?#22411;?#27605;释放锁?#35797;?#20043;后,其他线程才有可能进行执行该同步方法!

?#30001;? 对象锁分为三?#37073;?#20849;享?#35797;础his、当前类的字节码文件对象

244.请说出与线程同步相关的方法。

答:1. wait():使一个线程处于等待(阻塞)状态,并且释放所持有的对象的锁;

2. sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调?#20040;?#26041;法要捕捉InterruptedException 异常;

3. notify():唤醒一个处于等待状态的线程,当然在调?#20040;?#26041;法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且与优先级无关;

4. notityAll():唤醒所有处入等待状态的线程,注意并不是给所有唤醒线程一个对象的锁,而是让它们竞争;

5. JDK 1.5通过Lock接口提供了显式(explicit)的锁机制,增强了灵活性以及对线程的协调。Lock接口中定义了加锁(lock())和解锁(unlock())的方法,同时还提供了newCondition()方法来产生用于线程之间通信的Condition对象;

6. JDK 1.5还提供了信号量(semaphore)机制,信号量可以用来限制对某个共享?#35797;?#36827;行访问的线程的数量。在对?#35797;?#36827;行访问之前,线程必须得到信号量的许可(调用Semaphore对象的acquire()方法);在完成对?#35797;?#30340;访问后,线程必须向信号量归还许可(调用Semaphore对象的release()方法)。

下面的例子演示了100个线程同时向一个银行账户?#20889;?#20837;1元钱,在没有使用同步机制和使用同步机制情况下的执行情况。

银行账户类:

package com.bjsxt;
/**
 * 银行账户
 * @author sxt
 *
 */
public class Account {
    private double balance;     // 账户余额
    /**
     * 存款
     * @param money 存入金额
     */
    public void deposit(double money) {
        double newBalance = balance + money;
        try {
            Thread.sleep(10);   // 模拟此业务需要一段处理时间
        }
        catch(InterruptedException ex) {
            ex.printStackTrace();
        }
        balance = newBalance;
    }
    /**
     * 获得账户余额
     */
    public double getBalance() {
        return balance;
    }
}

存钱线程类:

package com.bjsxt;
/**
 * 存钱线程
 * @author sxt李端阳
 *
 */
public class AddMoneyThread implements Runnable {
    private Account account;    // 存入账户
    private double money;       // 存入金额

    public AddMoneyThread(Account account, double money) {
        this.account = account;
        this.money = money;
    }

    @Override
    public void run() {
        account.deposit(money);
    }
 }

测试类:

package com.bjsxt;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

 public class Test01 {
public static void main(String[] args) {
        Account account = new Account();
        ExecutorService service = Executors.newFixedThreadPool(100);
        for(int i = 1; i <= 100; i++) {
            service.execute(new AddMoneyThread(account, 1));
        }
        service.shutdown();
        while(!service.isTerminated()) {}
        System.out.println("账户余额: " + account.getBalance());
    }
}

在没有同步的情况下,执?#34218;?#26524;通常是显示账户余额在10元以下,出现这种状况的原因是,当一个线程A试图存入1元的时候,另外一个线程B也能够进入存款的方法?#26657;?#32447;程B读取到的账户余额仍然是线程A存入1元钱之前的账户余额,因此也是在原来的余额0上面做了加1元的操作,同理线程C?#19981;?#20570;类?#39057;?#20107;情,所以最后100个线程执?#34218;?#26463;时,本来期望账户余额为100元,但实?#23454;?#21040;的通常在10元以下。解决这个问题的办法就是同步,当一个线程对银行账户存钱时,需要将此账户锁定,待其操作完成后才允许其他的线程进行操作,代码有如?#24405;?#31181;调整方案:

1. 在银行账户的存款(deposit)方法上同步(synchronized)关键字

package com.bjsxt;
/**
 * 银行账户
 * @author SXT李端阳
*/
public class Account {
    private double balance;     // 账户余额
    /**
     * 存款
     * @param money 存入金额
     */
    public synchronized void deposit(double money) {
        double newBalance = balance + money;
        try {
            Thread.sleep(10);   // 模拟此业务需要一段处理时间
        }
        catch(InterruptedException ex) {
            ex.printStackTrace();
        }
        balance = newBalance;
    }

    /**
     * 获得账户余额
     */
    public double getBalance() {
        return balance;
    }
}

2. 在线程调?#20040;?#27454;方法时对银行账户进?#22411;?#27493;

package com.bjsxt;
/**
 * 存钱线程
 * @author SXT
 *
 */
public class AddMoneyThread implements Runnable {
    private Account account;    // 存入账户
    private double money;       // 存入金额

    public AddMoneyThread(Account account, double money) {
        this.account = account;
        this.money = money;
    }
    @Override
    public void run() {
        synchronized (account) {
            account.deposit(money);
        }
    }
}

3. 通过JDK 1.5显示的锁机制,为每个银行账户创建一个锁对象,在存款操作进行加锁和解锁的操作

package com.bjsxt;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 银行账户
 *
 * @author SXT李端阳
 *
 */
public class Account {
    private Lock accountLock = new ReentrantLock();
    private double balance; // 账户余额
   /**
     * 存款
     *
     * @param money
     *            存入金额
     */
    public void deposit(double money) {
        accountLock.lock();
        try {
            double newBalance = balance + money;
            try {
                Thread.sleep(10); // 模拟此业务需要一段处理时间
            }
            catch (InterruptedException ex) {
                ex.printStackTrace();
            }
            balance = newBalance;
        }
        finally {
            accountLock.unlock();
        }
    }
    /**
     * 获得账户余额
     */
    public double getBalance() {
        return balance;
    }
}

按照上述三种方式对代码进行修改后,重写执行测试代码Test01,将看到最终的账户余额为100元。?

245.编写多线程程序有几种实现方式?

答:Java 5以前实现多线程有两种实现方法:一种是继承Thread类;另一种是实现Runnable接口。两种方式都要通过重写run()方法来定义线程的行为,推荐使用后者,因为Java中的继承是单继?#26657;?#19968;个类有一个父类,如果继承了Thread类就无法再继承其他类了,同时?#37096;?#20197;实现?#35797;?#20849;享,显然使用Runnable接口更为灵活。

补充:Java 5以后创建线程还有第三种方式:实现Callable接口,该接口中的call方法可以在线程执?#34218;?#26463;时产生一个返回值,代码如下所示:

package com.bjsxt;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

  class MyTask implements Callable<Integer> {
    private int upperBounds;

    public MyTask(int upperBounds) {
        this.upperBounds = upperBounds;
    }

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for(int i = 1; i <= upperBounds; i++) {
            sum += i;
        }
        return sum;
    }

}

public class Test {
  public static void main(String[] args) throws Exception {
        List<Future<Integer>> list = new ArrayList<>();
        ExecutorService service = Executors.newFixedThreadPool(10);
        for(int i = 0; i < 10; i++) {
        list.add(service.submit(new MyTask((int) (Math.random() * 100))));
        }
        int sum = 0;
        for(Future<Integer> future : list) {
            while(!future.isDone()) ;
            sum += future.get();
        }
          System.out.println(sum);
    }
}
246.synchronized关键字的用法?

答:synchronized关键字可?#36234;?#23545;象或者方法标记为同步,以实现对对象和方法的互斥访问,可以用synchronized(对象) { … }定义同步代码块,或者在声明方法时将synchronized作为方法的修饰符。在第60题的例子中已经展示了synchronized关键字的用法。?

247.启动一个线程是用run()?#25925;莝tart()方法?

答:启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM 调度并执?#26657;?#36825;并不意味着线程就会立即运?#23567;un()方法是线程启动后要进行回调(callback)的方法。?

API解释如下:

248.什么是线程池(thread pool)?

答:在面向对象编程?#26657;?#21019;建和销毁对象是很费时间的,因为创建一个对象要获取内存?#35797;?#25110;者其它更多?#35797;础?#22312;Java中更是如此,虚拟机将试图跟踪每一个对象,?#21592;?#33021;够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数,特别是一些很耗?#35797;?#30340;对象创建和销毁,这就是"池化?#35797;?技术产生的原因。线程池顾名思义就是事先创建若干个可执行的线程放入一个池(容器)?#26657;?#38656;要的时候?#26144;?#20013;获取线程不用自行创建,使用完毕不需要销毁线程而是放回池?#26657;?#20174;而减少创建和销毁线程对象?#30446;?#38144;。

Java 5+中的Executor接口定义一个执行线程的工具。它的子类型即线程池接口是ExecutorService。要配置一个线程池是比较复杂的,尤其是对于线程池的原理不是很清楚的情况下,因此在工具类Executors面提供了一些静态工厂方法,生成一些常用的线程池,如下所示:

newSingleThreadExecutor:创建一个单线程的线程池。这个线程池只有一个线程在工作,也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束,那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执?#23567;?/p>

newFixedThreadPool:创建固定大小的线程池。每次提交一个任务就创建一个线程,直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变,如果某个线程因为执行异常而结束,那么线程池会补充一个新线程。

newCachedThreadPool:创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程,那么就会回收部分空?#26657;?0秒不执行任务)的线程,当任务数增加时,此线程池又可以智能的添?#26377;?#32447;程?#21019;?#29702;任务。此线程池?#25442;?#23545;线程池大小做限制,线程池大小完全?#35272;?#20110;操作系?#24120;?#25110;者说JVM)能够创建的最大线程大小。

newScheduledThreadPool:创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

newSingleThreadExecutor:创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

有通过Executors工具类创建线程池并使用线程池执行线程的代码。如果希望在服务器上使用线程池,强烈建议使用newFixedThreadPool方法?#21019;?#24314;线程池,这样能获得更好的性能。?

249.线程的基本状态以及状态之间的关系?

除去起始(new)状态和结束(finished)状态,线程有三种状态,分别是:就绪(ready)、运?#26657;╮unning)和阻塞(blocked)。其中就绪状态代表线程具备了运行的所有条件,只等待CPU调度(万事俱备,只?#33539;?#39118;);处于运行状态的线程可能因为CPU调度(时间片用完了)的原因回到就绪状态,也有可能因为调用了线程的yield方法回到就绪状态,此时线程?#25442;?#37322;放它占有的?#35797;?#30340;锁,坐等CPU以继续执?#26657;?#36816;行状态的线程可能因为I/O中断、线程休眠、调用了对象的wait方法而进入阻塞状态(有的地方也称之为等待状态);而进入阻塞状态的线程会因为休眠结束、调用了对象的notify方法或notifyAll方法或其他线程执?#34218;?#26463;而进入就绪状态。注意:调用wait方法会让线程进入等待池中等待?#25442;?#37266;,notify方法或notifyAll方法会让等待锁中的线程从等待池进入等锁池,在没有得到对象的锁之前,线程仍然无法获得CPU的调度和执?#23567;?/p>

250.简述synchronized 和java.util.concurrent.locks.Lock的异同?

答:Lock是Java 5以后引入的新的API,和关键字synchronized相比主要相同点:Lock 能完成synchronized所实现的所有功能;主要不同点:Lock 有比synchronized 更精确的线程语义和更好的性能。synchronized 会自动释放锁,而Lock 一定要求程序员手工释放,并且必须在finally 块中释放(这是释放外部?#35797;?#30340;最好的地方)。?

251.创建线程的两种方式分别是什么,优缺点是什么?

方式1:继承Java.lang.Thread类,并覆盖run() 方法。

优势:编写简单;

?#37038;疲?#21333;继承的限制----无法继承其它父类,同时不能实现?#35797;?#20849;享。

package com.bjsxt;

public class ThreadDemo1 {
public static void main(String args[]) {
MyThread1 t = new MyThread1();
t.start();
while (true) {
System.out.println("兔子领先了,别?#26223;?quot;);
}
}
}
class MyThread1 extends Thread {
public void run() {
while (true) {
System.out.println("乌龟领先了,加油");
}
}
}

方式2:实现Java.lang.Runnable接口,并实现run()方法。

优势:可继承其它类,多线程可共享同一个Thread对象;

?#37038;疲?#32534;程方式稍微复杂,如需访问当前线程,需调用Thread.currentThread()方法

package com.bjsxt;

public class ThreadDemo2 {
public static void main(String args[]) {
MyThread2 mt = new MyThread2();
Thread t = new Thread(mt);
t.start();
while (true) {
System.out.println("兔子领先了,加油");
}
}
}
class MyThread2 implements Runnable {
public void run() {
while (true) {
System.out.println("乌龟超过了,再接再厉");
}
}
}
252.Java创建线程后,调用start()方法和run()的区别

两种方法的区别

1) start方法:

用start方法来启动线程,真正实现了多线程运?#26657;?#36825;时无需等待run方法体代码执?#22411;?#27605;而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运?#26657;?#29366;态,并没有运?#26657;?#19968;旦得到cpu时间片,就开始执行run()方法,这里方法run()称为线程体,它包含了要执行的这个线程的内容,Run方法运?#34218;?#26463;,此线程随即终止。

2) run():

run()方法只是类的一个普通方法而已,如果直接调用run方法,程序中依然只有主线程这一个线程,其程序执行路径?#25925;?#21482;有一条,?#25925;且?#39034;序执?#26657;故且?#31561;待,run方法体执?#22411;?#27605;后才可继续执行下面的代码,这样就没有达到写线程的目的。

总结:调用start方法方可启动线程,而run方法只是thread的一个普通方法调用,?#25925;?#22312;主线程里执?#23567;?#36825;两个方法应该都比较熟悉,把需要并行处理的代码放在run()方法?#26657;瑂tart()方法启动线程将自动调用 run()方法,这是由jvm的内存机制规定的。并且run()方法必须是public访问权限,返回值类型为void。

两种方式的比较 :

实?#25163;型?#24448;采用实现Runable接口,一方面因为java只支?#20540;?#32487;?#26657;?#32487;承了Thread类就无法再继续继承其它类,而且Runable接口只有一个run方法;另一方面通过结果可以看出实现Runable接口才是真正的多线程。

253.线程的生命周期

线程是一个动态执行的过程,它也有一个从产生到死亡的过程。

生命周期的五种状态

新建(new Thread)

当创建Thread类的一个实例(对象)时,此线程进入新建状态(未被启动)

例如:Thread t1=new Thread();

就绪(runnable)

线程已经被启动,正在等待被分配给CPU时间片,也就是说此时线程正在就绪队列中排队等候得到CPU?#35797;础?#20363;如:t1.start();

运?#26657;╮unning)

线程获得CPU?#35797;?#27491;在执行任务(run()方法),此时除非此线程自动?#29260;鶦PU?#35797;?#25110;者有优先级更高的线程进入,线程将一直运行到结束。

死亡(dead)

当线程执?#22411;?#27605;或被其它线程杀?#28291;?#32447;程就进入死亡状态,这时线程不可能再进入就绪状态等待执?#23567;?/p>

自然终止:正常运行run()方法后终止

异常终止:调用stop()方法让一个线程终止运行

堵塞(blocked)

由于某种原因导致正在运行的线程让出CPU并暂停自己的执?#26657;?#21363;进入堵塞状态。

正在睡眠:用sleep(long t) 方法可使线程进入睡眠方?#20581;?#19968;个睡眠着的线程在指定的时间过去?#23665;?#20837;就绪状态。

正在等待:调用wait()方法。(调用motify()方法回到就绪状态)

被另一个线程所阻塞:调用suspend()方法。(调用resume()方法?#25351;矗?/p>

254.如?#38382;?#29616;线程同步?

当多个线程访?#37322;?#19968;个数据时,容易出现线程安全问题,需要某种方式来确保?#35797;?#22312;某一时刻只被一个线程使用。需要让线程同步,保证数据安全

线程同步的实现方案:

1)同步代码块,使用synchronized关键字

同步代码块:

synchronized (同步锁) {
授课代码;
}

同步方法:

public synchronized void makeWithdrawal(int amt) { }

线程同步的?#20040;Γ?#35299;决了线程安全问题

线程同步的缺点:性能下降,可能会带来死锁

注意: 同步代码块,所使用的同步锁可以是三?#37073;?/p>

1、this 2、 共享?#35797;? 3、 字节码文件对象

同步方法所使用的同步锁,默认的是this

255.说说关于同步锁的更多细节

答:Java中每个对象都有一个内置锁。

当程序运行到非静态的synchronized同步方法上时,自动获得与正在执?#20889;?#30721;类的当前实例(this实例)有关的锁。获得一个对象的锁也称为获取锁、锁定对象、在对象上锁定或在对象上同?#20581;?/p>

当程序运行到synchronized同步方法或代码块时才该对象锁才起作用。

一个对象只有一个锁。所以,如果一个线程获得该锁,就没有其他线程可以获得锁,直到第一个线程释放(或返回)锁。这也意味着任何其他线程都不能进入该对象上的synchronized方法或代码块,直到该锁被释放。

释放锁是指持锁线程退出了synchronized同步方法或代码块。

关于锁和同步,有一?#24405;?#20010;要点:

1)只能同步方法,而不能同步变量和类;

2)每个对象只有一个锁;当提到同步时,应?#20204;?#26970;在什么上同步?也就是说,在哪个对象上同步?

3)不必同步类中所有的方法,类可以同时拥有同步和非同步方法。

4)如果两个线程要执行一个类中的synchronized方法,并且两个线程使用相同的实例来调用方法,那么一次只能有一个线程能够执行方法,另一个需要等待,直到锁被释放。也就是说:如果一个线程在对象上获得一个锁,就没有任何其他线程可?#36234;?#20837;(该对象的)类中的任何一个同步方法。

5)如果线程拥有同步和非同步方法,则非同步方法可?#21592;?#22810;个线程自由访?#35782;?#19981;受锁的限制。

6)线程睡眠时,它所持的任何锁都?#25442;?#37322;放。

7)线程可以获得多个锁。?#28909;紓?#22312;一个对象的同步方法里面调用另外一个对象的同步方法,则获取了两个对象的同步锁。

8)同步损害并发性,应该尽可能缩小同步?#27573;А?#21516;?#35762;?#20294;可以同步整个方法,还可以同步方法中一部分代码块。

9)在使用同步代码块时候,应该指定在哪个对象上同步,也就是说要获取哪个对象的锁。

256.Java中实现线程通信的三个方法的作用是什么?

Java提供了3个方法解决线程之间的通信问题,均是java.lang.Object类的方法,都只能在同步方法或者同步代码块中使用,否则会抛出异常。

方法名 作 用
final void wait() 表示线程一直等待,直到其它线程通知
void wait(long timeout) 线程等待指定毫秒参数的时间
final void wait(long timeout,int nanos) 线程等待指定毫秒、微妙的时间
final void notify() 唤醒一个处于等待状态的线程。注意的是在调?#20040;?#26041;法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且不是按优先级。
final void notifyAll() 唤醒同一个对象上所有调用wait()方法的线程,注意并不是给所有唤醒线程一个对象的锁,而是让它们竞争
IO流:
257.下面哪个流类属于面向字符的输入流()选择一项)
A. BufferedWriter
B. FileInputStream
C. ObjectInputStream
D. InputStreamReader
答案:D
分析:A:字符输出的缓冲流
B:字节输入流
C:对象输入流

258.要从文件”file.dat”文件中读出第10个字节到变量c?#26657;?#19979;列哪个正确()(选择一项)
A.
FileInputStream in=new FileInputStream("file.dat");
in.skip(9);
int c=in.read();
B.
FileInputStream in=new FileInputStream("file.dat");
in.skip(10);
int c=in.read();
C.
FileInputStream in=new FileInputStream("file.dat");
int c=in.read();
D.
RandomAccessFile in=new RandomAccessFile("file.dat");
in.skip(7);
int c=in.readByte();
答案:A
分析: skip(long n)该方法中的n指的是要跳过的字节数
259.新建一个流对象,下面那个选项的代码是错误的?()
A. new BufferedWriter(new FileWriter(“a.txt”));
B. new BufferedReader (new FileInputStream(“a.dat”));
C. new GZIPOutputStream(new FileOutputStream(“a.zip”));
D. new ObjectInputStream(new FileInputStream(“a.dat”));
答案:B
分析:BufferedReader类的参数只能是Reader类型的,不能是InputStream类型。
260.下面哪个流是面向字符的输入流()
A. BufferedWriter
B. FileInputStream
C. ObjectInputStream
D. InputStreamReader
答案:D
以InputStream(输入流)/OutputStream(输出流)为后缀的是字节流;
以Reader(输入流)/Writer(输出流)为后缀的是字符流。
261.Java类库?#26657;?#23558;信息写入内存的类是()
A. Java.io.FileOutputStream
B. java.ByteArrayOutputStream
C. java.io.BufferedOutputStream
D. java,.io.DataOutputStream
答案:B
分析: ACD都是io到文件
262.请写出一段代码,能够完?#23665;?#23383;符串写入文件
public class test {
public static void main(String[] args) {
String str = "bjsxt";
writeFile(str);
}

public static void writeFile(String str) {
File file = new File("c:/test.txt");
PrintStream ps = null;
try {
OutputStream fos = new FileOutputStream(file);
ps = new PrintStream(fos);
ps.print(str);
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
ps.close();
}
}
}
263.下面哪个流类属于面向字符的输入流()
A. BufferedWriter
B. FileInputStream
C. ObjectInputStream
D. InputStreamReader
答案:D
264.Java中如?#38382;?#29616;序列化,有什么意义?

答:序列化就是一种用?#21019;?#29702;对象流的机制,所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作,?#37096;山?#27969;化后的对象传输于网络之间。序列化是为了解决对象流读写操作时可能引发的问题(如果不进行序列化可能会存在数据乱序的问题)。

要实现序列化,需要让一个类实现Serializable接口,该接口是一个标识?#36234;?#21475;,标注该类对象是可被序列化的,然后使用一个输出流来构造一个对象输出流并通过writeObject(Object obj)方法就可?#36234;?#23454;现对象写出(即保存其状态);如果需要反序列化则可以用一个输入流建立对象输入流,然后通过readObject方法从流中读取对象。序列化除了能够实现对象的持久化之外,还能够用于对象的深度克隆(参见Java面试题集1-29题)?

265.Java 中有几种类型的流?

答:两种流分别是字节流,字符流。

字节流继承于InputStream、OutputStream,字符流继承于Reader、Writer。在java.io 包中还有许多其他的流,主要是为了提高性能和使用方便。

补充:关于Java的IO需要注意的有两点:一是两种对称性(输入和输出的对称性,字节和字符的对称性);二是两种设计模式(适配器模式和装潢模式)。另外Java中的流不同于C#的是它只有一个维度一个方向。

补充:下面用IO和NIO两种方式实现文件拷贝,这个题目在面试的时候是经常被问到的。

package com.bjsxt;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class MyUtil {
  private MyUtil() {
        throw new AssertionError();
    }

    public static void fileCopy(String source, String target) throws IOException {
        try (InputStream in = new FileInputStream(source)) {
            try (OutputStream out = new FileOutputStream(target)) {
                byte[] buffer = new byte[4096];
                int bytesToRead;
                while((bytesToRead = in.read(buffer)) != -1) {
                    out.write(buffer, 0, bytesToRead);
                }
            }
        }
    }

    public static void fileCopyNIO(String source, String target) throws IOException {
        try (FileInputStream in = new FileInputStream(source)) {
            try (FileOutputStream out = new FileOutputStream(target)) {
                FileChannel inChannel = in.getChannel();
                FileChannel outChannel = out.getChannel();
                ByteBuffer buffer = ByteBuffer.allocate(4096);
                while(inChannel.read(buffer) != -1) {
                    buffer.flip();
                    outChannel.write(buffer);
                    buffer.clear();
                 }
            }
        }
    }
}

注意:上面用到Java 7的TWR,使用TWR后可以不用在finally中释放外部?#35797;?,从而?#20040;?#30721;更加优雅。

266.写一个方法,输入一个文件名和一个字符串,统计这个字符串在这个文件中出现的次数。

答:代码如下:

package com.bjsxt;
import java.io.BufferedReader;
import java.io.FileReader;

public class Account {
    // 工具类中的方法都是静态方式访问的因此将构造器私有不允许创建对象(绝?#38498;?#20064;惯)
    private Account() {
        throw new AssertionError();
    }
    /**
     * 统计给定文件中给定字符串的出?#25191;?#25968;
     * @param filename  文件名
     * @param word 字符串
     * @return 字符串在文件中出现的次数
     */
    public static int countWordInFile(String filename, String word) {
        int counter = 0;
        try (FileReader fr = new FileReader(filename)) {
            try (BufferedReader br = new BufferedReader(fr)) {
                String line = null;
                while ((line = br.readLine()) != null) {
                    int index = -1;
                    while (line.length() >= word.length() && (index = line.indexOf(word)) >= 0) {
                        counter++;
                        line = line.substring(index + word.length());
                    }
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return counter;
    }
}
267.输入流和输出流联系和区别,节点流和处理流联系和区别

首先,你要明?#36164;?#20040;是“流”。直观地讲,流就像管道一样,在程序和文件之间,输入输出的方向是针对程序而言,向程序中读入东西,就是输入流,从程序中向外读东西,就是输出流。

输入流是得到数据,输出流是输出数据,而节点流,处理流是流的另一种划分,按?#23637;?#33021;不同进行的划分。节点流,可以从或向一个特定的地方(节点)读写数据。处理流是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据?#21015;础?#22914;BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装,称为流的链接。

268.字符流字节流联系区别;什么时候使用字节流和字符流?

字符流和字节流是流的一种划分,?#21019;?#29702;照流的数据单位进行的划分。两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成,输入使的是InputStream,在字符流中输出主要是使用Writer类完成,输入流主要使用Reader类完成。这四个都是抽象类。

字符流处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,而字节流处理单元为1个字节,操作字节和字节数组。字节流是最基本的,所有的InputStrem和OutputStream的子类都是,主要用在处理二进制数据,它是按字节?#21019;?#29702;的 但实际中很多的数据是文本,又提出了字符流的概念,它是按虚拟机的编码?#21019;?#29702;,也就是要进行字符集的转化 这两个之间通过 InputStreamReader,OutputStreamWriter来关联,实际上是通过byte[]和String来关联的。

269.列举常用字节输入流和输出流并说明其特点,至少5对。

FileInputStream 从文件系统中的某个文件中获得输入字节。

FileOutputStream 从程序当中的数据,写入到指定文件。

ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。 ObjectOutputStream 和ObjectInputStream 分别与FileOutputStream 和 FileInputStream 一起使用时,可以为应用程序提供对对象图形的持?#20040;?#20648;。ObjectInputStream 用于?#25351;茨切?#20197;前序列化的对象。其他用途包括使用套接字流在主机之间传递对象,或者用于编组和解组远程通信系统中的实参和形参。

ByteArrayInputStream 包含一个内部缓冲区,该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。

FilterInputStream 包含其他一些输入流,它将这些流用作其基本数据源,它可以直接传输数据或提供一些额外的功能。FilterInputStream 类本身只是简单地重写?#20999;?#23558;所有请求传递给所包含输入流的 InputStream 的所有方法。FilterInputStream 的子类?#23665;?#19968;步重写这些方法中的一些方法,并?#19968;?#21487;以提供一些额外的方法和字段。

StringBufferInputStream此类允许应用程序创建输入流,在该流中读取的字节由字符串内容提供。应用程序还可以使用ByteArrayInputStream 从 byte 数组中读取字节。 只有字符串中每个字符的低八位可以由此类使用。

ByteArrayOutputStream此类实现了一个输出流,其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。

FileOutputStream文件输出流是用于将数据写入 File 或FileDescriptor 的输出流。文件是否可用或能否可?#21592;?#21019;建取决于基础平台。特别是?#25215;?#24179;台一次只允许一个 FileOutputStream(或其他文件写入对象)打开文件进行写入。在这种情况下,如果所涉及的文件已经打开,则此类中的构造方法将失败。

FilterOutputStream类是过滤输出流的所有类的超类。这些流位于已存在的输出流(基础 输出流)之上,它们将已存在的输出流作为其基本数据接收器,但可能直接传输数据或提供一些额外的功能。 FilterOutputStream 类本身只是简单地重写?#20999;?#23558;所有请求传递给所包含输出流的 OutputStream 的所有方法。FilterOutputStream 的子类?#23665;?#19968;步地重写这些方法中的一些方法,并?#19968;?#21487;以提供一些额外的方法和字段。

ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取(重构)对象。通过在流中使用文件可以实现对象的持?#20040;?#20648;。如果流是网络套接字流,则可以在另一台主机上或另一个进程中重构对象。

PipedOutputStream可?#36234;?#31649;道输出流连接到管道输入流?#21019;?#24314;通信管道。管道输出流是管道的发送端。通常,数据由某个线程写入 PipedOutputStream 对象,并由其他线程从连接的 PipedInputStream 读取。不建议对这两个对象尝试使用单个线程,因为这样可能会造成该线程死锁。如果某个线程正从连接的管道输入流中读取数据字节,但该线程不再处于活动状态,则该管道被视为处于毁?#24213;?#24577;。

270.说明缓冲流的优点和原理

不带缓冲的流的工作原理:

它读取到一个字节/字符,就向用户指定的路径写出去,读一个写一个,所以就慢了。

带缓冲的流的工作原理:

读取到一个字节/字符,先不输出,等凑足了缓冲的最大容量后一次性写出去,从而提高了工作效率

优点:减少对硬盘的读取次数,?#26723;?#23545;硬盘的损耗。

271.序列化的定义、实现和注意事项

想把一个对象写在硬盘上或者网络上,对其进行序列化,把他序列化成为一个字节流。

实现和注意事项:

1)实现接口Serializable Serializable接口中没有任何的方法,实现该接口的类不需要实现额外的方法。

2)如果对象中的某个属性是对象类型,必须也实现Serializable接口才可以,序列化对静态变?#35838;?#25928;

3)如果不希望某个属性参与序列化,不是将其static,而是transient串行化保存的只是变量的值,对于变量的任何修饰符,都不能保存序列化版本不兼容

272.使用IO流完成文件夹复制

(结?#31995;?#24402;)

package com.bjsxt;

import java.io.*;
/**
 * CopyDocJob定义了实际执行的任务,即
 * 从源目录拷贝文件到目标目录
*/
public class CopyDir2 {
public static void main(String[] args) {
try {
copyDirectiory("d:/301sxt","d:/301sxt2");
} catch (IOException e) {
e.printStackTrace();
}
}
/**
 * 复?#39057;?#20010;文件
 * @param sourceFile 源文件
 * @param targetFile 目标文件
 * @throws IOException
 */
    private static void copyFile(File sourceFile, File targetFile) throws IOException {
        BufferedInputStream inBuff = null;
        BufferedOutputStream outBuff = null;
        try {
            // 新建文件输入流
            inBuff = new BufferedInputStream(new FileInputStream(sourceFile));
            // 新建文件输出流
            outBuff = new BufferedOutputStream(new FileOutputStream(targetFile));
            // 缓冲数组
            byte[] b = new byte[1024 * 5];
            int len;
            while ((len = inBuff.read(b)) != -1) {
                outBuff.write(b, 0, len);
            }
            // 刷新此缓冲的输出流
            outBuff.flush();
        } finally {
            // 关闭流
            if (inBuff != null)
                inBuff.close();
            if (outBuff != null)
                outBuff.close();
        }
    }

    /**
     * 复制目录
     * @param sourceDir 源目录
     * @param targetDir 目标目录
     * @throws IOException
     */
    private static void copyDirectiory(String sourceDir, String targetDir) throws IOException {
        // 检查源目录
     File fSourceDir = new File(sourceDir);
     if(!fSourceDir.exists() || !fSourceDir.isDirectory()){
      return;
     }
     //检查目标目录,如不存在则创建
     File fTargetDir = new File(targetDir);
     if(!fTargetDir.exists()){
      fTargetDir.mkdirs();
     }
        // 遍历源目录下的文件或目录
        File[] file = fSourceDir.listFiles();
        for (int i = 0; i < file.length; i++) {
            if (file[i].isFile()) {
                // 源文件
                File sourceFile = file[i];
                // 目标文件
                File targetFile = new File(fTargetDir, file[i].getName());
                copyFile(sourceFile, targetFile);
            }
            //递归复制子目录
            if (file[i].isDirectory()) {
                // 准备复?#39057;?#28304;文件夹
                String subSourceDir = sourceDir + File.separator + file[i].getName();
                // 准备复?#39057;?#30446;标文件夹
                String subTargetDir = targetDir + File.separator + file[i].getName();
                // 复制子目录
                copyDirectiory(subSourceDir, subTargetDir);
            }
        }
    }
}
273.说说BIO、NIO和AIO的区别

Java BIO: 同?#35762;?#38459;塞,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,当然可以通过线程池机制改善。

Java NIO: 同步非阻塞,服务器实现模式为一个请求一个线程,即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有I/O请求时?#29260;?#21160;一个线程进行处理。

Java AIO: 异步非阻塞,服务器实现模式为一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

NIO比BIO的改善之处是把一些无效的连接挡在了启动线程之前,减少了这部分?#35797;?#30340;浪费(因为我们都知道每创建一个线程,就要为这个线程分配一定的内存空间)

AIO比NIO的进一步改善之处是将一些暂时可能无效的请求挡在了启动线程之前,?#28909;?#22312;NIO的处理方式?#26657;?#24403;一个请求来的话,开启线程进行处理,但这个请求所需要的?#35797;?#36824;没有就绪,此?#21271;?#39035;等待后端的应用?#35797;矗?#36825;时线程就被阻塞了。

?#35270;?#22330;景分析:

BIO方式?#35270;?#20110;连接数目比较小且固定的架构,这种方式对服务器?#35797;?#35201;求比较高,并发局限于应用?#26657;琂DK1.4以前的唯一选择,但程序直观简单易理解,如之前在Apache中使用。

NIO方式?#35270;?#20110;连接数目多且连接比较短(轻操作)的架构,?#28909;?#32842;天服务器,并发局限于应用?#26657;?#32534;程比较复杂,JDK1.4开始支?#37073;?#22914;在 Nginx,Netty中使用。

AIO方式使用于连接数目多且连接比较长(重操作)的架构,?#28909;?#30456;册服务器,充分调用OS参与并发操作,编程比较复杂,JDK7开始支?#37073;?#22312;成长?#26657;琋etty曾经使用过,后来?#29260;?/p>

网络编程:

274.IP地址和端口号

1)IP地址

用来标志网络中的一个通信实体的地址。通信实体可以是计算机,路由器?#21462;?

2)IP地址分类

IPV4:32位地址,以点分十进制表示,如192.168.0.1

IPV6:128位(16个字节)写成8个16位的无符号整数,每个整数用四个十六进制位表示,数之间用冒号(?#28023;?#20998;开,如:3ffe:3201:1401:1280:c8ff:fe4d:db39:1984

3)特殊的IP地址

127.0.0.1 本机地址

192.168.0.0--192.168.255.255私有地址,属于非注册地址,专门为组织机构内部使用。

4)端口:port

IP地址用来标志一台计算机,但是一台计算机上可能提供多种应用程序,使用端口来区分这些应用程序。 端口?#20999;?#25311;的概念,并不是说在主机上真的有若干个端口。通过端口,可以在一个主机上运行多个网络应用程序。 端口?#27573;?---65535,16位整数

5)端口分类

公认端口 0—1023 ?#28909;?0端口分配给WWW,21端口分配给FTP,22端口分配给SSH,23端口分配给telnet,25端口分配给smtp

注册端口 1024—49151 分配给用户进程或应用程序

动态/私有端口 49152--65535

6)理解IP和端口的关系

IP地址好比每个人的地址(门牌号),端口好比是房间号。必须同时指定IP地址和端口号才能够正确的发送数据

IP地址好比为电话号码,而端口号就好比为分机号。

275.介绍OSI七层模型和TCP/IP模型

OSI(Open System Interconnection),开放式系统互联参考模型 。是一个逻辑上的定义,一个规范,它把网络协议从逻辑上分为了7层。每一层都有相关、相对应的物理设备,?#28909;?#24120;规的路由器是三层?#25442;?#35774;备,常规的?#25442;换?#26159;二层?#25442;?#35774;备。OSI七层模型是一种框架性的设?#21697;?#27861;,建立七层模型的主要目的是为解决异种网络互连时所遇到的兼容性问题,其最主要的功能就是帮助不同类型的主机实现数据传输。它的最大优点是将服务、接口和协议这三个概念明确地区分开来,通过七个层次化的结构模型使不同的系统不同的网络之间实现可靠的通讯。

TCP/IP协议是Internet最基本的协议、Internet国际互联网络的基础,主要由网络层的IP协议和传输层的TCP协议组成。TCP/IP 定义了电子设备如何连入因特网,以及数据如何在它们之间传输的标准。协议采用了4层的层级结构,每一层都呼叫它的下一层所提供的协议来完成自己的需求。

ISO制定的OSI参考模型的过于庞大、复杂招致了许多批评。伴随着互联网的流?#26657;?#20854;本身所采用的TCP/IP协议?#25442;?#24471;了更为广泛的应用和认可。在TCP/IP参考模型?#26657;?#21435;掉了OSI参考模型中的会?#23433;?#21644;表示层(这?#35762;?#30340;功能被合并?#25509;?#29992;层实?#37073;?#21516;时将OSI参考模型中的数据链路层和物理层合并为主机到网络层。

276.TCP协议和UDP协议的比较

TCP和UDP是TCP/IP协议栈?#20889;?#36755;层的两个协议,它们使用IP路由功能把数据包发送到目的地,从而为应用程序及应用层协议(包括:HTTP、SMTP、SNMP、FTP和Telnet)提供网络服务。

TCP的server和client之间通信就好比两个人打电话,需要互相知道对方的电话号码,然后开始对话。所以在两者的连接过程中间需要指定端口和地址。

UDP的server和client之间的通信就像两个人互相发信。我只需要知道对方的地址,然后就发信过去。对方是否收到我不知道,也不需要专门对口令?#39057;?#26469;建立连接。具体区别如下:

1)TCP是面向连接的传输。UDP是无连接的传输

2)TCP有流量控制、?#31561;?#25511;制,检验数据数据按序到达,而UDP则相?#30784;?/p>

3)TCP的路由选择?#29615;?#29983;在建立连接的时候,而UDP的每个报文都要进行路由选择

4)TCP是可靠性传输,他?#30446;?#38752;性是?#27801;?#26102;重发机制实现的,而UDP则是不可靠传输

5)UDP因为少了很多控制信息,所以传输速?#32570;萒CP速度快

6)TCP适合用于传输大量数据,UDP适合用于传输小量数据

277.什么是Socket编程

Socket编程的定义如下:

所谓socket通常也称作"套接字",用于描述IP地址和端口,是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。

我们开发的网络应用程序位于应用层,TCP和UDP属于传输层协议,在应用层如何使?#20040;?#36755;层的服务呢?在应用层和传输层之间,则是使用套接字来进行分离。

套接字就像是传输层为应用层开的一个小口,应用程序通过这个小口向远程发送数据,或者接收远程发来的数据;而这个小口以内,也就是数据进入这个口之后,或者数据从这个口出来之前,是不知道也不需要知道的,也?#25442;?#20851;心它如何传输,这属于网络其它层次的工作。

Socket实际是传输层供给应用层的编程接口。传输层则在网络层的基础上提供进程到进程问的逻辑通道,而应用层的进程则利?#20040;?#36755;层向另一台主机的某一进程通信。Socket就是应用层与传输层之间的桥梁

使用Socket编程可以开发客户机和服务器应用程序,可以在本地网络上进?#22411;?#20449;,?#37096;?#36890;过Internet在全球?#27573;?#20869;通信。

生活案例1如果你想写封邮件发给远方的朋友,如何写信、将信打包,属于应用层。信怎么写,怎?#21019;?#21253;完全由我们做主;而当我们将信投入?#37322;?#26102;,?#37322;?#30340;那个口就是套接?#37073;?#22312;进入套接字之后,就是传输层、网络层等(?#31034;幀?#20844;路?#36824;?#25110;者航线等)其它层次的工作了。我们从来?#25442;?#21435;关心信是如何从西安发往北京的,我们只知道写好了投入?#37322;?#23601;OK了。

生活案例2:可以把Socket比作是一个港口码头,应用程序只要将数据交给Socket,就算完成了数据的发送,具体细节由Socket来完成,细节不必了解。同理,对于接收方,应用程序也要创建一个码头,等待数据的到达,并获取数据。

278.简述基于TCP和UDP的Socket编程的主要步骤

Java分别为TCP和UDP 两种通信协议提供了相应的Socket编程类,这些类存放在java.net包?#23567;?#19982;TCP对应的是服务器的ServerSocket和客户端的Socket,与UDP对应的是DatagramSocket。

基于TCP创建的套接字可?#36234;?#20570;流套接?#37073;?#26381;务器端相当于一个监听器,用来监听端口。?服务器与?#22836;?#31471;之间的通讯都是输入输出流来实现的。基于UDP的套接字就是数据报套接?#37073;?? 两个都要先构造好相应的数据包。

基于TCP协议的Socket编程的主要步骤

服务器端(server):

1. 构建一个ServerSocket实例,指定本地的端口。这个socket就是用来监听指定端口的连接请求的。

2. 重复如?#24405;?#20010;步骤:

a. 调用socket的accept()方法来获得下面客户端的连接请求。通过accept()方法返回的socket实例,建立了一个和客户端的新连接。

b. 通过这个返回的socket实例获取InputStream和OutputStream,可以通过这两个stream来分别读和写数据。

c. 结束的时候调用socket实例的close()方法关闭socket连接。

客户端(client):

1.构建Socket实例,通过指定的远程服务器地址和端口来建立连接。

2.通过Socket实例包含的InputStream和OutputStream来进行数据的?#21015;础?/p>

3.操作结束后调用socket实例的close方法,关闭。

UDP

服务器端(server):

1. 构造DatagramSocket实例,指定本地端口。

2. 通过DatagramSocket实例的receive方法接收DatagramPacket.DatagramPacket中间就包含了通信的内容。

3. 通过DatagramSocket的send和receive方法来收和发DatagramPacket.

客户端(client):

1. 构造DatagramSocket实例。

2. 通过DatagramSocket实例的send和receive方法发送DatagramPacket报文。

3. 结束后,调用DatagramSocket的close方法关闭。

异常处理:

279.下列哪种异常是检查型异常,需要在编写程序时声明()
A. NullPointerException
B. ClassCastException
C. FileNotFoundException
D. IndexOutOfBoundsException
答案:C
分析:NullPointerException空指针异常
ClassCastException类型转换异常
IndexOutOfBoundsException索引超出边界的异常
以上这些异常都是程序在运行时发生的异常,所以不需要在编写程序时声明
280.Java出现OutOf MemoryError(OOM 错误)的原因有哪些?出现OOM错误后,怎么解决?

答:OutOf MemoryError这种错误可以细分为多种不同的错误,每种错误都有自身的原因和解决办法,如下所示:

java.lang.OutOfMemoryError: Java heap space

错误原因:此OOM是由于JVM中heap的最大值不满足需要。

解决方法:1) 调高heap的最大值,即-Xmx的值调大。2) 如果你的程序存在内存泄漏,一味的增加heap空间也只是推迟?#20040;?#35823;出现的时间而已,所以要检查程序是否存在内存泄漏。

java.lang.OutOfMemoryError: GC overhead limit exceeded

错误原因:此OOM是由于JVM在GC时,对象过多,导致内存溢出,建议调整GC的策略,在一定比例下开始GC而不要使用默认的策略,或者将新代和老代设置合适的大小,需要进行微调存活率。

解决方法:改变GC策略,在老代80%?#26412;?#26159;开始GC,并且将-XX:SurvivorRatio(-XX:SurvivorRatio=8)和-XX:NewRatio(-XX:NewRatio=4)设置的更合理。

java.lang.OutOfMemoryError: Java perm space

错误原因:此OOM是由于JVM中perm的最大值不满足需要。

解决方法:调高heap的最大值,即-XX:MaxPermSize的值调大。

另外,注意一点,Perm一般是在JVM启动时加载类进来,如果是JVM运?#34218;?#38271;一段时间而不是刚启动后溢出的话,很有可能是由于运行时有类被动态加载进来,此时建议用CMS策略中的类卸载配置。如:-XX:+UseConcMarkSweepGC -XX:+CMSClassUnloadingEnabled。

java.lang.OutOfMemoryError: unable to create new native thread

错误原因:当JVM向OS请求创建一个新线程时,而OS却由于内存不足无法创建新的native线程。

解决方法:如果JVM内存调的过大或者可利用率小于20%,可?#36234;?#35758;将heap及perm的最大值下调,并将线程栈调小,即-Xss调小,如:-Xss128k。

java.lang.OutOfMemoryError: Requested array size exceeds VM limit

错误原因:此类信息表明应用程序(或者被应用程序调用的APIs)试图分配一个大于堆大小的数组。例如,如果应用程序new一个数组对象,大小为512M,但是最大堆大小为256M,因此OutOfMemoryError会抛出,因为数组的大小超过虚拟机的限制。

解决方法:1) 首先检查heap的-Xmx是不是设置的过小。2) 如果heap的-Xmx已经足够大,那么请检查应用程序是不是存在bug,例如:应用程序可能在计算数组的大小时,存在算法错误,导致数组的size很大,从而导致巨大的数组被分配。

java.lang.OutOfMemoryError: request < size> bytes for < reason>. Out of swap space

错误原因?#21495;?#20986;这类错误,是由于从native堆中分配内存失败,并且堆内存可能接近耗尽。这类错误可能跟应用程序没有关系,例如下面两种原因?#19981;?#23548;致错误的发生:1) 操作系统配置了较小的?#25442;?#21306;。2)系统的另外一个进程正在消耗所有的内存。

解决办法:1) 检查os的swap是不是没有设置或者设置的过小。2) 检查是否有其他进程在消耗大量的内存,从而导致当前的JVM内存不够分配。

注意?#26680;?#28982;有时< reason>部分显示导致OOM的原因,但大多数情况下,< reason>显示的是提示分配失败的源模块的名称,所以有必要查看日志文件,如crash时的hs文件。

281.列举常见的运行时异常

答:ClassCastException(类转换异常)

?#28909;?Object obj=new Object(); String s=(String)obj;?

IndexOutOfBoundsException(下标越界异常)

NullPointerException(空指针异常)

ArrayStoreException(数据存储异常,操作数组时类型不一致)

BufferOverflowException(IO操作时出现的缓冲区上溢异常)

InputMismatchException(输入类型不匹配异常)

ArithmeticException(算术异常)

注意:运行时异常都是RuntimeException子类异常。

282.下面关于 Java.lang.Exception类的说法正确的是()
A. 继承自 Throwable
B. 不支持Serializable
C. 继承自 AbstractSet
D. 继承自FitelnputStream
答案:A
分析:Throwable是Exception和Error的父类,Exception虽然没有实现Serializable接口,但是其父类Throwable已经实现了该接口,因此Exception也支持Serializable。
283.Unsupported major.minor version 52是什么异常,怎么造成的,如何解决?

答:问题的根本原因是工程中某个jar包的版本(jar包编译时的所用的jdk版本)高于工程build path中jdk的版本,这个是不兼容的! 编程中遇到此异常Unsupported major.minor version 52.0(根据版本号,这里可以为其他数值,52是1.8jdk jar包与 1.8以下低版本jdk不匹配),在将build path中jdk的版本调整与jar包匹配后,解决异常。

284.try{}里有一个return语句,那么紧跟在这个try后的finally{}里的code会?#25442;?#34987;执?#26657;?#20160;么时候被执?#26657;?#22312;return前?#25925;?#21518;?

答:会执?#26657;?#22312;方法返回调用者前执?#23567;ava允许在finally中改变返回值的做法是不好的,因为如果存在finally代码块,try中的return语句?#25442;?#31435;马返回调用者,而是记录下返回值待finally代码块执?#22411;?#27605;之后再向调用者返回其值,然后如果在finally中修改了返回值,这会对程序造成很大的困扰,C#中就从语法上规定不能做这样的事。?

(也许你的答案是在return之前,但往更细地说,?#19994;?#31572;案是在return中间执?#26657;?#35831;看下面程序代码的运?#34218;?#26524;:

public classTest {

    /**
     * @paramargs add by zxx ,Dec 9, 2008
     */
    public static voidmain(String[] args) {
       // TODO Auto-generated method stub
       System.out.println(newTest().test());;
    }

    static int test()
    {
       int x = 1;
       try
       {
           returnx;
       }
       finally
       {
           ++x;
       }
    }

}

执?#34218;?#26524;

运?#34218;?#26524;是1,为什么呢?主函数调用子函数并得到结果的过程,好比主函数准备一个?#23637;?#23376;,当子函数要返回结果时,先把结果放在罐子里,然后再将程序逻辑返回到主函数。所谓返回,就是子函数说,我不运行了,你主函数继续运行吧,这没什么结果可言,结果是在说这话之前放进罐子里的。

285.Java 语言如何进行异常处理,关键?#37073;簍hrows、throw、try、catch、finally分别如何使用?

答:Java 通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供了良好的接口。在Java ?#26657;?#27599;个异常都是一个对象,它是Throwable 类或其子类的实例。当一个方法出现异常后便抛出一个异常对象,该对象中包含有异常信息,调用这个对象的方法可以捕获到这个异常并进行处理。Java 的异常处理是通过5 个关键词来实现的:try、catch、throw、throws和finally。一般情况?#29575;?#29992;try来执行一段程序,如果出现异常,系统会抛出(throw)一个异常,这时候你可以通过它的类型来捕捉(catch)它,或最后(finally)由缺省处理器?#21019;?#29702;;try用来指定一块预防所有“异常”的程序;catch 子句紧跟在try块后面,用来指定你想要捕捉的“异常”的类型;throw 语句用来明确地抛出一个“异常?#20445;籺hrows用来标明一个成员函数可能抛出的各种“异常?#20445;籪inally 为确保一段代码不管发生什?#30784;?#24322;常”都被执行一段代码;可以在一个成员函数调用的外面写一个try语句,在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try 语句,“异常”?#30446;?#26550;就放到栈上面,直到所有的try语句都完成。如果下一级的try语句没有对某种“异常”进行处理,栈就会展开,直?#25509;?#21040;有处理这种“异常”的try 语句。?

286.运行时异常与受检异常有?#25105;?#21516;?

答:异常表示程序运行过程中可能出现的非正常状态,运行时异常表示虚拟机的通常操作中可能遇到的异常,是一种常见运?#20889;?#35823;,只要程序设?#39057;?#27809;有问题通常就?#25442;?#21457;生。受检异常跟程序运行的上下文环境有关,即使程序设计无误,仍然可能因使用的问题而引发。Java编译器要求方法必须声明抛出可能发生的受检异常,但是并不要求必须声明抛出未被捕获的运行时异常。异常和继承一样,是面向对象程序设计中经常被滥用的东西,神作《Effective Java?#20998;?#23545;异常的使用给出了以下指导原则:

不要将异常处理用于正常?#30446;?#21046;流(设计良好的API不应?#20204;?#36843;它的调用者为了正常?#30446;?#21046;流而使用异常)

对可以?#25351;?#30340;情况使用受检异常,?#21592;?#31243;错误使用运行时异常

避免不必要的使用受检异常(可以通过一些状态检测手段来避免异常发生)

优先使用标准的异常

每个方法抛出的异常都要有文档

保持异常的原?#26377;?/p>

不要在catch中忽略掉捕获到的异常?

(异常表示程序运行过程中可能出现的非正常状态,运行时异常表示虚拟机的通常操作中可能遇到的异常,是一种常见运?#20889;?#35823;。java编译器要求方法必须声明抛出可能发生的非运行时异常,但是并不要求必须声明抛出未被捕获的运行时异常。)

287.类ExampleA 继承Exception,类ExampleB 继承ExampleA

有如下代码片?#24076;?/p>

try{
throw new ExampleB("b")
}catch(ExampleA e){
System.out.println("ExampleA");
}catch(Exception e){
System.out.println("Exception");
}
 }

请问执?#20889;?#27573;代码的输出是什么?

答:输出:ExampleA。(根据里氏代换原则[能使用父类型的地方一定能使用子类型],抓取ExampleA类型异常的catch块能够抓住try块中抛出的ExampleB类型的异常)

补充: ?#21364;?#39064;略复杂的一道面试题如下所示(此题的出处是《Java编程思想》),说出你的答案吧!

package com.bjsxt;
class Annoyance extends Exception {}
class Sneeze extends Annoyance {}
 class Human {
  public static void main(String[] args)
        throws Exception {
        try {
            try {
                throw new Sneeze();
            }
            catch ( Annoyance a ) {
                System.out.println("Caught Annoyance");
                throw a;
            }
        }
        catch ( Sneeze s ) {
            System.out.println("Caught Sneeze");
            return ;
        }
        finally {
            System.out.println("Hello World!");
        }
    }
}

输出为:

Caught Annoyance

Caught Sneeze

Hello World!

288.Error和Exception的区别

Error类,表示仅靠程序本身无法?#25351;?#30340;?#29616;?#38169;误,?#28909;縊的?#23384;溢出、动态链接异常、虚拟机错误。应用程序不应该抛出这种类型的对象。假如出现这种错误,除了尽力使程序安全退出外,在其他方面是无能为力的。所以在进行程序设计时,应该更关注Exception类。

Exception类,由Java应用程序抛出和处理的非?#29616;?#38169;误,?#28909;?#25152;需文件没有?#19994;健?#38646;作除数,数组下标越界?#21462;?#23427;的各种不同子类分别对应不同类型异常。可分为两类:Checked异常和Runtime异常

289.Java异常处理try-catch-finally的执行过程

try-catch-finally程序块的执行流程以及执?#34218;?#26524;比较复?#21360;?/p>

基本执行过程如下:

1)程序首先执行可能发生异常的try语句块。

2)如果try语句没有出现异常则执?#22411;?#21518;跳至finally语句块执?#26657;?/p>

3)如果try语句出现异常,则中断执行并根据发生的异常类型跳?#26009;?#24212;的catch语句块执行处理。

4)catch语句块可以有多个,分别捕获不同类型的异常。

5)catch语句块执?#22411;?#21518;程序会继续执行finally语句块。

finally语句是可选的,如果有的话,则不管是否发生异常,finally语句都会被执?#23567;?#38656;要注意的是即使try和catch块?#20889;?#22312;return语句,finally语句?#19981;?#25191;?#26657;?#26159;在执?#22411;阥inally语句后再通过return退出。

290.异常处理中throws和throw的区别

1)作用不同:

throw用于程序员自行产生并抛出异常;

throws用于声明在该方法内抛出了异常

2) 使用的位置不同:

throw位于方法体内部,可以作为单独语句使用;

throws必须跟在方法参数列表的后面,不能单独使用。

3)内容不同:

throw抛出一个异常对象,且只能是一个;

throws后面跟异常类,而且可以有多个。

Web方面相关:
291.WEB应用中如果有.class和.jar类型的文件一般分别应该放在什么位置?

答:.class文件放在WEB-INF/classes文件下,.jar文件放在WEB-INF/lib文件夹下

292.元素中有一个输入框(< input type='text' name=”username”id=”username”value=””/>,请用JavaScript语言写一?#20889;?#30721;,取得这个输入框中的值。

答:document.getElementById(“username”).value;

293.简单描述一下Servlet与JSP的的相同点和区别点。

区别:

JSP是在HTML代码里写JAVA代码,框架是HTML;而Servlet是在JAVA代码中写HTML代码,本身是个JAVA类。

JSP使人们把显示和逻辑分隔成为可能,这意味着两者?#30446;?#21457;可并?#34218;校?#32780;Servlet并没有把两者分开。

Servlet独立地处理静态表示逻辑与动态业务逻辑.这样,任何文件的变动都需要对此服务程序重新编译;JSP允许用特殊标签直接嵌入到HTML页面, HTML内容与JAVA内容?#37096;?#25918;在单独文件中,HTML内容的任何变动会自动编译装入到服务程序.

Servlet需要在web.xml中配置,而JSP无需配置。

目前JSP主要用在视图层,负责显示,而Servlet主要用在控制层,负责调度

联系:

都是Sun公?#23601;?#20986;的动态网页技术。

先有Servlet,针对Servlet缺点推出JSP。JSP是Servlet的一种特殊?#38382;剑?#27599;个JSP页面就是一个Servlet实例——JSP页面?#19978;?#32479;翻译成Servlet,Servlet再负责响应用户请求。

294.请简单描述?#24405;?#20010;您熟悉JavaScript库,它们有哪些作用和特点?

JavaScript 高级程序设计(特别是对浏览器差异的复杂处理),通常很困难也很耗时。为了应对这些调整,许多的 JavaScript库应运而生。这些 JavaScript 库常被称为 JavaScript 框架。

jQuery:

Ext JS - 可定?#39057;?widget,用于构建富因特网应用程序(rich Internet applications)。

Prototype

MooTools。

YUI - Yahoo! User Interface Framework,涵盖大量函数的大型库,从简单的 JavaScript 功能到完整的 internet widget。

295.简单描述HTML,CSS,Javascript在Web开发中分别起什么作用?

1、什么是HTML(超文本标记语言 Hyper Text Markup Language),HTML 是用来描述网页的一种语言。

2、CSS(层叠样式表 Cascading Style Sheets),样式定义如何显示 HTML 元素,语法为:selector {property:value} (选择符 {属性:值})

3、JavaScript是一种脚本语言,其?#21019;?#30721;在发往客户端运行之?#23433;?#38656;经过编译,而是将文本格式的字符代码发送给浏览器?#23556;?#35272;器解释运行

对于一个网页,HTML定义网页的结构,CSS描述网页的样子,JavaScript设置一个很经典的例子是说HTML就像 一个人的骨骼、器官,而CSS就是人的皮肤,有了这两样也就构成了一个?#21442;?#20154;了,加上javascript这个?#21442;?#20154;就可以对外界刺激做出反应,可以思 考、运动、可以给自己整容化?#20445;?#25913;变CSS)等等,成为一个活生生的人。

如果说HTML是肉身、CSS就是皮相、Javascript就是灵魂。没有Javascript,HTML+CSS是?#21442;?#20154;,没有Javascript、CSS是个毁容的?#21442;?#20154;。

如果说HTML是建筑师,CSS就是干装修的,Javascript是魔术师。

296.当DOM加载完成后要执行的函数,下面哪个是正确的()
A. JQuery(expression, [context])
B. JQuery(html, [ownerDocument])
C. JQuery(callback)
答案:C
297.举例说明JAVA中如何解析xml,不同方式有和优缺点?

答:1. DOM(Document Object Model)

DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构,然后才能做任何工作。由于它是基于信息层次的,因而DOM被认为是基于树或基于对象的。

【优点】

①允许应用程序对数据和结构做出更改。

②访问是双向的,可以在任何时候在树中上下导航,获取和操作?#25105;?#37096;分的数据。

【缺点】

①通常需要加载整个XML文档来构造层次结构,消耗?#35797;创蟆?

2. SAX(Simple API for XML)

SAX处理的优点非常类似于流媒体的优点。分析能够立即开始,而不是等待所有的数据被处理。而且,由于应用程序只是在读取数据时检查数据,因此不需要将数据存储在内存?#23567;?#36825;对于大型文档来说是个巨大的优点。?#29575;?#19978;,应用程序甚至不必解析整个文档;它可以在某个条件得到满足时停止解析。一般来说,SAX还比它的替代者DOM快许多。

选择DOM?#25925;?#36873;择SAX? 对于需要自己编?#21019;?#30721;?#21019;?#29702;XML文档?#30446;?#21457;人员来说, 选择DOM?#25925;荢AX解析模型是一个非常重要的设计决策。 DOM采用建立树形结构的方式访问XML文档,而SAX采用的是?#24405;?#27169;型。

DOM解析器把XML文档转化为一个包含其内容的树,并可以对树进行遍历。用DOM解析模型的优点是编程容易,开发人员只需要调用建树的指令,然后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用DOM解析器的时候需要处理整个XML文档,所以对性能和内存的要求比较高,尤其是遇到很大的XML文件的时候。由于它的遍历能力,DOM解析器常用于XML文档需要频繁的改变的服务?#23567;?/p>

SAX解析器采用了基于?#24405;?#30340;模型,它在解析XML文档的时候可以触发一系列的?#24405;?#24403;发现给定的tag的时候,它可以激活一个回调方法,告诉该方法制定的标签已经?#19994;健AX对内存的要求通常会比?#31995;停?#22240;为它让开发人员自己来决定所要处理的tag.特别是当开发人员只需要处理文档中所包含的部分数据时,SAX这种扩展能力得到了更好的体现。但用SAX解析器的时候编码工作会比较困难,而且很难同时访?#37322;?#19968;个文档中的多处不同数据。

【优势】

①不需要等待所有数据都被处理,分析就能立即开始。

②只在读取数据时检查数据,不需要保存在内存?#23567;?/p>

③可以在某个条件得到满足时停止解析,不必解析整个文档。

④效率和性能较高,能解析大于系统内存的文档。

【缺点】

①需要应用程序自己负责TAG的处理逻辑(例如维护父/子关系等),文档越复杂程序就越复?#21360;?/p>

②单向导航,无法定位文档层次,很难同时访?#37322;?#19968;文档的不同部分数据,不支持XPath。

3. JDOM(Java-based Document Object Model)

JDOM的目的是成为Java特定文?#30340;?#22411;,它简化与XML的交互并且比使用DOM实现更快。由于是第一个Java特定模型,JDOM一直得到大力推广和促进。正在考虑通过“Java规范请求JSR-102”将它最终用作“Java标准扩展”。从2000年初就已经开始了JDOM开发。

JDOM与DOM主要有两方面不同。首先,JDOM仅使用具体类而不使用接口。这在?#25215;?#26041;面简化了API,但是也限制了灵活性。第二,API大量使用了Collections类,简化了?#20999;?#24050;经熟悉这些类的Java开发者的使用。

JDOM文档声明其目的是“使用20%(或更少)的精力解决80%(或更多)Java/XML问题?#20445;?#26681;据学习曲线假定为20%)。JDOM对于大多数Java/XML应用程序来说当然是有用的,并且大多数开发者发现API比DOM容易理解得多。JDOM还包括对程序行为的相当广泛检查以?#20048;?#29992;户做任何在XML中无意义的事。然而,它仍需要您充分理解XML?#21592;?#20570;一些超出基本的工作(或者甚至理解?#25215;?#24773;况下的错误)。这也许是比学习DOM或JDOM接口都更有意义的工作。

JDOM自身不包含解析器。它通常使用SAX2解析器来解析和验证输入XML文档(尽管它还可?#36234;?#20197;前构造的DOM表示作为输入)。它包含一些转换器?#36234;獼DOM表示输出成SAX2?#24405;?#27969;、DOM模型或XML文本文档。JDOM是在Apache许可证变体下发布?#30446;?#25918;源码。

【优点】

①使用具体类而不是接口,简化了DOM的API。

②大量使用了Java集合类,方便了Java开发人员。

【缺点】

①没?#34218;?#22909;的灵活性。

②性能较差。

4. DOM4J(Document Object Model for Java)

虽然DOM4J代表了完全独立?#30446;?#21457;结果,但最初,它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能,包括集成的XPath支持、XML Schema支持以及用于大文档或流化文档的基于?#24405;?#30340;处理。它还提供了构建文档表示的选项,它通过DOM4J API和标准DOM接口具有并行访?#20351;?#33021;。从2000下半年开始,它就一直处于开发之?#23567;?/p>

为支持所有这些功能,DOM4J使用接口和抽象基本类方法。DOM4J大量使用了API中的Collections类,但是在许多情况下,它还提供一些替代方法以允许更好的性能或更直接的编码方法。直接?#20040;?#26159;,虽然DOM4J付出了更复杂的API的代价,但是它提供了比JDOM大得多的灵活性。

在添加灵活性、XPath集成和对大文档处理的目标时,DOM4J的目标与JDOM是一样的:针对Java开发者的易用性和直观操作。它还致力于成为比JDOM更完整的解决方案,实现在本质上处理所有Java/XML问题的目标。在完成该目标时,它比JDOM更少强调?#20048;?#19981;正确的应用程序行为。

DOM4J是一个非常非常优秀的Java XML API,具有性能优异、功能强大和极端易用使用的特点,同时它也是一个开放?#21019;?#30721;的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML,特别值得一提的是连Sun的JAXM也在用DOM4J.

【优点】

①大量使用了Java集合类,方便Java开发人员,同时提供一些提高性能的替代方法。

②支持XPath。

③有很好的性能。

【缺点】

①大量使用了接口,API较为复?#21360;?/p>

二、比较

1. DOM4J性能最好,连Sun的JAXM也在用DOM4J。目前许多开源项目中大量采用DOM4J,例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性,那就采用DOM4J.

2. JDOM和DOM在性能测试?#21271;?#29616;不佳,在测试10M文档时内存溢出,但可移植。在小文档情况下还值得考虑使用DOM和JDOM.虽然JDOM?#30446;?#21457;者已经说明他们期望在正式发行版前专注性能问题,但是?#26377;?#33021;观点来看,它确实没有值得推荐之处。另外,DOM仍是一个非常好的选择。DOM实现广泛应用于多种编程语言。它?#25925;切?#22810;其它与XML相关的标准的基础,因为它正式获得W3C推荐(与基于非标准的Java模型相对),所以在?#25215;?#31867;型的项目中可能也需要它(如在JavaScript中使用DOM)。

3. SAX表现较好,这要?#35272;?#20110;它特定的解析方式-?#24405;?#39537;动。一个SAX检测即将到来的XML流,但并没有载入到内存(当然当XML流被读入时,会有部分文档暂时隐藏在内存?#26657;?/p>

?#19994;目?#27861;:如果XML文?#21040;?#22823;且不考?#19988;?#26893;性问题建议采用DOM4J;如果XML文?#21040;?#23567;则建议采用JDOM;如果需要及时处理而不需要保存数据则考虑SAX。但无论如何,?#25925;?#37027;句话:适合自己的才是最好的,如果时间允许,建议大家讲这四种方法都尝试一遍然后选择一种适合自己的即可。

298.char型变量中能不能存储一个中文汉?#37073;?/div>

答:1.java采用unicode编码,2个字节(16位)来表示一个字符, 无论是汉字?#25925;?#25968;?#37073;?#23383;母,或其他语言都可以存储。

2.char 在java中是2个字节,所以可以存储中文

299.一个类可以实现多个接口,但只能继承一个抽象类。

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

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

public abstract classBaseServlet extends HttpServlet{
        public final void service(HttpServletRequest request,HttpServletResponse response) throws IOExcetion,ServletException       {
               记录访问日志
               进行权限判断
if(具有权限){
       try{
              doService(request,response);
}
       catch(Excetpion e)  {
                     记录异常信息
       }
}
        }
        protected abstract void doService(HttpServletRequest request,HttpServletResponse response) throws IOExcetion,ServletException;
//注意访问权限定义成protected,显得既专业,又严谨,因为它是专门给子类用的
}

public class MyServlet1 extendsBaseServlet
{
protected voiddoService(HttpServletRequest request, HttpServletResponse response) throwsIOExcetion,ServletException
        {
               本Servlet只处理的具体业务逻辑代码
        }

}

父类方法中间的某段代码不确定,留给子类干,就用模板方法设计模?#20581;?/p>

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

300.比较一下Java 和JavaSciprt

答:JavaScript 与Java是两个公司开发的不同的两个产品。Java 是原Sun 公?#23601;?#20986;的面向对象的程序设计语言,特别适合于互联网应用程序开发;而JavaScript是Netscape公司的产品,为了扩展Netscape浏览器的功能而开发的一种可以嵌入Web页面?#24615;?#34892;的基于对象和?#24405;?#39537;动的解释性语言,它的前身是LiveScript;而Java 的前身是Oak语言。

下面对两种语言间的异同作如下比较:

1)基于对象和面向对象:Java是一种真正的面向对象的语言,?#35789;故?#24320;发简单的程序,必须设计对象;JavaScript是种脚本语言,它可以用来制作与网络无关的,与用户交互作用的复杂软件。它是一种基于对象(Object-Based)和?#24405;?#39537;动(Event-Driven)的编程语言。因而它本身提供了非常丰富的内部对象供设计人员使用;

2)解释和编译:Java 的?#21019;?#30721;在执行之前,必须经过编译;JavaScript 是一种解释?#21592;?#31243;语言,其?#21019;?#30721;不需经过编译,?#23556;?#35272;器解释执?#26657;?/p>

3)强类型变量和类型弱变量:Java采?#20204;?#31867;型变量检查,即所有变量在编译之前必须作声明;JavaScript中变?#21487;?#26126;,采用其弱类型。即变量在使?#20204;安?#38656;作声明,而是解释器在运行时检查其数据类型;

4)代码格?#35762;?#19968;样。

补充:上面列出的四点是原来所谓的标准答案中给出的。其实Java和JavaScript最重要的区别是一个是静态语言,一个是动态语言。目前的编程语言的发展趋势是函数式语言和动态语言。在Java中类(class)是一等公民,而JavaScript中函数(function)是一等公民。对于这种问题,在面试时?#25925;?#29992;自己的语言回答会更加靠?#20303;?

301.什么时候用assert?

答:assertion(断言)在软件开发中是一种常用的调试方式,很多开发语言中都支持这种机制。一般来说,assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能,在软件发布后, assertion检查通常是关闭的。在实?#31181;校?#26029;言是一个包含布尔表达式的语句,在执行这个语句时假定该表达式为true;如果表达式计算为false,那么系统会报告一个AssertionError。

断言用于调试目的:

assert(a > 0); // throws an AssertionError if a <= 0

断言可以有两种?#38382;剑?/p>

assert Expression1;

assert Expression1 : Expression2 ;

Expression1 应该总是产生一个布尔值。

Expression2 可以是得出一个值的?#25105;?#34920;达式;这个值用于生?#19978;?#31034;更多调试信息的字符串消息。

断言在默认情况?#29575;?#31105;用的,要在编译时启用断言,需使用source 1.4 标记:

javac -source 1.4 Test.java

要在运行时启用断言,可使用-enableassertions 或者-ea 标记。

要在运行时选择禁用断言,可使用-da 或者-disableassertions 标记。

要在系统类中启用断言,可使用-esa 或者-dsa 标记。还可以在包的基础上启用或者禁用断言。可以在预计正常情况下?#25442;?#21040;达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过,断言不应该用于验证传递给公有方法的参数,因为不管是否启用了断言,公有方法都必须检查其参数。不过,既可以在公有方法?#26657;部?#20197;在非公有方法中利用断言测试后置条件。另外,断言不应该以任何方式改变程序的状态。?

302.UML是什么?UML中有哪些图?

答:UML是统一建模语言(Unified Modeling Language)的缩写,它发表于1997年,综合了当时已经存在的面向对象的建模语言、方法和过程,是一个支持模型化和软件系统开发的图形化语言,为软件开发的所?#34218;?#27573;提供模型化和可视化支持。使用UML可以帮助沟通与交流,辅助应用设计和文档的生成,还能够阐释系统的结构和行为。UML定义了多种图形化的符号来描述软件系统部分或全部的静态结构和动态结构,包括:用例图(use case diagram)、类图(class diagram)、时序图(sequence diagram)、协作图(collaboration diagram)、状态图(statechart diagram)、活动图(activity diagram)、构件图(component diagram)、部署图(deployment diagram)?#21462;?#22312;这些图形化符号?#26657;?#26377;三种图最为重要,分别是:用例图(用来捕获需求,描述系统的功能,通过该图可以迅速的了解系统的功能模块及其关系)、类图(描述类以及类与类之间的关系,通过该图可以快速了解系?#24120;?#26102;序图(描述执行特定任务时对象之间的交互关系以及执行顺序,通过该图可以了解对象能接收的消息也就是说对象能够向外界提供的服务)。

用例图:

303.XML 文档定义有几种?#38382;剑?#23427;们之间有何本质区别?解析XML 文档有哪几种方式?

答: XML文档定义分为DTD和Schema两种?#38382;剑?#20854;本质区别在于Schema本身也是一个XML文件,可?#21592;籜ML解析器解析。对XML的解析主要有DOM(文档对象模型)、SAX、StAX(JDK 1.6中引入的新的解析XML的方式,Streaming API for XML) 等,其中DOM处理大型文件时其性能下降的非常厉害,这个问题是由DOM 的树结构所造成的,这种结构占用的内存较多,而且DOM 必须在解析文件之前把整个文档装入内存,适合对XML 的随机访问(典型的用空间换取时间的策略);SAX是?#24405;?#39537;动型的XML解析方式,它顺序读取XML文件,不需要一次全部装载整个文件。当遇到像文件开头,文档结束,或者标签开头与标签结束时,它会触发一个?#24405;?#29992;户通过在其回调?#24405;?#20013;写入处理代码?#21019;?#29702;XML文件,适合对XML 的顺序访问;如其名称所暗示的那样,StAX把重点放在流上。实际上,StAX与其他方法的区别就在于应用程序能够把XML作为一个?#24405;?#27969;?#21019;?#29702;。将XML作为一组?#24405;创?#29702;的想法并不新?#20445;ㄊ率?#19978; SAX 已经提出来了),但不同之处在于StAX允许应用程序代码把这些?#24405;?#36880;个拉出来,而不用提供在解析器方便时从解析器?#34218;?#25910;?#24405;?#30340;处理程序。?

304.你在项目中哪些地方用到了XML?

答: XML的主要作用有两个方面:数据?#25442;唬?#26366;经被称为业界数据?#25442;?#30340;?#29575;?#26631;准,现在此项功能在很多时候都被JSON取代)和信息配置。在做数据?#25442;?#26102;,XML将数据用标签组装成起来,然后压缩打包?#29992;?#21518;通过网络传送给接收者,接?#25112;?#23494;与解压缩后再从XML文件中还原相关信息进行处理。目前很多软件都使用XML?#21019;?#20648;配置信息,很多项目中我们通常?#19981;?#23558;作为配置的硬代码(hard code)写在XML文件?#26657;琂ava的很多框架也是这么做的。?

305.用JavaScript实现用正则表达式验证,某个字符串是合法的6位数字的?#26102;?#30340;函数
Function testE(ss){
  var reg=/^[1-9][0-9]{5}$/;
  if(req.test(ss)){
    alert(“?#26102;郞K”)
}else{
  alert(“?#26102;?#26684;?#35762;?#27491;确”);
}
}
306.请使用JQuery将页面上的所有元素边框设置为2pix宽的虚线?

$(“*”).css(“border”,”2px dashed”)

307.如何设定JQuery异步调用?#25925;?#21516;步调用?

答案:调用jQuery中的ajax函数,设置其async属性来表明是异步?#25925;?#21516;步,如下:

$.ajax({
async:true//表示异步,false表?#23601;?#27493;
})

308.说出3条以上firefox和IE的浏览器兼容问题?

答案:兼容firefox的 outerHTML,FF中没有outerHtml的方法

IE下,可以使用()或[]获取集合类对象;Firefox下,只能使用[]获取集合类对象.解决方法:统一使用[]获取集合类对象.

IE下,可以使用获取常规属性的方法来获取自定义属性,?#37096;?#20197;使用getAttribute()获取自定义属性;Firefox下,只能使用getAttribute()获取自定义属性.解决方法:统一通过getAttribute()获取自定义属性

309.请用Jquery语言写出ajax请求或者post请求代码
$.post(“show”,{uname=?#38381;?#19977;?#20445;琾wd=”123”},function(data){
  alert(data)
})
310.body中的onload ()函数和jQuery中document.ready()有什么区别?

答案:ready ?#24405;?#30340;触发,表示文档结构已经加载完成(不包含?#35745;?#31561;非文字媒体文件)

onload ?#24405;?#30340;触发,表示页面包含?#35745;?#31561;文件在内的所有元素都加载完成。

311.jQuery中有哪几种类型的选择器?

答案:

基本选择器

层次选择器

基本过滤选择器

内容过滤选择器

可见性过滤选择器

属性过滤选择器

子元素过滤选择器

表单选择器

表单过滤选择器

312.EasyUI中datagrid刷新当前数据的方法?

答案:使用reload()即可

313.分别写出一个div居中和其中的内容居中的css属性设置

Div居?#26657;?/p>

margin:auto 0px;

内容居中:

text-align:center;

314.概述一下session与cookie的区别

答案:

存储角度:

Session是服务器端的数据存储技术,cookie是客户端的数据存储技术

解决问题角度:

Session解决的是一个用户不同请求的数据共享问题,cookie解决的是不同请求的请求数据的共享问题

生命周期角度:

Session的id是?#35272;?#20110;cookie来进?#20889;?#20648;的,浏览器关闭id就会失效

Cookie可以单独的设置其在浏览器的存储时间。

315.JavaScript 中 null和 undefined 是否有区别?有哪些区别?

答案:

赋值角度说明:

null 表示此处没有值,undefined表示此处定义了但是没有赋值

从数据转换角度:

Null在做数值转换时会被转换为0,undefined会被转换为NaN

316.Servlet中的doPost和doGet方法有什么区别?它们在传递和获取参数上有什么区别?

答案:

区别:doPost用?#21019;?#29702;post请求,doGet用?#21019;?#29702;get请求,获取参数:获取的参数是相同的都是HttpServletRequest \HttpServletResponse

317.请写出一段jQuery代码,实现?#35757;?#21069;页面中所有的a元索中class 属性为“view-link”的链接都改为在新窗口?#20889;?#24320;

答案:$(“a[class=view-link]”).attr(“target”,”_blank”)

318.如下JavaScript代码的输出为:
var scope ="global scope";
function checkscope() {
var scope ="local scope?#20445;?
 return function() { return scope}
}
console.log (checkscope()());

319.Jquery?#23567;?get()’与’.eq()’的区别

eq返回的是一个jquery对象 get返回的是一个html对象

320.如何给weblogic定内存的大小?

在启动Weblogic的脚本?#26657;?#20301;于所在Domian对应服务器目录下的startServerName),增加set MEM_ARGS=-Xms32m -Xmx200m,可以调整最小内存为32M,最大200M

321.TCP为何采用三次握手来建立连接,若釆用二次握手可以吗,请说明理由?

三次握手是为了?#20048;?#24050;失效的连接请求再次传送到服务器端。 二次握手不?#23578;校?#22240;为:如果由于网络不稳定,虽然客户端以前发送的连接请求以到达服务方,但服务方的同意连接的应答未能到达客户端。则客户方要重?#36335;?#36865;连接请求,若采用二次握?#37073;?#26381;务方收到重传的请求连接后,会以为?#20999;?#30340;请求,就会发送同意连接报文,并新开进程提供服务,这样会造成服务方?#35797;?#30340;无谓浪费

322.以下HTTP相应状态码的含义描述正确的是()
A. 200ok表示请求成功
B. 400不良请求表示服务器未发现与请求URL匹配内容
C. 404未发现表示由于语法错误儿导?#36335;?#21153;器无法理解请求信息
D. 500内部服务器错误,无法处理请求
答案:D
分析:
A 200ok 表示的意思是一切正常。一般用于相应GET和POST请求。这个状态码对servlet是缺省的;如果没有调用setStatus方法的话,就会得到200。
B 400 表示指出客户端请求中的语法错误
C 404 客户端所给的地址无法?#19994;?#20219;何?#35797;?/div>
323.JSP页面包括哪些元素?()
A. JSP命令
B. JSP Action
C. JSP脚本
D. JSP控件
答案:C
分析:JSP页面元素构成如下,因此ABD错误
A 200ok 表示的意思是一切正常。一般用于相应GET和POST请求。这个状态码对servlet是缺省的;如果没有调用setStatus方法的话,就会得到200。
B 400 表示指出客户端请求中的语法错误
C 404 客户端所给的地址无法?#19994;?#20219;何?#35797;?/div>
324.Ajax有四种技术组成:DOM,CSS,JavaScript,XmlHttpRequest,其中控制文档结构的是()
A. DOM
B. CSS
C. JavaScript
D. XmlHttpRequest
答案:A
325.下面关于session的用法哪些是错误的?()
A. HttpSession session=new HttpSession();
B. String haha=session getParameler(:haha”);
C. session.removeAttribute(“haha”);
D. session.setAttribute(:haha:);XmlHttpRequest
答案:A
326.Jsp九大内置对象

答案:1、request对象

request 对象是 javax.servlet.httpServletRequest类型的对象。 该对象代表了客户端的请求信息,主要用于接受通过HTTP协议传送到服务器的数据。(包括头信息、系?#25215;?#24687;、请求方式以及请求参数等)。request对象的作用域为一次请求。

2、response对象

response 代表的是对客户端的响应,主要是将JSP容器处理过的对象传回到客户端。response对象也具有作用域,它只在JSP页面内有效。

3、session对象

session 对象是由服务器自动创建的与用户请求相关的对象。服务器为每个用户都生成一个session对象,用于保存该用户的信息,跟踪用户的操作状态。session对象内部使用Map类来保存数据,因此保存数据的格式为 “Key/value”。 session对象的value可以使复杂的对象类型,而不仅仅局限于字符串类型。

4、application对象

?application 对象?#23665;?#20449;息保存在服务器?#26657;?#30452;到服务器关闭,否则application对象中保存的信息会在整个应用中都有效。与session对象相比,application对象生命周期更长,类似于系统的“全局变量”。

5、out 对象

out 对象用于在Web浏览器内输出信息,并且管理应用服务器上的输出缓冲区。在使用 out 对象输出数据时,可以对数据缓冲区进行操作,及时清除缓冲区中的残余数据,为其他的输出让出缓冲空间。待数据输出完毕后,要及时关闭输出流。

6、pageContext 对象

pageContext 对象的作用是取得任何?#27573;?#30340;参数,通过它可以获取 JSP页面的out、request、reponse、session、application 等对象。pageContext对象的创建和初始化都是由容器来完成的,在JSP页面中可以直接使用 pageContext对象。

7、config 对象

config 对象的主要作用是取得服务器的配置信息。通过 pageConext对象的 getServletConfig() 方法可以获取一个config对象。当一个Servlet 初始化时,容器把?#25215;?#20449;息通过 config对象传递给这个 Servlet。 开发者可以在web.xml 文件中为应用程序环境中的Servlet程序和JSP页面提供初始化参数。

8、page 对象

page 对象代表JSP本身,只有在JSP页面内才是合法的。 page隐含对象本质上包含当前 Servlet接口引用的变量,类似于Java编程中的 this 指针。

9、exception 对象

exception 对象的作用是显示异常信息,只有在包含 isErrorPage="true" 的页面中才可?#21592;?#20351;用,在一般的JSP页面中使用该对象将无法编译JSP文件。excepation对象和Java的所有对象一样,都具有系?#31243;?#20379;的继?#34218;?#26500;。exception 对象几乎定义了所有异常情况。在Java程序?#26657;?#21487;以使用try/catch关键字?#21019;?#29702;异常情况; 如果在JSP页面中出现没有捕获到的异常,就会生成 exception 对象,并把 exception 对象传送到在page指令中设定的错误页面?#26657;?#28982;后在错误页面中处理相应的 exception 对象。

327.如何配置一个servlet?

在web.xml中使用如下标签:

<servlet>
 <servlet-name></servlet-name>
 <servlet-class></servlet-class>
</servlet>
<servlet-mapping>
 <servlet-name></servlet-name>
 <url-pattern></url-pattern>
 </servlet-mapping>
 或者使用注解方式:
@WebServlet(name="servlet", urlPatterns={"/*"})
328.JavaScript,如何定义含有数值1至8的数组?

答: var arr=[1,2,3,4,5,6,7,8]

329.以下JavaScipt语句会产生运?#20889;?#35823;的是_()
A. var obj=( );
B. var obj=[ ];
C. var obj=//;
D. var obj=1;
答案:AC
330.在JSP?#26657;?#19979;面__()__块中可以定义一个新类:
A. <% %>
B. <% ! %>
C. <%@ %>
D. <%=%>
答案:B
分析:B <% ! %> 可用作声明
A不正确
C为引用xxx,?#28909;?% @page xxxxx%>
D为表达式
331.HTML含义和版本变化

HTML含义:

Hyper Text Markup Language 超文本标记语言,是一种用来制作“网页”的简单标记语言;用HTML编写的超文本文档称为HTML文档,HTML文档的扩展名是html或者htm

版本变化:

HTML1.0——在1993年6月作为IETF工作草案发布(并非标准)

HTML 2.0——1995年11月作为RFC 1866发布

HTML 3.2——1997年1月14日,W3C推荐标准

HTML 4.0——1997年12月18日,W3C推荐标准

HTML 4.01(微小改进)——1999年12月24日,W3C推荐标准

HTML 5—2014年10月28日,W3C推荐标准HTML文档结构;

HTML 5.1 - 2016年

HTML 5.2 – 2018年最新版本

HTML 5.3 is coming…

332.什么是锚链接

锚链接是带有文本的超链接。可以跳转到页面的某个位置,?#35270;?#20110;页面内容较多,超过一屏的场合 。分为页面内的锚链接和页面间的锚链接 。

例如:1F2F

跳转到2F标记位置

说明:

1.在标记位置利用a标签的name属性设置标记。

2.在导航位置通过a标签的href属性用#开头加name属性值即可跳转锚点位置。

333.HTML字符实体的作用及其常用字符实体

有些字符,?#28909;?#35828;“<”字符,在HTML中有特殊的含义,因此不能在文本中使用。想要在HTML中显示一个小于号“

字符实体拥有三个部分:一个and符号(&),一个实体名或者一个实体号,最后是一个分号(;)

常用字符实体:

显示结果 描述 实体 实体号
空格    
< 小于 < <
> 大于 > &#
& and符号 & &
' 单引号 ' (IE不支持) '
" 引号 " "
英镑 £ £
人民?#20197;? ¥ ¥
§ 章节 ¥ ¥
? 版权 © ©
334.HTML表单的作用和常用表单项类型

表单的作用:

利用表单可以收集客户端提交的有关信息。

常用表单项类型:

input标签
type属性
功能 input标签
type属性
功能
text 单行本框 reset 重?#20882;磁?/td>
password 密码框 submit 提?#35805;磁?/td>
radio 单选?#30913;?/td> textarea 文本域
checkbox 复选框 select 下拉框
button 普通?#30913;?/td> hidden 隐藏域

335.表格、框架、div三种HTML布局方式的特点

优点 缺点 应用场合
表格 方便排列有规律、结构均匀的内容或数据 产生垃圾代码、影响页面下载时间、灵活性不大难于修改 内容或数据整齐的页面
框架 支?#27490;?#21160;条、方便导航 节省页面下载时间等 兼容性不好,保存时不方便、应用?#27573;?#26377;限 小型商业网站、论坛后台管理
Div 代码精简、提高页面下载速?#21462;?#34920;现和内容分离 比较灵活、难于控制 复杂的不规则页面、业务种类较多的大型商业网站

336.form中input设置为readonly和disabled的区别

readonly disabled
有效对象 .只针对type为text/password有效 对所有表单元素有效
表单提交 ?#21271;?#21333;元素设置readonly后,表单提交能将该表单元素的值传递出去。 ?#21271;?#21333;元素设置disabled后,表单提交不能将该表单元素的值传递出去。

337.CSS的定义和作用

CSS的定义:CSS是Cascading Style Sheets(层叠样式表)的简称。

CSS是一系列格式规则,它们控制网页内容的外观。CSS简单来说就是用来美化网页用的。

CSS的具体作用包括:

使网页丰富多彩,易于控制。

页面的精确控制,实现精美、复杂页面 。

338.CSS2常用选择器类型及其含义

选择器名称 案例 语法格式
标签选择器 h3{font-size:24px;font-family:"隶书“; }< h3>JSP< /h3> 元素标签名{样式属性}
类选择器 .red {color:#F00;} < li class="red">Oracle< /li> . 元素标签class属性值{样式属性}
ID选择器 #p1 {background-color:#0F0;} < p id="p1">content< /p> #元素标签id属性值{样式属性}
包含选择器 div h3{color:red;} < div> < h3>CSS层叠样式表< /h3> < /div> 父元素标签 子元素标签{ 样式属性 }
子选择器 div>ul{color:blue;} < div> < ul> < li>测试1 < ol> < li>?#30701;自?#32032;< /li> <