Java 基础知识面试题集

1. 基本数据类型与包装类

1. Java 中的基本数据类型有哪些？它们的默认值是什么？
   Java 的基本数据类型有 byte、short、int、long、float、double、char 和 boolean。它们的默认值分别是：

• byte：0
• short：0
• int：0
• long：0L
• float：0.0f
• double：0.0d
• char：‘\u0000’
• boolean：false

2. 解释一下自动装箱（Autoboxing）和拆箱（Unboxing）。
   自动装箱是指 Java 自动将基本数据类型转换为对应的包装类对象。拆箱是将包装类对象自动转换为基本数据类型。例如：

   int num = 10;
   Integer integerObj = num; // 自动装箱
   int num2 = integerObj;    // 拆箱
   

3. 如何将一个 String 转换为基本数据类型？
   可以使用 parse 方法来将 String 转换为基本数据类型。例如：

   String str = "123";
   int num = Integer.parseInt(str);
   double d = Double.parseDouble("3.14");

4. int 和 Integer 之间的区别是什么？
   int 是基本数据类型，而 Integer 是 int 的包装类。Integer 提供了更多的方法和常量，比如 parseInt() 和 MAX_VALUE，并且可以用于集合类中。

2. 控制结构

5. for 循环和 while 循环有什么不同？请给出示例。
   for 循环通常用于已知迭代次数的场景，而 while 循环用于循环次数不确定的场景。

• for 循环示例：

     for (int i = 0; i < 5; i++) {
         System.out.println("Iteration " + i);
     }

• while 循环示例：

     int i = 0;
     while (i < 5) {
         System.out.println("Iteration " + i);
         i++;
     }

6. 解释 break 和 continue 语句的作用，并给出示例。

• break 用于终止当前循环或 switch 语句。
• continue 用于跳过当前循环迭代的剩余部分，并直接进入下一次迭代。

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // 退出循环
    }
    System.out.println(i);
}

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue; // 跳过当前迭代
    }
    System.out.println(i); // 输出奇数
}

3. 方法与类

7. 方法重载（Overloading）是什么？请给出示例。
   方法重载是指在同一个类中定义多个方法名相同但参数列表不同的方法。它们可以有不同的参数类型、数量或顺序。

   public class OverloadDemo {
       public void display(int num) {
           System.out.println("Number: " + num);
       }
       public void display(String message) {
           System.out.println("Message: " + message);
       }
   }
   

8. 构造器（Constructor）是什么？它有什么特点？
   构造器是用于初始化对象的特殊方法。特点包括：
   • 名称与类名相同。
   • 没有返回类型。
   • 在对象创建时自动调用。
   • 可以有多个构造器（构造器重载）。

   public class Person {
       private String name;
       private int age;
   
       public Person(String name, int age) {
           this.name = name;
           this.age = age;
       }
       public Person() {
           this.name = "Unknown";
           this.age = 0;
       }
   }
   

9. 访问修饰符（Access Modifiers）有什么作用？请列举常见的修饰符并说明它们的访问级别。
   访问修饰符用于控制类、字段和方法的可见性。常见修饰符及其访问级别：

• public：对所有类可见。
• protected：对同一包中的类和子类可见。
• default（无修饰符）：对同一包中的类可见。
• private：对同一类中的代码可见。

10. 什么是方法重写（Overriding）？请给出示例。
    方法重写是子类重新定义父类方法的过程，以提供特定的实现。子类方法的返回类型、方法名和参数列表必须与父类的方法相同。

    public class Animal {
        public void makeSound() {
            System.out.println("Animal makes a sound.");
        }
    }
    
    public class Dog extends Animal {
        @Override
        public void makeSound() {
            System.out.println("Dog barks.");
        }
    }
    

4. 面向对象编程

11. 继承（Inheritance）是什么？请解释其作用，并提供示例。
    继承是面向对象编程的一个机制，它允许一个类（子类）继承另一个类（父类）的属性和方法。继承有助于代码重用和扩展。子类可以访问父类的公共和受保护的方法及属性。

    public class Animal {
        public void eat() {
            System.out.println("This animal eats food.");
        }
    }
    
    public class Dog extends Animal {
        public void bark() {
            System.out.println("The dog barks.");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Dog myDog = new Dog();
            myDog.eat();  // 继承自 Animal 类
            myDog.bark(); // Dog 类的方法
        }
    }
    

12. 什么是多态（Polymorphism）？如何在 Java 中实现多态？
    多态允许对象以不同的形式表现。同一个方法可以有不同的实现。Java 中的多态通过方法重载和方法重写实现。

    public class Shape {
        public void draw() {
            System.out.println("Drawing a shape.");
        }
    }
    
    public class Circle extends Shape {
        @Override
        public void draw() {
            System.out.println("Drawing a circle.");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Shape myShape = new Circle();
            myShape.draw(); // 输出 "Drawing a circle."
        }
    }
    

13. 抽象类（Abstract Class）和接口（Interface）的区别是什么？
    • 抽象类：
      • 可以包含抽象方法和具体方法。
      • 可以有构造器。
      • 可以包含成员变量。
      • 支持继承。
    • 接口：
      • 只能包含抽象方法（Java 8 之后可以有默认方法和静态方法）。
      • 不能有构造器。
      • 不能包含成员变量，只能有常量。
      • 支持实现（可以被多个类实现）。

    abstract class Animal {
        abstract void makeSound();
        
        public void sleep() {
            System.out.println("Sleeping...");
        }
    }
    
    interface Swimmer {
        void swim();
    }
    

14. 什么是封装（Encapsulation）？如何实现封装？
    封装是将对象的状态（属性）和行为（方法）绑定在一起，并控制对外部访问的机制。通过将类的属性设为 private 并提供 public 的 getter 和 setter 方法来实现封装。

   public class Person {
       private String name;
       private int age;

       public String getName() {
           return name;
       }

       public void setName(String name) {
           this.name = name;
       }

       public int getAge() {
           return age;
       }

       public void set

Age(int age) {
           this.age = age;
       }
   }

5. 数组与集合

15. 如何声明和初始化一个一维数组？请给出示例。
    可以使用以下两种方式声明和初始化一维数组：

    int[] numbers = new int[5]; // 声明并初始化一个长度为 5 的整数数组
    numbers[0] = 1;
    numbers[1] = 2;

    // 另一种声明和初始化方式
    int[] moreNumbers = {1, 2, 3, 4, 5};

16. ArrayList 和 LinkedList 有什么区别？

    • ArrayList：

      • 基于动态数组实现。
      • 访问元素速度较快，但插入和删除操作速度较慢，尤其是在数组中间。

    • LinkedList：

      • 基于双向链表实现。
      • 插入和删除操作速度较快，但访问元素速度较慢。
17. 如何遍历一个 ArrayList？
    可以使用 for 循环、增强型 for 循环或 Iterator 来遍历 ArrayList。

    ArrayList<String> list = new ArrayList<>();
    list.add("A");
    list.add("B");

    // 使用 for 循环
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }

    // 使用增强型 for 循环
    for (String item : list) {
        System.out.println(item);
    }

    // 使用 Iterator
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }

18. HashMap 和 TreeMap 有什么区别？

    • HashMap：

      • 基于哈希表实现。
      • 不保证顺序。
      • 允许键为 null。

    • TreeMap：

      • 基于红黑树实现。
      • 保持键的自然顺序或自定义顺序。
      • 不允许键为 null。