Question

假设我有一个抽象的超类A，其定义为：

public abstract class A {
    protected string a1;
    protected int a2;
    protected char a3;

    public A(string a1, int a2, char a3) {
        this.a1 = a1;
        this.a2 = a2;
        this.a3 = a3;
    }
}

然后我有从A继承的x类 - 每个使用相同的构造函数 - 但每个类都有自己的方法，它们以自己独特的方式使用a1，a2和a3。尽管构造函数是相同的，但根据我的理解，我必须重新定义每个子类中的参数的数量和类型，如下所示：

public sub(string a1, int a2, char a3) : base(a1, a2, a3) {}

如果我需要更改参数的类型，这可能会很痛苦，因为我需要调整所有11个类。如果我使用良好的继承实践，在大多数情况下，如果我修改A的构造函数的参数，那么所有类都应该受到影响，但是在某些情况下这不是真的。例如，如果我将参数从类型Vehicle更改为Car。 Car是Vehicle的子类，因此它包含所有Vehicle的API成员，除了构造函数之外，所有类都不需要更改。

有没有办法按照以下方式做点什么：

public sub {
    public sub(...) : base(...) {}
}

这样，当参数类型改变时，不需要更改所有10个子类构造函数定义吗？

Answer 1

不，它没有语法糖。

您可以将所有参数包装在一个类中，这样对参数的更改不会影响所有类型，但您很容易错过处理新添加的参数：

#Uses python3
import sys
def calc_cache_pos(strings, indexes):
    factor = 1
    pos = 0
    for s, i in zip(strings, indexes):
        pos += i * factor
        factor *= len(s)
    return pos

def lcs_back(strings, indexes, cache):
    if -1 in indexes:
        return ""
    match = all(strings[0][indexes[0]] == s[i]
                for s, i in zip(strings, indexes))
    if match:
        new_indexes = [i - 1 for i in indexes]
        result = lcs_back(strings, new_indexes, cache) + strings[0][indexes[0]]
    else:
        substrings = [""] * len(strings)
        for n in range(len(strings)):
            if indexes[n] > 0:
                new_indexes = indexes[:]
                new_indexes[n] -= 1
                cache_pos = calc_cache_pos(strings, new_indexes)
                if cache[cache_pos] is None:
                    substrings[n] = lcs_back(strings, new_indexes, cache)
                else:
                    substrings[n] = cache[cache_pos]
        result = max(substrings, key=len)
    cache[calc_cache_pos(strings, indexes)] = result
    return result

def lcs(strings):
        if len(strings) == 0:
        return ""
    elif len(strings) == 1:
        return strings[0]
    else:
        cache_size = 1
        for s in strings:
            cache_size *= len(s)
        cache = [None] * cache_size
        indexes = [len(s) - 1 for s in strings]
        return (lcs_back(strings, indexes, cache))
if __name__ == '__main__':
    input = sys.stdin.read()
    data = list(map(int, input.split()))
    an = data[0]
    data = data[1:]
    a1 = data[:an]
    data = data[an:]
    bn = data[0]
    data = data[1:]
    b1 = data[:bn]
    data = data[bn:]
    cn = data[0]
    data = data[1:]
    c1 = data[:cn]
    a = ''
    for i in a1:
        a = a + i
    b = ''
    for i in b1:
        b = b + i
    c = ''
    for i in c1:
        c = c + i
    print(lcs([a, b, c]))

请注意，在VS中使用重构工具（以及像R＃这样的外部工具）会使方法/构造函数的参数更改大多是自动的 - 因此在将所有参数打包到单个类之前首先尝试这些参数可能是个好主意。

在C＃中省略子类构造函数的参数

1 个答案: