抽象类和通用代码

Question

我对抽象类及其真正目的有疑问.

考虑以下情况:

interface A {
    void execute();
}

class AOne implements A {
    public void execute() {
        x = getX();
        ..
        functionality specific to A
        ..
        y = getY();
        ..
        more funtionality specific to A
    }

    private X getX() {
        .. 
        return x;
    }

    private Y getY() {
        ..
        return y;
    }
}

class ATwo implements A {
    public void execute() {
        x = getX();
        ..
        functionality specific to B
        ..
        y = getY();
        ..
        more funtionality specific to B
    }

    private X getX() {
        ..
        return x;
    }

    private Y getY() {
        ..
        return y;
    }   
}

所以,我有一个接口A,它声明了一个方法execute()和2个实现,AOne和ATwo都实现/定义execute()你会注意到两个实现中的execute方法都有一些常见的功能,即方法调用getX()和getY().这两种实现中的这些方法都做同样的事情,即它们在两个子类中都是重复的.

现在,问题.我将通过在接口和实现之间实现一个抽象类来对上面的代码进行一些修改.

interface A {
    void execute();
}

public abstract class AbstractA implements A {
    protected X getX() {
        .. 
        return x;
    }

    protected Y getY() {
        ..
        return y;
    }
}

class AOne extends AbstractA {
    public void execute() {
        x = getX();
        ..
        functionality specific to A
        ..
        y = getY();
        ..
        more funtionality specific to A
    }
}

class ATwo extends AbstractA {
    public void execute() {
        x = getX();
        ..
        functionality specific to B
        ..
        y = getY();
        ..
        more funtionality specific to B
    }
}

您现在将注意到,先前在实现类AOne和ATwo(即getX()和getY()中重复的方法已移至抽象类AbstractA.另请注意,AbstractA实现了A,但未提及execute()的任何实现.它只包含AOne和ATwo常用的代码

现在,我认为上面是错误地使用抽象类和不正确的面向对象编程.抽象类不应该用于保存实现类的通用代码,至少不是这种方式.

有人可以对此有所了解,如果上述内容是正确的,请告诉我.如果是,为什么,如果不是为什么？

编辑:我相信我的"公共代码"部分是错误的.我同意抽象类用于保存各种实现类的通用功能.但是如果我们认为方法getX()和getY()是AOne和ATwo类需要的某种实用程序,那么将它们提升到抽象类仍然是一个好主意吗？

问题的底线是:是否应该使用抽象类来保存子类中的公共实用程序代码？

Answer 1

你说过了

抽象类不应该用于保存实现类的通用代码

哪个不对.这正是他们的目的所在.

我会说你的execute方法可以更好地设计为AbstractA:

public abstract class AbstractA implements A {
    protected abstract void doStuff(X x);
    protected abstract void doMoreStuff(X x, Y y);

    public void execute() {
        X x = getX();
        doStuff(x);
        Y y = getY();
        doMoreStuff(x, y);
    }

    // getX(), getY(), etc...
}

然后,您的实现类可以在那些抽象的doStuff()和doMoreStuff()方法中分离特定于实现的代码.