JAVA面试题总结基础篇（一）（附答案）

JAVA面试题基础篇（一）

---

---

前言

到了大三的学期的暑假，即将面临找工作的考验。希望这份面试资料能够帮住大家学到自己的知识盲区。加油，我命由我不由天！！！

一、java语言有哪些特点

1、有丰富的类库，简单易学
2、面向对象，Java最重要的特性，让程序解耦，耦合性更低，类聚性更高
3、与平台无关（JVM是java跨平台使用的脚本）
4、可靠安全
5、支持多线程

二、面向对象以及面向过程的区别

面向过程：面向过程是分析解决问题的步骤，然后用函数把问题一步步实现，然后在使用的时候一一调用即可，特点是性能较高，使用单片机和嵌入式一般使用面向过程开发。

面向对象：面向对象是把构成的问题分解成各个对象，而建立对象的目的也不是一一去实现，而是为了描述某个事物在解决整个问题的过程中发生的行为，面向对象有封装、继承、多态的特性，所以易维护、易复用、易扩展。可以设计出低耦合的系统。但是性能上来说要比面向过程要低。

三、继承、封装、多态

1、封装（俩层含义）

一层含义是把对象的属性和行为作为一个整体，将这俩者封装到一个不可分割的独立单元（即对象中i）。
另一层含义为隐藏，把不需要让外界知道的信息隐藏起来。有些对象的属性以及行为允许让外界知道但不允许更改。而另一些对象的属性不允许外界知道，或只允许使用对象的功能，而尽量隐藏对象实现的细节

优点：
1、好的封装能减少耦合
2、类内部的结构可以自由改动
3、可以对成员变量更加精确的控制
4、隐藏实现信息细节

封装的使用细节：
1、一般使用private访问权限
2、提供get、set方法使用，这些方法通常使用public修饰。
3、一些只用于本类下的辅助功能，使用private，希望其他类也能调用则使用public修饰。

2、继承

继承是java面向对象编程的基石，因为它能允许创建分等级层次的类。
继承就是子类继承父类的功能以及特性，使得子类拥有父类的方法，并且能完成相同的行为。
需要注意的是继承不支持多继承，但支持多重继承。

优点：
1、提高了代码的复用性
2、提高了代码维护性
3、使得类和类产生了关系，是多态的前提

特性：
1、子类拥有父类非private的方法以及属性
2、子类可以拥有自己的方法和属性，所以子类比父类更加强大
3、子类可以用自己的方法实现父类的方法，即重写
4、java继承是单继承的，但是可以多次继承，例如：A继承了B，而B又继承了C，那么A也具有C的方法 以及属性。
5、继承的俩个关键字，extends和implements这俩个关键字来继承，而所以的类都是继承与Java.lang.object该类。这是所以的类的鼻祖，无需关键字继承。
6、继承的弊端就是提高的耦合性

3、多态

多态是同一个行为具有不同表现形式或形态能力。
方法重载：在一个类中可以有多个相同名字的方法，但方法的参数不同，所以实现的功能也不同。
对象多态：子类对象可以与父类对象进行转换，而且根据其使用的子类不同完成的功能也不同（重写父类的方法）。
（面试题）什么是多态？实现多态有哪些方法？
多态是面向对象的最后一个主要特征，它主要分为俩个部分：
1、重载，同一个方法名称，可以根据不同的参数而有不同的功能。
2、覆写，同一个方法根据子类的不同实现不同的功能

多态的优点：
1、消除类型之间的耦合关系
2、可替换性
3、可扩充性
4、接口性
5、灵活性
6、简化性
多态存在的三个必要条件
1、继承
2、重写
3、父类引用指向子类对象

四、八种基本数据类型的大小，以及他们的封装类

注：
1、int是基本数据类型，Integer是int的封装类，是引用类型。int的默认值为0，而integer的默认值为null，所以integer能区分值为0和null的区别

五、instanceof关键字的作用

instanceof是java的一个双目运算符，用来测试一个对象是否为一个实例。例如：

boolean result = obj instanceof Class

其中obj为一个对象，Class为一个类，当obj为Class的对象时，或是其直接子类或者间接子类，或者是其接口的实现类，结果都为true，否则返回false。

注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能确定类型，则通过编译，具体看运行时定。

int i = 0;
System.out.println(i instanceof Integer);//编译不通过 i必须是引用类型，不能是基本类型
System.out.println(i instanceof Object);//编译不通过

Integer integer = new Integer(1);
System.out.println(integer instanceof Integer);//true

//false ,在 JavaSE规范 中对 instanceof 运算符的规定就是：如果 obj 为 null，那么将返
回 false。
System.out.println(null instanceof Object);

六、java的自动装箱与拆箱

装箱就是自动将基本数据类型转换为包装器类型（int–>Integer）；调用方法：Integer的
valueOf(int) 方法
拆箱就是自动将包装器类型转换为基本数据类型（Integer–>int）。调用方法：Integer的
intValue方法

面试题1： 以下代码会输出什么？

public class Main {
 public static void main(String[] args) {
 
 Integer i1 = 100;
 Integer i2 = 100;
 Integer i3 = 200;
 Integer i4 = 200;
 
 System.out.println(i1==i2);
 System.out.println(i3==i4);
 }
}

这题容易误导我们，想当然的就因为返回俩个true。显然这是不正确的。
运行结果：true 、false
为什么会出现这样的结果？
输出结果表明i1和i2指向的是同一个对象，而i3和i4指向的是不同的对象。
此时只需一看源码便知究竟，下面这段代码是Integer的valueOf方法的具体实现：

public static Integer valueOf(int i) {
 if(i >= -128 && i <= IntegerCache.high)
 return IntegerCache.cache[i + 128];
 else
 return new Integer(i);
 }

其中IntegerCache类的实现为：

private static class IntegerCache {
 static final int high;
 static final Integer cache[];
 static {
 final int low = -128;
 // high value may be configured by property
 int h = 127;
 if (integerCacheHighPropValue != null) {
 // Use Long.decode here to avoid invoking methods that
 // require Integer's autoboxing cache to be initialized
 int i = Long.decode(integerCacheHighPropValue).intValue();
 i = Math.max(i, 127);
 // Maximum array size is Integer.MAX_VALUE
 h = Math.min(i, Integer.MAX_VALUE - -low);
 }
 high = h;
 cache = new Integer[(high - low) + 1];
 int j = low;
 for(int k = 0; k < cache.length; k++)
 cache[k] = new Integer(j++);
 }
 private IntegerCache() {}
 }

从这2段代码可以看出，在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，
便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。
上面的代码中i1和i2的数值为100，因此会直接从cache中取已经存在的对象，所以i1和i2指向的是
同一个对象，而i3和i4则是分别指向不同的对象。

面试题2：以下代码输出什么

public class Main {
 public static void main(String[] args) {
 
 Double i1 = 100.0;
 Double i2 = 100.0;
 Double i3 = 200.0;
 Double i4 = 200.0;
 
 System.out.println(i1==i2);
 System.out.println(i3==i4);
 }
}

答案是：false、false

原因： 在某个范围内的整型数值的个数是有限的，而浮点数却不是。

七、重载与重写的区别

重载（Overload）：
在同一个类当中，有同名的方法，但是它们的参数列表不同（参数类型不同、参数个数不同甚至是参数顺序不同），将视为重载。同时对返回参数没有要求。可以相同也可以不同，但不能通过返回返回参数来判断是否为重载。

重写：
发生在子类与父类当中，子类继承父类要重写方法，并且重写的方法名，参数个数，参数列表，返回参数必须相同。访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private)。重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。

八、equals与==的区别

==：
==比较的是变量（栈）内存中存放的对象的（堆）内存地址。用来判断俩个地址是否相同，即是否为同一个对象。
比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为
true，如： int a=10 与 long b=10L 与 double c=10.0都是相同的（为true），因为他们都指向地址为10的堆。

equals：
equals是用来比较俩个对象的内容是否相等。由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断。

九、Hashcode的作用

Java集合有俩类，一种为list，另一种为set，前者有序可重复，后者无序不可重复。当我们在set中插入时，我们如何判断集合中是否已经有相同元素，如果使用equals，当集合中元素较多时进行一个个比较，性能就非常低了。
于是有人发明了哈希算法来提高集合中查找元素的效率。 这种方式将集合分成若干个存储区域，每个对象可以计算出一个哈希码，可以将哈希码分组，每组分别对应某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储的那个区域。

hashCode方法可以这样理解：它返回的就是根据对象的内存地址换算出的一个值。这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。

十、String、 StringBuffer 和 StringBuilder 的区别是什么?

String 是只读字符串，它并不是基本数据类型，而是一个对象，所引用的字符串不能被改变，一经定义，不可改变。
StringBuffer和StringBuilder他们俩都继承了AbstractStringBuilder抽象类，他们的底层都是可变字符组，所以再进行频繁的字符串操作时，建议使StringBuffer和StringBuilder。另外StringBuffer对方法进行加同步锁或者对调用的方法加了同步锁，所以线程是安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。