如何检查Groovy类是否重写父类'；s法

我有两个Groovy类，

Child1

和

Child2

，它们派生自一个抽象的父类

parent

。父类实现了三个方法，只是它们的参数不同（即它们的方法名相同）

现在我有了一个child类的实例。任务是检查该对象的类是否实现（重写）父对象的一个或多个方法

我尝试在子类对象上使用Groovy的

检查器
。这给了我一个所有方法的列表，但我不确定如何读取输出。特别是，我不知道我正在寻找的方法是在子类中实现的，还是仅在父类中实现的

有人能帮我吗？我需要另一种自省的方式吗？
希望这有帮助。我仍然觉得有一种更棒的方式。尝试使用
collectInheritedMethods（）
查看您是否得到了想要的。我特意想返回一个匹配方法的列表，而不仅仅是一个标志，因为您还可以看到从超类实现的方法，列表上的Groovy truth（
if（collectInheritedMethods（..）
）足以进行标志

abstract class Parent {
    void method1() { println "No Param" }
    void method1( def a ) { println "param: $a" }
    void method1( List a, Map b ) { println "param: $a and $b" }
}

class Child extends Parent {
    void method1() { println "A: no param" }
    void method1( def a ) { println "A: param $a" }
    void method1( def a, def b ) { println "A: param $a and $b" }
}

List collectInheritedMethods( Class parent, Class child ) {
    List inheritedMethods = [] 
    def parentMethods = parent.declaredMethods.findAll { !it.synthetic }
    def childMethods = child.declaredMethods.findAll { !it.synthetic }

    for( chMet in childMethods ) {
        for( paMet in parentMethods ) {
            if( chMet.name == paMet.name && 
                  chMet.parameterTypes == paMet.parameterTypes && 
                     chMet.returnType == paMet.returnType ) {

                inheritedMethods << child.getMethod( chMet.name, 
                                                    chMet.parameterTypes )
                                         .toGenericString()

                //if only a flag is required to check if method implemented
                //flag = true
                //break
            }
        }
    }

    //Groovier way
    /*inheritedMethods = childMethods.findAll { chMet -> 
        parentMethods.findAll { paMet -> 
            chMet.name == paMet.name && 
                chMet.parameterTypes == paMet.parameterTypes && 
                    chMet.returnType == paMet.returnType 
        } 
    }*/

    inheritedMethods
}

assert collectInheritedMethods( Parent, Child ) == 
       ["public void Child.method1()", 
        "public void Child.method1(java.lang.Object)"]

抽象类父类{
void method1（）{println“No Param”}
void method1（def a）{println“param:$a”}
void method1（列表a，映射b）{println“param:$a和$b”}
}
类子级扩展父级{
void method1（）{println“A:无参数”}
void method1（def a）{println“a:param$a”}
void method1（def a，def b）{println“a:param$a和$b”}
}
列出collectInheritedMethods（类父类、类子类）{
列出继承的方法=[]
def parentMethods=parent.declaredMethods.findAll{！it.synthetic}
def childMethods=child.declaredMethods.findAll{！it.synthetic}
for（childMethods中的chMet）{
for（parentMethods中的paMet）{
如果（chMet.name==paMet.name&&
chMet.parameterTypes==paMet.parameterTypes&&
chMet.returnType==paMet.returnType）{
继承方法
parentMethods.findAll{paMet->
chMet.name==paMet.name&&
chMet.parameterTypes==paMet.parameterTypes&&
chMet.returnType==paMet.returnType
} 
}*/
继承方法
}
断言collectInheritedMethods（父级、子级）=
[“public void Child.method1（）”，
“public void Child.method1（java.lang.Object）”]
所以我最终得到了这个解决方案，它正是我想要的：

def pattern = ~/^public void ... $/
for(method in obj.metaClass.methods.findAll { it ==~ pattern })
{
    /* Do some stuff... */
}