JAVA后端开发面经8

​面经来源于github上的

Java-Interview

在学习时，用自己的语言解释​

 71.描述一下JVM加载class文件的原理机制?

JVM中类的装载是由ClassLoader和它的子类来实现的，Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。

这个没有啥好讲的，就记住就好了。

72.heap和stack有什么区别。

Java的内存分为两类，一类是栈内存，一类是堆内存。栈内存是指程序进入一个方法时，会为这个方法单独分配一块私属存储空间，用于存储这个方法内部的局部变量，当这个方法结束时，分配给这个方法的栈会释放，这个栈中的变量也将随之释放。

堆是与栈作用不同的内存，一般用于存放不放在当前方法栈中的那些数据，例如，使用new创建的对象都放在堆里，所以，它不会随方法的结束而消失。方法中的局部变量使用final修饰后，放在堆中，而不是栈中。

用一个例子比喻一下：栈也就是出去荒野求生时候用木材搭的堆，用的时候会有空间占用。而堆就是收回来的木材还没有用，放在旁边成堆了，也会占用空间。但是烧柴结束的时候，木头就没有了，也就成灰了（栈释放了）。

73.GC是什么? 为什么要有GC?

GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。

74.垃圾回收的优点和原理。并考虑2种回收机制。

Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。

由于有个垃圾回收机制，Java中的对象不再有"作用域"的概念，只有对象的引用才有"作用域"。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。

回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

75.垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？

讲的好！！

对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。

通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是“可达的”，哪些对象是“不可达的”。当GC确定一些对象为“不可达”时，GC就有责任回收这些内存空间。可以。程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。

76.什么时候用assert。

assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查。

一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，assert将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。

77.java中会存在内存泄漏吗，请简单描述。

所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存中。java中有垃圾回收机制，它可以保证一对象不再被引用的时候，即对象编程了的时候，对象将自动被垃圾回收器从内存中清除掉。由于Java 使用有向图的方式进行垃圾回收管理，可以消除引用循环的问题，例如有两个对象，相互引用，只要它们和根进程不可达的，那么GC也是可以回收它们的。

Java中的内存泄露的情况：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是Java中内存泄露的发生场景。

通俗地说，就是程序员可能创建了一个对象，以后一直不再使用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃圾回收器回收的，这就是Java中可能出现内存泄露的情况，例如，缓存系统，我们加载了一个对象放在缓存中(例如放在一个全局map对象中)，然后一直不再使用它，这个对象一直被缓存引用，但却不再被使用。

检查Java中的内存泄露，一定要让程序将各种分支情况都完整执行到程序结束，然后看某个对象是否被使用过，如果没有，则才能判定这个对象属于内存泄露。

如果一个外部类的实例对象的方法返回了一个内部类的实例对象，这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持久外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄露。

主要特点就是清空堆栈中的某个元素，并不是彻底把它从数组中拿掉，而是把存储的总数减少，在拿掉某个元素时，顺便也让它从数组中消失，将那个元素所在的位置的值设置为null即可。

这个问题原作者的回答看的我有点懵，我拿去问了一下文心一言：

•  Java中也可能会存在内存泄漏。尽管Java有垃圾回收（Garbage Collection，GC）机制来自动管理内存，但在某些情况下，程序仍然可能无法正确释放不再需要的对象，从而导致内存泄漏。
• 内存泄漏是指程序在申请内存后，未能正确释放不再使用的内存空间，导致系统中可用的内存空间逐渐减少。在Java中，内存泄漏通常发生在以下几种情况：

1.  静态集合类：如果使用了静态的集合类，如HashMap、LinkedList等，并且不断向其中添加对象，而没有在不需要时清空集合，那么这些对象将永远不会被垃圾回收器回收，从而导致内存泄漏。
2. 监听器和其他回调：在实现监听器或其他回调接口时，如果没有及时取消注册，那么相关对象将无法被垃圾回收，从而导致内存泄漏。例如，在Android开发中，使用广播接收器时如果没有在适当的时候取消注册，就可能导致内存泄漏。
3. 单例模式：单例对象在整个应用程序生命周期内都存在。如果单例对象持有其他对象的引用，并且这些对象不再需要，但单例对象仍然保持对它们的引用，那么这些对象将无法被垃圾回收，从而导致内存泄漏。
4. 线程：如果线程不再需要，但没有被正确终止，那么与该线程相关的资源（如线程栈）将无法被释放，从而导致内存泄漏。此外，线程中的局部变量也可能导致内存泄漏，尤其是当这些变量引用了大量数据时。
5. 第三方库：使用第三方库时，如果库中存在内存泄漏的问题，那么这些问题也可能影响到使用这些库的应用程序。 

• 为了避免内存泄漏，开发者需要注意在不再需要对象时及时释放对它们的引用，合理使用静态变量、单例和线程等资源，以及在必要时手动触发垃圾回收（尽管这通常不是解决问题的最佳方法，因为垃圾回收的时机和效果主要由JVM控制）。 

我更懵了。还不如原作者写的，我只能慢慢理解了。

78.能不能自己写个类，也叫java.lang.String？

可以，但在应用的时候，需要用自己的类加载器去加载，否则，系统的类加载器永远只是去加载jre.jar包中的那个java.lang.String。由于在tomcat的web应用程序中，都是由webapp自己的类加载器先自己加载WEB-INF/classess目录中的类，然后才委托上级的类加载器加载，如果我们在tomcat的web应用程序中写一个java.lang.String，这时候Servlet程序加载的就是我们自己写的java.lang.String，但是这么干就会出很多潜在的问题，原来所有用了java.lang.String类的都将出现问题。

虽然java提供了endorsed技术，可以覆盖jdk中的某些类，具体做法是….。但是，能够被覆盖的类是有限制范围，反正不包括java.lang这样的包中的类。例如，运行下面的程序：

package java.lang;
public class String {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("string");
	}
}

报告的错误如下： java.lang.NoSuchMethodError: main

Exception in thread "main"

这是因为加载了jre自带的java.lang.String，而该类中没有main方法。

 

79.获得一个类的类对象有哪些方式？

方法1：类型.class，例如：String.class

方法2：对象.getClass()，例如：”hello”.getClass()

方法3：Class.forName()，例如：Class.forName(“java.lang.String”)

80.Java代码查错 

来来来，好东西！

1）

abstract class Name {
    private String name;
    public abstract boolean isStupidName(String name) {}
}

这有何错误? 答案: 错。abstract method必须以分号结尾，且不带花括号。

也就是这样

public abstract boolean isStupidName(String name); 

2）

public class Something {
    void doSomething () {
        private String s = "";
        int l = s.length();
    }
}

有错吗? 答案: 错。局部变量前不能放置任何访问修饰符 (private，public，和protected)。final可以用来修饰局部变量(final如同abstract和strictfp，都是非访问修饰符，strictfp只能修饰class和method而非variable)。

也就是这个错误了

private String s = "";
//改成这样
String s = "";

3）

abstract class Something {
    private abstract String doSomething ();
}

这好像没什么错吧? 答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstract method封锁起来呢? (同理，abstract method前不能加final)。

4）

public class Something {
    public int addOne(final int x) {
        return ++x;
    }
}

这个比较明显。 答案: 错。int x被修饰成final，意味着x不能在addOne method中被修改。

5）

public class Something {
    public static void main(String[] args) {
        Other o = new Other();
        new Something().addOne(o);
    }
    public void addOne(final Other o) {
        o.i++;
    }
}
class Other {
    public int i;
}

和上面的很相似，都是关于final的问题，这有错吗? 答案: 正确。在addOne method中，参数o被修饰成final。如果在addOne method里我们修改了o的reference(比如: o = new Other();)，那么如同上例这题也是错的。但这里修改的是o的member vairable(成员变量)，而o的reference并没有改变。

6）

class Something {
    int i;
    public void doSomething() {
        System.out.println("i = " + i);
    }
}

有什么错呢? 看不出来啊。 答案: 正确。输出的是"i = 0"。int i属於instant variable (实例变量，或叫成员变量)。instant variable有default value。int的default value是0。

7）

class Something {
    final int i;
    public void doSomething() {
        System.out.println("i = " + i);
    }
}

和上面一题只有一个地方不同，就是多了一个final。这难道就错了吗? 答案: 错。final int i是个final的instant variable (实例变量，或叫成员变量)。final的instant variable没有default value，必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为“final int i = 0;”。

8）

public class Something {
    public static void main(String[] args) {
        Something s = new Something();
        System.out.println("s.doSomething() returns " + doSomething());
    }
    public String doSomething() {
        return "Do something ...";
    }
}

看上去很完美。 答案: 错。看上去在main里call doSomething没有什么问题，毕竟两个methods都在同一个class里。但仔细看，main是static的。static method不能直接call non-static methods。可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。同理，static method不能访问non-static instant variable。

9）

此处，Something类的文件名叫OtherThing.java

class Something {
    private static void main(String[] something_to_do) {   
        System.out.println("Do something ...");
    }
}

这个好像很明显。 答案: 正确。从来没有人说过Java的Class名字必须和其文件名相同。但public class的名字必须和文件名相同。

10）

interface A{
    int x = 0;
}
class B{
    int x =1;
}
class C extends B implements A {
    public void pX(){
        System.out.println(x);
    }
    public static void main(String[] args) {
        new C().pX();
    }
}

答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，两个x都匹配（就象在同时import java.util和java.sql两个包时直接声明Date一样）。对于父类的变量,可以用super.x来明确，而接口的属性默认隐含为 public static final.所以可以通过A.x来明确。 11）

interface Playable {
    void play();
}
interface Bounceable {
    void play();
}
interface Rollable extends Playable, Bounceable {
    Ball ball = new Ball("PingPang");
}
class Ball implements Rollable {
    private String name;
    public String getName() {
        return name;
    }
    public Ball(String name) {
        this.name = name;   
    }
    public void play() {
        ball = new Ball("Football");
        System.out.println(ball.getName());
    }
}

这个错误不容易发现。 答案: 错。

"interface Rollable extends Playable, Bounceable"没有问题。interface可继承多个interfaces，所以这里没错。问题出在interface Rollable里的"Ball ball = new Ball("PingPang");"。任何在interface里声明的interface variable (接口变量，也可称成员变量)，默认为public static final。也就是说"Ball ball = new Ball("PingPang");"实际上是"public static final Ball ball = new Ball("PingPang");"。在Ball类的Play()方法中，"ball = new Ball("Football");"改变了ball的reference，而这里的ball来自Rollable interface，Rollable interface里的ball是public static final的，final的object是不能被改变reference的。

因此编译器将在"ball = new Ball("Football");"这里显示有错。