一、Java 基础语法高频考点（20个）

1.Java 的三大特性：跨平台性（JVM实现）、面向对象、安全性（沙箱机制）。

2.JVM、JRE、JDK 的区别（必考）：JDK包含JRE，JRE包含JVM；JDK用于开发，JRE用于运行，JVM负责跨平台。

3.Java 程序的运行流程：编写.java文件→javac编译→生成.class字节码文件→JVM加载运行。

4.标识符的命名规则（★）：由字母、数字、_、$组成，不能以数字开头，区分大小写，不能使用关键字/保留字（如int、class）。

5.关键字与保留字的区别：关键字已被Java赋予特定含义（如public、static），保留字暂未使用但禁止作为标识符（如goto、const）。

6.基本数据类型（8种）：byte（1字节）、short（2）、int（4）、long（8）、float（4）、double（8）、char（2）、boolean（1位）。

7.基本数据类型与引用数据类型的区别（必考）：基本类型存值，引用类型存地址；基本类型在栈中，引用类型栈存地址、堆存对象。

8.自动装箱与拆箱（★）：基本类型→包装类为装箱（如int→Integer），包装类→基本类型为拆箱；JDK1.5后自动实现，注意空指针问题（如Integer i=null; int j=i; 报错）。

9.包装类的常量池（★）：Integer、Byte、Short、Long、Character、Boolean有常量池，默认缓存-128~127的数值（如Integer a=127; Integer b=127; a==b为true）。

10.变量的作用域：局部变量（方法/代码块内，必须初始化）、成员变量（类内方法外，默认初始化）、静态变量（static修饰，属于类，全局唯一）。

11.static关键字的作用（必考）：修饰变量（类变量）、方法（类方法，不能直接访问非静态成员）、代码块（静态代码块，类加载时执行一次）、内部类（静态内部类，不依赖外部类对象）。

12.final关键字的作用（必考）：修饰类（不能被继承）、方法（不能被重写）、变量（常量，初始化后不能修改，引用类型常量不能修改地址）。

13.访问修饰符的权限（从小到大）：private（本类）→default（同包）→protected（同包+子类）→public（全局）（必考）。

14.运算符优先级（高频）：算术运算符（*、/、%优先于+、-）→关系运算符→逻辑运算符（&&优先于||）→赋值运算符。

15.短路与（&&）和逻辑与（&）的区别（★）：&&短路，左边为false时右边不执行；&不短路，两边都执行。

16.三元运算符语法：条件表达式 ? 表达式1 : 表达式2；表达式1和表达式2类型必须一致（或可自动转换）。

17.流程控制语句：if-else（注意else的匹配规则）、switch-case（JDK1.7后支持String，case后必须加break，否则穿透）、for（含增强for）、while、do-while（至少执行一次）。

18.break与continue的区别：break跳出当前循环/switch，continue跳过本次循环，进入下一次循环。

19.数组的定义与初始化：静态初始化（int[] arr = {1,2,3}）、动态初始化（int[] arr = new int[3]）；数组长度不可变，通过length属性获取长度。

20.数组的遍历方式：for循环、增强for循环（for(int num : arr)）、Arrays.toString(arr)（打印数组）。

21.String类的特性（必考）：不可变字符序列，底层是char数组（JDK1.9后改为byte数组）；常用方法（equals、length、substring、replace、split、trim）。

22.String、StringBuffer、StringBuilder的区别（必考★）：String不可变，StringBuffer线程安全（效率低），StringBuilder非线程安全（效率高）；三者底层都是字符数组。

23.equals与==的区别（必考★）：==比较地址（基本类型比较值），equals默认比较地址（Object类），String重写后比较内容。

二、面向对象高频考点（20个）

1.面向对象的三大核心特性（必考）：封装、继承、多态。

2.封装的定义与实现：隐藏对象的属性和实现细节，只对外提供公共访问方式（getter/setter）；作用：提高安全性、简化操作、提高代码复用性。

3.继承的定义与注意事项（必考）：子类继承父类的非private成员（属性、方法）；Java单继承（一个子类只能有一个直接父类），但支持多层继承；子类构造方法默认调用父类无参构造（super()）。

4.super关键字的作用（必考）：调用父类的构造方法（super()必须在子类构造方法第一行）、调用父类的成员变量（super.属性）、调用父类的成员方法（super.方法()）。

5.this关键字的作用（必考）：指代当前对象，调用当前对象的成员变量（this.属性）、成员方法（this.方法()）、构造方法（this()，必须在构造方法第一行，不能与super()同时使用）。

6.方法重写（Override）的规则（必考★）：子类方法与父类方法的方法名、参数列表、返回值类型（子类≤父类，支持协变返回）完全一致；子类访问权限≥父类；父类方法不能是private（无法重写）；不能抛出比父类更多、更高级的异常。

7.方法重载（Overload）的规则（必考★）：同一类中，方法名相同，参数列表（参数个数、类型、顺序）不同；与返回值类型、访问修饰符无关。

8.重写与重载的区别（必考）：重写是子类与父类之间，方法签名完全一致；重载是同一类中，方法签名不同。

9.多态的定义与实现条件（必考）：同一行为，不同对象有不同表现形式；条件：子类继承父类、子类重写父类方法、父类引用指向子类对象（向上转型）。

10.向上转型与向下转型（★）：向上转型（父类引用=子类对象，自动转换，丢失子类特有方法）；向下转型（子类引用=(子类)父类引用，强制转换，需先判断（instanceof），否则报ClassCastException）。

11.instanceof关键字的作用（必考）：判断一个对象是否是某个类（或接口）的实例，返回boolean类型；用于向下转型前的校验。

12.抽象类（abstract）的定义与注意事项（必考）：包含抽象方法的类，必须用abstract修饰；抽象类不能实例化；抽象方法没有方法体，必须由子类重写（子类非抽象）；抽象类可以有非抽象方法、构造方法。

13.接口（interface）的定义与注意事项（必考）：JDK1.8前，接口中只有抽象方法（public abstract）和常量（public static final）；JDK1.8后，支持默认方法（default，有方法体，子类可重写）、静态方法（static，属于接口）；JDK1.9后，支持私有方法（private）；类实现接口（implements），必须重写所有抽象方法（类非抽象）；一个类可以实现多个接口，接口可以多继承。

14.抽象类与接口的区别（必考★）：抽象类单继承，接口多实现；抽象类有构造方法，接口没有；抽象类可以有非抽象方法，JDK1.8前接口只有抽象方法；抽象类体现继承关系，接口体现实现关系。

15.内部类的分类（高频）：成员内部类（类内方法外，依赖外部类对象）、局部内部类（方法/代码块内，不能用static修饰）、静态内部类（static修饰，不依赖外部类）、匿名内部类（无类名，只能使用一次，常用于简化接口/抽象类实现）。

16.匿名内部类的注意事项（★）：匿名内部类是局部内部类的特殊形式，不能有构造方法；不能定义静态成员；访问外部局部变量，必须用final修饰（JDK1.8后隐式final）。

17.Object类的核心方法（必考）：equals（默认比较地址）、hashCode（返回对象的哈希值，与equals一致：equals相等，hashCode必相等；hashCode相等，equals不一定相等）、toString（默认返回类名+@哈希值，建议重写）、getClass（返回对象的运行时类）、wait/notify/notifyAll（线程通信，需在同步代码块中使用）、finalize（垃圾回收时调用，不建议重写）。

18.hashCode与equals的关系（必考★）：重写equals时，必须重写hashCode；否则会导致HashSet、HashMap等集合中，equals相等的对象被视为不同元素（因为哈希值不同）。

19.构造方法的特点（高频）：方法名与类名一致，无返回值（不能写void）；默认有一个无参构造（若自定义构造方法，默认无参构造失效）；用于初始化对象。

20.单例模式的核心与实现（必考）：核心是一个类只有一个实例，提供全局唯一访问点；常见实现：饿汉式（线程安全，加载时初始化）、懒汉式（延迟初始化，需加锁保证线程安全）、双重检查锁（DCL，高效且线程安全）、静态内部类（推荐，线程安全，延迟初始化）。

三、泛型高频考点（15个）

1.泛型的定义与作用（必考）：参数化类型，将类型作为参数传递；作用：提高代码复用性、避免类型转换异常（编译期检查类型安全）。

2.泛型的使用场景：泛型类（如ArrayList<T>）、泛型方法（如public <T> T get(T t)）、泛型接口（如List<T>）。

3.泛型类的定义语法：class 类名<类型参数列表> {  // 类型参数常用T、E、K、V（T=Type，E=Element，K=Key，V=Value） }

4.泛型方法的定义语法（★）：修饰符 <类型参数> 返回值类型方法名(参数列表) { ... }；泛型方法可以独立于泛型类存在。

5.泛型通配符（必考★）：?（无界通配符）、? extends T（上界通配符，只能读取，不能添加，T及其子类）、? super T（下界通配符，只能添加T及其子类，读取时为Object）。

6.泛型擦除机制（必考★）：Java泛型是编译期语法糖，运行时会擦除泛型类型信息（擦除为Object或上界类型）；因此运行时无法获取泛型的具体类型。

7.泛型擦除的影响（★）：不能用泛型类型创建数组（如new ArrayList<String>[10] 报错）；不能用泛型类型作为instanceof的参数（如obj instanceof ArrayList<String> 报错）；不能在静态方法中使用泛型类的类型参数（因为静态方法属于类，类加载时泛型未确定）。

8.泛型与继承的关系（★）：ArrayList<String> 不是 ArrayList<Object> 的子类；泛型类不具备协变性，需用通配符实现（如ArrayList<? extends Object> list = new ArrayList<String>()）。

9.泛型方法与普通方法的区别：泛型方法的类型参数由调用时确定，普通方法的参数类型在定义时确定。

10.泛型接口的实现：实现泛型接口时，可以指定具体类型（如class MyList implements List<String>），也可以继续保留泛型（如class MyList<T> implements List<T>）。

11.受限泛型（上界/下界）的使用场景：上界通配符用于读取数据（如集合遍历），下界通配符用于添加数据（如集合批量添加）。

12.泛型中的类型参数不能是基本数据类型（★）：如ArrayList<int> 报错，需用包装类（ArrayList<Integer>）。

13.泛型方法的类型推断：调用泛型方法时，若能从参数中推断出类型，可省略类型参数（如List&lt;String&gt; list = new ArrayList<>()，菱形语法，JDK1.7后支持）。

14.泛型与反射的结合（高频）：由于泛型擦除，反射获取泛型信息时，需通过ParameterizedType（参数化类型）获取（如获取泛型类的父类泛型、方法参数的泛型）。

15.常见泛型集合（必考）：ArrayList<T>、HashMap<K,V>、HashSet<T>，使用时必须指定泛型类型，否则会有编译警告。

四、注解高频考点（15个）

1.注解（Annotation）的定义与作用（必考）：Java语言的一种标记机制，用于对类、方法、参数等进行标注（无业务逻辑）；作用：编译期检查、代码生成、运行时获取标注信息（结合反射）。

2.注解的语法：用@interface关键字定义，如public @interface MyAnnotation { ... }

3.注解的组成：注解元素（参数），语法：类型元素名() default 默认值;（默认值可选，若没有默认值，使用注解时必须指定该元素）。

4.注解的分类（必考）：内置注解（JDK自带）、元注解（修饰注解的注解）、自定义注解。

5.JDK内置注解（高频）：@Override（标识方法重写，编译期检查）、@Deprecated（标识方法/类已过时，编译期警告）、@SuppressWarnings（抑制编译警告，如@SuppressWarnings("unchecked")）、@FunctionalInterface（标识函数式接口，JDK1.8后）、@SafeVarargs（抑制可变参数的泛型警告）。

6.元注解（必考★）：4个核心元注解，用于定义注解的生命周期、作用范围等：

￮@Retention：指定注解的生命周期（RetentionPolicy），可选SOURCE（源码期，编译后删除）、CLASS（类文件期，编译后保留，运行时不加载，默认）、RUNTIME（运行时期，保留到运行时，可通过反射获取，最常用）。

￮@Target：指定注解的作用范围（ElementType），可选TYPE（类/接口）、METHOD（方法）、FIELD（成员变量）、PARAMETER（方法参数）、CONSTRUCTOR（构造方法）等。

￮@Documented：指定注解是否被javadoc文档生成工具包含。

￮@Inherited：指定注解是否能被子类继承（只有作用于类的注解，子类才能继承）。

7.自定义注解的实现步骤（必考）：1. 用@interface定义注解；2. 添加元注解（指定@Retention和@Target）；3. 定义注解元素；4. 在类/方法上使用注解；5. 结合反射获取注解信息。

8.注解的使用语法：@注解名(元素名1=值1, 元素名2=值2, ...)；若注解只有一个元素，且元素名是value，可省略元素名（如@Test("test") 等价于 @Test(value="test")）。

9.注解与反射的关系（必考）：只有@Retention(RetentionPolicy.RUNTIME)的注解，才能在运行时通过反射获取（如getAnnotation()方法）；SOURCE和CLASS级别的注解，运行时无法获取。

10.@Override注解的作用（高频）：编译期检查方法是否真的重写了父类方法（若方法名、参数列表错误，编译报错）；只能作用于方法。

11.@Deprecated注解的作用：标识某个程序元素（类、方法、变量）已过时，提醒开发者不要使用；编译时会给出警告，不影响运行。

12.@SuppressWarnings注解的使用：指定要抑制的警告类型，如"unchecked"（泛型未指定类型警告）、"deprecation"（使用过时元素警告）、"all"（抑制所有警告）。

13.注解的本质（★）：注解本质是一个继承了java.lang.annotation.Annotation接口的接口，注解的元素本质是接口中的抽象方法。

14.注解的应用场景（高频）：Spring框架中的@Component、@Service、@Autowired；JUnit中的@Test；MyBatis中的@Mapper、@Select等，都是自定义注解的实际应用。

15.注解与注释的区别：注释是给开发者看的，不参与编译和运行；注解是给编译器/虚拟机看的，可参与编译和运行，有实际语义。

五、反射高频考点（20个）

1.反射的定义与作用（必考）：Java反射机制允许程序在运行时，获取类的信息（属性、方法、构造方法等），并操作类/对象的成员（即使是private修饰）；作用：提高代码灵活性、实现框架（如Spring、MyBatis）的核心功能。

2.反射的核心类（必考★）：java.lang.Class（代表类的运行时类型，是反射的入口）、java.lang.reflect.Field（代表类的成员变量）、Method（代表类的方法）、Constructor（代表类的构造方法）。

3.获取Class对象的3种方式（必考★）： 

￮类名.class（如Class<User> clazz = User.class;，编译期确定，最安全）；

￮对象.getClass()（如User user = new User(); Class<?> clazz = user.getClass();，运行时确定，需创建对象）；

￮Class.forName("全类名")（如Class<?> clazz = Class.forName("com.test.User");，运行时加载类，需处理ClassNotFoundException，最常用，适合动态加载）。

4.Class对象的特性（★）：一个类在JVM中只有一个Class对象，无论通过哪种方式获取，都是同一个实例；Class对象是单例的。

5.通过反射创建对象的2种方式（必考）：

￮clazz.newInstance()：调用类的无参构造方法（已过时，JDK9后推荐用Constructor.newInstance()）；

￮通过Constructor对象调用newInstance()：可调用有参构造方法（如Constructor<User> constructor = clazz.getConstructor(String.class); User user = constructor.newInstance("张三");）。

6.反射获取成员变量（Field）的方法（必考）：        

￮getField(String name)：获取类的public修饰的成员变量（包括父类）；

￮getDeclaredField(String name)：获取类自身声明的所有成员变量（无论访问修饰符，不包括父类）；

￮getFields()：获取所有public修饰的成员变量（包括父类）；

￮getDeclaredFields()：获取类自身声明的所有成员变量（无论访问修饰符，不包括父类）。

7.反射操作成员变量（Field）的方法（★）：

￮set(Object obj, Object value)：给对象的成员变量赋值（obj为对象，静态变量obj可设为null）；

￮get(Object obj)：获取对象的成员变量值；

￮setAccessible(true)：暴力破解访问权限（即使是private修饰，也能操作，注意安全性）。

8.反射获取方法（Method）的方法（必考）：    

￮getMethod(String name, Class<?>... parameterTypes)：获取类的public修饰的方法（包括父类）；

￮getDeclaredMethod(String name, Class<?>... parameterTypes)：获取类自身声明的所有方法（无论访问修饰符，不包括父类）；

￮getMethods()：获取所有public修饰的方法（包括父类的，含Object类的方法）；

￮getDeclaredMethods()：获取类自身声明的所有方法（无论访问修饰符，不包括父类）。

9.反射调用方法（Method）的方法（必考★）：invoke(Object obj, Object... args)：调用对象的方法（obj为对象，静态方法obj可设为null；args为方法参数）；返回值为方法的返回值。

10.反射获取构造方法（Constructor）的方法（高频）： 

￮getConstructor(Class<?>... parameterTypes)：获取类的public修饰的构造方法；

￮getDeclaredConstructor(Class<?>... parameterTypes)：获取类自身声明的所有构造方法（无论访问修饰符）；

￮getConstructors()：获取所有public修饰的构造方法；

￮getDeclaredConstructors()：获取类自身声明的所有构造方法（无论访问修饰符）。

11.反射操作构造方法的注意事项：调用private构造方法时，需先调用setAccessible(true)暴力破解权限。

12.反射获取类的基本信息（高频）：clazz.getName()（获取全类名）、clazz.getSimpleName()（获取类名，不含包名）、clazz.getSuperclass()（获取父类的Class对象）、clazz.getInterfaces()（获取类实现的所有接口）、clazz.isInterface()（判断是否是接口）、clazz.isAnnotation()（判断是否是注解）。

13.反射的优缺点（必考）：  

￮优点：提高代码灵活性、可扩展性，实现动态加载、解耦（框架核心）；

￮缺点：破坏封装性（可操作private成员）、性能较低（反射操作需动态解析，比直接调用慢）、代码可读性差。

14.反射中setAccessible(true)的作用（★）：取消Java语言的访问权限检查，允许访问private、protected等修饰的成员；但不改变成员本身的访问修饰符，只是临时绕过检查。

15.反射与泛型的结合（高频）：通过Method的getGenericReturnType()获取方法返回值的泛型类型，通过ParameterizedType解析泛型参数（如获取List<String>中的String）。

16.反射与注解的结合（必考）：通过Field、Method、Class的getAnnotation(Class<A> annotationClass)方法，获取运行时注解的信息（前提是注解的@Retention为RUNTIME）。

17.反射的应用场景（必考）：Spring的IOC容器（通过反射创建Bean）、MyBatis的SQL映射（通过反射封装结果集）、JUnit的@Test注解（通过反射调用测试方法）、动态代理。

18.反射调用方法时的异常处理（高频）：需处理IllegalAccessException（访问权限异常）、InvocationTargetException（方法调用本身抛出的异常）、NoSuchMethodException（方法不存在异常）等。

19.静态成员的反射操作（★）：操作静态变量、静态方法、静态构造方法时，obj参数可设为null（因为静态成员属于类，不属于对象）。

20.反射能否修改final修饰的成员变量（★）：可以，但有限制：final修饰的基本数据类型，反射无法修改（值已存入常量池）；final修饰的引用数据类型，反射可以修改其地址（但不推荐，破坏常量语义）。

21.Class.forName()与ClassLoader.loadClass()的区别（★）：Class.forName()会加载类，并执行类的静态代码块；ClassLoader.loadClass()只加载类，不执行静态代码块（延迟加载）。

六、Lambda 表达式高频考点（10个）

1.Lambda表达式的定义与作用（必考）：JDK1.8后引入的函数式编程语法糖，用于简化接口的实现（仅适用于函数式接口）；作用：简化代码、提高可读性、支持函数式编程。

2.函数式接口的定义（必考★）：只有一个抽象方法的接口（可以有默认方法、静态方法、私有方法）；可用@FunctionalInterface注解标识（编译期检查是否为函数式接口）。

3.Lambda表达式的语法（必考★）：(参数列表) -> { 方法体 };  简化规则：    

￮参数列表：若只有一个参数，可省略括号（如a -> { ... }）；参数类型可省略（类型推断）；

￮方法体：若只有一行代码，可省略大括号和return（如(a,b) -> a+b）；若有多行代码，必须加括号和return（如有返回值）。

4.Lambda表达式的使用前提（必考）：必须是函数式接口的实现场景（如接口作为方法参数、变量赋值）；否则无法使用Lambda表达式。

5.JDK内置函数式接口（必考★）：

￮Consumer<T>：消费型接口，有一个参数，无返回值（void accept(T t)）；

￮Supplier<T>：供给型接口，无参数，有返回值（T get()）；

￮Function<T,R>：函数型接口，有一个参数，有返回值（R apply(T t)）；

￮Predicate<T>：断言型接口，有一个参数，返回boolean类型（boolean test(T t)）。

6.Lambda表达式与匿名内部类的区别（必考★）：

￮语法：Lambda更简洁，匿名内部类语法繁琐；

￮接口限制：Lambda只能用于函数式接口，匿名内部类可用于任意接口/抽象类；

￮this指向：Lambda的this指向当前外部类对象，匿名内部类的this指向自身对象；

￮性能：Lambda性能略高于匿名内部类（JVM对Lambda有优化）。

7.Lambda表达式的变量捕获（★）：Lambda表达式中访问外部局部变量，该变量必须是final修饰（JDK1.8后隐式final，即变量不能被重新赋值）；访问外部成员变量（成员变量、静态变量）无限制。

8.Lambda表达式与方法引用的关系（高频）：方法引用是Lambda表达式的简化形式，当Lambda表达式的方法体只是调用一个已存在的方法时，可使用方法引用（如System.out::println 等价于 s -> System.out.println(s)）。

9.方法引用的常见形式（高频）：对象::实例方法、类::静态方法、类::实例方法（如String::equals 等价于 (s1,s2) -> s1.equals(s2)）。

10.Lambda表达式的应用场景（高频）：集合的遍历（如list.forEach(s -> System.out.println(s))）、线程的创建（如new Thread(() -> System.out.println("线程运行")).start()）、Stream API的操作（函数式编程核心）。

11.Lambda表达式的注意事项（★）：Lambda表达式没有自己的this和super，其this指向外部类的this；Lambda表达式不能用于创建匿名内部类（只能简化函数式接口实现）；不能在Lambda表达式中抛出未捕获的受检异常（需在方法体中处理，或函数式接口的抽象方法声明异常）。

七、备考小贴士

1. 100个考点中，标注「必考」「★」的是核心中的核心，优先背诵、熟练掌握，面试大概率会问；

2. 基础语法是根基，不要忽视简单考点（如equals与==、static用法），很多面试错题都出自基础；