Java 面试题集锦

1基础部分

1.JAVA中的几种基本类型，各占用多少字节？

下图单位是bit,非字节 1B=8bit

2.String能被继承吗？为什么？

不可以，因为String类有final修饰符，而final修饰的类是不能被继承的，实现细节不允许改变。平常我们定义的String str=”abc”(直接赋一个字面量);其实和String str=new String(“abc”)(通过构造器构造)还是有差异的。

3.String， Stringbuffer， StringBuilder 的区别。

String 字符串常量(final修饰，不可被继承)，String是常量，当创建之后即不能更改。(可以通过StringBuffer和StringBuilder创建String对象(常用的两个字符串操作类)。)

==StringBuffer 字符串变量（线程安全）,==其也是final类别的，不允许被继承，其中的绝大多数方法都进行了同步处理，包括常用的Append方法也做了同步处理(synchronized修饰)。其自jdk1.0起就已经出现。其toString方法会进行对象缓存，以减少元素复制开销

==StringBuilder 字符串变量（非线程安全）==其自jdk1.5起开始出现。与StringBuffer一样都继承和实现了同样的接口和类，方法除了没使用synch修饰以外基本一致，不同之处在于最后toString的时候，会直接返回一个新对象

4.Java内部类和子类之间有什么区别？

内部类是指在一个外部类的内部再定义一个类，内部类对外部类有访问权限，可以访问类中定义的所有变量和方法。

子类是从父类（superclass）中继承的类，子类可以访问父类所有public和protected的字段和方法。

class Outer{ //外部类
class Inner{ //内部类 
}
}
class Other{ //外部其他类
}

5.Java语言中有哪些常见的访问说明符,有什么意义？

Java中的访问说明符是放在类名之前，用于定义访问范围的关键字，常见的访问说明符有以下几类：

Public：公共，能被项目中的任何一个Class、Method、Field访问。

Protected：受保护，能被同类或子类访问，不能从外部访问。

Default：默认，只能被同一个包的Class、Method、Field访问。

Private：私有，只能被本类访问

6.静态方法和静态变量的目的是什么？

答案：静态变量被类的所有实例共用，静态类只能访问类的静态变量，或调用类的静态方法

7.JDK 和 JRE 有什么区别？

JDK：Java Development Kit 的简称，Java 开发工具包，提供了 Java 的开发环境和运行环境。
JRE：Java Runtime Environment 的简称，Java 运行环境，为 Java 的运行提供了所需环境。
具体来说 JDK 其实包含了 JRE，同时还包含了编译 Java 源码的编译器 Javac，还包含了很多 Java 程序调试和分析的工具。简单来说：如果你需要运行 Java 程序，只需安装 JRE 就可以了，如果你需要编写 Java 程序，需要安装 JDK。

8.== 和 equals 的区别是什么？

「== 解读」

对于基本类型和引用类型 == 的作用效果是不同的，如下所示：

• 基本类型：比较的是值是否相同；
• 引用类型：比较的是引用是否相同

总结：

==对于基本数据类型，判断是数值是否相等，

对于引用数据类型，判断的是物理位置是否相等

而equals是Object类中的方法，Object是所有类的父类，所以类中都可以使用该方法，

但是，一般情况下，例如String类等，会对equals做重写，所以一般情况下

可以理解为equals是对比两个对象的内容是否一致

9.两个对象的 hashCode() 相同，则 equals() 也一定为 true，对吗？

不对，两个对象的 hashCode() 相同，equals() 不一定 true。

10.final 在 Java 中有什么作用？

final意为最终的，

修饰类：该类则无法被继承

修饰方法：该方法则无法被重写

修饰变量：该变量则为常量，初始化之后值就不能被修改

特点别的，final修饰变量是指引用不能改变，如果是一个引用数据类型，那么对象中的属性值是可以改变的

final int MAX = 9；
MAX = 20；//报错 不能更改

final Person person = new Person();
person.setAge(10);//这是可以的
person = new Person();//这是错误的

11.使用 final 关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

使用 final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改 
变的。例如，对于如下语句： 
final StringBuffer a=new StringBuffer("immutable"); 
执行如下语句将报告编译期错误： 
a=new StringBuffer(""); 
但是，执行如下语句则可以通过编译： 
a.append(" broken!"); 

12.int和Integer的区别?

1.int是基本数据类型 Integer是引用数据类型 是int的封装类
2.int的默认值是0；Integer的默认值是null
3.int类型的数据是数值，放在常量池中，
Integer实际是引用的是对象，内容在堆内，对象创建成功后，会通过指针指向对象

13.什么是重载和重写？

重写就是父类与子类之间的多态
重载是在一个类中对多态的体现
(1)方法重载是一个类中 定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方 法的重载(Overloading)。
(2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返 回值也一样的方法,就称为重写(Overriding)（子类的访问权限大于等于父类）。

14.面向对象有哪些特征？

1、封装:封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面；面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
2、继承:继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法；对象的一个新类可以从现有的类中派生，这个过程称为新类的基类(也就是父类)。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更合适特殊的需要。
3、多态性：多态性是指允许不用类的对象对同一消息做出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很多的解决了应用程序函数同名问题。

15.swtich选择语句中支持哪些数据类型？

在JDK1.5之前,switch循环只支持byte short char int，枚举五种数据类型.
jdk1.7开始支持String类型

16.堆栈的区别？

1.堆内存用来存储Java中的对象。无论是成员变量，还是类变量，它们指向的对象都存储在堆内存中。
2.栈内存用来存储局部变量和方法调用。
3.栈内存归属于单个线程，每个线程都会有一个栈内存，其存储的变量只能在其所属线程中可见，即栈内存可以理解成线程的私有内存。
4.堆内存中的对象对所有线程可见。堆内存中的对象可以被所有线程访问。

16.接口和类有什么区别和相同点？
1.不同点：
接口不能直接实例化。
接口不包含方法的实现。
接口可以多继承，类只能单继承。
类定义可以在不同的源文件之间进行拆分。
2.相同点：
接口、类和结构都可以从多个接口继承。
接口类似于抽象基类：继承接口的任何非抽象类型都必须实现接口的所有成员。
接口和类都可以包含事件、索引器、属性。

17.Throw 和 Throws 的区别?

throw 是抛出自定义异常的,throws 是在方法上抛出异常的.

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

char 型变量是用来存储 Unicode 编码的字符的， unicode 编码字符集中包含了汉字，所以，
char 型变量 中当然可以存储汉字啦。 不过， 如果某个特殊的汉字没有被包含在
unicode 编码字符集中， 那么，这个 char 型变量中就不能存储这个特殊汉字。补充说明：
unicode 编码占用两个字节，所以， char 类型的变量也是占用两个字节。

19.一个 ".java" 源文件中是否可以包括多个类（不是内部 类）？有什么限制？

可以有多个类，但只能有一个 public 的类，并且 public 的类名必须与文件名相一致。

20.说说 & 和&& 的区别

& 和&& 都可以用作逻辑与的运算符，表示逻辑与（ and），当运算符两边的表达式的结果都为
true 时， 整个运算结果才为 true，否则，只要有一方为 false，则结果为 false。 && 还具有短路的功能， 即如果第一个表达式为 false，则不再计算第二个表达式， 例如，对于 if(str != null && !str.equals(“”))表达式，当 str 为 null 时，后面的表达式不会执行，所以不会出现 NullPointerException 如果将 && 改为 &，则会抛出 NullPointerException 异常。 If(x==33 & ++y>0) y 会增长， If(x==33 && ++y>0) 不会增长。
& 还可以用作位运算符

21.在 JAVA 中如何跳出当前的多重嵌套循环？

在 Java 中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中
使用带有标号的 break 语句，即可跳出外层循环。例如，
 

ok: 
 for(int i=0;i<10;i++) { 
    for(int j=0;j<10;j++) { 
        System.out.println( “i= ” + i + “,j=” + j); 
        if(j == 5) break ok; 
    } 
 }

另外，我个人通常并不使用标号这种方式，而是让外层的循环条件表达式的结果可以受到里层循环体

代码的控制，例如，要在二维数组中查找到某个数字。

int arr[][] = {{1,2,3},{4,5,6,7},{9}}; 
boolean found = false; 
for(int i=0;i<arr.length && !found;i++) { 
    for(int j=0;j<arr[i].length;j++){ 
            System.out.println( “i= ” + i + “,j=” + j); 
            if(arr[i][j] == 5) { 
            found = true; 
            break; 
        } 
    } 
 }

21.short s1 = 1; s1 = s1 + 1; 有什么错 ? short s1 = 1; s1 += 1; 有什么错 ?

对于 short s1 = 1; s1 = s1 + 1; 由于 s1+1 运算时会自动提升表达式的类型，所以结果是

int 型，再赋值 给 short 类型 s1 时，编译器将报告需要强制转换类型的错误。

对于 short s1 = 1; s1 += 1; 由于 += 是 java 语言规定的运算符， java 编译器会对它进行特殊处理，因此

可以正确编译。

23.是否可以从一个 static 方法内部发出对非 static 方法的 调用？

不可以。 因为非 static 方法是要与对象关联在一起的， 必须创建一个对象后， 才可以在该对象上进行方法调用，而 static 方法调用时不需要创建对象，可以直接调用。也就是说，当一个 static 方法被调用时，可能还没有创建任何实例对象，如果从一个 static 方法中发出对非 static 方法的调用，那个非 static 方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个 static 方法未创建实例对象时内部无法发出对非 static 方法的调用

24.当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回

变化后的结果，那么这里到底是值传递还是引用传递？

答：是值传递。 Java 语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数 被传递到方法中时， 参数的值就是对该对象的引用。 对象的属性可以在被调用过程中被改变， 但对对象引用的改变是不会影响到调用者的

25.接口和抽象类有什么区别？

1、实现：抽象类的子类使用 extends 来继承；接口必须使用 implements 来实现接口。

2、构造函数：抽象类可以有构造函数；接口不能有。

3、实现数量：类可以实现很多个接口；但是只能继承一个抽象类。

4、访问修饰符：接口中的方法默认使用 public 修饰；抽象类中的方法可以是任意访问修饰符。

5、变量：接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

6、级别：抽象类和接口都是用来抽象具体对象的，但是接口的抽象级别最高

26.常见的异常类有哪些？

1.NullPointerException：空指针异常；

2.SQLException：数据库相关的异常；

3.IndexOutOfBoundsException：数组下角标越界异常；

4.FileNotFoundException：打开文件失败时抛出；

5.IOException：当发生某种IO异常时抛出；

6.ClassCastException：当试图将对象强制转换为不是实例的子类时，抛出此异常；

7.NoSuchMethodException：无法找到某一方法时，抛出；

8.ArrayStoreException：试图将错误类型的对象存储到一个对象数组时抛出的异常；

9.NumberFormatException：当试图将字符串转换成数字时，失败了，抛出；

10.IllegalArgumentException 抛出的异常表明向方法传递了一个不合法或不正确的参数。

11.ArithmeticException当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例。

27.抽象类能使用 final 修饰吗？

不能，定义抽象类就是让其他类继承的，如果定义为 final 该类就不能被继承，这样彼此就会产生矛盾，所以 final 不能修饰抽象类，

28.String 类的常用方法都有那些？

indexOf()：返回指定字符的索引。

charAt()：返回指定索引处的字符。

replace()：字符串替换。

trim()：去除字符串两端空白。

split()：分割字符串，返回一个分割后的字符串数组。

getBytes()：返回字符串的 byte 类型数组。

length()：返回字符串长度。

toLowerCase()：将字符串转成小写字母。

toUpperCase()：将字符串转成大写字符。

substring()：截取字符串。

equals()：字符串比较。

29.构造方法的特点？

1、构造方法名一定与类同名

2、构造方法无返回值类型（void 也不行）

3、构造方法可以没有（如果在类中没有提供任何构造方法，java虚拟机会默认创建一个无参构造方法），也可以有多个构造方法，他们之间构成重载关系

4、如果定义有参构造函数，则无参构造函数将被自动屏蔽

5、构造方法不能被继承

6、构造方法不能手动调用，在创建类实例的时候自动调用构造方法

30.在Java中，子类可以从父类中继承哪些？

1）继承public和protected修饰的属性和方法，不管子类和父类是否在同一个包里。

（2）继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里。

（3）无法继承private修饰的属性和方法。

（4）无法继承父类的构造方法。

31.简述数据类型转换的方式

2种

自动类型转换 ：

在基本数据类型中：小空间类型数据向大空间类型可以之间转换

在引用数据类型中：比如在继承关系中，

父类的引用可以直接指向子类的对象

这种关系也发生在接口的实现中，

强制类型转换

在基本数据类型中：大空间类型数据向小空间类型数据转换，

要保证转换的数据是合法的，否则会发生内存溢出

语法： 小数据类型 变量 =(小数据类型) 大类型数据

在引用数据类型中：一般也发生在继承关系中，

如果父类的对象要转化为子类的对象 这时可以使用强制类型转换

语法：子类类型 对象 = （子类类型）父类对象

前提：要保证父类的对象的实体确实与目标子类为同一个类型

可以通过instanceOf二元表达式进行判断

32 构造方法能否被重写

不能被重写

首先构造方法的名字要与该类的方法名一致，

其次，重写要求发生在继承关系中，

且要求子类的方法名字要与被重写的父类的名字一致，

这样就不能保证构造方法与类名一致的特性，

所以不可以被重写，

但是在子类中可以使用super()进行对父类构造方法的调用

33 简述重载和重写的异同

重载：overload，发生在同一作用域，

且要求方法的参数列表、参数个数、参数顺序必须保证其中的一个不同

对于方法的返回值重载没有要求

重写：override，发生在继承关系中，

重写要求方法名字，返回值，参数列表等必须与父类完全一致，

且子类重写的方法的访问权限必须大于等于父类该方法的访问权限。

34.简述静态变量和实例变量

静态变量：是使用static修饰的变量，可以理解为类变量。

即可以直接通过类名.变量的方式，直接进行访问

并且在JVM加载该类时，会首先创建静态变量，

存放在静态区内，等待被调用。

使用static修饰变量，其值被所有调用者共享

实例变量：没有使用static修饰的成员变量，称之为实例变量，可以理解为对象变量。

即如果要使用实例变量，只能通过创建对象的方式，使用对象.变量的方式

对其进行访问

35.简述super和this关键字

super:指代父类对象

在子类中可以通过super关键字访问到父类中的属性或方法

如果是访问构造方法，可以直接使用super([参数])

如果是访问父类中公开的属性：super.属性

如果是访问父类中公开的方法：super.方法()

一般情况下会写在方法的第一行

this：代表当前类对象

该类中，所有的资源都可以使用this进行访问

查找范围：

super：只会父类里面

this： 先在当前类对象中查找资源，父类中再去查找

36.简述继承的特点

1.在Java中，类是单继承，但是允许多层继承

2.子类只能拥有一个父类，父类可以有多个子类

3.子类可以直接访问父类中公开的属性和方法

4.对于父类中私有化的属性和方法，子类无权直接访问，但仍可以继承

37.两个对象的 hashCode()相同，则 equals()也一定为 true，对吗？为什么

不对的

一组数据的hashCode相等，不能代表他们的值也相等

重地 --> 通话

38.java中操作字符串的类都有哪些，简述他们之间的区别

String ： 不可改变字符串序列

StringBuffer 可改变 线程安全的

StringBuilder 可改变 线程不安全的

如果在多线程的情况下 建议使用 StringBuffer

如果在单线程的情况下 建议使用 StringBuilder

39.String str="i"与 String str=new String("i")一样吗？

不一样

String str="i" --常量池中

String str=new String("i") --"i"常量池中；new String("i")--堆中

40.抽象类必须要有抽象方法吗？

错误的，抽象类中可以包含普通方法 也可以包含抽象方法

41 .int转String的几种方式

1) String str = 5 +"";

2)String str = String.valueOf(5);

3)String str = Integer.toString(5);

42.String转int的2种方式

1) int i = Integer.parseInt(String str);

2)int i = Integer.valueOf(String str);

43.Integer转String的几种方式

1)String str = Integer.toString(num);

2)Integer inte = 3;

String str = inte.toString();

3)String str = String.valueOf(num);

4)Integer inte = 3;

String str = inte+"";

44.String转Integer的几种方式

1)Integer inte = Integer.valueOf(String str);

45.Math.round(11.5) 等於多少 ? Math.round(-11.5) 等於多少?

Math 类中提供了三个与取整有关的方法：

ceil 、floor 、round，这些方法的作用与它们的英文名称的含义 相 对 应 ，例 如 ：

ceil 的 英 文 意 义 是 天 花 板 ， 该 方 法 就 表 示 向 上 取 整 ， Math.ceil(11.3) 的 结 果为12, Math.ceil(-11.3) 的结果是 -11；

floor 的英文意义是地板，该方法就表示向下取整， Math.ceil(11.6) 的结果为 11,Math.ceil(-11.6) 的结果是 -12；

最难掌握的是 round 方法，它表示“四舍五入” ，算法为 Math.floor(x+0.5) ， 即将原来的数字加上 0.5 后再向下取整，所以， Math.round(11.5) 的结果为 12，Math.round(-11.5) 的 结果为 -11。

46.abstrat的方法是否可以同时使用static修饰

答：不可以，使用static修饰的方法必须是类级别的，可以先加载在静态区，而抽象的方法需要靠子类重现后实现代码块的具体内容，两者编译和加载时机不同，因此不可以

47.如何把一段逗号分割的字符转换为一个数组

可以使用字符串.split(",")方法

48.数组有没有 length()这个方法 ? String 有没有 length()这 个方法？

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

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

finally 中的代码比 return 和 break 语句后执行

案例1：

public class Test { 
/** 
 * @param args add by zxx ,Dec 9, 2008 
 */ 
public static void main(String[] args) { 
// TODO Auto-generated method stub 
  System. out .println( new Test().test());; 
} 
  static int test()  { 
    int x = 1; 
    try{ 
      return x; 
    } finally{ 
      ++x; 
    } 
  } 
}
执行结果：

案例2：

public class Test { 
  /** 
   * @param args add by zxx ,Dec 9, 2008 
   */ 
  public static void main(String[] args) { 
  // TODO Auto-generated method stub 
      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; 
  } 
}

50.运行时异常与一般异常有何异同

异常可以分为运行时异常和编译时异常，运行时异常指发生在代码运行的时候出现的异常，比如： 数组下标越界，空指针异常，类型转换异常等

编译时异常一般指，在编译阶段编译器就要求必须声明和抛出的异常，比如FileNotFoundException：文件找不到的异常

SQLException：数据库操作异常

DataFormatException：数据格式化异常等

他们的主要区别在于编译时异常是在编译阶段必须要抛出和处理的，而运行时异常则不需要

51.error和exception有什么区别

异常有自己的体系树，其中最上面的是Throwable，在他的下边分为error和exception。

error表示恢复不是不可能，但是一旦发生，都是很严重的问题。比如说内存溢出等。一般不可能指望程序能处理这样的情况。

exception表示一种设计或实现问题，也就是我们俗称的异常，一般我们会进行异常的抛出或捕获处理，以此来解决

52.Java 语言如何进行异常处理，关键字throws，throw try catch，finally分别代表什么意义？try块中可以抛出异常吗

Java 通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java 中，每个异常都是一个对象，它是Throwable 类或其子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。

Java 的异常处理是通过5 个关键词来实现的：try、catch、throw、throws和finally。

try用来指定一块预防所有“异常”的程序；

catch 子句紧跟在try块后面，用来指定你想要捕捉的“异常”的类型；

throw 语句用来明确地抛出一个“异常”；

throws用来标明一个成员函数可能抛出的各种“异常”；

finally 为确保一段代码不管发生什么“异常”都被执行一段代码；

其中catch语句块如果是多个的话，必须按照子类到父类的顺序进行异常捕获，catch语句块可以没有，也可以有多个，如果没有的话 必须要有finally语句块

try {
    异常捕获代码
    }catch(异常类型子类  e){
    
    }catch(异常类型父类  e){
    
    }finally{

}

public void test() throws 异常类型{

      throw 异常
    
}

另外 try语句块中时可以抛出异常的

53.简述什么单例模式

1） 单例模式特点：

– 拥有一个私有构造方法

– 提供一个自身静态私有的成员变量

– 提供一个公有的静态的方法(返回实例化后的对象)

public class Singleton {
    /*• 单例模式实现：
    –   拥有一个私有构造方法 
    –   提供一个类型为自身的  静态的私有的成员变量(属性)
    –   提供一个公有的静态的方法(返回实例化后的对象)*/
    //step 2 提供一个类型为自身的  静态的私有的成员变量
    private static final Singleton instance=new Singleton();
    //step 1拥有一个私有构造方法 
    private Singleton (){
        
    }
    //step 3提供一个公有的静态的方法
    public static Singleton getSingleton(){
        return instance;
    }
        public static void main(String[] args) {
        Singleton s1=Singleton.getSingleton();
        Singleton s2=Singleton.getSingleton();
        System.out.println(s1);
        System.out.println(s2);
        
    }
}

• ---

  
  ....博主太懒了字数太多了，不想写了....文章已经做成PDF，有需要的朋友可以私信我免费获取！