关于java中的虚方法的问题

Question

简而言之：我希望以下代码打印“sub”：

Element e = new SubElement();
print(e);
... 

private static void print(Element e) {
    System.out.println("e");
}

private static void print(SubElement e) {
    System.out.println("sub");
}

并且我不想更改 print(Element e)。所以

private static void print(Element e) {
    if (e instanceof SubElement) {
        print((SubElement) e);
    } else {
        System.out.println("e");
    }
}

我想做的就是

print(e.getClass().cast(e));

自动将其转换为真正的子类并强制系统输入 print(SubElement e)。这有可能吗？

Answer 1

运行的重载方法是在编译时选择的，这就是选择 Element 版本而不是 SubElement 版本的原因。看起来更合乎逻辑的是让 Element 或子类包含应打印的数据。

class Element {

    public String getName() {
        return "e";
    }
}

class SubElement extends Element {
    public String getName() {
        return "sub";
    }
}

然后在 print 方法中：

private static void print(Element e) {
    System.out.println(e.getName());
}

这是否有意义将取决于 Element 类实际上是什么以及打印的数据表示什么。

Answer 2

是的。您可以使用访客模式。然而，它适用于已建立的定义良好的层次结构，因为您必须定义的 Visitor 接口需要每种类型都有一个方法。

interface ElementVisitor {
   visit(Element e);
   visit(SubElement se);
}

class ElementerPrinter implements ElementVisitor {
   visit(Element e) { System.out.println("e"); }
   visit(SubElement e) { System.out.println("sub"); }
}

class Element {
  // here's the trick, Element knows that this is Element
  // and childs have to implement it!
  // if the parent-most class is an interface it force you to implement!
  accept(ElementVisitor visitor) { visitor.visit(this); } 
}

class SubElement {
  // here's the trick, Element knows that this is SubElement
  accept(ElementVisitor visitor) { visitor.visit(this); }
}

Answer 3

print() 确实需要成为 Element 的实例方法。否则，您将尝试以困难的方式模仿多态性。如果您希望这样做，您实际上无法避免一系列从 Class 到函数对象的映射的 if 语句。何苦呢？

Answer 4

您能够将行为差异推入元素类中吗？

Element e = new SubElement();
print(e);
... 

private static void print(Element e) {
    System.out.println(e.getMessageToPrint());
}

// no longer needed
//
//private static void print(SubElement e) {
//    System.out.println("sub");
//}

这样，SubElement 就可以重写 getMessageToPrint() 方法。

或者更好的是：

Element e = new SubElement();
e.print();

Answer 5

我会选择不同的方法。要么

1. 按照其他人的建议使用多态性，扩展 Element 以添加 print() 方法（可以被子类覆盖），要么
2. 定义一个辅助接口并使用策略和工厂模式的组合：

基类

 public class Element{}

派生类

 public class SubElement extends Element{}

打印元素的帮助器接口

public interface PrintHelper{
    void print(Element element);
}

为给定元素获取最佳 PrintHelper 的工厂

public class PrintHelperFactory{

    private final Map<Class<? extends Element>, PrintHelper> registeredHelpers =
        new HashMap<Class<? extends Element>, PrintHelper>();

    // Register a PrintHelper for a given Element class.
    public void registerHelper(final Class<? extends Element> clazz,
      final PrintHelper helper){
        this.registeredHelpers.put(clazz, helper);
    }

    // Get the most specific PrintHelper for a given Element.
    public PrintHelper getHelperForElement(final Element element){
        Class<? extends Element> clazz = element.getClass();
        while(!Object.class.equals(clazz)){
            if(this.registeredHelpers.containsKey(clazz)){
                return this.registeredHelpers.get(clazz);
            }
            clazz = (Class<? extends Element>) clazz.getSuperclass();
        }
        return null;
    }

}

客户端测试类，作为 Java 应用程序运行< /strong>

public class Main{

    public static void main(final String[] args){

        final PrintHelperFactory factory = new PrintHelperFactory();
        factory.registerHelper(Element.class, new PrintHelper(){
            @Override
            public void print(final Element element){
                System.out.println("Element");
            }
        });
        factory.registerHelper(SubElement.class, new PrintHelper(){
            @Override
            public void print(final Element element){
                System.out.println("Sub Element");
            }
        });

        // test it with an Element  
        final Element elem = new Element();
        factory.getHelperForElement(elem).print(elem);

        // test it with a sub class
        final Element sub = new SubElement();
        factory.getHelperForElement(sub).print(sub);

    }

}

输出

Element
Sub Element