以下是 30 道大学生 Java 面试常见编程面试题和答案，包含完整代码：
- 什么是 Java 中的 main 方法？
答：main 方法是 Java 程序的入口点。它是一个特殊的方法，不需要被声明。当 Java 运行时系统执行一个 Java 程序时，它首先运行 main 方法。main 方法应该具有以下签名：public static void main(String[] args)。 - 如何在 Java 中创建一个新的对象？
答：在 Java 中，可以使用关键字"new"来创建一个新的对象。例如，要创建一个名为"myObject"的新对象，可以使用以下代码：
MyClass myObject = new MyClass();
- 什么是 Java 中的构造函数？
答：构造函数是一种特殊的方法，用于创建和初始化对象。它与类同名，并且没有返回类型。Java 会自动调用构造函数，当创建类的新对象时。
class MyClass { int a;MyClass() { a = 10; }
}
- 如何在 Java 中访问类的属性？
答：在 Java 中，可以使用点号（.）运算符来访问类的属性。例如，如果一个类有属性 name 和 age，可以这样访问：
MyClass obj = new MyClass();
obj.name = "John";
obj.age = 30;
- 什么是 Java 中的访问修饰符？
答：访问修饰符是用于限制其他类对类中成员（属性和方法）访问的修饰符。Java 中的访问修饰符有四种：public、protected、default（即不加任何修饰符）和 private。
// public
public class PublicClass { public int publicProperty = 10;public void publicMethod() { System.out.println("This is a public method."); }
}
// protected
protected class ProtectedClass { protected int protectedProperty = 20;protected void protectedMethod() { System.out.println("This is a protected method."); }
}
// default (no modifier)
class DefaultClass { int defaultProperty = 30;void defaultMethod() { System.out.println("This is a default method."); }
}
// private
class PrivateClass { private int privateProperty = 40;private void privateMethod() { System.out.println("This is a private method."); }
}
- 如何实现 Java 中的单例模式？
答：单例模式是一种设计模式，确保一个类只有一个实例。可以使用懒汉式（线程安全）和饿汉式（线程不安全）来实现单例模式。
// 懒汉式 (线程安全)
class Singleton { private static Singleton instance;private Singleton() { // private constructor to prevent instantiation }public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; }
}
// 饿汉式 (线程不安全)
class Singleton { private static final Singleton instance = new Singleton();private Singleton() { // private constructor to prevent instantiation }public static Singleton getInstance() { return instance; }
}
- 什么是 Java 中的静态变量和静态方法？
答：静态变量和静态方法属于类，而不是类的实例。静态变量在类加载时分配内存，并且只分配一次，直到程序结束才被释放。静态方法可以直接通过类名来调用，不需要创建类的实例。
class MyClass { static int staticProperty = 10;static void staticMethod() { System.out.println("This is a static method."); }
}
public class Main { public static void main(String[] args) { System.out.println("Static property: " + MyClass.staticProperty); MyClass.staticMethod(); }
}
- 什么是 Java 中的继承？
答：继承是 Java 面向对象编程中的一种特性，它允许一个类（子类）继承另一个类（父类）的属性和方法。
Java 中的继承是一种代码复用机制，它允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以扩展父类的功能，也可以根据自己的需求覆盖或新增方法。继承的关键字是"extends"。
以下是一个简单的 Java 继承代码示例：
// 父类
class Animal { String name;// 父类构造方法 public Animal(String name) { this.name = name; }// 父类方法 public void makeSound() { System.out.println(name + " makes a sound"); }
}
// 子类，继承自 Animal
class Dog extends Animal { String breed;// 子类构造方法，调用父类构造方法 public Dog(String name, String breed) { super(name); // 调用父类构造方法 this.breed = breed; }// 子类方法，覆盖父类方法 @Override public void makeSound() { System.out.println(name + " barks"); }// 子类新增方法 public void doTrick() { System.out.println(name + " does a trick"); }
}
public class Main { public static void main(String[] args) { Dog myDog = new Dog("Buddy", "Golden Retriever"); myDog.makeSound(); // 输出：Buddy barks myDog.doTrick(); // 输出：Buddy does a trick }
}
在这个示例中，我们定义了一个父类Animal和一个子类Dog，子类继承了父类的属性和方法。我们创建了一个Dog对象，并调用了其方法和属性。
- 计算两个数之和
public class Sum { public static void main(String[] args) { int a = 10; int b = 20; int sum = a + b; System.out.println("两数之和为：" + sum); }
}
- 计算两个数之差
public class Difference { public static void main(String[] args) { int a = 10; int b = 20; int difference = a - b; System.out.println("两数之差为：" + difference); }
}
- 计算两个数之积
public class Product { public static void main(String[] args) { int a = 10; int b = 20; int product = a * b; System.out.println("两数之积为：" + product); }
}
- 计算两个数之商
public class Quotient { public static void main(String[] args) { int a = 10; int b = 20; int quotient = a / b; System.out.println("两数之商为：" + quotient); }
}
- 判断一个数是否为偶数
public class EvenNumber { public static void main(String[] args) { int number = 20; if (isEven(number)) { System.out.println(number + " 是偶数"); } else { System.out.println(number + " 不是偶数"); } }public static boolean isEven(int number) { return number % 2 == 0; }
}
- 判断一个数是否为奇数
public class OddNumber { public static void main(String[] args) { int number = 20; if (isOdd(number)) { System.out.println(number + " 是奇数"); } else { System.out.println(number + " 不是奇数"); } }public static boolean isOdd(int number) { return number % 2!= 0; }
}
- 打印九九乘法表
public class MultiplicationTable { public static void main(String[] args) { for (int i = 1; i <= 9; i++) { for (int j = 1; j <= i; j++) { System.out.print(j + " * " + i + " = " + (i * j) + "\t"); } System.out.println(); } }
}
- 替换字符串中的空格
public class StringReplacer { public static void main(String[] args) { String input = "Hello World"; String output = replaceSpace(input); System.out.println(output); }public static String replaceSpace(String input) { return input.replace(" ", "_"); }
}
- 计算字符串中字符的数量
public class StringCounter { public static void main(String[] args) { String input = "Hello World"; int count = countCharacters(input); System.out.println("字符数量：" + count); }public static int countCharacters(String input) { return input.length(); }
}
- 判断字符串是否为回文字符串
public class Palindrome { public static void main(String[] args) { String input = "madam"; if (isPalindrome(input)) { System.out.println(input + " 是回文字符串"); } else { System.out.println(input + " 不是回文字符串} } public static boolean isPalindrome(String input) { int left = 0; int right = input.length() - 1; while (left < right) { if (input.charAt(left)!= input.charAt(right)) { return false; } left++; right--; } return true; }
}
- 题目：实现一个简单的 Java 多线程程序。
答案：
public class MultiThreading { public static void main(String[] args) { Thread t1 = new Thread(new PrintName("Thread-1")); Thread t2 = new Thread(new PrintName("Thread-2")); t1.start(); t2.start(); }static class PrintName implements Runnable { private String name;public PrintName(String name) { this.name = name; }@Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(name + " - " + i); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } }
}
- 题目：实现一个 Java 类，该类有一个私有构造函数和一个公共静态方法，该方法返回该类的实例。
答案：
public class Singleton { private Singleton() { }public static Singleton getInstance() { return new Singleton(); }
}
- 题目：实现一个 Java 类，该类有一个字符串和一个方法，该方法返回字符串的反转字符串。
答案：
public class StringReverse { private String str;public StringReverse(String str) { this.str = str; }public String reverse() { StringBuilder sb = new StringBuilder(); for (int i = str.length() - 1; i >= 0; i--) { sb.append(str.charAt(i)); } return sb.toString(); }
}
- 题目：实现一个 Java 接口，该接口有一个方法，该方法返回一个字符串，该字符串表示接口的实现。
答案：
public interface MyInterface { String getString();
}
- 题目：实现一个 Java 抽象类，该类有两个抽象方法和一个具体方法，该具体方法实现两个抽象方法。
答案：
public abstract class MyAbstractClass { public abstract void abstractMethod1(); public abstract void abstractMethod2();public void specificMethod() { abstractMethod1(); abstractMethod2(); }
}
- 题目：实现一个 Java 类，该类有一个字符串和一个方法，该方法将字符串转换为大写。
答案：
public class StringToUpperCase { private String str;public StringToUpperCase(String str) { this.str = str; }public String toUpperCase() { StringBuilder sb = new StringBuilder(); for (int i = 0; i < str.length(); i++) { sb.append(Character.toUpperCase(str.charAt(i))); } return sb.toString(); }
}
- 题目：实现一个 Java 类，该类有一个整数和一个方法，该方法将整数转换为字符串。
答案：
public class IntegerToString { private int num;public IntegerToString(int num) { this.num = num; }public String toString() { return Integer.toString(num); }
}
- 题目：实现一个 Java 类，该类有一个字符串和一个方法，该方法将字符串转换为整数。
答案：
public class StringToInteger { private String str;public StringToInteger(String str) { this.str = str; }public int toInteger() { return Integer.parseInt(str); }
}
- 题目：实现一个 Java 类，该类有一个字符串和一个方法，该方法将字符串分割成子字符串数组。
答案：
下面是一个实现这个需求的 Java 类：
public class StringSplitter {private String str;public StringSplitter(String str) { this.str = str; }public String[] split(int maxLength) { if (maxLength <= 0) { throw new IllegalArgumentException("Max length must be greater than 0"); }String[] substrings = new String[str.length() / maxLength]; int index = 0;for (int i = 0; i < str.length(); i += maxLength) { substrings[index++] = str.substring(i, Math.min(i + maxLength, str.length())); }return substrings; }public static void main(String[] args) { StringSplitter splitter = new StringSplitter("This is a test string"); String[] substrings = splitter.split(4);for (String substring : substrings) { System.out.println(substring); } }
}
这个类有一个字符串属性 str 和一个 split 方法，该方法接受一个整数参数 maxLength，用于指定子字符串的最大长度。split 方法将字符串分割成子字符串数组，并返回该数组。在 main 方法中，我们创建了一个 StringSplitter 对象，并使用 split 方法将字符串分割成最大长度为 4 的子字符串数组。然后，我们遍历并打印这些子字符串。
- 编写一个 Java 类，实现克隆（clone）功能。
public class Cloneable { private int id; private String name;public Cloneable(int id, String name) { this.id = id; this.name = name; }public Object clone() throws CloneNotSupportedException { return super.clone(); }@Override protected void finalize() throws Throwable { super.finalize(); System.out.println("Cloneable object " + this.id + " has been cloned"); }
}
- 实现 Java 中的深拷贝和浅拷贝。
public class Cloneable { private int id; private String name;public Cloneable(int id, String name) { this.id = id; this.name = name; }public Object deepClone() { if (this instanceof Cloneable) { try { return (Cloneable) super.clone(); } catch (CloneNotSupportedException e) { throw new RuntimeException("Failed to deep clone", e); } } return null; }public Object shallowClone() { return super.clone(); }
}
- 实现 Java 中的抽象类和抽象方法。
public abstract class Animal { private String name;public abstract void makeSound();public Animal(String name) { this.name = name; }public String getName() { return name; }
}
public class Dog extends Animal { private String breed;public Dog(String name, String breed) { super(name); this.breed = breed; }@Override public void makeSound() { System.out.println(name + " barks"); }public String getBreed() { return breed; }
}
