java面试题(三)

爱被打了一巴掌 2024-03-30 15:46 82阅读 0赞

## **1、Java 中会存在内存泄漏吗，请简单描述。** ##

答：

理论上 Java 因为有垃圾回收机制（GC）不会存在内存泄露问题（这也是 Java 被

广泛使用于服务器端编程的一个重要原因）；然而在实际开发中，可能会存在无

用但可达的对象，这些对象不能被 GC 回收，因此也会导致内存泄露的发生。例如

Hibernate 的 Session（一级缓存）中的对象属于持久态，垃圾回收器是不会回收

这些对象的，然而这些对象中可能存在无用的垃圾对象，如果不及时关闭（close）

或清空（flush）一级缓存就可能导致内存泄露。

下面例子中的代码也会导致内存泄露。

import java.util.Arrays;
    import java.util.EmptyStackException;
    public class MyStack<T> {
        private T[] elements;
        private int size = 0;
        private static final int INIT_CAPACITY = 16;
        public MyStack() {
            elements = (T[]) new Object[INIT_CAPACITY];
        }
        public void push(T elem) {
            ensureCapacity();
            elements[size++] = elem;
        }
        public T pop() {
            if(size == 0)
                throw new EmptyStackException();
            return elements[--size];
        }
        private void ensureCapacity() {
            if(elements.length == size) {
                elements = Arrays.copyOf(elements, 2 * size + 1);
            }
        }
    }

上面的代码实现了一个栈（先进后出（FILO））结构，乍看之下似乎没有什么明

显的问题，它甚至可以通过你编写的各种单元测试。然而其中的 pop 方法却存在

内存泄露的问题，当我们用 pop 方法弹出栈中的对象时，该对象不会被当作垃圾

回收，即使使用栈的程序不再引用这些对象，因为栈内部维护着对这些对象的过

期引用（obsolete reference）。在支持垃圾回收的语言中，内存泄露是很隐蔽的，

这种内存泄露其实就是无意识的对象保持。如果一个对象引用被无意识的保留起

来了，那么垃圾回收器不会处理这个对象，也不会处理该对象引用的其他对象，

即使这样的对象只有少数几个，也可能会导致很多的对象被排除在垃圾回收之外，

从而对性能造成重大影响，极端情况下会引发 Disk Paging（物理内存与硬盘的虚

拟内存交换数据），甚至造成 OutOfMemoryError。

## **2、抽象的（abstract）方法是否可同时是静态（static）, 是否可同时是本地方法（native），是否可同时被synchronized 修饰？** ##

答：

都不能。抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛

盾的。本地方法是由本地代码（如 C 代码）实现的方法，而抽象方法是没有实现

的，也是矛盾的。synchronized 和方法的实现细节有关，抽象方法不涉及实现细

节，因此也是相互矛盾的。

## **3、阐述静态变量和实例变量的区别。** ##

静态变量是被 static 修饰符修饰的变量，也称为类变量，它属于类，不属于类的

任何一个对象，一个类不管创建多少个对象，静态变量在内存中有且仅有一个拷

贝；实例变量必须依存于某一实例，需要先创建对象然后通过对象才能访问到它。

静态变量可以实现让多个对象共享内存。

## **4、是否可以从一个静态（static）方法内部发出对非静态 （non-static）方法的调用？** ##

答：

不可以，静态方法只能访问静态成员，因为非静态方法的调用要先创建对象，在

调用静态方法时可能对象并没有被初始化。

## **5、如何实现对象克隆？** ##

答：

有两种方式：

1). 实现 Cloneable 接口并重写 Object 类中的 clone()方法；

2). 实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，代码如下。

import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    public class MyUtil {
        private MyUtil() {
            throw new AssertionError();
        }
        @SuppressWarnings("unchecked")
        public static <T extends Serializable> T clone(T obj) throws
                Exception {
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bout);
            oos.writeObject(obj);
            ByteArrayInputStream bin = new
                    ByteArrayInputStream(bout.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bin);
            return (T) ois.readObject();
    // 说明：调用 ByteArrayInputStream 或 ByteArrayOutputStream
            对象的 close 方法没有任何意义
    // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这
            一点不同于对外部资源（如文件流）的释放
        }
    }

测试方法

import java.io.Serializable;
    /**
     * 人类
     * @author 骆昊
     *
     */
    class Person implements Serializable {
        private static final long serialVersionUID = -9102017020286042305L;
        private String name; // 姓名
        private int age; // 年龄
        private Car car; // 座驾
        public Person(String name, int age, Car car) {
            this.name = name;
            this.age = age;
            this.car = car;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public Car getCar() {
            return car;
        }
        public void setCar(Car car) {
            this.car = car;
        }
        @Override
        public String toString() {
            return "Person [name=" + name + ", age=" + age + ", car=" +
                    car + "]";
        }
    }

/**
     * 小汽车类
     * @author 骆昊
     *
     */
    class Car implements Serializable {
        private static final long serialVersionUID = -5713945027627603702L;
        private String brand; // 品牌
        private int maxSpeed; // 最高时速
        public Car(String brand, int maxSpeed) {
            this.brand = brand;
            this.maxSpeed = maxSpeed;
        }
        public String getBrand() {
            return brand;
        }
        public void setBrand(String brand) {
            this.brand = brand;
        }
        public int getMaxSpeed() {
            return maxSpeed;
        }
        public void setMaxSpeed(int maxSpeed) {
            this.maxSpeed = maxSpeed;
        }
        @Override
        public String toString() {
            return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed +
                    "]";
        }
    }

class CloneTest {
        public static void main(String[] args) {
            try {
                Person p1 = new Person("Hao LUO", 33, new Car("Benz",
                        300));
                Person p2 = MyUtil.clone(p1); // 深度克隆
                p2.getCar().setBrand("BYD");
    // 修改克隆的 Person 对象 p2 关联的汽车对象的品牌属性
    // 原来的 Person 对象 p1 关联的汽车不会受到任何影响
    // 因为在克隆 Person 对象时其关联的汽车对象也被克隆了
                System.out.println(p1);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

**注意：** 基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛

型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，

不是在运行时抛出异常，这种是方案明显优于使用 Object 类的 clone 方法克隆对

象。让问题在编译的时候暴露出来总是好过把问题留到运行时。

## **6、GC 是什么？为什么要有 GC？** ##

答：

GC 是垃圾收集的意思，内存处理是编程人员容易出现问题的地方，忘记或者错误

的内存回收会导致程序或系统的不稳定甚至崩溃，Java 提供的 GC 功能可以自动

监测对象是否超过作用域从而达到自动回收内存的目的，Java 语言没有提供释放

已分配内存的显示操作方法。Java 程序员不用担心内存管理，因为垃圾收集器会

自动进行管理。要请求垃圾收集，可以调用下面的方法之一：System.gc() 或

Runtime.getRuntime().gc() ，但 JVM 可以屏蔽掉显示的垃圾回收调用。

垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通

常是作为一个单独的低优先级的线程运行，不可预知的情况下对内存堆中已经死

亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回

收器对某个对象或所有对象进行垃圾回收。在 Java 诞生初期，垃圾回收是 Java

最大的亮点之一，因为服务器端的编程需要有效的防止内存泄露问题，然而时过

境迁，如今 Java 的垃圾回收机制已经成为被诟病的东西。移动智能终端用户通常

觉得 iOS 的系统比 Android 系统有更好的用户体验，其中一个深层次的原因就在

于 Android 系统中垃圾回收的不可预知性。

**补充：** 垃圾回收机制有很多种，包括：分代复制垃圾回收、标记垃圾回收、增量

垃圾回收等方式。标准的 Java 进程既有栈又有堆。栈保存了原始型局部变量，堆

保存了要创建的对象。Java 平台对堆内存回收和再利用的基本算法被称为标记和

清除，但是 Java 对其进行了改进，采用“分代式垃圾收集”。这种方法会跟 Java

对象的生命周期将堆内存划分为不同的区域，在垃圾收集过程中，可能会将对象

移动到不同区域：

伊甸园（Eden）：这是对象最初诞生的区域，并且对大多数对象来说，

这里是它们唯一存在过的区域。

幸存者乐园（Survivor）：从伊甸园幸存下来的对象会被挪到这里。

终身颐养园（Tenured）：这是足够老的幸存对象的归宿。年轻代收集

（Minor-GC）过程是不会触及这个地方的。当年轻代收集不能把对象放进终身

颐养园时，就会触发一次完全收集（Major-GC），这里可能还会牵扯到压缩，

以便为大对象腾出足够的空间。

与垃圾回收相关的 JVM 参数：

\-Xms / -Xmx — 堆的初始大小 / 堆的最大大小

\-Xmn — 堆中年轻代的大小

\-XX:-DisableExplicitGC — 让 System.gc()不产生任何作用

\-XX:+PrintGCDetails — 打印 GC 的细节第 244 页 共 485 页

\-XX:+PrintGCDateStamps — 打印 GC 操作的时间戳

\-XX:NewSize / XX:MaxNewSize — 设置新生代大小/新生代最大大小

\-XX:NewRatio — 可以设置老生代和新生代的比例

\-XX:PrintTenuringDistribution — 设置每次新生代 GC 后输出幸存者

乐园中对象年龄的分布

\-XX:InitialTenuringThreshold / -XX:MaxTenuringThreshold：设置老

年代阀值的初始值和最大值

\-XX:TargetSurvivorRatio：设置幸存区的目标使用率

## 7 **、Anonymous Inner Class(匿名内部类)是否可以继承它 类？是否可以实现接口？** ##

答：

可以继承其他类或实现其他接口，在 Swing 编程和 Android 开发中常用此方式来

实现事件监听和回调。

## **8、内部类可以引用它的包含类（外部类）的成员吗？有没有什么限制？** ##

答：

一个内部类对象可以访问创建它的外部类对象的成员，包括私有成员。

## **9、Java 中的 final 关键字有哪些用法？** ##

(1)修饰类：表示该类不能被继承；(2)修饰方法：表示方法不能被重写；(3)修饰变

量：表示变量只能一次赋值以后值不能被修改（常量）。

## **10、日期和时间：** ##

如何取得年月日、小时分钟秒？

如何取得从 1970 年 1 月 1 日 0 时 0 分 0 秒到现在的毫秒数？

如何取得某月的最后一天？

如何格式化日期？

答：

问题 1：创建 java.util.Calendar 实例，调用其 get()方法传入不同的参数即可获

得参数所对应的值。Java 8 中可以使用 java.time.LocalDateTimel 来获取，代码

如下所示。

public class DateTimeTest {
        public static void main(String[] args) {
            Calendar cal = Calendar.getInstance();
            System.out.println(cal.get(Calendar.YEAR));
            System.out.println(cal.get(Calendar.MONTH)); // 0 - 11
            System.out.println(cal.get(Calendar.DATE));
            System.out.println(cal.get(Calendar.HOUR_OF_DAY));
            System.out.println(cal.get(Calendar.MINUTE));
            System.out.println(cal.get(Calendar.SECOND));
    // Java 8
            LocalDateTime dt = LocalDateTime.now();
            System.out.println(dt.getYear());
            System.out.println(dt.getMonthValue()); // 1 - 12
            System.out.println(dt.getDayOfMonth());
            System.out.println(dt.getHour());
            System.out.println(dt.getMinute());
            System.out.println(dt.getSecond());
        }
    }

Calendar.getInstance().getTimeInMillis();
    System.currentTimeMillis();
    Clock.systemDefaultZone().millis(); // Java 8

Calendar time = Calendar.getInstance();
    time.getActualMaximum(Calendar.DAY_OF_MONTH);

import java.text.SimpleDateFormat;
    import java.time.LocalDate;
    import java.time.format.DateTimeFormatter;
    import java.util.Date;
    class DateFormatTest {
        public static void main(String[] args) {
            SimpleDateFormat oldFormatter = new
                    SimpleDateFormat("yyyy/MM/dd");
            Date date1 = new Date();
            System.out.println(oldFormatter.format(date1));
    // Java 8
            DateTimeFormatter newFormatter =
                    DateTimeFormatter.ofPattern("yyyy/MM/dd");
            LocalDate date2 = LocalDate.now();
            System.out.println(date2.format(newFormatter));
        }
    }