Question

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

    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;
    }

问题是，对于日期（java.sql.Date），有时日期而不是MM / dd / yyyy可能有MM / dd / yyyy hh：mm而另一个没有，所以它不是处理他们平等。如果日期相同，我希望它们是平等的（我不关心小时，分钟，秒）。

所以我尝试创建一个新方法：

    public static <K, V> Diff<K, java.sql.Date> check(K key, java.sql.Date act, java.sql.Date exp) {
        Diff<K, java.sql.Date> d = null;

        // 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.toString().equals(act.toString())) {
                d = new Diff<K, java.sql.Date>(key, exp, act);
            }
        }

        return d;
    }

出于某种原因它不会让我说公共静态。无论如何，这并没有给出任何编译器错误，但是当程序时，我看到原来的方法被调用了。您可以在原始方法中看到我正在打印类，它们的值是

class java.sql.Date
class java.sql.Date

那么为什么我的专用方法没有被调用，并且通用的方法被调用了？

这是课程（部分内容）：

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

（我列出了数据，我在这里展示了很多其他方法......）

这是调用函数。地图中有几行。有些很长，有些是字符串，有些是sql日期。 Key总是String，但很多其他地方也可能会调用它，这可能有其他数据类型。

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;
}

调用MapComparison：

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;
            }
        }

和FYI

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

Answer 1

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);
    // ...

呼叫站点在编译时绑定。编译器永远不会将此Diff.check的调用绑定到您的新重载，因为它不知道也不关心V在运行时可能绑定到java.sql.Date。它只知道K和V是从Object派生的某些类型，因此它可以绑定到唯一的方法：Diff<K, V> check(K, V, V)。

覆盖静态<k，v>方法

1 个答案: