Java 覆盖静态<；K、 V>；方法

我们有一种方法可以对两个通用对象进行区分：

    public static <K, V> Diff<K, V> check(K key, V act, V exp) {
        Diff<K, V> d = null;
        System.out.println(act.getClass());
        System.out.println(exp.getClass());
        // null checks
        if (exp == null && act == null) {
            // both null, so no difference
        } else if (exp == null) {
            d = new Diff<>(key, null, act);
        } else if (act == null) {
            d = new Diff<>(key, exp, null);
        } else {
            // compare the entries
            if (!exp.equals(act)) {
                d = new Diff<>(key, exp, act);
            }
        }

        return d;
    }

那么，为什么不调用我的专用方法，而调用通用方法呢

这是课程（其中的一部分）：

及供参考

public static class Row extends HashMap<String, Object> {
    private static final long serialVersionUID = 1L;
}

公共静态类行扩展HashMap{
私有静态最终长serialVersionUID=1L；
}

公共静态列表地图比较（地图地图1、地图地图2）{
// ...
V exp=map1.get（键）；
V act=map2.get（键）；
差异d=差异检查（键、动作、经验）；
// ...

---

调用站点在编译时绑定。编译器永远不会将

Diff.check

的调用绑定到新的重载，因为它不知道也不关心运行时

V

可能绑定到

java.sql.Date

。它只知道

K

和

V

是从

对象派生的一些类型，因此，它绑定到它可以使用的唯一方法：
Diff-check（K，V，V）
是的，但我不知道如何在回复中正确格式化它。这里是未格式化的，因为它似乎从未在回复中格式化过：太长了。我将不得不在下一篇评论中发布：始终使用有意义的名称。什么是
check（）
mean？完全正确：无。提示：在第二种情况下，甚至没有必要定义
V
类型。V没有被使用，因此不应该出现在那里！公共静态列表映射比较（Map map1，Map map2）{List result=new LinkedList（）；//null检查（map1==null）{map1=new HashMap（）；}if（map2==null）{map2=new HashMap（）；}HashSet allKeys=new HashSet（）；allKeys.addAll（map1.keySet（））；allKeys.addAll（map2.keySet（））；for（K key:allKeys）{V exp=map1.get（key）；V act=map2.get（key）；Diff d=Diff.check（key，act，exp）；if（d！=null）{result.add（d）；}返回结果；}不要在注释中添加更多信息。编辑您的问题，并在那里设置代码格式…就像您设置问题中所有其他代码的格式一样！谈论重写静态方法没有意义；只能重写虚拟方法。那么，您认为在原文中，我可以设置if而不是if（！exp.equals（act））！（exp.toString（）.equals（act.toString（））？用于只打印yyyy-mm-dd的java.sql.Date。但对于其他数据类型，它可能会出错？我不会，因为默认的
toString（）
实现包括标识哈希代码。没有规则规定两个等效对象也必须通过
toString（）相等
。更重要的是，没有规则规定通过
toString（）
相等的对象实际上是相等的。
class java.sql.Date
class java.sql.Date

public static class Diff<K, V> {
    private K key;
    private V exp, act;
    ...
    ...
}

public static <K, V> List<Diff<K, V>> MapComparison(Map<K, V> map1, Map<K, V> map2) {
    List<Diff<K, V>> result = new LinkedList<Diff<K, V>>();

    // null checks
    if (map1 == null) {
        map1 = new HashMap<K, V>();
    }
    if (map2 == null) {
        map2 = new HashMap<K, V>();
    }

    HashSet<K> allKeys = new HashSet<K>();
    allKeys.addAll(map1.keySet());
    allKeys.addAll(map2.keySet());

    for (K key : allKeys) {
        V exp = map1.get(key);
        V act = map2.get(key);
        Diff<K, V> d = Diff.check(key, act, exp);
        if (d != null) {
            result.add(d);
        }
    }

    return result;
}

public static DiffListMap doComparison(RowList exp, RowList act, String keyName) {
    DiffListMap ret = new DiffListMap();
    DiffList diffs;

    // Loop through each expected row.
    for (Row exp_row : exp) {
        Object key = exp_row.get(keyName);
        diffs = null;
        boolean found = false;
        // Look for the corresponding actual row
        // using the unique key
        for (Row act_row : act) {
            if (act_row.get(keyName).equals(key)) {
                // If the correct one is found, do the comparison
                found = true;
                diffs = new DiffList(MapComparison(exp_row, act_row));
                // remove the row from the actual results.
                act.remove(act_row);
                break;
            }
        }

public static class Row extends HashMap<String, Object> {
    private static final long serialVersionUID = 1L;
}

public static <K, V> List<Diff<K, V>> MapComparison(Map<K, V> map1, Map<K, V> map2) {
    // ...
    V exp = map1.get(key);
    V act = map2.get(key);
    Diff<K, V> d = Diff.check(key, act, exp);
    // ...