结丹期

8. 什么是异常处理？Java 中如何使用 try-catch 和 throws 进行异常处理？

异常处理 是 Java 中用于处理运行时错误的机制，确保程序在遇到异常时不会崩溃。

通过 try-catch 块捕获异常，使用 throws 关键字将异常抛给调用者。

try-catch：用于捕获并处理异常。

throws：用于将异常抛出给调用该方法的外部方法。

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0); // 触发异常
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) { // 捕获异常
            System.out.println("Error: " + e.getMessage());
        }
    }

    // 使用 throws 抛出异常
    public static int divide(int a, int b) throws ArithmeticException {
        if (b == 0) {
            throw new ArithmeticException("Cannot divide by zero");
        }
        return a / b;
    }
}

在 divide 方法中，throws 关键字抛出了 ArithmeticException，try-catch 块捕获并处理了异常。

9. Java 中有哪些常见的异常类型？如何自定义异常？

Java 中的异常分为已检查异常（Checked Exception）和未检查异常（Unchecked Exception）。

常见的异常类型有：

  • 已检查异常：

    • IOException

    • SQLException

    • ClassNotFoundException

  • 未检查异常：

    • NullPointerException

    • ArrayIndexOutOfBoundsException

    • ArithmeticException

自定义异常：可以通过继承 Exception 类来创建自己的异常类型。

// 自定义异常
class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            checkAge(15);
        } catch (InvalidAgeException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }

    // 抛出自定义异常
    public static void checkAge(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("Age must be 18 or older");
        }
        System.out.println("Age is valid");
    }
}

InvalidAgeException 是自定义异常，checkAge 方法在年龄不合法时抛出该异常。

10. 什么是泛型（Generics）？如何在 Java 中使用泛型？

泛型 是 Java 中的一个机制，允许在定义类、接口和方法时使用类型参数，从而提高代码的重用性和安全性。

泛型使得类型在编译时检查，减少了类型转换的错误。

// 示例：泛型类
class Box<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

public class GenericsExample {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>(); // 泛型指定为 String
        stringBox.setItem("Hello");
        System.out.println("String Box: " + stringBox.getItem());

        Box<Integer> intBox = new Box<>(); // 泛型指定为 Integer
        intBox.setItem(100);
        System.out.println("Integer Box: " + intBox.getItem());
    }
}

Box<T> 是一个泛型类，可以通过不同的类型参数在同一个类中处理不同的数据类型。

11. 什么是 Java 的 ArrayList 和 LinkedList？它们的区别是什么？

ArrayList 和 LinkedList 都是 Java 集合框架中的常见列表实现，但它们的底层结构不同，适合不同的应用场景：

ArrayList：

  • 基于动态数组实现，支持快速随机访问。

  • 适合频繁读取数据的场景，但插入和删除元素较慢，尤其是在列表的中间位置。

LinkedList：

  • 基于双向链表实现，适合频繁插入和删除元素的场景。

  • 不支持快速随机访问，因为查找元素时需要从头遍历。

import java.util.ArrayList;
import java.util.LinkedList;

public class ListExample {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("Apple");
        arrayList.add("Banana");
        System.out.println("ArrayList: " + arrayList);

        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("Cat");
        linkedList.add("Dog");
        System.out.println("LinkedList: " + linkedList);
    }
}

12. 什么是 HashMap 和 TreeMap？它们的使用场景和区别是什么？

HashMap 和 TreeMap 都是用于存储键值对的 Map 实现，但它们的内部结构和行为不同。

HashMap：

  • 基于哈希表实现，提供常数时间的插入和查找。

  • 不保证元素的顺序，适用于快速查找和更新的场景。

TreeMap：

  • 基于红黑树实现，元素按键的自然顺序或指定的比较器排序。

  • 适用于需要按键排序或范围查询的场景。

import java.util.HashMap;
import java.util.TreeMap;

public class MapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("Apple", 1);
        hashMap.put("Banana", 2);
        System.out.println("HashMap: " + hashMap);

        TreeMap<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("Apple", 1);
        treeMap.put("Banana", 2);
        System.out.println("TreeMap: " + treeMap);
    }
}

13. Java 中的 String、StringBuilder 和 StringBuffer 有什么区别？

String：不可变的字符序列，任何对 String 的修改都会生成新的对象。

StringBuilder：可变字符序列，适用于在单线程环境下执行字符串操作，效率高。

StringBuffer：与 StringBuilder 类似，但是线程安全的，适用于多线程环境。

public class StringExample {
    public static void main(String[] args) {
        // String（不可变）
        String str = "Hello";
        str = str + " World"; // 生成新的对象
        System.out.println("String: " + str);

        // StringBuilder（可变）
        StringBuilder sb = new StringBuilder("Hello");
        sb.append(" World");
        System.out.println("StringBuilder: " + sb);

        // StringBuffer（线程安全）
        StringBuffer sbf = new StringBuffer("Hello");
        sbf.append(" World");
        System.out.println("StringBuffer: " + sbf);
    }
}

14. 什么是线程（Thread）？如何在 Java 中创建和管理线程？

线程（Thread） 是程序执行的最小单位，Java 支持多线程编程，使得多个任务可以并发执行。

创建线程有两种主要方式：

  • 继承 Thread 类。

  • 实现 Runnable 接口。

// 示例 1：继承 Thread 类
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running");
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}

// 示例 2：实现 Runnable 接口
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable is running");
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start(); // 启动线程
    }
}

MyThread 类继承了 Thread，并重写了 run 方法；MyRunnable 实现了 Runnable 接口，同样定义了 run 方法。

results matching ""

    No results matching ""