Java基础面试题库

面向对象

一、封装：指隐藏成员的属性和实现细节，仅对外提供公共的访问方式。

1.封装的好处

(1)隐藏实现细节，仅对外提供公共访问方式

(2)提高代码的复用性

(3)提高代码的安全性

2.封装的原则

(1)将不需要对外提供的内容都隐藏起来

(2)把属性隐藏，仅对外提供公共访问方式

3.private关键字

(1)是一个权限修饰符

(2)可以修饰成员（成员变量和成员方法）

(3)被private修饰的成员只能在本类中才能访问

4.static关键字特点

(1)随着类的加载而加载

(2)优先于对象存在

(3)被类的所有对象共享

(4)可以通过类名调用

注意事项：

(1) 在静态方法中是没有this关键字的

静态是随着类的加载而加载，this是随着对象的创建而存在，且static优先于 对象存在。

(2) 静态方法只能访问静态的成员变量和静态的成员方法

5.如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢？如何解决？

报错。

A：在父类中加一个无参构造方法

B：通过使用super关键字去显示调用父类的带参构造方法

C：子类通过this去调用本类的其他构造方法（子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化）

注意事项：this(…)或super(…)必须出现在第一条语句上

如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化。

二、继承：让类与类之间产生关系，子父类

1.继承的好处

(1)提高代码的复用性

(2)提高代码的维护性

(3)让类与类之间产生关系，是多态的前提

2.继承的弊端

(1)类的耦合性增强了 (开发原则：低耦合，高内聚)

(2)打破了封装性

3.java中继承的特点

(1)Java只支持单继承，不支持多继承

(2)Java支持多层继承

(3)如果想用这个体系的所用功能，用最底层的类创建对象

(4)如果想看这个体系的共性功能，看最顶层的类

4.Java中继承的注意事项

(1)子类只能继承父类的所有非私有的成员（成员变量和成员方法）

(2)子类不能继承父类的构造方法，但可以通过super关键字去访问父类构造方法

(3)不要为了部分功能而去继承

继承其实体现的是“is，a”的关系。

5.super关键字：代表父类存储空间的标识

注意：子类每一个构造方法的第一条语句默认都是super(…)

6.方法重写(Override)：子类中出现了和父类中方法声明一模一样的方法

使用特点：

A：如果方法名不同，就调用对应的方法

B：如果方法名相同，最终使用的是子类自己

注意事项：

A：父类中私有方法不能被重写，因为父类私有方法子类根本就无法继承

B：子类重写父类方法时，访问权限不能更低，最好一致

C：父类静态方法，子类也必须通过静态方法进行重写

7.final关键字：可以修饰类、方法、变量

(1)final修饰类，该类不能被继承

(2)final修饰方法，该方法不能被重写

(3)final修饰变量，该变量不能被重新赋值，变量变为常量

8.一个类的静态代码块、构造代码块和构造方法的执行流程

静态代码块 > 构造代码块 > 构造方法

静态代码块：只执行一次

构造代码块：每次调用构造方法都执行

静态的内容是随着类的加载而加载

静态代码块的内容会优先执行

子类初始化之前先会进行父类的初始化

9.继承中构造方法的关系

A：子类中所有的构造方法默认都会访问父类中空参数的构造方法

B：为什么呢？

因为子类会继承父类中的数据，可能还会使用父类的数据，所以，子类初始 化之前，一定要先完成父类数据的初始化。

三、多态：同一个对象(事物)，在不同时刻体现出来不同状态

1.多态的前提

(1)要有继承关系

(2)要有方法重写

(3)父类引用指向子类对象

2.多态的好处

(1)提高代码的维护性

(2)提高代码的扩展性

3.多态的弊端

不能使用子类的特用功能

若想使用：A：创建子类对象调用方法即可（但很多时候不合理，而且太占内存）

B：把父类的引用强制转换为子类的引用（向下转型）

四、抽象类(abstract)

1.概念

一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

2.抽象类的特点

(1)抽象类和抽象方法必须使用abstract关键字修饰

(2)抽象类中不一定有抽象方法，但是有抽象方法的类必须定义为抽象类

(3)抽象类不能实例化（因为它不是具体的）

(4)抽象类的子类

A：如果不想写抽象方法，该子类是一个抽象类

B：重写所有的抽象方法，这个时候子类是一个具体的类

3.一个抽象类中如果没有抽象方法，可不可以定义为抽象类？如果可以。有什么意义？

可以。这么做的目的只有一个，就是不让其他类创建本类对象，交给子类完成。

4.abstract不能和哪些关键字共存？（static、final和private）

1. abstract：被abstract修饰的方法没有方法体

   static：被static修饰可以用类名.调用，但是类名.调用抽象方法没有意义

2. abstract：被abstract修饰的方法强制子类重写

   final：被final修饰的不让子类重写，所以两者是矛盾的

3. abstract：被abstract修饰是为了让子类看到并强制重写

   private：被private修饰的不让子类访问，所以两者是矛盾的

五、接口(interface、implements)

1.接口的特点

(1)接口用关键字interface表示（interface 接口名 {}）

(2)类实现接口用implements表示（class 类名 implements 接口名 {}）

(3)接口不能实例化

(4)接口的子类

A：可以是抽象类，但是意义不大

B：可以是具体类，要重写接口中的所有抽象方法

2.抽象类和接口的区别

六、内部类

1.内部类访问特点

(1)内部类可以直接访问外部类的成员，包括私有

(2)外部类要访问内部类的成员，必须创建对象

外部类名.内部类名 对象名 = 外部类对象.内部类对象；

外部类名.内部类名 对象名 = new 外部类名().new 内部类名()；

2.内部类位置

成员位置：在成员位置定义的类

局部位置：在局部位置定义的类

3.成员内部类

4.局部内部类

(1)可以直接访问外部类的成员

(2)在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

面试题：局部内部类访问局部变量的注意事项？

A：局部内部类访问局部变量必须使用final修饰

B：为什么呢？

局部变量是随着方法的调用而调用，随着调用完毕而消失。

而堆内存的内容并不会立即消失，所以，我们加final修饰。

5.匿名内部类：就是内部类的简化写法

(1)前提：存在一个类或者接口（这里的类可以是具体类也可以是抽象类）

(2)格式：

(3)本质：是一个继承了该类或者实现了该接口的子类匿名对象

七、修饰符

1.修饰符

权限修饰符：private，默认的，protected，public

状态修饰符：static，final

抽象修饰符：abstract

2.类

权限修饰符：默认的，public

状态修饰符：final

抽象修饰符：abstract

3.成员变量

权限修饰符：private，默认的，protected，public

状态修饰符：static，final

4.成员方法

权限修饰符：private，默认的，protected，public

状态修饰符：static，final

抽象修饰符：abstract

5.构造方法

	本类	同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

八、成员变量、局部变量和静态变量的区别

	在类中的位置不同	在内存中的位置不同	生命周期不同	初始化值不同	调用方式不同
成员变量 (实例变量)	类中方法外	堆内存	随着对象的创建而存在，随着对象的消失而消失	有默认初始化值	只能通过对象名调用
局部变量	方法定义中或方法声明上	栈内存	随着方法的调用而存在，随着方法的调用完毕而消失	没有默认初始化值，必须定义、赋值，然后才能使用
静态变量 (类变量)	类中方法外	方法区的静态区	随着类的加载而加载，随着类的消失而消失	有默认初始化值	可以通过类名调用，也可以通过对象名调用

集合

一、集合特点

只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

二、数组和集合的区别

1.长度区别

数组长度固定，集合长度不固定（可变）

2.内容不同

数组存储的是同一种类型的元素

集合可以存储不同类型的元素

3.元素的数据类型问题

数组可以存储基本数据类型(存储的是值)、引用数据类型(存储的是地址值)

集合只能存储引用数据类型(当存储基本类型时，会自动装箱变成对象)

三、泛型：限定存储的数据的类型

1.泛型的好处

(1)提高安全性（将运行期的错误转换到编译器）

(2)省去强转的麻烦

2.基本使用：<>中方的必须时引用数据类型

3.使用注意事项

前后的泛型必须一致，或者后面的泛型可以省略不写

四、增强for

1.格式：

2.好处：简化了数组和集合的遍历

3.弊端：增强for的目标不能为null

如何解决？ 对增强for的目标先进行不为null的判断，然后再使用

五、迭代器

1.Iterator<> it = c.iterator();

2.并发修改异常

ConcurrentModificationExCxception：当方法检测到对象的并发修改，但不允许这 种修改时，抛出此异常。

产生原因：迭代器是依赖于集合而存在的，在判断成功后，集合重新添加了元素，而迭代器不知道，所以就报错了，这个错叫并发修改异常。

如何解决呢？

A：迭代器迭代元素，迭代器修改元素（元素是跟在刚才迭代的元素后面的）

B：集合遍历元素，集合修改元素(普通for)（元素在最后添加的）

3.三种迭代能否删除

(1)普通for循环：可以删除，但是索引要–

(2)迭代器：可以删除，但是必须使用迭代器自身的remove方法，否则会出现并发修改异常

(3)增强for循环：不能删除

六、Map接口和Collection接口的区别

Map：双列；键唯一；数据结构（hash算法）只针对键有效，跟值无关；存储的是键 值对形式的元素，键唯一，值可重复

Collection：单列；子体系Set是唯一的；数据结构是针对元素有效

七、HashMap、Hashtable和ConcurrentHashMap的区别

HashMap：JDK1.2出现；线程不安全，效率高；可以存储null键和null值

Hashtable：JDK1.0出现；线程安全，效率低；不可以存储null键和null值

ConcurrentHashMap：具有HashMap的功能，但是线程安全

八、Collection和Collections的区别

Collection：是单列集合的顶层接口，有子接口List和Set

Collections：是针对集合操作的工具类，有对集合进行排序和二分查找的方法

排序：Collections.sort(list);

最大值：Collections.max(list);

反转：Collections.reverse(list);

二分查找：Collections.binarySearch(list,30);

随机置换：Collections.shuffle(list);

九、Collection集合

两种排序方式的区别：

A：TreeSet构造函数什么都不传，默认按照类中Comparable的顺序（没有就报错 ClassCastException）

B：TreeSet如果传入Comparator，就优先按照Comparator

十、Map集合

异常

一、异常分类

Java中常见的运行期异常：

ClassCastException 类型转换异常

NumberFormatException 数字转换异常

ArrayIndexOutOfBoundsException 数组脚标越界异常

IndexOutOfBoundsException 脚标越界异常

NullPointerException 空指针异常

ConcurrentModificationException 并发性修改异常

ArithmeticException 除数为0异常

ConnectException 拒绝访问异常

异常名命名注意事项：

(1) 能明确的尽量明确，不要用大的来处理

(2) 平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面

二、编译时异常和运行时异常的区别？

编译期异常：Java程序必须显示处理，否则程序就会发生错误，无法通过编译

运行期异常：无需显示处理，也可以和编译时异常处理一样

三、final、finally和finalize的区别？

四、如果catch里面有return语句，请问finally里面的代码还会执行么？ 如果会，请问是在return前还是return后？

finally里面的代码还会执行；在return前（准确的说，应该是中间）

五、throw和throws的区别？

常见API

一、Object

所有类的直接或者间接父类，Java认为所有的对象都具备一些基本的共性内容，这些内容可以不断的向上抽取，最终就抽取到了一个最顶层的类中的，该类中定义的就是所有对象都具备的功能。

1.public int hashCode()：返回该对象的哈希码值

2.public boolean equals(Object obj)：比较两个对象是否相等，内部比较两个对象地址

3.public String toString()：将对象变成字符串，默认返回地址值

通常equals，toString，hashCode在应用中都会被复写，建立具体对象的特有的内容

二、String、StringBuffer和StringBuilder

1.String、StringBuffer和StringBuilder的区别？

(1)String是内容不可变的，StringBuffer和StringBuilder长度和内容可变，且使用StringBuffer和StringBuilder做字符串拼接，不会浪费太多资源

(2)StringBuffer是线程同步的，数据安全，效率低；StringBuilder是线程不同步的，数据不安全，效率高

2.String特点

(1)字符串一旦被赋值，就不能改变（是内容不能改变，不是引用不能改变）

(2)字面值作为字符串对象和通过构造方法创建对象的不同

3.String s1 = new String(“hello”);和String s2 = “hello”;的区别？

(1)String s1 = new String(“hello”);创建了两个对象，一个字符对象，一个字符对象引用对象

(2)String s2 = “hello”;创建了一个对象，一个字符对象

(3)System.out.println(s1 == s2); // false

(4)System.out.println(s1.equals(s2)); // true

4.StringBuffer和数组的区别？

二者都可以看成是一个容器，装其他的数据，但是，StringBuffer的数据最终是一个字符串数据；而数组可以放多种数据，但必须是同一种类型

三、基本数据类型对象包装类

1.好处

(1)可以通过对象中的属性和行为操作基本数据。

(2)可以实现基本数据类型和字符串之间的转换。

2.转换

byte(Byte) short(Short) int(Integer) long(Long)

float(Float) double(Double) char(Character) boolean(Boolean)

3.包装类缓冲池

为了优化，虚拟机为包装类提供了缓冲池

Integer a1 = 40;

Integer a2 = 40;

System.out.println(a1 == a2);       // true

Integer a3 = 200;

Integer a4 = 200;

System.out.println(a3 == a4);       // false

包装类缓存的范围如下：

包装类	缓存范围
Byte	-128~127
Short	-128~127
Integer	-128~127
Long	-128~127
Character	0~127

4.int 和 Integer 有什么区别？

Java 提供两种不同的类型：引用类型和原始类型（或基本类型）。int是java的原始数据类型，Integer是java为int提供的封装类。

四、Arrays、System、Math、Date和Calendar

1.Arrays：用于操作数组对象的工具类，里面都是静态方法

(1)public static String toString(int [] a)：把数组转换成字符串

(2)public static void sort(int [] a)：对数组进行排序

(3)public static int binarySearch(int [] a,int key)：二分查找

(4)public static List asList(T… a)：把数组转成集合

2.System：包含一些有用的类字段和方法，属性和行为都是静态的(不能被实例化)

(1)public static void exit(int stratus)：终止当前正在运行的JVM(System.exit(0); )

(2)public static long currentTimeMillis()：返回当前毫秒值

3.Math：用于数学运算的工具类，属性和行为都是静态的，该类是不允许final继承

Math.round(11.5)等于多少? Math.round(-11.5)等于多少？为什么？

(1)Math.round(11.5)=12;Math.round(-11.5)=-11;

(2)round方法返回与参数最接近的长整数，参数加1/2后求其floor

4.Date：日期类，表示特定的瞬间，精确到毫秒(自1970年1月1日00:00:00 GMT)

• DateFormat

  final String format(Date date)：将日期对象转换成字符串

  Date parse(String source)：将日期字符串转换成日期对象

• SimpleDateFormat（自定义日期格式）

  SimpleDateFormat()：默认模式

  SimpleDateFormat(String pattern)：给定的模式

5.Calendar：日历类，抽象类

IO流

一、File类

二、递归：方法定义中调用方法本身的现象

递归注意事项：（解决思想：找到出口，找到规律）

要有出口，否则是死递归；次数不要太多，否则就内存溢出；构造方法不能递归使用

三、字节流

四、字符流 = 字节流 + 编码表

五、Properties集合

1.持久的属性集合类，是Hashtable的子类（说明是一个Map集合，但是没有泛型）

2.Properties和IO流的结合使用

(1)把键值对形式的文本文件内容加载到集合中（这里必须是Properties集合）

public void load(Reader reader)

public void load(InputStream inStream)

(2)把集合中的数据存到文本文件中

public void store(Writer writer,String comments)

public void store(OutputStream out,String comments)

六、数据写成功后，为什么要close()？

1.让流对象变成垃圾，这样就可以被垃圾回收器回收了

2.通知系统去释放跟文件相关的资源

七、close()和flush()的区别？

1.close()关闭流对象，但是先刷新一次缓冲区，关闭之后，流对象不可以再继续使用

2.flush()仅仅刷新缓冲区，刷新之后，流对象还可以继续使用

八、如何实现数据的换行

1.写入换行符（但是有些文本文件打开是可以的，通过windows自带的记事本却不行，为什么？）因为不同的系统针对不同的换行符号识别是不一样的。

Windows：\r\n Linux:\n Mac:\r

2.字符缓冲区的特殊方法 public void newLine();

九、如何实现数据的追加写入？

用构造方法带第二个参数是true的情况即可 public FileOutputStream(String name,true)

十、read()方法读取的是一个字节，为什么返回的是int，而不是byte？

因为字节输入流可以操作任意类型的文件，文件底层都是以二进制形式存储的，如果每次读取都返回byte，有可能在读到中间的时候遇到11111111，那么这个11111111是byte类型的-1，我们的程序是遇到-1就会停止不读了，后面的数据就读不到了。

十一、键盘录入的三种方式

1.main方法的args接收参数 Java HelloWorld hello world java

2.Scanner（JDK5以后）

3.通过字符缓冲流包装标准输入流实现

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

十二、输出语句的原理、如何使用字符流输出数据？

1. PrintStream ps = System.out;

   Ps.println(“HelloWorld”);

   System.out.println(“HelloWorld”);

2. 把System.out用字符缓冲流包装一下使用

   BufferedWriter bw = new BufferedWriter (new BufferedWriter(new OutputStreamWriter(System.out));