python - python 类层次结构问题

Question

我有一个类层次结构:

class ParentClass:

    def do_something(self):
        pass # child classes have their own implementation of this

class ChildClass1(ParentClass):

    def do_something(self):
        <implementation here>

class ChildClass2(ParentClass):

    def do_something(self, argument_x):
        <implementation here>

class ChildClass3(ParentClass):

    def do_something(self, argument_y):
        <implementation here>

这里有两个问题:

• 方法 do_something() 在子类中具有不同的接口(interface):它在子类 2 和 3 中接受参数，但在子类 1 中没有参数
• do_something() 的参数具有不同的名称，以强调它们在子类 2 和 3 中具有不同的含义。通过下面的使用示例，这一点将变得更加清楚

这就是这些类的使用方式:

有一个返回实例的工厂类:

class ChildFactory:

    def get_child(self, argument):
        if argument == '1':
            return ChildClass1()
        elif argument == '2':
            return ChildClass2()
        elif argument == '3':
            return ChildClass3()

稍后的代码:

...
# pseudocode, not python
child_type = ? # can have values '1', '2' or '3' at this moment
var1 = 1
var2 = 'xxx'
# var1 and var2 have different types, just to emphasize the difference in their
# meaning when being passed as arguments to do_something()
# this was mentioned above (the second problem)
child = ChildFactory.get_child(child_type)
if child is an instance of ChildClass1, child.do_something() is called
if child is an instance of ChildClass2, child.do_something(var1) is called
if child is an instance of ChildClass3, child.do_something(var2) is called
# end of pseudocode

问题:

1. 上面提到的两个问题是否是糟糕设计的表现？如果是这样，设计层次结构的正确方法是什么？
2. 如何用python统一编写伪代码片段？主要问题是避免对每个特定情况使用巨大的 if/else 语句，因为它会使 ChildFactory.get_child() 中的 if/else 语句加倍

Answer 1

具有相同名称和不同参数的方法是一种代码味道。

“方法 do_something() 在子类中具有不同的接口(interface):它在子类 2 和 3 中接受参数，但在子类 1 中没有参数”

你不说为什么。有两个很好的理由

• 子类 1 有一个默认值。

• 子类 2 忽略该值。

几乎任何其他原因都表明 do_something 确实不同，并且应该具有不同的名称。

如果子类 1 有默认值，则只需在方法函数的参数中显式编码默认值即可。

class ChildClass1( ParentClass ):
    def do_something( argument_x= None )
        ....

如果子类 1 忽略该值，则只需忽略该值。不要倒立而忽略某个值。

class ChildClass1( ParentClass ):
    def do_something( argument_x )
        return True

多态方法函数如果不碰巧使用所有参数值，就没有什么魔力。

“do_something() 的参数具有不同的名称，以强调它们在子类 2 和 3 中具有不同的含义。”

这只是糟糕的设计。您不能使用具有不同参数名称的相同方法函数，因为它们执行不同的操作。

具有相同的方法函数名称是错误的。如果它们是相似事物的不同实现，那么参数将具有本质上相同的含义。

如果它们实际上做不同的事情，那么你就没有多态性，并且你不应该给这些方法赋予相同的名称。

当两个类中的方法执行根本不同的操作时(需要具有不同名称的不同参数以使其显而易见)，这些方法不得具有相同的名称。当该名称没有描述该方法实际执行的操作时，该名称就不再有意义。

注意

顺便说一句，由于鸭子类型，你的代码将在 Python 中运行。只要方法名称匹配，参数类型甚至不必接近匹配。然而，这确实是一个糟糕的设计，因为这些方法之间的本质差异是如此巨大。