title: Java基础与面向对象高频面试题
tags: [Java基础, 面向对象, 泛型, 反射, 异常]
created: 2026-05-31
共55道题 | 难度分布:★★★☆☆~★★★★★ | 2026年20K+ Java后端面试必考:equals/hashCode契约、泛型擦除、反射原理、SPI机制。
答案:==对于基本类型比较的是值(int==int、double==double),对于引用类型比较的是内存地址(是否为同一个对象)。equals()是Object类的方法,默认实现与==相同(比较地址),但String、Integer等类重写了equals方法来比较内容/值。使用原则:基本类型用==,引用类型判断内容相等用equals()。注意:==比较Integer缓存范围(-128~127)外的对象时会返回false,因为自动装箱会创建新对象。面试常见陷阱:new String("a") == new String("a")为false,但.equals()为true。
答案:Java对象的equals和hashCode有一个契约(contract):(1) 如果两个对象equals为true,则hashCode必须相同;(2) 如果hashCode相同,两个对象不一定equals为true(hash冲突);(3) 同一对象多次调用hashCode应返回相同值。如果不重写hashCode,equals为true的两个对象可能hashCode不同,导致在HashMap/HashSet中无法正确工作——因为HashMap先按hashCode找桶位再按equals比较,hashCode不同会定位到不同桶,"相同"对象会被当作不同元素。JDK中String、Integer等都同时重写了这两个方法。
答案:不一定。hashCode相同只说明两个对象映射到了同一个hash桶位,这叫做hash冲突。HashMap/HashSet在找到桶位后还会调用equals逐一比较链表/红黑树中的元素。好的hashCode算法应该尽量均匀分布减少冲突,但无法完全避免。例如String的hashCode算法,"Aa"和"BB"的hashCode都是2112('A'*31+'a' = 65*31+97 = 2112,'B'*31+'B' = 66*31+66 = 2112),但equals为false。这就是为什么HashMap需要同时使用hashCode和equals。
答案:Object类的equals方法默认实现就是this == obj,即比较两个引用是否指向同一个对象(内存地址相同)。源码为:public boolean equals(Object obj) { return (this == obj); }。这意味着如果自定义类不重写equals,则两个不同实例即使所有字段都相同,equals也返回false。重写equals的标准步骤:(1) this == obj先判断是否同一对象;(2) obj == null判断空;(3) getClass() != obj.getClass()判断类型;(4) 逐个比较关键字段。或使用instanceof判断(允许子类相等)。
答案:String重写了equals方法:(1) 先this == obj判断是否同一对象(快速路径);(2) 再obj instanceof String判断类型;(3) 最后逐字符比较两个字符串的char数组(JDK9+为byte数组,因为Compact Strings优化)。String还重写了hashCode方法,采用h = 31 * h + val[i]的算法计算,31是一个质数且31 * i == (i << 5) - i可以用位运算优化。String的hashCode是惰性计算的(首次调用时计算并缓存),且String是不可变的,所以hashCode不会变化。
答案:这两个对象会被存储在HashMap的不同桶位中(因为hashCode不同导致(n-1) & hash不同),即使它们的equals为true。这违反了"equals为true则hashCode必须相同"的契约,导致HashMap/HashSet中出现"重复"元素(逻辑上相同但存储了两份)。get操作时,用其中一个对象去查找,只会去它自己的hashCode对应的桶位找,可能找到也可能找不到(取决于用哪个对象去查),行为不可预期。这是为什么重写equals时必须同时重写hashCode的根本原因。
答案:String类被声明为final(不可被继承),内部存储字符的数组也是final且private的(JDK8是char[] value,JDK9+是byte[] value),并且没有提供任何修改该数组的方法。不可变的好处:(1) 字符串常量池的基础——相同内容可以共享同一对象,节省内存;(2) 天然线程安全,不需要同步;(3) hashCode可以缓存,适合做HashMap的key;(4) 安全性——防止敏感数据(如数据库连接串)被意外修改。如果需要可变字符串,使用StringBuilder或StringBuffer。
答案:两者都继承自AbstractStringBuilder,底层都是可变的char[](JDK9+为byte[]),都支持动态扩容(默认容量16,扩容为max(原容量*2+2, 最小需要容量))。唯一区别是StringBuffer的所有公开方法都加了synchronized修饰,是线程安全的;StringBuilder没有加锁,非线程安全但性能更好。实际开发中99%的场景都是单线程操作字符串,用StringBuilder即可。JDK5之后编译器将+拼接字符串自动优化为StringBuilder的append操作(在循环中除外)。
答案:(1) 字面量拼接:"a" + "b"在编译期直接优化为"ab"(class文件中只有一个字符串常量),不会创建StringBuilder;(2) final变量拼接:final String s = "a"; String r = s + "b";编译期优化为"ab";(3) 字符串常量池:双引号字面量在类加载时放入字符串常量池,intern()方法可以将运行时创建的字符串放入池中;(4) 但如果是变量拼接String s = a + b;(a、b是变量),编译器会生成new StringBuilder().append(a).append(b).toString(),无法在编译期合并。
答案:JDK6及之前,字符串常量池位于永久代(PermGen)中,大小有限容易OOM。JDK7将字符串常量池移到了堆中,因为堆的空间更大且更容易被GC管理。JDK8永久代被元空间取代,但字符串常量池仍在堆中。String.intern()方法:如果常量池中已存在等值的字符串则返回池中引用,否则将字符串添加到池中并返回引用。JDK6的intern()会将字符串复制到永久代,JDK7+只会在池中记录首次出现的引用(堆中对象),不会复制。
答案:最多创建2个对象(如果字符串常量池中不存在"abc"):(1) 常量池中的"abc"字面量对象(类加载时在常量池中创建);(2) 堆中的new String对象(运行时创建)。如果常量池中已经存在"abc",则只创建1个堆上的new String对象。注意new String对象内部的value数组指向常量池中"abc"的value(共享底层char/byte数组),所以不会重复创建字符数组。如果再调用intern(),则会将堆上的引用放入常量池。
答案:JDK9将String内部的char[] value改为byte[] value,配合一个coder字段(LATIN1=0或UTF16=1)标识编码方式。如果字符串只包含Latin-1字符(ASCII及西欧字符),每个字符用1个byte存储(原来每个char占2个byte),内存占用减半。如果包含中文等多字节字符,仍然用UTF-16编码(每个字符2个byte)。这是对JEP 254的实现,在大多数纯英文应用中能节省约30%~50%的String内存,同时由于GC扫描的数据量减少,也间接提升了GC性能。
答案:final有三个层面的用法:(1) 修饰类:该类不能被继承(如String、Integer、所有包装类),保证类的实现不可被改变;(2) 修饰方法:该方法不能被子类重写(override),但可以被继承和重载(overload),private方法隐式为final;(3) 修饰变量:如果是基本类型则值不可变,如果是引用类型则引用不可变(指向的对象不能换,但对象内部的字段可以修改)。final修饰的成员变量必须在声明时、构造代码块或构造方法中初始化。JVM会对final字段做特殊优化(如消除内存屏障)。
答案:finally块通常在try或catch块执行完后、return之前执行。即使try中有return,finally也会执行——执行顺序是先执行try中的代码到return语句,然后执行finally,最后再执行return。但以下情况finally不会执行:(1) 在try/catch中调用了System.exit();(2) 执行try/catch时JVM崩溃或被kill;(3) 执行try/catch的线程被中断/杀死。注意:如果finally中有return,会覆盖try/catch中的return值,这是一个常见的坑,应避免在finally中return。
答案:Object.finalize()在对象被GC回收前由Finalizer线程调用,用于清理资源。被废弃的原因:(1) 不确定性——无法保证finalize何时执行甚至是否执行,不能依赖它来释放资源;(2) 性能问题——Finalizer线程优先级低,如果对象很多会导致finalize队列积压;(3) 可能导致对象"复活"——在finalize中重新建立引用会导致对象无法被回收;(4) 安全风险——finalize可能被恶意代码利用。替代方案:实现AutoCloseable接口配合try-with-resources显式释放资源,或使用Cleaner(JDK9+)。
答案:try-with-resources是JDK7引入的语法糖,要求资源实现AutoCloseable接口(或其父接口Closeable)。编译后会为每个资源生成close()调用,并按声明逆序关闭(后声明的先关闭)。异常处理:如果try块和close()都抛异常,close()的异常会被suppressed(通过addSuppressed()附加到try块的异常上),主异常是try块的异常。这比手动在finally中关闭资源更安全(finally中close的异常会覆盖try块的异常)。JDK9进一步允许在try外声明资源变量并传入。
答案:(1) 继承限制:一个类只能继承一个抽象类(单继承),但可以实现多个接口(多实现);(2) 成员变量:抽象类可以有普通成员变量,接口的变量默认是public static final常量;(3) 方法实现:抽象类可以有构造方法和具体方法,JDK8之前接口只能有抽象方法;(4) 设计意图:抽象类是"is-a"关系(子类是父类的一种),接口是"has-a"能力(实现类具有某种能力)。选择原则:多个不相关的类具有相同行为时用接口;相关类之间共享代码和状态时用抽象类。
答案:JDK8允许在接口中用default关键字定义有默认实现的方法。引入default方法的核心目的是接口演进(interface evolution)——在不破坏已有实现类的情况下为接口添加新方法。例如JDK8为Collection接口添加了stream()/forEach()/removeIf()等default方法,如果不用default,所有已有的Collection实现类都需要修改。default方法可以被实现类重写。当一个类实现多个接口且这些接口有相同签名的default方法时,实现类必须显式重写该方法,用InterfaceName.super.method()指定调用哪个接口的实现。
答案:JDK9允许接口中定义private方法和private static方法。它们的作用是复用接口内部的代码逻辑——当多个default方法有共同逻辑时,可以抽取为private方法,避免代码重复。private static方法可以被default方法和static方法调用;private非static方法只能被default方法调用。注意private方法不能被实现类继承或访问,纯粹是接口内部的代码组织手段。这是接口逐渐从"纯行为契约"向"可包含实现代码"演进的体现。
答案:抽象类可以实现接口,并且可以选择不实现接口中的方法(交给具体子类实现),也可以提供默认实现。抽象类可以继承实体类(非抽象类),条件是实体类必须有可访问的构造方法。最常见的用法是:抽象类实现接口中的部分方法,剩余方法留给具体子类实现——这是模板方法设计模式的基础。例如AbstractList实现了List接口的部分方法(add、set、remove等抛UnsupportedOperationException),而ArrayList继承AbstractList实现剩余方法。
答案:重载发生在同一个类中,方法名相同但参数列表不同(参数类型、个数、顺序不同),与返回值和访问修饰符无关——这是编译期多态(静态绑定)。重写发生在父子类之间,子类重新定义父类的方法,方法签名必须完全相同(方法名、参数列表),返回值可以是父类方法返回值的子类型(协变返回),访问权限不能比父类更严格——这是运行期多态(动态绑定)。注意:重载是编译器在编译时根据方法签名决定调用哪个方法,重写是JVM在运行时根据对象的实际类型决定调用哪个方法。
答案:(1) 方法签名必须完全相同(方法名+参数列表);(2) 返回值类型必须相同或是父类方法返回值类型的子类(协变返回,JDK5+);(3) 访问权限不能比父类更严格(可以更宽松,如protected到public);(4) 抛出的受检异常不能比父类更宽(可以更窄或不抛);(5) private/final/static方法不能被重写(private不可见,final禁止重写,static是隐藏而非重写);(6) 构造方法不能被重写(构造方法不属于类的成员方法)。违反以上规则编译器会报错,这是Java强类型保证多态安全的重要机制。
答案:静态方法不能被重写(Override),只能被隐藏(Hide)。如果子类定义了与父类签名相同的静态方法,这叫做方法隐藏(method hiding),而不是方法重写。区别在于:重写是运行时根据对象实际类型决定调用哪个方法(多态),而隐藏是编译时根据引用类型决定调用哪个方法(无多态)。例如Parent p = new Child(); p.staticMethod()调用的是Parent的静态方法,而p.instanceMethod()调用的是Child的实例方法。这也是为什么@Override注解不能用于静态方法。
答案:编译期多态(静态绑定/静态分派)通过方法重载实现,编译器在编译阶段根据方法签名(参数类型和数量)决定调用哪个方法。典型例子:print(int i)和print(String s),调用print(1)编译期就绑定了int版本。运行期多态(动态绑定/动态分派)通过方法重写实现,JVM在运行时根据对象的实际类型(不是引用类型)决定调用哪个方法。典型例子:Animal a = new Dog(); a.speak()调用的是Dog的speak,而不是Animal的。Java通过虚方法表(vtable)实现运行期方法的动态分派。
答案:Java泛型在编译时进行类型检查,编译后会擦除所有泛型信息,替换为原始类型(Raw Type)或上界(bounded type的上界)。例如List<String>和List<Integer>编译后都是List。无界类型参数<T>擦除为Object,<T extends Number>擦除为Number。类型擦除是为了向后兼容JDK5之前的代码。擦除的后果:(1) 不能用基本类型作泛型参数(List<int>不行,只能List<Integer>);(2) 运行时无法做instanceof泛型类型检查;(3) 不能创建泛型数组new T[]。
答案:PECS = Producer Extends, Consumer Super,出自Joshua Bloch的《Effective Java》。如果泛型集合只用于读取(生产者),用? extends T(上界通配符),保证读取出来的都是T或T的子类,可以安全地赋值给T类型变量。如果泛型集合只用于写入(消费者),用? super T(下界通配符),保证写入的都是T或T的子类,可以安全地传入T类型参数。如果既要读又要写,就不要用通配符,直接用<T>。典型例子:void copy(List<? extends T> src, List<? super T> dest)——从src读(Producer Extends),往dest写(Consumer Super)。
答案:? extends T(上界通配符)表示"某个T的子类型",可以读取(get出来的对象可以安全赋值给T),但不能写入(因为编译器不知道具体是哪个子类型,所以add()除了null之外任何类型都不能安全写入)。? super T(下界通配符)表示"某个T的父类型",可以写入(add(T)是安全的,因为T一定是这个未知父类型的子类),但读取只能赋值给Object(因为编译器不知道具体是哪个父类型)。这就是PECS原则的理论基础。
new T[]?答案:因为类型擦除后T变为Object,new T[]等同于new Object[],但数组是协变的(covariant),如果允许创建泛型数组会导致类型安全问题。例如假设允许List<String>[] array = new List<String>[1],擦除后为List[] array = new List[1],然后Object[] objArray = array; objArray[0] = new List<Integer>();就能把List<Integer>放入原本只应存放List<String>的数组,运行时取出来转型会报ClassCastException。Java设计者在编译期就禁止了这种不安全的操作。
答案:泛型方法是在方法声明中定义类型参数的方法,格式:public <T> T methodName(T param),类型参数在返回值之前声明。类型推断是编译器根据方法调用时传入的参数类型自动推断泛型类型参数的能力。JDK5时类型推断能力有限,JDK8大幅增强(目标类型推断),JDK11进一步改进。例如Collections.emptyList()返回List<T>,编译器能根据上下文推断T的类型:List<String> list = Collections.emptyList();不需要显式指定Collections.<String>emptyList()。
答案:虽然编译后泛型类型会被擦除,但在某些场景下仍然可以通过反射获取泛型信息:(1) 通过Field.getGenericType()获取字段的泛型类型(如List<String>的类型信息保存在Signature属性中);(2) 通过Method.getGenericReturnType()/getGenericParameterTypes()获取方法返回值和参数的泛型类型;(3) 通过TypeToken<Gson>或TypeReference<T>(Jackson)等模式——创建匿名子类来捕获泛型类型参数。这些信息保存在class文件的Signature属性中,类加载时存入方法区,运行时可通过反射API读取。
答案:所有异常都继承自Throwable类,分为两大分支:Error和Exception。Error表示JVM层面的严重错误(如OutOfMemoryError、StackOverflowError),程序不应捕获处理。Exception分为受检异常(Checked Exception)和非受检异常(Unchecked Exception)。受检异常在编译期检查,必须用try-catch捕获或在方法签名中throws声明(如IOException、SQLException)。非受检异常即RuntimeException及其子类(如NullPointerException、ArrayIndexOutOfBoundsException),编译器不强制处理,通常是编程逻辑错误。
答案:Checked Exception(受检异常)继承自Exception但不是RuntimeException,编译器强制要求处理(try-catch或throws),用于表示程序可以合理恢复的异常情况(如文件不存在、网络超时)。Unchecked Exception(非受检异常)继承自RuntimeException,编译器不强制处理,用于表示编程错误(如空指针、数组越界、类型转换错误)。争议:Checked Exception增加了代码冗余(每个方法都要声明throws),Spring/Hibernate等框架都将Checked Exception转换为Unchecked Exception(DataAccessException等),现代Java开发倾向于使用Unchecked Exception。
答案:throw是一个语句,用于在方法内部主动抛出一个异常对象(throw new IllegalArgumentException("参数错误")),执行throw后方法立即终止,异常向上传播。throws是方法签名的一部分,声明该方法可能抛出的受检异常类型(public void read() throws IOException),告诉调用者需要处理这些异常。一个方法可以有多个throws声明的异常类型(逗号分隔),但throw一次只能抛出一个异常对象。throw可以用在任意代码位置,throws只能出现在方法签名中。
答案:异常链允许在捕获一个异常后将其包装为另一个异常重新抛出,同时保留原始异常信息。通过new Exception("message", cause)构造方法或initCause()方法将原始异常(cause)附加到新异常上。调用getCause()可以获取原始异常,printStackTrace()会打印完整的异常链。典型场景:将底层技术异常(如SQLException)包装为业务异常(如DataAccessException),对外暴露统一的异常类型,同时保留根本原因用于调试。Spring的DataAccessException体系就是异常链的经典应用。
答案:取决于业务场景和团队约定。继承Exception(受检异常)会强制调用者处理,适合"可以合理恢复且调用者必须知道的异常"(如余额不足、库存不足)。继承RuntimeException(非受检异常)不强制处理,适合"调用者通常无法有效恢复的异常"或"通过参数校验可以避免的异常"。现代企业开发的趋势是使用非受检异常(如Spring的体系),在全局异常处理器(@ControllerAdvice + @ExceptionHandler)中统一处理,减少业务代码中的try-catch样板代码。
答案:四种方式:(1) 类名.class——编译期确定,如String.class,最简洁高效;(2) 对象.getClass()——运行时获取,如"hello".getClass(),返回运行时实际类型;(3) Class.forName("全限定类名")——通过类名动态加载,如Class.forName("java.lang.String"),会触发类的初始化(执行static块),JDBC加载驱动就是用这种方式;(4) ClassLoader.loadClass("全限定类名")——通过类加载器加载,不会触发初始化。第(3)和(4)的区别在于是否执行类的clinit方法(static初始化块)。
答案:两种方式:(1) Class.newInstance()(已deprecated in JDK9)——调用无参构造方法创建对象,要求类必须有public无参构造器,且构造方法不能抛出受检异常。已废弃的原因是它会绕过编译时的异常检查。(2) Constructor.newInstance()——通过clazz.getDeclaredConstructor()获取构造器对象,再调用newInstance(args)。这种方式支持有参构造、private构造(配合setAccessible(true)),且正确传播构造方法声明的异常。Spring的IoC容器就是用Constructor.newInstance来创建Bean实例的。
答案:反射慢的主要原因:(1) 方法调用的安全性检查——每次调用都需要检查访问权限、参数类型匹配等,而正常方法调用在编译期就完成了;(2) 无法被JIT内联优化——正常方法调用在热点代码中会被JIT内联(inline),反射调用无法内联;(3) 参数需要装箱/拆箱/类型转换——反射的Method.invoke参数是Object[],基本类型需要自动装箱;(4) 每次调用都需要查找方法——getDeclaredMethod()需要遍历方法数组查找。缓解措施:缓存Method对象、使用MethodHandle(JDK7+)、使用字节码生成库(如cglib、ByteBuddy)。
答案:setAccessible(true)是AccessibleObject(Method/Field/Constructor的父类)的方法,作用是抑制Java访问控制检查,允许访问private/protected成员。它不会修改类或成员的实际访问修饰符,只是绕过了安全检查。注意在模块化系统(JDK9+)中,即使setAccessible(true)也可能失败——如果目标类在不同模块中且没有通过--add-opens开放包。Spring、Hibernate等框架大量使用反射+setAccessible来注入private字段,这也是为什么运行Spring应用时经常需要添加--add-opensJVM参数。
答案:(1) Spring IoC——通过反射实例化Bean(Constructor.newInstance)、注入依赖(Field.set)、处理AOP代理(Method.invoke);(2) Spring MVC——通过反射调用Controller方法(HandlerAdapter使用Method.invoke);(3) MyBatis——通过反射将ResultSet列映射到实体类字段(MetaObject);(4) Jackson/Gson——通过反射获取Java类的属性和getter/setter进行JSON序列化/反序列化;(5) JUnit——通过反射扫描@Test注解并执行测试方法;(6) 注解处理器——运行时通过反射读取注解信息。
答案:Java注解本质上是继承自java.lang.annotation.Annotation接口的接口。例如@Override的定义是public @interface Override extends Annotation {}。编译后生成的字节码中,注解会被编译为一个接口加上一个实现了该接口的动态代理类。当通过反射获取注解时(如method.getAnnotation(MyAnnotation.class)),返回的是JVM动态生成的代理对象。这意味着注解不是代码逻辑的一部分,而是附加在代码上的元数据(metadata),需要通过工具(编译器注解处理器或运行时反射)来消费。
答案:元注解(meta-annotation)是用于定义注解的注解,共5个标准元注解:(1) @Target——指定注解能用在哪些位置(ElementType枚举:TYPE/FIELD/METHOD/PARAMETER/CONSTRUCTOR等);(2) @Retention——指定注解的保留策略(RetentionPolicy:SOURCE编译时丢弃/CLASS字节码保留但不加载/RUNTIME运行时可通过反射获取);(3) @Documented——注解会被Javadoc工具记录到文档中;(4) @Inherited——注解可以被子类继承(仅对类级别的注解有效);(5) @Repeatable(JDK8)——注解可以在同一位置重复使用。其中最常用的是@Target和@Retention。
答案:APT(Annotation Processing Tool)是JDK提供的编译期注解处理机制,在编译阶段扫描和处理注解,可以生成新的Java源文件但不能修改已有代码。实现方式是继承AbstractProcessor,重写process()方法,通过FilerAPI生成Java文件。典型框架:Lombok(修改AST而非生成新文件,严格来说不是标准APT)、ButterKnife、Dagger2、MapStruct(编译期生成实现类)、AutoService(自动生成SPI配置文件)。相比运行时反射,编译期处理的优点是零运行时开销、编译期发现错误,是现代Java框架的趋势。
答案:运行时注解的@Retention为RUNTIME,通过反射在运行时读取和处理(如Spring的@Component/@Autowired、JUnit的@Test)。缺点是反射有性能开销且错误在运行时才能发现。编译期注解的@Retention为SOURCE或CLASS,在编译阶段通过APT处理,生成代码或做校验(如Dagger2生成依赖注入代码、MapStruct生成映射器)。编译期注解性能更好、错误更早发现,但开发复杂度更高。Lombok比较特殊,它通过修改编译期的AST(抽象语法树)来实现,既不是标准APT也不是运行时反射。
答案:SPI(Service Provider Interface)是Java提供的服务发现机制,允许第三方为某个接口提供实现,并在运行时自动发现和加载。使用步骤:(1) 定义一个接口(如interface DataSource);(2) 第三方提供实现类;(3) 在classpath的META-INF/services/目录下创建以接口全限定名为名的文件,文件内容为实现类的全限定名(每行一个);(4) 通过ServiceLoader.load(接口.class)或java.util.ServiceLoader加载所有实现。SPI实现了接口与实现的解耦,是面向接口编程+插件化架构的重要支撑。
答案:(1) JDBC——java.sql.Driver接口,各数据库厂商(MySQL/Oracle/PostgreSQL)在驱动jar的META-INF/services/java.sql.Driver文件中声明实现类,DriverManager通过SPI自动加载;(2) SLF4J——日志门面接口,Logback/Log4j2等实现通过SPI绑定;(3) Spring Boot自动配置——spring.factories(Spring Boot 2.x)和META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports(Spring Boot 3.x)本质是SPI的扩展;(4) Dubbo——大量使用SPI实现可扩展的微服务框架,Dubbo SPI扩展了Java标准SPI支持按名获取实现和依赖注入。
答案:Java标准SPI通过ServiceLoader.load()一次性加载所有实现类,不支持按名获取特定实现,且没有懒加载(全部实例化浪费资源)。Dubbo SPI扩展了Java SPI:(1) 使用@SPI("dubbo")注解标记接口并指定默认实现;(2) 配置文件使用key=value格式(如dubbo=org.apache.dubbo.rpc.protocol.dubbo.DubboProtocol),支持按key获取特定实现;(3) 支持懒加载(用到时才实例化)和自动注入(实现类中可以使用其他扩展点);(4) 支持自适应扩展(@Adaptive根据URL参数动态选择实现)和自动包装(Wrapper模式)。
答案:Java对象在内存中由三部分组成:(1) 对象头(Object Header)——包含Mark Word(存储GC年龄、锁状态标志、线程持有的锁、偏向线程ID等,64位JVM占8字节)和Klass Pointer(指向类元数据的指针,默认开启压缩指针占4字节,否则8字节),如果是数组还有数组长度(4字节);(2) 实例数据(Instance Data)——对象实际存储的字段值(包括从父类继承的字段),字段按类型大小重新排列以优化内存对齐;(3) 对齐填充(Padding)——保证对象大小是8字节的倍数(JVM要求对象起始地址必须是8的倍数),不足则补齐。
答案:以64位JVM为例,Mark Word的64位存储内容随锁状态变化:(1) 无锁状态:存储对象的hashCode(31位)、GC分代年龄(4位)、是否偏向(1位)、锁标志位(2位=01);(2) 偏向锁:存储偏向线程ID(54位)、时间戳(2位)、GC年龄(4位)、偏向标志(1位=1)、锁标志位(01);(3) 轻量级锁:指向栈中Lock Record的指针(62位)、锁标志位(00);(4) 重量级锁:指向ObjectMonitor的指针(62位)、锁标志位(10);(5) GC标记:空(62位)、锁标志位(11)。锁标志位占2位,和是否偏向1位共同标识五种状态。
答案:Compressed Oops(Compressed Ordinary Object Pointers)是JDK6u23+默认开启的优化,将64位JVM中的对象引用从8字节压缩为4字节。原理:大多数JVM堆内存不超过32GB,而4字节指针配合8字节对齐可以寻址2^32 × 8 = 32GB空间。通过-XX:+UseCompressedOops开启(默认),-XX:-UseCompressedOops关闭。当堆内存超过32GB时指针压缩自动失效,所以64位JVM使用32GB以内的堆内存效率更高。指针压缩使得64位JVM的对象内存占用接近32位,大大减少了内存浪费。
答案:计算方法:(1) 对象头:64位JVM开启指针压缩时12字节(8字节Mark Word + 4字节Klass Pointer),未压缩时16字节;(2) 实例数据:基本类型直接计算(int=4、long=8、boolean=1),引用类型压缩后4字节否则8字节;(3) 对齐填充:对象总大小必须是8的倍数。例如new Object()只有对象头12字节+4字节填充=16字节。一个Integer对象=12字节头+4字节int值=16字节(刚好对齐)。一个ArrayList对象=12字节头+4字节int size+4字节int modCount+4字节Object[]引用+4字节int capacity=28字节,填充到32字节。可用JOL(Java Object Layout)工具精确计算。
答案:(1) 强引用(Strong Reference)——普通赋值Object obj = new Object(),只要引用存在GC就不会回收,即使OOM也不回收;(2) 软引用(SoftReference)——通过SoftReference<Object>包装,在内存不足时才会被GC回收,适合做缓存(如Guava Cache的弱键/软值);(3) 弱引用(WeakReference)——通过WeakReference<Object>包装,下一次GC时无论内存是否充足都会被回收,适合临时缓存(如ThreadLocal的ThreadLocalMap的key);(4) 虚引用(PhantomReference)——通过PhantomReference<Object>包装,无法通过get()获取对象,唯一作用是在对象被回收时收到通知(配合ReferenceQueue),用于管理直接内存(Cleaner机制)。
答案:Java只有值传递(pass by value),没有引用传递。对于基本类型,传递的是值的副本;对于引用类型(对象、数组),传递的是引用的副本(即地址值的副本)。因此方法内无法改变实参引用的指向(如swap(Object a, Object b)不行),但可以通过引用副本修改对象内部的字段(如obj.setName("new")可以)。这是面试中最容易混淆的点:传递对象时看起来像是引用传递,实际上传递的是引用的值(地址的拷贝),只是这个拷贝和原始引用指向同一个对象。
答案:浅拷贝:创建一个新对象,然后将原对象的所有字段直接复制过来。对于基本类型字段复制值,对于引用类型字段复制引用(新旧对象共享同一个引用对象)。实现方式:Object.clone()(实现Cloneable接口)。深拷贝:递归复制所有层级,新旧对象完全独立,修改一个不会影响另一个。实现方式:(1) 重写clone()方法递归调用所有引用类型的clone();(2) 序列化/反序列化(实现Serializable,通过ByteArrayOutputStream/ObjectOutputStream序列化后再反序列化);(3) 使用JSON序列化(如Jackson的objectMapper.readValue(objectMapper.writeValueAsString(obj), Clazz))。
答案:自动装箱(Autoboxing):基本类型自动转为包装类型,如Integer i = 10;编译为Integer i = Integer.valueOf(10);。自动拆箱(Unboxing):包装类型自动转为基本类型,如int n = i;编译为int n = i.intValue();。IntegerCache缓存了-128到127的Integer对象(IntegerCache.cache数组),Integer.valueOf()在这个范围内返回缓存对象(==为true),超出范围则创建新对象(==为false)。陷阱:Integer a = 128; Integer b = 128; a == b为false,但Integer a = 127; Integer b = 127; a == b为true。自动拆箱可能引发NullPointerException(如Integer i = null; int n = i;)。