java就业面试试题大全[精选多篇]

第一篇：java就业面试试题大全

java就业面试试题大全

（二）2010-07-19 17:35 4．5月15号班同学贡献的一些题？

1.线程如何同步和通讯。同学回答说synchronized方法或代码块！面试官似乎不太满意！

只有多个synchronized代码块使用的是同一个监视器对象，这些synchronized代码块之间才具有线程互斥的效果，假如a代码块用obj1作为监视器对象，假如b代码块用obj2作为监视器对象，那么，两个并发的线程可以同时分别进入这两个代码块中。„这里还可以分析一下同步的原理。

对于同步方法的分析，所用的同步监视器对象是this 接着对于静态同步方法的分析，所用的同步监视器对象是该类的Class对象 接着对如何实现代码块与方法的同步进行分析。2.ClassLoader如何加载class。

jvm里有多个类加载，每个类加载可以负责加载特定位置的类，例如，bootstrap类加载负责加载jre/lib/rt.jar中的类，我们平时用的jdk中的类都位于rt.jar中。extclassloader负责加载jar/lib/ext/*.jar中的类，appclassloader负责classpath指定的目录或jar中的类。除了bootstrap之外，其他的类加载器本身也都是java类，它们的父类是ClassLoader。3.Servlet的生命周期 4.抽象类的作用

5.ArrayList如何实现插入的数据按自定义的方式有序存放 class MyBean implements Comparable{ public int compareTo(Object obj){ if(!obj instanceof MyBean)throw new ClassCastException()//具体异常的名称，我要查jdk文档。

MyBean other =(MyBean)obj;return age > other.age?1:age== other.age?0:-1;} } class MyTreeSet { private ArrayList datas = new ArrayList();

public void add(Object obj){ for(int i=0;i

下面的仅供参考，不建议照搬照套，一定要改成自己的语言，发现内心的感受： 分层的好处：

1，实现了软件之间的解耦； 2.便于进行分工 3.便于维护

4，提高软件组件的重用

5.便于替换某种产品，比如持久层用的是hibernate,需要更换产品用toplink，就不用该其他业务代码，直接把配置一改。6.便于产品功能的扩展。7。便于适用用户需求的不断变化 7.序列化接口的id有什么用？

对象经常要通过IO进行传送，让你写程序传递对象，你会怎么做？把对象的状态数据用某种格式写入到硬盘，Person->“zxx,male,28,30000”àPerson，既然大家都要这么干，并且没有个统一的干法，于是，sun公司就提出一种统一的解决方案，它会把对象变成某个格式进行输入和输出，这种格式对程序员来说是透明（transparent）的，但是，我们的某个类要想能被sun的这种方案处理，必须实现Serializable接口。

ObjectOutputStream.writeObject(obj);Object obj = ObjectInputStream.readObject();假设两年前我保存了某个类的一个对象，这两年来，我修改该类，删除了某个属性和增加了另外一个属性，两年后，我又去读取那个保存的对象，或有什么结果？未知！sun的jdk就会蒙了。为此，一个解决办法就是在类中增加版本后，每一次类的属性修改，都应该把版本号升级一下，这样，在读取时，比较存储对象时的版本号与当前类的版本号，如果不一致，则直接报版本号不同的错!9.hashCode方法的作用？说

（网友提供的一段，待改进：hashcode这个方法是用来鉴定2个对象是否相等的。那你会说，不是还有equals这个方法吗？

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

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

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

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

10.webservice问得很多

11.设计出计算任意正整数的阶层。4.在oracle数据库中需要查询出前8条记录的sql语句怎么写？ 5.什么是SOA，谈谈你的SOA的理解。service orientied architecture 6.如何实现线程间的通讯。

新题目：编程:1.编写一个函数将一个十六进制数的字符串参数转换成整数返回。

String str = “13abf”;int len = str.length;int sum = 0;for(int i=0;i

其实，也可以用Integer.parseInt(str,16)，但面试官很可能是想考我们的编码基本功。编程2 :银行贷款的还款方式中最常用的是一种叫“等额本息”，还款法，即借款人在约定还款期限内的每一期（月）归还的金额（产生的利息+部分本金）都是相等的，现有一笔总额为T元的N年期住房贷款，年利率为R，要求算出每一期的还款的本金和利息总额，请写出解决思路和任意一种编程语言实现的主要代码。

思路：既然是按月还款，那我就要将N年按月来计算，即要还N*12个月，这样就可以求出每月要还的本金。由于每月要还的那部分本金所欠的时间不同，所以，它们所产生的利息是不同的，该部分本金的利息为：部分本金额*所欠月数*月利率。应该是这么个算法，如果利息还计利息，如果月还款不按年利率来算，老百姓算不明白的。int monthMoney = T/N/12;float monthRate = R/12;int totalMonth = N * 12;float totalRate = 0;for(int i=1;i<=totalMonth;i++){ totalRate += monthMoney * monthRate * i;} int result = monthMoney + totalRate/N/12;几道题：

1.****Spring的DI是什么（学员注：除了IOC，AOP这些概念，还不太清楚DI的概念）2.*任意数字序列“123456”之类，输出它们所有的排列组合 3.*****什么是AOP（学员注：会用，但感觉说不清楚）

我注：由上面这些题，可以看出，思想很重要，只有琢磨思想和原理的人才能很好地回答这些问题！2题的答案：

String str = “xafdvs”;

char[] arr1 = str.toCharArray();char[] arr2 = Arrays.copyOf(arr1,arr1.length);for(int i=0;i

3题的答案：

1.概念介绍：所谓AOP，即Aspect orientied program,就是面向方面的编程，2.解释什么是方面：贯穿到系统的各个模块中的系统一个功能就是一个方面，比如，记录日志，统一异常处理，事务处理，全限检查，这些功能都是软件系统 的一个面，而不是一点，在各个模块中都要出现。

3.什么是面向方面编程：把系统的一个方面的功能封装成对象的形式来处理

4.怎么进行面向方面编程：把功能模块对应的对象作为切面嵌入到原来的各个系统模块中，采用代理技术，代理会调用目标，同时把切面功能的代码（对象）加入进来，所以，用spring配置代理对象时只要要配两个属性，分别表示目标和切面对象（Advisor）。

3、构造器Constructor是否可被override?

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

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

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

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

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

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

clone 有缺省行为，super.clone();因为首先要把父类中的成员复制到位，然后才是复制自己的成员。

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

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

面向对象的编程语言有封装、继承、抽象、多态等4个主要的特征。1封装：

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

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

抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与当前目标有关的方面。例如，看到一只蚂蚁和大象，你能够想象出它们的相同之处，那就是抽象。抽象包括行为抽象和状态抽象两个方面。例如，定义一个Person类，如下： class Person { String name;int age;} 人本来是很复杂的事物，有很多方面，但因为当前系统只需要了解人的姓名和年龄，所以上面定义的类中只包含姓名和年龄这两个属性，这就是一种抽像，使用抽象可以避免考虑一些与目标无关的细节。我对抽象的理解就是不要用显微镜去看一个事物的所有方面，这样涉及的内容就太多了，而是要善于划分问题的边界，当前系统需要什么，就只考虑什么。继承：

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

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

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

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

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

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

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

1.抽象类可以有构造方法，接口中不能有构造方法。2.抽象类中可以有普通成员变量，接口中没有普通成员变量

3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。4.抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然

eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

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

6.抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。7.一个类可以实现多个接口，但只能继承一个抽象类。下面接着再说说两者在应用上的区别：

接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码，伪代码如下： public abstract class BaseServlet 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 extends BaseServlet { protected void doService(HttpServletRequest request, HttpServletResponse response)throws IOExcetion,ServletException { 本Servlet只处理的具体业务逻辑代码 } } 父类方法中间的某段代码不确定，留给子类干，就用模板方法设计模式。

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

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

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

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

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

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

10、什么是内部类？Static Nested Class 和 Inner Class的不同。内部类就是在一个类的内部定义的类，内部类中不能定义静态成员（静态成员不是对象的特性，只是为了找一个容身之处，所以需要放到一个类中而已，这么一点小事，你还要把它放到类内部的一个类中，过分了啊！提供内部类，不是为让你干这种事情，无聊，不让你干。我想可能是既然静态成员类似c语言的全局变量，而内部类通常是用于创建内部对象用的，所以，把“全局变量”放在内部类中就是毫无意义的事情，既然是毫无意义的事情，就应该被禁止），内部类可以直接访问外部类中的成员变量，内部类可以定义在外部类的方法外面，也可以定义在外部类的方法体中，如下所示： 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种类型，这就好像类中定义的成员变量有4种访问类型一样，它们决定这个内部类的定义对其他类是否可见；对于这种情况，我们也可以在外面创建内部类的实例对象，创建内部类的实例对象时，一定要先创建外部类的实例对象，然后用这个外部类的实例对象去创建内部类的实例对象，代码如下： Outer outer = new Outer();Outer.Inner1 inner1 = outer.new Innner1();在方法内部定义的内部类前面不能有访问类型修饰符，就好像方法中定义的局部变量一样，但这种内部类的前面可以使用final或abstract修饰符。这种内部类对其他类是不可见的其他类无法引用这种内部类，但是这种内部类创建的实例对象可以传递给其他类访问。这种内部类必须是先定义，后使用，即内部类的定义代码必须出现在使用该类之前，这与方法中的局部变量必须先定义后使用的道理也是一样的。这种内部类可以访问方法体中的局部变量，但是，该局部变量前必须加final修饰符。

对于这些细节，只要在eclipse写代码试试，根据开发工具提示的各类错误信息就可以马上了解到。在方法体内部还可以采用如下语法来创建一种匿名内部类，即定义某一接口或类的子类的同时，还创建了该子类的实例对象，无需为该子类定义名称： public class Outer { public void start(){ new Thread(new Runable(){ public void run(){};}).start();} } 最后，在方法外部定义的内部类前面可以加上static关键字，从而成为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 = new Outer.Inner();由于static Nested Class不依赖于外部类的实例对象，所以，static Nested Class能访问外部类的非static成员变量。当在外部类中访问Static Nested Class时，可以直接使用Static Nested Class的名字，而不需要加上外部类的名字了，在Static Nested Class中也可以直接引用外部类的static的成员变量，不需要加上外部类的名字。

在静态方法中定义的内部类也是Static Nested Class，这时候不能在类前面加static关键字，静态方法中的Static Nested Class与普通方法中的内部类的应用方式很相似，它除了可以直接访问外部类中的static的成员变量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加final修饰符。备注：首先根据你的印象说出你对内部类的总体方面的特点：例如，在两个地方可以定义，可以访问外部类的成员变量，不能定义静态成员，这是大的特点。然后再说一些细节方面的知识，例如，几种定义方式的语法区别，静态内部类，以及匿名内部类。

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

完全可以。如果不是静态内部类，那没有什么限制！

如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员，例如，下面的代码： class Outer { static int x;static class Inner { void test(){ syso(x);} } } 答题时，也要能察言观色，揣摩提问者的心思，显然人家希望你说的是静态内部类不能访问外部类的成员，但你一上来就顶牛，这不好，要先顺着人家，让人家满意，然后再说特殊情况，让人家吃惊。

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

可以继承其他类或实现其他接口。不仅是可以，而是必须!

13、super.getClass()方法调用

下面程序的输出结果是多少？ import java.util.Date;public class Test extends Date{ public static void main(String[] args){ new Test().test();}

public void test(){ System.out.println(super.getClass().getName());} } 很奇怪，结果是Test 这属于脑筋急转弯的题目，在一个qq群有个网友正好问过这个问题，我觉得挺有趣，就研究了一下，没想到今天还被你面到了，哈哈。

在test方法中，直接调用getClass().getName()方法，返回的是Test类名 由于getClass()在Object类中定义成了final，子类不能覆盖该方法，所以，在

test方法中调用getClass().getName()方法，其实就是在调用从父类继承的getClass()方法，等效于调用super.getClass().getName()方法，所以，super.getClass().getName()方法返回的也应该是Test。如果想得到父类的名称，应该用如下代码： getClass().getSuperClass().getName();14.jdk中哪些类是不能继承的？

不能继承的是类是那些用final关键字修饰的类。一般比较基本的类型或防止扩展类无意间破坏原来方法的实现的类型都应该是final的，在jdk中System,String,StringBuffer等都是基本类型。

2、String是最基本的数据类型吗?

基本数据类型包括byte、int、char、long、float、double、boolean和short。

java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类 111、String s = “Hello”;s = s + “ world!”;这两行代码执行后，原始的String对象中的内容到底变了没有？

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

通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做： public class Demo { private String s;...public Demo { s = “Initial Value”;}...} 而非

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

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

至于为什么要把String类设计成不可变类，是它的用途决定的。其实不只String，很多Java标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本，即 StringBuffer。

41、是否可以继承String类?

String类是final类故不可以继承。

27、String s = new String(“xyz”);创建了几个String Object? 二者之间有什么区别？ 两个或一个，”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，都是缓冲区中的那一个。New String每写一遍，就创建一个新的对象，它一句那个常量”xyz”对象的内容来创建出一个新String对象。如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。

5、String 和StringBuffer的区别

JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。String类表示内容不可改变的字符串。而StringBuffer类表示内容可以被修改的字符串。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。另外，String实现了equals方法，new String(“abc”).equals(new String(“abc”)的结果为true,而StringBuffer没有实现equals方法，所以，new StringBuffer(“abc”).equals(new StringBuffer(“abc”)的结果为false。

接着要举一个具体的例子来说明，我们要把1到100的所有数字拼起来，组成一个串。StringBuffer sbf = new StringBuffer();for(int i=0;i<100;i++){ sbf.append(i);} 上面的代码效率很高，因为只创建了一个StringBuffer对象，而下面的代码效率很低，因为创建了101个对象。

String str = new String();for(int i=0;i<100;i++){ str = str + i;} 在讲两者区别时，应把循环的次数搞成10000，然后用endTime-beginTime来比较两者执行的时间差异，最后还要讲讲StringBuilder与StringBuffer的区别。

String覆盖了equals方法和hashCode方法，而StringBuffer没有覆盖equals方法和hashCode方法，所以，将StringBuffer对象存储进Java集合类中时会出现问题。

第二篇：java英语面试试题整理

1.What are java beans?

JavaBeans is a portable, platform-independent component model written in the Java programming language, developed in collaboration with industry leaders.It enables developers to write reusable components once and run them anywhere--benefiting from the platform-independent power of Java technology.JavaBeans acts as a Bridge between proprietary component models and provides a seamless and powerful means for developers to build components that run in ActiveX container applications.Java beans is very powerful tool you can use in your servlet/JSP bridge.You can use the servlets to build the bean and can be passed over to the JSP for reading.This provides tight encapsulation of the data while preserving the sanctity of servlets and JSP。2.What is RMI?

RMI stands for Remote Method Invocation.Traditional approaches to executing code on other machines across a network have been confusing as well as tedious and error-prone to implement.The nicest way to think about this problem is that some object happens to live on another machine, and that you can send a message to the remote object and get a result as if the object lived on your local machine.This simplification is exactly what Java Remote Method Invocation(RMI)allows you to do.3.How does Java inheritance work?

A class can only directly extend one class at a time.Multiple inheritance is only allowed with regard to interfaces.A class can implement many interfaces.But a class can only extend one non-interface class.4.How does exception handling work in Java?

1.It separates the working/functional code from the error-handling code by way of try-catch clauses.2.It allows a clean path for error propagation.If the called method encounters a situation it can't manage, it can throw an

exception and let the calling method deal with it.3.By enlisting the compiler to ensure that “exceptional” situations are anticipated and accounted for, it enforces powerful coding.4.Exceptions are of two types: Compiler-enforced exceptions, or checked exceptions and Runtime exceptions, or unchecked exceptions.Compiler-enforced(checked)exceptions are instances of the Exception class or one of its subclasses--excluding the RuntimeException branch.The compiler

expects all checked exceptions to be appropriately handled.Checked exceptions must be declared in the throws clause of the method throwing them--assuming, of course, they're not being caught within that same method.The calling method must take care of these exceptions by either catching or declaring them in its throws clause.Thus, making an exception checked forces us to pay heed to the possibility of it

being thrown.An example of a checked exception is java.io.IOException.As the name suggests, it throws whenever an input/output operation is abnormally terminated.5.Does Java have destructors?

Java does not have destructors.Garbage collector does this job periodically depending upon the memory requirements of the machine and on the fact that a particular object is no longer needed.But it has finalizers that does a similar job.The syntax is

public void finalize(){ }

If an object has a finalizer, the method is invoked before the system garbage collects the object, but using finalize()does not guarantee that it would be called b4 garbage collector is invoked.6.What does the “final” keyword mean in front of a variable? A method? A class?

A final variable cannot be reassigned, but it is not constant.For instance, final StringBuffer x = new StringBuffer();

x.append(“hello”);

is valid.X cannot have a new value in it, but nothing stops operations on the object that it refers, including destructive operations.Also, a final method cannot be overridden or hidden by new access specifications.This means that the compiler can choose to in-line the invocation of such a method.(I don't know if any compiler actually does this, but it's true in theory.)

The best example of a final class is String, which defines a class that cannot be derived.6.Access specifiers: “public”, “protected”, “private”, nothing?

Public?Any other class from any package can instantiate and execute the classes and methods Protected? Only subclasses and classes inside of the package can access the classes and methods Private? The original class is the only class allowed to execute the methods.And in case if there is no modifier specified, it means, only the classes inside the package can access this class and its methods, it is also called “Friendly”.Question:What is the difference between an Interface and an Abstract class?Question: What is the purpose of garbage collection in Java, and when is it used?

Question:Describe synchronization in respect to multithreading.1.what is single inheritance.ans:one class is inherited by only other one class

9.what is interface.ans:Interface has only method declarations but no definition

10.what is differenec between abstract class and interface.ans:In abstract class some methods may contain definition,but in interface every method should be abstract

11.how to u prove that abstrace class cannot instantiate directly.ans:As they dont have constructor they cant be instantiated

12.what is differenece between string and stringbuffer.ans:Strings are immutable where as string buffer can be modified

13.what is immutable

ans:Which cant be changed

18.what is legacy interface.ans: legacy is something that is old in terms of technology/ system

19.what is main difference hashmap and hastable

ans:Hash table is synchronized

20.what is main difference between arraylist and vector.ans:Vector is synchronised

22.what are distributed techonologies.distributed technologies means any technology / s/w program that are having many components in

multiple environments that interact with each other depending on the functional requirements and design.23.what is advantage and disadvantage of distributed techonologies.language is avoided.Application can be built flexible to meet requirements.Division of labour is

possible.Best of all the technologies and platforms can be optimally utilized.Complexity of requirements can be reduced.25.what is difference between procedure and functions.''

ans:Fuctions can return value ,procedures cant return value

26.what is jdbc.ans:Connecting to DB from java program requires JDBC

31.what is deployment descriptor.ans:Which contains the infrnmation like which file to be used

40.what is platfrom independent

ans:A language is said to be platform independent if it can be run on any machine with out modifying code

46.what is major concepts in oops.ans:Abstraction,polymorphism,encapsulation,inheritance

48.what is implicit object.ans:Implicit objects are a set of Java objects that the JSP Container makes available to developers in each page

49.how many implicit objects in jsp

ans:out,page,session,request,response,application,page context,config

介绍下自己情况

技术问题.基本在论坛上面资料都cover了.比如 list和array 区别, pass by reference or value, memory leakage, oo基本问题, overload/override, 数据库clustered or non-clustered.还有quick sort和 binary sort介绍.复杂度.适用在哪里.有什么问题等等.基本准备下应该没有问题,都很基本.这个过了就进入最后一轮 AC, 是5.5个小时的.从早上8:30开始.相比以前和其他公司.今年这个长度我觉得不累.哈哈.往年有1天半的AC.晕

面试基本是.group discussion+2个technical interviews+1个interpersonal skill interview.全部2个对你一个.group discussion 是给了几个os+database+gui资料, 然后要求选择哪个合适.四个人一组.然后2个人资料是来自相同department的email.根据自己和其他人的资料.选系统.我可以说的就是.要get involved, 如果有不了解问题.不要怕要问其他人来确认..做完后.hr会杀入在给一个资料.然后继续做讨论15分钟.反正就是多说就是了.多和其他人交流.然后就是一般面试...介绍自己, 为什么要做这个,为什么学这个学校, teamwork, 对公司了解, 有个特别点问题就是.如果你是boss在开10人大会.下面你的员工说的东西有个很大的错误,而且很基本的错误.你怎么办.还有如果回到几年前.你会有什么选择会改变吗.(我就说不读phd了,申请ms直接.哈哈)这个部分问题很多.准备要充分.而且很多问题是根据你自己回答.他们追下去问.后面就是两个technical interview, 我大概回忆下.有np/p问题, hashmap, hash原理, deadlock问题, java GC 问题, 还有很多多线程问题(具体有点忘记了), 记得一个GC在多线程环境下的操作.还有j2ee问题.介绍下spring, soap, hibernate.(基本就可以了).c 内存操作问题, 还有 internet, ip和tcp区别.然后osi说几个protocols.第二个面试.基本都是数据结构.写个 binary search tree 来找某个值, 要递归和非递归的.然后hash table, 还有点不记得了.然后数据库.写个简单的er 图.学生, 课程.然后写sql.还要早最大值.然后排序的sql.基本的很.然后说下dns是什么.怎么实现的.最后说下从你在浏览器输入一个网址.到内容被全部显示的过程, 原理等等.基本面试完了.然后去吃饭和以前的graduate scheme的人聊聊.

第三篇：JAVA面试

马老师：

您好，昨天下午面试的中软资源。因为笔试时间很短（她之前并没说多长时间，我估计就只有30多分钟就要收卷），而且题量很大，所以没有记下题目，不过前面的题目都很简单，主要是咱们做的那些基础题。后面的主观题是：

1、详细叙述5种以上种的设计模式

2、详细说明类的设计原则

3、sql语句的调优

还有一个忘记了！

完了之后人事的会做初步面试，首先自我介绍，然后问离职原因，以前的一些工作情况。再就是简单介绍他们目前要做的项目情况，会说工作很幸苦之类的话，最后会问薪水要求!

再就是技术人员面，感觉他们对基础知识很看重，当然首先是自我介绍。会问到一些详细的知识点，比如说怎么配置DWR，sql语句的调优，当然项目也是得问的，主要介绍最近的项目，做过什么东西！

最后是技术总监，开始也是自我介绍。技术方面问的少，就问我jbpm和我做过什么以及用到的一些开源框架和工具。然后问3到5年的职业规划，再给我一份英文的文档让我翻译（他不会告诉你是关于什么方面，我傻到居然去问他）。后面有人遇到这种情况要先看文档大标题，完了告诉他这文档大概是关于什么的（给我的是分需求文档），不要一上来就往细里看，那位总监就批评过我，完了再看细节。最后问我有什么问题！

如果问到的一些知识没听过，就说这些不会是以后项目开发中的问题，因为我们以前也是好多技术都是在项目中边学习边开发的，不可能我们什么技术都会了都准备好了再去做开发。面试中也问道过俩，我不知道是什么，按照上面的回答，感觉对方还是比较满意，也没有为难我！

这些都跟面得职位有关，职位不同情况可能不同。我面得是中软内部的职位，不是外包。

中科软笔试

1.集合类

2.servlet生命周期

3.string,stringbuffer,区别，int integer 区别

4.常见的运行时异常

5.写出几个常见的类，包，接口

6.写一个单例

7.抽象类和接口的区别

8.还有两页的SQL选择题，我不太记得了

9.怎么配置tomcat的内存大小

10.数据库连接池的原理

11.触发器有哪几种，并说说每一种

12.还有JSP中静态include和动态include区别

13.jsp的9种内置对象

14.选择题好几个都是关于主键的，记不清了

还有一个是写几种常用的数据结构，并写出实现原理

还有一个也是数据 结构上的，我不记得了，我连见都没见过 还有一个是程序改错题，挺简单的

第四篇：Java 软件工程师面试笔试题

Java 软件工程师面试笔试题.txt﹃根网线''尽赚了多少人的青春い有时候感动的就是身边微不足道的小事。﹎破碎不是最残酷的 最残酷的是踩着这些碎片却假装不疼痛 固执的寻找﹎将来就算我遇见再怎么完美的人,都有一个缺点,他不是你,_____下辈子要做男生，娶一个像我这样的女生。

一、你对MVC的理解，MVC有什么优缺点？结合Struts，说明在一个Web应用如何去使用？ 答：

MVC设计模式（应用观察者模式的框架模式）

M: Model(Business process layer)，模型，操作数据的业务处理层,并独立于表现层(Independent of presentation)。

V: View(Presentation layer)，视图，通过客户端数据类型显示数据,并回显模型层的执行结果。

C: Controller(Control layer)，控制器，也就是视图层和模型层桥梁，控制数据的流向，接受视图层发出的事件，并重绘视图

MVC框架的一种实现模型 模型二(Servlet-centric)：

JSP+Servlet+JavaBean，以控制为核心，JSP只负责显示和收集数据，Sevlet，连接视图和模型，将视图层数据，发送给模型层，JavaBean，分为业务类和数据实体，业务类处理业务数据，数据实体，承载数据，基本上大多数的项目都是使用这种MVC的实现模式。

StrutsMVC框架(Web application frameworks)

Struts是使用MVC的实现模式二来实现的，也就是以控制器为核心。

Struts提供了一些组件使用MVC开发应用程序：

Model：Struts没有提供model类。这个商业逻辑必须由Web应用程序的开发者以JavaBean或EJB的形式提供

View：Struts提供了action form创建form bean, 用于在controller和view间传输数据。此外，Struts提供了自定义JSP标签库，辅助开发者用JSP创建交互式的以表单为基础的应用程序，应用程序资源文件保留了一些文本常量和错误消息，可转变为其它语言，可用于JSP中。

Controller：Struts提供了一个核心的控制器ActionServlet，通过这个核心的控制器来调用其他用户注册了的自定义的控制器Action，自定义Action需要符合Struts的自定义Action规范，还需要在struts-config.xml的特定配置文件中进行配置，接收JSP输入字段形成Action form，然后调用一个Action控制器。Action控制器中提供了model的逻辑接口。

二、什么是WebService？ 答：

WebService是一个SOA（面向服务的编程）的架构，它是不依赖于语言，不依赖于平台，可以实现不同的语言间的相互调用，通过Internet进行基于Http协议的网络应用间的交互。WebService实现不同语言间的调用，是依托于一个标准，webservice是需要遵守WSDL（web服务定义语言）/SOAP（简单请求协议）规范的。WebService=WSDL+SOAP+UDDI（webservice的注册）

Soap是由Soap的part和0个或多个附件组成，一般只有part，在part中有Envelope和Body。

Web Service是通过提供标准的协议和接口，可以让不同的程序集成的一种SOA架构。Web Service的优点

(1)可以让异构的程序相互访问（跨平台）

(2)松耦合

(3)基于标准协议（通用语言，允许其他程序访问）Web Service的基本原理

(1)Service Provider采用WSDL描述服务

(2)Service Provider 采用UDDI将服务的描述文件发布到UDDI服务器（Register server）

(3)Service Requestor在UDDI服务器上查询并 获取WSDL文件

(4)Service requestor将请求绑定到SOAP，并访问相应的服务。

三、什么是中间件？

中间件就是程序中可织入的，可重用的，与业务逻辑无关的各种组件。

中间件（middleware）是基础软件的一大类，属于可复用软件的范畴。顾名思义，中间件处于操作系统软件与用户的应用软件的中间。中间件在操作系统、网络和数据库之上，应用软件的下层，总的作用是为处于自己上层的应用软件提供运行与开发的环境，帮助用户灵活、高效地开发和集成复杂的应用软件。

在众多关于中间件的定义中，比较普遍被接受的是IDC表述的：中间件是一种独立的系统软件或服务程序，分布式应用软件借助这种软件在不同的技术之间共享资源，中间件位于客户机服务器的操作系统之上，管理计算资源和网络通信。

分类：数据访问中间件，远程调用中间件，消息中间件，交易中间件，对象中间件。

举例：

1，RMI（Remote Method Invocations, 远程调用）

2，Load Balancing(负载均衡，将访问负荷分散到各个服务器中)

3，Transparent Fail-over(透明的故障切换)

4，Clustering(集群,用多个小的服务器代替大型机）

5，Back-end-Integration(后端集成，用现有的、新开发的系统如何去集成遗留的系统)

6，Transaction事务（全局/局部）全局事务（分布式事务）局部事务（在同一数据库联接内的事务）

7，Dynamic Redeployment(动态重新部署,在不停止原系统的情况下，部署新的系统）

8，System Management(系统管理)

9，Threading(多线程处理)

10，Message-oriented Middleware面向消息的中间件（异步的调用编程）

11，Component Life Cycle(组件的生命周期管理)

12，Resource pooling（资源池）

13，Security（安全）

14，Caching（缓存）

四、什么是典型的软件三层结构？软件设计为什么要分层？软件分层有什么好处？ 答：(1)Presentation layer（表示层）

(1)表示逻辑（生成界面代码）

(2)接收请求

(3)处理业务层抛出的异常

(4)负责规则验证（数据格式，数据非空等）

(5)流程控制

(2)Service layer（服务层/业务层）

(1)封装业务逻辑处理，并且对外暴露接口

(2)负责事务，安全等服务

(3)Persistence layer（持久层）

(1)封装数据访问的逻辑，暴露接口

(2)提供方便的数据访问的方案（查询语言，API，映射机制等）Domain layer（域层）

(1)业务对象以及业务关系的表示

(2)处理简单的业务逻辑

(3)域层的对象可以穿越表示层，业务层，持久层

软件分层结构使得代码维护非常方便，设计明确，各层独立，专注自己擅长的领域。

五、什么是OOP？OOP相对于面向过程编程有哪些优点？

OOP，Object-Oriented Programming，面向对象编程不同于面向过程编程：

（1）OOP关注对象和角色，也就是事物的本质

1）OOP把客观世界中的对象抽象成对应的类；

2）通过类构造实例；

3）通过依赖、继承、实现等形式建立对象间的通信关系

（2）OOP易于扩展，增加或改变业务的功能，无需大幅改动改变源代码

（3）OOP易于建模，OOP就是软件架构师在计算机高级语言中对客观世界的抽象和再现，人们可以很好地理解和建立起计算机中的抽象模型

六、谈谈Overload和Override的区别。

答：

方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

七、谈谈HashMap和Hashtable的区别。答：

HashMap是轻量级的（线程不安全的，效率高的）集合，Hashtable是重量级的（线程安全的，效率低的）集合。

都属于Map接口的类，实现了将惟一键映射到特定的值上。

HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。

Hashtable 类似于 HashMap，但是不允许 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。

八、请问abstract class和interface有什么区别？

答：

1)接口没有任何的实现,而抽象类它可以有部分的实现也可以没有;

2)如果需要复用或者共享部分代码,应该用抽象类而不是接口;

3)继承无法解决类型的转换问题,接口就是为了解决这一问题而产生的(Java的单继承是接口产生的根本原因)接口是一种抽象的第三方规范,跟对象没什么直接关系。

九、请问软件开发中的设计模式你会使用哪些？

答：我熟悉的设计模式有单例模式，DAO模式，模板方法，工厂模式，委托代理模式，MVC模式等。

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

Singleton模式一般形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

十、类的核心特性有哪些？

类具有封装性、继承性和多态性。

封装性：

类的封装性为类的成员提供公有、缺省、保护和私有等多级访问权限，目的是隐藏类中的私有变量和类中方法的实现细节。

继承性：

类的继承性提供从已存在的类创建新类的机制，继承（inheritance）使一个新类自动拥有被继承类（父类）的全部成员。

多态性：

类的多态性提供类中方法执行的多样性，多态性有两种表现形式：重载和覆盖。

十一、请问类与对象有什么区别？

类

类就是某一种事物的一般性的集合体，是相同或相似的各个事物共同特性的一种抽象。

对象

在面向对象概念中，对象（Object）是类的实例（instance）。对象与类的关系就像变量与数据类型的关系一样。

十二、写出生产者消费者模型的实现

十三、用软件工程和Java来叙述购物车（shopping cart）系统实现

十四、文件系统的几个类:FileInputStream、FileOutputStream、FileReader、FileWriter的区别

十五、请写出Java API中最常用的五个包，并且各举两个类加以说明。

十六、请问你在“电信运营支撑系统”中遇到了哪些问题？你是怎么解决的？做这个项目你最大的收获是什么？

十七、请说出几个常用的异常类

答：NullpointException（空指针异常）

ClassNotFoundException（类找不到异常）

ClassCastException（类型转换异常）

IllegalArgumentException（非法参数异常）

ArithmeticException（算术异常）

NumberFormatException（数据格式异常）

IndexOutOfBoundsException（数组下标越界异常）

IllegalStateException（非法语句异常）

十八、什么是进程和线程？两者的区别是什么？

十九、请简要描述一下你做的ShoppingCart项目。

二十、请问网络7层协议，tcp/ip4 层协议是什么？

二十一、Java面向对象的四大特点

二十二、public,private,protected，default访问权限（可见性）

答：

public：全局可见

protected：继承体系结构之间可见

default（或不写）：同包可见

private：本类可见。

二十二、public,private,protected，default访问权限（可见性）

答：

public：全局可见

protected：继承体系结构之间可见

default（或不写）：同包可见

private：本类可见。

二十三、名词解释

CRM

[Customer Relationship Management, 客户关系管理] ERP

[Enterprise Resource Planning, 企业资源规划] OSS

[Operation Support System, 运营支撑系统] BSS

[Business Support System, 数据定义语言] BOSS

[Business Operation Support System, 数据定义语言] OA

[Office Automatization, 办公自动化] HTTP OOP SOA GUI DDL

[Data Definition Language, 数据定义语言] DML

[Data Manipulation Language, 数据操作语言]

WYSIWYG

所见即所得 [What You See is What You Get] CMP CMT B2B C2C B2C IDE DOM

Client/Server CMM ORM MIS MVC

MVC是Model－View－Controller的简写。“Model” 代表的是应用的业务逻辑（通过JavaBean，EJB组件实现），“View” 是应用的表示面（由JSP页面产生），“Controller” 是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。

OLE

CORBA

CORBA 标准是公共对象请求代理结构(Common Object Request Broker Architecture)，由对象管理组织(Object Management Group，缩写为 OMG)标准化。它的组成是接口定义语言(IDL), 语言绑定(binding:也译为联编)和允许应用程序间互操作的协议。其目的为：

用不同的程序设计语言书写

在不同的进程中运行

为不同的操作系统开发。

UML

UML，标准建模语言，包含用例图,静态图(包括类图、对象图和包图),行为图,交互图(顺序图,合作图),实现图等。

XML CMMI JRE J2EE

J2EE是Sun公司提出的多层(multi-diered),分布式(distributed),基于组件(component-base)的企业级应用模型(enterpriese application model).在这样的一个应用系统中，可按照功能划分为不同的组件，这些组件又可在不同计算机上，并且处于相应的层次(tier)中。所属层次包括客户层(clietn tier)组件,web层和组件,Business层和组件,企业信息系统(EIS)层。

JDK AOP OO

Container W3C JMS

Domain POJO JVM JNDI JTA SOAP

[Simple Object Access Protocol，简单对象访问协议] WSDL JDO

JDO是Java对象持久化的新的规范，为Java Data Object的简称,也是一个用于存取某种数据仓库中的对象的标准化API。JDO提供了透明的对象存储，因此对开发人员来说，存储数据对象完全不需要额外的代码（如JDBC API的使用）。这些繁琐的例行工作已经转移到JDO产品提供商身上，使开发人员解脱出来，从而集中时间和精力在业务逻辑上。另外，JDO很灵活，因为它可以在任何数据底层上运行。JDBC只是面向关系数据库（RDBMS)JDO更通用，提供到任何数据底层的存储功能，比如关系数据库、文件、XML以及对象数据库（ODBMS）等等，使得应用可移植性更强。

TDD DAO IoC

[Inversion of Control, 控制反转] RMI DNS

[Internet Domain Name System, 因特网域名系统] URL URI

二十四、数据库连接池的工作机制

二十五、互联网提供哪些服务？

二十六、请写出JSP的几个隐含内置对象

答：JSP中隐含内置对象

名称 类型

request javax.servlet.http.HttpServletRequest request

response javax.servlet.http.HttpServletResponse

注释和范围 response page javax.lang.Object page

Exception java.lang.Throwable page

pageContext javax.servlet.jsp.PageContext page

session javax.servlet.http.HttpSession session

application javax.servlet.ServletContext ServletContext out javax.servlet.jsp.JspWriter OutputStream

config javax.servlet.ServletConfig ServletConfig

JSP共有以下9种基本内置组件（可与ASP的6种内部组件相对应）：

request 用户端请求，此请求会包含来自GET/POST请求的参数

response 网页传回用户端的回应

page JSP 网页本身

exception 针对错误网页，未捕捉的例外

pageContext 网页的属性是在这里管理

session 与请求有关的会话期

application servlet 正在执行的内容

out 用来传送回应的输出

config Servlet的构架部件

二十七、请你谈谈SSH整合

答：SSH：

Struts（表示层）+Spring（业务层）+Hibernate（持久层）

Struts：

Struts是一个表示层框架，主要作用是界面展示，接收请求，分发请求。

在MVC框架中，Struts属于VC层次，负责界面表现，负责MVC关系的分发。（View：沿用JSP，HTTP，Form，Tag，Resourse ；Controller：ActionServlet，struts-config.xml，Action）

Hibernate：

Hibernate是一个持久层框架，它只负责与关系数据库的操作。

Spring：

Spring是一个业务层框架，是一个整合的框架，能够很好地黏合表示层与持久层。

二十八、应用服务器与Web Server的区别

二十九、Java Servlet API中forward()与redirect()的区别

答：

前者仅是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址；后者则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接。这样，从浏览器的地址栏中可以看到跳转后的链接地址。所以，前者更加高效，在前者可以满足需要时，尽量使用forward()方法，并且，这样也有助于隐藏实际的链接。在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用sendRedirect()方法。

三

十、写一个简单的C/S结构程序，Java 的通信编程，编程题(或问答)，用JAVA SOCKET编程，读服务器几个字符，再写入本地显示？

答:Server端程序: package test;import java.net.*;import java.io.*;

public class Server { private ServerSocket ss;private Socket socket;private BufferedReader in;private PrintWriter out;public Server(){ try { ss=new ServerSocket(10000);while(true){ socket = ss.accept();String RemoteIP = socket.getInetAddress().getHostAddress();String RemotePort = “:”+socket.getLocalPort();System.out.println(“A client come in!IP:”+RemoteIP+RemotePort);in = new BufferedReader(new

InputStreamReader(socket.getInputStream()));String line = in.readLine();System.out.println(“Cleint send is :” + line);out = new PrintWriter(socket.getOutputStream(),true);out.println(“Your Message Received!”);out.close();in.close();socket.close();} }catch(IOException e){ out.println(“wrong”);} } public static void main(String[] args){ new Server();} };Client端程序: package test;import java.io.*;import java.net.*;

public class Client { Socket socket;BufferedReader in;PrintWriter out;public Client(){ try { System.out.println(“Try to Connect to 127.0.0.1:10000”);socket = new Socket(“127.0.0.1”,10000);System.out.println(“The Server Connected!”);System.out.println(“Please enter some Character:”);BufferedReader line = new BufferedReader(new

InputStreamReader(System.in));out = new PrintWriter(socket.getOutputStream(),true);out.println(line.readLine());in = new BufferedReader(new InputStreamReader(socket.getInputStream()));System.out.println(in.readLine());out.close();in.close();socket.close();}catch(IOException e){ out.println(“Wrong”);} } public static void main(String[] args){ new Client();} };

第五篇：面试笔试题总结(java)

笔试题部分：

1、（北京37期）编程题：编写一段程序用于生成随机码，入参为随机码长度，出参为随机码，要求随机码中必须包含大小写字母及数字

，2015/5/5 15:59:38

2、（北京37期）编写一段程序用于判断一个字符串是否是合法的IP地址

3、笔试题最难的内容：

根据给定的表，写一个存储过程：

客户信息表（客户编号、客户名称，联系方式...）

订单表（订单号，订单名称，订单价格合计，订单明细信息id，客户编号）订单明细表（id,产品名称，单位，单价，数量）该存储过程要求根据客户编号，查询该客户的订单以及该订单下不同产品价格合计；

即： 客户编号、客户 名称、订单号、订单名称、产品id、数量合计、价格合计

4、笔试题最恶心的：英文阅读翻译等；脑筋急转弯；

5、没涉及到的笔试题（自己百度或者求助同学）

6、其他笔试题（老师将上一期学生笔试题内容以图片形式保存了，到时候按时下载）

7、不用循环写一个小于5000以2的倍数递增并输出值？

上机题：

上机题可能有如下几个考点：

1、手动搭建SSH框架，写一套增删改查

2、解析一个XML文件（sax、DOM解析）

3、写一个方法，实现扫描指定路径下某个文件夹中所有文件（获取文件个数，文件名称等）；

4、使用SSH框架，结合给定页面，实现功能（一般涉及到ajax）

面试题部分：

1、谈谈你对java的了解？

Java是面向对象的、具有安全性、可移植性、跨平台性、并发性。Java有三个平台J2EE、J2ME、J2SE

2、面向对象的三个特性：

继承封装多态（体现在哪里？）

继承：子类继承父类，子类能够继承父类中非私有的方法或者变量，继承的好处是可以使程序大量的复用；缺点是如果过多继承会导致程序结构庞大

封装：体现在包、访问修饰符以及setget方法取值，还有某些操作封装到方法中

多态：实例化对象，一个类可以new多次，构造方法的重载重写也体现多态；

3、面向对象的过程

面向对象分析、面向对象设计、面向对象编程

4、java的八个基本数据类型 和对应的包装类和每一种类型的长度

Byte、short、int、long、double、float、char、boolean

5、异常和错误区别？ 运行时异常和非运行时异常（编译时异常）区别，说出几个你用过的异常？如何捕获异常？Throws和throw区别？

异常： 程序运行过程中产生的某些错误，程序人员通过修改程序可以修复的，程序员可以预知的错误；

错误： 表示系统级别的错误，例如系统崩溃，jvm内存溢出等；无法预知并且修改程序也无法避免的；

运行时异常：表示程序运行过程中产生的异常，可以不强制try catch捕获或者不强制的throws，程序可以编译通过；

非运行时异常：表示程序编译过程中就捕获的异常，需要强制try catch或者throws抛出，程序运行时，一旦产生非运行时异常，程序无法编译通过；

如何捕获异常？ 通过try catch finally try{表示放可能产生异常的程序} catch(可能产生的异常){如果符合该异常，此时执行该语句段，表示这里要处理该异常}finally{不论是否有异常都执行该语句段} Throws:在方法声明时使用，表示该方法可能产生的异常，谁调用该方法，谁捕获处理；当前方法不处理不捕获

Throw：表示抛出一个具体异常，使用在方法体中；例如：throw new Ｅｘｃｅｐｔｉｏｎ（“异常消息”）；

6、String和StringBuffer区别？为什么用StringBuffer拼字符串？ String 表示不可长度字符串，finally不可被继承的类；

StringBuffer：表示可变长度字符串，通过append方法追加字符串，默认有16位缓冲区，时能new实例化赋值，不能=号赋值；

使用StringBuffer拼接字符串以为StringBuffer长度可变，并且通过append方法追加字符串，节省内存：例如： “a”+”b”+”c” 此时字符串池中有： a b c ab

abc几个字符串；而通过StringBuffer：

则字符串池中有： a

b c 和 abc

7、线程和进程区别？如何理解锁？

线程：一段可执行的代码段；多个线程共同完成一个任务； 进程：一个可执行的应用程序；

解决死锁可以通过：synchronized 关键词，实现多个线程中不同方法，在同一时间内，只能有一个线程在执行；其他线程等待，直到该线程释放资源；

8、Wait和sleep方法区别？

Wait方法是object类中的，sleep是Thread类中的

9、如何定义一个线程？

重写Thread类中的Run方法，或者实现Runnable接口中Run方法

10、Collection和Collections区别

Collection是集合接口，Collections是封装了操作集合方法的类；

11、Set和List区别

Set无序，不可以重复；

List有序，可以重复；

12、LinkedList和vector以及ArrayList区别 LinkedList： 链表实现，对该集合新增修改删除数据速度快，效率高，线程不安全； Arraylist：数组实现，对该集合操作时，从该集合中查询数据速度快，效率高，线程不安全；

Vector: 数组实现，线程安全，效率低；

13、HashMap和HashTable区别：

HasMap: 键值对可以为空；线程不安全；

HashTable： 键值对不可以为空；线程安全；

14、PreparedStatement 和Statement区别：

前者使用预编译sql，效率高，安全，后者未采用预编译sql，效率低；

15、名词解释： jdbc、JNDI、BI、VO、DAO、IOC、AOP、OOP、DI（依赖注入）、MVC、ORM（关系映射模型）、盒子模型、JDBC:java 数据库链接；即：java提供操作数据库的东西； JNDI:java 命名目录接口； BI:商业智能； VO：值对象；

DAO：数据访问对象也就是：java访问数据库的第一层接口； IOC：控制翻转；（Spring时候讲）AOP:面向切面编程（Spring讲）OOP:面向对象编程； DI: MVC:是一种开发模式，M：model模型层，V view 视图层 C Controller 控制层；

控制层主要负责模型层以及视图层数据交互；

ORM:关系映射模型；（Hibernate,Mybatis等都是ORM框架）

盒子模型：css中的一种模型；将页面元素认为是现实中盒子，他们都具有border 边框 Content内容，padding（补白）内边距 margin外边距 等特点，这就是盒子模型；

16、接口和抽象类区别？为什么用接口（弥补java单继承特点）？为什么用抽象类（提取公共部分内容，达到代码复用目的和多态）？

接口：是Interface，是一种特殊的抽象类，为了弥补java单继承的特点，接口可以继承多个接口，也可以实现多个类，声明的变量为常量，方法默认public 省略abstract关键词；

使用时必须通过类重写里面所有抽象方法；

抽象类： 是abstract 声明的类，可以有抽象方法，也可以有非抽象方法；

不能被实例化，只能通过子类继承重写里面所有抽象方法，通过实例化子类使用；

用抽象类可以提取公共部分，然后子类重写相关方法或者抽象方法，实现多态以及程序的复用；

接口目的就是为了弥补单继承缺点；因为接口可以弥补多继承；

17、Break（退出整个循环）、continue（退出当前循环，只能用于循环或者switch语句）和return（退出整个方法体表示该方法有返回值）区别

18、Finally（异常语句块中的，表示有无异常都执行该方法体）、final(声明变量为常量，声明类不可被继承)、finalize（垃圾回收机制中自动调用的方法）区别

19、如何获取随机小数？如何获取随机整数？

Math.random()

Random.类 20、io流的种类？ 哪里用到了io流，？什么时候用字节流，什么时候用字符流？

说一下你用过的流有哪些？

（1）字节流和字符流

（2）文件上传下载以及解析xml时加载文件等，还有某些框架底层用到了

（3）读取文件内容，即文本，使用字符流，其他情况都是用字节流

（4）字节流： InputStram，OutputStream FileInputStram、FileOutputStream

BufferedInputStream。BufferedOutputStream

字符流：Reader、Writer、BufferedReader、BufferedWriter、FileReader、FileWriter、InputStreamReader、OutputStreamWriter

21、内部类种类？

匿名内部类、非静态内部类、静态内部类、局部内部类

22、list、set如何重新排序？如何让set有序？

重写Comparable 以及Comparator 中的comparaTo以及compare方法

23、重写以及重载区别？

重写发生在继承中，子类继承父类，要求子类方法与父类方法名，参数个数，返回值必须相同；

重载是发生在当前类中，方法名相同，参数个数不同，类型不同即可；

24、Static用法：

static表示声明的变量或者方法只能被实例化一次，并且被一个对象的不同实例共享，类名可直接打点调用；

25、super和this区别？

Super调用父类对象，使用时如果在子类构造方法中，必须写第一行，不能用在static中；

This表示当前类对象，不能用static中；

26、Jsp的两中包含：

动态包含，被包含页面不独立存在，先包含进来在编译；

<%@include> 静态包含，被包含的页面独立存在，先编译完毕后再包含进来；

27、jsp的就个内置对象：

out、page、request、session、application、config、pageContext、exception、response

四个作用域： page（最小）、request、session、application（最大）

28、过滤器用在哪儿？

即：filter，可以实现权限控制以及转码，某些框架中也使用了（struts2）

29、监听器？ Session、request、application（ServletContex类型）

监听在线人数、通过application初始化时加载数据或者配置； 30、servlet的声明周期？

服务器加载后，servlet容器通过init方法初始化，然后客户端访问服务器时，经过servlet的指定的urlpattern，然后进入指定servlet类中的service方法处理业务逻辑，然后响应给客户端，服务器关闭通过destory方法销毁servlet容器；

31、Session和Cookie区别：

Session’表示一次会话，客户端访问服务器端，会有唯一session表示该客户端，有一个sesionid是唯一的； 浏览器关闭只能是断开会话，而session依然存在，直到过期或者手动销毁；（web.xml中可以设置或者通过set...方法设置有效时间）

Session是保留在服务器端的；过多使用给服务器端带来压力； Cookie是键值对存储数据，保留在客户端不安全；

32、Jsp中的<%%> <%!%> <=%>区别

<%%> 可以声明变量也可以写操作；

<%!%> 只能用于声明变量，声明变量是全局的；

<%=%> 表示输出，显示某个字段值，类似于out.print();

33、客户端跳转（重定向）或者服务器端跳转（转发）区别？

客户端跳转当页面刷新时，不会再次发送请求，以前的request中存放的变量全部失效，并进入一个新的request作用域。

服务器端跳转当刷新页面会再次提交请求，并且服务器端跳转时以前的request中存放的变量不会失效。

34、初始化快和静态初始化块区别：

类中写static{}永远只加载一次，单利的、比构造方法早

类中写{} 每次加载类都执行，比构造方法早

35、为什么用构造方法？（初始化成员变量使用的）

36、Js如何操作DOM？什么是DOM（文本对象模型）？

(1)按照id获取对象、按照name属性获取、按照标签获取、按照form找

document.getElementById(“”)

document.getElementsByName(“”)document.getElementsByTagName(“”)Document.forms[0].id或者name属性

38、如何js创建一个节点？如何用jquery创建一个节点？

Js: document.createElement(“标签名”)Jquery: $(“

$(“