如何在Java中通过子类名调用多个父接口的静态方法？

我正在将项目从Python迁移到Java。Python中有一个多继承的工具类Util，继承了TimeUtil、MathUtil等多个工具类，示例代码如下：

# python
class MathUtil(object):
    @staticmethod
    def add(n, m):
        return n + m


class TimeUtil(object):
    @staticmethod
    def date_to_str():
        return '2022-01-01'


class Util(MathUtil, TimeUtil):
    @staticmethod
    def do_something():
        return

Util.add(1, 2)

在Python中，只需导入Util类，即可通过Util类名直接调用父类静态方法，如Util.date_to_str()、Util.add()等。

我希望将工具函数拆分到不同工具类中，请问如何在Java中实现通过子类名（而非实例）调用多个父接口的静态方法？若无法实现，原因是什么？

已尝试方案 #

Java不支持多继承类，我尝试用接口并定义default方法，但必须创建子类实例才能调用，不符合工具类通过类名调用的需求：

import java.util.Date;

interface MathUtil {

    default int add(int n, int m){
        return n + m;
    }
}

interface TimeUtil{
    default String parseDate(Date date) {
        return "2022-01-01";
    }
}
public class Util implements MathUtil, TimeUtil {

    public static void main(String[] args) {
//        期望代码 
//         int add = Util.add(1, 2); 
//         编译错误
//         Non-static method 'add(int, int)' cannot be referenced from a static context

        // 可编译的实际代码
        Util util = new Util();
        int add = util.add(1, 2);
    }
}

若将接口中default方法改为static方法，则必须通过父接口名调用（如MathUtil.add(1, 2)），否则会报错：仅能在所属接口类上调用静态方法

无法直接实现的原因 #

Java的设计规则决定了这一点：

1. 接口静态方法的归属限制：接口的静态方法属于接口本身，而非实现类。实现类无法继承接口的静态方法，因此不能通过实现类的类名直接调用接口的静态方法，必须通过接口名调用。
2. default方法的实例绑定特性：接口的default方法是实例方法，只能通过接口的实现类实例调用，无法直接通过类名调用，这和工具类静态调用的需求冲突。
3. 类的单继承限制：Java类只能单继承，无法像Python那样通过多继承类来聚合多个父类的静态方法。

替代实现方案 #

如果想通过统一的Util类名调用多个工具类的静态方法，最直接的方式是在Util类中编写静态代理方法，手动转发调用：

import java.util.Date;

class MathUtil {
    public static int add(int n, int m) {
        return n + m;
    }
}

class TimeUtil {
    public static String parseDate(Date date) {
        return "2022-01-01";
    }
}

public class Util {
    // 代理MathUtil的add方法
    public static int add(int n, int m) {
        return MathUtil.add(n, m);
    }

    // 代理TimeUtil的parseDate方法
    public static String parseDate(Date date) {
        return TimeUtil.parseDate(date);
    }

    public static void doSomething() {
        // 自定义逻辑
    }

    public static void main(String[] args) {
        // 现在可以通过Util类名直接调用
        int result = Util.add(1, 2);
        String dateStr = Util.parseDate(new Date());
    }
}

这种方式的优势是：

• 完全符合Java的语法规范，编译运行无问题
• 保持了和Python中类似的调用方式，通过Util类名统一调用所有工具方法
• 各工具类的职责依然清晰拆分，不会耦合在一起

另一种可选方案是使用静态导入，但这需要在每个使用的类中单独导入对应工具类的静态方法，无法实现通过Util统一入口调用的需求，适合局部场景使用：

import static MathUtil.add;
import static TimeUtil.parseDate;

public class Test {
    public static void main(String[] args) {
        int result = add(1, 2);
        String dateStr = parseDate(new Date());
    }
}

内容的提问来源于stack exchange，提问作者Hi computer