实现类是否需要重写接口的所有方法

在 Java 中，**实现类是否需要重写接口的所有方法**，取决于接口中方法的类型和实现类的类型。以下是详细规则：

---

### **1. 接口中的方法类型**
#### **(1) 抽象方法（无默认实现）**
- **必须重写**：实现类必须为所有抽象方法提供具体实现，否则会编译报错。
  ```java
  interface MyInterface {
      void abstractMethod(); // 抽象方法（无默认实现）
  }

  class MyClass implements MyInterface {
      @Override
      public void abstractMethod() { // 必须重写
          System.out.println("实现抽象方法");
      }
  }
  ```

#### **(2) 默认方法（`default` 关键字，Java 8+）**
- **无需重写**：实现类可以直接继承接口的默认方法，也可以选择重写。
  ```java
  interface MyInterface {
      default void defaultMethod() { // 默认方法
          System.out.println("默认方法");
      }
  }

  class MyClass implements MyInterface {
      // 不重写 defaultMethod()，直接使用默认实现
  }
  ```

#### **(3) 静态方法（`static` 关键字，Java 8+）**
- **无法重写**：静态方法属于接口本身，实现类无需也无法重写。
  ```java
  interface MyInterface {
      static void staticMethod() { // 静态方法
          System.out.println("静态方法");
      }
  }

  class MyClass implements MyInterface {
      // 无法重写 staticMethod()
  }
  ```

---

### **2. 实现类的类型**
#### **(1) 具体类（非抽象类）**
- **必须重写所有抽象方法**，但默认方法和静态方法无需处理。
  ```java
  interface MyInterface {
      void abstractMethod();
      default void defaultMethod() {}
  }

  class MyClass implements MyInterface {
      @Override
      public void abstractMethod() {} // 必须重写
      // defaultMethod() 无需重写
  }
  ```

#### **(2) 抽象类（`abstract` 关键字）**
- **可以暂缓重写**：抽象类可以选择不实现接口的抽象方法，将责任交给子类。
  ```java
  interface MyInterface {
      void abstractMethod();
  }

  abstract class MyAbstractClass implements MyInterface {
      // 不实现 abstractMethod()，但需保持抽象类
  }

  class MyConcreteClass extends MyAbstractClass {
      @Override
      public void abstractMethod() {} // 子类必须实现
  }
  ```

---

### **3. 示例场景**
#### **接口定义**
```java
interface Animal {
    void eat();                   // 抽象方法（必须重写）
    default void breathe() {      // 默认方法（无需重写）
        System.out.println("呼吸氧气");
    }
    static void evolution() {     // 静态方法（无法重写）
        System.out.println("生物进化");
    }
}
```

#### **实现类**
```java
class Dog implements Animal {
    @Override
    public void eat() {           // 必须重写抽象方法
        System.out.println("吃狗粮");
    }
    // 不重写 breathe()，直接继承默认实现
    // 无法重写 evolution()
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();      // 输出：吃狗粮
        dog.breathe();  // 输出：呼吸氧气
        Animal.evolution(); // 输出：生物进化
    }
}
```

---

### **总结**
| **方法类型**        | **是否需要重写** | **说明**                              |
|---------------------|-----------------|---------------------------------------|
| 抽象方法（无实现）   | 必须            | 实现类必须提供具体逻辑                |
| 默认方法（`default`）| 可选            | 可直接使用默认实现，也可自定义        |
| 静态方法（`static`）| 无法重写        | 属于接口本身，通过接口名调用          |
| **实现类类型**       |                 |                                       |
| 具体类              | 必须重写抽象方法 | 否则编译错误                          |
| 抽象类              | 可暂缓重写      | 由子类完成具体实现                    |

---

### **常见问题**
#### **Q：一个类实现多个接口，且接口中有同名默认方法怎么办？**
需显式重写该方法以解决冲突：
```java
interface InterfaceA {
    default void conflict() {}
}

interface InterfaceB {
    default void conflict() {}
}

class MyClass implements InterfaceA, InterfaceB {
    @Override
    public void conflict() { // 必须重写
        System.out.println("解决默认方法冲突");
    }
}
```

#### **Q：能否调用接口的默认方法？**
可以，通过 `接口名.super.默认方法名()`：
```java
class MyClass implements MyInterface {
    @Override
    public void defaultMethod() {
        MyInterface.super.defaultMethod(); // 调用接口的默认方法
    }
}
```

通过理解这些规则，可以更灵活地设计接口和实现类的关系。