Java 语言特性(面试系列1)

一、面向对象编程

1. 封装（Encapsulation）

• 定义：将数据（属性）和操作数据的方法绑定在一起，通过访问控制符（private、protected、public）隐藏内部实现细节。
• 示例：

  public class Person {private String name; // 私有属性，外部无法直接访问public String getName() { return name; } // 公开访问方法public void setName(String name) { this.name = name; }
  }

• 优点：提高安全性，降低耦合度，便于维护。

2. 继承（Inheritance）

• 定义：子类继承父类的属性和方法，通过extends关键字实现，支持单继承。
• 特性：
  • 子类可重写（Override）父类方法。
  • 构造器不能被继承，但可通过super()调用父类构造器。
• 示例：

  public class Student extends Person {private int studentId;// 继承了Person的name和getName()/setName()
  }

3. 多态（Polymorphism）

• 定义：同一方法调用可表现出不同行为，通过继承、接口实现和方法重写实现。
• 实现方式：
  • 编译时多态：方法重载（Overload，参数列表不同）。
  • 运行时多态：父类引用指向子类对象，动态调用重写方法。
• 示例：

  Person p = new Student(); // 父类引用指向子类对象
  p.getName(); // 实际调用Student类重写的方法

4. 抽象类 vs 接口

特性	抽象类（abstract class）	接口（interface）
实例化	不能实例化	不能实例化
方法实现	可包含抽象方法和具体方法	全部是抽象方法（Java 8 + 支持默认方法）
继承 / 实现	单继承	可实现多个接口
访问修饰符	各种修饰符	默认 public
字段	各种类型字段	默认 public static final 常量
设计目的	代码复用，抽取共性	定义行为规范，实现多继承能力

二、核心类库

1. String 类

• 不可变性：String对象一旦创建，其值不可变（由final char[]实现）

  String s = "abc"; // 实际创建新对象
  s = s + "d"; // 生成新String对象"abcd"

  字符串常量池：JVM 为节省内存，相同字面量的字符串共享同一个实例。

  String s1 = "abc";
  String s2 = "abc";
  System.out.println(s1 == s2); // true（指向常量池同一对象）

• StringBuilder vs StringBuffer：
  • StringBuilder：非线程安全，性能高（推荐日常使用）。
  • StringBuffer：线程安全（方法加synchronized）。

2. Integer 类

• 自动装箱 / 拆箱

  Integer i = 10; // 自动装箱：Integer.valueOf(10)
  int j = i; // 自动拆箱：i.intValue()

  缓存机制：Integer缓存-128~127之间的对象，超出范围时创建新对象。

  Integer a = 100, b = 100;
  System.out.println(a == b); // true（缓存对象）Integer x = 200, y = 200;
  System.out.println(x == y); // false（不同对象）

3. 集合框架

• List：有序可重复，常用实现类：
  • ArrayList：动态数组，查询快，增删慢。
  • LinkedList：双向链表，增删快，查询慢。
• Set：无序不可重复，常用实现类：
  • HashSet：基于 HashMap，元素需重写hashCode()和equals()。
  • TreeSet：基于红黑树，元素需实现Comparable接口或提供Comparator。
• Map：键值对存储，常用实现类：
  • HashMap：线程不安全，无序，JDK8 后采用数组 + 链表 + 红黑树（链表长度≥8 时转换为树）。
  • ConcurrentHashMap：线程安全，分段锁实现（JDK8 采用 CAS+synchronized）。
  • TreeMap：基于红黑树，按键排序。

4. 并发包（JUC）

• 线程池：ExecutorService接口，常用实现：
  • ThreadPoolExecutor：手动配置核心参数（核心线程数、最大线程数等）。
  • Executors工具类：提供快速创建线程池的静态方法（如newFixedThreadPool）。
• 锁机制：
  • ReentrantLock：可重入锁，比synchronized更灵活（支持公平锁、可中断锁）。
  • ReadWriteLock：读写分离锁，读锁共享，写锁互斥。
• 原子类：AtomicInteger、AtomicLong等，基于 CAS（Compare-and-Swap）实现无锁原子操作。
• 并发容器：
  • ConcurrentHashMap：线程安全的 HashMap。
  • CopyOnWriteArrayList：写时复制的 List，读操作无锁，写操作复制数组。

三、高级特性

1. 反射（Reflection）

• 定义：在运行时动态获取类的信息（字段、方法、构造器）并操作对象。
• 核心类：Class、Field、Method、Constructor。
• 应用场景：框架开发（如 Spring 的依赖注入）、JSON 反序列化。
• 示例：

  Class<?> clazz = Class.forName("com.example.Person");
  Method method = clazz.getMethod("getName");
  Object instance = clazz.getDeclaredConstructor().newInstance();
  String name = (String) method.invoke(instance);

2. 注解（Annotation）

• 内置注解：@Override、@Deprecated、@SuppressWarnings。
• 元注解：用于定义注解的注解（@Retention、@Target、@Documented、@Inherited）。
• 自定义注解：

  @Retention(RetentionPolicy.RUNTIME)
  @Target(ElementType.METHOD)
  public @interface MyAnnotation {String value() default "";
  }

• 应用场景：测试框架（JUnit）、ORM（MyBatis）、Spring 的@Component等。

3. 泛型（Generic）

• 定义：参数化类型，在编译时检查类型安全。
• 通配符：
  • <? extends T>：上界通配符（只读取，不写入）。
  • <? super T>：下界通配符（只写入，不读取）。
• 类型擦除：泛型信息在编译后被擦除，运行时无法获取

  List<String> list = new ArrayList<>();
  // 编译后等同于 List list = new ArrayList();

4. Stream API

• 定义：用于对集合数据进行高效处理的流式操作。
• 特性：
  • 中间操作：返回 Stream（如filter、map、sorted）。
  • 终端操作：返回结果（如collect、forEach、count）。

  • List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
    List<String> filtered = names.stream().filter(n -> n.length() > 4).map(String::toUpperCase).collect(Collectors.toList());

5. Lambda 表达式

• 定义：简化匿名内部类的语法糖，用于实现函数式接口。
• 语法：(参数) -> { 方法体 }。
• 示例：

  // 传统方式
  new Thread(new Runnable() {@Overridepublic void run() {System.out.println("Hello");}
  }).start();// Lambda方式
  new Thread(() -> System.out.println("Hello")).start();

四、内存管理

1. GC 机制

• 垃圾回收对象：不再被引用的对象（如Object obj = new Object(); obj = null;）。
• 常见算法：
  • 标记 - 清除（Mark-Sweep）：标记无用对象后清除，产生内存碎片。
  • 复制（Copying）：将存活对象复制到新区域，适用于新生代。
  • 标记 - 整理（Mark-Compact）：标记后整理内存，避免碎片，适用于老年代。
• 分代收集：
  • 新生代：Eden 区 + 两个 Survivor 区，频繁 GC（Minor GC）。
  • 老年代：长期存活对象，GC 频率低（Major GC/FULL GC）。
  • 永久代 / 元空间：存储类信息、常量池（JDK8 后元空间使用本地内存）。

2. 堆与栈

内存区域	存储内容	线程独享 / 共享	特点
堆（Heap）	对象实例、数组	共享	内存大，GC 管理
栈（Stack）	局部变量、方法调用帧	独享	速度快，内存小，自动分配
方法区	类信息、静态变量、常量池	共享	JDK8 后改为元空间

3. OOM 场景及调优(Out Of Memory)

• 常见 OOM 类型：
  • Java heap space：堆内存不足（如创建大量对象）。
  • GC overhead limit exceeded：GC 耗时过长且回收内存少。
  • PermGen space/Metaspace：永久代 / 元空间溢出（如动态生成大量类）。
  • Direct buffer memory：NIO 直接内存溢出。
• 调优工具：
  • JVM 参数：-Xmx（最大堆内存）、-Xms（初始堆内存）、-XX:MetaspaceSize等。
  • 分析工具：VisualVM、MAT（Memory Analyzer Tool）、GC 日志分析。
• 调优思路：
  • 减少对象生命周期，及时释放资源。
  • 调整堆内存大小和比例（如新生代与老年代比例）。
  • 避免内存泄漏（如静态集合持有大对象）