[java技术面试问题和答案]java面试问题及答案

【jianli.jxxyjl.com--面试试题】

　　java经典面试题及参考答案

　　1、作用域public,private,protected,以及不写时的区别

　　答：区别如下：

　　作用域 当前类 同一package 子孙类 其他package

　　public √ √ √ √

　　protected √ √ √ ×

　　friendly √ √ × ×

　　private √ × × ×

　　不写时默认为friendly

　　2、arraylist和vector的区别,hashmap和hashtable的区别

　　答：就arraylist与vector主要从二方面来说.

　　一.同步性:vector是线程安全的，也就是说是同步的，而arraylist是线程序不安全的，不是同步的

　　二.数据增长:当需要增长时,vector默认增长为原来一培，而arraylist却是原来的一半

　　就hashmap与hashtable主要从三方面来说。

　　一.历史原因:hashtable是基于陈旧的dictionary类的，hashmap是java 1.2引进的map接口的一个实现

　　二.同步性:hashtable是线程安全的，也就是说是同步的，而hashmap是线程序不安全的，不是同步的

　　三.值：只有hashmap可以让你将空值作为一个表的条目的key或value

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

　　答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的

　　4、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?

　　答：多线程有两种实现方法，分别是继承thread类与实现runnable接口

　　同步的实现方面有两种，分别是synchronized,wait与notify

　　java经典面试题及参考答案

　　1)transient和volatile是java关键字吗?(瞬联)

　　如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。例如：

　　class t

　　{

　　transient int a; //不需要维持

　　int b; //需要维持

　　}

　　这里，如果t类的一个对象写入一个持久的存储区域，a的内容不被保存，但b的将被保存。

　　volatile修饰符告诉编译器被volatile修饰的变量可以被程序的其他部分改变。在多线程程序中，有时两个或更多的线程共享一个相同的实例变量。考虑效率问题，每个线程可以自己保存该共享变量的私有拷贝。实际的变量副本在不同的时候更新，如当进入synchronized方法时。 用strictfp修饰类或方法，可以确保浮点运算(以及所有切断)正如早期的java版本那样准确。切断只影响某些操作的指数。当一个类被strictfp修饰，所有的方法自动被strictfp修饰。

　　strictfp的意思是fp-strict，也就是说精确浮点的意思。在java虚拟机进行浮点运算时，如果没有指定strictfp关键字时，java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作，以致于得到的结果往往无法令你满意。而一旦使用了strictfp来声明一个类、接口或者方法时，那么所声明的范围内java的编译器以及运行环境会完全依照浮点规范ieee-754来执行。因此如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，那就请用关键字strictfp。

　　你可以将一个类、接口以及方法声明为strictfp，但是不允许对接口中的方法以及构造函数声明strictfp关键字，例如下面的代码：

　　strictfp interface a {}

　　public strictfp class fpdemo1 {

　　strictfp void f() {}

　　}

　　2. 错误的使用方法

　　interface a {

　　strictfp void f();

　　}

　　public class fpdemo2 {

　　strictfp fpdemo2() {}

　　}

　　一旦使用了关键字strictfp来声明某个类、接口或者方法时，那么在这个关键字所声明的范围内所有浮点运算都是精确的，符合ieee-754规范

　　的。例如一个类被声明为strictfp，那么该类中所有的方法都是strictfp的。

　　2)抽象类和接口有什么区别?(瞬联)

　　1.abstract class 在 java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。

　　2.在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员(也就是必须是static final的，不过在 interface中一般不定义数据成员)，所有的成员方法都是abstract的。

　　3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。

　　4.实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。

　　5.接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。

　　6.抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。

　　7.接口中的方法默认都是 public,abstract 类型的。

　　3)能说一下java的反射(reflection)机制吗?(瞬联)

　　开放性和原因连接(causally-connected)是反射系统的两大基本要素

　　4)在java中怎样实现多线程?(瞬联)

　　extends thread

　　implement runnable

　　方法一：继承 thread 类，覆盖方法 run()，我们在创建的 thread 类的子类中重写 run() ,加入线程所要执行的代码即可。下面是一个例子：

　　public class mythread extends thread

　　{

　　int count= 1, number;

　　public mythread(int num)

　　{

　　number = num;

　　system.out.println

　　("创建线程 " + number);

　　}

　　public void run() {

　　while(true) {

　　system.out.println

　　("线程 " + number + ":计数 " + count);

　　if(++count== 6) return;

　　}

　　}

　　public static void main(string args[])

　　{

　　for(int i = 0;i 〈 5; i++) new mythread(i+1).start();

　　}

　　}

　　这种方法简单明了，符合大家的习惯，但是，它也有一个很大的缺点，那就是如果我们的类已经从一个类继承(如小程序必须继承自 applet 类)，则无法再继承 thread 类，这时如果我们又不想建立一个新的类，应该怎么办呢?

　　我们不妨来探索一种新的方法：我们不创建thread类的子类，而是直接使用它，那么我们只能将我们的方法作为参数传递给 thread 类的实例，有点类似回调函数。但是 java 没有指针，我们只能传递一个包含这个方法的类的实例。

　　那么如何限制这个类必须包含这一方法呢?当然是使用接口!(虽然抽象类也可满足，但是需要继承，而我们之所以要采用这种新方法，不就是为了避免继承带来的限制吗?)

　　java 提供了接口 java.lang.runnable 来支持这种方法。

　　方法二：实现 runnable 接口

　　runnable接口只有一个方法run()，我们声明自己的类实现runnable接口并提供这一方法，将我们的线程代码写入其中，就完成了这一部分的任务。但是runnable接口并没有任何对线程的支持，我们还必须创建thread类的实例，这一点通过thread类的构造函数 public thread(runnable target);来实现。下面是一个例子：

　　public class mythread implements runnable

　　{

　　int count= 1, number;

　　public mythread(int num)

　　{

　　number = num;

　　system.out.println("创建线程 " + number);

　　}

　　public void run()

　　{

　　while(true)

　　{

　　system.out.println

　　("线程 " + number + ":计数 " + count);

　　if(++count== 6) return;

　　}

　　}

　　public static void main(string args[])

　　{

　　for(int i = 0; i 〈 5;i++) new thread(new mythread(i+1)).start();

　　}

　　}

　　严格地说，创建thread子类的实例也是可行的，但是必须注意的是，该子类必须没有覆盖 thread 类的 run 方法，否则该线程执行的将是子类的 run 方法，而不是我们用以实现runnable 接口的类的 run 方法，对此大家不妨试验一下。

　　使用 runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码，有利于封装，它的缺点在于，我们只能使用一套代码，若想创建多个线程并使各个线程执行不同的代码，则仍必须额外创建类，如果这样的话，在大多数情况下也许还不如直接用多个类分别继承 thread 来得紧凑。

　　综上所述，两种方法各有千秋，大家可以灵活运用。

　　下面让我们一起来研究一下多线程使用中的一些问题。

　　三、线程的四种状态

　　1. 新状态：线程已被创建但尚未执行(start() 尚未被调用)。

　　2. 可执行状态：线程可以执行，虽然不一定正在执行。cpu 时间随时可能被分配给该线程，从而使得它执行。

　　3. 死亡状态：正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。

　　4. 阻塞状态：线程不会被分配 cpu 时间，无法执行。

　　四、线程的优先级

　　线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 cpu 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 cpu 时间，优先级高的线程有更大的机会获得 cpu 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。

　　你可以调用 thread 类的方法 getpriority() 和 setpriority()来存取线程的优先级，线程的优先级界于1(min_priority)和10(max_priority)之间，缺省是5(norm_priority)。

　　5)你用过哪种设计模式?(瞬联，ibm，aspentech)

　　设计:design

　　模式:pattern

　　框架:framework

　　创建模式，结构模式和行为模式

　　gof设计模式

　　a.创建模式

　　设计模式之factory(工厂模式)

　　使用工厂模式就象使用new一样频繁.XX/10/9更新

　　设计模式之prototype(原型模式)

　　用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

　　设计模式之builder

　　汽车由车轮 方向盘 发动机很多部件组成，同时，将这些部件组装成汽车也是一件复杂的工作，builder模式就是将这两种情况分开进行。

　　设计模式之singleton(单态模式)

　　保证一个类只有一个实例,并提供一个访问它的全局访问点 XX/10/9更新

　　b.结构模式

　　设计模式之facade

　　可扩展的使用jdbc针对不同的数据库编程,facade提供了一种灵活的实现.

　　设计模式之proxy

　　以jive为例,剖析代理模式在用户级别授权机制上的应用

　　设计模式之adapter

　　使用类再生的两个方式:组合(new)和继承(extends),这个已经在"thinking in java"中提到过.

　　设计模式之composite

　　就是将类用树形结构组合成一个单位.你向别人介绍你是某单位，你是单位中的一个元素，别人和你做买卖，相当于和单位做买卖。文章中还对jive再进行了剖析。

　　设计模式之decorator

　　decorator是个油漆工,给你的东东的外表刷上美丽的颜色.

　　设计模式之bridge

　　将"牛郎织女"分开(本应在一起,分开他们,形成两个接口),在他们之间搭建一个桥(动态的结合)

　　设计模式之flyweight

　　提供java运行性能,降低小而大量重复的类的开销.

　　c.行为模式

　　设计模式之template

　　实际上向你介绍了为什么要使用java 抽象类,该模式原理简单,使用很普遍.

　　设计模式之memento

　　很简单一个模式,就是在内存中保留原来数据的拷贝.

　　设计模式之observer

　　介绍如何使用java api提供的现成observer

　　设计模式之chain of responsibility

　　各司其职的类串成一串,好象击鼓传花,当然如果自己能完成,就不要推委给下一个.

　　设计模式之command

　　什么是将行为封装,command是最好的说明.

　　设计模式之state

　　状态是编程中经常碰到的实例,将状态对象化,设立状态变换器,便可在状态中轻松切换.

　　设计模式之strategy

　　不同算法各自封装,用户端可随意挑选需要的算法.

　　设计模式之mediator

　　mediator很象十字路口的红绿灯,每个车辆只需和红绿灯交互就可以.

　　设计模式之interpreter

　　主要用来对语言的分析,应用机会不多.

　　设计模式之visitor

　　访问者在进行访问时,完成一系列实质性操作,而且还可以扩展.

　　设计模式之iterator

　　这个模式已经被整合入java的collection.在大多数场合下无需自己制造一个iterator,只要将对象装入collection中，直接使用iterator进行对象遍历。

本文来源：https://jianli.jxxyjl.com/mianshishiti/5077.html