校招 java 面试基础题目及解析

我将结合常见的校招Java面试基础题目，从概念阐述、代码示例等角度展开，为你提供一份可用于学习的技术方案及应用实例。

校招Java面试基础题目解析与学习指南

在Java校招面试中，扎实掌握基础知识是成功的关键。本文将围绕常见的Java基础面试题，通过理论解析与实际代码示例，帮助大家深入理解和掌握相关知识，为校招面试做好充分准备。

一、Java基础特性

1.1 平台无关性

Java的平台无关性是其重要特性之一，通过Java虚拟机（JVM）实现“一次编写，到处运行”。Java源文件（.java）经编译器编译成字节码文件（.class），不同平台的JVM负责将字节码解释成该平台的机器码。例如，以下代码在不同操作系统（Windows、Linux等）上运行时，无需修改代码，只需有对应的JVM环境即可。

public class HelloWorld {public static void main(String[] args) {System.out.println("Hello, World!");}
}

1.2 面向对象特性

1.2.1 封装

封装是将数据和操作数据的方法封装在类中，提高代码安全性和可维护性。例如：

class Person {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

在上述代码中，Person类的name和age属性被声明为private，只能通过类中提供的public方法（getName、setName、getAge、setAge）来访问和修改，外部代码无法直接操作这些属性，保证了数据的安全性。

1.2.2 继承

继承允许子类继承父类的属性和方法，实现代码复用。例如：

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

Dog类继承自Animal类，不仅拥有了Animal类的makeSound方法，还可以根据自身特点重写该方法，实现更具体的行为。

1.2.3 多态

多态指同一个行为具有多个不同表现形式或形态的能力。通过方法重写和接口实现来体现。在上述继承的例子中，Dog类重写了Animal类的makeSound方法，当通过Animal类型的变量调用makeSound方法时，如果该变量实际指向的是Dog类的对象，就会调用Dog类中重写后的makeSound方法，这就是多态的体现。

Animal animal = new Dog();
animal.makeSound();// 输出 "Dog barks"

二、数据类型

2.1 基本数据类型

Java有8种基本数据类型：byte、short、int、long、float、double、char、boolean。它们在内存中直接存储值，例如：

int num = 10;
double price = 19.99;
char ch = 'A';
boolean flag = true;

2.2 引用数据类型

包括类、接口、数组等。引用数据类型的变量存储的是对象在堆内存中的地址。例如：

String str = "Hello";
int[] array = {1, 2, 3};

str是String类的引用，指向存储在堆内存中的字符串对象；array是int类型数组的引用，指向堆内存中的数组对象。

三、关键字

3.1 static关键字

3.1.1 修饰成员变量

被static修饰的成员变量属于类，而不是类的某个实例。例如：

class Student {private static int studentCount = 0;private String name;public Student(String name) {this.name = name;studentCount++;}public static int getStudentCount() {return studentCount;}
}

studentCount是静态成员变量，用于记录学生数量，无论创建多少个Student对象，studentCount只有一份，存储在类的静态区域。

3.1.2 修饰成员方法

静态方法同样属于类，可通过类名直接调用，无需创建类的实例。如上述Student类中的getStudentCount方法，可通过Student.getStudentCount()调用。

3.1.3 静态代码块

使用static关键字定义的代码块，在类加载时执行，且只执行一次。例如：

class StaticBlockExample {static {System.out.println("Static block is executed");}
}

当StaticBlockExample类被加载到内存时，静态代码块中的内容会被执行。

3.2 final关键字

3.2.1 修饰类

被final修饰的类不能被继承。例如：

final class FinalClass {// 类的内容
}
// 以下代码会报错，因为FinalClass不能被继承
// class SubClass extends FinalClass {}

3.2.2 修饰方法

被final修饰的方法不能被重写。例如：

class Parent {public final void finalMethod() {System.out.println("This is a final method");}
}class Child extends Parent {// 以下代码会报错，因为finalMethod不能被重写// @Override// public void finalMethod() {//     System.out.println("Trying to override final method");// }
}

3.2.3 修饰变量

被final修饰的变量一旦赋值后，值不能被改变。如果是基本数据类型变量，则值不能改变；如果是引用数据类型变量，则引用不能再指向其他对象。例如：

final int num = 10;
// num = 20; // 报错，不能重新赋值final String[] array = {"a", "b", "c"};
// array = new String[]{"d", "e", "f"}; // 报错，不能重新指向其他数组
array[0] = "x"; // 但可以修改数组元素

四、方法相关

4.1 方法重载（Overload）

方法重载发生在同一个类中，多个方法可以具有相同的方法名，但参数列表必须不同（参数个数、参数类型或参数顺序不同）。例如：

class Calculator {public int add(int a, int b) {return a + b;}public double add(double a, double b) {return a + b;}public int add(int a, int b, int c) {return a + b + c;}
}

在Calculator类中，定义了三个add方法，通过不同的参数列表实现了方法重载。方法重载与返回类型无关，即返回类型可以相同也可以不同。

4.2 方法覆盖（Overriding）

方法覆盖发生在子类与父类之间，当子类继承父类后，子类可以重新定义父类中已有的方法。方法覆盖要求子类方法与父类被覆盖方法具有相同的方法名、参数列表和返回类型（返回类型可以是父类被覆盖方法返回类型的子类，这是Java 5.0引入的协变返回类型特性）。子类方法不能比父类被覆盖方法有更严格的访问权限。例如：

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

Dog类覆盖了Animal类的makeSound方法，在Dog类的实例调用makeSound方法时，执行的是Dog类中重写后的方法。

五、流程控制语句

5.1 if - else语句

根据条件判断执行不同的代码块。例如：

int score = 85;
if (score >= 90) {System.out.println("Grade: A");
} else if (score >= 80) {System.out.println("Grade: B");
} else if (score >= 70) {System.out.println("Grade: C");
} else {System.out.println("Grade: D");
}

5.2 switch语句

根据表达式的值，从多个分支中选择一个执行。从Java 7开始，switch语句支持String类型。例如：

String day = "Monday";
switch (day) {case "Monday":System.out.println("Start of the workweek");break;case "Friday":System.out.println("Nearly weekend");break;default:System.out.println("Regular day");
}

5.3 for循环

常用于已知循环次数的场景。例如：

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

5.4 while循环

先判断条件，条件为真时执行循环体。例如：

int num = 0;
while (num < 3) {System.out.println("Number: " + num);num++;
}

5.5 do - while循环

先执行一次循环体，再判断条件，条件为真时继续执行循环体。例如：

int count = 0;
do {System.out.println("Count value: " + count);count++;
} while (count < 3);

六、数组与集合

6.1 数组

数组是相同类型元素的有序集合，长度固定。例如：

// 声明并初始化一个整型数组
int[] numbers = {1, 2, 3, 4, 5};
// 访问数组元素
System.out.println("Element at index 2: " + numbers[2]);

6.2 ArrayList

ArrayList是List接口的一个实现类，基于动态数组实现，可动态调整大小。例如：

import java.util.ArrayList;
import java.util.List;public class ArrayListExample {public static void main(String[] args) {List<String> names = new ArrayList<>();names.add("Alice");names.add("Bob");names.add("Charlie");System.out.println("Names list: " + names);// 获取指定位置的元素String name = names.get(1);System.out.println("Element at index 1: " + name);// 修改指定位置的元素names.set(2, "David");System.out.println("Updated names list: " + names);}
}

6.3 HashMap

HashMap是Map接口的常用实现类，用于存储键值对，允许null键和null值。例如：

import java.util.HashMap;
import java.util.Map;public class HashMapExample {public static void main(String[] args) {Map<String, Integer> ages = new HashMap<>();ages.put("Alice", 25);ages.put("Bob", 30);ages.put("Charlie", 35);System.out.println("Ages map: " + ages);// 获取指定键的值Integer age = ages.get("Bob");System.out.println("Age of Bob: " + age);// 判断是否包含某个键boolean containsKey = ages.containsKey("Alice");System.out.println("Contains Alice? " + containsKey);}
}

七、异常处理

7.1 try - catch - finally

try块中放置可能会抛出异常的代码，catch块用于捕获并处理异常，finally块中的代码无论是否发生异常都会执行。例如：

public class ExceptionHandlingExample {public static void main(String[] args) {try {int result = 10 / 0; // 可能会抛出ArithmeticException异常} catch (ArithmeticException e) {System.out.println("Caught ArithmeticException: " + e.getMessage());} finally {System.out.println("This is finally block");}}
}

7.2 throws和throw

throws用于方法声明中，表明该方法可能会抛出某种异常，由调用者处理。throw用于手动抛出一个异常对象。例如：

public class ThrowsAndThrowExample {public static void main(String[] args) {try {divide(10, 0);} catch (ArithmeticException e) {System.out.println("Caught in main: " + e.getMessage());}}public static int divide(int a, int b) throws ArithmeticException {if (b == 0) {throw new ArithmeticException("Cannot divide by zero");}return a / b;}
}

在上述代码中，divide方法声明可能会抛出ArithmeticException异常，当除数为0时，通过throw手动抛出该异常，由调用divide方法的main方法中的try - catch块捕获处理。

通过对以上Java基础面试题的学习和理解，希望能帮助大家在Java校招面试中更好地展现自己的能力，顺利通过面试。同时，大家可以通过实际编写代码、调试程序等方式，加深对这些知识的掌握程度。

如果想进一步提升对Java面试题的掌握程度，建议你针对上述知识点进行专项练习，比如自己编写代码实现多态、异常处理等场景。若你在学习过程中对某类题目或知识点有疑问，也可以随时和我交流。

---

代码获取方式

（夸克网盘）点击查看

---

关注我获取更多内容