Java面试必备知识点解析

需积分: 16 140 浏览量更新于2024-07-26 收藏 771KB PDF 举报

"Java面试葵花宝典包含了Java面试中的基础、JSP、HTML、XML、数据库、框架等多个领域的经典问答，提供了详细的解答，旨在帮助求职者全面准备Java面试。一、Java基础部分： 1. Java源文件可以包含多个类，但只能有一个公开的（public）类，其他类可以是非公开的（非public）。 2. Java中没有goto语句，这与C/C++不同，Java鼓励使用结构化的控制流程。 3. &是按位与运算符，&&是逻辑与运算符。&始终会计算两边的操作数，而&&会在左操作数为假时短路，不会计算右操作数。 4. 要跳出多重嵌套循环，可以使用标记（label）配合break语句。 5. switch语句不能作用于byte，但Java 7之后可以作用于char和字符串（String）。 6. 对于short类型的变量，使用s1=s1+1会导致数据溢出，因为隐式转换为int类型；而s1+=1会自动处理类型转换。 7. char类型可以存储单个Unicode字符，因此可以存储中文汉字。 8. 计算2乘以8的最有效率方法是直接使用*运算符：int result = 2 * 8。 9. 设计一个一百亿的计算器要考虑数值溢出问题，可以使用BigInteger类处理大整数。 10. 使用final修饰变量，意味着该变量一旦赋值后就不能再改变，如果是引用类型，则引用本身不能变，但引用的对象状态可以变。 11. "=="比较的是对象的引用，而equals方法比较的是对象的内容。 12. 静态变量属于类，实例变量属于对象。静态变量可以被类的所有实例共享，实例变量仅在创建的对象中存在。 13. 不可以从static方法内部直接调用非static方法，因为static方法与类关联，而非static方法与对象关联。 14. Integer是int的包装类，它们之间有自动装箱拆箱机制。Integer对象在一定范围内有缓存，效率上低于int。 15. Math.round(11.5)等于12，Math.round(-11.5)等于-11，四舍五入处理。 16. 未提供代码，无法分析不妥之处。 17. public表示全局访问，private表示私有访问，protected表示包内和子类访问，无修饰符表示默认包内访问。 18. Overload是重载，可以改变参数列表；Override是覆盖，不能改变返回类型。重载方法不能改变返回类型。 19. 构造器不能被override，但可以被重载。 20. 接口可以继承接口，抽象类可以实现接口，抽象类也可以继承具体类。静态的main方法在抽象类中是可以的。 21. 实现克隆时，通常会调用super.clone()来创建对象副本。 22. 面向对象的特征包括封装、继承、多态。 23. Java通过方法重写（Override）和父类引用指向子类对象来实现多态。 24. abstract class和interface都可以定义抽象方法，但abstract class可以有非抽象方法和成员变量，可以实现接口，而interface不能有方法实现，只能声明常量和抽象方法。 25. abstract method不能同时是static、native或synchronized，因为这些修饰符与抽象方法的定义冲突。 26. 内部类是定义在另一个类内部的类，StaticNestedClass是静态嵌套类，它像其他静态成员一样存在；InnerClass是非静态内部类，需要外部类的实例才能创建。 27. 内部类可以直接访问外部类的成员，包括私有成员，但外部类不能直接访问内部类的非静态成员，除非有实例引用。以上是Java面试葵花宝典的部分内容，涵盖了基础语法、面向对象、异常处理、集合框架、多线程等方面，对于准备Java面试的程序员来说是宝贵的参考资料。"

最后，在方法外部定义的内部类前面可以加上 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 Clas s 不依赖于外部类的实例对象，所以， static Nested Clas s 能访问外部类的非 stati c

成员变量。当在外部类中访问 Static Nested Class 时，可以直接使用 Static Nested Class 的名字，而不需要

加上外部类的名字了，在 Static Nested Class 中也可以直接引用外部类的 static 的成员变量，不需要加上外部

类的名字。

在静态方法中定义的内部类也是 Static Nested Class ，这时候不能在类前面加 static 关键字，静态方法中的

Static Nested Class 与普通方法中的内部类的应用方式很相似，它除了可以直接访问外部类中的 static 的成员变

量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加 final 修饰符。

备注：首先根据你的印象说出你对内部类的总体方面的特点：例如，在两个地方可以定义，可以访问外部类的成员变

量，不能定义静态成员，这是大的特点。然后再说一些细节方面的知识，例如，几种定义方式的语法区别，静态内部类

，

以及匿名内部类。

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

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

如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类

中的静态成员，例如，下面的代码：

class Outer {

static int x;

static class Inner {

void test() {

syso(x);

}

答题时，也要能察言观色，揣摩提问者的心思，显然人家希望你说的是静态

内部类不能访问外部类的成员，但你一上来就顶牛，这不好，要先顺着人家，让

人家满意，然后再说特殊情况，让人家吃惊。

28 、 Anonymous

Anonymous

Anonymous Inner

Inner

Inner Class

Class

Class (

(

( 匿名内部类 )

)

) 是否可以 extends(

extends(

extends( 继承 )

)

) 其它类，是否可以 implements(

implements(

implements( 实

现 )interface(

)interface(

)interface( 接口 )?

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

29 、 super.getClass()

super.getClass()

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----------

在 test 方法中，直接调用

getClass().getName() 方法，返回的是 Test 类

名。由于 getClass() 在 Object 类中定义成了

final ，子类不能覆盖该方法，所以在 test 方法中

调用 getClass().getName() 方法，其实就是在

调用从父类继承的 getClass() 方法，等效于调用

super.getClass().getName() 方法，所以，

super.getClass().getName() 方法返回的也应

该是 Test 。若想得到父类的名称，应该用如下代码：

getClass().getSuperClass().getName();

30 、 String

String

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

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

java.lang.String 类是 final 类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我

们应该用 StringBuffer 类

31 、 String

String

String s

s =

= "Hello";s

"Hello";s

"Hello";s =

= s

s +

+ "

" world!";

world!";

world!"; 这两行代码执行后，原始的 String

String

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 。

、是否可以继承

String

类

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

33 、 String

String

String s

s =

= new

new

new String("xyz");

String("xyz");

String("xyz"); 创建了几个 String

String

String Object?

Object?

Object? 二者之间有什么区别？

两个或一个， ” xyz ” 对应一个对象，这个对象放在字符串常量缓冲区，常量 ” xyz ” 不管出现多少遍，都是缓冲区中的

那一个。 New String 每写一遍，就创建一个新的对象，它依据那个常量 ” xyz ” 对象的内容来创建出一个新 String 对象

。

如果以前就用过 ’ xyz ’ ，这句代表就不会创建 ” xyz ” 自己了，直接从缓冲区拿。

34 、 String

String

String 和 StringBuffer

StringBuffer

StringBuffer 的区别

JAVA 平台提供了两个类： String 和 StringBuffer ，它们可以储存和操作字符串，即包含多个字符的字符数据。

这个 String 类提供了数值不可改变的字符串。而这个 StringBuffer 类提供的字符串进行修改。当你知道字符数据要

改变的时候你就可以使用 StringBuffer 。典型地，你可以使用 StringBuffers 来动态构造字符数据。另外， Strin g

实现了 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;

}

String 覆盖了 equals 方法和 hashCode 方法，而 StringBuffer 没有覆盖 equals 方法和 hashCode 方法，

所以，将 StringBuffer 对象存储进 Java 集合类中时会出现问题。

在讲两者区别时，应把循环的次数搞成 10000 ，然后用 endTime-beginTime 来比较两者执行的时间差异，最后

还要讲讲 StringBuilder

StringBuilder

StringBuilder 与 StringBuffer

StringBuffer

StringBuffer 的区别。（区别如下）

StringBuffer 线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间

点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容，可将字符串缓冲区安全地用于

多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与

所涉及的每个线程进行的方法调用顺序一致。（从 JDK 5 开始，为该类补充了一个单个线程使用的等价类，即

StringBuilder 。与该类相比，通常应该优先使用 StringBuilder 类，因为它支持所有相同的操作，但由于它不执

行同步，所以速度更快。）

StringBuilder 一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API ，但不保证同步。该类被设

计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。（如果可能，

建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。但将 StringBuilder 的实例用于多个线程

是不安全的。如果需要这样的同步，则建议使用 StringBuffer 。）

StringBuffer 和 Stringbuilder 上的主要操作都是 append 和 insert 方法，可重载这些方法，以接受任

意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中

。

append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。

例如，如果 z 引用一个当前内容是 “ start ” 的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符

串缓冲区包含 “ startle ” ，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含 “ starlet ” 。

通常，如果 sb 引用 StringBuilder 的一个实例，则 sb.append(x) 和 sb.insert(sb.length(), x) 具

有相同的效果。只要发生有关源序列（如在源序列中追加或插入）的操作，该类就只在执行此操作的字符串缓冲区上而

不是在源上实现同步。

35 、如何把一段逗号分割的字符串转换成一个数组 ?

如果不查 jdk api ，我很难写出来！我可以说说我的思路：

1. 用正则表达式，代码大概为： String [] result = orgStr.split( “ , ” );

2. 用 StingTokenizer , 代码为： StringTokenizer tokener = StringTokenizer(orgStr, ” , ” );

String [] result = new String[tokener . countTokens ()];

Int i=0;

while(tokener.hasNext(){result[i++]=toker.nextToken();}

36 、数组有没有 length()

length()

length() 这个方法 ?

? String

String

String 有没有 length()

length()

length() 这个方法？

数组没有 length() 这个方法，有 length 的属性。 String 有有 length() 这个方法。

37 、下面这条语句一共创建了多少个对象： String

String

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

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

答：对于如下代码：

static String s1 = "a";

s tring s2 = s1 + "b";

s tring s3 = "a" + "b";

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

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

第一条语句打印的结果为 false ，第二条语句打印的结果为 true ，这说明 javac 编译可以对字符串常量直接相加的

表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编译时去掉其中的加号，直接将其编译成一个这些常量

相连的结果。

题目中的第一行代码被编译器在编译时优化后，相当于直接定义了一个 ” abcd ” 的字符串，所以，上面的代码应该只创

建了一个 String 对象。写如下两行代码，

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

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

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

、

try

try {}

{}

里有一个

return

语句，那么紧跟在这个

try

后的

finally

finally {}

{}

里的

code

会不会被执行，什

么时候被执行，在

return

前还是后

也许你的答案是在 return 之前，但往更细地说，我的答案是在 return 中间执行，请看下面程序代码的运行结果：

public class Test {

public static void main(String[] args) {

System.out.println(new Test().test());

}

static int test() {

int x = 1;

try {

return x;

} finally {

++x;

}

--------- 执行结果 ---------

为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果

放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什

么结果可言，结果是在说这话之前放进罐子里的。

39 、下面的程序代码输出的结果是多少？

public class smallT {

public static void main(String args[]) {

smallT t = new smallT();

int b = t.get();

System.out.println(b);

}

public int get() {

---------- 返回结果是 ----------

我可以通过下面一个例子程序来帮助我解释这个

答案，从下面例子的运行结果中可以发现， try 中的

retur n 语句调用的函数先于 finall y 中调用的函数

执行，也就是说 return 语句先执行， finally 语句

后执行，所以，返回的结果是 2 。 r eturn 并不是让函

try {

return 1 ;

} finally {

return 2 ;

}

数马上返回，而是 return 语句执行后，将把返回结

果放置进函数栈中，此时函数并不是马上返回，它要

执行 finally 语句后才真正开始返回。

在讲解答案时可以用下面的程序来帮助分析：

public class Test {

public static void main(String[] args) {

System.out.println(new Test().test());

}

int test() {

try {

return func1();

} finally {

return func2();

}

int func1() {

System.out.println("func1");

return 1;

}

int func2() {

System.out.println("func2");

return 2;

}

---- - ------- 执行结果 -------- - - -

func1

func2

结论： finally 中的代码比 return 和 brea k

语句后执行。

40 、 final,

final,

final, finally,

finally,

finally, finalize

finalize

finalize 的区别。

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

内部类要访问局部变量，局部变量必须定义成 final 类型，例如，一段代码 ……

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

finalize 是 Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提

供垃圾收集时的其他资源回收，例如关闭文件等。 JVM 不保证此方法总被调用

41 、运行时异常与一般异常有何异同？

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运

行错误。 java 编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异

常。

、

error

和

exception

有什么区别

error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。

exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

43 、 Java

Java

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

异常是指 java 程序运行时（非编译）所发生的非正常情况或错误，与现实生活中的事件很相似，现实生活中的事件可

以包含事件发生的时间、地点、人物、情节等信息，可以用一个对象来表示， Java 使用面向对象的方式来处理异常，它

把程序中发生的每个异常也都分别封装到一个对象来表示的，该对象中包含有异常的信息。

剩余96页未读，继续阅读

qcooler

粉丝: 1
资源: 17

Java面试必备知识点解析

java面试葵花宝典

JAVA面试葵花宝典.zip

java面试 葵花宝典 最详细版

java葵花宝典下载

qt 界面 葵花宝典

initle: qt样式表葵花宝典

qt样式表葵花宝典.pdf

vscode右键葵花宝典

《葵花宝典——wpf自学手册》 光盘内容下载

《葵花宝典_wpf自学手册》 pdf

最新资源

java面试葵花宝典最详细版

qt 界面葵花宝典

《葵花宝典——wpf自学手册》光盘内容下载