国庆中秋特辑（六）大学生常见30道宝藏编程面试题

àì夳堔傛蜴生んèń 2023-10-16 17:18 37阅读 0赞

![在这里插入图片描述][b0a36a702c8b46d99034a0de71070f2c.png_pic_center]

以下是 30 道大学生 Java 面试常见编程面试题和答案，包含完整代码：

1.  什么是 Java 中的 main 方法？  
    答：main 方法是 Java 程序的入口点。它是一个特殊的方法，不需要被声明。当 Java 运行时系统执行一个 Java 程序时，它首先运行 main 方法。main 方法应该具有以下签名：public static void main(String\[\] args)。
2.  如何在 Java 中创建一个新的对象？  
    答：在 Java 中，可以使用关键字"new"来创建一个新的对象。例如，要创建一个名为"myObject"的新对象，可以使用以下代码：

MyClass myObject = new MyClass();

1.  什么是 Java 中的构造函数？  
    答：构造函数是一种特殊的方法，用于创建和初始化对象。它与类同名，并且没有返回类型。Java 会自动调用构造函数，当创建类的新对象时。

class MyClass {
          
       int a;
       MyClass() {
          
           a = 10;  
       }  
    }

1.  如何在 Java 中访问类的属性？  
    答：在 Java 中，可以使用点号（.）运算符来访问类的属性。例如，如果一个类有属性 name 和 age，可以这样访问：

MyClass obj = new MyClass();  
    obj.name = "John";  
    obj.age = 30;

1.  什么是 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.");  
       }  
    }

1.  如何实现 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;  
       }  
    }

1.  什么是 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();  
       }  
    }

1.  什么是 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`对象，并调用了其方法和属性。

1.  计算两个数之和

public class Sum {
          
       public static void main(String[] args) {
          
           int a = 10;  
           int b = 20;  
           int sum = a + b;  
           System.out.println("两数之和为：" + sum);  
       }  
    }

1.  计算两个数之差

public class Difference {
          
       public static void main(String[] args) {
          
           int a = 10;  
           int b = 20;  
           int difference = a - b;  
           System.out.println("两数之差为：" + difference);  
       }  
    }

1.  计算两个数之积

public class Product {
          
       public static void main(String[] args) {
          
           int a = 10;  
           int b = 20;  
           int product = a * b;  
           System.out.println("两数之积为：" + product);  
       }  
    }

1.  计算两个数之商

public class Quotient {
          
       public static void main(String[] args) {
          
           int a = 10;  
           int b = 20;  
           int quotient = a / b;  
           System.out.println("两数之商为：" + quotient);  
       }  
    }

1.  判断一个数是否为偶数

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;  
       }  
    }

1.  判断一个数是否为奇数

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;  
       }  
    }

1.  打印九九乘法表

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();  
           }  
       }  
    }

1.  替换字符串中的空格

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(" ", "_");  
       }  
    }

1.  计算字符串中字符的数量

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();  
       }  
    }

1.  判断字符串是否为回文字符串

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;    
      }    
    }

1.  题目：实现一个简单的 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();  
                   }  
               }  
           }  
       }  
    }

1.  题目：实现一个 Java 类，该类有一个私有构造函数和一个公共静态方法，该方法返回该类的实例。  
    答案：

public class Singleton {
          
       private Singleton() {
          
       }
       public static Singleton getInstance() {
          
           return new Singleton();  
       }  
    }

1.  题目：实现一个 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();  
       }  
    }

1.  题目：实现一个 Java 接口，该接口有一个方法，该方法返回一个字符串，该字符串表示接口的实现。  
    答案：

public interface MyInterface {
          
       String getString();  
    }

1.  题目：实现一个 Java 抽象类，该类有两个抽象方法和一个具体方法，该具体方法实现两个抽象方法。  
    答案：

public abstract class MyAbstractClass {
          
       public abstract void abstractMethod1();  
       public abstract void abstractMethod2();
       public void specificMethod() {
          
           abstractMethod1();  
           abstractMethod2();  
       }  
    }

1.  题目：实现一个 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();  
       }  
    }

1.  题目：实现一个 Java 类，该类有一个整数和一个方法，该方法将整数转换为字符串。  
    答案：

public class IntegerToString {
          
       private int num;
       public IntegerToString(int num) {
          
           this.num = num;  
       }
       public String toString() {
          
           return Integer.toString(num);  
       }  
    }

1.  题目：实现一个 Java 类，该类有一个字符串和一个方法，该方法将字符串转换为整数。  
    答案：

public class StringToInteger {
          
       private String str;
       public StringToInteger(String str) {
          
           this.str = str;  
       }
       public int toInteger() {
          
           return Integer.parseInt(str);  
       }  
    }

1.  题目：实现一个 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 的子字符串数组。然后，我们遍历并打印这些子字符串。

1.  编写一个 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");  
       }  
    }

1.  实现 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();  
       }  
    }

1.  实现 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;  
       }  
    }

[b0a36a702c8b46d99034a0de71070f2c.png_pic_center]: https://img-blog.csdnimg.cn/b0a36a702c8b46d99034a0de71070f2c.png#pic_center