Java⾼频⾯试题⼋股⽂背诵版（秋招冲呀） 总结了下常见的Java⾯试题，题⽬后⾯的星星数量表⽰⾯试中题⽬出现的频率，秋招的⼩伙伴冲呀
⽂章⽬录：
⽂章⽬录
1. JVM、JRE及JDK的关系 ＊＊
JDK（Java Development Kit）是针对Java开发员的产品，是整个Java的核⼼，包括了Java运⾏环境JRE、Java⼯具和Java基础类库。Java Runtime Environment（JRE）是运⾏JAVA程序所必须的环境的集合，包含JVM标准实现及Java核⼼类库。
JVM是Java Virtual Machine（Java虚拟机）的缩写，是整个java实现跨平台的最核⼼的部分，能够运⾏以Java语⾔写作的软件程序。简单来说就是JDK是Java的开发⼯具，JRE是Java程序运⾏所需的环境，JVM是Java虚拟机．它们之间的关系是JDK包含JRE和JVM，JRE包含JVM．
由于本⽂篇幅有限，我这边就把我整理好了 部分⼋股⽂ （背诵版）的⾼频⾯试题PDF，放这⾥，如需获取全部⼋股⽂（背诵由于本⽂篇幅有限，我这边就把我整理好了 部分⼋股⽂ （背诵版）的⾼频⾯试题PDF，放这⾥，如需获取全部⼋股⽂（背诵获取即可
版）：
版）： 获取即可
2. JAVA语⾔特点　＊＊
Java是⼀种⾯向对象的语⾔
Java通过Java虚拟机实现了平台⽆关性，⼀次编译，到处运⾏
⽀持多线程
⽀持⽹络编程
具有较⾼的安全性和可靠性
3. JAVA和C++的区别　＊＊
⾯试时记住前四个就⾏了
Java 通过虚拟机从⽽实现跨平台特性，但是 C++ 依赖于特定的平台。
Java 没有指针，它的引⽤可以理解为安全指针，⽽ C++ 具有和 C ⼀样的指针。
Java ⽀持⾃动垃圾回收，⽽ C++ 需要⼿动回收。
Java 不⽀持多重继承，只能通过实现多个接⼝来达到相同⽬的，⽽ C++ ⽀持多重继承。
Java 不⽀持操作符重载，虽然可以对两个 String 对象执⾏加法运算，但是这是语⾔内置⽀持的操作，不属于操
作符重载，⽽ C++ 可以。
Java 的 goto 是保留字，但是不可⽤，C++ 可以使⽤ goto。
4. Java的基本数据类型　＊＊
注意 String不是基本数据类型
5. 隐式(⾃动)类型转换和显⽰(强制)类型转换　＊＊
隐式(⾃动)类型转换：从存储范围⼩的类型到存储范围⼤的类型。byte→short(char)→int→long→float→double
显⽰(强制)类型转换：从存储范围⼤的类型到存储范围⼩的类型。double→float→long→int→short(char)→byte。该类类型转换很可能存在精度的损失。
看⼀个经典的代码
short s = 1;
s = s + 1;
这是会报错的，因为1是int型，s+1会⾃动转换为int型，将int型直接赋值给short型会报错。
做⼀下修改即可避免报错
short s = 1;
s = (short)(s + 1);
或这样写，因为s += 1会⾃动进⾏强制类型转换
short s = 1;
s += 1;
6. ⾃动装箱与拆箱＊＊
装箱：将基本类型⽤包装器类型包装起来
拆箱：将包装器类型转换为基本类型
这个地⽅有很多易混淆的地⽅，但在⾯试中问到的频率⼀般，笔试的选择题中经常出现，还有⼀个 String创建对象和这个⽐较像，很容易混淆，在下⽂可以看到
下⾯这段代码的输出结果是什么？
public class Main {
public static void main(String[] args) {
Integer a = 100;
Integer b = 100;
Integer c = 128;
Integer d = 128;
System.out.println(a==b);
System.out.println(c==d);
}
}
很多⼈看到这个结果会很疑惑，为什么会是⼀个true⼀个flase．其实从中可以很容易到原因．⾸先到Integer⽅法中的valueOf⽅法
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
可以看到当不满⾜if语句中的条件，就会重新创建⼀个对象返回，那结果必然不相等。继续打开IntegerCache可以看到
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.SavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)java valueof
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
代码挺长，⼤概说的就是在通过valueOf⽅法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中
已经存在的对象的引⽤；否则创建⼀个新的Integer对象。所以上⾯代码中a与b相等，c与d不相等。
在看下⾯的代码会输出什么
public class Main {
public static void main(String[] args) {
Double a = 1.0;
Double b = 1.0;
Double c = 2.0;
Double d = 2.0;
System.out.println(a==b);
System.out.println(c==d);
}
}
采⽤同样的⽅法，可以看到Double的valueOf⽅法，每次返回都是重新new⼀个新的对象，所以上⾯代码中的结果都不想等。
public static Double valueOf(double d) {
return new Double(d);
}
最后再看这段代码的输出结果
public class Main {
public static void main(String[] args) {
Boolean a = false;
Boolean b = false;
Boolean c = true;
Boolean d = true;
System.out.println(a==b);
System.out.println(c==d);
}
}
true
true
⽼⽅法继续看valueOf⽅法
public static Boolean valueOf(boolean b) {
return (b ? TRUE : FALSE);
}
再看看TRUE和FALSE是个什么东西，是两个静态成员属性。
public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);
*说下结论 *：Integer、Short、Byte、Character、Long这⼏个类的valueOf⽅法的实现是类似的。Double、Float的valueOf⽅法的实现是类似的。然后是Boolean的valueOf⽅法是单独⼀组的。
Integer i = new Integer(xxx)和Integer i =xxx的区别
这两者的区别主要是第⼀种会触发⾃动装箱，第⼆者不会
最后看看下⾯这段程序的输出结果
public class Main {
public static void main(String[] args) {
Integer a = 1;
Integer b = 2;
Integer c = 3;
Long g = 3L;
int int1 = 12;
int int2 = 12;
Integer integer1 = new Integer(12);
Integer integer2 = new Integer(12);
Integer integer3 = new Integer(1);
System.out.println("c==(a+b) ->"+ (c==(a+b)));
System.out.println("g==(a+b) ->" + (g==(a+b)));
System.out.println( "c.equals(a+b) ->" + (c.equals(a+b)));
System.out.println( "g.equals(a+b) ->" + (g.equals(a+b)));
System.out.println("int1 == int2 -> " + (int1 == int2));
System.out.println("int1 == integer1 -> " + (int1 == integer1));
System.out.println("integer1 == integer2 -> " + (integer1 == integer2));
System.out.println("integer3 == a1 -> " + (integer3 == a));
}
}
下⾯简单解释这些结果。
1.当 "=="运算符的两个操作数都是包装器类型的引⽤，则是⽐较指向的是否是同⼀个对象，⽽如果其中有⼀个操作数是表达式（即包含算术运算）则⽐较的是数值（即会触发⾃动拆箱的过程）。所以c==a+b，g==a+b为true。
2.⽽对于equals⽅***先触发⾃动拆箱过程，再触发⾃动装箱过程。也就是说a+b，会先各⾃调⽤intValue⽅法，得到了加法运算后的数值之后，便调⽤Integer.valueOf⽅法，再进⾏equals⽐较。所以c.equals(a+b)为true。⽽对于g.equals(a+b)，a+b会先拆箱进⾏相加运算，在装箱进⾏equals⽐较，但是装箱后为Integer，g为Long，所以g.equals(a+b)为false。
3.int1 == int2为true⽆需解释，int1 == integer1，在进⾏⽐较时，integer1会先进⾏⼀个拆箱操作变成int型在进⾏⽐较，所以int1 == integer1为true。
4.integer1 == integer2->false。integer1和integer2都是通过new关键字创建的，可以看成两个对象，所以integer1 == integer2
为false。integer3 == a1 -> false , integer3是⼀个对象类型，⽽a1是⼀个常量它们存放内存的位置不⼀样，所以integer3 == a1为false，具体原因可学习下java的内存模型。
String(不是基本数据类型)
7. String的不可变性＊＊＊
在 Java 8 中，String 内部使⽤ char 数组存储数据。并且被声明为final，因此它不可被继承。
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
private final char value[];
}
为什么Strin g`要设计成不可变的呢（不可变性的好处）:
1.可以缓存 hash 值（）

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。