JAVA面试中，面试官最爱问的问题。

Java中的静态关键字有什么作用？

在Java中，`static`关键字是一个修饰符，它可以用于修饰类的方法、变量、代码块和初始化块。`static`关键字的作用主要包括以下几点：

1. **类属性和方法**：当变量或方法被声明为`static`时，它们属于类本身，而不是类的实例。这意味着：
   - 静态变量由类的所有实例共享，而不是每个实例都有自己的副本。
   - 静态方法可以在没有创建类的实例的情况下被调用，并且它们不能访问类的非静态成员。

2. **静态初始化块**：静态初始化块是使用`static`关键字声明的代码块，它在类加载时执行一次。它通常用于初始化静态变量。

3. **静态代码块**：静态代码块主要用于初始化类的静态变量，它在类第一次被加载到JVM中时执行。

4. **静态导包**：使用`import static`语句可以导入某个类中的静态成员，这样在使用这些静态成员时就不需要每次都指定类名。

5. **静态工厂方法**：静态方法可以被用作返回类实例的工厂方法，因为它们可以被类名直接调用，而不需要创建类的实例。

6. **不变性**：由于静态变量的值在类加载时就已经确定，它们通常用于表示不变性，如常量。

7. **单例模式**：静态方法常用于实现单例模式，确保全局只有一个实例。

8. **工具类**：`static`关键字通常用于工具类（如`java.lang.Math`），因为这些类不需要维护状态，并且它们的方法通常不需要访问类的实例变量。

9. **静态内部类**：静态内部类是被声明为静态的内部类，它可以不依赖于外部类的实例而存在。

使用`static`关键字时需要注意的是，过度使用静态方法和变量可能会导致代码难以测试和维护，因为它们违反了面向对象的一些原则，如封装和继承。因此，应该谨慎使用静态成员，确保它们符合设计模式和最佳实践。

什么是Java中的多态？如何实现多态？

在Java中，**多态**（Polymorphism）是一个核心的面向对象概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。多态性使得代码更加灵活和可扩展。

### 多态的两种主要形式：

1. **编译时多态（静态多态/方法重载）**：通过方法重载（Overloading）实现，即在一个类中可以有多个同名方法，只要它们的参数列表不同（参数的类型、数量或顺序不同）。

2. **运行时多态（动态多态/方法重写）**：通过方法重写（Overriding）和接口实现实现，即子类重写父类的方法，或者实现接口中的方法。运行时多态是Java多态性的一个重要特点，它允许程序在运行时确定方法的调用。

### 如何实现多态：

1. **通过继承**：子类继承父类，并重写（Override）父类的方法。这样，当子类对象赋给父类引用时，可以调用子类重写的方法。

   ```java
   class Parent {
       void show() {
           System.out.println("Parent show()");
       }
   }

   class Child extends Parent {
       @Override
       void show() {
           System.out.println("Child show()");
       }
   }

   Parent obj = new Child();
   obj.show(); // 输出 "Child show()"
   ```

2. **通过接口**：一个类实现一个或多个接口，并提供接口中方法的具体实现。

   ```java
   interface Shape {
       void draw();
   }

   class Circle implements Shape {
       @Override
       public void draw() {
           System.out.println("Drawing a Circle");
       }
   }

   Shape shape = new Circle();
   shape.draw(); // 输出 "Drawing a Circle"
   ```

3. **通过泛型**：Java的泛型允许在编译时检查类型安全，同时在运行时处理未知类型。

   ```java
   class GenericClass<T> {
       private T value;

       public GenericClass(T value) {
           this.value = value;
       }

       public void printValue() {
           System.out.println(value);
       }
   }

   GenericClass<String> stringObject = new GenericClass<>("Hello World");
   stringObject.printValue(); // 输出 "Hello World"
   ```

4. **通过抽象类**：抽象类不能被实例化，但可以被继承。子类可以实现抽象类中的抽象方法，从而实现多态。

   ```java
   abstract class Animal {
       abstract void makeSound();
   }

   class Dog extends Animal {
       @Override
       void makeSound() {
           System.out.println("Woof woof");
       }
   }

   Animal myDog = new Dog();
   myDog.makeSound(); // 输出 "Woof woof"
   ```

多态是Java中一个非常重要的特性，它提高了代码的复用性和灵活性，允许以统一的方式处理不同类型的对象。通过多态，可以编写出更加通用和可扩展的代码。