相关疑难解决方法(0)

如果我用Java写这行:

JOptionPane.showInputDialog(null, "Write something");

将调用哪种方法？

• showInputDialog(Component parent, Object message)
• showInputDialog(Object message, Object initialSelectionValue)

我可以测试一下.但在其他类似的情况下,我想知道会发生什么.

根据这个问题,当尝试在不明确的重载构造函数之间进行选择时,Java将选择"最具体"的选项.在这个例子中:

public class Test{
    private Test(Map map){
        System.out.println("Map");
    }
    private Test(Object o){
        System.out.println("Object");
    }
    public static void main(String[] args){
        new Test(null);
    }
}

它会打印出来

"地图"

但是,我试图找出"最具体"的含义.我认为这意味着"最不模糊",如"可能指的是最不可能的类型".在这种情况下,Object可能是任何不是原始的东西,而Map可能只是Map或? extends Map.基本上,我假设选择了接近继承树的叶子的类.当一个类是另一个类的子类时,这是有效的:

public class Test{
    private Test(A a){
        System.out.println("A");
    }
    private Test(B b){
        System.out.println("B");
    }
    public static void main(String[] args){
        new Test(null);
    }
}

class A{}

class B extends A{}

"B"

然后我想出了这个:

public class Test{
    private Test(A a){
        System.out.println("A");
    }
    private Test(E e){
        System.out.println("E"); …

在讨论FileInputStream之前,我首先介绍了一个场景,其中有两个完全有效的重载方法,但编译器会感到困惑,然后报告编译时错误以响应某些输入.

这是方法.

double calcAverage(double marks1, int marks2) {  
   return (marks1 + marks2)/2.0;  
}  

double calcAverage(int marks1, double marks2) {  
   return (marks1 + marks2)/2.0;  
} 

以下是显示方法用法的完整代码:

class MyClass {  
  double calcAverage(double marks1, int marks2) {  
            return (marks1 + marks2)/2.0;  
  }  
  double calcAverage(int marks1, double marks2) {  
           return (marks1 + marks2)/2.0;  
  }  
  public static void main(String args[]) {  
          MyClass myClass = new MyClass();  
          myClass.calcAverage(2, 3);  
  }  
}  

因为int文字值可以传递给double类型的变量,所以这两个方法都是文字值2和3的可接受候选者,因此编译器无法决定选择哪个方法.

当我对我采用上述概念,进一步深入Java 7 API到FileInputStream类,并研究该类的两个重载构造函数时,我就会感到困惑.

1. public FileInputStream(String name)抛出FileNotFoundException {.....}
2. public FileInputStream(File file)抛出FileNotFoundException …

以下代码打印"String"

public class Riddle {

    public static void main(String[] args) {
        hello(null);
    }

    public static void hello(Object o) {
        System.out.println("Object");
    }


    public static void hello(String s) {
        System.out.println("String");
    }

}

为什么代码编译？是不是空暧昧？

例如,由于签名模糊,以下代码将无法编译.

public class Riddle {

    public static void main(String[] args) {
        hello(null);
    }

    public static void hello(Object o) {
        System.out.println("Object");
    }

    public static void hello(Integer o) {
        System.out.println("Integer");
    }

    public static void hello(String s) {
        System.out.println("String");
    }

}

有人可以解释为什么第一个例子可以编译而没有模棱两可的错误？

public class A{
    public static int x = 1;
    public int m(A a, B b){
        return a.m(b, b) + x;
    }
}

public class B extends A {
    public int m(A a1, B a2){
        if(a1 == a2)
            return x;
        return super.m(a1,a2);
    }
}

这是我过去考试的一个问题.

public class Main{
    public static void main(String[] args){
        B b1 = new B(){int m(A a, A b){ return 10; }};
        System.out.println(b1.m(b1, b1));
    }
}

问题是,以下输出是什么.我在答案1中是对的.但我没有完全理解为什么.

由于B对象的内部类是(A,A).我是否正确认为它不能覆盖超级方法m,因为它是(A,B)？如果交换了两个方法的参数,它是否能够覆盖？

既然它既不能覆盖也不能超载,它什么也不做,只是在B类中使用方法m？

对象的内部类是否仅适用于自身？它就像一个异类吗？

为所有问题道歉.

提前致谢.

编辑:

从我到目前为止的理解,因为静态类型设置为B,所以类型B无法看到anon类.如果将其设置为公开,则可以看到它,但仍然不会使用它.

这使我对另一个问题感到困惑.

public class A{ …