Java 根本知识口试题集

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
  

• 表明一下主动装箱（Autoboxing）和拆箱（Unboxing）。
  主动装箱是指 Java 主动将根本数据范例转换为对应的包装类对象。拆箱是将包装类对象主动转换为根本数据范例。比方：
  1. int num = 10;
  2. Integer integerObj = num; // 自动装箱
  3. int num2 = integerObj;    // 拆箱

  复制代码
• 怎样将一个 String 转换为根本数据范例？
  可以利用 parse 方法来将 String 转换为根本数据范例。比方：
  

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

复制代码

• int 和 Integer 之间的区别是什么？
  int 是根本数据范例，而 Integer 是 int 的包装类。Integer 提供了更多的方法和常量，比如 parseInt() 和 MAX_VALUE，而且可以用于聚集类中。
  

2. 控制结构

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

• for 循环示例：
  

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

复制代码

• while 循环示例：
  

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

复制代码

• 表明 break 和 continue 语句的作用，并给出示例。
  

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

1. for (int i = 0; i < 10; i++) {
2.     if (i == 5) {
3.         break; // 退出循环
4.     }
5.     System.out.println(i);
6. }
8. for (int i = 0; i < 10; i++) {
9.     if (i % 2 == 0) {
10.         continue; // 跳过当前迭代
11.     }
12.     System.out.println(i); // 输出奇数
13. }

复制代码

3. 方法与类

• 方法重载（Overloading）是什么？请给出示例。
  方法重载是指在同一个类中界说多个方法名雷同但参数列表差异的方法。它们可以有差异的参数范例、数量或次序。
  1. public class OverloadDemo {
  2.     public void display(int num) {
  3.         System.out.println("Number: " + num);
  4.     }
  5.     public void display(String message) {
  6.         System.out.println("Message: " + message);
  7.     }
  8. }

  复制代码
• 构造器（Constructor）是什么？它有什么特点？
  构造器是用于初始化对象的特殊方法。特点包罗：
  
  
  
  • 名称与类名雷同。
    
  • 没有返回范例。
    
  • 在对象创建时主动调用。
    
  • 可以有多个构造器（构造器重载）。
    
  1. public class Person {
  2.     private String name;
  3.     private int age;
  5.     public Person(String name, int age) {
  6.         this.name = name;
  7.         this.age = age;
  8.     }
  9.     public Person() {
  10.         this.name = "Unknown";
  11.         this.age = 0;
  12.     }
  13. }

  复制代码
• 访问修饰符（Access Modifiers）有什么作用？请罗列常见的修饰符并分析它们的访问级别。
  访问修饰符用于控制类、字段和方法的可见性。常见修饰符及其访问级别：
  

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

• 什么是方法重写（Overriding）？请给出示例。
  方法重写是子类重新界说父类方法的过程，以提供特定的实现。子类方法的返回范例、方法名和参数列表必须与父类的方法雷同。
  1. public class Animal {
  2.     public void makeSound() {
  3.         System.out.println("Animal makes a sound.");
  4.     }
  5. }
  7. public class Dog extends Animal {
  8.     @Override
  9.     public void makeSound() {
  10.         System.out.println("Dog barks.");
  11.     }
  12. }

  复制代码

4. 面向对象编程

• 继续（Inheritance）是什么？请表明其作用，并提供示例。
  继续是面向对象编程的一个机制，它允许一个类（子类）继续另一个类（父类）的属性和方法。继续有助于代码重用和扩展。子类可以访问父类的公共和受掩护的方法及属性。
  1. public class Animal {
  2.     public void eat() {
  3.         System.out.println("This animal eats food.");
  4.     }
  5. }
  7. public class Dog extends Animal {
  8.     public void bark() {
  9.         System.out.println("The dog barks.");
  10.     }
  11. }
  13. public class Main {
  14.     public static void main(String[] args) {
  15.         Dog myDog = new Dog();
  16.         myDog.eat();  // 继承自 Animal 类
  17.         myDog.bark(); // Dog 类的方法
  18.     }
  19. }

  复制代码
• 什么是多态（Polymorphism）？如安在 Java 中实现多态？
  多态允许对象以差异的情势体现。同一个方法可以有差异的实现。Java 中的多态通过方法重载和方法重写实现。
  1. public class Shape {
  2.     public void draw() {
  3.         System.out.println("Drawing a shape.");
  4.     }
  5. }
  7. public class Circle extends Shape {
  8.     @Override
  9.     public void draw() {
  10.         System.out.println("Drawing a circle.");
  11.     }
  12. }
  14. public class Main {
  15.     public static void main(String[] args) {
  16.         Shape myShape = new Circle();
  17.         myShape.draw(); // 输出 "Drawing a circle."
  18.     }
  19. }

  复制代码
• 抽象类（Abstract Class）和接口（Interface）的区别是什么？
  
  
  
  • 抽象类：
    
    
    
    • 可以包罗抽象方法和具体方法。
      
    • 可以有构造器。
      
    • 可以包罗成员变量。
      
    • 支持继续。
      
    
    
  • 接口：
    
    
    
    • 只能包罗抽象方法（Java 8 之后可以有默认方法和静态方法）。
      
    • 不能有构造器。
      
    • 不能包罗成员变量，只能有常量。
      
    • 支持实现（可以被多个类实现）。
      
    
    
  1. abstract class Animal {
  2.     abstract void makeSound();
  3.    
  4.     public void sleep() {
  5.         System.out.println("Sleeping...");
  6.     }
  7. }
  9. interface Swimmer {
  10.     void swim();
  11. }

  复制代码
• 什么是封装（Encapsulation）？怎样实现封装？
  封装是将对象的状态（属性）和运动（方法）绑定在一起，并控制对外部访问的机制。通过将类的属性设为 private 并提供 public 的 getter 和 setter 方法来实现封装。
  

1.    public class Person {
2.        private String name;
3.        private int age;
5.        public String getName() {
6.            return name;
7.        }
9.        public void setName(String name) {
10.            this.name = name;
11.        }
13.        public int getAge() {
14.            return age;
15.        }
17.        public void set
19. Age(int age) {
20.            this.age = age;
21.        }
22.    }

复制代码

5. 数组与聚集

• 怎样声明和初始化一个一维数组？请给出示例。
  可以利用以下两种方式声明和初始化一维数组：
  

1.     int[] numbers = new int[5]; // 声明并初始化一个长度为 5 的整数数组
2.     numbers[0] = 1;
3.     numbers[1] = 2;
5.     // 另一种声明和初始化方式
6.     int[] moreNumbers = {1, 2, 3, 4, 5};

复制代码

• ArrayList 和 LinkedList 有什么区别？
  
  
  
  • ArrayList：
    
    
    
    • 基于动态数组实现。
      
    • 访问元素速率较快，但插入和删除利用速率较慢，尤其是在数组中央。
      
    
    
  • LinkedList：
    
    
    
    • 基于双向链表实现。
      
    • 插入和删除利用速率较快，但访问元素速率较慢。
      
    
    
  
  
• 怎样遍历一个 ArrayList？
  可以利用 for 循环、增强型 for 循环或 Iterator 来遍历 ArrayList。
  

1.     ArrayList<String> list = new ArrayList<>();
2.     list.add("A");
3.     list.add("B");
5.     // 使用 for 循环
6.     for (int i = 0; i < list.size(); i++) {
7.         System.out.println(list.get(i));
8.     }
10.     // 使用增强型 for 循环
11.     for (String item : list) {
12.         System.out.println(item);
13.     }
15.     // 使用 Iterator
16.     Iterator<String> iterator = list.iterator();
17.     while (iterator.hasNext()) {
18.         System.out.println(iterator.next());
19.     }

复制代码

• HashMap 和 TreeMap 有什么区别？
  
  
  
  • HashMap：
    
    
    
    • 基于哈希表实现。
      
    • 不包管次序。
      
    • 允许键为 null。
      
    
    
  • TreeMap：
    
    
    
    • 基于红黑树实现。
      
    • 保持键的天然次序或自界说次序。
      
    • 不允许键为 null。