Question

见以下例子:

interface I {}

class A implements I {}

class B implements I {}

class Foo{
    void f(A a) {}
    void f(B b) {}
    static public void main(String[]args ) {
        I[] elements = new I[] {new A(), new B(), new B(), new A()};
        Foo o = new Foo();
        for (I element:elements)
            o.f(element);//won t compile
    }
}

为什么超载方法不支持上传?

如果在运行时执行超载,它会提供更大的灵活性。例如,访问者模式会更简单。是否有任何技术原因阻止爪哇这样做?

Answer 1

超载分辨率涉及一些非三重规则, 以确定哪个超载最合适, 并且很难在运行时有效完成这些操作。相反, 超载分辨率比较容易。相比之下, 超载分辨率比较容易 -- -- 在硬的案例中, 您只需查看对象类的 < code> foo 函数, 在简单的情况下( 例如, 当此代码路径中只有一次执行, 或者只有一个执行时), 您可以将虚拟方法转换成静态的、非虚拟的、非虚拟的、非动态的调用( 如果您根据代码路径重新操作, 您必须快速检查, 以验证该对象是否实际是您所期望的 ) 。

事实证明,这是一件好事,Java 1.4和较低水平的Java 1.4没有运行时间超时分辨率,因为这将使通用软件更难改装。通用软件在取代分辨率方面起着作用,但这一信息在运行时由于消亡而无法提供。

Answer 2

没有theoretical 的理由不能这样做。普通 Lisp 对象系统支持这种类型的构造 — — 称为 倍数发送 generics

但是,除了语言设计师认为不应该这样做之外, Java 语言可能也有一些原因,因为除了语言设计师认为我不应该这样做之外,我让其他人去解释。虽然它确实给继承带来复杂问题。考虑:

interface A {}
interface B {}
class C implements A {}

class Foo {
    public void invoke(A a) {}
    public void invoke(B b) {}
}

class Bar extends Foo {
    public void invoke(C c) {}
}

class Baz extends Bar {
    public void invoke(A a) {}
}

Baz obj = new Baz();
obj.invoke(new C);

引用哪个 invoke ? Baz ? Bar ? Bar ? 是什么? super.invoke ?可以找到决定性的语义学,但至少在某些情况下,它们可能涉及混乱和意外。鉴于爪哇的用意是简单语言,我不认为引入这种混淆的特征可能被视为符合其目标。

Answer 3

是否有任何技术原因阻止爪哇这样做?

Code 更正 :您目前的例子提供了两种I和两种对应方法的两种执行方法f。然而,没有任何东西可以阻止存在其他执行I的类别-将分辨率移动到运行时也会将编译错误替换为可能隐藏的运行时错误。

<强度 > 性能 :正如其他人提到过的方法超载涉及相当复杂的规则,在编译时一次这样做肯定比在运行时对每种方法的调用都快。

<强度 > 反向兼容 :目前超载的方法是使用已通过参数的编译时间类型而不是运行时间类型来解决的,改变使用运行时间信息的行为会打破许多现有的应用程序。

如何绕着它工作 < 坚固>

使用访客模式,我不明白怎么会有人觉得这很难。

interface I{
      void accept(IVisitor v);
}
interface IVisitor{
      void f(A a);
      void f(B b);
}

class A implements I{
    void accept(IVisitor v){v.f(this);}
}
class B implements I{
    void accept(IVisitor v){v.f(this);}
}
class Foo implements IVisitor{
 void f(A a) {}
 void f(B b) {}
 static public void main(String[]args ) {
    I[] elements = new I[] {new A(), new B(), new B(), new A()};
    Foo o = new Foo();
    for (I element:elements)
        element.accept(o);
 }


}

Answer 4

除了语言设计师之外,我不认为任何人都可以回答这个问题。我几乎不是这个问题的专家,但我只提供我的意见。

通过阅读JLS 15.12 有关方法援引表达式的,非常明显的是,选择正确的执行方法已经是一个复杂的编译时间过程;最重要的是,在采用通用术语之后。

现在想象一下,将所有这一切都移到运行时间,只是为了支持 mutimethods 。对我来说,这听起来像一个小特性,给语言增加了太多的复杂性,而且可能是一个具有一定程度的绩效影响的特点,因为所有这些决定都需要在运行时一次又一次地作出,而不是像今天这样一次,在汇编时作出。

除了所有这些之外,我们可以补充一个事实,即由于type securess ,不可能确定某些通用类型的实际类型。在我看来,放弃静态类型检查的安全性不符合爪哇的最佳利益。

无论如何,处理多发问题都有有效的替代方法,也许这些替代方法在很大程度上可以说明为何没有在语言中实施。所以,你可以使用古典的visitor 模式 ,也可以使用一定的反省。

http://multijava.sourceforge.net/"rel="nofollow" >MultiJava项目在爪哇实施混合发送支持,还有其他一些项目,利用反射支持爪哇的多种方法:Java Moltemethods ,Java 多重方法框架。也许还有更多。

您也可以考虑一种支持多种方法的替代爪哇语言,例如Clojure 或Groovy 。

此外,由于C#是一个与爪哇在一般的冰山中非常相似的语言,也许应该更深入地调查一下它如何,并思考在爪哇提供类似特征的影响。如果你认为它是一个值得在爪哇提供的特点,你甚至可以提交一个 rel=“nofolved>JEP ,并且可以在未来释放爪哇语时加以考虑。

Answer 5

不是 Java 的答案。这个功能存在于 C# 4 中 :

using System;

public class MainClass {     
    public static void Main() {
        IAsset[] xx = { 
             new Asset(), new House(), new Asset(), new House(), new Car() 
        };     
        foreach(IAsset x in xx) {
            Foo((dynamic)x);
        }
    }


    public static void Foo(Asset a) {
        Console.WriteLine("Asset");
    }

    public static void Foo(House h) {
        Console.WriteLine("House");
    }

    public static void Foo(Car c) {
        Console.WriteLine("Car");
    }     
}

public interface IAsset { }      

public class Asset : IAsset { }

public class House : Asset { }

public class Car : Asset { }

产出:

Asset
House
Asset
House
Car

如果您使用C# 3及以下的C# 3, 您必须使用反省, 我在我的博客 Multiple Express in C/em> 上发表了一篇文章: < a href="http://www.ienablebus.com/2012/04/ multiple-dispatch- in- c.html" rel=“nofollow” > http://www.ienablebus.com/2012/04/ multiple-dispatch-in- c.html

如果你想在爪哇做多次调度,你可能会走反射路线。

这是爪哇的另一个解决方案:http://blog.efftinge.de/2010/03/multiple-dispatch-and-poor-mens-patter.html

Answer 6

我猜你只要沉思一下就可以了结了

import java.lang.reflect.*;

interface I {}    
class A implements I {}    
class B implements I {}

public class Foo {

    public void f(A a) { System.out.println("from A"); }
    public void f(B b) { System.out.println("from B"); }

    static public void main(String[]args ) throws InvocationTargetException
        , NoSuchMethodException, IllegalAccessException 
    {
        I[] elements = new I[] {new A(), new B(), new B(), new A()};
        Foo o = new Foo();
        for (I element : elements) {
            o.multiDispatch(element);    
        }
    }

    void multiDispatch(I x) throws NoSuchMethodException
        , InvocationTargetException, IllegalAccessException 
    {    
        Class cls = this.getClass();

        Class[] parameterTypes = { x.getClass() };
        Object[] arguments = { x };

        Method fMethod = cls.getMethod("f", parameterTypes);
        fMethod.invoke(this,arguments);
    }       
}

产出:

from A
from B
from B
from A

Answer 7

您的方法表示它会接受 A 或 B , 它们是 I 的衍生类别, 它们可以包含更多细节, 然后 I

void f(A a) {}

当您试图发送您案件界面 A 超级类 A 时, 编译者希望确认您实际发送 A 中的细节 A , 可能无法在 A 中找到, 仅在运行时 I 才会实际提及 A 实例, 汇编时没有这种信息, 因此您必须明确告知编译者, I 实际上是 A/code > 或 B 中提供的细节, 您要这样做。

友情链接