Question

使用Java。

我已经定义了几个不同的抽象类，每个抽象类都有一个名为aCommonMethod的静态方法。每个人都有一个依赖方法，它本身调用一个CommonMethod，如下所示：

public abstract class SomeAbstractClass{
    public static void aCommonMethod() {
    // does something
    }

    public static void someDependentMethod() {
    //some stuff
    aCommonMethod()
    //some more stuff
    }
}

someDependentMethod方法对于我的每个抽象类都是相同的，除了通过调用aCommonMethod调用什么方法。

用Java实现这一目标的惯用方法是什么？到目前为止，除了将aCommonMethod方法实际复制到每个抽象类中之外，我找不到任何有用的东西。显然，最好只在某个地方编写一次方法然后让我的抽象类以某种方式继承它。我在Java中找不到任何方法。

Answer 1

Fist，你不能覆盖静态方法，如果你想让不同的类有不同的行为，可能需要template pattern。

示例：

public abstract class SomeAbstractClass{
    public abstract void aCommonMethod();

    public void someDependentMethod() {
        //some stuff
        aCommonMethod();
        //some more stuff
    }
}

public abstract class SomeClass{
    public void aCommonMethod() {
        // Do your thing
    }
}

public abstract class SomeOtherClass{
    public void aCommonMethod() {
        // Do your thing
    }
}

new SomeClass().someDependentMethod();
new SomeOtherClass().someDependentMethod();

Answer 2

如果我明白你的意思，我不是不舒服，但我会通过使用这两个类来解决你的问题：

妈妈级：

public class mother 
{
    public void sortTest()
    {
        //some stuff
        child.sort();
        //some stuff
    }
}

小孩子类别：

public abstract class child extends mother
{
    public static void sort()
    {
        //some stuff
    }
}

您应该更准确地描述您的问题！

Answer 3

这就是抽象方法的用途。

abstract class SomeAbstractClass {
    public abstract void aCommonMethod();

    public void someDependentMethod() {
        // some stuff
        aCommonMethod();
       // some more stuff
    }
}

class Impl1 extends SomeAbstractClass {
    @Override public void aCommonMethod() {
       System.out.println("Impl1 version of aCommonMethod");
    }
}

每个子类都可以实现抽象方法来做自己的事情，而常见的超类方法将调用具体的子类'实现。

继承不适用于静态方法，请改为使用这些实例方法。惯用的答案是避免对作为类层次结构一部分的方法使用静态。

你的例子中有什么，从定义aCommonMethod判断为返回void，似乎有状态和副作用出没，但如果你拥有的是无状态的静态方法的集合，那么你似乎可能不会这里需要一个类层次结构;考虑使用策略模式，传入指定应该如何完成某些操作的对象。

请参阅this question，了解在Java 8中使用lambdas传递策略。

Answer 4

从Java 8开始，现在可以使用lambda表达式将函数作为参数传递给其他函数。然而，程序员在Java 8之前绕过了这个问题，他们过于复杂的阴谋已经过时了。

例如，使用新的lambda表达式，可以编写

interface PointlessInterfaceObject {
    void onlyFunction();
}

然后可以像这样定义someDependentMethod：

someDependentMethod(PointlessInterfaceObject myPointlessInterfaceObject){
// some code
myPointlessInterfaceObject.onlyFunction();
// more code
}

现在，如果你首先实例化这样的匿名函数，

PointlessInterfaceObject myAnonymousFunction = ()->SomeAbstractClass.aCommonMethod();

然后你可以将它作为参数传递给方法，如下所示：

someDependentMethod(myAnonymousFunction)

这使您可以像someDependentMethod一样编写一个函数，然后将其他方法传递给它。

如何实现抽象子类继承的方法？

4 个答案: