Java面试题

1. 问题：Java中的String和StringBuilder有什么区别？请举例说明。

   答案：

   在Java中，String 和 StringBuilder 都用于处理字符串，但它们之间有几个重要的区别：

   • String 类是不可变的，即一旦创建就不能修改。而 StringBuilder 类是可变的，可以进行字符串的修改操作。
   • 当需要频繁对字符串进行修改时，使用 StringBuilder 更高效，因为不需要创建新的对象，而是在原始对象上进行修改。
   • String 类的方法返回一个新的字符串对象，而 StringBuilder 类的方法则在原始对象上进行操作，并返回自身。

   示例代码如下：

   public class StringStringBuilderExample {
       public static void main(String[] args) {
           String str = "Hello";
           str.concat(" World"); // 返回一个新的字符串对象，原始字符串不受影响
           System.out.println(str); // 输出：Hello
           
           StringBuilder stringBuilder = new StringBuilder("Hello");
           stringBuilder.append(" World"); // 在原始字符串上进行修改
           System.out.println(stringBuilder.toString()); // 输出：Hello World
       }
   }
   

   在上述示例中，String 类的 concat() 方法返回一个新的字符串对象，但原始字符串 str 并没有被修改。而 StringBuilder 类的 append() 方法在原始字符串上进行了修改，最终输出的结果包含了添加的内容。

2. 问题：Java中的重载（Overloading）和重写（Overriding）有什么区别？请举例说明。

   答案：

   在Java中，重载和重写是实现多态性的两种机制，它们之间的区别如下：

   • 重载是指在同一个类中，方法名相同但参数列表不同的情况下，可以定义多个方法。重载方法通过不同的参数来区分，并且返回值类型不影响重载。
   • 重写是指子类重写父类中具有相同名称和参数的方法。重写方法必须具有相同的返回值类型或其子类型，并且访问修饰符不能比父类中的方法更严格。

   示例代码如下：

   // 父类
   class Animal {
       public void makeSound() {
           System.out.println("动物发出声音");
       }
   }
   
   // 子类
   class Dog extends Animal {
       @Override
       public void makeSound() {
           System.out.println("狗叫：汪汪汪");
       }
       
       public void makeSound(String soundType) { // 重载方法
           System.out.println("狗发出声音：" + soundType);
       }
   }
   
   public class OverloadOverrideExample {
       public static void main(String[] args) {
           Animal animal = new Dog();
           animal.makeSound(); // 输出：狗叫：汪汪汪
           
           Dog dog = new Dog();
           dog.makeSound("喔喔喔"); // 输出：狗发出声音：喔喔喔
       }
   }
   

   在上述示例中，Animal 类有一个 makeSound() 方法，而 Dog 类通过重写该方法实现了自己的行为。同时，Dog 类还定义了一个重载方法 makeSound(String soundType)，通过不同的参数区分了两个方法。

3. 问题：Java中的内部类（Inner Class）是什么？有哪些类型的内部类？请举例说明。

   答案：

   在Java中，内部类是定义在另一个类内部的类。它可以访问外部类的成员变量和方法，并且提供了更好的封装性和代码组织性。Java中有四种类型的内部类：

   • 成员内部类（Member Inner Class）：定义在类的内部，与外部类的实例相关联。
   • 静态内部类（Static Inner Class）：定义在类的内部，与外部类的实例无关，可以直接访问外部类的静态成员。
   • 方法内部类（Method Local Inner Class）：定义在方法内部，只能在方法内部访问。
   • 匿名内部类（Anonymous Inner Class）：没有名字的内部类，通常用于创建实现某个接口或抽象类的对象。

   示例代码如下：

   // 外部类
   class OuterClass {
       private int x = 10;
       private static int y = 20;
       
       // 成员内部类
       class MemberInnerClass {
           public void display() {
               System.out.println("成员内部类，x = " + x);
           }
       }
       
       // 静态内部类
       static class StaticInnerClass {
           public void display() {
               System.out.println("静态内部类，y = " + y);
           }
       }
       
       // 方法
       public void outerMethod() {
           // 方法内部类
           class MethodLocalInnerClass {
               public void display() {
                   System.out.println("方法内部类");
               }
           }
           
           MethodLocalInnerClass methodLocalInnerClass = new MethodLocalInnerClass();
           methodLocalInnerClass.display(); // 输出：方法内部类
       }
   }
   
   public class InnerClassExample {
       public static void main(String[] args) {
           OuterClass outerClass = new OuterClass();
           
           OuterClass.MemberInnerClass memberInnerClass = outerClass.new MemberInnerClass();
           memberInnerClass.display(); // 输出：成员内部类，x = 10
           
           OuterClass.StaticInnerClass staticInnerClass = new OuterClass.StaticInnerClass();
           staticInnerClass.display(); // 输出：静态内部类，y = 20
           
           outerClass.outerMethod(); // 输出：方法内部类
       }
   }
   

   在上述示例中，OuterClass 是外部类，它包含了三种类型的内部类。通过实例化外部类对象，我们可以访问和使用不同类型的内部类。