Java 我怎样才能有一个单元测试来确保所有子类实现一个方法？

我想做一个单元测试，确保所有子类都实现一个方法

一些代码可以更好地解释我正在尝试做什么

超级类是这样的：

class SuperClass
{
    public boolean isImportant()
    {
        throw customException;
    } 
}

for(Class subClass : SuperClass.subclasses)
{
   subClass obj = new subClass();
   obj.isImportant();
}

现在假设我有子类

A

和

B

我想确保这些课程中包含了这些内容，比如：

class A extends SuperClass
{
    @Override
    public boolean isImportant()
    { 
        return true; //or false
    }
}

b类：

class B extends SuperClass
{
}

现在如果我做

bb=newb（）；b、 isImportant（）

我将获得异常

我不需要对每个类都进行测试（有很多类，我可能会错过一些，将来可能会添加更多的子类），我怎样才能轻松地测试它呢

我在想是否有某种方法可以实例化每个子类的对象

大概是这样的：

class SuperClass
{
    public boolean isImportant()
    {
        throw customException;
    } 
}

for(Class subClass : SuperClass.subclasses)
{
   subClass obj = new subClass();
   obj.isImportant();
}

因为这将遍历所有子类，不管是否添加或删除了一些子类，如果抛出异常，则将失败

---

有什么方法可以做到这一点吗？

将方法

抽象化，子类必须实现它，否则它们将无法编译。无需进行单元测试（无论如何）

更新

现在，如果您不能（或不想）将方法更改为
abstract
，您可以这样测试它

class SuperClass {
    public boolean isImportant() { throw new UnsupportedOperationException(); } 
}

class A extends SuperClass {
    @Override
    public boolean isImportant() { return true; }
}

class B extends SuperClass {
}

class TestIsImportant {

    @SuppressWarnings("unchecked")
    private static final Class<?>[] classesToTest = new Class[] {
        A.class, B.class
    };

    @Test
    public void test() throws Exception {
        for (Class<?> classToTest : classesToTest) {
            classToTest.getDeclaredMethod("isImportant");
        }
    }

}

类超类{
公共布尔值isImportant（）{抛出新的UnsupportedOperationException（）；}
}
类扩展了超类{
@凌驾
公共布尔值isImportant（）{return true；}
}
类扩展了超类{
}
类测试很重要{
@抑制警告（“未选中”）
私有静态最终类[]classesToTest=新类[]{
A级，B级
};
@试验
public void test（）引发异常{
对于（类classToTest:classesToTest）{
classToTest.getDeclaredMethod（“isImportant”）；
}
}
}

如果方法没有实现，这将抛出
NoSuchMethodException
，并且很容易添加到要测试的类列表中。
将方法
抽象化，子类必须实现它，否则它们不会编译。无需进行单元测试（无论如何）

更新

现在，如果您不能（或不想）将方法更改为
abstract
，您可以这样测试它

class SuperClass {
    public boolean isImportant() { throw new UnsupportedOperationException(); } 
}

class A extends SuperClass {
    @Override
    public boolean isImportant() { return true; }
}

class B extends SuperClass {
}

class TestIsImportant {

    @SuppressWarnings("unchecked")
    private static final Class<?>[] classesToTest = new Class[] {
        A.class, B.class
    };

    @Test
    public void test() throws Exception {
        for (Class<?> classToTest : classesToTest) {
            classToTest.getDeclaredMethod("isImportant");
        }
    }

}

类超类{
公共布尔值isImportant（）{抛出新的UnsupportedOperationException（）；}
}
类扩展了超类{
@凌驾
公共布尔值isImportant（）{return true；}
}
类扩展了超类{
}
类测试很重要{
@抑制警告（“未选中”）
私有静态最终类[]classesToTest=新类[]{
A级，B级
};
@试验
public void test（）引发异常{
对于（类classToTest:classesToTest）{
classToTest.getDeclaredMethod（“isImportant”）；
}
}
}

如果方法未实现，这将抛出
NoSuchMethodException
，并且很容易添加到要测试的类列表中。
我认为您尝试测试的内容很奇怪，您可能应该使用@Andreas的解决方案：

使方法抽象，子类必须实现它，否则
不会编译。无需进行单元测试（无论如何）

话虽如此，以下是您测试所需内容的方法：

public class SuperClass {

    public void method() {
        System.out.println("Default implementation.");
    }

}

public class SubClassA extends SuperClass {

    @Override
    public void method() {
        System.out.println("Overridden implementation.");
    }

}

public class SubClassB extends SuperClass {}

public class TestClass {

    @Test
    public void test() throws NoSuchMethodException {
        // nothing happens here
        SubClassA.class.getDeclaredMethod("isImportant");

        // the line below throws NoSuchMethodException, failing the test
        SubClassB.class.getDeclaredMethod("isImportant");
    }

}

现在，如果您希望能够循环遍历所有
超类
子类，您应该了解以下内容：
我认为您尝试测试的内容很奇怪，您可能应该使用@Andreas的解决方案：

使方法抽象，子类必须实现它，否则
不会编译。无需进行单元测试（无论如何）

话虽如此，以下是您测试所需内容的方法：

public class SuperClass {

    public void method() {
        System.out.println("Default implementation.");
    }

}

public class SubClassA extends SuperClass {

    @Override
    public void method() {
        System.out.println("Overridden implementation.");
    }

}

public class SubClassB extends SuperClass {}

public class TestClass {

    @Test
    public void test() throws NoSuchMethodException {
        // nothing happens here
        SubClassA.class.getDeclaredMethod("isImportant");

        // the line below throws NoSuchMethodException, failing the test
        SubClassB.class.getDeclaredMethod("isImportant");
    }

}

现在，如果您希望能够循环遍历所有
超类
子类，您应该了解以下内容：
我不明白您认为单元测试与您案例中的继承有多大关系。如果需要确保
isImportant（）
在子类中实现/继承，只需使A和B
扩展
超类。然后，您可以确保所有子类永远都拥有超类的所有方法

class A extends SuperClass {
...

如果该方法没有在超类中实现，但您仍然希望执行您所编写的操作，请将超类
抽象化

最后，定义一个
接口
，如：

interface SuperInterface {
   boolean isImportant();
}

…并使A和B执行它这可能是最干净的方法。
我不明白您认为单元测试与您案例中的继承有什么关系。如果需要确保
isImportant（）
在子类中实现/继承，只需使A和B
扩展
超类。然后，您可以确保所有子类永远都拥有超类的所有方法

class A extends SuperClass {
...

如果该方法没有在超类中实现，但您仍然希望执行您所编写的操作，请将超类
抽象化

最后，定义一个
接口
，如：

interface SuperInterface {
   boolean isImportant();
}

…并使A和B执行它这可能是最干净的方法。
我相信OP的超类有一个默认实现，所以我不确定这是否适用于他。但如果你想确保子类实现一个方法，这绝对是正确的策略。@Thiagoprorciúncula是的，我的想法是，如果你想单元测试所有代码都实现了它，为什么不强制执行它呢。当然，除非基类不在您的控制范围之内，但问题并不是说这是一个约束。我同意。单元测试是确保代码单元的运行时行为符合预期的一种很好的方法。使用抽象方法可以让编译器为您强制执行此规则。虽然这是一个非常好的建议，但它并不能真正回答OP的问题。@Andreas本着对OPs问题保持客观的精神，我认为对ma说这是一个更好的答案