java - 如何在接受 `Derived` 的重写方法中使用类型 `Base` 的参数？

Question

我有以下情况:

abstract class Base {
    int data = 0;
    void baseMethod() {
        System.out.println("baseMethod:" + data);
    }
}

class DerivedA extends Base {
    void DerivedBMethodA() {

    }

    void usefulMethod(Something something) {
        something.doSomething(this);
    }

    interface Something {
        void doSomething(DerivedA deriv);
    }
}

class DerivedB extends Base {
    void DerivedMethodB() {

    }
}

public class Temp {

    public static void main() {
        DerivedA a = new DerivedA();
        a.usefulMethod(new DerivedA.Something() {
            @Override
            public void doSomething(DerivedA deriv) {
                deriv.DerivedBMethodA();
            }
        });
    }

}

我想将 usefulMethod 和 Something 推送到 Base 类，以便 DerivedB 可以利用它。我希望 Something.doSomething 的实现能够使用派生类型，以便它可以访问派生功能。

我该怎么做？

尝试

我尝试过以下方法:

abstract class Base {
    int data = 0;
    void baseMethod() {
        System.out.println("baseMethod:" + data);
    }


    void usefulMethod(Something something) {
        something.doSomething(this);
    }

    interface Something {
        void doSomething(Base deriv);
    }
}

class DerivedA extends Base {
    void DerivedBMethodA() {

    }
}

class DerivedB extends Base {
    void DerivedMethodB() {

    }
}

public class Temp {

    public static void main() {
        DerivedA a = new DerivedA();
        a.usefulMethod(new Base.Something() {
            @Override
            public void doSomething(DerivedA deriv) {
                deriv.DerivedBMethodA();
            }
        });
    }
}

但是失败了，因为我的匿名 Something 没有实现 doSomething(Base)。因此尝试使用泛型:

我尝试过:

    interface Something {
        void doSomething(<? extends Base> deriv);
    }

但由于以下原因无法编译:“通配符只能用作引用参数”

我尝试过:

    interface Something {
        <T extends Base> void doSomething(T deriv);
    }

但这需要我这样实现接口(interface):

        a.usefulMethod(new Base.Something() {
            @Override
            public <T extends Base> void doSomething(T deriv) {

            }
        });

这显然不允许我访问派生类型？

有一些方法可以让它“工作”，但它们是不可取的:

1. 这个:

   interface Something {
       void doSomething(Base deriv);
   }
   
       a.usefulMethod(new Base.Something() {
           @Override
           public void doSomething(Base deriv) {
               DerivedA a1 = (DerivedA) deriv;
               a1.DerivedBMethodA();
           }
       });
   

   但这需要我在每个实现中进行强制转换，这似乎很浪费。

2. 还有这个:

   package com.miurasample.ui.info;
   
   
   abstract class Base {
       int data = 0;
       void baseMethod() {
           System.out.println("baseMethod:" + data);
       }
   
   
       void usefulMethod(Something something) {
           something.doSomething(this);
       }
   
       interface Something<T extends Base> {
           void doSomething(T deriv);
       }
   }
   
   public class Temp {
   
       public static void main() {
           DerivedA a = new DerivedA();
           a.usefulMethod(new Base.Something<DerivedA>() {
               @Override
               public void doSomething(DerivedA deriv) {
   
               }
           });
       }
   }
   

但这会导致在 usefulMethod 中出现警告/IDE 突出显示:

“未经检查地调用 doSomething(T) 作为原始类型 Base.Something 的成员”

最简洁和“最干净”的方法是什么？我这样做还算理智吗？

Answer 1

很难说你的设计是否错误。我们没有您的要求的全部范围来断言，但这里是您想要做的事情的干净的非 Actor 方法。它确实需要派生类中的额外方法:

public static void main(String... args) {
        DerivedA a = new DerivedA();

        a.usefulMethod( new Base.Something<DerivedA>() {
            @Override
            public void doSomething(DerivedA deriv) {
                deriv.DerivedBMethodA();
            }
        } );
    }

    public abstract static class Base< T extends Base<T> > {
        int data = 0;

        protected abstract T getThis();

        void baseMethod() {
            System.out.println("baseMethod:" + data);
        }

        void usefulMethod(Something<T> something) {
            something.doSomething( getThis() );
        }

        interface Something< T extends Base<T> > {
            void doSomething(T deriv);
        }
    }

    public static class DerivedA extends Base<DerivedA> {

        protected DerivedA getThis(){
            return this;
        }

        void DerivedBMethodA() {}
    }

    public static class DerivedB extends Base<DerivedB> {

        protected DerivedB getThis(){
            return this;
        }

        void DerivedMethodB() {}
    }