Java 知识总结与面试题

public class User {    private String name;  // 隐藏内部数据        public String getName() {        return name;    }        public void setName(String name) {        if (name != null && name.length() > 0) {            this.name = name;        }    }}

public class Animal {    protected String name;        public void eat() {        System.out.println("Animal is eating");    }}public class Dog extends Animal {    public void bark() {        System.out.println("Dog is barking");    }        @Override    public void eat() {        super.eat();  // 调用父类方法        System.out.println("Dog is eating");    }}

Animal animal = new Dog();   // 父类引用指向子类对象animal.eat();                 // 调用的是 Dog 的 eat() 方法// animal.bark();            // ❌ 编译错误，父类引用看不到子类特有方法

// 抽象类：定义一种类型和公共行为public abstract class Shape {    protected String color;        public abstract double area();  // 抽象方法，子类必须实现        public void setColor(String color) {        this.color = color;    }}// 接口：定义能力public interface Drawable {    void draw();  // 默认 public abstract        default void print() {  // Java 8+ default 方法        System.out.println("Printing...");    }}

// 常用 APIList<String> list = new ArrayList<>();list.add("A");               // 添加list.get(0);                 // 取list.remove(0);              // 删list.contains("A");          // 是否包含list.size();                 // 大小

Map<String, Integer> map = new HashMap<>();map.put("key", 1);map.get("key");               // 1map.getOrDefault("key", 0);   // 1map.containsKey("key");       // truemap.forEach((k, v) -> System.out.println(k + "=" + v));

// 推荐用法Map<String, Object> concurrentMap = new ConcurrentHashMap<>();Queue<String> queue = new LinkedBlockingQueue<>();

List<Integer> list = Arrays.asList(3, 1, 4, 1, 5);Collections.sort(list);               // 排序Collections.reverse(list);            // 反转Collections.shuffle(list);            // 打乱Collections.max(list);                // 最大值Collections.min(list);                // 最小值Collections.binarySearch(list, 3);    // 二分查找Collections.unmodifiableList(list);   // 返回不可修改的视图

Throwable├── Error（不可恢复）│   ├── OutOfMemoryError│   ├── StackOverflowError│   └── NoClassDefFoundError└── Exception（可处理）    ├── RuntimeException（非受检异常）    │   ├── NullPointerException    │   ├── ArrayIndexOutOfBoundsException    │   ├── IllegalArgumentException    │   └── ArithmeticException    └── 受检异常（Checked Exception）        ├── IOException        ├── SQLException        └── FileNotFoundException

try {    // 可能抛出异常的代码    FileInputStream fis = new FileInputStream("test.txt");    int data = fis.read();} catch (FileNotFoundException e) {    // 处理特定异常    System.err.println("文件未找到: " + e.getMessage());} catch (IOException e) {    // 处理更通用的异常    System.err.println("IO 异常: " + e.getMessage());} finally {    // 无论是否异常都执行（释放资源）    if (fis != null) {        try { fis.close(); } catch (IOException e) { /* ignore */ }    }}

try (FileInputStream fis = new FileInputStream("test.txt");     BufferedReader br = new BufferedReader(new InputStreamReader(fis))) {    String line = br.readLine();    System.out.println(line);} catch (IOException e) {    System.err.println("IO 异常: " + e.getMessage());}// 无需在 finally 中手动 close，资源自动释放

public class BusinessException extends RuntimeException {    private Integer code;        public BusinessException(Integer code, String message) {        super(message);        this.code = code;    }        public Integer getCode() {        return code;    }}// 使用throw new BusinessException(40001, "用户名已存在");

// 泛型类public class Box<T> {    private T content;        public void set(T content) {        this.content = content;    }        public T get() {        return content;    }}// 泛型方法public static <T> T getMiddle(T... args) {    return args[args.length / 2];}// 使用Box<String> stringBox = new Box<>();stringBox.set("Hello");String str = stringBox.get();  // 无需强转

// 编译时List<String> list1 = new ArrayList<>();List<Integer> list2 = new ArrayList<>();// 运行时（擦除后）// list1 和 list2 都是 ArrayList，类型信息丢失System.out.println(list1.getClass() == list2.getClass());  // true

// ? extends T — 上界通配符（读数据时用）List<? extends Number> list = new ArrayList<Integer>();Number n = list.get(0);     // 可以读，最大到 Number// list.add(1);             // ❌ 不能写，因为具体类型未知// ? super T — 下界通配符（写数据时用）List<? super Integer> list2 = new ArrayList<Number>();list2.add(1);               // 可以写 Integer// Integer i = list2.get(0); // ❌ 不能读，因为可能是 Object// ? — 无界通配符List<?> list3 = new ArrayList<String>();// list3.add("test");        // ❌ 不能写（null 除外）Object obj = list3.get(0);   // 只能读为 Object

// 编译时检查@Override          // 重写父类方法@SuppressWarnings  // 抑制警告@Deprecated        // 标记已弃用// Spring 常用@Component         // 通用组件@Autowired         // 依赖注入@Service           // 业务层@Repository        // 持久层@Controller        // 控制层@Configuration     // 配置类@Value             // 注入属性值@Transactional     // 事务管理// Lombok@Data              // 生成 getter/setter/toString/equals/hashCode@Slf4j             // 生成 log 对象@Builder           // 建造者模式@NoArgsConstructor // 无参构造@AllArgsConstructor// 全参构造

// 文本文件读取（推荐）try (BufferedReader reader = new BufferedReader(new FileReader("test.txt"))) {    String line;    while ((line = reader.readLine()) != null) {        System.out.println(line);    }}// 二进制文件复制try (FileInputStream in = new FileInputStream("source.jpg");     FileOutputStream out = new FileOutputStream("dest.jpg")) {    byte[] buffer = new byte[8192];    int len;    while ((len = in.read(buffer)) != -1) {        out.write(buffer, 0, len);    }}

// NIO 核心组件// Channel — 通道（FileChannel、SocketChannel）// Buffer — 缓冲区（ByteBuffer、CharBuffer）// Selector — 多路复用器// NIO 快速读取文件示例try (RandomAccessFile file = new RandomAccessFile("test.txt", "r");     FileChannel channel = file.getChannel()) {    ByteBuffer buffer = ByteBuffer.allocate(1024);    int bytesRead = channel.read(buffer);    while (bytesRead != -1) {        buffer.flip();  // 切换为读模式        while (buffer.hasRemaining()) {            System.out.print((char) buffer.get());        }        buffer.clear();  // 清空，准备下次写入        bytesRead = channel.read(buffer);    }}

// 推荐：通过 ThreadPoolExecutor 创建ThreadPoolExecutor executor = new ThreadPoolExecutor(    2,                    // corePoolSize — 核心线程数    5,                    // maximumPoolSize — 最大线程数    60L,                  // keepAliveTime — 空闲线程存活时间    TimeUnit.SECONDS,     // 时间单位    new LinkedBlockingQueue<>(100),  // 工作队列    Executors.defaultThreadFactory(), // 线程工厂    new ThreadPoolExecutor.AbortPolicy()  // 拒绝策略);// 用法executor.execute(() -> System.out.println("Task executed"));executor.shutdown();  // 关闭线程池// 不建议用 Executors 创建（阿里巴巴 Java 规范禁止）// Executors.newFixedThreadPool(10);      // ❌ 队列无限大，可能 OOM// Executors.newCachedThreadPool();       // ❌ 线程无限多// Executors.newSingleThreadExecutor();   // ❌ 同上

public class Flag {    private volatile boolean running = true;        public void stop() {        running = false;  // volatile 保证修改对其他线程立即可见    }        public void run() {        while (running) {            // 不加 volatile，此循环可能永远不会停止（指令重排）        }    }}

// 常用于存储当前用户信息public class UserContext {    private static final ThreadLocal<User> currentUser = new ThreadLocal<>();        public static void set(User user) {        currentUser.set(user);    }        public static User get() {        return currentUser.get();    }        public static void remove() {        currentUser.remove();  // 必须清理，否则内存泄漏    }}

// 传统写法button.addActionListener(new ActionListener() {    @Override    public void actionPerformed(ActionEvent e) {        System.out.println("Clicked");    }});// Lambda 写法button.addActionListener(e -> System.out.println("Clicked"));// 多参数Comparator<String> comparator = (a, b) -> a.length() - b.length();

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");// 链式操作List<String> result = names.stream()    .filter(name -> name.length() > 3)    // 过滤    .map(String::toUpperCase)              // 映射    .sorted()                              // 排序    .collect(Collectors.toList());         // 收集// 常用操作names.stream()    .filter(n -> n.startsWith("A"))    .forEach(System.out::println);    long count = names.stream()    .filter(n -> n.length() > 3)    .count();    boolean anyMatch = names.stream()    .anyMatch(n -> n.equals("Bob"));    // 分组Map<Integer, List<String>> grouped = names.stream()    .collect(Collectors.groupingBy(String::length));

// 传统写法 — 大量 null 检查public String getCity(User user) {    if (user != null) {        Address address = user.getAddress();        if (address != null) {            return address.getCity();        }    }    return "Unknown";}// Optional 链式写法public String getCity(User user) {    return Optional.ofNullable(user)        .map(User::getAddress)        .map(Address::getCity)        .orElse("Unknown");}

// 新的日期 API（线程安全，不可变）LocalDate today = LocalDate.now();                    // 2024-01-15LocalTime now = LocalTime.now();                      // 14:30:00LocalDateTime dateTime = LocalDateTime.now();          // 2024-01-15T14:30// 格式化DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");String formatted = dateTime.format(formatter);         // 2024-01-15 14:30:00LocalDateTime parsed = LocalDateTime.parse("2024-01-15 14:30:00", formatter);// 时间计算LocalDateTime tomorrow = dateTime.plusDays(1);LocalDateTime nextWeek = dateTime.plusWeeks(1);long hoursBetween = ChronoUnit.HOURS.between(dateTime, tomorrow);// 时间差Duration duration = Duration.between(LocalTime.now(), LocalTime.of(18, 0));Period period = Period.between(LocalDate.of(2024, 1, 1), LocalDate.now());

@SpringBootApplication  // 组合注解：@SpringBootConfiguration + @EnableAutoConfiguration + @ComponentScanpublic class Application {    public static void main(String[] args) {        SpringApplication.run(Application.class, args);    }}// 分层结构@RestController          // 控制层@RequestMapping("/api")public class UserController {        @Autowired           // 依赖注入    private UserService userService;        @GetMapping("/users/{id}")    public Result<User> getUser(@PathVariable Long id) {        return Result.success(userService.getById(id));    }}

// Mapper 接口@Mapperpublic interface UserMapper {    @Select("SELECT * FROM user WHERE id = #{id}")    User selectById(Long id);        @Insert("INSERT INTO user(username, password) VALUES(#{username}, #{password})")    @Options(useGeneratedKeys = true, keyProperty = "id")    int insert(User user);        @Update("UPDATE user SET username = #{username} WHERE id = #{id}")    int update(User user);        @Delete("DELETE FROM user WHERE id = #{id}")    int deleteById(Long id);}

// 继承 BaseMapper，内置 CRUD 方法@Mapperpublic interface UserMapper extends BaseMapper<User> {    // 无需写任何 SQL，自动拥有增删改查}// 使用@Servicepublic class UserService {    @Autowired    private UserMapper userMapper;        public User getById(Long id) {        return userMapper.selectById(id);    }        public Page<User> page(int page, int pageSize) {        return userMapper.selectPage(new Page<>(page, pageSize), null);    }}

@Servicepublic class OrderService {    @Autowired    private OrderMapper orderMapper;        @Transactional(rollbackFor = Exception.class)    public void createOrder(Order order) {        orderMapper.insert(order);                // 如果这里抛出异常，上面的 insert 会自动回滚        inventoryService.deductStock(order.getProductId(), order.getQuantity());    }}

String a = new String("hello");String b = new String("hello");a == b;          // false，不同对象a.equals(b);     // true，内容相同

// JDK 动态代理示例public class LogProxy implements InvocationHandler {    private Object target;        public LogProxy(Object target) {        this.target = target;    }        @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        System.out.println("调用前: " + method.getName());        Object result = method.invoke(target, args);        System.out.println("调用后: " + method.getName());        return result;    }        public static <T> T createProxy(T target, Class<T> interfaceType) {        return (T) Proxy.newProxyInstance(            target.getClass().getClassLoader(),            new Class[]{interfaceType},            new LogProxy(target)        );    }}

public int test() {    int x = 1;    try {        return x++;  // 先保存 x=1 作为返回值，然后 x=2    } finally {        System.out.println(x);  // 输出 2        // return 100;          // 如果这里 return 100，会覆盖返回值    }}// 结果是 1，不是 2