4

我有一个复杂的类，我想通过实现一个外观类来简化它（假设我无法控制复杂的类）。我的问题是复杂类有很多方法，我将简化其中的一些，其余的将保持原样。下面解释我所说的“简化”。

我想找到一种方法，如果一个方法是用外观实现的，然后调用它，如果没有，那么在复杂类中调用该方法。我想要这个的原因是编写更少的代码:) [少即是多]

例子：

Facade facade = // initialize
facade.simplified(); // defined in Facade class so call it

// not defined in Facade but exists in the complex class
// so call the one in the complex class
facade.alreadySimple();

想到的选项是：

选项1：编写一个包含复杂类变量的类并实现复杂类，然后通过直接委托实现简单类：

class Facade {
    private PowerfulButComplexClass realWorker = // initialize
    public void simplified() {
         // do stuff
    }
    public void alreadySimple() {
         realWorker.alreadySimple();
    }
    // more stuff
}

但是使用这种方法，我将需要只用一个委托语句来实现所有简单的方法。所以我需要写更多的代码（虽然很简单）

选项 2：扩展复杂类并实现简化的方法，但是这些方法的简单和复杂版本都将可见。

在python中，我可以实现类似的行为：

class PowerfulButComplexClass(object):
    def alreadySimple(self):
        # really simple

    # some very complex methods


class Facade(object):
    def __init__(self):
        self.realworker = PowerfulButComplexClass()
    def simplified(self):
        # simplified version of complex methods in PowerfulButComplexClass

    def __getattribute__(self, key):
    """For rest of the PowerfulButComplexClass' methods use them as they are
    because they are simple enough.
    """
        try:
            # return simplified version if we did
            attr = object.__getattribute__(self, key)
        except AttributeError:
            # return PowerfulButComplexClass' version because it is already simple
            attr = object.__getattribute__(self.data, key)
        return attr


obj = Facace()
obj.simplified() # call the one we have defined
obj.alreadySimple( # call the one defined in PowerfulButComplexClass

那么实现这一点的 Java 方法是什么？

编辑：我所说的“简化”是什么意思：复杂的方法可以是具有太多参数的方法

void complex method(arg1, arg2, ..., argn) // n is sufficiently large

或一组相关的方法，它们几乎总是一起调用以完成单个任务

outArg1 = someMethod(arg1, arg2);
outArg2 = someOtherMethod(outArg1, arg3);
actualResult = someAnotherMethod(outArg2);

所以我们想要这样的东西：

String simplified(arg1, arg2, arg3) {
    outArg1 = someMethod(arg1, arg2);
    outArg2 = someOtherMethod(outArg1, arg3);
    return someAnotherMethod(outArg2);
}
4

4 回答 4

3

这叫继承。考虑以下代码：

class Complex {
    public function complex() { /* Complex Function */ }
    public function simple() { /* Already simple function */ }
}

class SimplifiedComplex extends Complex {
    public function complex() { /* Simplify Here */ }
}

该simple()方法将作用于一个SimplifiedComplex对象。

于 2012-05-08T20:20:03.733 回答
2

我想你已经调用它了。我会选择选项 1。考虑到 java 的刚性，它提供了最大的灵活性。

我更喜欢它，因为它有利于组合而不是继承。尽管这会创建更多代码，但我发现从长远来看，这样的设计通常更容易修改。

继承只能用于建模严格的“是”关系，其中子类必须具有基类的所有属性和行为。如果您将继承用于其他任何事情，那么您会自找麻烦。

最后，我不赞成“少即是多”的想法（在此处插入非常简洁、难以理解的 perl 示例）。我认同“代码应该尽可能简单，而不是简单”的原则。

于 2012-05-08T20:53:40.260 回答
1

根据您的用例，您可能希望通过委托（选项 1）在复杂类中的某些功能前面创建一个外观，而不是为复杂类中的其余功能提供支持，而是提供访问方法直接复杂类（getComplexClass）。

这可能会使设计更清晰。例如，考虑一个处理银行系统大部分功能的复杂类。创建一个名为“Account”的类，它可以访问复杂的类，但只使用与银行账户相关的方法，这有助于设计。为方便起见，Account 类可以有一个方法 getBankSystemForAccount 或类似的方法。

于 2012-05-08T20:33:58.913 回答
1

这在 Java 中很难看，但是您可以编写一个函数，该函数接受您要调用的方法的名称和一个参数列表，并使用反射找到要调用的适当方法。这在概念上与您在 Python 中的操作方式相似，只是更难看。

于 2012-05-09T01:09:58.477 回答