java.docx

java.docx

《java.docx》由会员分享，可在线阅读，更多相关《java.docx（37页珍藏版）》请在冰点文库上搜索。

java

3、String是最基本的数据类型吗？

答：

不是。

Java中的基本数据类型只有8个：

byte、short、int、long、float、double、char、boolean；除了基本类型（primitivetype）和枚举类型（enumerationtype），剩下的都是引用类型（referencetype）。

4、floatf=3.4;是否正确？

答:

不正确。

3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换floatf=（float）3.4;或者写成floatf=3.4F;。

5、shorts1=1;s1=s1+1;有错吗?

shorts1=1;s1+=1;有错吗？

答：

对于shorts1=1;s1=s1+1;由于1是int类型，因此s1+1运算结果也是int型，需要强制转换类型才能赋值给short型。

而shorts1=1;s1+=1;可以正确编译，因为s1+=1;相当于s1=（short）（s1+1）;其中有隐含的强制类型转换。

7、int和Integer有什么区别？

答：

Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapperclass），int的包装类就是Integer，从Java5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。

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

-原始类型:

boolean，char，byte，short，int，long，float，double

-包装类型：

Boolean，Character，Byte，Short，Integer，Long，Float，Double

11、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上？

答：

在Java5以前，switch（expr）中，expr只能是byte、short、char、int。

从Java5开始，Java中引入了枚举类型，expr也可以是enum类型，从Java7开始，expr还可以是字符串（String），但是长整型（long）在目前所有的版本中都是不可以的。

13、数组有没有length（）方法？

String有没有length（）方法？

答：

数组没有length（）方法，有length的属性。

String有length（）方法。

JavaScript中，获得字符串的长度是通过length属性得到的，这一点容易和Java混淆。

14、在Java中，如何跳出当前的多重嵌套循环？

答：

在最外层循环前加一个标记如A，然后用breakA;可以跳出多重循环。

（Java中支持带标签的break和continue语句，作用有点类似于C和C++中的goto语句，但是就像要避免使用goto一样，应该避免使用带标签的break和continue，因为它不会让你的程序变得更优雅，很多时候甚至有相反的作用，所以这种语法其实不知道更好）

15、构造器（constructor）是否可被重写（override）？

答：

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

17、是否可以继承String类？

答：

String类是final类，不可以被继承。

19、String和StringBuilder、StringBuffer的区别？

答：

Java平台提供了两种类型的字符串：

String和StringBuffer/StringBuilder，它们可以储存和操作字符串。

其中String是只读字符串，也就意味着String引用的字符串内容是不能被改变的。

而StringBuffer/StringBuilder类表示的字符串对象可以直接进行修改。

StringBuilder是Java5中引入的，它和StringBuffer的方法完全相同，区别在于它是在单线程环境下使用的，因为它的所有方面都没有被synchronized修饰，因此它的效率也比StringBuffer要高。

20、重载（Overload）和重写（Override）的区别。

重载的方法能否根据返回类型进行区分？

答：

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。

重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。

重载对返回类型没有特殊的要求。

23、抽象类（abstractclass）和接口（interface）有什么异同？

答：

抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用。

一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类。

接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法。

抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的。

抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。

有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法。

31、Strings=newString（"xyz"）;创建了几个字符串对象？

答：

两个对象，一个是静态区的"xyz"，一个是用new创建在堆上的对象。

32、接口是否可继承（extends）接口？

抽象类是否可实现（implements）接口？

抽象类是否可继承具体类（concreteclass）？

答：

接口可以继承接口，而且支持多重继承。

抽象类可以实现（implements）接口，抽象类可继承具体类也可以继承抽象类。

33、一个".java"源文件中是否可以包含多个类（不是内部类）？

有什么限制？

答：

可以，但一个源文件中最多只能有一个公开类（publicclass）而且文件名必须和公开类的类名完全保持一致。

36、Java中的final关键字有哪些用法？

答：

（1）修饰类：

表示该类不能被继承；

（2）修饰方法：

表示方法不能被重写；（3）修饰变量：

表示变量只能一次赋值以后值不能被修改（常量）。

?

40、怎样将GB2312编码的字符串转换为ISO-8859-1编码的字符串？

答：

代码如下所示：

Strings1="你好";

Strings2=newString（s1.getBytes（"GB2312"）,"ISO-8859-1"）;

46、try{}里有一个return语句，那么紧跟在这个try后的finally{}里的代码会不会被执行，什么时候被执行，在return前还是后?

答：

会执行，在方法返回调用者前执行。

45、Error和Exception有什么区别？

答：

Error表示系统级的错误和程序不必处理的异常，是恢复不是不可能但很困难的情况下的一种严重问题；比如内存溢出，不可能指望程序能处理这样的情况；Exception表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况。

47、Java语言如何进行异常处理，关键字：

throws、throw、try、catch、finally分别如何使用？

答：

Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。

在Java中，每个异常都是一个对象，它是Throwable类或其子类的实例。

当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并可以对其进行处理。

Java的异常处理是通过5个关键词来实现的：

try、catch、throw、throws和finally。

一般情况下是用try来执行一段程序，如果系统会抛出（throw）一个异常对象，可以通过它的类型来捕获（catch）它，或通过总是执行代码块（finally）来处理；try用来指定一块预防所有异常的程序；catch子句紧跟在try块后面，用来指定你想要捕获的异常的类型；throw语句用来明确地抛出一个异常；throws用来声明一个方法可能抛出的各种异常（当然声明异常时允许无病呻吟）；finally为确保一段代码不管发生什么异常状况都要被执行；try语句可以嵌套，每当遇到一个try语句，异常的结构就会被放入异常栈中，直到所有的try语句都完成。

如果下一级的try语句没有对某种异常进行处理，异常栈就会执行出栈操作，直到遇到有处理这种异常的try语句或者最终将异常抛给JVM。

50、阐述final、finally、finalize的区别。

答：

-final：

修饰符（关键字）有三种用法：

如果一个类被声明为final，意味着它不能再派生出新的子类，即不能被继承，因此它和abstract是反义词。

将变量声明为final，可以保证它们在使用中不被改变，被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取不可修改。

被声明为final的方法也同样只能使用，不能在子类中被重写。

-finally：

通常放在try…catch…的后面构造总是执行代码块，这就意味着程序无论正常执行还是发生异常，这里的代码只要JVM不关闭都能执行，可以将释放外部资源的代码写在finally块中。

-finalize：

Object类中定义的方法，Java中允许使用finalize（）方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。

这个方法是由垃圾收集器在销毁对象时调用的，通过重写finalize（）方法可以整理系统资源或者执行其他清理工作。

52、List、Set、Map是否继承自Collection接口？

答：

List、Set是，Map不是。

Map是键值对映射容器，与List和Set有明显的区别，而Set存储的零散的元素且不允许有重复元素（数学中的集合也是如此），List是线性结构的容器，适用于按数值索引访问元素的情形。

53、阐述ArrayList、Vector、LinkedList的存储性能和特性。

答：

ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector中的方法由于添加了synchronized修饰，因此Vector是线程安全的容器，但性能上较ArrayList差，因此已经是Java中的遗留容器。

LinkedList使用双向链表实现存储（将内存中零散的内存单元通过附加的引用关联起来，形成一个可以按序号索引的线性结构，这种链式存储方式与数组的连续存储方式相比，内存的利用率更高），按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

Vector属于遗留容器（Java早期的版本中提供的容器，除此之外，Hashtable、Dictionary、BitSet、Stack、Properties都是遗留容器），已经不推荐使用，但是由于ArrayList和LinkedListed都是非线程安全的，如果遇到多个线程操作同一个容器的场景，则可以通过工具类Collections中的synchronizedList方法将其转换成线程安全的容器后再使用（这是对装潢模式的应用，将已有对象传入另一个类的构造器中创建新的对象来增强实现）。

0p

54、Collection和Collections的区别？

答：

Collection是一个接口，它是Set、List等容器的父接口；Collections是个一个工具类，提供了一系列的静态方法来辅助容器操作，这些方法包括对容器的搜索、排序、线程安全化等等。

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

答：

List以特定索引来存取元素，可以有重复元素。

Set不能存放重复元素（用对象的equals（）方法来区分元素是否重复）。

Map保存键值对（key-valuepair）映射，映射关系可以是一对一或多对一。

Set和Map容器都有基于哈希存储和排序树的两种实现版本，基于哈希存储的版本理论存取时间复杂度为O

（1），而基于排序树版本的实现在插入或删除元素时会按照元素或元素的键（key）构成排序树从而达到排序和去重的效果。

61、编写多线程程序有几种实现方式？

答：

Java5以前实现多线程有两种实现方法：

一种是继承Thread类；另一种是实现Runnable接口。

两种方式都要通过重写run（）方法来定义线程的行为，推荐使用后者，因为Java中的继承是单继承，一个类有一个父类，如果继承了Thread类就无法再继承其他类了，显然使用Runnable接口更为灵活。

64、启动一个线程是调用run（）还是start（）方法？

答：

启动一个线程是调用start（）方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行，这并不意味着线程就会立即运行。

run（）方法是线程启动后要进行回调（callback）的方法。

?

80、事务的ACID是指什么？

答：

-原子性（Atomic）：

事务中各项操作，要么全做要么全不做，任何一项操作的失败都会导致整个事务的失败；

-一致性（Consistent）：

事务结束后系统状态是一致的；

-隔离性（Isolated）：

并发执行的事务彼此无法看到对方的中间状态；

-持久性（Durable）：

事务完成后所做的改动都会被持久化，即使发生灾难性的失败。

通过日志和同步备份可以在故障发生后重建数据。

81.写出冒泡排序和单例模式

------------------------------------------------------------------------------------------------------------------------------------------------------------------------

&和&&的区别。

&和&&都可作为逻辑运算符”与”使用，但是&&是”短路与”，运算时先判断符号前面的表达式的值，如果能够确定整个表达式的值，则不进行符号后面的表达式的运算。

另外，&也可作为位运算符使用。

?

HashMap和Hashtable的区别。

HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。

HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。

HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。

因为contains方法容易让人引起误解。

Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Mapinterface的一个实现。

最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供外同步。

Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

final,finally,finalize的区别。

final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

sleep（）和wait（）有什么区别?

sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。

调用sleep不会释放对象锁?

。

wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

Overload和Override的区别。

Overloaded的方法是否可以改变返回值的类型?

方法的重写Overriding和重载Overloading是Java多态性的不同表现。

重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写（Overriding）。

子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被”屏蔽”了。

如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载（Overloading）。

Overloaded的方法是可以改变返回值的类型。

error和exception有什么区别?

error表示恢复不是不可能但很困难的情况下的一种严重问题。

比如说内存溢出。

不可能指望程序能处理这样的情况。

exception表示一种设计或实现问题。

也就是说，它表示如果程序运行正常，从不会发生的情况。

同步和异步有何异同，在什么情况下分别使用他们？

举例说明。

如果数据将在线程间共享。

例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。

当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

----------------------------------------------------------------------------------------------------------------------------------------------------------------------

1.下面哪些是Thread类的方法（）

Astart（）Brun（）Cexit（）DgetPriority（）

答案：

ABD

解析：

看JavaAPIdocs吧：

2.下面关于java.lang.Exception类的说法正确的是（）

A继承自ThrowableBSerialableCD不记得，反正不正确

答案：

A

解析：

Java异常的基类为java.lang.Throwable，java.lang.Error和java.lang.Exception继承Throwable，RuntimeException和其它的Exception等继承Exception，具体的RuntimeException继承RuntimeException。

扩展：

错误和异常的区别（ErrorvsException）

1）java.lang.Error:

Throwable的子类，用于标记严重错误。

合理的应用程序不应该去try/catch这种错误。

绝大多数的错误都是非正常的，就根本不该出现的。

java.lang.Exception:

Throwable的子类，用于指示一种合理的程序想去catch的条件。

即它仅仅是一种程序运行条件，而非严重错误，并且鼓励用户程序去catch它。

2）Error和RuntimeException及其子类都是未检查的异常（uncheckedexceptions），而所有其他的Exception类都是检查了的异常（checkedexceptions）.

checkedexceptions:

通常是从一个可以恢复的程序中抛出来的，并且最好能够从这种异常中使用程序恢复。

比如FileNotFoundException,ParseException等。

检查了的异常发生在编译阶段，必须要使用try…catch（或者throws）否则编译不通过。

uncheckedexceptions:

通常是如果一切正常的话本不该发生的异常，但是的确发生了。

发生在运行期，具有不确定性，主要是由于程序的逻辑问题所引起的。

比如ArrayIndexOutOfBoundException,ClassCastException等。

从语言本身的角度讲，程序不该去catch这类异常，虽然能够从诸如RuntimeException这样的异常中catch并恢复，但是并不鼓励终端程序员这么做，因为完全没要必要。

因为这类错误本身就是bug，应该被修复，出现此类错误时程序就应该立即停止执行。

因此，面对Errors和uncheckedexceptions应该让程序自动终止执行，程序员不该做诸如try/catch这样的事情，而是应该查明原因，修改代码逻辑。

RuntimeException：

RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等。

处理RuntimeException的原则是：

如果出现RuntimeException，那么一定是程序员的错误。

例如，可以通过检查数组下标和数组边界来避免数组越界访问异常。

其他（IOException等等）checked异常一般是外部错误，例如试图从文件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部错误。

3.下面程序的运行结果是（）

Stringstr1="hello";

Stringstr2="he"+newString（"llo"）;

System.err.println（str1==str2）;

答案：

false

解析：

因为str2中的llo是新申请的内存块，而==判断的是对象的地址而非值，所以不一样。

如果是Stringstr2=str1，那么就是true了。

4.下列说法正确的有（）

A．class中的constructor不可省略

B．constructor必须与class同名，但方法不能与class同名

C．constructor在一个对象被new时执行

D．一个class只能定义一个constructor

答案：

C

解析：

这里可能会有误区，其实普通的类方法是可以和类名同名的，和构造方法唯一的区分就是，构造方法没有返回值。

5.具体选项不记得，但用到的知识如下：

String[]a=newStrin